1 /* 2 * encoding.c : implements the encoding conversion functions needed for XML 3 * 4 * Related specs: 5 * rfc2044 (UTF-8 and UTF-16) F. Yergeau Alis Technologies 6 * rfc2781 UTF-16, an encoding of ISO 10646, P. Hoffman, F. Yergeau 7 * [ISO-10646] UTF-8 and UTF-16 in Annexes 8 * [ISO-8859-1] ISO Latin-1 characters codes. 9 * [UNICODE] The Unicode Consortium, "The Unicode Standard -- 10 * Worldwide Character Encoding -- Version 1.0", Addison- 11 * Wesley, Volume 1, 1991, Volume 2, 1992. UTF-8 is 12 * described in Unicode Technical Report #4. 13 * [US-ASCII] Coded Character Set--7-bit American Standard Code for 14 * Information Interchange, ANSI X3.4-1986. 15 * 16 * See Copyright for the status of this software. 17 * 18 * daniel (at) veillard.com 19 * 20 * Original code for IsoLatin1 and UTF-16 by "Martin J. Duerst" <duerst (at) w3.org> 21 */ 22 23 #define IN_LIBXML 24 #include "libxml.h" 25 26 #include <string.h> 27 28 #ifdef HAVE_CTYPE_H 29 #include <ctype.h> 30 #endif 31 #ifdef HAVE_STDLIB_H 32 #include <stdlib.h> 33 #endif 34 #ifdef LIBXML_ICONV_ENABLED 35 #ifdef HAVE_ERRNO_H 36 #include <errno.h> 37 #endif 38 #endif 39 #include <libxml/encoding.h> 40 #include <libxml/xmlmemory.h> 41 #ifdef LIBXML_HTML_ENABLED 42 #include <libxml/HTMLparser.h> 43 #endif 44 #include <libxml/globals.h> 45 #include <libxml/xmlerror.h> 46 47 static xmlCharEncodingHandlerPtr xmlUTF16LEHandler = NULL; 48 static xmlCharEncodingHandlerPtr xmlUTF16BEHandler = NULL; 49 50 typedef struct _xmlCharEncodingAlias xmlCharEncodingAlias; 51 typedef xmlCharEncodingAlias *xmlCharEncodingAliasPtr; 52 struct _xmlCharEncodingAlias { 53 const char *name; 54 const char *alias; 55 }; 56 57 static xmlCharEncodingAliasPtr xmlCharEncodingAliases = NULL; 58 static int xmlCharEncodingAliasesNb = 0; 59 static int xmlCharEncodingAliasesMax = 0; 60 61 #if defined(LIBXML_ICONV_ENABLED) || defined(LIBXML_ICU_ENABLED) 62 #if 0 63 #define DEBUG_ENCODING /* Define this to get encoding traces */ 64 #endif 65 #else 66 #ifdef LIBXML_ISO8859X_ENABLED 67 static void xmlRegisterCharEncodingHandlersISO8859x (void); 68 #endif 69 #endif 70 71 static int xmlLittleEndian = 1; 72 73 /** 74 * xmlEncodingErrMemory: 75 * @extra: extra informations 76 * 77 * Handle an out of memory condition 78 */ 79 static void 80 xmlEncodingErrMemory(const char *extra) 81 { 82 __xmlSimpleError(XML_FROM_I18N, XML_ERR_NO_MEMORY, NULL, NULL, extra); 83 } 84 85 /** 86 * xmlErrEncoding: 87 * @error: the error number 88 * @msg: the error message 89 * 90 * n encoding error 91 */ 92 static void 93 xmlEncodingErr(xmlParserErrors error, const char *msg, const char *val) 94 { 95 __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, 96 XML_FROM_I18N, error, XML_ERR_FATAL, 97 NULL, 0, val, NULL, NULL, 0, 0, msg, val); 98 } 99 100 #ifdef LIBXML_ICU_ENABLED 101 static uconv_t* 102 openIcuConverter(const char* name, int toUnicode) 103 { 104 UErrorCode status = U_ZERO_ERROR; 105 uconv_t *conv = (uconv_t *) xmlMalloc(sizeof(uconv_t)); 106 if (conv == NULL) 107 return NULL; 108 109 conv->uconv = ucnv_open(name, &status); 110 if (U_FAILURE(status)) 111 goto error; 112 113 status = U_ZERO_ERROR; 114 if (toUnicode) { 115 ucnv_setToUCallBack(conv->uconv, UCNV_TO_U_CALLBACK_STOP, 116 NULL, NULL, NULL, &status); 117 } 118 else { 119 ucnv_setFromUCallBack(conv->uconv, UCNV_FROM_U_CALLBACK_STOP, 120 NULL, NULL, NULL, &status); 121 } 122 if (U_FAILURE(status)) 123 goto error; 124 125 status = U_ZERO_ERROR; 126 conv->utf8 = ucnv_open("UTF-8", &status); 127 if (U_SUCCESS(status)) 128 return conv; 129 130 error: 131 if (conv->uconv) 132 ucnv_close(conv->uconv); 133 xmlFree(conv); 134 return NULL; 135 } 136 137 static void 138 closeIcuConverter(uconv_t *conv) 139 { 140 if (conv != NULL) { 141 ucnv_close(conv->uconv); 142 ucnv_close(conv->utf8); 143 xmlFree(conv); 144 } 145 } 146 #endif /* LIBXML_ICU_ENABLED */ 147 148 /************************************************************************ 149 * * 150 * Conversions To/From UTF8 encoding * 151 * * 152 ************************************************************************/ 153 154 /** 155 * asciiToUTF8: 156 * @out: a pointer to an array of bytes to store the result 157 * @outlen: the length of @out 158 * @in: a pointer to an array of ASCII chars 159 * @inlen: the length of @in 160 * 161 * Take a block of ASCII chars in and try to convert it to an UTF-8 162 * block of chars out. 163 * Returns 0 if success, or -1 otherwise 164 * The value of @inlen after return is the number of octets consumed 165 * if the return value is positive, else unpredictable. 166 * The value of @outlen after return is the number of octets consumed. 167 */ 168 static int 169 asciiToUTF8(unsigned char* out, int *outlen, 170 const unsigned char* in, int *inlen) { 171 unsigned char* outstart = out; 172 const unsigned char* base = in; 173 const unsigned char* processed = in; 174 unsigned char* outend = out + *outlen; 175 const unsigned char* inend; 176 unsigned int c; 177 178 inend = in + (*inlen); 179 while ((in < inend) && (out - outstart + 5 < *outlen)) { 180 c= *in++; 181 182 if (out >= outend) 183 break; 184 if (c < 0x80) { 185 *out++ = c; 186 } else { 187 *outlen = out - outstart; 188 *inlen = processed - base; 189 return(-1); 190 } 191 192 processed = (const unsigned char*) in; 193 } 194 *outlen = out - outstart; 195 *inlen = processed - base; 196 return(*outlen); 197 } 198 199 #ifdef LIBXML_OUTPUT_ENABLED 200 /** 201 * UTF8Toascii: 202 * @out: a pointer to an array of bytes to store the result 203 * @outlen: the length of @out 204 * @in: a pointer to an array of UTF-8 chars 205 * @inlen: the length of @in 206 * 207 * Take a block of UTF-8 chars in and try to convert it to an ASCII 208 * block of chars out. 209 * 210 * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise 211 * The value of @inlen after return is the number of octets consumed 212 * if the return value is positive, else unpredictable. 213 * The value of @outlen after return is the number of octets consumed. 214 */ 215 static int 216 UTF8Toascii(unsigned char* out, int *outlen, 217 const unsigned char* in, int *inlen) { 218 const unsigned char* processed = in; 219 const unsigned char* outend; 220 const unsigned char* outstart = out; 221 const unsigned char* instart = in; 222 const unsigned char* inend; 223 unsigned int c, d; 224 int trailing; 225 226 if ((out == NULL) || (outlen == NULL) || (inlen == NULL)) return(-1); 227 if (in == NULL) { 228 /* 229 * initialization nothing to do 230 */ 231 *outlen = 0; 232 *inlen = 0; 233 return(0); 234 } 235 inend = in + (*inlen); 236 outend = out + (*outlen); 237 while (in < inend) { 238 d = *in++; 239 if (d < 0x80) { c= d; trailing= 0; } 240 else if (d < 0xC0) { 241 /* trailing byte in leading position */ 242 *outlen = out - outstart; 243 *inlen = processed - instart; 244 return(-2); 245 } else if (d < 0xE0) { c= d & 0x1F; trailing= 1; } 246 else if (d < 0xF0) { c= d & 0x0F; trailing= 2; } 247 else if (d < 0xF8) { c= d & 0x07; trailing= 3; } 248 else { 249 /* no chance for this in Ascii */ 250 *outlen = out - outstart; 251 *inlen = processed - instart; 252 return(-2); 253 } 254 255 if (inend - in < trailing) { 256 break; 257 } 258 259 for ( ; trailing; trailing--) { 260 if ((in >= inend) || (((d= *in++) & 0xC0) != 0x80)) 261 break; 262 c <<= 6; 263 c |= d & 0x3F; 264 } 265 266 /* assertion: c is a single UTF-4 value */ 267 if (c < 0x80) { 268 if (out >= outend) 269 break; 270 *out++ = c; 271 } else { 272 /* no chance for this in Ascii */ 273 *outlen = out - outstart; 274 *inlen = processed - instart; 275 return(-2); 276 } 277 processed = in; 278 } 279 *outlen = out - outstart; 280 *inlen = processed - instart; 281 return(*outlen); 282 } 283 #endif /* LIBXML_OUTPUT_ENABLED */ 284 285 /** 286 * isolat1ToUTF8: 287 * @out: a pointer to an array of bytes to store the result 288 * @outlen: the length of @out 289 * @in: a pointer to an array of ISO Latin 1 chars 290 * @inlen: the length of @in 291 * 292 * Take a block of ISO Latin 1 chars in and try to convert it to an UTF-8 293 * block of chars out. 294 * Returns the number of bytes written if success, or -1 otherwise 295 * The value of @inlen after return is the number of octets consumed 296 * if the return value is positive, else unpredictable. 297 * The value of @outlen after return is the number of octets consumed. 298 */ 299 int 300 isolat1ToUTF8(unsigned char* out, int *outlen, 301 const unsigned char* in, int *inlen) { 302 unsigned char* outstart = out; 303 const unsigned char* base = in; 304 unsigned char* outend; 305 const unsigned char* inend; 306 const unsigned char* instop; 307 308 if ((out == NULL) || (in == NULL) || (outlen == NULL) || (inlen == NULL)) 309 return(-1); 310 311 outend = out + *outlen; 312 inend = in + (*inlen); 313 instop = inend; 314 315 while ((in < inend) && (out < outend - 1)) { 316 if (*in >= 0x80) { 317 *out++ = (((*in) >> 6) & 0x1F) | 0xC0; 318 *out++ = ((*in) & 0x3F) | 0x80; 319 ++in; 320 } 321 if ((instop - in) > (outend - out)) instop = in + (outend - out); 322 while ((in < instop) && (*in < 0x80)) { 323 *out++ = *in++; 324 } 325 } 326 if ((in < inend) && (out < outend) && (*in < 0x80)) { 327 *out++ = *in++; 328 } 329 *outlen = out - outstart; 330 *inlen = in - base; 331 return(*outlen); 332 } 333 334 /** 335 * UTF8ToUTF8: 336 * @out: a pointer to an array of bytes to store the result 337 * @outlen: the length of @out 338 * @inb: a pointer to an array of UTF-8 chars 339 * @inlenb: the length of @in in UTF-8 chars 340 * 341 * No op copy operation for UTF8 handling. 342 * 343 * Returns the number of bytes written, or -1 if lack of space. 344 * The value of *inlen after return is the number of octets consumed 345 * if the return value is positive, else unpredictable. 346 */ 347 static int 348 UTF8ToUTF8(unsigned char* out, int *outlen, 349 const unsigned char* inb, int *inlenb) 350 { 351 int len; 352 353 if ((out == NULL) || (inb == NULL) || (outlen == NULL) || (inlenb == NULL)) 354 return(-1); 355 if (*outlen > *inlenb) { 356 len = *inlenb; 357 } else { 358 len = *outlen; 359 } 360 if (len < 0) 361 return(-1); 362 363 memcpy(out, inb, len); 364 365 *outlen = len; 366 *inlenb = len; 367 return(*outlen); 368 } 369 370 371 #ifdef LIBXML_OUTPUT_ENABLED 372 /** 373 * UTF8Toisolat1: 374 * @out: a pointer to an array of bytes to store the result 375 * @outlen: the length of @out 376 * @in: a pointer to an array of UTF-8 chars 377 * @inlen: the length of @in 378 * 379 * Take a block of UTF-8 chars in and try to convert it to an ISO Latin 1 380 * block of chars out. 381 * 382 * Returns the number of bytes written if success, -2 if the transcoding fails, 383 or -1 otherwise 384 * The value of @inlen after return is the number of octets consumed 385 * if the return value is positive, else unpredictable. 386 * The value of @outlen after return is the number of octets consumed. 387 */ 388 int 389 UTF8Toisolat1(unsigned char* out, int *outlen, 390 const unsigned char* in, int *inlen) { 391 const unsigned char* processed = in; 392 const unsigned char* outend; 393 const unsigned char* outstart = out; 394 const unsigned char* instart = in; 395 const unsigned char* inend; 396 unsigned int c, d; 397 int trailing; 398 399 if ((out == NULL) || (outlen == NULL) || (inlen == NULL)) return(-1); 400 if (in == NULL) { 401 /* 402 * initialization nothing to do 403 */ 404 *outlen = 0; 405 *inlen = 0; 406 return(0); 407 } 408 inend = in + (*inlen); 409 outend = out + (*outlen); 410 while (in < inend) { 411 d = *in++; 412 if (d < 0x80) { c= d; trailing= 0; } 413 else if (d < 0xC0) { 414 /* trailing byte in leading position */ 415 *outlen = out - outstart; 416 *inlen = processed - instart; 417 return(-2); 418 } else if (d < 0xE0) { c= d & 0x1F; trailing= 1; } 419 else if (d < 0xF0) { c= d & 0x0F; trailing= 2; } 420 else if (d < 0xF8) { c= d & 0x07; trailing= 3; } 421 else { 422 /* no chance for this in IsoLat1 */ 423 *outlen = out - outstart; 424 *inlen = processed - instart; 425 return(-2); 426 } 427 428 if (inend - in < trailing) { 429 break; 430 } 431 432 for ( ; trailing; trailing--) { 433 if (in >= inend) 434 break; 435 if (((d= *in++) & 0xC0) != 0x80) { 436 *outlen = out - outstart; 437 *inlen = processed - instart; 438 return(-2); 439 } 440 c <<= 6; 441 c |= d & 0x3F; 442 } 443 444 /* assertion: c is a single UTF-4 value */ 445 if (c <= 0xFF) { 446 if (out >= outend) 447 break; 448 *out++ = c; 449 } else { 450 /* no chance for this in IsoLat1 */ 451 *outlen = out - outstart; 452 *inlen = processed - instart; 453 return(-2); 454 } 455 processed = in; 456 } 457 *outlen = out - outstart; 458 *inlen = processed - instart; 459 return(*outlen); 460 } 461 #endif /* LIBXML_OUTPUT_ENABLED */ 462 463 /** 464 * UTF16LEToUTF8: 465 * @out: a pointer to an array of bytes to store the result 466 * @outlen: the length of @out 467 * @inb: a pointer to an array of UTF-16LE passwd as a byte array 468 * @inlenb: the length of @in in UTF-16LE chars 469 * 470 * Take a block of UTF-16LE ushorts in and try to convert it to an UTF-8 471 * block of chars out. This function assumes the endian property 472 * is the same between the native type of this machine and the 473 * inputed one. 474 * 475 * Returns the number of bytes written, or -1 if lack of space, or -2 476 * if the transcoding fails (if *in is not a valid utf16 string) 477 * The value of *inlen after return is the number of octets consumed 478 * if the return value is positive, else unpredictable. 479 */ 480 static int 481 UTF16LEToUTF8(unsigned char* out, int *outlen, 482 const unsigned char* inb, int *inlenb) 483 { 484 unsigned char* outstart = out; 485 const unsigned char* processed = inb; 486 unsigned char* outend = out + *outlen; 487 unsigned short* in = (unsigned short*) inb; 488 unsigned short* inend; 489 unsigned int c, d, inlen; 490 unsigned char *tmp; 491 int bits; 492 493 if ((*inlenb % 2) == 1) 494 (*inlenb)--; 495 inlen = *inlenb / 2; 496 inend = in + inlen; 497 while ((in < inend) && (out - outstart + 5 < *outlen)) { 498 if (xmlLittleEndian) { 499 c= *in++; 500 } else { 501 tmp = (unsigned char *) in; 502 c = *tmp++; 503 c = c | (((unsigned int)*tmp) << 8); 504 in++; 505 } 506 if ((c & 0xFC00) == 0xD800) { /* surrogates */ 507 if (in >= inend) { /* (in > inend) shouldn't happens */ 508 break; 509 } 510 if (xmlLittleEndian) { 511 d = *in++; 512 } else { 513 tmp = (unsigned char *) in; 514 d = *tmp++; 515 d = d | (((unsigned int)*tmp) << 8); 516 in++; 517 } 518 if ((d & 0xFC00) == 0xDC00) { 519 c &= 0x03FF; 520 c <<= 10; 521 c |= d & 0x03FF; 522 c += 0x10000; 523 } 524 else { 525 *outlen = out - outstart; 526 *inlenb = processed - inb; 527 return(-2); 528 } 529 } 530 531 /* assertion: c is a single UTF-4 value */ 532 if (out >= outend) 533 break; 534 if (c < 0x80) { *out++= c; bits= -6; } 535 else if (c < 0x800) { *out++= ((c >> 6) & 0x1F) | 0xC0; bits= 0; } 536 else if (c < 0x10000) { *out++= ((c >> 12) & 0x0F) | 0xE0; bits= 6; } 537 else { *out++= ((c >> 18) & 0x07) | 0xF0; bits= 12; } 538 539 for ( ; bits >= 0; bits-= 6) { 540 if (out >= outend) 541 break; 542 *out++= ((c >> bits) & 0x3F) | 0x80; 543 } 544 processed = (const unsigned char*) in; 545 } 546 *outlen = out - outstart; 547 *inlenb = processed - inb; 548 return(*outlen); 549 } 550 551 #ifdef LIBXML_OUTPUT_ENABLED 552 /** 553 * UTF8ToUTF16LE: 554 * @outb: a pointer to an array of bytes to store the result 555 * @outlen: the length of @outb 556 * @in: a pointer to an array of UTF-8 chars 557 * @inlen: the length of @in 558 * 559 * Take a block of UTF-8 chars in and try to convert it to an UTF-16LE 560 * block of chars out. 561 * 562 * Returns the number of bytes written, or -1 if lack of space, or -2 563 * if the transcoding failed. 564 */ 565 static int 566 UTF8ToUTF16LE(unsigned char* outb, int *outlen, 567 const unsigned char* in, int *inlen) 568 { 569 unsigned short* out = (unsigned short*) outb; 570 const unsigned char* processed = in; 571 const unsigned char *const instart = in; 572 unsigned short* outstart= out; 573 unsigned short* outend; 574 const unsigned char* inend; 575 unsigned int c, d; 576 int trailing; 577 unsigned char *tmp; 578 unsigned short tmp1, tmp2; 579 580 /* UTF16LE encoding has no BOM */ 581 if ((out == NULL) || (outlen == NULL) || (inlen == NULL)) return(-1); 582 if (in == NULL) { 583 *outlen = 0; 584 *inlen = 0; 585 return(0); 586 } 587 inend= in + *inlen; 588 outend = out + (*outlen / 2); 589 while (in < inend) { 590 d= *in++; 591 if (d < 0x80) { c= d; trailing= 0; } 592 else if (d < 0xC0) { 593 /* trailing byte in leading position */ 594 *outlen = (out - outstart) * 2; 595 *inlen = processed - instart; 596 return(-2); 597 } else if (d < 0xE0) { c= d & 0x1F; trailing= 1; } 598 else if (d < 0xF0) { c= d & 0x0F; trailing= 2; } 599 else if (d < 0xF8) { c= d & 0x07; trailing= 3; } 600 else { 601 /* no chance for this in UTF-16 */ 602 *outlen = (out - outstart) * 2; 603 *inlen = processed - instart; 604 return(-2); 605 } 606 607 if (inend - in < trailing) { 608 break; 609 } 610 611 for ( ; trailing; trailing--) { 612 if ((in >= inend) || (((d= *in++) & 0xC0) != 0x80)) 613 break; 614 c <<= 6; 615 c |= d & 0x3F; 616 } 617 618 /* assertion: c is a single UTF-4 value */ 619 if (c < 0x10000) { 620 if (out >= outend) 621 break; 622 if (xmlLittleEndian) { 623 *out++ = c; 624 } else { 625 tmp = (unsigned char *) out; 626 *tmp = c ; 627 *(tmp + 1) = c >> 8 ; 628 out++; 629 } 630 } 631 else if (c < 0x110000) { 632 if (out+1 >= outend) 633 break; 634 c -= 0x10000; 635 if (xmlLittleEndian) { 636 *out++ = 0xD800 | (c >> 10); 637 *out++ = 0xDC00 | (c & 0x03FF); 638 } else { 639 tmp1 = 0xD800 | (c >> 10); 640 tmp = (unsigned char *) out; 641 *tmp = (unsigned char) tmp1; 642 *(tmp + 1) = tmp1 >> 8; 643 out++; 644 645 tmp2 = 0xDC00 | (c & 0x03FF); 646 tmp = (unsigned char *) out; 647 *tmp = (unsigned char) tmp2; 648 *(tmp + 1) = tmp2 >> 8; 649 out++; 650 } 651 } 652 else 653 break; 654 processed = in; 655 } 656 *outlen = (out - outstart) * 2; 657 *inlen = processed - instart; 658 return(*outlen); 659 } 660 661 /** 662 * UTF8ToUTF16: 663 * @outb: a pointer to an array of bytes to store the result 664 * @outlen: the length of @outb 665 * @in: a pointer to an array of UTF-8 chars 666 * @inlen: the length of @in 667 * 668 * Take a block of UTF-8 chars in and try to convert it to an UTF-16 669 * block of chars out. 670 * 671 * Returns the number of bytes written, or -1 if lack of space, or -2 672 * if the transcoding failed. 673 */ 674 static int 675 UTF8ToUTF16(unsigned char* outb, int *outlen, 676 const unsigned char* in, int *inlen) 677 { 678 if (in == NULL) { 679 /* 680 * initialization, add the Byte Order Mark for UTF-16LE 681 */ 682 if (*outlen >= 2) { 683 outb[0] = 0xFF; 684 outb[1] = 0xFE; 685 *outlen = 2; 686 *inlen = 0; 687 #ifdef DEBUG_ENCODING 688 xmlGenericError(xmlGenericErrorContext, 689 "Added FFFE Byte Order Mark\n"); 690 #endif 691 return(2); 692 } 693 *outlen = 0; 694 *inlen = 0; 695 return(0); 696 } 697 return (UTF8ToUTF16LE(outb, outlen, in, inlen)); 698 } 699 #endif /* LIBXML_OUTPUT_ENABLED */ 700 701 /** 702 * UTF16BEToUTF8: 703 * @out: a pointer to an array of bytes to store the result 704 * @outlen: the length of @out 705 * @inb: a pointer to an array of UTF-16 passed as a byte array 706 * @inlenb: the length of @in in UTF-16 chars 707 * 708 * Take a block of UTF-16 ushorts in and try to convert it to an UTF-8 709 * block of chars out. This function assumes the endian property 710 * is the same between the native type of this machine and the 711 * inputed one. 712 * 713 * Returns the number of bytes written, or -1 if lack of space, or -2 714 * if the transcoding fails (if *in is not a valid utf16 string) 715 * The value of *inlen after return is the number of octets consumed 716 * if the return value is positive, else unpredictable. 717 */ 718 static int 719 UTF16BEToUTF8(unsigned char* out, int *outlen, 720 const unsigned char* inb, int *inlenb) 721 { 722 unsigned char* outstart = out; 723 const unsigned char* processed = inb; 724 unsigned char* outend = out + *outlen; 725 unsigned short* in = (unsigned short*) inb; 726 unsigned short* inend; 727 unsigned int c, d, inlen; 728 unsigned char *tmp; 729 int bits; 730 731 if ((*inlenb % 2) == 1) 732 (*inlenb)--; 733 inlen = *inlenb / 2; 734 inend= in + inlen; 735 while (in < inend) { 736 if (xmlLittleEndian) { 737 tmp = (unsigned char *) in; 738 c = *tmp++; 739 c = c << 8; 740 c = c | (unsigned int) *tmp; 741 in++; 742 } else { 743 c= *in++; 744 } 745 if ((c & 0xFC00) == 0xD800) { /* surrogates */ 746 if (in >= inend) { /* (in > inend) shouldn't happens */ 747 *outlen = out - outstart; 748 *inlenb = processed - inb; 749 return(-2); 750 } 751 if (xmlLittleEndian) { 752 tmp = (unsigned char *) in; 753 d = *tmp++; 754 d = d << 8; 755 d = d | (unsigned int) *tmp; 756 in++; 757 } else { 758 d= *in++; 759 } 760 if ((d & 0xFC00) == 0xDC00) { 761 c &= 0x03FF; 762 c <<= 10; 763 c |= d & 0x03FF; 764 c += 0x10000; 765 } 766 else { 767 *outlen = out - outstart; 768 *inlenb = processed - inb; 769 return(-2); 770 } 771 } 772 773 /* assertion: c is a single UTF-4 value */ 774 if (out >= outend) 775 break; 776 if (c < 0x80) { *out++= c; bits= -6; } 777 else if (c < 0x800) { *out++= ((c >> 6) & 0x1F) | 0xC0; bits= 0; } 778 else if (c < 0x10000) { *out++= ((c >> 12) & 0x0F) | 0xE0; bits= 6; } 779 else { *out++= ((c >> 18) & 0x07) | 0xF0; bits= 12; } 780 781 for ( ; bits >= 0; bits-= 6) { 782 if (out >= outend) 783 break; 784 *out++= ((c >> bits) & 0x3F) | 0x80; 785 } 786 processed = (const unsigned char*) in; 787 } 788 *outlen = out - outstart; 789 *inlenb = processed - inb; 790 return(*outlen); 791 } 792 793 #ifdef LIBXML_OUTPUT_ENABLED 794 /** 795 * UTF8ToUTF16BE: 796 * @outb: a pointer to an array of bytes to store the result 797 * @outlen: the length of @outb 798 * @in: a pointer to an array of UTF-8 chars 799 * @inlen: the length of @in 800 * 801 * Take a block of UTF-8 chars in and try to convert it to an UTF-16BE 802 * block of chars out. 803 * 804 * Returns the number of byte written, or -1 by lack of space, or -2 805 * if the transcoding failed. 806 */ 807 static int 808 UTF8ToUTF16BE(unsigned char* outb, int *outlen, 809 const unsigned char* in, int *inlen) 810 { 811 unsigned short* out = (unsigned short*) outb; 812 const unsigned char* processed = in; 813 const unsigned char *const instart = in; 814 unsigned short* outstart= out; 815 unsigned short* outend; 816 const unsigned char* inend; 817 unsigned int c, d; 818 int trailing; 819 unsigned char *tmp; 820 unsigned short tmp1, tmp2; 821 822 /* UTF-16BE has no BOM */ 823 if ((outb == NULL) || (outlen == NULL) || (inlen == NULL)) return(-1); 824 if (in == NULL) { 825 *outlen = 0; 826 *inlen = 0; 827 return(0); 828 } 829 inend= in + *inlen; 830 outend = out + (*outlen / 2); 831 while (in < inend) { 832 d= *in++; 833 if (d < 0x80) { c= d; trailing= 0; } 834 else if (d < 0xC0) { 835 /* trailing byte in leading position */ 836 *outlen = out - outstart; 837 *inlen = processed - instart; 838 return(-2); 839 } else if (d < 0xE0) { c= d & 0x1F; trailing= 1; } 840 else if (d < 0xF0) { c= d & 0x0F; trailing= 2; } 841 else if (d < 0xF8) { c= d & 0x07; trailing= 3; } 842 else { 843 /* no chance for this in UTF-16 */ 844 *outlen = out - outstart; 845 *inlen = processed - instart; 846 return(-2); 847 } 848 849 if (inend - in < trailing) { 850 break; 851 } 852 853 for ( ; trailing; trailing--) { 854 if ((in >= inend) || (((d= *in++) & 0xC0) != 0x80)) break; 855 c <<= 6; 856 c |= d & 0x3F; 857 } 858 859 /* assertion: c is a single UTF-4 value */ 860 if (c < 0x10000) { 861 if (out >= outend) break; 862 if (xmlLittleEndian) { 863 tmp = (unsigned char *) out; 864 *tmp = c >> 8; 865 *(tmp + 1) = c; 866 out++; 867 } else { 868 *out++ = c; 869 } 870 } 871 else if (c < 0x110000) { 872 if (out+1 >= outend) break; 873 c -= 0x10000; 874 if (xmlLittleEndian) { 875 tmp1 = 0xD800 | (c >> 10); 876 tmp = (unsigned char *) out; 877 *tmp = tmp1 >> 8; 878 *(tmp + 1) = (unsigned char) tmp1; 879 out++; 880 881 tmp2 = 0xDC00 | (c & 0x03FF); 882 tmp = (unsigned char *) out; 883 *tmp = tmp2 >> 8; 884 *(tmp + 1) = (unsigned char) tmp2; 885 out++; 886 } else { 887 *out++ = 0xD800 | (c >> 10); 888 *out++ = 0xDC00 | (c & 0x03FF); 889 } 890 } 891 else 892 break; 893 processed = in; 894 } 895 *outlen = (out - outstart) * 2; 896 *inlen = processed - instart; 897 return(*outlen); 898 } 899 #endif /* LIBXML_OUTPUT_ENABLED */ 900 901 /************************************************************************ 902 * * 903 * Generic encoding handling routines * 904 * * 905 ************************************************************************/ 906 907 /** 908 * xmlDetectCharEncoding: 909 * @in: a pointer to the first bytes of the XML entity, must be at least 910 * 2 bytes long (at least 4 if encoding is UTF4 variant). 911 * @len: pointer to the length of the buffer 912 * 913 * Guess the encoding of the entity using the first bytes of the entity content 914 * according to the non-normative appendix F of the XML-1.0 recommendation. 915 * 916 * Returns one of the XML_CHAR_ENCODING_... values. 917 */ 918 xmlCharEncoding 919 xmlDetectCharEncoding(const unsigned char* in, int len) 920 { 921 if (in == NULL) 922 return(XML_CHAR_ENCODING_NONE); 923 if (len >= 4) { 924 if ((in[0] == 0x00) && (in[1] == 0x00) && 925 (in[2] == 0x00) && (in[3] == 0x3C)) 926 return(XML_CHAR_ENCODING_UCS4BE); 927 if ((in[0] == 0x3C) && (in[1] == 0x00) && 928 (in[2] == 0x00) && (in[3] == 0x00)) 929 return(XML_CHAR_ENCODING_UCS4LE); 930 if ((in[0] == 0x00) && (in[1] == 0x00) && 931 (in[2] == 0x3C) && (in[3] == 0x00)) 932 return(XML_CHAR_ENCODING_UCS4_2143); 933 if ((in[0] == 0x00) && (in[1] == 0x3C) && 934 (in[2] == 0x00) && (in[3] == 0x00)) 935 return(XML_CHAR_ENCODING_UCS4_3412); 936 if ((in[0] == 0x4C) && (in[1] == 0x6F) && 937 (in[2] == 0xA7) && (in[3] == 0x94)) 938 return(XML_CHAR_ENCODING_EBCDIC); 939 if ((in[0] == 0x3C) && (in[1] == 0x3F) && 940 (in[2] == 0x78) && (in[3] == 0x6D)) 941 return(XML_CHAR_ENCODING_UTF8); 942 /* 943 * Although not part of the recommendation, we also 944 * attempt an "auto-recognition" of UTF-16LE and 945 * UTF-16BE encodings. 946 */ 947 if ((in[0] == 0x3C) && (in[1] == 0x00) && 948 (in[2] == 0x3F) && (in[3] == 0x00)) 949 return(XML_CHAR_ENCODING_UTF16LE); 950 if ((in[0] == 0x00) && (in[1] == 0x3C) && 951 (in[2] == 0x00) && (in[3] == 0x3F)) 952 return(XML_CHAR_ENCODING_UTF16BE); 953 } 954 if (len >= 3) { 955 /* 956 * Errata on XML-1.0 June 20 2001 957 * We now allow an UTF8 encoded BOM 958 */ 959 if ((in[0] == 0xEF) && (in[1] == 0xBB) && 960 (in[2] == 0xBF)) 961 return(XML_CHAR_ENCODING_UTF8); 962 } 963 /* For UTF-16 we can recognize by the BOM */ 964 if (len >= 2) { 965 if ((in[0] == 0xFE) && (in[1] == 0xFF)) 966 return(XML_CHAR_ENCODING_UTF16BE); 967 if ((in[0] == 0xFF) && (in[1] == 0xFE)) 968 return(XML_CHAR_ENCODING_UTF16LE); 969 } 970 return(XML_CHAR_ENCODING_NONE); 971 } 972 973 /** 974 * xmlCleanupEncodingAliases: 975 * 976 * Unregisters all aliases 977 */ 978 void 979 xmlCleanupEncodingAliases(void) { 980 int i; 981 982 if (xmlCharEncodingAliases == NULL) 983 return; 984 985 for (i = 0;i < xmlCharEncodingAliasesNb;i++) { 986 if (xmlCharEncodingAliases[i].name != NULL) 987 xmlFree((char *) xmlCharEncodingAliases[i].name); 988 if (xmlCharEncodingAliases[i].alias != NULL) 989 xmlFree((char *) xmlCharEncodingAliases[i].alias); 990 } 991 xmlCharEncodingAliasesNb = 0; 992 xmlCharEncodingAliasesMax = 0; 993 xmlFree(xmlCharEncodingAliases); 994 xmlCharEncodingAliases = NULL; 995 } 996 997 /** 998 * xmlGetEncodingAlias: 999 * @alias: the alias name as parsed, in UTF-8 format (ASCII actually) 1000 * 1001 * Lookup an encoding name for the given alias. 1002 * 1003 * Returns NULL if not found, otherwise the original name 1004 */ 1005 const char * 1006 xmlGetEncodingAlias(const char *alias) { 1007 int i; 1008 char upper[100]; 1009 1010 if (alias == NULL) 1011 return(NULL); 1012 1013 if (xmlCharEncodingAliases == NULL) 1014 return(NULL); 1015 1016 for (i = 0;i < 99;i++) { 1017 upper[i] = toupper(alias[i]); 1018 if (upper[i] == 0) break; 1019 } 1020 upper[i] = 0; 1021 1022 /* 1023 * Walk down the list looking for a definition of the alias 1024 */ 1025 for (i = 0;i < xmlCharEncodingAliasesNb;i++) { 1026 if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) { 1027 return(xmlCharEncodingAliases[i].name); 1028 } 1029 } 1030 return(NULL); 1031 } 1032 1033 /** 1034 * xmlAddEncodingAlias: 1035 * @name: the encoding name as parsed, in UTF-8 format (ASCII actually) 1036 * @alias: the alias name as parsed, in UTF-8 format (ASCII actually) 1037 * 1038 * Registers an alias @alias for an encoding named @name. Existing alias 1039 * will be overwritten. 1040 * 1041 * Returns 0 in case of success, -1 in case of error 1042 */ 1043 int 1044 xmlAddEncodingAlias(const char *name, const char *alias) { 1045 int i; 1046 char upper[100]; 1047 1048 if ((name == NULL) || (alias == NULL)) 1049 return(-1); 1050 1051 for (i = 0;i < 99;i++) { 1052 upper[i] = toupper(alias[i]); 1053 if (upper[i] == 0) break; 1054 } 1055 upper[i] = 0; 1056 1057 if (xmlCharEncodingAliases == NULL) { 1058 xmlCharEncodingAliasesNb = 0; 1059 xmlCharEncodingAliasesMax = 20; 1060 xmlCharEncodingAliases = (xmlCharEncodingAliasPtr) 1061 xmlMalloc(xmlCharEncodingAliasesMax * sizeof(xmlCharEncodingAlias)); 1062 if (xmlCharEncodingAliases == NULL) 1063 return(-1); 1064 } else if (xmlCharEncodingAliasesNb >= xmlCharEncodingAliasesMax) { 1065 xmlCharEncodingAliasesMax *= 2; 1066 xmlCharEncodingAliases = (xmlCharEncodingAliasPtr) 1067 xmlRealloc(xmlCharEncodingAliases, 1068 xmlCharEncodingAliasesMax * sizeof(xmlCharEncodingAlias)); 1069 } 1070 /* 1071 * Walk down the list looking for a definition of the alias 1072 */ 1073 for (i = 0;i < xmlCharEncodingAliasesNb;i++) { 1074 if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) { 1075 /* 1076 * Replace the definition. 1077 */ 1078 xmlFree((char *) xmlCharEncodingAliases[i].name); 1079 xmlCharEncodingAliases[i].name = xmlMemStrdup(name); 1080 return(0); 1081 } 1082 } 1083 /* 1084 * Add the definition 1085 */ 1086 xmlCharEncodingAliases[xmlCharEncodingAliasesNb].name = xmlMemStrdup(name); 1087 xmlCharEncodingAliases[xmlCharEncodingAliasesNb].alias = xmlMemStrdup(upper); 1088 xmlCharEncodingAliasesNb++; 1089 return(0); 1090 } 1091 1092 /** 1093 * xmlDelEncodingAlias: 1094 * @alias: the alias name as parsed, in UTF-8 format (ASCII actually) 1095 * 1096 * Unregisters an encoding alias @alias 1097 * 1098 * Returns 0 in case of success, -1 in case of error 1099 */ 1100 int 1101 xmlDelEncodingAlias(const char *alias) { 1102 int i; 1103 1104 if (alias == NULL) 1105 return(-1); 1106 1107 if (xmlCharEncodingAliases == NULL) 1108 return(-1); 1109 /* 1110 * Walk down the list looking for a definition of the alias 1111 */ 1112 for (i = 0;i < xmlCharEncodingAliasesNb;i++) { 1113 if (!strcmp(xmlCharEncodingAliases[i].alias, alias)) { 1114 xmlFree((char *) xmlCharEncodingAliases[i].name); 1115 xmlFree((char *) xmlCharEncodingAliases[i].alias); 1116 xmlCharEncodingAliasesNb--; 1117 memmove(&xmlCharEncodingAliases[i], &xmlCharEncodingAliases[i + 1], 1118 sizeof(xmlCharEncodingAlias) * (xmlCharEncodingAliasesNb - i)); 1119 return(0); 1120 } 1121 } 1122 return(-1); 1123 } 1124 1125 /** 1126 * xmlParseCharEncoding: 1127 * @name: the encoding name as parsed, in UTF-8 format (ASCII actually) 1128 * 1129 * Compare the string to the encoding schemes already known. Note 1130 * that the comparison is case insensitive accordingly to the section 1131 * [XML] 4.3.3 Character Encoding in Entities. 1132 * 1133 * Returns one of the XML_CHAR_ENCODING_... values or XML_CHAR_ENCODING_NONE 1134 * if not recognized. 1135 */ 1136 xmlCharEncoding 1137 xmlParseCharEncoding(const char* name) 1138 { 1139 const char *alias; 1140 char upper[500]; 1141 int i; 1142 1143 if (name == NULL) 1144 return(XML_CHAR_ENCODING_NONE); 1145 1146 /* 1147 * Do the alias resolution 1148 */ 1149 alias = xmlGetEncodingAlias(name); 1150 if (alias != NULL) 1151 name = alias; 1152 1153 for (i = 0;i < 499;i++) { 1154 upper[i] = toupper(name[i]); 1155 if (upper[i] == 0) break; 1156 } 1157 upper[i] = 0; 1158 1159 if (!strcmp(upper, "")) return(XML_CHAR_ENCODING_NONE); 1160 if (!strcmp(upper, "UTF-8")) return(XML_CHAR_ENCODING_UTF8); 1161 if (!strcmp(upper, "UTF8")) return(XML_CHAR_ENCODING_UTF8); 1162 1163 /* 1164 * NOTE: if we were able to parse this, the endianness of UTF16 is 1165 * already found and in use 1166 */ 1167 if (!strcmp(upper, "UTF-16")) return(XML_CHAR_ENCODING_UTF16LE); 1168 if (!strcmp(upper, "UTF16")) return(XML_CHAR_ENCODING_UTF16LE); 1169 1170 if (!strcmp(upper, "ISO-10646-UCS-2")) return(XML_CHAR_ENCODING_UCS2); 1171 if (!strcmp(upper, "UCS-2")) return(XML_CHAR_ENCODING_UCS2); 1172 if (!strcmp(upper, "UCS2")) return(XML_CHAR_ENCODING_UCS2); 1173 1174 /* 1175 * NOTE: if we were able to parse this, the endianness of UCS4 is 1176 * already found and in use 1177 */ 1178 if (!strcmp(upper, "ISO-10646-UCS-4")) return(XML_CHAR_ENCODING_UCS4LE); 1179 if (!strcmp(upper, "UCS-4")) return(XML_CHAR_ENCODING_UCS4LE); 1180 if (!strcmp(upper, "UCS4")) return(XML_CHAR_ENCODING_UCS4LE); 1181 1182 1183 if (!strcmp(upper, "ISO-8859-1")) return(XML_CHAR_ENCODING_8859_1); 1184 if (!strcmp(upper, "ISO-LATIN-1")) return(XML_CHAR_ENCODING_8859_1); 1185 if (!strcmp(upper, "ISO LATIN 1")) return(XML_CHAR_ENCODING_8859_1); 1186 1187 if (!strcmp(upper, "ISO-8859-2")) return(XML_CHAR_ENCODING_8859_2); 1188 if (!strcmp(upper, "ISO-LATIN-2")) return(XML_CHAR_ENCODING_8859_2); 1189 if (!strcmp(upper, "ISO LATIN 2")) return(XML_CHAR_ENCODING_8859_2); 1190 1191 if (!strcmp(upper, "ISO-8859-3")) return(XML_CHAR_ENCODING_8859_3); 1192 if (!strcmp(upper, "ISO-8859-4")) return(XML_CHAR_ENCODING_8859_4); 1193 if (!strcmp(upper, "ISO-8859-5")) return(XML_CHAR_ENCODING_8859_5); 1194 if (!strcmp(upper, "ISO-8859-6")) return(XML_CHAR_ENCODING_8859_6); 1195 if (!strcmp(upper, "ISO-8859-7")) return(XML_CHAR_ENCODING_8859_7); 1196 if (!strcmp(upper, "ISO-8859-8")) return(XML_CHAR_ENCODING_8859_8); 1197 if (!strcmp(upper, "ISO-8859-9")) return(XML_CHAR_ENCODING_8859_9); 1198 1199 if (!strcmp(upper, "ISO-2022-JP")) return(XML_CHAR_ENCODING_2022_JP); 1200 if (!strcmp(upper, "SHIFT_JIS")) return(XML_CHAR_ENCODING_SHIFT_JIS); 1201 if (!strcmp(upper, "EUC-JP")) return(XML_CHAR_ENCODING_EUC_JP); 1202 1203 #ifdef DEBUG_ENCODING 1204 xmlGenericError(xmlGenericErrorContext, "Unknown encoding %s\n", name); 1205 #endif 1206 return(XML_CHAR_ENCODING_ERROR); 1207 } 1208 1209 /** 1210 * xmlGetCharEncodingName: 1211 * @enc: the encoding 1212 * 1213 * The "canonical" name for XML encoding. 1214 * C.f. http://www.w3.org/TR/REC-xml#charencoding 1215 * Section 4.3.3 Character Encoding in Entities 1216 * 1217 * Returns the canonical name for the given encoding 1218 */ 1219 1220 const char* 1221 xmlGetCharEncodingName(xmlCharEncoding enc) { 1222 switch (enc) { 1223 case XML_CHAR_ENCODING_ERROR: 1224 return(NULL); 1225 case XML_CHAR_ENCODING_NONE: 1226 return(NULL); 1227 case XML_CHAR_ENCODING_UTF8: 1228 return("UTF-8"); 1229 case XML_CHAR_ENCODING_UTF16LE: 1230 return("UTF-16"); 1231 case XML_CHAR_ENCODING_UTF16BE: 1232 return("UTF-16"); 1233 case XML_CHAR_ENCODING_EBCDIC: 1234 return("EBCDIC"); 1235 case XML_CHAR_ENCODING_UCS4LE: 1236 return("ISO-10646-UCS-4"); 1237 case XML_CHAR_ENCODING_UCS4BE: 1238 return("ISO-10646-UCS-4"); 1239 case XML_CHAR_ENCODING_UCS4_2143: 1240 return("ISO-10646-UCS-4"); 1241 case XML_CHAR_ENCODING_UCS4_3412: 1242 return("ISO-10646-UCS-4"); 1243 case XML_CHAR_ENCODING_UCS2: 1244 return("ISO-10646-UCS-2"); 1245 case XML_CHAR_ENCODING_8859_1: 1246 return("ISO-8859-1"); 1247 case XML_CHAR_ENCODING_8859_2: 1248 return("ISO-8859-2"); 1249 case XML_CHAR_ENCODING_8859_3: 1250 return("ISO-8859-3"); 1251 case XML_CHAR_ENCODING_8859_4: 1252 return("ISO-8859-4"); 1253 case XML_CHAR_ENCODING_8859_5: 1254 return("ISO-8859-5"); 1255 case XML_CHAR_ENCODING_8859_6: 1256 return("ISO-8859-6"); 1257 case XML_CHAR_ENCODING_8859_7: 1258 return("ISO-8859-7"); 1259 case XML_CHAR_ENCODING_8859_8: 1260 return("ISO-8859-8"); 1261 case XML_CHAR_ENCODING_8859_9: 1262 return("ISO-8859-9"); 1263 case XML_CHAR_ENCODING_2022_JP: 1264 return("ISO-2022-JP"); 1265 case XML_CHAR_ENCODING_SHIFT_JIS: 1266 return("Shift-JIS"); 1267 case XML_CHAR_ENCODING_EUC_JP: 1268 return("EUC-JP"); 1269 case XML_CHAR_ENCODING_ASCII: 1270 return(NULL); 1271 } 1272 return(NULL); 1273 } 1274 1275 /************************************************************************ 1276 * * 1277 * Char encoding handlers * 1278 * * 1279 ************************************************************************/ 1280 1281 1282 /* the size should be growable, but it's not a big deal ... */ 1283 #define MAX_ENCODING_HANDLERS 50 1284 static xmlCharEncodingHandlerPtr *handlers = NULL; 1285 static int nbCharEncodingHandler = 0; 1286 1287 /* 1288 * The default is UTF-8 for XML, that's also the default used for the 1289 * parser internals, so the default encoding handler is NULL 1290 */ 1291 1292 static xmlCharEncodingHandlerPtr xmlDefaultCharEncodingHandler = NULL; 1293 1294 /** 1295 * xmlNewCharEncodingHandler: 1296 * @name: the encoding name, in UTF-8 format (ASCII actually) 1297 * @input: the xmlCharEncodingInputFunc to read that encoding 1298 * @output: the xmlCharEncodingOutputFunc to write that encoding 1299 * 1300 * Create and registers an xmlCharEncodingHandler. 1301 * 1302 * Returns the xmlCharEncodingHandlerPtr created (or NULL in case of error). 1303 */ 1304 xmlCharEncodingHandlerPtr 1305 xmlNewCharEncodingHandler(const char *name, 1306 xmlCharEncodingInputFunc input, 1307 xmlCharEncodingOutputFunc output) { 1308 xmlCharEncodingHandlerPtr handler; 1309 const char *alias; 1310 char upper[500]; 1311 int i; 1312 char *up = NULL; 1313 1314 /* 1315 * Do the alias resolution 1316 */ 1317 alias = xmlGetEncodingAlias(name); 1318 if (alias != NULL) 1319 name = alias; 1320 1321 /* 1322 * Keep only the uppercase version of the encoding. 1323 */ 1324 if (name == NULL) { 1325 xmlEncodingErr(XML_I18N_NO_NAME, 1326 "xmlNewCharEncodingHandler : no name !\n", NULL); 1327 return(NULL); 1328 } 1329 for (i = 0;i < 499;i++) { 1330 upper[i] = toupper(name[i]); 1331 if (upper[i] == 0) break; 1332 } 1333 upper[i] = 0; 1334 up = xmlMemStrdup(upper); 1335 if (up == NULL) { 1336 xmlEncodingErrMemory("xmlNewCharEncodingHandler : out of memory !\n"); 1337 return(NULL); 1338 } 1339 1340 /* 1341 * allocate and fill-up an handler block. 1342 */ 1343 handler = (xmlCharEncodingHandlerPtr) 1344 xmlMalloc(sizeof(xmlCharEncodingHandler)); 1345 if (handler == NULL) { 1346 xmlFree(up); 1347 xmlEncodingErrMemory("xmlNewCharEncodingHandler : out of memory !\n"); 1348 return(NULL); 1349 } 1350 memset(handler, 0, sizeof(xmlCharEncodingHandler)); 1351 handler->input = input; 1352 handler->output = output; 1353 handler->name = up; 1354 1355 #ifdef LIBXML_ICONV_ENABLED 1356 handler->iconv_in = NULL; 1357 handler->iconv_out = NULL; 1358 #endif 1359 #ifdef LIBXML_ICU_ENABLED 1360 handler->uconv_in = NULL; 1361 handler->uconv_out = NULL; 1362 #endif 1363 1364 /* 1365 * registers and returns the handler. 1366 */ 1367 xmlRegisterCharEncodingHandler(handler); 1368 #ifdef DEBUG_ENCODING 1369 xmlGenericError(xmlGenericErrorContext, 1370 "Registered encoding handler for %s\n", name); 1371 #endif 1372 return(handler); 1373 } 1374 1375 /** 1376 * xmlInitCharEncodingHandlers: 1377 * 1378 * Initialize the char encoding support, it registers the default 1379 * encoding supported. 1380 * NOTE: while public, this function usually doesn't need to be called 1381 * in normal processing. 1382 */ 1383 void 1384 xmlInitCharEncodingHandlers(void) { 1385 unsigned short int tst = 0x1234; 1386 unsigned char *ptr = (unsigned char *) &tst; 1387 1388 if (handlers != NULL) return; 1389 1390 handlers = (xmlCharEncodingHandlerPtr *) 1391 xmlMalloc(MAX_ENCODING_HANDLERS * sizeof(xmlCharEncodingHandlerPtr)); 1392 1393 if (*ptr == 0x12) xmlLittleEndian = 0; 1394 else if (*ptr == 0x34) xmlLittleEndian = 1; 1395 else { 1396 xmlEncodingErr(XML_ERR_INTERNAL_ERROR, 1397 "Odd problem at endianness detection\n", NULL); 1398 } 1399 1400 if (handlers == NULL) { 1401 xmlEncodingErrMemory("xmlInitCharEncodingHandlers : out of memory !\n"); 1402 return; 1403 } 1404 xmlNewCharEncodingHandler("UTF-8", UTF8ToUTF8, UTF8ToUTF8); 1405 #ifdef LIBXML_OUTPUT_ENABLED 1406 xmlUTF16LEHandler = 1407 xmlNewCharEncodingHandler("UTF-16LE", UTF16LEToUTF8, UTF8ToUTF16LE); 1408 xmlUTF16BEHandler = 1409 xmlNewCharEncodingHandler("UTF-16BE", UTF16BEToUTF8, UTF8ToUTF16BE); 1410 xmlNewCharEncodingHandler("UTF-16", UTF16LEToUTF8, UTF8ToUTF16); 1411 xmlNewCharEncodingHandler("ISO-8859-1", isolat1ToUTF8, UTF8Toisolat1); 1412 xmlNewCharEncodingHandler("ASCII", asciiToUTF8, UTF8Toascii); 1413 xmlNewCharEncodingHandler("US-ASCII", asciiToUTF8, UTF8Toascii); 1414 #ifdef LIBXML_HTML_ENABLED 1415 xmlNewCharEncodingHandler("HTML", NULL, UTF8ToHtml); 1416 #endif 1417 #else 1418 xmlUTF16LEHandler = 1419 xmlNewCharEncodingHandler("UTF-16LE", UTF16LEToUTF8, NULL); 1420 xmlUTF16BEHandler = 1421 xmlNewCharEncodingHandler("UTF-16BE", UTF16BEToUTF8, NULL); 1422 xmlNewCharEncodingHandler("UTF-16", UTF16LEToUTF8, NULL); 1423 xmlNewCharEncodingHandler("ISO-8859-1", isolat1ToUTF8, NULL); 1424 xmlNewCharEncodingHandler("ASCII", asciiToUTF8, NULL); 1425 xmlNewCharEncodingHandler("US-ASCII", asciiToUTF8, NULL); 1426 #endif /* LIBXML_OUTPUT_ENABLED */ 1427 #if !defined(LIBXML_ICONV_ENABLED) && !defined(LIBXML_ICU_ENABLED) 1428 #ifdef LIBXML_ISO8859X_ENABLED 1429 xmlRegisterCharEncodingHandlersISO8859x (); 1430 #endif 1431 #endif 1432 1433 } 1434 1435 /** 1436 * xmlCleanupCharEncodingHandlers: 1437 * 1438 * Cleanup the memory allocated for the char encoding support, it 1439 * unregisters all the encoding handlers and the aliases. 1440 */ 1441 void 1442 xmlCleanupCharEncodingHandlers(void) { 1443 xmlCleanupEncodingAliases(); 1444 1445 if (handlers == NULL) return; 1446 1447 for (;nbCharEncodingHandler > 0;) { 1448 nbCharEncodingHandler--; 1449 if (handlers[nbCharEncodingHandler] != NULL) { 1450 if (handlers[nbCharEncodingHandler]->name != NULL) 1451 xmlFree(handlers[nbCharEncodingHandler]->name); 1452 xmlFree(handlers[nbCharEncodingHandler]); 1453 } 1454 } 1455 xmlFree(handlers); 1456 handlers = NULL; 1457 nbCharEncodingHandler = 0; 1458 xmlDefaultCharEncodingHandler = NULL; 1459 } 1460 1461 /** 1462 * xmlRegisterCharEncodingHandler: 1463 * @handler: the xmlCharEncodingHandlerPtr handler block 1464 * 1465 * Register the char encoding handler, surprising, isn't it ? 1466 */ 1467 void 1468 xmlRegisterCharEncodingHandler(xmlCharEncodingHandlerPtr handler) { 1469 if (handlers == NULL) xmlInitCharEncodingHandlers(); 1470 if ((handler == NULL) || (handlers == NULL)) { 1471 xmlEncodingErr(XML_I18N_NO_HANDLER, 1472 "xmlRegisterCharEncodingHandler: NULL handler !\n", NULL); 1473 return; 1474 } 1475 1476 if (nbCharEncodingHandler >= MAX_ENCODING_HANDLERS) { 1477 xmlEncodingErr(XML_I18N_EXCESS_HANDLER, 1478 "xmlRegisterCharEncodingHandler: Too many handler registered, see %s\n", 1479 "MAX_ENCODING_HANDLERS"); 1480 return; 1481 } 1482 handlers[nbCharEncodingHandler++] = handler; 1483 } 1484 1485 /** 1486 * xmlGetCharEncodingHandler: 1487 * @enc: an xmlCharEncoding value. 1488 * 1489 * Search in the registered set the handler able to read/write that encoding. 1490 * 1491 * Returns the handler or NULL if not found 1492 */ 1493 xmlCharEncodingHandlerPtr 1494 xmlGetCharEncodingHandler(xmlCharEncoding enc) { 1495 xmlCharEncodingHandlerPtr handler; 1496 1497 if (handlers == NULL) xmlInitCharEncodingHandlers(); 1498 switch (enc) { 1499 case XML_CHAR_ENCODING_ERROR: 1500 return(NULL); 1501 case XML_CHAR_ENCODING_NONE: 1502 return(NULL); 1503 case XML_CHAR_ENCODING_UTF8: 1504 return(NULL); 1505 case XML_CHAR_ENCODING_UTF16LE: 1506 return(xmlUTF16LEHandler); 1507 case XML_CHAR_ENCODING_UTF16BE: 1508 return(xmlUTF16BEHandler); 1509 case XML_CHAR_ENCODING_EBCDIC: 1510 handler = xmlFindCharEncodingHandler("EBCDIC"); 1511 if (handler != NULL) return(handler); 1512 handler = xmlFindCharEncodingHandler("ebcdic"); 1513 if (handler != NULL) return(handler); 1514 handler = xmlFindCharEncodingHandler("EBCDIC-US"); 1515 if (handler != NULL) return(handler); 1516 break; 1517 case XML_CHAR_ENCODING_UCS4BE: 1518 handler = xmlFindCharEncodingHandler("ISO-10646-UCS-4"); 1519 if (handler != NULL) return(handler); 1520 handler = xmlFindCharEncodingHandler("UCS-4"); 1521 if (handler != NULL) return(handler); 1522 handler = xmlFindCharEncodingHandler("UCS4"); 1523 if (handler != NULL) return(handler); 1524 break; 1525 case XML_CHAR_ENCODING_UCS4LE: 1526 handler = xmlFindCharEncodingHandler("ISO-10646-UCS-4"); 1527 if (handler != NULL) return(handler); 1528 handler = xmlFindCharEncodingHandler("UCS-4"); 1529 if (handler != NULL) return(handler); 1530 handler = xmlFindCharEncodingHandler("UCS4"); 1531 if (handler != NULL) return(handler); 1532 break; 1533 case XML_CHAR_ENCODING_UCS4_2143: 1534 break; 1535 case XML_CHAR_ENCODING_UCS4_3412: 1536 break; 1537 case XML_CHAR_ENCODING_UCS2: 1538 handler = xmlFindCharEncodingHandler("ISO-10646-UCS-2"); 1539 if (handler != NULL) return(handler); 1540 handler = xmlFindCharEncodingHandler("UCS-2"); 1541 if (handler != NULL) return(handler); 1542 handler = xmlFindCharEncodingHandler("UCS2"); 1543 if (handler != NULL) return(handler); 1544 break; 1545 1546 /* 1547 * We used to keep ISO Latin encodings native in the 1548 * generated data. This led to so many problems that 1549 * this has been removed. One can still change this 1550 * back by registering no-ops encoders for those 1551 */ 1552 case XML_CHAR_ENCODING_8859_1: 1553 handler = xmlFindCharEncodingHandler("ISO-8859-1"); 1554 if (handler != NULL) return(handler); 1555 break; 1556 case XML_CHAR_ENCODING_8859_2: 1557 handler = xmlFindCharEncodingHandler("ISO-8859-2"); 1558 if (handler != NULL) return(handler); 1559 break; 1560 case XML_CHAR_ENCODING_8859_3: 1561 handler = xmlFindCharEncodingHandler("ISO-8859-3"); 1562 if (handler != NULL) return(handler); 1563 break; 1564 case XML_CHAR_ENCODING_8859_4: 1565 handler = xmlFindCharEncodingHandler("ISO-8859-4"); 1566 if (handler != NULL) return(handler); 1567 break; 1568 case XML_CHAR_ENCODING_8859_5: 1569 handler = xmlFindCharEncodingHandler("ISO-8859-5"); 1570 if (handler != NULL) return(handler); 1571 break; 1572 case XML_CHAR_ENCODING_8859_6: 1573 handler = xmlFindCharEncodingHandler("ISO-8859-6"); 1574 if (handler != NULL) return(handler); 1575 break; 1576 case XML_CHAR_ENCODING_8859_7: 1577 handler = xmlFindCharEncodingHandler("ISO-8859-7"); 1578 if (handler != NULL) return(handler); 1579 break; 1580 case XML_CHAR_ENCODING_8859_8: 1581 handler = xmlFindCharEncodingHandler("ISO-8859-8"); 1582 if (handler != NULL) return(handler); 1583 break; 1584 case XML_CHAR_ENCODING_8859_9: 1585 handler = xmlFindCharEncodingHandler("ISO-8859-9"); 1586 if (handler != NULL) return(handler); 1587 break; 1588 1589 1590 case XML_CHAR_ENCODING_2022_JP: 1591 handler = xmlFindCharEncodingHandler("ISO-2022-JP"); 1592 if (handler != NULL) return(handler); 1593 break; 1594 case XML_CHAR_ENCODING_SHIFT_JIS: 1595 handler = xmlFindCharEncodingHandler("SHIFT-JIS"); 1596 if (handler != NULL) return(handler); 1597 handler = xmlFindCharEncodingHandler("SHIFT_JIS"); 1598 if (handler != NULL) return(handler); 1599 handler = xmlFindCharEncodingHandler("Shift_JIS"); 1600 if (handler != NULL) return(handler); 1601 break; 1602 case XML_CHAR_ENCODING_EUC_JP: 1603 handler = xmlFindCharEncodingHandler("EUC-JP"); 1604 if (handler != NULL) return(handler); 1605 break; 1606 default: 1607 break; 1608 } 1609 1610 #ifdef DEBUG_ENCODING 1611 xmlGenericError(xmlGenericErrorContext, 1612 "No handler found for encoding %d\n", enc); 1613 #endif 1614 return(NULL); 1615 } 1616 1617 /** 1618 * xmlFindCharEncodingHandler: 1619 * @name: a string describing the char encoding. 1620 * 1621 * Search in the registered set the handler able to read/write that encoding. 1622 * 1623 * Returns the handler or NULL if not found 1624 */ 1625 xmlCharEncodingHandlerPtr 1626 xmlFindCharEncodingHandler(const char *name) { 1627 const char *nalias; 1628 const char *norig; 1629 xmlCharEncoding alias; 1630 #ifdef LIBXML_ICONV_ENABLED 1631 xmlCharEncodingHandlerPtr enc; 1632 iconv_t icv_in, icv_out; 1633 #endif /* LIBXML_ICONV_ENABLED */ 1634 #ifdef LIBXML_ICU_ENABLED 1635 xmlCharEncodingHandlerPtr encu; 1636 uconv_t *ucv_in, *ucv_out; 1637 #endif /* LIBXML_ICU_ENABLED */ 1638 char upper[100]; 1639 int i; 1640 1641 if (handlers == NULL) xmlInitCharEncodingHandlers(); 1642 if (name == NULL) return(xmlDefaultCharEncodingHandler); 1643 if (name[0] == 0) return(xmlDefaultCharEncodingHandler); 1644 1645 /* 1646 * Do the alias resolution 1647 */ 1648 norig = name; 1649 nalias = xmlGetEncodingAlias(name); 1650 if (nalias != NULL) 1651 name = nalias; 1652 1653 /* 1654 * Check first for directly registered encoding names 1655 */ 1656 for (i = 0;i < 99;i++) { 1657 upper[i] = toupper(name[i]); 1658 if (upper[i] == 0) break; 1659 } 1660 upper[i] = 0; 1661 1662 if (handlers != NULL) { 1663 for (i = 0;i < nbCharEncodingHandler; i++) { 1664 if (!strcmp(upper, handlers[i]->name)) { 1665 #ifdef DEBUG_ENCODING 1666 xmlGenericError(xmlGenericErrorContext, 1667 "Found registered handler for encoding %s\n", name); 1668 #endif 1669 return(handlers[i]); 1670 } 1671 } 1672 } 1673 1674 #ifdef LIBXML_ICONV_ENABLED 1675 /* check whether iconv can handle this */ 1676 icv_in = iconv_open("UTF-8", name); 1677 icv_out = iconv_open(name, "UTF-8"); 1678 if (icv_in == (iconv_t) -1) { 1679 icv_in = iconv_open("UTF-8", upper); 1680 } 1681 if (icv_out == (iconv_t) -1) { 1682 icv_out = iconv_open(upper, "UTF-8"); 1683 } 1684 if ((icv_in != (iconv_t) -1) && (icv_out != (iconv_t) -1)) { 1685 enc = (xmlCharEncodingHandlerPtr) 1686 xmlMalloc(sizeof(xmlCharEncodingHandler)); 1687 if (enc == NULL) { 1688 iconv_close(icv_in); 1689 iconv_close(icv_out); 1690 return(NULL); 1691 } 1692 memset(enc, 0, sizeof(xmlCharEncodingHandler)); 1693 enc->name = xmlMemStrdup(name); 1694 enc->input = NULL; 1695 enc->output = NULL; 1696 enc->iconv_in = icv_in; 1697 enc->iconv_out = icv_out; 1698 #ifdef DEBUG_ENCODING 1699 xmlGenericError(xmlGenericErrorContext, 1700 "Found iconv handler for encoding %s\n", name); 1701 #endif 1702 return enc; 1703 } else if ((icv_in != (iconv_t) -1) || icv_out != (iconv_t) -1) { 1704 xmlEncodingErr(XML_ERR_INTERNAL_ERROR, 1705 "iconv : problems with filters for '%s'\n", name); 1706 } 1707 #endif /* LIBXML_ICONV_ENABLED */ 1708 #ifdef LIBXML_ICU_ENABLED 1709 /* check whether icu can handle this */ 1710 ucv_in = openIcuConverter(name, 1); 1711 ucv_out = openIcuConverter(name, 0); 1712 if (ucv_in != NULL && ucv_out != NULL) { 1713 encu = (xmlCharEncodingHandlerPtr) 1714 xmlMalloc(sizeof(xmlCharEncodingHandler)); 1715 if (encu == NULL) { 1716 closeIcuConverter(ucv_in); 1717 closeIcuConverter(ucv_out); 1718 return(NULL); 1719 } 1720 memset(encu, 0, sizeof(xmlCharEncodingHandler)); 1721 encu->name = xmlMemStrdup(name); 1722 encu->input = NULL; 1723 encu->output = NULL; 1724 encu->uconv_in = ucv_in; 1725 encu->uconv_out = ucv_out; 1726 #ifdef DEBUG_ENCODING 1727 xmlGenericError(xmlGenericErrorContext, 1728 "Found ICU converter handler for encoding %s\n", name); 1729 #endif 1730 return encu; 1731 } else if (ucv_in != NULL || ucv_out != NULL) { 1732 closeIcuConverter(ucv_in); 1733 closeIcuConverter(ucv_out); 1734 xmlEncodingErr(XML_ERR_INTERNAL_ERROR, 1735 "ICU converter : problems with filters for '%s'\n", name); 1736 } 1737 #endif /* LIBXML_ICU_ENABLED */ 1738 1739 #ifdef DEBUG_ENCODING 1740 xmlGenericError(xmlGenericErrorContext, 1741 "No handler found for encoding %s\n", name); 1742 #endif 1743 1744 /* 1745 * Fallback using the canonical names 1746 */ 1747 alias = xmlParseCharEncoding(norig); 1748 if (alias != XML_CHAR_ENCODING_ERROR) { 1749 const char* canon; 1750 canon = xmlGetCharEncodingName(alias); 1751 if ((canon != NULL) && (strcmp(name, canon))) { 1752 return(xmlFindCharEncodingHandler(canon)); 1753 } 1754 } 1755 1756 /* If "none of the above", give up */ 1757 return(NULL); 1758 } 1759 1760 /************************************************************************ 1761 * * 1762 * ICONV based generic conversion functions * 1763 * * 1764 ************************************************************************/ 1765 1766 #ifdef LIBXML_ICONV_ENABLED 1767 /** 1768 * xmlIconvWrapper: 1769 * @cd: iconv converter data structure 1770 * @out: a pointer to an array of bytes to store the result 1771 * @outlen: the length of @out 1772 * @in: a pointer to an array of ISO Latin 1 chars 1773 * @inlen: the length of @in 1774 * 1775 * Returns 0 if success, or 1776 * -1 by lack of space, or 1777 * -2 if the transcoding fails (for *in is not valid utf8 string or 1778 * the result of transformation can't fit into the encoding we want), or 1779 * -3 if there the last byte can't form a single output char. 1780 * 1781 * The value of @inlen after return is the number of octets consumed 1782 * as the return value is positive, else unpredictable. 1783 * The value of @outlen after return is the number of ocetes consumed. 1784 */ 1785 static int 1786 xmlIconvWrapper(iconv_t cd, unsigned char *out, int *outlen, 1787 const unsigned char *in, int *inlen) { 1788 size_t icv_inlen, icv_outlen; 1789 const char *icv_in = (const char *) in; 1790 char *icv_out = (char *) out; 1791 int ret; 1792 1793 if ((out == NULL) || (outlen == NULL) || (inlen == NULL) || (in == NULL)) { 1794 if (outlen != NULL) *outlen = 0; 1795 return(-1); 1796 } 1797 icv_inlen = *inlen; 1798 icv_outlen = *outlen; 1799 ret = iconv(cd, (ICONV_CONST char **) &icv_in, &icv_inlen, &icv_out, &icv_outlen); 1800 *inlen -= icv_inlen; 1801 *outlen -= icv_outlen; 1802 if ((icv_inlen != 0) || (ret == -1)) { 1803 #ifdef EILSEQ 1804 if (errno == EILSEQ) { 1805 return -2; 1806 } else 1807 #endif 1808 #ifdef E2BIG 1809 if (errno == E2BIG) { 1810 return -1; 1811 } else 1812 #endif 1813 #ifdef EINVAL 1814 if (errno == EINVAL) { 1815 return -3; 1816 } else 1817 #endif 1818 { 1819 return -3; 1820 } 1821 } 1822 return 0; 1823 } 1824 #endif /* LIBXML_ICONV_ENABLED */ 1825 1826 /************************************************************************ 1827 * * 1828 * ICU based generic conversion functions * 1829 * * 1830 ************************************************************************/ 1831 1832 #ifdef LIBXML_ICU_ENABLED 1833 /** 1834 * xmlUconvWrapper: 1835 * @cd: ICU uconverter data structure 1836 * @toUnicode : non-zero if toUnicode. 0 otherwise. 1837 * @out: a pointer to an array of bytes to store the result 1838 * @outlen: the length of @out 1839 * @in: a pointer to an array of ISO Latin 1 chars 1840 * @inlen: the length of @in 1841 * 1842 * Returns 0 if success, or 1843 * -1 by lack of space, or 1844 * -2 if the transcoding fails (for *in is not valid utf8 string or 1845 * the result of transformation can't fit into the encoding we want), or 1846 * -3 if there the last byte can't form a single output char. 1847 * 1848 * The value of @inlen after return is the number of octets consumed 1849 * as the return value is positive, else unpredictable. 1850 * The value of @outlen after return is the number of ocetes consumed. 1851 */ 1852 static int 1853 xmlUconvWrapper(uconv_t *cd, int toUnicode, unsigned char *out, int *outlen, 1854 const unsigned char *in, int *inlen) { 1855 const char *ucv_in = (const char *) in; 1856 char *ucv_out = (char *) out; 1857 UErrorCode err = U_ZERO_ERROR; 1858 1859 if ((out == NULL) || (outlen == NULL) || (inlen == NULL) || (in == NULL)) { 1860 if (outlen != NULL) *outlen = 0; 1861 return(-1); 1862 } 1863 1864 /* 1865 * TODO(jungshik) 1866 * 1. is ucnv_convert(To|From)Algorithmic better? 1867 * 2. had we better use an explicit pivot buffer? 1868 * 3. error returned comes from 'fromUnicode' only even 1869 * when toUnicode is true ! 1870 */ 1871 if (toUnicode) { 1872 /* encoding => UTF-16 => UTF-8 */ 1873 ucnv_convertEx(cd->utf8, cd->uconv, &ucv_out, ucv_out + *outlen, 1874 &ucv_in, ucv_in + *inlen, NULL, NULL, NULL, NULL, 1875 0, TRUE, &err); 1876 } else { 1877 /* UTF-8 => UTF-16 => encoding */ 1878 ucnv_convertEx(cd->uconv, cd->utf8, &ucv_out, ucv_out + *outlen, 1879 &ucv_in, ucv_in + *inlen, NULL, NULL, NULL, NULL, 1880 0, TRUE, &err); 1881 } 1882 *inlen = ucv_in - (const char*) in; 1883 *outlen = ucv_out - (char *) out; 1884 if (U_SUCCESS(err)) 1885 return 0; 1886 if (err == U_BUFFER_OVERFLOW_ERROR) 1887 return -1; 1888 if (err == U_INVALID_CHAR_FOUND || err == U_ILLEGAL_CHAR_FOUND) 1889 return -2; 1890 /* if (err == U_TRUNCATED_CHAR_FOUND) */ 1891 return -3; 1892 } 1893 #endif /* LIBXML_ICU_ENABLED */ 1894 1895 /************************************************************************ 1896 * * 1897 * The real API used by libxml for on-the-fly conversion * 1898 * * 1899 ************************************************************************/ 1900 int 1901 xmlCharEncFirstLineInt(xmlCharEncodingHandler *handler, xmlBufferPtr out, 1902 xmlBufferPtr in, int len); 1903 1904 /** 1905 * xmlCharEncFirstLineInt: 1906 * @handler: char enconding transformation data structure 1907 * @out: an xmlBuffer for the output. 1908 * @in: an xmlBuffer for the input 1909 * @len: number of bytes to convert for the first line, or -1 1910 * 1911 * Front-end for the encoding handler input function, but handle only 1912 * the very first line, i.e. limit itself to 45 chars. 1913 * 1914 * Returns the number of byte written if success, or 1915 * -1 general error 1916 * -2 if the transcoding fails (for *in is not valid utf8 string or 1917 * the result of transformation can't fit into the encoding we want), or 1918 */ 1919 int 1920 xmlCharEncFirstLineInt(xmlCharEncodingHandler *handler, xmlBufferPtr out, 1921 xmlBufferPtr in, int len) { 1922 int ret = -2; 1923 int written; 1924 int toconv; 1925 1926 if (handler == NULL) return(-1); 1927 if (out == NULL) return(-1); 1928 if (in == NULL) return(-1); 1929 1930 /* calculate space available */ 1931 written = out->size - out->use - 1; /* count '\0' */ 1932 toconv = in->use; 1933 /* 1934 * echo '<?xml version="1.0" encoding="UCS4"?>' | wc -c => 38 1935 * 45 chars should be sufficient to reach the end of the encoding 1936 * declaration without going too far inside the document content. 1937 * on UTF-16 this means 90bytes, on UCS4 this means 180 1938 * The actual value depending on guessed encoding is passed as @len 1939 * if provided 1940 */ 1941 if (len >= 0) { 1942 if (toconv > len) 1943 toconv = len; 1944 } else { 1945 if (toconv > 180) 1946 toconv = 180; 1947 } 1948 if (toconv * 2 >= written) { 1949 xmlBufferGrow(out, toconv); 1950 written = out->size - out->use - 1; 1951 } 1952 1953 if (handler->input != NULL) { 1954 ret = handler->input(&out->content[out->use], &written, 1955 in->content, &toconv); 1956 xmlBufferShrink(in, toconv); 1957 out->use += written; 1958 out->content[out->use] = 0; 1959 } 1960 #ifdef LIBXML_ICONV_ENABLED 1961 else if (handler->iconv_in != NULL) { 1962 ret = xmlIconvWrapper(handler->iconv_in, &out->content[out->use], 1963 &written, in->content, &toconv); 1964 xmlBufferShrink(in, toconv); 1965 out->use += written; 1966 out->content[out->use] = 0; 1967 if (ret == -1) ret = -3; 1968 } 1969 #endif /* LIBXML_ICONV_ENABLED */ 1970 #ifdef LIBXML_ICU_ENABLED 1971 else if (handler->uconv_in != NULL) { 1972 ret = xmlUconvWrapper(handler->uconv_in, 1, &out->content[out->use], 1973 &written, in->content, &toconv); 1974 xmlBufferShrink(in, toconv); 1975 out->use += written; 1976 out->content[out->use] = 0; 1977 if (ret == -1) ret = -3; 1978 } 1979 #endif /* LIBXML_ICU_ENABLED */ 1980 #ifdef DEBUG_ENCODING 1981 switch (ret) { 1982 case 0: 1983 xmlGenericError(xmlGenericErrorContext, 1984 "converted %d bytes to %d bytes of input\n", 1985 toconv, written); 1986 break; 1987 case -1: 1988 xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of input, %d left\n", 1989 toconv, written, in->use); 1990 break; 1991 case -2: 1992 xmlGenericError(xmlGenericErrorContext, 1993 "input conversion failed due to input error\n"); 1994 break; 1995 case -3: 1996 xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of input, %d left\n", 1997 toconv, written, in->use); 1998 break; 1999 default: 2000 xmlGenericError(xmlGenericErrorContext,"Unknown input conversion failed %d\n", ret); 2001 } 2002 #endif /* DEBUG_ENCODING */ 2003 /* 2004 * Ignore when input buffer is not on a boundary 2005 */ 2006 if (ret == -3) ret = 0; 2007 if (ret == -1) ret = 0; 2008 return(ret); 2009 } 2010 2011 /** 2012 * xmlCharEncFirstLine: 2013 * @handler: char enconding transformation data structure 2014 * @out: an xmlBuffer for the output. 2015 * @in: an xmlBuffer for the input 2016 * 2017 * Front-end for the encoding handler input function, but handle only 2018 * the very first line, i.e. limit itself to 45 chars. 2019 * 2020 * Returns the number of byte written if success, or 2021 * -1 general error 2022 * -2 if the transcoding fails (for *in is not valid utf8 string or 2023 * the result of transformation can't fit into the encoding we want), or 2024 */ 2025 int 2026 xmlCharEncFirstLine(xmlCharEncodingHandler *handler, xmlBufferPtr out, 2027 xmlBufferPtr in) { 2028 return(xmlCharEncFirstLineInt(handler, out, in, -1)); 2029 } 2030 2031 /** 2032 * xmlCharEncInFunc: 2033 * @handler: char encoding transformation data structure 2034 * @out: an xmlBuffer for the output. 2035 * @in: an xmlBuffer for the input 2036 * 2037 * Generic front-end for the encoding handler input function 2038 * 2039 * Returns the number of byte written if success, or 2040 * -1 general error 2041 * -2 if the transcoding fails (for *in is not valid utf8 string or 2042 * the result of transformation can't fit into the encoding we want), or 2043 */ 2044 int 2045 xmlCharEncInFunc(xmlCharEncodingHandler * handler, xmlBufferPtr out, 2046 xmlBufferPtr in) 2047 { 2048 int ret = -2; 2049 int written; 2050 int toconv; 2051 2052 if (handler == NULL) 2053 return (-1); 2054 if (out == NULL) 2055 return (-1); 2056 if (in == NULL) 2057 return (-1); 2058 2059 toconv = in->use; 2060 if (toconv == 0) 2061 return (0); 2062 written = out->size - out->use -1; /* count '\0' */ 2063 if (toconv * 2 >= written) { 2064 xmlBufferGrow(out, out->size + toconv * 2); 2065 written = out->size - out->use - 1; 2066 } 2067 if (handler->input != NULL) { 2068 ret = handler->input(&out->content[out->use], &written, 2069 in->content, &toconv); 2070 xmlBufferShrink(in, toconv); 2071 out->use += written; 2072 out->content[out->use] = 0; 2073 } 2074 #ifdef LIBXML_ICONV_ENABLED 2075 else if (handler->iconv_in != NULL) { 2076 ret = xmlIconvWrapper(handler->iconv_in, &out->content[out->use], 2077 &written, in->content, &toconv); 2078 xmlBufferShrink(in, toconv); 2079 out->use += written; 2080 out->content[out->use] = 0; 2081 if (ret == -1) 2082 ret = -3; 2083 } 2084 #endif /* LIBXML_ICONV_ENABLED */ 2085 #ifdef LIBXML_ICU_ENABLED 2086 else if (handler->uconv_in != NULL) { 2087 ret = xmlUconvWrapper(handler->uconv_in, 1, &out->content[out->use], 2088 &written, in->content, &toconv); 2089 xmlBufferShrink(in, toconv); 2090 out->use += written; 2091 out->content[out->use] = 0; 2092 if (ret == -1) 2093 ret = -3; 2094 } 2095 #endif /* LIBXML_ICU_ENABLED */ 2096 switch (ret) { 2097 case 0: 2098 #ifdef DEBUG_ENCODING 2099 xmlGenericError(xmlGenericErrorContext, 2100 "converted %d bytes to %d bytes of input\n", 2101 toconv, written); 2102 #endif 2103 break; 2104 case -1: 2105 #ifdef DEBUG_ENCODING 2106 xmlGenericError(xmlGenericErrorContext, 2107 "converted %d bytes to %d bytes of input, %d left\n", 2108 toconv, written, in->use); 2109 #endif 2110 break; 2111 case -3: 2112 #ifdef DEBUG_ENCODING 2113 xmlGenericError(xmlGenericErrorContext, 2114 "converted %d bytes to %d bytes of input, %d left\n", 2115 toconv, written, in->use); 2116 #endif 2117 break; 2118 case -2: { 2119 char buf[50]; 2120 2121 snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X", 2122 in->content[0], in->content[1], 2123 in->content[2], in->content[3]); 2124 buf[49] = 0; 2125 xmlEncodingErr(XML_I18N_CONV_FAILED, 2126 "input conversion failed due to input error, bytes %s\n", 2127 buf); 2128 } 2129 } 2130 /* 2131 * Ignore when input buffer is not on a boundary 2132 */ 2133 if (ret == -3) 2134 ret = 0; 2135 return (written? written : ret); 2136 } 2137 2138 /** 2139 * xmlCharEncOutFunc: 2140 * @handler: char enconding transformation data structure 2141 * @out: an xmlBuffer for the output. 2142 * @in: an xmlBuffer for the input 2143 * 2144 * Generic front-end for the encoding handler output function 2145 * a first call with @in == NULL has to be made firs to initiate the 2146 * output in case of non-stateless encoding needing to initiate their 2147 * state or the output (like the BOM in UTF16). 2148 * In case of UTF8 sequence conversion errors for the given encoder, 2149 * the content will be automatically remapped to a CharRef sequence. 2150 * 2151 * Returns the number of byte written if success, or 2152 * -1 general error 2153 * -2 if the transcoding fails (for *in is not valid utf8 string or 2154 * the result of transformation can't fit into the encoding we want), or 2155 */ 2156 int 2157 xmlCharEncOutFunc(xmlCharEncodingHandler *handler, xmlBufferPtr out, 2158 xmlBufferPtr in) { 2159 int ret = -2; 2160 int written; 2161 int writtentot = 0; 2162 int toconv; 2163 int output = 0; 2164 2165 if (handler == NULL) return(-1); 2166 if (out == NULL) return(-1); 2167 2168 retry: 2169 2170 written = out->size - out->use; 2171 2172 if (written > 0) 2173 written--; /* Gennady: count '/0' */ 2174 2175 /* 2176 * First specific handling of in = NULL, i.e. the initialization call 2177 */ 2178 if (in == NULL) { 2179 toconv = 0; 2180 if (handler->output != NULL) { 2181 ret = handler->output(&out->content[out->use], &written, 2182 NULL, &toconv); 2183 if (ret >= 0) { /* Gennady: check return value */ 2184 out->use += written; 2185 out->content[out->use] = 0; 2186 } 2187 } 2188 #ifdef LIBXML_ICONV_ENABLED 2189 else if (handler->iconv_out != NULL) { 2190 ret = xmlIconvWrapper(handler->iconv_out, &out->content[out->use], 2191 &written, NULL, &toconv); 2192 out->use += written; 2193 out->content[out->use] = 0; 2194 } 2195 #endif /* LIBXML_ICONV_ENABLED */ 2196 #ifdef LIBXML_ICU_ENABLED 2197 else if (handler->uconv_out != NULL) { 2198 ret = xmlUconvWrapper(handler->uconv_out, 0, 2199 &out->content[out->use], 2200 &written, NULL, &toconv); 2201 out->use += written; 2202 out->content[out->use] = 0; 2203 } 2204 #endif /* LIBXML_ICU_ENABLED */ 2205 #ifdef DEBUG_ENCODING 2206 xmlGenericError(xmlGenericErrorContext, 2207 "initialized encoder\n"); 2208 #endif 2209 return(0); 2210 } 2211 2212 /* 2213 * Conversion itself. 2214 */ 2215 toconv = in->use; 2216 if (toconv == 0) 2217 return(0); 2218 if (toconv * 4 >= written) { 2219 xmlBufferGrow(out, toconv * 4); 2220 written = out->size - out->use - 1; 2221 } 2222 if (handler->output != NULL) { 2223 ret = handler->output(&out->content[out->use], &written, 2224 in->content, &toconv); 2225 if (written > 0) { 2226 xmlBufferShrink(in, toconv); 2227 out->use += written; 2228 writtentot += written; 2229 } 2230 out->content[out->use] = 0; 2231 } 2232 #ifdef LIBXML_ICONV_ENABLED 2233 else if (handler->iconv_out != NULL) { 2234 ret = xmlIconvWrapper(handler->iconv_out, &out->content[out->use], 2235 &written, in->content, &toconv); 2236 xmlBufferShrink(in, toconv); 2237 out->use += written; 2238 writtentot += written; 2239 out->content[out->use] = 0; 2240 if (ret == -1) { 2241 if (written > 0) { 2242 /* 2243 * Can be a limitation of iconv 2244 */ 2245 goto retry; 2246 } 2247 ret = -3; 2248 } 2249 } 2250 #endif /* LIBXML_ICONV_ENABLED */ 2251 #ifdef LIBXML_ICU_ENABLED 2252 else if (handler->uconv_out != NULL) { 2253 ret = xmlUconvWrapper(handler->uconv_out, 0, 2254 &out->content[out->use], 2255 &written, in->content, &toconv); 2256 xmlBufferShrink(in, toconv); 2257 out->use += written; 2258 writtentot += written; 2259 out->content[out->use] = 0; 2260 if (ret == -1) { 2261 if (written > 0) { 2262 /* 2263 * Can be a limitation of iconv 2264 */ 2265 goto retry; 2266 } 2267 ret = -3; 2268 } 2269 } 2270 #endif /* LIBXML_ICU_ENABLED */ 2271 else { 2272 xmlEncodingErr(XML_I18N_NO_OUTPUT, 2273 "xmlCharEncOutFunc: no output function !\n", NULL); 2274 return(-1); 2275 } 2276 2277 if (ret >= 0) output += ret; 2278 2279 /* 2280 * Attempt to handle error cases 2281 */ 2282 switch (ret) { 2283 case 0: 2284 #ifdef DEBUG_ENCODING 2285 xmlGenericError(xmlGenericErrorContext, 2286 "converted %d bytes to %d bytes of output\n", 2287 toconv, written); 2288 #endif 2289 break; 2290 case -1: 2291 #ifdef DEBUG_ENCODING 2292 xmlGenericError(xmlGenericErrorContext, 2293 "output conversion failed by lack of space\n"); 2294 #endif 2295 break; 2296 case -3: 2297 #ifdef DEBUG_ENCODING 2298 xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of output %d left\n", 2299 toconv, written, in->use); 2300 #endif 2301 break; 2302 case -2: { 2303 int len = in->use; 2304 const xmlChar *utf = (const xmlChar *) in->content; 2305 int cur; 2306 2307 cur = xmlGetUTF8Char(utf, &len); 2308 if (cur > 0) { 2309 xmlChar charref[20]; 2310 2311 #ifdef DEBUG_ENCODING 2312 xmlGenericError(xmlGenericErrorContext, 2313 "handling output conversion error\n"); 2314 xmlGenericError(xmlGenericErrorContext, 2315 "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n", 2316 in->content[0], in->content[1], 2317 in->content[2], in->content[3]); 2318 #endif 2319 /* 2320 * Removes the UTF8 sequence, and replace it by a charref 2321 * and continue the transcoding phase, hoping the error 2322 * did not mangle the encoder state. 2323 */ 2324 snprintf((char *) &charref[0], sizeof(charref), "&#%d;", cur); 2325 xmlBufferShrink(in, len); 2326 xmlBufferAddHead(in, charref, -1); 2327 2328 goto retry; 2329 } else { 2330 char buf[50]; 2331 2332 snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X", 2333 in->content[0], in->content[1], 2334 in->content[2], in->content[3]); 2335 buf[49] = 0; 2336 xmlEncodingErr(XML_I18N_CONV_FAILED, 2337 "output conversion failed due to conv error, bytes %s\n", 2338 buf); 2339 if (in->alloc != XML_BUFFER_ALLOC_IMMUTABLE) 2340 in->content[0] = ' '; 2341 } 2342 break; 2343 } 2344 } 2345 return(ret); 2346 } 2347 2348 /** 2349 * xmlCharEncCloseFunc: 2350 * @handler: char enconding transformation data structure 2351 * 2352 * Generic front-end for encoding handler close function 2353 * 2354 * Returns 0 if success, or -1 in case of error 2355 */ 2356 int 2357 xmlCharEncCloseFunc(xmlCharEncodingHandler *handler) { 2358 int ret = 0; 2359 int tofree = 0; 2360 if (handler == NULL) return(-1); 2361 if (handler->name == NULL) return(-1); 2362 #ifdef LIBXML_ICONV_ENABLED 2363 /* 2364 * Iconv handlers can be used only once, free the whole block. 2365 * and the associated icon resources. 2366 */ 2367 if ((handler->iconv_out != NULL) || (handler->iconv_in != NULL)) { 2368 tofree = 1; 2369 if (handler->iconv_out != NULL) { 2370 if (iconv_close(handler->iconv_out)) 2371 ret = -1; 2372 handler->iconv_out = NULL; 2373 } 2374 if (handler->iconv_in != NULL) { 2375 if (iconv_close(handler->iconv_in)) 2376 ret = -1; 2377 handler->iconv_in = NULL; 2378 } 2379 } 2380 #endif /* LIBXML_ICONV_ENABLED */ 2381 #ifdef LIBXML_ICU_ENABLED 2382 if ((handler->uconv_out != NULL) || (handler->uconv_in != NULL)) { 2383 tofree = 1; 2384 if (handler->uconv_out != NULL) { 2385 closeIcuConverter(handler->uconv_out); 2386 handler->uconv_out = NULL; 2387 } 2388 if (handler->uconv_in != NULL) { 2389 closeIcuConverter(handler->uconv_in); 2390 handler->uconv_in = NULL; 2391 } 2392 } 2393 #endif 2394 if (tofree) { 2395 /* free up only dynamic handlers iconv/uconv */ 2396 if (handler->name != NULL) 2397 xmlFree(handler->name); 2398 handler->name = NULL; 2399 xmlFree(handler); 2400 } 2401 #ifdef DEBUG_ENCODING 2402 if (ret) 2403 xmlGenericError(xmlGenericErrorContext, 2404 "failed to close the encoding handler\n"); 2405 else 2406 xmlGenericError(xmlGenericErrorContext, 2407 "closed the encoding handler\n"); 2408 #endif 2409 2410 return(ret); 2411 } 2412 2413 /** 2414 * xmlByteConsumed: 2415 * @ctxt: an XML parser context 2416 * 2417 * This function provides the current index of the parser relative 2418 * to the start of the current entity. This function is computed in 2419 * bytes from the beginning starting at zero and finishing at the 2420 * size in byte of the file if parsing a file. The function is 2421 * of constant cost if the input is UTF-8 but can be costly if run 2422 * on non-UTF-8 input. 2423 * 2424 * Returns the index in bytes from the beginning of the entity or -1 2425 * in case the index could not be computed. 2426 */ 2427 long 2428 xmlByteConsumed(xmlParserCtxtPtr ctxt) { 2429 xmlParserInputPtr in; 2430 2431 if (ctxt == NULL) return(-1); 2432 in = ctxt->input; 2433 if (in == NULL) return(-1); 2434 if ((in->buf != NULL) && (in->buf->encoder != NULL)) { 2435 unsigned int unused = 0; 2436 xmlCharEncodingHandler * handler = in->buf->encoder; 2437 /* 2438 * Encoding conversion, compute the number of unused original 2439 * bytes from the input not consumed and substract that from 2440 * the raw consumed value, this is not a cheap operation 2441 */ 2442 if (in->end - in->cur > 0) { 2443 unsigned char convbuf[32000]; 2444 const unsigned char *cur = (const unsigned char *)in->cur; 2445 int toconv = in->end - in->cur, written = 32000; 2446 2447 int ret; 2448 2449 if (handler->output != NULL) { 2450 do { 2451 toconv = in->end - cur; 2452 written = 32000; 2453 ret = handler->output(&convbuf[0], &written, 2454 cur, &toconv); 2455 if (ret == -1) return(-1); 2456 unused += written; 2457 cur += toconv; 2458 } while (ret == -2); 2459 #ifdef LIBXML_ICONV_ENABLED 2460 } else if (handler->iconv_out != NULL) { 2461 do { 2462 toconv = in->end - cur; 2463 written = 32000; 2464 ret = xmlIconvWrapper(handler->iconv_out, &convbuf[0], 2465 &written, cur, &toconv); 2466 if (ret < 0) { 2467 if (written > 0) 2468 ret = -2; 2469 else 2470 return(-1); 2471 } 2472 unused += written; 2473 cur += toconv; 2474 } while (ret == -2); 2475 #endif 2476 #ifdef LIBXML_ICU_ENABLED 2477 } else if (handler->uconv_out != NULL) { 2478 do { 2479 toconv = in->end - cur; 2480 written = 32000; 2481 ret = xmlUconvWrapper(handler->uconv_out, 0, &convbuf[0], 2482 &written, cur, &toconv); 2483 if (ret < 0) { 2484 if (written > 0) 2485 ret = -2; 2486 else 2487 return(-1); 2488 } 2489 unused += written; 2490 cur += toconv; 2491 } while (ret == -2); 2492 #endif 2493 } else { 2494 /* could not find a converter */ 2495 return(-1); 2496 } 2497 } 2498 if (in->buf->rawconsumed < unused) 2499 return(-1); 2500 return(in->buf->rawconsumed - unused); 2501 } 2502 return(in->consumed + (in->cur - in->base)); 2503 } 2504 2505 #if !defined(LIBXML_ICONV_ENABLED) && !defined(LIBXML_ICU_ENABLED) 2506 #ifdef LIBXML_ISO8859X_ENABLED 2507 2508 /** 2509 * UTF8ToISO8859x: 2510 * @out: a pointer to an array of bytes to store the result 2511 * @outlen: the length of @out 2512 * @in: a pointer to an array of UTF-8 chars 2513 * @inlen: the length of @in 2514 * @xlattable: the 2-level transcoding table 2515 * 2516 * Take a block of UTF-8 chars in and try to convert it to an ISO 8859-* 2517 * block of chars out. 2518 * 2519 * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise 2520 * The value of @inlen after return is the number of octets consumed 2521 * as the return value is positive, else unpredictable. 2522 * The value of @outlen after return is the number of ocetes consumed. 2523 */ 2524 static int 2525 UTF8ToISO8859x(unsigned char* out, int *outlen, 2526 const unsigned char* in, int *inlen, 2527 unsigned char const *xlattable) { 2528 const unsigned char* outstart = out; 2529 const unsigned char* inend; 2530 const unsigned char* instart = in; 2531 const unsigned char* processed = in; 2532 2533 if ((out == NULL) || (outlen == NULL) || (inlen == NULL) || 2534 (xlattable == NULL)) 2535 return(-1); 2536 if (in == NULL) { 2537 /* 2538 * initialization nothing to do 2539 */ 2540 *outlen = 0; 2541 *inlen = 0; 2542 return(0); 2543 } 2544 inend = in + (*inlen); 2545 while (in < inend) { 2546 unsigned char d = *in++; 2547 if (d < 0x80) { 2548 *out++ = d; 2549 } else if (d < 0xC0) { 2550 /* trailing byte in leading position */ 2551 *outlen = out - outstart; 2552 *inlen = processed - instart; 2553 return(-2); 2554 } else if (d < 0xE0) { 2555 unsigned char c; 2556 if (!(in < inend)) { 2557 /* trailing byte not in input buffer */ 2558 *outlen = out - outstart; 2559 *inlen = processed - instart; 2560 return(-3); 2561 } 2562 c = *in++; 2563 if ((c & 0xC0) != 0x80) { 2564 /* not a trailing byte */ 2565 *outlen = out - outstart; 2566 *inlen = processed - instart; 2567 return(-2); 2568 } 2569 c = c & 0x3F; 2570 d = d & 0x1F; 2571 d = xlattable [48 + c + xlattable [d] * 64]; 2572 if (d == 0) { 2573 /* not in character set */ 2574 *outlen = out - outstart; 2575 *inlen = processed - instart; 2576 return(-2); 2577 } 2578 *out++ = d; 2579 } else if (d < 0xF0) { 2580 unsigned char c1; 2581 unsigned char c2; 2582 if (!(in < inend - 1)) { 2583 /* trailing bytes not in input buffer */ 2584 *outlen = out - outstart; 2585 *inlen = processed - instart; 2586 return(-3); 2587 } 2588 c1 = *in++; 2589 if ((c1 & 0xC0) != 0x80) { 2590 /* not a trailing byte (c1) */ 2591 *outlen = out - outstart; 2592 *inlen = processed - instart; 2593 return(-2); 2594 } 2595 c2 = *in++; 2596 if ((c2 & 0xC0) != 0x80) { 2597 /* not a trailing byte (c2) */ 2598 *outlen = out - outstart; 2599 *inlen = processed - instart; 2600 return(-2); 2601 } 2602 c1 = c1 & 0x3F; 2603 c2 = c2 & 0x3F; 2604 d = d & 0x0F; 2605 d = xlattable [48 + c2 + xlattable [48 + c1 + 2606 xlattable [32 + d] * 64] * 64]; 2607 if (d == 0) { 2608 /* not in character set */ 2609 *outlen = out - outstart; 2610 *inlen = processed - instart; 2611 return(-2); 2612 } 2613 *out++ = d; 2614 } else { 2615 /* cannot transcode >= U+010000 */ 2616 *outlen = out - outstart; 2617 *inlen = processed - instart; 2618 return(-2); 2619 } 2620 processed = in; 2621 } 2622 *outlen = out - outstart; 2623 *inlen = processed - instart; 2624 return(*outlen); 2625 } 2626 2627 /** 2628 * ISO8859xToUTF8 2629 * @out: a pointer to an array of bytes to store the result 2630 * @outlen: the length of @out 2631 * @in: a pointer to an array of ISO Latin 1 chars 2632 * @inlen: the length of @in 2633 * 2634 * Take a block of ISO 8859-* chars in and try to convert it to an UTF-8 2635 * block of chars out. 2636 * Returns 0 if success, or -1 otherwise 2637 * The value of @inlen after return is the number of octets consumed 2638 * The value of @outlen after return is the number of ocetes produced. 2639 */ 2640 static int 2641 ISO8859xToUTF8(unsigned char* out, int *outlen, 2642 const unsigned char* in, int *inlen, 2643 unsigned short const *unicodetable) { 2644 unsigned char* outstart = out; 2645 unsigned char* outend; 2646 const unsigned char* instart = in; 2647 const unsigned char* inend; 2648 const unsigned char* instop; 2649 unsigned int c; 2650 2651 if ((out == NULL) || (outlen == NULL) || (inlen == NULL) || 2652 (in == NULL) || (unicodetable == NULL)) 2653 return(-1); 2654 outend = out + *outlen; 2655 inend = in + *inlen; 2656 instop = inend; 2657 2658 while ((in < inend) && (out < outend - 2)) { 2659 if (*in >= 0x80) { 2660 c = unicodetable [*in - 0x80]; 2661 if (c == 0) { 2662 /* undefined code point */ 2663 *outlen = out - outstart; 2664 *inlen = in - instart; 2665 return (-1); 2666 } 2667 if (c < 0x800) { 2668 *out++ = ((c >> 6) & 0x1F) | 0xC0; 2669 *out++ = (c & 0x3F) | 0x80; 2670 } else { 2671 *out++ = ((c >> 12) & 0x0F) | 0xE0; 2672 *out++ = ((c >> 6) & 0x3F) | 0x80; 2673 *out++ = (c & 0x3F) | 0x80; 2674 } 2675 ++in; 2676 } 2677 if (instop - in > outend - out) instop = in + (outend - out); 2678 while ((*in < 0x80) && (in < instop)) { 2679 *out++ = *in++; 2680 } 2681 } 2682 if ((in < inend) && (out < outend) && (*in < 0x80)) { 2683 *out++ = *in++; 2684 } 2685 if ((in < inend) && (out < outend) && (*in < 0x80)) { 2686 *out++ = *in++; 2687 } 2688 *outlen = out - outstart; 2689 *inlen = in - instart; 2690 return (*outlen); 2691 } 2692 2693 2694 /************************************************************************ 2695 * Lookup tables for ISO-8859-2..ISO-8859-16 transcoding * 2696 ************************************************************************/ 2697 2698 static unsigned short const xmlunicodetable_ISO8859_2 [128] = { 2699 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 2700 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 2701 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 2702 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 2703 0x00a0, 0x0104, 0x02d8, 0x0141, 0x00a4, 0x013d, 0x015a, 0x00a7, 2704 0x00a8, 0x0160, 0x015e, 0x0164, 0x0179, 0x00ad, 0x017d, 0x017b, 2705 0x00b0, 0x0105, 0x02db, 0x0142, 0x00b4, 0x013e, 0x015b, 0x02c7, 2706 0x00b8, 0x0161, 0x015f, 0x0165, 0x017a, 0x02dd, 0x017e, 0x017c, 2707 0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7, 2708 0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e, 2709 0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7, 2710 0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df, 2711 0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7, 2712 0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f, 2713 0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7, 2714 0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9, 2715 }; 2716 2717 static unsigned char const xmltranscodetable_ISO8859_2 [48 + 6 * 64] = { 2718 "\x00\x00\x01\x05\x02\x04\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00" 2719 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2720 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2721 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2722 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2723 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2724 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2725 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 2726 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 2727 "\xa0\x00\x00\x00\xa4\x00\x00\xa7\xa8\x00\x00\x00\x00\xad\x00\x00" 2728 "\xb0\x00\x00\x00\xb4\x00\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00" 2729 "\x00\x00\xc3\xe3\xa1\xb1\xc6\xe6\x00\x00\x00\x00\xc8\xe8\xcf\xef" 2730 "\xd0\xf0\x00\x00\x00\x00\x00\x00\xca\xea\xcc\xec\x00\x00\x00\x00" 2731 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2732 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc5\xe5\x00\x00\xa5\xb5\x00" 2733 "\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00" 2734 "\x00\x00\x00\x00\x00\x00\x00\x00\xa2\xff\x00\xb2\x00\xbd\x00\x00" 2735 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2736 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2737 "\x00\xa3\xb3\xd1\xf1\x00\x00\xd2\xf2\x00\x00\x00\x00\x00\x00\x00" 2738 "\xd5\xf5\x00\x00\xc0\xe0\x00\x00\xd8\xf8\xa6\xb6\x00\x00\xaa\xba" 2739 "\xa9\xb9\xde\xfe\xab\xbb\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xf9" 2740 "\xdb\xfb\x00\x00\x00\x00\x00\x00\x00\xac\xbc\xaf\xbf\xae\xbe\x00" 2741 "\x00\xc1\xc2\x00\xc4\x00\x00\xc7\x00\xc9\x00\xcb\x00\xcd\xce\x00" 2742 "\x00\x00\x00\xd3\xd4\x00\xd6\xd7\x00\x00\xda\x00\xdc\xdd\x00\xdf" 2743 "\x00\xe1\xe2\x00\xe4\x00\x00\xe7\x00\xe9\x00\xeb\x00\xed\xee\x00" 2744 "\x00\x00\x00\xf3\xf4\x00\xf6\xf7\x00\x00\xfa\x00\xfc\xfd\x00\x00" 2745 }; 2746 2747 static unsigned short const xmlunicodetable_ISO8859_3 [128] = { 2748 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 2749 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 2750 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 2751 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 2752 0x00a0, 0x0126, 0x02d8, 0x00a3, 0x00a4, 0x0000, 0x0124, 0x00a7, 2753 0x00a8, 0x0130, 0x015e, 0x011e, 0x0134, 0x00ad, 0x0000, 0x017b, 2754 0x00b0, 0x0127, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x0125, 0x00b7, 2755 0x00b8, 0x0131, 0x015f, 0x011f, 0x0135, 0x00bd, 0x0000, 0x017c, 2756 0x00c0, 0x00c1, 0x00c2, 0x0000, 0x00c4, 0x010a, 0x0108, 0x00c7, 2757 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 2758 0x0000, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x0120, 0x00d6, 0x00d7, 2759 0x011c, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x016c, 0x015c, 0x00df, 2760 0x00e0, 0x00e1, 0x00e2, 0x0000, 0x00e4, 0x010b, 0x0109, 0x00e7, 2761 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 2762 0x0000, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x0121, 0x00f6, 0x00f7, 2763 0x011d, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x016d, 0x015d, 0x02d9, 2764 }; 2765 2766 static unsigned char const xmltranscodetable_ISO8859_3 [48 + 7 * 64] = { 2767 "\x04\x00\x01\x06\x02\x05\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00" 2768 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2769 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2770 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2771 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2772 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2773 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2774 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 2775 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 2776 "\xa0\x00\x00\xa3\xa4\x00\x00\xa7\xa8\x00\x00\x00\x00\xad\x00\x00" 2777 "\xb0\x00\xb2\xb3\xb4\xb5\x00\xb7\xb8\x00\x00\x00\x00\xbd\x00\x00" 2778 "\x00\x00\x00\x00\x00\x00\x00\x00\xc6\xe6\xc5\xe5\x00\x00\x00\x00" 2779 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xf8\xab\xbb" 2780 "\xd5\xf5\x00\x00\xa6\xb6\xa1\xb1\x00\x00\x00\x00\x00\x00\x00\x00" 2781 "\xa9\xb9\x00\x00\xac\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2782 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2783 "\x00\x00\x00\x00\x00\x00\x00\x00\xa2\xff\x00\x00\x00\x00\x00\x00" 2784 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2785 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2786 "\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2787 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2788 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2789 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2790 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2791 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\xfe\xaa\xba" 2792 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\xfd\x00\x00" 2793 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\xbf\x00\x00\x00" 2794 "\xc0\xc1\xc2\x00\xc4\x00\x00\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" 2795 "\x00\xd1\xd2\xd3\xd4\x00\xd6\xd7\x00\xd9\xda\xdb\xdc\x00\x00\xdf" 2796 "\xe0\xe1\xe2\x00\xe4\x00\x00\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" 2797 "\x00\xf1\xf2\xf3\xf4\x00\xf6\xf7\x00\xf9\xfa\xfb\xfc\x00\x00\x00" 2798 }; 2799 2800 static unsigned short const xmlunicodetable_ISO8859_4 [128] = { 2801 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 2802 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 2803 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 2804 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 2805 0x00a0, 0x0104, 0x0138, 0x0156, 0x00a4, 0x0128, 0x013b, 0x00a7, 2806 0x00a8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00ad, 0x017d, 0x00af, 2807 0x00b0, 0x0105, 0x02db, 0x0157, 0x00b4, 0x0129, 0x013c, 0x02c7, 2808 0x00b8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014a, 0x017e, 0x014b, 2809 0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e, 2810 0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x012a, 2811 0x0110, 0x0145, 0x014c, 0x0136, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 2812 0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x0168, 0x016a, 0x00df, 2813 0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f, 2814 0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x012b, 2815 0x0111, 0x0146, 0x014d, 0x0137, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 2816 0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x0169, 0x016b, 0x02d9, 2817 }; 2818 2819 static unsigned char const xmltranscodetable_ISO8859_4 [48 + 6 * 64] = { 2820 "\x00\x00\x01\x05\x02\x03\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00" 2821 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2822 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2823 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2824 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2825 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2826 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2827 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 2828 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 2829 "\xa0\x00\x00\x00\xa4\x00\x00\xa7\xa8\x00\x00\x00\x00\xad\x00\xaf" 2830 "\xb0\x00\x00\x00\xb4\x00\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00" 2831 "\xc0\xe0\x00\x00\xa1\xb1\x00\x00\x00\x00\x00\x00\xc8\xe8\x00\x00" 2832 "\xd0\xf0\xaa\xba\x00\x00\xcc\xec\xca\xea\x00\x00\x00\x00\x00\x00" 2833 "\x00\x00\xab\xbb\x00\x00\x00\x00\xa5\xb5\xcf\xef\x00\x00\xc7\xe7" 2834 "\x00\x00\x00\x00\x00\x00\xd3\xf3\xa2\x00\x00\xa6\xb6\x00\x00\x00" 2835 "\x00\x00\x00\x00\x00\xd1\xf1\x00\x00\x00\xbd\xbf\xd2\xf2\x00\x00" 2836 "\x00\x00\x00\x00\x00\x00\xa3\xb3\x00\x00\x00\x00\x00\x00\x00\x00" 2837 "\xa9\xb9\x00\x00\x00\x00\xac\xbc\xdd\xfd\xde\xfe\x00\x00\x00\x00" 2838 "\x00\x00\xd9\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\xbe\x00" 2839 "\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00" 2840 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\xb2\x00\x00\x00\x00" 2841 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2842 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2843 "\x00\xc1\xc2\xc3\xc4\xc5\xc6\x00\x00\xc9\x00\xcb\x00\xcd\xce\x00" 2844 "\x00\x00\x00\x00\xd4\xd5\xd6\xd7\xd8\x00\xda\xdb\xdc\x00\x00\xdf" 2845 "\x00\xe1\xe2\xe3\xe4\xe5\xe6\x00\x00\xe9\x00\xeb\x00\xed\xee\x00" 2846 "\x00\x00\x00\x00\xf4\xf5\xf6\xf7\xf8\x00\xfa\xfb\xfc\x00\x00\x00" 2847 }; 2848 2849 static unsigned short const xmlunicodetable_ISO8859_5 [128] = { 2850 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 2851 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 2852 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 2853 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 2854 0x00a0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407, 2855 0x0408, 0x0409, 0x040a, 0x040b, 0x040c, 0x00ad, 0x040e, 0x040f, 2856 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 2857 0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f, 2858 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 2859 0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f, 2860 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 2861 0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, 0x043f, 2862 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 2863 0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f, 2864 0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 2865 0x0458, 0x0459, 0x045a, 0x045b, 0x045c, 0x00a7, 0x045e, 0x045f, 2866 }; 2867 2868 static unsigned char const xmltranscodetable_ISO8859_5 [48 + 6 * 64] = { 2869 "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2870 "\x02\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2871 "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2872 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2873 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2874 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2875 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2876 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 2877 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 2878 "\xa0\x00\x00\x00\x00\x00\x00\xfd\x00\x00\x00\x00\x00\xad\x00\x00" 2879 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2880 "\x00\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\x00\xae\xaf" 2881 "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf" 2882 "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" 2883 "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf" 2884 "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" 2885 "\x00\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\x00\xfe\xff" 2886 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2887 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2888 "\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2889 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2890 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2891 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2892 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2893 "\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2894 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2895 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2896 }; 2897 2898 static unsigned short const xmlunicodetable_ISO8859_6 [128] = { 2899 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 2900 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 2901 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 2902 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 2903 0x00a0, 0x0000, 0x0000, 0x0000, 0x00a4, 0x0000, 0x0000, 0x0000, 2904 0x0000, 0x0000, 0x0000, 0x0000, 0x060c, 0x00ad, 0x0000, 0x0000, 2905 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 2906 0x0000, 0x0000, 0x0000, 0x061b, 0x0000, 0x0000, 0x0000, 0x061f, 2907 0x0000, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627, 2908 0x0628, 0x0629, 0x062a, 0x062b, 0x062c, 0x062d, 0x062e, 0x062f, 2909 0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637, 2910 0x0638, 0x0639, 0x063a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 2911 0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 2912 0x0648, 0x0649, 0x064a, 0x064b, 0x064c, 0x064d, 0x064e, 0x064f, 2913 0x0650, 0x0651, 0x0652, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 2914 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 2915 }; 2916 2917 static unsigned char const xmltranscodetable_ISO8859_6 [48 + 5 * 64] = { 2918 "\x02\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2919 "\x00\x00\x00\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00" 2920 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2921 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2922 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2923 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2924 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2925 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 2926 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 2927 "\xa0\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00" 2928 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2929 "\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2930 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2931 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2932 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2933 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00" 2934 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbf" 2935 "\x00\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" 2936 "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\x00\x00\x00\x00\x00" 2937 "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" 2938 "\xf0\xf1\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2939 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2940 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2941 }; 2942 2943 static unsigned short const xmlunicodetable_ISO8859_7 [128] = { 2944 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 2945 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 2946 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 2947 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 2948 0x00a0, 0x2018, 0x2019, 0x00a3, 0x0000, 0x0000, 0x00a6, 0x00a7, 2949 0x00a8, 0x00a9, 0x0000, 0x00ab, 0x00ac, 0x00ad, 0x0000, 0x2015, 2950 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x0384, 0x0385, 0x0386, 0x00b7, 2951 0x0388, 0x0389, 0x038a, 0x00bb, 0x038c, 0x00bd, 0x038e, 0x038f, 2952 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 2953 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f, 2954 0x03a0, 0x03a1, 0x0000, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, 2955 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af, 2956 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7, 2957 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf, 2958 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7, 2959 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, 0x0000, 2960 }; 2961 2962 static unsigned char const xmltranscodetable_ISO8859_7 [48 + 7 * 64] = { 2963 "\x04\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x06" 2964 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2965 "\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2966 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2967 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2968 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2969 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2970 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 2971 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 2972 "\xa0\x00\x00\xa3\x00\x00\xa6\xa7\xa8\xa9\x00\xab\xac\xad\x00\x00" 2973 "\xb0\xb1\xb2\xb3\x00\x00\x00\xb7\x00\x00\x00\xbb\x00\xbd\x00\x00" 2974 "\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2975 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2976 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2977 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2978 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2979 "\x00\x00\x00\x00\x00\xaf\x00\x00\xa1\xa2\x00\x00\x00\x00\x00\x00" 2980 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2981 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2982 "\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2983 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2984 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2985 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2986 "\x00\x00\x00\x00\xb4\xb5\xb6\x00\xb8\xb9\xba\x00\xbc\x00\xbe\xbf" 2987 "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" 2988 "\xd0\xd1\x00\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf" 2989 "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" 2990 "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\x00" 2991 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2992 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2993 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 2994 }; 2995 2996 static unsigned short const xmlunicodetable_ISO8859_8 [128] = { 2997 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 2998 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 2999 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 3000 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 3001 0x00a0, 0x0000, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 3002 0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af, 3003 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 3004 0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x0000, 3005 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 3006 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 3007 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 3008 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2017, 3009 0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7, 3010 0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df, 3011 0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7, 3012 0x05e8, 0x05e9, 0x05ea, 0x0000, 0x0000, 0x200e, 0x200f, 0x0000, 3013 }; 3014 3015 static unsigned char const xmltranscodetable_ISO8859_8 [48 + 7 * 64] = { 3016 "\x02\x00\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3017 "\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00" 3018 "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3019 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3020 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3021 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3022 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3023 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 3024 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 3025 "\xa0\x00\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\x00\xab\xac\xad\xae\xaf" 3026 "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\x00\xbb\xbc\xbd\xbe\x00" 3027 "\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3028 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3029 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3030 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3031 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3032 "\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x00" 3033 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3034 "\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00" 3035 "\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3036 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3037 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3038 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3039 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xfe" 3040 "\x00\x00\x00\x00\x00\x00\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00" 3041 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3042 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3043 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3044 "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" 3045 "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\x00\x00\x00\x00\x00" 3046 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3047 }; 3048 3049 static unsigned short const xmlunicodetable_ISO8859_9 [128] = { 3050 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 3051 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 3052 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 3053 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 3054 0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 3055 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af, 3056 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 3057 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf, 3058 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 3059 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 3060 0x011e, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 3061 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0130, 0x015e, 0x00df, 3062 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 3063 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 3064 0x011f, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 3065 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0131, 0x015f, 0x00ff, 3066 }; 3067 3068 static unsigned char const xmltranscodetable_ISO8859_9 [48 + 5 * 64] = { 3069 "\x00\x00\x01\x02\x03\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3070 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3071 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3072 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3073 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3074 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3075 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3076 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 3077 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 3078 "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf" 3079 "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf" 3080 "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" 3081 "\x00\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\x00\x00\xdf" 3082 "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" 3083 "\x00\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\x00\x00\xff" 3084 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3085 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\xf0" 3086 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3087 "\xdd\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3088 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3089 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\xfe" 3090 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3091 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3092 }; 3093 3094 static unsigned short const xmlunicodetable_ISO8859_10 [128] = { 3095 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 3096 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 3097 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 3098 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 3099 0x00a0, 0x0104, 0x0112, 0x0122, 0x012a, 0x0128, 0x0136, 0x00a7, 3100 0x013b, 0x0110, 0x0160, 0x0166, 0x017d, 0x00ad, 0x016a, 0x014a, 3101 0x00b0, 0x0105, 0x0113, 0x0123, 0x012b, 0x0129, 0x0137, 0x00b7, 3102 0x013c, 0x0111, 0x0161, 0x0167, 0x017e, 0x2015, 0x016b, 0x014b, 3103 0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e, 3104 0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x00cf, 3105 0x00d0, 0x0145, 0x014c, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x0168, 3106 0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 3107 0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f, 3108 0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x00ef, 3109 0x00f0, 0x0146, 0x014d, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x0169, 3110 0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x0138, 3111 }; 3112 3113 static unsigned char const xmltranscodetable_ISO8859_10 [48 + 7 * 64] = { 3114 "\x00\x00\x01\x06\x02\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3115 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3116 "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3117 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3118 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3119 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3120 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3121 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 3122 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 3123 "\xa0\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x00\x00\xad\x00\x00" 3124 "\xb0\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00" 3125 "\xc0\xe0\x00\x00\xa1\xb1\x00\x00\x00\x00\x00\x00\xc8\xe8\x00\x00" 3126 "\xa9\xb9\xa2\xb2\x00\x00\xcc\xec\xca\xea\x00\x00\x00\x00\x00\x00" 3127 "\x00\x00\xa3\xb3\x00\x00\x00\x00\xa5\xb5\xa4\xb4\x00\x00\xc7\xe7" 3128 "\x00\x00\x00\x00\x00\x00\xa6\xb6\xff\x00\x00\xa8\xb8\x00\x00\x00" 3129 "\x00\x00\x00\x00\x00\xd1\xf1\x00\x00\x00\xaf\xbf\xd2\xf2\x00\x00" 3130 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3131 "\xaa\xba\x00\x00\x00\x00\xab\xbb\xd7\xf7\xae\xbe\x00\x00\x00\x00" 3132 "\x00\x00\xd9\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\xbc\x00" 3133 "\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3134 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3135 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3136 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3137 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3138 "\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3139 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3140 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3141 "\x00\xc1\xc2\xc3\xc4\xc5\xc6\x00\x00\xc9\x00\xcb\x00\xcd\xce\xcf" 3142 "\xd0\x00\x00\xd3\xd4\xd5\xd6\x00\xd8\x00\xda\xdb\xdc\xdd\xde\xdf" 3143 "\x00\xe1\xe2\xe3\xe4\xe5\xe6\x00\x00\xe9\x00\xeb\x00\xed\xee\xef" 3144 "\xf0\x00\x00\xf3\xf4\xf5\xf6\x00\xf8\x00\xfa\xfb\xfc\xfd\xfe\x00" 3145 }; 3146 3147 static unsigned short const xmlunicodetable_ISO8859_11 [128] = { 3148 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 3149 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 3150 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 3151 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 3152 0x00a0, 0x0e01, 0x0e02, 0x0e03, 0x0e04, 0x0e05, 0x0e06, 0x0e07, 3153 0x0e08, 0x0e09, 0x0e0a, 0x0e0b, 0x0e0c, 0x0e0d, 0x0e0e, 0x0e0f, 3154 0x0e10, 0x0e11, 0x0e12, 0x0e13, 0x0e14, 0x0e15, 0x0e16, 0x0e17, 3155 0x0e18, 0x0e19, 0x0e1a, 0x0e1b, 0x0e1c, 0x0e1d, 0x0e1e, 0x0e1f, 3156 0x0e20, 0x0e21, 0x0e22, 0x0e23, 0x0e24, 0x0e25, 0x0e26, 0x0e27, 3157 0x0e28, 0x0e29, 0x0e2a, 0x0e2b, 0x0e2c, 0x0e2d, 0x0e2e, 0x0e2f, 3158 0x0e30, 0x0e31, 0x0e32, 0x0e33, 0x0e34, 0x0e35, 0x0e36, 0x0e37, 3159 0x0e38, 0x0e39, 0x0e3a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0e3f, 3160 0x0e40, 0x0e41, 0x0e42, 0x0e43, 0x0e44, 0x0e45, 0x0e46, 0x0e47, 3161 0x0e48, 0x0e49, 0x0e4a, 0x0e4b, 0x0e4c, 0x0e4d, 0x0e4e, 0x0e4f, 3162 0x0e50, 0x0e51, 0x0e52, 0x0e53, 0x0e54, 0x0e55, 0x0e56, 0x0e57, 3163 0x0e58, 0x0e59, 0x0e5a, 0x0e5b, 0x0000, 0x0000, 0x0000, 0x0000, 3164 }; 3165 3166 static unsigned char const xmltranscodetable_ISO8859_11 [48 + 6 * 64] = { 3167 "\x04\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3168 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3169 "\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3170 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3171 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3172 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3173 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3174 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 3175 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 3176 "\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3177 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3178 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3179 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3180 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3181 "\x00\x00\x00\x00\x00\x00\x00\x00\x03\x05\x00\x00\x00\x00\x00\x00" 3182 "\x00\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf" 3183 "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf" 3184 "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" 3185 "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\x00\x00\x00\x00\xdf" 3186 "\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3187 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3188 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3189 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3190 "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" 3191 "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\x00\x00\x00\x00" 3192 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3193 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3194 }; 3195 3196 static unsigned short const xmlunicodetable_ISO8859_13 [128] = { 3197 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 3198 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 3199 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 3200 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 3201 0x00a0, 0x201d, 0x00a2, 0x00a3, 0x00a4, 0x201e, 0x00a6, 0x00a7, 3202 0x00d8, 0x00a9, 0x0156, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00c6, 3203 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x201c, 0x00b5, 0x00b6, 0x00b7, 3204 0x00f8, 0x00b9, 0x0157, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00e6, 3205 0x0104, 0x012e, 0x0100, 0x0106, 0x00c4, 0x00c5, 0x0118, 0x0112, 3206 0x010c, 0x00c9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012a, 0x013b, 3207 0x0160, 0x0143, 0x0145, 0x00d3, 0x014c, 0x00d5, 0x00d6, 0x00d7, 3208 0x0172, 0x0141, 0x015a, 0x016a, 0x00dc, 0x017b, 0x017d, 0x00df, 3209 0x0105, 0x012f, 0x0101, 0x0107, 0x00e4, 0x00e5, 0x0119, 0x0113, 3210 0x010d, 0x00e9, 0x017a, 0x0117, 0x0123, 0x0137, 0x012b, 0x013c, 3211 0x0161, 0x0144, 0x0146, 0x00f3, 0x014d, 0x00f5, 0x00f6, 0x00f7, 3212 0x0173, 0x0142, 0x015b, 0x016b, 0x00fc, 0x017c, 0x017e, 0x2019, 3213 }; 3214 3215 static unsigned char const xmltranscodetable_ISO8859_13 [48 + 7 * 64] = { 3216 "\x00\x00\x01\x04\x06\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3217 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3218 "\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3219 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3220 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3221 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3222 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3223 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 3224 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 3225 "\xa0\x00\xa2\xa3\xa4\x00\xa6\xa7\x00\xa9\x00\xab\xac\xad\xae\x00" 3226 "\xb0\xb1\xb2\xb3\x00\xb5\xb6\xb7\x00\xb9\x00\xbb\xbc\xbd\xbe\x00" 3227 "\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3228 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3229 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3230 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3231 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3232 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\xb4\xa1\xa5\x00" 3233 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3234 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3235 "\x00\x00\x00\x00\xc4\xc5\xaf\x00\x00\xc9\x00\x00\x00\x00\x00\x00" 3236 "\x00\x00\x00\xd3\x00\xd5\xd6\xd7\xa8\x00\x00\x00\xdc\x00\x00\xdf" 3237 "\x00\x00\x00\x00\xe4\xe5\xbf\x00\x00\xe9\x00\x00\x00\x00\x00\x00" 3238 "\x00\x00\x00\xf3\x00\xf5\xf6\xf7\xb8\x00\x00\x00\xfc\x00\x00\x00" 3239 "\x00\xd9\xf9\xd1\xf1\xd2\xf2\x00\x00\x00\x00\x00\xd4\xf4\x00\x00" 3240 "\x00\x00\x00\x00\x00\x00\xaa\xba\x00\x00\xda\xfa\x00\x00\x00\x00" 3241 "\xd0\xf0\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfb\x00\x00\x00\x00" 3242 "\x00\x00\xd8\xf8\x00\x00\x00\x00\x00\xca\xea\xdd\xfd\xde\xfe\x00" 3243 "\xc2\xe2\x00\x00\xc0\xe0\xc3\xe3\x00\x00\x00\x00\xc8\xe8\x00\x00" 3244 "\x00\x00\xc7\xe7\x00\x00\xcb\xeb\xc6\xe6\x00\x00\x00\x00\x00\x00" 3245 "\x00\x00\xcc\xec\x00\x00\x00\x00\x00\x00\xce\xee\x00\x00\xc1\xe1" 3246 "\x00\x00\x00\x00\x00\x00\xcd\xed\x00\x00\x00\xcf\xef\x00\x00\x00" 3247 }; 3248 3249 static unsigned short const xmlunicodetable_ISO8859_14 [128] = { 3250 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 3251 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 3252 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 3253 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 3254 0x00a0, 0x1e02, 0x1e03, 0x00a3, 0x010a, 0x010b, 0x1e0a, 0x00a7, 3255 0x1e80, 0x00a9, 0x1e82, 0x1e0b, 0x1ef2, 0x00ad, 0x00ae, 0x0178, 3256 0x1e1e, 0x1e1f, 0x0120, 0x0121, 0x1e40, 0x1e41, 0x00b6, 0x1e56, 3257 0x1e81, 0x1e57, 0x1e83, 0x1e60, 0x1ef3, 0x1e84, 0x1e85, 0x1e61, 3258 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 3259 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 3260 0x0174, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x1e6a, 3261 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x0176, 0x00df, 3262 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 3263 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 3264 0x0175, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x1e6b, 3265 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x0177, 0x00ff, 3266 }; 3267 3268 static unsigned char const xmltranscodetable_ISO8859_14 [48 + 10 * 64] = { 3269 "\x00\x00\x01\x09\x04\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3270 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3271 "\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3272 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3273 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3274 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3275 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3276 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 3277 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 3278 "\xa0\x00\x00\xa3\x00\x00\x00\xa7\x00\xa9\x00\x00\x00\xad\xae\x00" 3279 "\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3280 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3281 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3282 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3283 "\x00\x00\x00\x00\x00\x00\x00\x00\x03\x08\x05\x06\x00\x00\x00\x00" 3284 "\x00\x00\xa1\xa2\x00\x00\x00\x00\x00\x00\xa6\xab\x00\x00\x00\x00" 3285 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xb1" 3286 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3287 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3288 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\xa5\x00\x00\x00\x00" 3289 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3290 "\xb2\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3291 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3292 "\xa8\xb8\xaa\xba\xbd\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3293 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3294 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3295 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3296 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3297 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3298 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3299 "\x00\x00\xac\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3300 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3301 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3302 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3303 "\x00\x00\x00\x00\xd0\xf0\xde\xfe\xaf\x00\x00\x00\x00\x00\x00\x00" 3304 "\xb4\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3305 "\x00\x00\x00\x00\x00\x00\xb7\xb9\x00\x00\x00\x00\x00\x00\x00\x00" 3306 "\xbb\xbf\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xf7\x00\x00\x00\x00" 3307 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3308 "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" 3309 "\x00\xd1\xd2\xd3\xd4\xd5\xd6\x00\xd8\xd9\xda\xdb\xdc\xdd\x00\xdf" 3310 "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" 3311 "\x00\xf1\xf2\xf3\xf4\xf5\xf6\x00\xf8\xf9\xfa\xfb\xfc\xfd\x00\xff" 3312 }; 3313 3314 static unsigned short const xmlunicodetable_ISO8859_15 [128] = { 3315 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 3316 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 3317 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 3318 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 3319 0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20ac, 0x00a5, 0x0160, 0x00a7, 3320 0x0161, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af, 3321 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x017d, 0x00b5, 0x00b6, 0x00b7, 3322 0x017e, 0x00b9, 0x00ba, 0x00bb, 0x0152, 0x0153, 0x0178, 0x00bf, 3323 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 3324 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 3325 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 3326 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 3327 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 3328 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 3329 0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 3330 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff, 3331 }; 3332 3333 static unsigned char const xmltranscodetable_ISO8859_15 [48 + 6 * 64] = { 3334 "\x00\x00\x01\x05\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3335 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3336 "\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3337 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3338 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3339 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3340 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3341 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 3342 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 3343 "\xa0\xa1\xa2\xa3\x00\xa5\x00\xa7\x00\xa9\xaa\xab\xac\xad\xae\xaf" 3344 "\xb0\xb1\xb2\xb3\x00\xb5\xb6\xb7\x00\xb9\xba\xbb\x00\x00\x00\xbf" 3345 "\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3346 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3347 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3348 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3349 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3350 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3351 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00" 3352 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3353 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3354 "\x00\x00\xbc\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3355 "\xa6\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3356 "\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\xb4\xb8\x00" 3357 "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" 3358 "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf" 3359 "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" 3360 "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff" 3361 }; 3362 3363 static unsigned short const xmlunicodetable_ISO8859_16 [128] = { 3364 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 3365 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 3366 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 3367 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 3368 0x00a0, 0x0104, 0x0105, 0x0141, 0x20ac, 0x201e, 0x0160, 0x00a7, 3369 0x0161, 0x00a9, 0x0218, 0x00ab, 0x0179, 0x00ad, 0x017a, 0x017b, 3370 0x00b0, 0x00b1, 0x010c, 0x0142, 0x017d, 0x201d, 0x00b6, 0x00b7, 3371 0x017e, 0x010d, 0x0219, 0x00bb, 0x0152, 0x0153, 0x0178, 0x017c, 3372 0x00c0, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0106, 0x00c6, 0x00c7, 3373 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 3374 0x0110, 0x0143, 0x00d2, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x015a, 3375 0x0170, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0118, 0x021a, 0x00df, 3376 0x00e0, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x0107, 0x00e6, 0x00e7, 3377 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 3378 0x0111, 0x0144, 0x00f2, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x015b, 3379 0x0171, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0119, 0x021b, 0x00ff, 3380 }; 3381 3382 static unsigned char const xmltranscodetable_ISO8859_16 [48 + 9 * 64] = { 3383 "\x00\x00\x01\x08\x02\x03\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00" 3384 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3385 "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3386 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3387 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3388 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3389 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3390 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" 3391 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 3392 "\xa0\x00\x00\x00\x00\x00\x00\xa7\x00\xa9\x00\xab\x00\xad\x00\x00" 3393 "\xb0\xb1\x00\x00\x00\x00\xb6\xb7\x00\x00\x00\xbb\x00\x00\x00\x00" 3394 "\x00\x00\xc3\xe3\xa1\xa2\xc5\xe5\x00\x00\x00\x00\xb2\xb9\x00\x00" 3395 "\xd0\xf0\x00\x00\x00\x00\x00\x00\xdd\xfd\x00\x00\x00\x00\x00\x00" 3396 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3397 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3398 "\x00\xa3\xb3\xd1\xf1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3399 "\xd5\xf5\xbc\xbd\x00\x00\x00\x00\x00\x00\xd7\xf7\x00\x00\x00\x00" 3400 "\xa6\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3401 "\xd8\xf8\x00\x00\x00\x00\x00\x00\xbe\xac\xae\xaf\xbf\xb4\xb8\x00" 3402 "\x06\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3403 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3404 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3405 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3406 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3407 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3408 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00" 3409 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3410 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3411 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\xa5\x00" 3412 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3413 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3414 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3415 "\x00\x00\x00\x00\x00\x00\x00\x00\xaa\xba\xde\xfe\x00\x00\x00\x00" 3416 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3417 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 3418 "\xc0\xc1\xc2\x00\xc4\x00\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" 3419 "\x00\x00\xd2\xd3\xd4\x00\xd6\x00\x00\xd9\xda\xdb\xdc\x00\x00\xdf" 3420 "\xe0\xe1\xe2\x00\xe4\x00\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" 3421 "\x00\x00\xf2\xf3\xf4\x00\xf6\x00\x00\xf9\xfa\xfb\xfc\x00\x00\xff" 3422 }; 3423 3424 3425 /* 3426 * auto-generated functions for ISO-8859-2 .. ISO-8859-16 3427 */ 3428 3429 static int ISO8859_2ToUTF8 (unsigned char* out, int *outlen, 3430 const unsigned char* in, int *inlen) { 3431 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_2); 3432 } 3433 static int UTF8ToISO8859_2 (unsigned char* out, int *outlen, 3434 const unsigned char* in, int *inlen) { 3435 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_2); 3436 } 3437 3438 static int ISO8859_3ToUTF8 (unsigned char* out, int *outlen, 3439 const unsigned char* in, int *inlen) { 3440 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_3); 3441 } 3442 static int UTF8ToISO8859_3 (unsigned char* out, int *outlen, 3443 const unsigned char* in, int *inlen) { 3444 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_3); 3445 } 3446 3447 static int ISO8859_4ToUTF8 (unsigned char* out, int *outlen, 3448 const unsigned char* in, int *inlen) { 3449 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_4); 3450 } 3451 static int UTF8ToISO8859_4 (unsigned char* out, int *outlen, 3452 const unsigned char* in, int *inlen) { 3453 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_4); 3454 } 3455 3456 static int ISO8859_5ToUTF8 (unsigned char* out, int *outlen, 3457 const unsigned char* in, int *inlen) { 3458 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_5); 3459 } 3460 static int UTF8ToISO8859_5 (unsigned char* out, int *outlen, 3461 const unsigned char* in, int *inlen) { 3462 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_5); 3463 } 3464 3465 static int ISO8859_6ToUTF8 (unsigned char* out, int *outlen, 3466 const unsigned char* in, int *inlen) { 3467 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_6); 3468 } 3469 static int UTF8ToISO8859_6 (unsigned char* out, int *outlen, 3470 const unsigned char* in, int *inlen) { 3471 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_6); 3472 } 3473 3474 static int ISO8859_7ToUTF8 (unsigned char* out, int *outlen, 3475 const unsigned char* in, int *inlen) { 3476 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_7); 3477 } 3478 static int UTF8ToISO8859_7 (unsigned char* out, int *outlen, 3479 const unsigned char* in, int *inlen) { 3480 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_7); 3481 } 3482 3483 static int ISO8859_8ToUTF8 (unsigned char* out, int *outlen, 3484 const unsigned char* in, int *inlen) { 3485 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_8); 3486 } 3487 static int UTF8ToISO8859_8 (unsigned char* out, int *outlen, 3488 const unsigned char* in, int *inlen) { 3489 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_8); 3490 } 3491 3492 static int ISO8859_9ToUTF8 (unsigned char* out, int *outlen, 3493 const unsigned char* in, int *inlen) { 3494 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_9); 3495 } 3496 static int UTF8ToISO8859_9 (unsigned char* out, int *outlen, 3497 const unsigned char* in, int *inlen) { 3498 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_9); 3499 } 3500 3501 static int ISO8859_10ToUTF8 (unsigned char* out, int *outlen, 3502 const unsigned char* in, int *inlen) { 3503 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_10); 3504 } 3505 static int UTF8ToISO8859_10 (unsigned char* out, int *outlen, 3506 const unsigned char* in, int *inlen) { 3507 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_10); 3508 } 3509 3510 static int ISO8859_11ToUTF8 (unsigned char* out, int *outlen, 3511 const unsigned char* in, int *inlen) { 3512 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_11); 3513 } 3514 static int UTF8ToISO8859_11 (unsigned char* out, int *outlen, 3515 const unsigned char* in, int *inlen) { 3516 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_11); 3517 } 3518 3519 static int ISO8859_13ToUTF8 (unsigned char* out, int *outlen, 3520 const unsigned char* in, int *inlen) { 3521 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_13); 3522 } 3523 static int UTF8ToISO8859_13 (unsigned char* out, int *outlen, 3524 const unsigned char* in, int *inlen) { 3525 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_13); 3526 } 3527 3528 static int ISO8859_14ToUTF8 (unsigned char* out, int *outlen, 3529 const unsigned char* in, int *inlen) { 3530 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_14); 3531 } 3532 static int UTF8ToISO8859_14 (unsigned char* out, int *outlen, 3533 const unsigned char* in, int *inlen) { 3534 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_14); 3535 } 3536 3537 static int ISO8859_15ToUTF8 (unsigned char* out, int *outlen, 3538 const unsigned char* in, int *inlen) { 3539 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_15); 3540 } 3541 static int UTF8ToISO8859_15 (unsigned char* out, int *outlen, 3542 const unsigned char* in, int *inlen) { 3543 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_15); 3544 } 3545 3546 static int ISO8859_16ToUTF8 (unsigned char* out, int *outlen, 3547 const unsigned char* in, int *inlen) { 3548 return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_16); 3549 } 3550 static int UTF8ToISO8859_16 (unsigned char* out, int *outlen, 3551 const unsigned char* in, int *inlen) { 3552 return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_16); 3553 } 3554 3555 static void 3556 xmlRegisterCharEncodingHandlersISO8859x (void) { 3557 xmlNewCharEncodingHandler ("ISO-8859-2", ISO8859_2ToUTF8, UTF8ToISO8859_2); 3558 xmlNewCharEncodingHandler ("ISO-8859-3", ISO8859_3ToUTF8, UTF8ToISO8859_3); 3559 xmlNewCharEncodingHandler ("ISO-8859-4", ISO8859_4ToUTF8, UTF8ToISO8859_4); 3560 xmlNewCharEncodingHandler ("ISO-8859-5", ISO8859_5ToUTF8, UTF8ToISO8859_5); 3561 xmlNewCharEncodingHandler ("ISO-8859-6", ISO8859_6ToUTF8, UTF8ToISO8859_6); 3562 xmlNewCharEncodingHandler ("ISO-8859-7", ISO8859_7ToUTF8, UTF8ToISO8859_7); 3563 xmlNewCharEncodingHandler ("ISO-8859-8", ISO8859_8ToUTF8, UTF8ToISO8859_8); 3564 xmlNewCharEncodingHandler ("ISO-8859-9", ISO8859_9ToUTF8, UTF8ToISO8859_9); 3565 xmlNewCharEncodingHandler ("ISO-8859-10", ISO8859_10ToUTF8, UTF8ToISO8859_10); 3566 xmlNewCharEncodingHandler ("ISO-8859-11", ISO8859_11ToUTF8, UTF8ToISO8859_11); 3567 xmlNewCharEncodingHandler ("ISO-8859-13", ISO8859_13ToUTF8, UTF8ToISO8859_13); 3568 xmlNewCharEncodingHandler ("ISO-8859-14", ISO8859_14ToUTF8, UTF8ToISO8859_14); 3569 xmlNewCharEncodingHandler ("ISO-8859-15", ISO8859_15ToUTF8, UTF8ToISO8859_15); 3570 xmlNewCharEncodingHandler ("ISO-8859-16", ISO8859_16ToUTF8, UTF8ToISO8859_16); 3571 } 3572 3573 #endif 3574 #endif 3575 3576 #define bottom_encoding 3577 #include "elfgcchack.h" 3578
