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