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