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
  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 /**
2388  * xmlCharEncOutput:
2389  * @output: a parser output buffer
2390  * @init: is this an initialization call without data
2391  *
2392  * Generic front-end for the encoding handler on parser output
2393  * a first call with @init == 1 has to be made first to initiate the
2394  * output in case of non-stateless encoding needing to initiate their
2395  * state or the output (like the BOM in UTF16).
2396  * In case of UTF8 sequence conversion errors for the given encoder,
2397  * the content will be automatically remapped to a CharRef sequence.
2398  *
2399  * Returns the number of byte written if success, or
2400  *     -1 general error
2401  *     -2 if the transcoding fails (for *in is not valid utf8 string or
2402  *        the result of transformation can't fit into the encoding we want), or
2403  */
2404 int
2405 xmlCharEncOutput(xmlOutputBufferPtr output, int init)
2406 {
2407     int ret = -2;
2408     size_t written;
2409     size_t writtentot = 0;
2410     size_t toconv;
2411     int c_in;
2412     int c_out;
2413     xmlBufPtr in;
2414     xmlBufPtr out;
2415     int charref_len = 0;
2416
2417     if ((output == NULL) || (output->encoder == NULL) ||
2418         (output->buffer == NULL) || (output->conv == NULL))
2419         return (-1);
2420     out = output->conv;
2421     in = output->buffer;
2422
2423 retry:
2424
2425     written = xmlBufAvail(out);
2426     if (written > 0)
2427         written--; /* count '\0' */
2428
2429     /*
2430      * First specific handling of the initialization call
2431      */
2432     if (init) {
2433         c_in = 0;
2434         c_out = written;
2435         if (output->encoder->output != NULL) {
2436             ret = output->encoder->output(xmlBufEnd(out), &c_out,
2437                                           NULL, &c_in);
2438             if (ret > 0) /* Gennady: check return value */
2439                 xmlBufAddLen(out, c_out);
2440         }
2441 #ifdef LIBXML_ICONV_ENABLED
2442         else if (output->encoder->iconv_out != NULL) {
2443             ret = xmlIconvWrapper(output->encoder->iconv_out, xmlBufEnd(out),
2444                                   &c_out, NULL, &c_in);
2445             xmlBufAddLen(out, c_out);
2446         }
2447 #endif /* LIBXML_ICONV_ENABLED */
2448 #ifdef LIBXML_ICU_ENABLED
2449         else if (output->encoder->uconv_out != NULL) {
2450             ret = xmlUconvWrapper(output->encoder->uconv_out, 0, xmlBufEnd(out),
2451                                   &c_out, NULL, &c_in);
2452             xmlBufAddLen(out, c_out);
2453         }
2454 #endif /* LIBXML_ICU_ENABLED */
2455 #ifdef DEBUG_ENCODING
2456         xmlGenericError(xmlGenericErrorContext,
2457                 "initialized encoder\n");
2458 #endif
2459         return(0);
2460     }
2461
2462     /*
2463      * Conversion itself.
2464      */
2465     toconv = xmlBufUse(in);
2466     if (toconv == 0)
2467         return (0);
2468     if (toconv > 64 * 1024)
2469         toconv = 64 * 1024;
2470     if (toconv * 4 >= written) {
2471         xmlBufGrow(out, toconv * 4);
2472         written = xmlBufAvail(out) - 1;
2473     }
2474     if (written > 256 * 1024)
2475         written = 256 * 1024;
2476
2477     c_in = toconv;
2478     c_out = written;
2479     if (output->encoder->output != NULL) {
2480         ret = output->encoder->output(xmlBufEnd(out), &c_out,
2481                                       xmlBufContent(in), &c_in);
2482         if (c_out > 0) {
2483             xmlBufShrink(in, c_in);
2484             xmlBufAddLen(out, c_out);
2485             writtentot += c_out;
2486         }
2487     }
2488 #ifdef LIBXML_ICONV_ENABLED
2489     else if (output->encoder->iconv_out != NULL) {
2490         ret = xmlIconvWrapper(output->encoder->iconv_out, xmlBufEnd(out),
2491                               &c_out, xmlBufContent(in), &c_in);
2492         xmlBufShrink(in, c_in);
2493         xmlBufAddLen(out, c_out);
2494         writtentot += c_out;
2495         if (ret == -1) {
2496             if (c_out > 0) {
2497                 /*
2498                  * Can be a limitation of iconv
2499                  */
2500                 charref_len = 0;
2501                 goto retry;
2502             }
2503             ret = -3;
2504         }
2505     }
2506 #endif /* LIBXML_ICONV_ENABLED */
2507 #ifdef LIBXML_ICU_ENABLED
2508     else if (output->encoder->uconv_out != NULL) {
2509         ret = xmlUconvWrapper(output->encoder->uconv_out, 0, xmlBufEnd(out),
2510                               &c_out, xmlBufContent(in), &c_in);
2511         xmlBufShrink(in, c_in);
2512         xmlBufAddLen(out, c_out);
2513         writtentot += c_out;
2514         if (ret == -1) {
2515             if (c_out > 0) {
2516                 /*
2517                  * Can be a limitation of uconv
2518                  */
2519                 charref_len = 0;
2520                 goto retry;
2521             }
2522             ret = -3;
2523         }
2524     }
2525 #endif /* LIBXML_ICU_ENABLED */
2526     else {
2527         xmlEncodingErr(XML_I18N_NO_OUTPUT,
2528                        "xmlCharEncOutFunc: no output function !\n", NULL);
2529         return(-1);
2530     }
2531
2532     if (ret >= 0) output += ret;
2533
2534     /*
2535      * Attempt to handle error cases
2536      */
2537     switch (ret) {
2538         case 0:
2539 #ifdef DEBUG_ENCODING
2540             xmlGenericError(xmlGenericErrorContext,
2541                     "converted %d bytes to %d bytes of output\n",
2542                     c_in, c_out);
2543 #endif
2544             break;
2545         case -1:
2546 #ifdef DEBUG_ENCODING
2547             xmlGenericError(xmlGenericErrorContext,
2548                     "output conversion failed by lack of space\n");
2549 #endif
2550             break;
2551         case -3:
2552 #ifdef DEBUG_ENCODING
2553             xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of output %d left\n",
2554                     c_in, c_out, (int) xmlBufUse(in));
2555 #endif
2556             break;
2557         case -2: {
2558             int len = (int) xmlBufUse(in);
2559             xmlChar *content = xmlBufContent(in);
2560             int cur;
2561
2562             cur = xmlGetUTF8Char(content, &len);
2563             if ((charref_len != 0) && (c_out < charref_len)) {
2564                 /*
2565                  * We attempted to insert a character reference and failed.
2566                  * Undo what was written and skip the remaining charref.
2567                  */
2568                 xmlBufErase(out, c_out);
2569                 writtentot -= c_out;
2570                 xmlBufShrink(in, charref_len - c_out);
2571                 charref_len = 0;
2572
2573                 ret = -1;
2574                 break;
2575             } else if (cur > 0) {
2576                 xmlChar charref[20];
2577
2578 #ifdef DEBUG_ENCODING
2579                 xmlGenericError(xmlGenericErrorContext,
2580                         "handling output conversion error\n");
2581                 xmlGenericError(xmlGenericErrorContext,
2582                         "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
2583                         content[0], content[1],
2584                         content[2], content[3]);
2585 #endif
2586                 /*
2587                  * Removes the UTF8 sequence, and replace it by a charref
2588                  * and continue the transcoding phase, hoping the error
2589                  * did not mangle the encoder state.
2590                  */
2591                 charref_len = snprintf((char *) &charref[0], sizeof(charref),
2592                                  "&#%d;", cur);
2593                 xmlBufShrink(in, len);
2594                 xmlBufAddHead(in, charref, -1);
2595
2596                 goto retry;
2597             } else {
2598                 char buf[50];
2599
2600                 snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X",
2601                          content[0], content[1],
2602                          content[2], content[3]);
2603                 buf[49] = 0;
2604                 xmlEncodingErr(XML_I18N_CONV_FAILED,
2605                     "output conversion failed due to conv error, bytes %s\n",
2606                                buf);
2607                 if (xmlBufGetAllocationScheme(in) != XML_BUFFER_ALLOC_IMMUTABLE)
2608                     content[0] = ' ';
2609             }
2610             break;
2611         }
2612     }
2613     return(ret);
2614 }
2615
2616 /**
2617  * xmlCharEncOutFunc:
2618  * @handler:    char enconding transformation data structure
2619  * @out:  an xmlBuffer for the output.
2620  * @in:  an xmlBuffer for the input
2621  *
2622  * Generic front-end for the encoding handler output function
2623  * a first call with @in == NULL has to be made firs to initiate the
2624  * output in case of non-stateless encoding needing to initiate their
2625  * state or the output (like the BOM in UTF16).
2626  * In case of UTF8 sequence conversion errors for the given encoder,
2627  * the content will be automatically remapped to a CharRef sequence.
2628  *
2629  * Returns the number of byte written if success, or
2630  *     -1 general error
2631  *     -2 if the transcoding fails (for *in is not valid utf8 string or
2632  *        the result of transformation can't fit into the encoding we want), or
2633  */
2634 int
2635 xmlCharEncOutFunc(xmlCharEncodingHandler *handler, xmlBufferPtr out,
2636                   xmlBufferPtr in) {
2637     int ret = -2;
2638     int written;
2639     int writtentot = 0;
2640     int toconv;
2641     int output = 0;
2642     int charref_len = 0;
2643
2644     if (handler == NULL) return(-1);
2645     if (out == NULL) return(-1);
2646
2647 retry:
2648
2649     written = out->size - out->use;
2650
2651     if (written > 0)
2652         written--; /* Gennady: count '/0' */
2653
2654     /*
2655      * First specific handling of in = NULL, i.e. the initialization call
2656      */
2657     if (in == NULL) {
2658         toconv = 0;
2659         if (handler->output != NULL) {
2660             ret = handler->output(&out->content[out->use], &written,
2661                                   NULL, &toconv);
2662             if (ret >= 0) { /* Gennady: check return value */
2663                 out->use += written;
2664                 out->content[out->use] = 0;
2665             }
2666         }
2667 #ifdef LIBXML_ICONV_ENABLED
2668         else if (handler->iconv_out != NULL) {
2669             ret = xmlIconvWrapper(handler->iconv_out, &out->content[out->use],
2670                                   &written, NULL, &toconv);
2671             out->use += written;
2672             out->content[out->use] = 0;
2673         }
2674 #endif /* LIBXML_ICONV_ENABLED */
2675 #ifdef LIBXML_ICU_ENABLED
2676         else if (handler->uconv_out != NULL) {
2677             ret = xmlUconvWrapper(handler->uconv_out, 0,
2678                               &out->content[out->use],
2679                                               &written, NULL, &toconv);
2680             out->use += written;
2681             out->content[out->use] = 0;
2682         }
2683 #endif /* LIBXML_ICU_ENABLED */
2684 #ifdef DEBUG_ENCODING
2685         xmlGenericError(xmlGenericErrorContext,
2686                 "initialized encoder\n");
2687 #endif
2688         return(0);
2689     }
2690
2691     /*
2692      * Conversion itself.
2693      */
2694     toconv = in->use;
2695     if (toconv == 0)
2696         return(0);
2697     if (toconv * 4 >= written) {
2698         xmlBufferGrow(out, toconv * 4);
2699         written = out->size - out->use - 1;
2700     }
2701     if (handler->output != NULL) {
2702         ret = handler->output(&out->content[out->use], &written,
2703                               in->content, &toconv);
2704         if (written > 0) {
2705             xmlBufferShrink(in, toconv);
2706             out->use += written;
2707             writtentot += written;
2708         }
2709         out->content[out->use] = 0;
2710     }
2711 #ifdef LIBXML_ICONV_ENABLED
2712     else if (handler->iconv_out != NULL) {
2713         ret = xmlIconvWrapper(handler->iconv_out, &out->content[out->use],
2714                               &written, in->content, &toconv);
2715         xmlBufferShrink(in, toconv);
2716         out->use += written;
2717         writtentot += written;
2718         out->content[out->use] = 0;
2719         if (ret == -1) {
2720             if (written > 0) {
2721                 /*
2722                  * Can be a limitation of iconv
2723                  */
2724                 charref_len = 0;
2725                 goto retry;
2726             }
2727             ret = -3;
2728         }
2729     }
2730 #endif /* LIBXML_ICONV_ENABLED */
2731 #ifdef LIBXML_ICU_ENABLED
2732     else if (handler->uconv_out != NULL) {
2733         ret = xmlUconvWrapper(handler->uconv_out, 0,
2734                               &out->content[out->use],
2735                               &written, in->content, &toconv);
2736         xmlBufferShrink(in, toconv);
2737         out->use += written;
2738         writtentot += written;
2739         out->content[out->use] = 0;
2740         if (ret == -1) {
2741             if (written > 0) {
2742                 /*
2743                  * Can be a limitation of iconv
2744                  */
2745                 charref_len = 0;
2746                 goto retry;
2747             }
2748             ret = -3;
2749         }
2750     }
2751 #endif /* LIBXML_ICU_ENABLED */
2752     else {
2753         xmlEncodingErr(XML_I18N_NO_OUTPUT,
2754                        "xmlCharEncOutFunc: no output function !\n", NULL);
2755         return(-1);
2756     }
2757
2758     if (ret >= 0) output += ret;
2759
2760     /*
2761      * Attempt to handle error cases
2762      */
2763     switch (ret) {
2764         case 0:
2765 #ifdef DEBUG_ENCODING
2766             xmlGenericError(xmlGenericErrorContext,
2767                     "converted %d bytes to %d bytes of output\n",
2768                     toconv, written);
2769 #endif
2770             break;
2771         case -1:
2772 #ifdef DEBUG_ENCODING
2773             xmlGenericError(xmlGenericErrorContext,
2774                     "output conversion failed by lack of space\n");
2775 #endif
2776             break;
2777         case -3:
2778 #ifdef DEBUG_ENCODING
2779             xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of output %d left\n",
2780                     toconv, written, in->use);
2781 #endif
2782             break;
2783         case -2: {
2784             int len = in->use;
2785             const xmlChar *utf = (const xmlChar *) in->content;
2786             int cur;
2787
2788             cur = xmlGetUTF8Char(utf, &len);
2789             if ((charref_len != 0) && (written < charref_len)) {
2790                 /*
2791                  * We attempted to insert a character reference and failed.
2792                  * Undo what was written and skip the remaining charref.
2793                  */
2794                 out->use -= written;
2795                 writtentot -= written;
2796                 xmlBufferShrink(in, charref_len - written);
2797                 charref_len = 0;
2798
2799                 ret = -1;
2800                 break;
2801             } else if (cur > 0) {
2802                 xmlChar charref[20];
2803
2804 #ifdef DEBUG_ENCODING
2805                 xmlGenericError(xmlGenericErrorContext,
2806                         "handling output conversion error\n");
2807                 xmlGenericError(xmlGenericErrorContext,
2808                         "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
2809                         in->content[0], in->content[1],
2810                         in->content[2], in->content[3]);
2811 #endif
2812                 /*
2813                  * Removes the UTF8 sequence, and replace it by a charref
2814                  * and continue the transcoding phase, hoping the error
2815                  * did not mangle the encoder state.
2816                  */
2817                 charref_len = snprintf((char *) &charref[0], sizeof(charref),
2818                                  "&#%d;", cur);
2819                 xmlBufferShrink(in, len);
2820                 xmlBufferAddHead(in, charref, -1);
2821
2822                 goto retry;
2823             } else {
2824                 char buf[50];
2825
2826                 snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X",
2827                          in->content[0], in->content[1],
2828                          in->content[2], in->content[3]);
2829                 buf[49] = 0;
2830                 xmlEncodingErr(XML_I18N_CONV_FAILED,
2831                     "output conversion failed due to conv error, bytes %s\n",
2832                                buf);
2833                 if (in->alloc != XML_BUFFER_ALLOC_IMMUTABLE)
2834                     in->content[0] = ' ';
2835             }
2836             break;
2837         }
2838     }
2839     return(ret);
2840 }
2841
2842 /**
2843  * xmlCharEncCloseFunc:
2844  * @handler:    char enconding transformation data structure
2845  *
2846  * Generic front-end for encoding handler close function
2847  *
2848  * Returns 0 if success, or -1 in case of error
2849  */
2850 int
2851 xmlCharEncCloseFunc(xmlCharEncodingHandler *handler) {
2852     int ret = 0;
2853     int tofree = 0;
2854     if (handler == NULL) return(-1);
2855     if (handler->name == NULL) return(-1);
2856 #ifdef LIBXML_ICONV_ENABLED
2857     /*
2858      * Iconv handlers can be used only once, free the whole block.
2859      * and the associated icon resources.
2860      */
2861     if ((handler->iconv_out != NULL) || (handler->iconv_in != NULL)) {
2862         tofree = 1;
2863         if (handler->iconv_out != NULL) {
2864             if (iconv_close(handler->iconv_out))
2865                 ret = -1;
2866             handler->iconv_out = NULL;
2867         }
2868         if (handler->iconv_in != NULL) {
2869             if (iconv_close(handler->iconv_in))
2870                 ret = -1;
2871             handler->iconv_in = NULL;
2872         }
2873     }
2874 #endif /* LIBXML_ICONV_ENABLED */
2875 #ifdef LIBXML_ICU_ENABLED
2876     if ((handler->uconv_out != NULL) || (handler->uconv_in != NULL)) {
2877         tofree = 1;
2878         if (handler->uconv_out != NULL) {
2879             closeIcuConverter(handler->uconv_out);
2880             handler->uconv_out = NULL;
2881         }
2882         if (handler->uconv_in != NULL) {
2883             closeIcuConverter(handler->uconv_in);
2884             handler->uconv_in = NULL;
2885         }
2886     }
2887 #endif
2888     if (tofree) {
2889         /* free up only dynamic handlers iconv/uconv */
2890         if (handler->name != NULL)
2891             xmlFree(handler->name);
2892         handler->name = NULL;
2893         xmlFree(handler);
2894     }
2895 #ifdef DEBUG_ENCODING
2896     if (ret)
2897         xmlGenericError(xmlGenericErrorContext,
2898                 "failed to close the encoding handler\n");
2899     else
2900         xmlGenericError(xmlGenericErrorContext,
2901                 "closed the encoding handler\n");
2902 #endif
2903
2904     return(ret);
2905 }
2906
2907 /**
2908  * xmlByteConsumed:
2909  * @ctxt: an XML parser context
2910  *
2911  * This function provides the current index of the parser relative
2912  * to the start of the current entity. This function is computed in
2913  * bytes from the beginning starting at zero and finishing at the
2914  * size in byte of the file if parsing a file. The function is
2915  * of constant cost if the input is UTF-8 but can be costly if run
2916  * on non-UTF-8 input.
2917  *
2918  * Returns the index in bytes from the beginning of the entity or -1
2919  *         in case the index could not be computed.
2920  */
2921 long
2922 xmlByteConsumed(xmlParserCtxtPtr ctxt) {
2923     xmlParserInputPtr in;
2924
2925     if (ctxt == NULL) return(-1);
2926     in = ctxt->input;
2927     if (in == NULL)  return(-1);
2928     if ((in->buf != NULL) && (in->buf->encoder != NULL)) {
2929         unsigned int unused = 0;
2930         xmlCharEncodingHandler * handler = in->buf->encoder;
2931         /*
2932          * Encoding conversion, compute the number of unused original
2933          * bytes from the input not consumed and substract that from
2934          * the raw consumed value, this is not a cheap operation
2935          */
2936         if (in->end - in->cur > 0) {
2937             unsigned char convbuf[32000];
2938             const unsigned char *cur = (const unsigned char *)in->cur;
2939             int toconv = in->end - in->cur, written = 32000;
2940
2941             int ret;
2942
2943             if (handler->output != NULL) {
2944                 do {
2945                     toconv = in->end - cur;
2946                     written = 32000;
2947                     ret = handler->output(&convbuf[0], &written,
2948                                       cur, &toconv);
2949                     if (ret == -1) return(-1);
2950                     unused += written;
2951                     cur += toconv;
2952                 } while (ret == -2);
2953 #ifdef LIBXML_ICONV_ENABLED
2954             } else if (handler->iconv_out != NULL) {
2955                 do {
2956                     toconv = in->end - cur;
2957                     written = 32000;
2958                     ret = xmlIconvWrapper(handler->iconv_out, &convbuf[0],
2959                               &written, cur, &toconv);
2960                     if (ret < 0) {
2961                         if (written > 0)
2962                             ret = -2;
2963                         else
2964                             return(-1);
2965                     }
2966                     unused += written;
2967                     cur += toconv;
2968                 } while (ret == -2);
2969 #endif
2970 #ifdef LIBXML_ICU_ENABLED
2971             } else if (handler->uconv_out != NULL) {
2972                 do {
2973                     toconv = in->end - cur;
2974                     written = 32000;
2975                     ret = xmlUconvWrapper(handler->uconv_out, 0, &convbuf[0],
2976                               &written, cur, &toconv);
2977                     if (ret < 0) {
2978                         if (written > 0)
2979                             ret = -2;
2980                         else
2981                             return(-1);
2982                     }
2983                     unused += written;
2984                     cur += toconv;
2985                 } while (ret == -2);
2986 #endif
2987             } else {
2988                 /* could not find a converter */
2989                 return(-1);
2990             }
2991         }
2992         if (in->buf->rawconsumed < unused)
2993             return(-1);
2994         return(in->buf->rawconsumed - unused);
2995     }
2996     return(in->consumed + (in->cur - in->base));
2997 }
2998
2999 #if !defined(LIBXML_ICONV_ENABLED) && !defined(LIBXML_ICU_ENABLED)
3000 #ifdef LIBXML_ISO8859X_ENABLED
3001
3002 /**
3003  * UTF8ToISO8859x:
3004  * @out:  a pointer to an array of bytes to store the result
3005  * @outlen:  the length of @out
3006  * @in:  a pointer to an array of UTF-8 chars
3007  * @inlen:  the length of @in
3008  * @xlattable: the 2-level transcoding table
3009  *
3010  * Take a block of UTF-8 chars in and try to convert it to an ISO 8859-*
3011  * block of chars out.
3012  *
3013  * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise
3014  * The value of @inlen after return is the number of octets consumed
3015  *     as the return value is positive, else unpredictable.
3016  * The value of @outlen after return is the number of ocetes consumed.
3017  */
3018 static int
3019 UTF8ToISO8859x(unsigned char* out, int *outlen,
3020               const unsigned char* in, int *inlen,
3021               unsigned char const *xlattable) {
3022     const unsigned char* outstart = out;
3023     const unsigned char* inend;
3024     const unsigned char* instart = in;
3025     const unsigned char* processed = in;
3026
3027     if ((out == NULL) || (outlen == NULL) || (inlen == NULL) ||
3028         (xlattable == NULL))
3029         return(-1);
3030     if (in == NULL) {
3031         /*
3032         * initialization nothing to do
3033         */
3034         *outlen = 0;
3035         *inlen = 0;
3036         return(0);
3037     }
3038     inend = in + (*inlen);
3039     while (in < inend) {
3040         unsigned char d = *in++;
3041         if  (d < 0x80)  {
3042             *out++ = d;
3043         } else if (d < 0xC0) {
3044             /* trailing byte in leading position */
3045             *outlen = out - outstart;
3046             *inlen = processed - instart;
3047             return(-2);
3048         } else if (d < 0xE0) {
3049             unsigned char c;
3050             if (!(in < inend)) {
3051                 /* trailing byte not in input buffer */
3052                 *outlen = out - outstart;
3053                 *inlen = processed - instart;
3054                 return(-3);
3055             }
3056             c = *in++;
3057             if ((c & 0xC0) != 0x80) {
3058                 /* not a trailing byte */
3059                 *outlen = out - outstart;
3060                 *inlen = processed - instart;
3061                 return(-2);
3062             }
3063             c = c & 0x3F;
3064             d = d & 0x1F;
3065             d = xlattable [48 + c + xlattable [d] * 64];
3066             if (d == 0) {
3067                 /* not in character set */
3068                 *outlen = out - outstart;
3069                 *inlen = processed - instart;
3070                 return(-2);
3071             }
3072             *out++ = d;
3073         } else if (d < 0xF0) {
3074             unsigned char c1;
3075             unsigned char c2;
3076             if (!(in < inend - 1)) {
3077                 /* trailing bytes not in input buffer */
3078                 *outlen = out - outstart;
3079                 *inlen = processed - instart;
3080                 return(-3);
3081             }
3082             c1 = *in++;
3083             if ((c1 & 0xC0) != 0x80) {
3084                 /* not a trailing byte (c1) */
3085                 *outlen = out - outstart;
3086                 *inlen = processed - instart;
3087                 return(-2);
3088             }
3089             c2 = *in++;
3090             if ((c2 & 0xC0) != 0x80) {
3091                 /* not a trailing byte (c2) */
3092                 *outlen = out - outstart;
3093                 *inlen = processed - instart;
3094                 return(-2);
3095             }
3096             c1 = c1 & 0x3F;
3097             c2 = c2 & 0x3F;
3098             d = d & 0x0F;
3099             d = xlattable [48 + c2 + xlattable [48 + c1 +
3100                         xlattable [32 + d] * 64] * 64];
3101             if (d == 0) {
3102                 /* not in character set */
3103                 *outlen = out - outstart;
3104                 *inlen = processed - instart;
3105                 return(-2);
3106             }
3107             *out++ = d;
3108         } else {
3109             /* cannot transcode >= U+010000 */
3110             *outlen = out - outstart;
3111             *inlen = processed - instart;
3112             return(-2);
3113         }
3114         processed = in;
3115     }
3116     *outlen = out - outstart;
3117     *inlen = processed - instart;
3118     return(*outlen);
3119 }
3120
3121 /**
3122  * ISO8859xToUTF8
3123  * @out:  a pointer to an array of bytes to store the result
3124  * @outlen:  the length of @out
3125  * @in:  a pointer to an array of ISO Latin 1 chars
3126  * @inlen:  the length of @in
3127  *
3128  * Take a block of ISO 8859-* chars in and try to convert it to an UTF-8
3129  * block of chars out.
3130  * Returns 0 if success, or -1 otherwise
3131  * The value of @inlen after return is the number of octets consumed
3132  * The value of @outlen after return is the number of ocetes produced.
3133  */
3134 static int
3135 ISO8859xToUTF8(unsigned char* out, int *outlen,
3136               const unsigned char* in, int *inlen,
3137               unsigned short const *unicodetable) {
3138     unsigned char* outstart = out;
3139     unsigned char* outend;
3140     const unsigned char* instart = in;
3141     const unsigned char* inend;
3142     const unsigned char* instop;
3143     unsigned int c;
3144
3145     if ((out == NULL) || (outlen == NULL) || (inlen == NULL) ||
3146         (in == NULL) || (unicodetable == NULL))
3147         return(-1);
3148     outend = out + *outlen;
3149     inend = in + *inlen;
3150     instop = inend;
3151
3152     while ((in < inend) && (out < outend - 2)) {
3153         if (*in >= 0x80) {
3154             c = unicodetable [*in - 0x80];
3155             if (c == 0) {
3156                 /* undefined code point */
3157                 *outlen = out - outstart;
3158                 *inlen = in - instart;
3159                 return (-1);
3160             }
3161             if (c < 0x800) {
3162                 *out++ = ((c >>  6) & 0x1F) | 0xC0;
3163                 *out++ = (c & 0x3F) | 0x80;
3164             } else {
3165                 *out++ = ((c >>  12) & 0x0F) | 0xE0;
3166                 *out++ = ((c >>  6) & 0x3F) | 0x80;
3167                 *out++ = (c & 0x3F) | 0x80;
3168             }
3169             ++in;
3170         }
3171         if (instop - in > outend - out) instop = in + (outend - out);
3172         while ((*in < 0x80) && (in < instop)) {
3173             *out++ = *in++;
3174         }
3175     }
3176     if ((in < inend) && (out < outend) && (*in < 0x80)) {
3177         *out++ =  *in++;
3178     }
3179     if ((in < inend) && (out < outend) && (*in < 0x80)) {
3180         *out++ =  *in++;
3181     }
3182     *outlen = out - outstart;
3183     *inlen = in - instart;
3184     return (*outlen);
3185 }
3186
3187
3188 /************************************************************************
3189  * Lookup tables for ISO-8859-2..ISO-8859-16 transcoding                *
3190  ************************************************************************/
3191
3192 static unsigned short const xmlunicodetable_ISO8859_2 [128] = {
3193     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3194     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3195     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3196     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3197     0x00a0, 0x0104, 0x02d8, 0x0141, 0x00a4, 0x013d, 0x015a, 0x00a7,
3198     0x00a8, 0x0160, 0x015e, 0x0164, 0x0179, 0x00ad, 0x017d, 0x017b,
3199     0x00b0, 0x0105, 0x02db, 0x0142, 0x00b4, 0x013e, 0x015b, 0x02c7,
3200     0x00b8, 0x0161, 0x015f, 0x0165, 0x017a, 0x02dd, 0x017e, 0x017c,
3201     0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7,
3202     0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
3203     0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7,
3204     0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
3205     0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7,
3206     0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
3207     0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7,
3208     0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9,
3209 };
3210
3211 static unsigned char const xmltranscodetable_ISO8859_2 [48 + 6 * 64] = {
3212     "\x00\x00\x01\x05\x02\x04\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00"
3213     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3214     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3215     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3216     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3217     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3218     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3219     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3220     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3221     "\xa0\x00\x00\x00\xa4\x00\x00\xa7\xa8\x00\x00\x00\x00\xad\x00\x00"
3222     "\xb0\x00\x00\x00\xb4\x00\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00"
3223     "\x00\x00\xc3\xe3\xa1\xb1\xc6\xe6\x00\x00\x00\x00\xc8\xe8\xcf\xef"
3224     "\xd0\xf0\x00\x00\x00\x00\x00\x00\xca\xea\xcc\xec\x00\x00\x00\x00"
3225     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3226     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc5\xe5\x00\x00\xa5\xb5\x00"
3227     "\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00"
3228     "\x00\x00\x00\x00\x00\x00\x00\x00\xa2\xff\x00\xb2\x00\xbd\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\xa3\xb3\xd1\xf1\x00\x00\xd2\xf2\x00\x00\x00\x00\x00\x00\x00"
3232     "\xd5\xf5\x00\x00\xc0\xe0\x00\x00\xd8\xf8\xa6\xb6\x00\x00\xaa\xba"
3233     "\xa9\xb9\xde\xfe\xab\xbb\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xf9"
3234     "\xdb\xfb\x00\x00\x00\x00\x00\x00\x00\xac\xbc\xaf\xbf\xae\xbe\x00"
3235     "\x00\xc1\xc2\x00\xc4\x00\x00\xc7\x00\xc9\x00\xcb\x00\xcd\xce\x00"
3236     "\x00\x00\x00\xd3\xd4\x00\xd6\xd7\x00\x00\xda\x00\xdc\xdd\x00\xdf"
3237     "\x00\xe1\xe2\x00\xe4\x00\x00\xe7\x00\xe9\x00\xeb\x00\xed\xee\x00"
3238     "\x00\x00\x00\xf3\xf4\x00\xf6\xf7\x00\x00\xfa\x00\xfc\xfd\x00\x00"
3239 };
3240
3241 static unsigned short const xmlunicodetable_ISO8859_3 [128] = {
3242     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3243     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3244     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3245     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3246     0x00a0, 0x0126, 0x02d8, 0x00a3, 0x00a4, 0x0000, 0x0124, 0x00a7,
3247     0x00a8, 0x0130, 0x015e, 0x011e, 0x0134, 0x00ad, 0x0000, 0x017b,
3248     0x00b0, 0x0127, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x0125, 0x00b7,
3249     0x00b8, 0x0131, 0x015f, 0x011f, 0x0135, 0x00bd, 0x0000, 0x017c,
3250     0x00c0, 0x00c1, 0x00c2, 0x0000, 0x00c4, 0x010a, 0x0108, 0x00c7,
3251     0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
3252     0x0000, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x0120, 0x00d6, 0x00d7,
3253     0x011c, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x016c, 0x015c, 0x00df,
3254     0x00e0, 0x00e1, 0x00e2, 0x0000, 0x00e4, 0x010b, 0x0109, 0x00e7,
3255     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
3256     0x0000, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x0121, 0x00f6, 0x00f7,
3257     0x011d, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x016d, 0x015d, 0x02d9,
3258 };
3259
3260 static unsigned char const xmltranscodetable_ISO8859_3 [48 + 7 * 64] = {
3261     "\x04\x00\x01\x06\x02\x05\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00"
3262     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3263     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3264     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3265     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3266     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3267     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3268     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3269     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3270     "\xa0\x00\x00\xa3\xa4\x00\x00\xa7\xa8\x00\x00\x00\x00\xad\x00\x00"
3271     "\xb0\x00\xb2\xb3\xb4\xb5\x00\xb7\xb8\x00\x00\x00\x00\xbd\x00\x00"
3272     "\x00\x00\x00\x00\x00\x00\x00\x00\xc6\xe6\xc5\xe5\x00\x00\x00\x00"
3273     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xf8\xab\xbb"
3274     "\xd5\xf5\x00\x00\xa6\xb6\xa1\xb1\x00\x00\x00\x00\x00\x00\x00\x00"
3275     "\xa9\xb9\x00\x00\xac\xbc\x00\x00\x00\x00\x00\x00\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\xa2\xff\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     "\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3281     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3282     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3283     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3284     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3285     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\xfe\xaa\xba"
3286     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\xfd\x00\x00"
3287     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\xbf\x00\x00\x00"
3288     "\xc0\xc1\xc2\x00\xc4\x00\x00\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
3289     "\x00\xd1\xd2\xd3\xd4\x00\xd6\xd7\x00\xd9\xda\xdb\xdc\x00\x00\xdf"
3290     "\xe0\xe1\xe2\x00\xe4\x00\x00\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
3291     "\x00\xf1\xf2\xf3\xf4\x00\xf6\xf7\x00\xf9\xfa\xfb\xfc\x00\x00\x00"
3292 };
3293
3294 static unsigned short const xmlunicodetable_ISO8859_4 [128] = {
3295     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3296     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3297     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3298     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3299     0x00a0, 0x0104, 0x0138, 0x0156, 0x00a4, 0x0128, 0x013b, 0x00a7,
3300     0x00a8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00ad, 0x017d, 0x00af,
3301     0x00b0, 0x0105, 0x02db, 0x0157, 0x00b4, 0x0129, 0x013c, 0x02c7,
3302     0x00b8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014a, 0x017e, 0x014b,
3303     0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e,
3304     0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x012a,
3305     0x0110, 0x0145, 0x014c, 0x0136, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
3306     0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x0168, 0x016a, 0x00df,
3307     0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f,
3308     0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x012b,
3309     0x0111, 0x0146, 0x014d, 0x0137, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
3310     0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x0169, 0x016b, 0x02d9,
3311 };
3312
3313 static unsigned char const xmltranscodetable_ISO8859_4 [48 + 6 * 64] = {
3314     "\x00\x00\x01\x05\x02\x03\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00"
3315     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3316     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3317     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3318     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3319     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3320     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3321     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3322     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3323     "\xa0\x00\x00\x00\xa4\x00\x00\xa7\xa8\x00\x00\x00\x00\xad\x00\xaf"
3324     "\xb0\x00\x00\x00\xb4\x00\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00"
3325     "\xc0\xe0\x00\x00\xa1\xb1\x00\x00\x00\x00\x00\x00\xc8\xe8\x00\x00"
3326     "\xd0\xf0\xaa\xba\x00\x00\xcc\xec\xca\xea\x00\x00\x00\x00\x00\x00"
3327     "\x00\x00\xab\xbb\x00\x00\x00\x00\xa5\xb5\xcf\xef\x00\x00\xc7\xe7"
3328     "\x00\x00\x00\x00\x00\x00\xd3\xf3\xa2\x00\x00\xa6\xb6\x00\x00\x00"
3329     "\x00\x00\x00\x00\x00\xd1\xf1\x00\x00\x00\xbd\xbf\xd2\xf2\x00\x00"
3330     "\x00\x00\x00\x00\x00\x00\xa3\xb3\x00\x00\x00\x00\x00\x00\x00\x00"
3331     "\xa9\xb9\x00\x00\x00\x00\xac\xbc\xdd\xfd\xde\xfe\x00\x00\x00\x00"
3332     "\x00\x00\xd9\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\xbe\x00"
3333     "\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00"
3334     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\xb2\x00\x00\x00\x00"
3335     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3336     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3337     "\x00\xc1\xc2\xc3\xc4\xc5\xc6\x00\x00\xc9\x00\xcb\x00\xcd\xce\x00"
3338     "\x00\x00\x00\x00\xd4\xd5\xd6\xd7\xd8\x00\xda\xdb\xdc\x00\x00\xdf"
3339     "\x00\xe1\xe2\xe3\xe4\xe5\xe6\x00\x00\xe9\x00\xeb\x00\xed\xee\x00"
3340     "\x00\x00\x00\x00\xf4\xf5\xf6\xf7\xf8\x00\xfa\xfb\xfc\x00\x00\x00"
3341 };
3342
3343 static unsigned short const xmlunicodetable_ISO8859_5 [128] = {
3344     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3345     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3346     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3347     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3348     0x00a0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407,
3349     0x0408, 0x0409, 0x040a, 0x040b, 0x040c, 0x00ad, 0x040e, 0x040f,
3350     0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
3351     0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f,
3352     0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
3353     0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f,
3354     0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
3355     0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, 0x043f,
3356     0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
3357     0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f,
3358     0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457,
3359     0x0458, 0x0459, 0x045a, 0x045b, 0x045c, 0x00a7, 0x045e, 0x045f,
3360 };
3361
3362 static unsigned char const xmltranscodetable_ISO8859_5 [48 + 6 * 64] = {
3363     "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3364     "\x02\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3365     "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3366     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3367     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3368     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3369     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3370     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3371     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3372     "\xa0\x00\x00\x00\x00\x00\x00\xfd\x00\x00\x00\x00\x00\xad\x00\x00"
3373     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3374     "\x00\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\x00\xae\xaf"
3375     "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
3376     "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
3377     "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
3378     "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
3379     "\x00\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\x00\xfe\xff"
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\x05\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     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3385     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3386     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3387     "\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3388     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3389     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3390 };
3391
3392 static unsigned short const xmlunicodetable_ISO8859_6 [128] = {
3393     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3394     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3395     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3396     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3397     0x00a0, 0x0000, 0x0000, 0x0000, 0x00a4, 0x0000, 0x0000, 0x0000,
3398     0x0000, 0x0000, 0x0000, 0x0000, 0x060c, 0x00ad, 0x0000, 0x0000,
3399     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
3400     0x0000, 0x0000, 0x0000, 0x061b, 0x0000, 0x0000, 0x0000, 0x061f,
3401     0x0000, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
3402     0x0628, 0x0629, 0x062a, 0x062b, 0x062c, 0x062d, 0x062e, 0x062f,
3403     0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637,
3404     0x0638, 0x0639, 0x063a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
3405     0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647,
3406     0x0648, 0x0649, 0x064a, 0x064b, 0x064c, 0x064d, 0x064e, 0x064f,
3407     0x0650, 0x0651, 0x0652, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
3408     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
3409 };
3410
3411 static unsigned char const xmltranscodetable_ISO8859_6 [48 + 5 * 64] = {
3412     "\x02\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3413     "\x00\x00\x00\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00"
3414     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3415     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3416     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3417     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3418     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3419     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3420     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3421     "\xa0\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00"
3422     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3423     "\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3424     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3425     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3426     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3427     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00"
3428     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbf"
3429     "\x00\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
3430     "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\x00\x00\x00\x00\x00"
3431     "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
3432     "\xf0\xf1\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3433     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3434     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3435 };
3436
3437 static unsigned short const xmlunicodetable_ISO8859_7 [128] = {
3438     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3439     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3440     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3441     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3442     0x00a0, 0x2018, 0x2019, 0x00a3, 0x0000, 0x0000, 0x00a6, 0x00a7,
3443     0x00a8, 0x00a9, 0x0000, 0x00ab, 0x00ac, 0x00ad, 0x0000, 0x2015,
3444     0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x0384, 0x0385, 0x0386, 0x00b7,
3445     0x0388, 0x0389, 0x038a, 0x00bb, 0x038c, 0x00bd, 0x038e, 0x038f,
3446     0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
3447     0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f,
3448     0x03a0, 0x03a1, 0x0000, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
3449     0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
3450     0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
3451     0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
3452     0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7,
3453     0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, 0x0000,
3454 };
3455
3456 static unsigned char const xmltranscodetable_ISO8859_7 [48 + 7 * 64] = {
3457     "\x04\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x06"
3458     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3459     "\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3460     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3461     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3462     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3463     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3464     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3465     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3466     "\xa0\x00\x00\xa3\x00\x00\xa6\xa7\xa8\xa9\x00\xab\xac\xad\x00\x00"
3467     "\xb0\xb1\xb2\xb3\x00\x00\x00\xb7\x00\x00\x00\xbb\x00\xbd\x00\x00"
3468     "\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3469     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3470     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3471     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3472     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3473     "\x00\x00\x00\x00\x00\xaf\x00\x00\xa1\xa2\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     "\xff\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     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3479     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3480     "\x00\x00\x00\x00\xb4\xb5\xb6\x00\xb8\xb9\xba\x00\xbc\x00\xbe\xbf"
3481     "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
3482     "\xd0\xd1\x00\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
3483     "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
3484     "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3488 };
3489
3490 static unsigned short const xmlunicodetable_ISO8859_8 [128] = {
3491     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3492     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3493     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3494     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3495     0x00a0, 0x0000, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
3496     0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
3497     0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
3498     0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x0000,
3499     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
3500     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
3501     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
3502     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2017,
3503     0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7,
3504     0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df,
3505     0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7,
3506     0x05e8, 0x05e9, 0x05ea, 0x0000, 0x0000, 0x200e, 0x200f, 0x0000,
3507 };
3508
3509 static unsigned char const xmltranscodetable_ISO8859_8 [48 + 7 * 64] = {
3510     "\x02\x00\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3511     "\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00"
3512     "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3513     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3514     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3515     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3516     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3517     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3518     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3519     "\xa0\x00\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\x00\xab\xac\xad\xae\xaf"
3520     "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\x00\xbb\xbc\xbd\xbe\x00"
3521     "\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3522     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3523     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3524     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3525     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3526     "\x00\x00\x00\x00\x00\x00\x00\xaa\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\xba\x00\x00\x00\x00\x00\x00\x00\x00"
3529     "\x05\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     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3532     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3533     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xfe"
3534     "\x00\x00\x00\x00\x00\x00\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00"
3535     "\x00\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     "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
3539     "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\x00\x00\x00\x00\x00"
3540     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3541 };
3542
3543 static unsigned short const xmlunicodetable_ISO8859_9 [128] = {
3544     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3545     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3546     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3547     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3548     0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
3549     0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
3550     0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
3551     0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
3552     0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
3553     0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
3554     0x011e, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
3555     0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0130, 0x015e, 0x00df,
3556     0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
3557     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
3558     0x011f, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
3559     0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0131, 0x015f, 0x00ff,
3560 };
3561
3562 static unsigned char const xmltranscodetable_ISO8859_9 [48 + 5 * 64] = {
3563     "\x00\x00\x01\x02\x03\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3564     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3565     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3566     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3567     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3568     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3569     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3570     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3571     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3572     "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf"
3573     "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
3574     "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
3575     "\x00\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\x00\x00\xdf"
3576     "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
3577     "\x00\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\x00\x00\xff"
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\xd0\xf0"
3580     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3581     "\xdd\xfd\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\xde\xfe"
3584     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3585     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3586 };
3587
3588 static unsigned short const xmlunicodetable_ISO8859_10 [128] = {
3589     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3590     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3591     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3592     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3593     0x00a0, 0x0104, 0x0112, 0x0122, 0x012a, 0x0128, 0x0136, 0x00a7,
3594     0x013b, 0x0110, 0x0160, 0x0166, 0x017d, 0x00ad, 0x016a, 0x014a,
3595     0x00b0, 0x0105, 0x0113, 0x0123, 0x012b, 0x0129, 0x0137, 0x00b7,
3596     0x013c, 0x0111, 0x0161, 0x0167, 0x017e, 0x2015, 0x016b, 0x014b,
3597     0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e,
3598     0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x00cf,
3599     0x00d0, 0x0145, 0x014c, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x0168,
3600     0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
3601     0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f,
3602     0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x00ef,
3603     0x00f0, 0x0146, 0x014d, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x0169,
3604     0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x0138,
3605 };
3606
3607 static unsigned char const xmltranscodetable_ISO8859_10 [48 + 7 * 64] = {
3608     "\x00\x00\x01\x06\x02\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3609     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3610     "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3611     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3612     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3613     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3614     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3615     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3616     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3617     "\xa0\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x00\x00\xad\x00\x00"
3618     "\xb0\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00"
3619     "\xc0\xe0\x00\x00\xa1\xb1\x00\x00\x00\x00\x00\x00\xc8\xe8\x00\x00"
3620     "\xa9\xb9\xa2\xb2\x00\x00\xcc\xec\xca\xea\x00\x00\x00\x00\x00\x00"
3621     "\x00\x00\xa3\xb3\x00\x00\x00\x00\xa5\xb5\xa4\xb4\x00\x00\xc7\xe7"
3622     "\x00\x00\x00\x00\x00\x00\xa6\xb6\xff\x00\x00\xa8\xb8\x00\x00\x00"
3623     "\x00\x00\x00\x00\x00\xd1\xf1\x00\x00\x00\xaf\xbf\xd2\xf2\x00\x00"
3624     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3625     "\xaa\xba\x00\x00\x00\x00\xab\xbb\xd7\xf7\xae\xbe\x00\x00\x00\x00"
3626     "\x00\x00\xd9\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\xbc\x00"
3627     "\x05\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     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3630     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3631     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3632     "\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3633     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3634     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3635     "\x00\xc1\xc2\xc3\xc4\xc5\xc6\x00\x00\xc9\x00\xcb\x00\xcd\xce\xcf"
3636     "\xd0\x00\x00\xd3\xd4\xd5\xd6\x00\xd8\x00\xda\xdb\xdc\xdd\xde\xdf"
3637     "\x00\xe1\xe2\xe3\xe4\xe5\xe6\x00\x00\xe9\x00\xeb\x00\xed\xee\xef"
3638     "\xf0\x00\x00\xf3\xf4\xf5\xf6\x00\xf8\x00\xfa\xfb\xfc\xfd\xfe\x00"
3639 };
3640
3641 static unsigned short const xmlunicodetable_ISO8859_11 [128] = {
3642     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3643     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3644     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3645     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3646     0x00a0, 0x0e01, 0x0e02, 0x0e03, 0x0e04, 0x0e05, 0x0e06, 0x0e07,
3647     0x0e08, 0x0e09, 0x0e0a, 0x0e0b, 0x0e0c, 0x0e0d, 0x0e0e, 0x0e0f,
3648     0x0e10, 0x0e11, 0x0e12, 0x0e13, 0x0e14, 0x0e15, 0x0e16, 0x0e17,
3649     0x0e18, 0x0e19, 0x0e1a, 0x0e1b, 0x0e1c, 0x0e1d, 0x0e1e, 0x0e1f,
3650     0x0e20, 0x0e21, 0x0e22, 0x0e23, 0x0e24, 0x0e25, 0x0e26, 0x0e27,
3651     0x0e28, 0x0e29, 0x0e2a, 0x0e2b, 0x0e2c, 0x0e2d, 0x0e2e, 0x0e2f,
3652     0x0e30, 0x0e31, 0x0e32, 0x0e33, 0x0e34, 0x0e35, 0x0e36, 0x0e37,
3653     0x0e38, 0x0e39, 0x0e3a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0e3f,
3654     0x0e40, 0x0e41, 0x0e42, 0x0e43, 0x0e44, 0x0e45, 0x0e46, 0x0e47,
3655     0x0e48, 0x0e49, 0x0e4a, 0x0e4b, 0x0e4c, 0x0e4d, 0x0e4e, 0x0e4f,
3656     0x0e50, 0x0e51, 0x0e52, 0x0e53, 0x0e54, 0x0e55, 0x0e56, 0x0e57,
3657     0x0e58, 0x0e59, 0x0e5a, 0x0e5b, 0x0000, 0x0000, 0x0000, 0x0000,
3658 };
3659
3660 static unsigned char const xmltranscodetable_ISO8859_11 [48 + 6 * 64] = {
3661     "\x04\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3662     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3663     "\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3664     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3665     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3666     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3667     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3668     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3669     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3670     "\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3671     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3672     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3673     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3674     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3675     "\x00\x00\x00\x00\x00\x00\x00\x00\x03\x05\x00\x00\x00\x00\x00\x00"
3676     "\x00\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf"
3677     "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
3678     "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
3679     "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\x00\x00\x00\x00\xdf"
3680     "\xff\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     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3683     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3684     "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
3685     "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\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 };
3689
3690 static unsigned short const xmlunicodetable_ISO8859_13 [128] = {
3691     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3692     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3693     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3694     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3695     0x00a0, 0x201d, 0x00a2, 0x00a3, 0x00a4, 0x201e, 0x00a6, 0x00a7,
3696     0x00d8, 0x00a9, 0x0156, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00c6,
3697     0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x201c, 0x00b5, 0x00b6, 0x00b7,
3698     0x00f8, 0x00b9, 0x0157, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00e6,
3699     0x0104, 0x012e, 0x0100, 0x0106, 0x00c4, 0x00c5, 0x0118, 0x0112,
3700     0x010c, 0x00c9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012a, 0x013b,
3701     0x0160, 0x0143, 0x0145, 0x00d3, 0x014c, 0x00d5, 0x00d6, 0x00d7,
3702     0x0172, 0x0141, 0x015a, 0x016a, 0x00dc, 0x017b, 0x017d, 0x00df,
3703     0x0105, 0x012f, 0x0101, 0x0107, 0x00e4, 0x00e5, 0x0119, 0x0113,
3704     0x010d, 0x00e9, 0x017a, 0x0117, 0x0123, 0x0137, 0x012b, 0x013c,
3705     0x0161, 0x0144, 0x0146, 0x00f3, 0x014d, 0x00f5, 0x00f6, 0x00f7,
3706     0x0173, 0x0142, 0x015b, 0x016b, 0x00fc, 0x017c, 0x017e, 0x2019,
3707 };
3708
3709 static unsigned char const xmltranscodetable_ISO8859_13 [48 + 7 * 64] = {
3710     "\x00\x00\x01\x04\x06\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3711     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3712     "\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3713     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3714     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3715     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3716     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3717     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3718     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3719     "\xa0\x00\xa2\xa3\xa4\x00\xa6\xa7\x00\xa9\x00\xab\xac\xad\xae\x00"
3720     "\xb0\xb1\xb2\xb3\x00\xb5\xb6\xb7\x00\xb9\x00\xbb\xbc\xbd\xbe\x00"
3721     "\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3722     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3723     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3724     "\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\xb4\xa1\xa5\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\xc4\xc5\xaf\x00\x00\xc9\x00\x00\x00\x00\x00\x00"
3730     "\x00\x00\x00\xd3\x00\xd5\xd6\xd7\xa8\x00\x00\x00\xdc\x00\x00\xdf"
3731     "\x00\x00\x00\x00\xe4\xe5\xbf\x00\x00\xe9\x00\x00\x00\x00\x00\x00"
3732     "\x00\x00\x00\xf3\x00\xf5\xf6\xf7\xb8\x00\x00\x00\xfc\x00\x00\x00"
3733     "\x00\xd9\xf9\xd1\xf1\xd2\xf2\x00\x00\x00\x00\x00\xd4\xf4\x00\x00"
3734     "\x00\x00\x00\x00\x00\x00\xaa\xba\x00\x00\xda\xfa\x00\x00\x00\x00"
3735     "\xd0\xf0\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfb\x00\x00\x00\x00"
3736     "\x00\x00\xd8\xf8\x00\x00\x00\x00\x00\xca\xea\xdd\xfd\xde\xfe\x00"
3737     "\xc2\xe2\x00\x00\xc0\xe0\xc3\xe3\x00\x00\x00\x00\xc8\xe8\x00\x00"
3738     "\x00\x00\xc7\xe7\x00\x00\xcb\xeb\xc6\xe6\x00\x00\x00\x00\x00\x00"
3739     "\x00\x00\xcc\xec\x00\x00\x00\x00\x00\x00\xce\xee\x00\x00\xc1\xe1"
3740     "\x00\x00\x00\x00\x00\x00\xcd\xed\x00\x00\x00\xcf\xef\x00\x00\x00"
3741 };
3742
3743 static unsigned short const xmlunicodetable_ISO8859_14 [128] = {
3744     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3745     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3746     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3747     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3748     0x00a0, 0x1e02, 0x1e03, 0x00a3, 0x010a, 0x010b, 0x1e0a, 0x00a7,
3749     0x1e80, 0x00a9, 0x1e82, 0x1e0b, 0x1ef2, 0x00ad, 0x00ae, 0x0178,
3750     0x1e1e, 0x1e1f, 0x0120, 0x0121, 0x1e40, 0x1e41, 0x00b6, 0x1e56,
3751     0x1e81, 0x1e57, 0x1e83, 0x1e60, 0x1ef3, 0x1e84, 0x1e85, 0x1e61,
3752     0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
3753     0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
3754     0x0174, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x1e6a,
3755     0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x0176, 0x00df,
3756     0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
3757     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
3758     0x0175, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x1e6b,
3759     0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x0177, 0x00ff,
3760 };
3761
3762 static unsigned char const xmltranscodetable_ISO8859_14 [48 + 10 * 64] = {
3763     "\x00\x00\x01\x09\x04\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3764     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3765     "\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3766     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3767     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3768     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3769     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3770     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3771     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3772     "\xa0\x00\x00\xa3\x00\x00\x00\xa7\x00\xa9\x00\x00\x00\xad\xae\x00"
3773     "\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3774     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3775     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3776     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3777     "\x00\x00\x00\x00\x00\x00\x00\x00\x03\x08\x05\x06\x00\x00\x00\x00"
3778     "\x00\x00\xa1\xa2\x00\x00\x00\x00\x00\x00\xa6\xab\x00\x00\x00\x00"
3779     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xb1"
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\xa4\xa5\x00\x00\x00\x00"
3783     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3784     "\xb2\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3785     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3786     "\xa8\xb8\xaa\xba\xbd\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3787     "\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00"
3792     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3793     "\x00\x00\xac\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
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\x00\x00\x00\x00\x00\x00"
3797     "\x00\x00\x00\x00\xd0\xf0\xde\xfe\xaf\x00\x00\x00\x00\x00\x00\x00"
3798     "\xb4\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3799     "\x00\x00\x00\x00\x00\x00\xb7\xb9\x00\x00\x00\x00\x00\x00\x00\x00"
3800     "\xbb\xbf\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xf7\x00\x00\x00\x00"
3801     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3802     "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
3803     "\x00\xd1\xd2\xd3\xd4\xd5\xd6\x00\xd8\xd9\xda\xdb\xdc\xdd\x00\xdf"
3804     "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
3805     "\x00\xf1\xf2\xf3\xf4\xf5\xf6\x00\xf8\xf9\xfa\xfb\xfc\xfd\x00\xff"
3806 };
3807
3808 static unsigned short const xmlunicodetable_ISO8859_15 [128] = {
3809     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3810     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3811     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3812     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3813     0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20ac, 0x00a5, 0x0160, 0x00a7,
3814     0x0161, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
3815     0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x017d, 0x00b5, 0x00b6, 0x00b7,
3816     0x017e, 0x00b9, 0x00ba, 0x00bb, 0x0152, 0x0153, 0x0178, 0x00bf,
3817     0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
3818     0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
3819     0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
3820     0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
3821     0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
3822     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
3823     0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
3824     0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff,
3825 };
3826
3827 static unsigned char const xmltranscodetable_ISO8859_15 [48 + 6 * 64] = {
3828     "\x00\x00\x01\x05\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3829     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3830     "\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3831     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3832     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3833     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3834     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3835     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3836     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3837     "\xa0\xa1\xa2\xa3\x00\xa5\x00\xa7\x00\xa9\xaa\xab\xac\xad\xae\xaf"
3838     "\xb0\xb1\xb2\xb3\x00\xb5\xb6\xb7\x00\xb9\xba\xbb\x00\x00\x00\xbf"
3839     "\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3840     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3841     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3842     "\x00\x00\x00\x00\x00\x00\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\x00\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\xa4\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\xbc\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3849     "\xa6\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3850     "\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\xb4\xb8\x00"
3851     "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
3852     "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
3853     "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
3854     "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
3855 };
3856
3857 static unsigned short const xmlunicodetable_ISO8859_16 [128] = {
3858     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
3859     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
3860     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
3861     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
3862     0x00a0, 0x0104, 0x0105, 0x0141, 0x20ac, 0x201e, 0x0160, 0x00a7,
3863     0x0161, 0x00a9, 0x0218, 0x00ab, 0x0179, 0x00ad, 0x017a, 0x017b,
3864     0x00b0, 0x00b1, 0x010c, 0x0142, 0x017d, 0x201d, 0x00b6, 0x00b7,
3865     0x017e, 0x010d, 0x0219, 0x00bb, 0x0152, 0x0153, 0x0178, 0x017c,
3866     0x00c0, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0106, 0x00c6, 0x00c7,
3867     0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
3868     0x0110, 0x0143, 0x00d2, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x015a,
3869     0x0170, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0118, 0x021a, 0x00df,
3870     0x00e0, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x0107, 0x00e6, 0x00e7,
3871     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
3872     0x0111, 0x0144, 0x00f2, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x015b,
3873     0x0171, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0119, 0x021b, 0x00ff,
3874 };
3875
3876 static unsigned char const xmltranscodetable_ISO8859_16 [48 + 9 * 64] = {
3877     "\x00\x00\x01\x08\x02\x03\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00"
3878     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3879     "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3880     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3881     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3882     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3883     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3884     "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
3885     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
3886     "\xa0\x00\x00\x00\x00\x00\x00\xa7\x00\xa9\x00\xab\x00\xad\x00\x00"
3887     "\xb0\xb1\x00\x00\x00\x00\xb6\xb7\x00\x00\x00\xbb\x00\x00\x00\x00"
3888     "\x00\x00\xc3\xe3\xa1\xa2\xc5\xe5\x00\x00\x00\x00\xb2\xb9\x00\x00"
3889     "\xd0\xf0\x00\x00\x00\x00\x00\x00\xdd\xfd\x00\x00\x00\x00\x00\x00"
3890     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3891     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3892     "\x00\xa3\xb3\xd1\xf1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3893     "\xd5\xf5\xbc\xbd\x00\x00\x00\x00\x00\x00\xd7\xf7\x00\x00\x00\x00"
3894     "\xa6\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3895     "\xd8\xf8\x00\x00\x00\x00\x00\x00\xbe\xac\xae\xaf\xbf\xb4\xb8\x00"
3896     "\x06\x00\x05\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     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3899     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3900     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3901     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3902     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00"
3903     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\xa5\x00"
3906     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3907     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3908     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3909     "\x00\x00\x00\x00\x00\x00\x00\x00\xaa\xba\xde\xfe\x00\x00\x00\x00"
3910     "\x00\x00\x00\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     "\xc0\xc1\xc2\x00\xc4\x00\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
3913     "\x00\x00\xd2\xd3\xd4\x00\xd6\x00\x00\xd9\xda\xdb\xdc\x00\x00\xdf"
3914     "\xe0\xe1\xe2\x00\xe4\x00\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
3915     "\x00\x00\xf2\xf3\xf4\x00\xf6\x00\x00\xf9\xfa\xfb\xfc\x00\x00\xff"
3916 };
3917
3918
3919 /*
3920  * auto-generated functions for ISO-8859-2 .. ISO-8859-16
3921  */
3922
3923 static int ISO8859_2ToUTF8 (unsigned char* out, int *outlen,
3924     const unsigned char* in, int *inlen) {
3925     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_2);
3926 }
3927 static int UTF8ToISO8859_2 (unsigned char* out, int *outlen,
3928     const unsigned char* in, int *inlen) {
3929     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_2);
3930 }
3931
3932 static int ISO8859_3ToUTF8 (unsigned char* out, int *outlen,
3933     const unsigned char* in, int *inlen) {
3934     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_3);
3935 }
3936 static int UTF8ToISO8859_3 (unsigned char* out, int *outlen,
3937     const unsigned char* in, int *inlen) {
3938     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_3);
3939 }
3940
3941 static int ISO8859_4ToUTF8 (unsigned char* out, int *outlen,
3942     const unsigned char* in, int *inlen) {
3943     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_4);
3944 }
3945 static int UTF8ToISO8859_4 (unsigned char* out, int *outlen,
3946     const unsigned char* in, int *inlen) {
3947     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_4);
3948 }
3949
3950 static int ISO8859_5ToUTF8 (unsigned char* out, int *outlen,
3951     const unsigned char* in, int *inlen) {
3952     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_5);
3953 }
3954 static int UTF8ToISO8859_5 (unsigned char* out, int *outlen,
3955     const unsigned char* in, int *inlen) {
3956     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_5);
3957 }
3958
3959 static int ISO8859_6ToUTF8 (unsigned char* out, int *outlen,
3960     const unsigned char* in, int *inlen) {
3961     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_6);
3962 }
3963 static int UTF8ToISO8859_6 (unsigned char* out, int *outlen,
3964     const unsigned char* in, int *inlen) {
3965     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_6);
3966 }
3967
3968 static int ISO8859_7ToUTF8 (unsigned char* out, int *outlen,
3969     const unsigned char* in, int *inlen) {
3970     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_7);
3971 }
3972 static int UTF8ToISO8859_7 (unsigned char* out, int *outlen,
3973     const unsigned char* in, int *inlen) {
3974     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_7);
3975 }
3976
3977 static int ISO8859_8ToUTF8 (unsigned char* out, int *outlen,
3978     const unsigned char* in, int *inlen) {
3979     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_8);
3980 }
3981 static int UTF8ToISO8859_8 (unsigned char* out, int *outlen,
3982     const unsigned char* in, int *inlen) {
3983     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_8);
3984 }
3985
3986 static int ISO8859_9ToUTF8 (unsigned char* out, int *outlen,
3987     const unsigned char* in, int *inlen) {
3988     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_9);
3989 }
3990 static int UTF8ToISO8859_9 (unsigned char* out, int *outlen,
3991     const unsigned char* in, int *inlen) {
3992     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_9);
3993 }
3994
3995 static int ISO8859_10ToUTF8 (unsigned char* out, int *outlen,
3996     const unsigned char* in, int *inlen) {
3997     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_10);
3998 }
3999 static int UTF8ToISO8859_10 (unsigned char* out, int *outlen,
4000     const unsigned char* in, int *inlen) {
4001     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_10);
4002 }
4003
4004 static int ISO8859_11ToUTF8 (unsigned char* out, int *outlen,
4005     const unsigned char* in, int *inlen) {
4006     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_11);
4007 }
4008 static int UTF8ToISO8859_11 (unsigned char* out, int *outlen,
4009     const unsigned char* in, int *inlen) {
4010     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_11);
4011 }
4012
4013 static int ISO8859_13ToUTF8 (unsigned char* out, int *outlen,
4014     const unsigned char* in, int *inlen) {
4015     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_13);
4016 }
4017 static int UTF8ToISO8859_13 (unsigned char* out, int *outlen,
4018     const unsigned char* in, int *inlen) {
4019     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_13);
4020 }
4021
4022 static int ISO8859_14ToUTF8 (unsigned char* out, int *outlen,
4023     const unsigned char* in, int *inlen) {
4024     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_14);
4025 }
4026 static int UTF8ToISO8859_14 (unsigned char* out, int *outlen,
4027     const unsigned char* in, int *inlen) {
4028     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_14);
4029 }
4030
4031 static int ISO8859_15ToUTF8 (unsigned char* out, int *outlen,
4032     const unsigned char* in, int *inlen) {
4033     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_15);
4034 }
4035 static int UTF8ToISO8859_15 (unsigned char* out, int *outlen,
4036     const unsigned char* in, int *inlen) {
4037     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_15);
4038 }
4039
4040 static int ISO8859_16ToUTF8 (unsigned char* out, int *outlen,
4041     const unsigned char* in, int *inlen) {
4042     return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_16);
4043 }
4044 static int UTF8ToISO8859_16 (unsigned char* out, int *outlen,
4045     const unsigned char* in, int *inlen) {
4046     return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_16);
4047 }
4048
4049 static void
4050 xmlRegisterCharEncodingHandlersISO8859x (void) {
4051     xmlNewCharEncodingHandler ("ISO-8859-2", ISO8859_2ToUTF8, UTF8ToISO8859_2);
4052     xmlNewCharEncodingHandler ("ISO-8859-3", ISO8859_3ToUTF8, UTF8ToISO8859_3);
4053     xmlNewCharEncodingHandler ("ISO-8859-4", ISO8859_4ToUTF8, UTF8ToISO8859_4);
4054     xmlNewCharEncodingHandler ("ISO-8859-5", ISO8859_5ToUTF8, UTF8ToISO8859_5);
4055     xmlNewCharEncodingHandler ("ISO-8859-6", ISO8859_6ToUTF8, UTF8ToISO8859_6);
4056     xmlNewCharEncodingHandler ("ISO-8859-7", ISO8859_7ToUTF8, UTF8ToISO8859_7);
4057     xmlNewCharEncodingHandler ("ISO-8859-8", ISO8859_8ToUTF8, UTF8ToISO8859_8);
4058     xmlNewCharEncodingHandler ("ISO-8859-9", ISO8859_9ToUTF8, UTF8ToISO8859_9);
4059     xmlNewCharEncodingHandler ("ISO-8859-10", ISO8859_10ToUTF8, UTF8ToISO8859_10);
4060     xmlNewCharEncodingHandler ("ISO-8859-11", ISO8859_11ToUTF8, UTF8ToISO8859_11);
4061     xmlNewCharEncodingHandler ("ISO-8859-13", ISO8859_13ToUTF8, UTF8ToISO8859_13);
4062     xmlNewCharEncodingHandler ("ISO-8859-14", ISO8859_14ToUTF8, UTF8ToISO8859_14);
4063     xmlNewCharEncodingHandler ("ISO-8859-15", ISO8859_15ToUTF8, UTF8ToISO8859_15);
4064     xmlNewCharEncodingHandler ("ISO-8859-16", ISO8859_16ToUTF8, UTF8ToISO8859_16);
4065 }
4066
4067 #endif
4068 #endif
4069
4070 #define bottom_encoding
4071 #include "elfgcchack.h"