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