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