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