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