Bug Summary

File:encoding.c
Location:line 2009, column 6
Description:Value stored to 'ret' is never read

Annotated Source Code

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