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