encoding.c

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