encoding.c@ 74745

Last change on this file since 74745 was 65950, checked in by vboxsync, 8 years ago
libxml 2.9.4: fix export
Property svn:eol-style set to `native`
File size: 145.0 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.9.4/encoding.c@ 74745

Download in other formats: