| Geant4 Cross Reference |
1 /* 1
2 __ __
3 ___\ \/ /_ __ __ _|
4 / _ \\ /| '_ \ / _` |
5 | __// \| |_) | (_| |
6 \___/_/\_\ .__/ \__,_|
7 |_| XML parse
8
9 Copyright (c) 1997-2000 Thai Open Source So
10 Copyright (c) 2000 Clark Cooper <coope
11 Copyright (c) 2001-2003 Fred L. Drake, Jr.
12 Copyright (c) 2002 Greg Stein <gstein@
13 Copyright (c) 2002-2016 Karl Waclawek <karl
14 Copyright (c) 2005-2009 Steven Solie <steve
15 Copyright (c) 2016-2022 Sebastian Pipping <
16 Copyright (c) 2016 Pascal Cuoq <cuoq@t
17 Copyright (c) 2016 Don Lewis <truckman
18 Copyright (c) 2017 Rhodri James <rhodr
19 Copyright (c) 2017 Alexander Bluhm <al
20 Copyright (c) 2017 Benbuck Nason <bnas
21 Copyright (c) 2017 José Gutiérrez de
22 Copyright (c) 2019 David Loffredo <lof
23 Copyright (c) 2021 Dong-hee Na <donghe
24 Copyright (c) 2022 Martin Ettl <ettl.m
25 Licensed under the MIT license:
26
27 Permission is hereby granted, free of cha
28 a copy of this software and associat
29 "Software"), to deal in the Software w
30 without limitation the rights to use, c
31 distribute, sublicense, and/or sell copies
32 persons to whom the Software is furnish
33 following conditions:
34
35 The above copyright notice and this permis
36 in all copies or substantial portions of th
37
38 THE SOFTWARE IS PROVIDED "AS IS", WIT
39 EXPRESS OR IMPLIED, INCLUDING BUT NOT L
40 MERCHANTABILITY, FITNESS FOR A PARTICULAR P
41 NO EVENT SHALL THE AUTHORS OR COPYRIGHT HO
42 DAMAGES OR OTHER LIABILITY, WHETHER IN AN
43 OTHERWISE, ARISING FROM, OUT OF OR IN CONNE
44 USE OR OTHER DEALINGS IN THE SOFTWARE.
45 */
46
47 #include <expat_config.h>
48
49 #include <stddef.h>
50 #include <string.h> /* memcpy */
51 #include <stdbool.h>
52
53 #ifdef _WIN32
54 # include "winconfig.h"
55 #endif
56
57 #include "expat_external.h"
58 #include "internal.h"
59 #include "xmltok.h"
60 #include "nametab.h"
61
62 #ifdef XML_DTD
63 # define IGNORE_SECTION_TOK_VTABLE , PREFIX(i
64 #else
65 # define IGNORE_SECTION_TOK_VTABLE /* as noth
66 #endif
67
68 #define VTABLE1
69 {PREFIX(prologTok), PREFIX(contentTok),
70 PREFIX(cdataSectionTok) IGNORE_SECTION_TOK_
71 {PREFIX(attributeValueTok), PREFIX(entit
72 PREFIX(nameMatchesAscii), PREFIX(nameLen
73 PREFIX(getAtts), PREFIX(charRefNumber),
74 PREFIX(updatePosition), PREFIX(isPublicI
75
76 #define VTABLE VTABLE1, PREFIX(toUtf8), PREFIX
77
78 #define UCS2_GET_NAMING(pages, hi, lo)
79 (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)
80
81 /* A 2 byte UTF-8 representation splits the ch
82 the bottom 5 and 6 bits of the bytes. We n
83 pages, 3 bits to add to that index and 5 bi
84 */
85 #define UTF8_GET_NAMING2(pages, byte)
86 (namingBitmap[((pages)[(((byte)[0]) >> 2) &
87 + ((((byte)[0]) & 3) << 1) + (
88 & (1u << (((byte)[1]) & 0x1F)))
89
90 /* A 3 byte UTF-8 representation splits the ch
91 the bottom 4, 6 and 6 bits of the bytes. W
92 into pages, 3 bits to add to that index and
93 mask.
94 */
95 #define UTF8_GET_NAMING3(pages, byte)
96 (namingBitmap
97 [((pages)[((((byte)[0]) & 0xF) << 4) +
98 << 3)
99 + ((((byte)[1]) & 3) << 1) + ((((byte)
100 & (1u << (((byte)[2]) & 0x1F)))
101
102 /* Detection of invalid UTF-8 sequences is bas
103 of Unicode 3.2: http://www.unicode.org/unic
104 with the additional restriction of not allo
105 code points 0xFFFF and 0xFFFE (sequences EF
106 Implementation details:
107 (A & 0x80) == 0 means A < 0x80
108 and
109 (A & 0xC0) == 0xC0 means A > 0xBF
110 */
111
112 #define UTF8_INVALID2(p)
113 ((*p) < 0xC2 || ((p)[1] & 0x80) == 0 || ((p)
114
115 #define UTF8_INVALID3(p)
116 (((p)[2] & 0x80) == 0
117 || ((*p) == 0xEF && (p)[1] == 0xBF ? (p)[2]
118 : ((p)[2
119 || ((*p) == 0xE0
120 ? (p)[1] < 0xA0 || ((p)[1] & 0xC0)
121 : ((p)[1] & 0x80) == 0
122 || ((*p) == 0xED ? (p)[1] > 0
123
124 #define UTF8_INVALID4(p)
125 (((p)[3] & 0x80) == 0 || ((p)[3] & 0xC0) ==
126 || ((p)[2] & 0xC0) == 0xC0
127 || ((*p) == 0xF0
128 ? (p)[1] < 0x90 || ((p)[1] & 0xC0)
129 : ((p)[1] & 0x80) == 0
130 || ((*p) == 0xF4 ? (p)[1] > 0
131
132 static int PTRFASTCALL
133 isNever(const ENCODING *enc, const char *p) {
134 UNUSED_P(enc);
135 UNUSED_P(p);
136 return 0;
137 }
138
139 static int PTRFASTCALL
140 utf8_isName2(const ENCODING *enc, const char *
141 UNUSED_P(enc);
142 return UTF8_GET_NAMING2(namePages, (const un
143 }
144
145 static int PTRFASTCALL
146 utf8_isName3(const ENCODING *enc, const char *
147 UNUSED_P(enc);
148 return UTF8_GET_NAMING3(namePages, (const un
149 }
150
151 #define utf8_isName4 isNever
152
153 static int PTRFASTCALL
154 utf8_isNmstrt2(const ENCODING *enc, const char
155 UNUSED_P(enc);
156 return UTF8_GET_NAMING2(nmstrtPages, (const
157 }
158
159 static int PTRFASTCALL
160 utf8_isNmstrt3(const ENCODING *enc, const char
161 UNUSED_P(enc);
162 return UTF8_GET_NAMING3(nmstrtPages, (const
163 }
164
165 #define utf8_isNmstrt4 isNever
166
167 static int PTRFASTCALL
168 utf8_isInvalid2(const ENCODING *enc, const cha
169 UNUSED_P(enc);
170 return UTF8_INVALID2((const unsigned char *)
171 }
172
173 static int PTRFASTCALL
174 utf8_isInvalid3(const ENCODING *enc, const cha
175 UNUSED_P(enc);
176 return UTF8_INVALID3((const unsigned char *)
177 }
178
179 static int PTRFASTCALL
180 utf8_isInvalid4(const ENCODING *enc, const cha
181 UNUSED_P(enc);
182 return UTF8_INVALID4((const unsigned char *)
183 }
184
185 struct normal_encoding {
186 ENCODING enc;
187 unsigned char type[256];
188 #ifdef XML_MIN_SIZE
189 int(PTRFASTCALL *byteType)(const ENCODING *,
190 int(PTRFASTCALL *isNameMin)(const ENCODING *
191 int(PTRFASTCALL *isNmstrtMin)(const ENCODING
192 int(PTRFASTCALL *byteToAscii)(const ENCODING
193 int(PTRCALL *charMatches)(const ENCODING *,
194 #endif /* XML_MIN_SIZE */
195 int(PTRFASTCALL *isName2)(const ENCODING *,
196 int(PTRFASTCALL *isName3)(const ENCODING *,
197 int(PTRFASTCALL *isName4)(const ENCODING *,
198 int(PTRFASTCALL *isNmstrt2)(const ENCODING *
199 int(PTRFASTCALL *isNmstrt3)(const ENCODING *
200 int(PTRFASTCALL *isNmstrt4)(const ENCODING *
201 int(PTRFASTCALL *isInvalid2)(const ENCODING
202 int(PTRFASTCALL *isInvalid3)(const ENCODING
203 int(PTRFASTCALL *isInvalid4)(const ENCODING
204 };
205
206 #define AS_NORMAL_ENCODING(enc) ((const struct
207
208 #ifdef XML_MIN_SIZE
209
210 # define STANDARD_VTABLE(E)
211 E##byteType, E##isNameMin, E##isNmstrtMin,
212
213 #else
214
215 # define STANDARD_VTABLE(E) /* as nothing */
216
217 #endif
218
219 #define NORMAL_VTABLE(E)
220 E##isName2, E##isName3, E##isName4, E##isNms
221 E##isNmstrt4, E##isInvalid2, E##isInvali
222
223 #define NULL_VTABLE
224 /* isName2 */ NULL, /* isName3 */ NULL, /* i
225 /* isNmstrt2 */ NULL, /* isNmstrt3 */ NU
226 /* isInvalid2 */ NULL, /* isInvalid3 */
227
228 static int FASTCALL checkCharRefNumber(int);
229
230 #include "xmltok_impl.h"
231 #include "ascii.h"
232
233 #ifdef XML_MIN_SIZE
234 # define sb_isNameMin isNever
235 # define sb_isNmstrtMin isNever
236 #endif
237
238 #ifdef XML_MIN_SIZE
239 # define MINBPC(enc) ((enc)->minBytesPerChar)
240 #else
241 /* minimum bytes per character */
242 # define MINBPC(enc) 1
243 #endif
244
245 #define SB_BYTE_TYPE(enc, p)
246 (((struct normal_encoding *)(enc))->type[(un
247
248 #ifdef XML_MIN_SIZE
249 static int PTRFASTCALL
250 sb_byteType(const ENCODING *enc, const char *p
251 return SB_BYTE_TYPE(enc, p);
252 }
253 # define BYTE_TYPE(enc, p) (AS_NORMAL_ENCODIN
254 #else
255 # define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc,
256 #endif
257
258 #ifdef XML_MIN_SIZE
259 # define BYTE_TO_ASCII(enc, p) (AS_NORMAL_ENC
260 static int PTRFASTCALL
261 sb_byteToAscii(const ENCODING *enc, const char
262 UNUSED_P(enc);
263 return *p;
264 }
265 #else
266 # define BYTE_TO_ASCII(enc, p) (*(p))
267 #endif
268
269 #define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENC
270 #define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_E
271 #ifdef XML_MIN_SIZE
272 # define IS_INVALID_CHAR(enc, p, n)
273 (AS_NORMAL_ENCODING(enc)->isInvalid##n
274 && AS_NORMAL_ENCODING(enc)->isInvalid##n(
275 #else
276 # define IS_INVALID_CHAR(enc, p, n)
277 (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc
278 #endif
279
280 #ifdef XML_MIN_SIZE
281 # define IS_NAME_CHAR_MINBPC(enc, p)
282 (AS_NORMAL_ENCODING(enc)->isNameMin(enc, p
283 # define IS_NMSTRT_CHAR_MINBPC(enc, p)
284 (AS_NORMAL_ENCODING(enc)->isNmstrtMin(enc,
285 #else
286 # define IS_NAME_CHAR_MINBPC(enc, p) (0)
287 # define IS_NMSTRT_CHAR_MINBPC(enc, p) (0)
288 #endif
289
290 #ifdef XML_MIN_SIZE
291 # define CHAR_MATCHES(enc, p, c)
292 (AS_NORMAL_ENCODING(enc)->charMatches(enc,
293 static int PTRCALL
294 sb_charMatches(const ENCODING *enc, const char
295 UNUSED_P(enc);
296 return *p == c;
297 }
298 #else
299 /* c is an ASCII character */
300 # define CHAR_MATCHES(enc, p, c) (*(p) == (c)
301 #endif
302
303 #define PREFIX(ident) normal_##ident
304 #define XML_TOK_IMPL_C
305 #include "xmltok_impl.c"
306 #undef XML_TOK_IMPL_C
307
308 #undef MINBPC
309 #undef BYTE_TYPE
310 #undef BYTE_TO_ASCII
311 #undef CHAR_MATCHES
312 #undef IS_NAME_CHAR
313 #undef IS_NAME_CHAR_MINBPC
314 #undef IS_NMSTRT_CHAR
315 #undef IS_NMSTRT_CHAR_MINBPC
316 #undef IS_INVALID_CHAR
317
318 enum { /* UTF8_cvalN is value of masked first
319 UTF8_cval1 = 0x00,
320 UTF8_cval2 = 0xc0,
321 UTF8_cval3 = 0xe0,
322 UTF8_cval4 = 0xf0
323 };
324
325 void
326 _INTERNAL_trim_to_complete_utf8_characters(con
327 con
328 const char *fromLim = *fromLimRef;
329 size_t walked = 0;
330 for (; fromLim > from; fromLim--, walked++)
331 const unsigned char prev = (unsigned char)
332 if ((prev & 0xf8u)
333 == 0xf0u) { /* 4-byte character, lead
334 if (walked + 1 >= 4) {
335 fromLim += 4 - 1;
336 break;
337 } else {
338 walked = 0;
339 }
340 } else if ((prev & 0xf0u)
341 == 0xe0u) { /* 3-byte character
342 if (walked + 1 >= 3) {
343 fromLim += 3 - 1;
344 break;
345 } else {
346 walked = 0;
347 }
348 } else if ((prev & 0xe0u)
349 == 0xc0u) { /* 2-byte character
350 if (walked + 1 >= 2) {
351 fromLim += 2 - 1;
352 break;
353 } else {
354 walked = 0;
355 }
356 } else if ((prev & 0x80u)
357 == 0x00u) { /* 1-byte character
358 break;
359 }
360 }
361 *fromLimRef = fromLim;
362 }
363
364 static enum XML_Convert_Result PTRCALL
365 utf8_toUtf8(const ENCODING *enc, const char **
366 char **toP, const char *toLim) {
367 bool input_incomplete = false;
368 bool output_exhausted = false;
369
370 /* Avoid copying partial characters (due to
371 const ptrdiff_t bytesAvailable = fromLim - *
372 const ptrdiff_t bytesStorable = toLim - *toP
373 UNUSED_P(enc);
374 if (bytesAvailable > bytesStorable) {
375 fromLim = *fromP + bytesStorable;
376 output_exhausted = true;
377 }
378
379 /* Avoid copying partial characters (from in
380 {
381 const char *const fromLimBefore = fromLim;
382 _INTERNAL_trim_to_complete_utf8_characters
383 if (fromLim < fromLimBefore) {
384 input_incomplete = true;
385 }
386 }
387
388 {
389 const ptrdiff_t bytesToCopy = fromLim - *f
390 memcpy(*toP, *fromP, bytesToCopy);
391 *fromP += bytesToCopy;
392 *toP += bytesToCopy;
393 }
394
395 if (output_exhausted) /* needs to go first *
396 return XML_CONVERT_OUTPUT_EXHAUSTED;
397 else if (input_incomplete)
398 return XML_CONVERT_INPUT_INCOMPLETE;
399 else
400 return XML_CONVERT_COMPLETED;
401 }
402
403 static enum XML_Convert_Result PTRCALL
404 utf8_toUtf16(const ENCODING *enc, const char *
405 unsigned short **toP, const unsig
406 enum XML_Convert_Result res = XML_CONVERT_CO
407 unsigned short *to = *toP;
408 const char *from = *fromP;
409 while (from < fromLim && to < toLim) {
410 switch (((struct normal_encoding *)enc)->t
411 case BT_LEAD2:
412 if (fromLim - from < 2) {
413 res = XML_CONVERT_INPUT_INCOMPLETE;
414 goto after;
415 }
416 *to++ = (unsigned short)(((from[0] & 0x1
417 from += 2;
418 break;
419 case BT_LEAD3:
420 if (fromLim - from < 3) {
421 res = XML_CONVERT_INPUT_INCOMPLETE;
422 goto after;
423 }
424 *to++ = (unsigned short)(((from[0] & 0xf
425 | (from[2] & 0x
426 from += 3;
427 break;
428 case BT_LEAD4: {
429 unsigned long n;
430 if (toLim - to < 2) {
431 res = XML_CONVERT_OUTPUT_EXHAUSTED;
432 goto after;
433 }
434 if (fromLim - from < 4) {
435 res = XML_CONVERT_INPUT_INCOMPLETE;
436 goto after;
437 }
438 n = ((from[0] & 0x7) << 18) | ((from[1]
439 | ((from[2] & 0x3f) << 6) | (from[3]
440 n -= 0x10000;
441 to[0] = (unsigned short)((n >> 10) | 0xD
442 to[1] = (unsigned short)((n & 0x3FF) | 0
443 to += 2;
444 from += 4;
445 } break;
446 default:
447 *to++ = *from++;
448 break;
449 }
450 }
451 if (from < fromLim)
452 res = XML_CONVERT_OUTPUT_EXHAUSTED;
453 after:
454 *fromP = from;
455 *toP = to;
456 return res;
457 }
458
459 #ifdef XML_NS
460 static const struct normal_encoding utf8_encod
461 = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1,
462 {
463 # include "asciitab.h"
464 # include "utf8tab.h"
465 },
466 STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8
467 #endif
468
469 static const struct normal_encoding utf8_encod
470 = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1,
471 {
472 #define BT_COLON BT_NMSTRT
473 #include "asciitab.h"
474 #undef BT_COLON
475 #include "utf8tab.h"
476 },
477 STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8
478
479 #ifdef XML_NS
480
481 static const struct normal_encoding internal_u
482 = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1,
483 {
484 # include "iasciitab.h"
485 # include "utf8tab.h"
486 },
487 STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8
488
489 #endif
490
491 static const struct normal_encoding internal_u
492 = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1,
493 {
494 #define BT_COLON BT_NMSTRT
495 #include "iasciitab.h"
496 #undef BT_COLON
497 #include "utf8tab.h"
498 },
499 STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8
500
501 static enum XML_Convert_Result PTRCALL
502 latin1_toUtf8(const ENCODING *enc, const char
503 char **toP, const char *toLim) {
504 UNUSED_P(enc);
505 for (;;) {
506 unsigned char c;
507 if (*fromP == fromLim)
508 return XML_CONVERT_COMPLETED;
509 c = (unsigned char)**fromP;
510 if (c & 0x80) {
511 if (toLim - *toP < 2)
512 return XML_CONVERT_OUTPUT_EXHAUSTED;
513 *(*toP)++ = (char)((c >> 6) | UTF8_cval2
514 *(*toP)++ = (char)((c & 0x3f) | 0x80);
515 (*fromP)++;
516 } else {
517 if (*toP == toLim)
518 return XML_CONVERT_OUTPUT_EXHAUSTED;
519 *(*toP)++ = *(*fromP)++;
520 }
521 }
522 }
523
524 static enum XML_Convert_Result PTRCALL
525 latin1_toUtf16(const ENCODING *enc, const char
526 unsigned short **toP, const uns
527 UNUSED_P(enc);
528 while (*fromP < fromLim && *toP < toLim)
529 *(*toP)++ = (unsigned char)*(*fromP)++;
530
531 if ((*toP == toLim) && (*fromP < fromLim))
532 return XML_CONVERT_OUTPUT_EXHAUSTED;
533 else
534 return XML_CONVERT_COMPLETED;
535 }
536
537 #ifdef XML_NS
538
539 static const struct normal_encoding latin1_enc
540 = {{VTABLE1, latin1_toUtf8, latin1_toUtf16
541 {
542 # include "asciitab.h"
543 # include "latin1tab.h"
544 },
545 STANDARD_VTABLE(sb_) NULL_VTABLE};
546
547 #endif
548
549 static const struct normal_encoding latin1_enc
550 = {{VTABLE1, latin1_toUtf8, latin1_toUtf16
551 {
552 #define BT_COLON BT_NMSTRT
553 #include "asciitab.h"
554 #undef BT_COLON
555 #include "latin1tab.h"
556 },
557 STANDARD_VTABLE(sb_) NULL_VTABLE};
558
559 static enum XML_Convert_Result PTRCALL
560 ascii_toUtf8(const ENCODING *enc, const char *
561 char **toP, const char *toLim) {
562 UNUSED_P(enc);
563 while (*fromP < fromLim && *toP < toLim)
564 *(*toP)++ = *(*fromP)++;
565
566 if ((*toP == toLim) && (*fromP < fromLim))
567 return XML_CONVERT_OUTPUT_EXHAUSTED;
568 else
569 return XML_CONVERT_COMPLETED;
570 }
571
572 #ifdef XML_NS
573
574 static const struct normal_encoding ascii_enco
575 = {{VTABLE1, ascii_toUtf8, latin1_toUtf16,
576 {
577 # include "asciitab.h"
578 /* BT_NONXML == 0 */
579 },
580 STANDARD_VTABLE(sb_) NULL_VTABLE};
581
582 #endif
583
584 static const struct normal_encoding ascii_enco
585 = {{VTABLE1, ascii_toUtf8, latin1_toUtf16,
586 {
587 #define BT_COLON BT_NMSTRT
588 #include "asciitab.h"
589 #undef BT_COLON
590 /* BT_NONXML == 0 */
591 },
592 STANDARD_VTABLE(sb_) NULL_VTABLE};
593
594 static int PTRFASTCALL
595 unicode_byte_type(char hi, char lo) {
596 switch ((unsigned char)hi) {
597 /* 0xD800-0xDBFF first 16-bit code unit or h
598 case 0xD8:
599 case 0xD9:
600 case 0xDA:
601 case 0xDB:
602 return BT_LEAD4;
603 /* 0xDC00-0xDFFF second 16-bit code unit or
604 case 0xDC:
605 case 0xDD:
606 case 0xDE:
607 case 0xDF:
608 return BT_TRAIL;
609 case 0xFF:
610 switch ((unsigned char)lo) {
611 case 0xFF: /* noncharacter-FFFF */
612 case 0xFE: /* noncharacter-FFFE */
613 return BT_NONXML;
614 }
615 break;
616 }
617 return BT_NONASCII;
618 }
619
620 #define DEFINE_UTF16_TO_UTF8(E)
621 static enum XML_Convert_Result PTRCALL E##to
622 const ENCODING *enc, const char **fromP,
623 char **toP, const char *toLim) {
624 const char *from = *fromP;
625 UNUSED_P(enc);
626 fromLim = from + (((fromLim - from) >> 1)
627 for (; from < fromLim; from += 2) {
628 int plane;
629 unsigned char lo2;
630 unsigned char lo = GET_LO(from);
631 unsigned char hi = GET_HI(from);
632 switch (hi) {
633 case 0:
634 if (lo < 0x80) {
635 if (*toP == toLim) {
636 *fromP = from;
637 return XML_CONVERT_OUTPUT_EXHAUSTE
638 }
639 *(*toP)++ = lo;
640 break;
641 }
642 /* fall through */
643 case 0x1:
644 case 0x2:
645 case 0x3:
646 case 0x4:
647 case 0x5:
648 case 0x6:
649 case 0x7:
650 if (toLim - *toP < 2) {
651 *fromP = from;
652 return XML_CONVERT_OUTPUT_EXHAUSTED;
653 }
654 *(*toP)++ = ((lo >> 6) | (hi << 2) | U
655 *(*toP)++ = ((lo & 0x3f) | 0x80);
656 break;
657 default:
658 if (toLim - *toP < 3) {
659 *fromP = from;
660 return XML_CONVERT_OUTPUT_EXHAUSTED;
661 }
662 /* 16 bits divided 4, 6, 6 amongst 3 b
663 *(*toP)++ = ((hi >> 4) | UTF8_cval3);
664 *(*toP)++ = (((hi & 0xf) << 2) | (lo >
665 *(*toP)++ = ((lo & 0x3f) | 0x80);
666 break;
667 case 0xD8:
668 case 0xD9:
669 case 0xDA:
670 case 0xDB:
671 if (toLim - *toP < 4) {
672 *fromP = from;
673 return XML_CONVERT_OUTPUT_EXHAUSTED;
674 }
675 if (fromLim - from < 4) {
676 *fromP = from;
677 return XML_CONVERT_INPUT_INCOMPLETE;
678 }
679 plane = (((hi & 0x3) << 2) | ((lo >> 6
680 *(*toP)++ = (char)((plane >> 2) | UTF8
681 *(*toP)++ = (((lo >> 2) & 0xF) | ((pla
682 from += 2;
683 lo2 = GET_LO(from);
684 *(*toP)++ = (((lo & 0x3) << 4) | ((GET
685 | (lo2 >> 6) | 0x80);
686 *(*toP)++ = ((lo2 & 0x3f) | 0x80);
687 break;
688 }
689 }
690 *fromP = from;
691 if (from < fromLim)
692 return XML_CONVERT_INPUT_INCOMPLETE;
693 else
694 return XML_CONVERT_COMPLETED;
695 }
696
697 #define DEFINE_UTF16_TO_UTF16(E)
698 static enum XML_Convert_Result PTRCALL E##to
699 const ENCODING *enc, const char **fromP,
700 unsigned short **toP, const unsigned sho
701 enum XML_Convert_Result res = XML_CONVERT_
702 UNUSED_P(enc);
703 fromLim = *fromP + (((fromLim - *fromP) >>
704 /* Avoid copying first half only of surrog
705 if (fromLim - *fromP > ((toLim - *toP) <<
706 && (GET_HI(fromLim - 2) & 0xF8) == 0xD
707 fromLim -= 2;
708 res = XML_CONVERT_INPUT_INCOMPLETE;
709 }
710 for (; *fromP < fromLim && *toP < toLim; *
711 *(*toP)++ = (GET_HI(*fromP) << 8) | GET_
712 if ((*toP == toLim) && (*fromP < fromLim))
713 return XML_CONVERT_OUTPUT_EXHAUSTED;
714 else
715 return res;
716 }
717
718 #define SET2(ptr, ch) (((ptr)[0] = ((ch)&0xff)
719 #define GET_LO(ptr) ((unsigned char)(ptr)[0])
720 #define GET_HI(ptr) ((unsigned char)(ptr)[1])
721
722 DEFINE_UTF16_TO_UTF8(little2_)
723 DEFINE_UTF16_TO_UTF16(little2_)
724
725 #undef SET2
726 #undef GET_LO
727 #undef GET_HI
728
729 #define SET2(ptr, ch) (((ptr)[0] = ((ch) >> 8)
730 #define GET_LO(ptr) ((unsigned char)(ptr)[1])
731 #define GET_HI(ptr) ((unsigned char)(ptr)[0])
732
733 DEFINE_UTF16_TO_UTF8(big2_)
734 DEFINE_UTF16_TO_UTF16(big2_)
735
736 #undef SET2
737 #undef GET_LO
738 #undef GET_HI
739
740 #define LITTLE2_BYTE_TYPE(enc, p)
741 ((p)[1] == 0 ? ((struct normal_encoding *)(e
742 : unicode_byte_type((p)[1], (p)
743 #define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0
744 #define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] ==
745 #define LITTLE2_IS_NAME_CHAR_MINBPC(p)
746 UCS2_GET_NAMING(namePages, (unsigned char)p[
747 #define LITTLE2_IS_NMSTRT_CHAR_MINBPC(p)
748 UCS2_GET_NAMING(nmstrtPages, (unsigned char)
749
750 #ifdef XML_MIN_SIZE
751
752 static int PTRFASTCALL
753 little2_byteType(const ENCODING *enc, const ch
754 return LITTLE2_BYTE_TYPE(enc, p);
755 }
756
757 static int PTRFASTCALL
758 little2_byteToAscii(const ENCODING *enc, const
759 UNUSED_P(enc);
760 return LITTLE2_BYTE_TO_ASCII(p);
761 }
762
763 static int PTRCALL
764 little2_charMatches(const ENCODING *enc, const
765 UNUSED_P(enc);
766 return LITTLE2_CHAR_MATCHES(p, c);
767 }
768
769 static int PTRFASTCALL
770 little2_isNameMin(const ENCODING *enc, const c
771 UNUSED_P(enc);
772 return LITTLE2_IS_NAME_CHAR_MINBPC(p);
773 }
774
775 static int PTRFASTCALL
776 little2_isNmstrtMin(const ENCODING *enc, const
777 UNUSED_P(enc);
778 return LITTLE2_IS_NMSTRT_CHAR_MINBPC(p);
779 }
780
781 # undef VTABLE
782 # define VTABLE VTABLE1, little2_toUtf8, litt
783
784 #else /* not XML_MIN_SIZE */
785
786 # undef PREFIX
787 # define PREFIX(ident) little2_##ident
788 # define MINBPC(enc) 2
789 /* CHAR_MATCHES is guaranteed to have MINBPC b
790 # define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(
791 # define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_T
792 # define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR
793 # define IS_NAME_CHAR(enc, p, n) 0
794 # define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_
795 # define IS_NMSTRT_CHAR(enc, p, n) (0)
796 # define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE
797
798 # define XML_TOK_IMPL_C
799 # include "xmltok_impl.c"
800 # undef XML_TOK_IMPL_C
801
802 # undef MINBPC
803 # undef BYTE_TYPE
804 # undef BYTE_TO_ASCII
805 # undef CHAR_MATCHES
806 # undef IS_NAME_CHAR
807 # undef IS_NAME_CHAR_MINBPC
808 # undef IS_NMSTRT_CHAR
809 # undef IS_NMSTRT_CHAR_MINBPC
810 # undef IS_INVALID_CHAR
811
812 #endif /* not XML_MIN_SIZE */
813
814 #ifdef XML_NS
815
816 static const struct normal_encoding little2_en
817 = {{VTABLE, 2, 0,
818 # if BYTEORDER == 1234
819 1
820 # else
821 0
822 # endif
823 },
824 {
825 # include "asciitab.h"
826 # include "latin1tab.h"
827 },
828 STANDARD_VTABLE(little2_) NULL_VTABLE};
829
830 #endif
831
832 static const struct normal_encoding little2_en
833 = {{VTABLE, 2, 0,
834 #if BYTEORDER == 1234
835 1
836 #else
837 0
838 #endif
839 },
840 {
841 #define BT_COLON BT_NMSTRT
842 #include "asciitab.h"
843 #undef BT_COLON
844 #include "latin1tab.h"
845 },
846 STANDARD_VTABLE(little2_) NULL_VTABLE};
847
848 #if BYTEORDER != 4321
849
850 # ifdef XML_NS
851
852 static const struct normal_encoding internal_l
853 = {{VTABLE, 2, 0, 1},
854 {
855 # include "iasciitab.h"
856 # include "latin1tab.h"
857 },
858 STANDARD_VTABLE(little2_) NULL_VTABLE};
859
860 # endif
861
862 static const struct normal_encoding internal_l
863 = {{VTABLE, 2, 0, 1},
864 {
865 # define BT_COLON BT_NMSTRT
866 # include "iasciitab.h"
867 # undef BT_COLON
868 # include "latin1tab.h"
869 },
870 STANDARD_VTABLE(little2_) NULL_VTABLE};
871
872 #endif
873
874 #define BIG2_BYTE_TYPE(enc, p)
875 ((p)[0] == 0
876 ? ((struct normal_encoding *)(enc))->ty
877 : unicode_byte_type((p)[0], (p)[1]))
878 #define BIG2_BYTE_TO_ASCII(p) ((p)[0] == 0 ? (
879 #define BIG2_CHAR_MATCHES(p, c) ((p)[0] == 0 &
880 #define BIG2_IS_NAME_CHAR_MINBPC(p)
881 UCS2_GET_NAMING(namePages, (unsigned char)p[
882 #define BIG2_IS_NMSTRT_CHAR_MINBPC(p)
883 UCS2_GET_NAMING(nmstrtPages, (unsigned char)
884
885 #ifdef XML_MIN_SIZE
886
887 static int PTRFASTCALL
888 big2_byteType(const ENCODING *enc, const char
889 return BIG2_BYTE_TYPE(enc, p);
890 }
891
892 static int PTRFASTCALL
893 big2_byteToAscii(const ENCODING *enc, const ch
894 UNUSED_P(enc);
895 return BIG2_BYTE_TO_ASCII(p);
896 }
897
898 static int PTRCALL
899 big2_charMatches(const ENCODING *enc, const ch
900 UNUSED_P(enc);
901 return BIG2_CHAR_MATCHES(p, c);
902 }
903
904 static int PTRFASTCALL
905 big2_isNameMin(const ENCODING *enc, const char
906 UNUSED_P(enc);
907 return BIG2_IS_NAME_CHAR_MINBPC(p);
908 }
909
910 static int PTRFASTCALL
911 big2_isNmstrtMin(const ENCODING *enc, const ch
912 UNUSED_P(enc);
913 return BIG2_IS_NMSTRT_CHAR_MINBPC(p);
914 }
915
916 # undef VTABLE
917 # define VTABLE VTABLE1, big2_toUtf8, big2_to
918
919 #else /* not XML_MIN_SIZE */
920
921 # undef PREFIX
922 # define PREFIX(ident) big2_##ident
923 # define MINBPC(enc) 2
924 /* CHAR_MATCHES is guaranteed to have MINBPC b
925 # define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc
926 # define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_A
927 # define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MA
928 # define IS_NAME_CHAR(enc, p, n) 0
929 # define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_
930 # define IS_NMSTRT_CHAR(enc, p, n) (0)
931 # define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_I
932
933 # define XML_TOK_IMPL_C
934 # include "xmltok_impl.c"
935 # undef XML_TOK_IMPL_C
936
937 # undef MINBPC
938 # undef BYTE_TYPE
939 # undef BYTE_TO_ASCII
940 # undef CHAR_MATCHES
941 # undef IS_NAME_CHAR
942 # undef IS_NAME_CHAR_MINBPC
943 # undef IS_NMSTRT_CHAR
944 # undef IS_NMSTRT_CHAR_MINBPC
945 # undef IS_INVALID_CHAR
946
947 #endif /* not XML_MIN_SIZE */
948
949 #ifdef XML_NS
950
951 static const struct normal_encoding big2_encod
952 = {{VTABLE, 2, 0,
953 # if BYTEORDER == 4321
954 1
955 # else
956 0
957 # endif
958 },
959 {
960 # include "asciitab.h"
961 # include "latin1tab.h"
962 },
963 STANDARD_VTABLE(big2_) NULL_VTABLE};
964
965 #endif
966
967 static const struct normal_encoding big2_encod
968 = {{VTABLE, 2, 0,
969 #if BYTEORDER == 4321
970 1
971 #else
972 0
973 #endif
974 },
975 {
976 #define BT_COLON BT_NMSTRT
977 #include "asciitab.h"
978 #undef BT_COLON
979 #include "latin1tab.h"
980 },
981 STANDARD_VTABLE(big2_) NULL_VTABLE};
982
983 #if BYTEORDER != 1234
984
985 # ifdef XML_NS
986
987 static const struct normal_encoding internal_b
988 = {{VTABLE, 2, 0, 1},
989 {
990 # include "iasciitab.h"
991 # include "latin1tab.h"
992 },
993 STANDARD_VTABLE(big2_) NULL_VTABLE};
994
995 # endif
996
997 static const struct normal_encoding internal_b
998 = {{VTABLE, 2, 0, 1},
999 {
1000 # define BT_COLON BT_NMSTRT
1001 # include "iasciitab.h"
1002 # undef BT_COLON
1003 # include "latin1tab.h"
1004 },
1005 STANDARD_VTABLE(big2_) NULL_VTABLE};
1006
1007 #endif
1008
1009 #undef PREFIX
1010
1011 static int FASTCALL
1012 streqci(const char *s1, const char *s2) {
1013 for (;;) {
1014 char c1 = *s1++;
1015 char c2 = *s2++;
1016 if (ASCII_a <= c1 && c1 <= ASCII_z)
1017 c1 += ASCII_A - ASCII_a;
1018 if (ASCII_a <= c2 && c2 <= ASCII_z)
1019 /* The following line will never get ex
1020 * only called from two places, both of
1021 * upper-case strings into s2.
1022 */
1023 c2 += ASCII_A - ASCII_a; /* LCOV_EXCL_L
1024 if (c1 != c2)
1025 return 0;
1026 if (! c1)
1027 break;
1028 }
1029 return 1;
1030 }
1031
1032 static void PTRCALL
1033 initUpdatePosition(const ENCODING *enc, const
1034 POSITION *pos) {
1035 UNUSED_P(enc);
1036 normal_updatePosition(&utf8_encoding.enc, p
1037 }
1038
1039 static int
1040 toAscii(const ENCODING *enc, const char *ptr,
1041 char buf[1];
1042 char *p = buf;
1043 XmlUtf8Convert(enc, &ptr, end, &p, p + 1);
1044 if (p == buf)
1045 return -1;
1046 else
1047 return buf[0];
1048 }
1049
1050 static int FASTCALL
1051 isSpace(int c) {
1052 switch (c) {
1053 case 0x20:
1054 case 0xD:
1055 case 0xA:
1056 case 0x9:
1057 return 1;
1058 }
1059 return 0;
1060 }
1061
1062 /* Return 1 if there's just optional white sp
1063 followed by name=val.
1064 */
1065 static int
1066 parsePseudoAttribute(const ENCODING *enc, con
1067 const char **namePtr, co
1068 const char **valPtr, con
1069 int c;
1070 char open;
1071 if (ptr == end) {
1072 *namePtr = NULL;
1073 return 1;
1074 }
1075 if (! isSpace(toAscii(enc, ptr, end))) {
1076 *nextTokPtr = ptr;
1077 return 0;
1078 }
1079 do {
1080 ptr += enc->minBytesPerChar;
1081 } while (isSpace(toAscii(enc, ptr, end)));
1082 if (ptr == end) {
1083 *namePtr = NULL;
1084 return 1;
1085 }
1086 *namePtr = ptr;
1087 for (;;) {
1088 c = toAscii(enc, ptr, end);
1089 if (c == -1) {
1090 *nextTokPtr = ptr;
1091 return 0;
1092 }
1093 if (c == ASCII_EQUALS) {
1094 *nameEndPtr = ptr;
1095 break;
1096 }
1097 if (isSpace(c)) {
1098 *nameEndPtr = ptr;
1099 do {
1100 ptr += enc->minBytesPerChar;
1101 } while (isSpace(c = toAscii(enc, ptr,
1102 if (c != ASCII_EQUALS) {
1103 *nextTokPtr = ptr;
1104 return 0;
1105 }
1106 break;
1107 }
1108 ptr += enc->minBytesPerChar;
1109 }
1110 if (ptr == *namePtr) {
1111 *nextTokPtr = ptr;
1112 return 0;
1113 }
1114 ptr += enc->minBytesPerChar;
1115 c = toAscii(enc, ptr, end);
1116 while (isSpace(c)) {
1117 ptr += enc->minBytesPerChar;
1118 c = toAscii(enc, ptr, end);
1119 }
1120 if (c != ASCII_QUOT && c != ASCII_APOS) {
1121 *nextTokPtr = ptr;
1122 return 0;
1123 }
1124 open = (char)c;
1125 ptr += enc->minBytesPerChar;
1126 *valPtr = ptr;
1127 for (;; ptr += enc->minBytesPerChar) {
1128 c = toAscii(enc, ptr, end);
1129 if (c == open)
1130 break;
1131 if (! (ASCII_a <= c && c <= ASCII_z) && !
1132 && ! (ASCII_0 <= c && c <= ASCII_9) &
1133 && c != ASCII_MINUS && c != ASCII_UND
1134 *nextTokPtr = ptr;
1135 return 0;
1136 }
1137 }
1138 *nextTokPtr = ptr + enc->minBytesPerChar;
1139 return 1;
1140 }
1141
1142 static const char KW_version[]
1143 = {ASCII_v, ASCII_e, ASCII_r, ASCII_s, AS
1144
1145 static const char KW_encoding[] = {ASCII_e, A
1146 ASCII_i, A
1147
1148 static const char KW_standalone[]
1149 = {ASCII_s, ASCII_t, ASCII_a, ASCII_n, AS
1150 ASCII_l, ASCII_o, ASCII_n, ASCII_e, '\
1151
1152 static const char KW_yes[] = {ASCII_y, ASCII_
1153
1154 static const char KW_no[] = {ASCII_n, ASCII_o
1155
1156 static int
1157 doParseXmlDecl(const ENCODING *(*encodingFind
1158
1159 int isGeneralTextEntity, const
1160 const char *end, const char **
1161 const char **versionEndPtr, co
1162 const ENCODING **encoding, int
1163 const char *val = NULL;
1164 const char *name = NULL;
1165 const char *nameEnd = NULL;
1166 ptr += 5 * enc->minBytesPerChar;
1167 end -= 2 * enc->minBytesPerChar;
1168 if (! parsePseudoAttribute(enc, ptr, end, &
1169 || ! name) {
1170 *badPtr = ptr;
1171 return 0;
1172 }
1173 if (! XmlNameMatchesAscii(enc, name, nameEn
1174 if (! isGeneralTextEntity) {
1175 *badPtr = name;
1176 return 0;
1177 }
1178 } else {
1179 if (versionPtr)
1180 *versionPtr = val;
1181 if (versionEndPtr)
1182 *versionEndPtr = ptr;
1183 if (! parsePseudoAttribute(enc, ptr, end,
1184 *badPtr = ptr;
1185 return 0;
1186 }
1187 if (! name) {
1188 if (isGeneralTextEntity) {
1189 /* a TextDecl must have an EncodingDe
1190 *badPtr = ptr;
1191 return 0;
1192 }
1193 return 1;
1194 }
1195 }
1196 if (XmlNameMatchesAscii(enc, name, nameEnd,
1197 int c = toAscii(enc, val, end);
1198 if (! (ASCII_a <= c && c <= ASCII_z) && !
1199 *badPtr = val;
1200 return 0;
1201 }
1202 if (encodingName)
1203 *encodingName = val;
1204 if (encoding)
1205 *encoding = encodingFinder(enc, val, pt
1206 if (! parsePseudoAttribute(enc, ptr, end,
1207 *badPtr = ptr;
1208 return 0;
1209 }
1210 if (! name)
1211 return 1;
1212 }
1213 if (! XmlNameMatchesAscii(enc, name, nameEn
1214 || isGeneralTextEntity) {
1215 *badPtr = name;
1216 return 0;
1217 }
1218 if (XmlNameMatchesAscii(enc, val, ptr - enc
1219 if (standalone)
1220 *standalone = 1;
1221 } else if (XmlNameMatchesAscii(enc, val, pt
1222 if (standalone)
1223 *standalone = 0;
1224 } else {
1225 *badPtr = val;
1226 return 0;
1227 }
1228 while (isSpace(toAscii(enc, ptr, end)))
1229 ptr += enc->minBytesPerChar;
1230 if (ptr != end) {
1231 *badPtr = ptr;
1232 return 0;
1233 }
1234 return 1;
1235 }
1236
1237 static int FASTCALL
1238 checkCharRefNumber(int result) {
1239 switch (result >> 8) {
1240 case 0xD8:
1241 case 0xD9:
1242 case 0xDA:
1243 case 0xDB:
1244 case 0xDC:
1245 case 0xDD:
1246 case 0xDE:
1247 case 0xDF:
1248 return -1;
1249 case 0:
1250 if (latin1_encoding.type[result] == BT_NO
1251 return -1;
1252 break;
1253 case 0xFF:
1254 if (result == 0xFFFE || result == 0xFFFF)
1255 return -1;
1256 break;
1257 }
1258 return result;
1259 }
1260
1261 int FASTCALL
1262 XmlUtf8Encode(int c, char *buf) {
1263 enum {
1264 /* minN is minimum legal resulting value
1265 min2 = 0x80,
1266 min3 = 0x800,
1267 min4 = 0x10000
1268 };
1269
1270 if (c < 0)
1271 return 0; /* LCOV_EXCL_LINE: this case is
1272 if (c < min2) {
1273 buf[0] = (char)(c | UTF8_cval1);
1274 return 1;
1275 }
1276 if (c < min3) {
1277 buf[0] = (char)((c >> 6) | UTF8_cval2);
1278 buf[1] = (char)((c & 0x3f) | 0x80);
1279 return 2;
1280 }
1281 if (c < min4) {
1282 buf[0] = (char)((c >> 12) | UTF8_cval3);
1283 buf[1] = (char)(((c >> 6) & 0x3f) | 0x80)
1284 buf[2] = (char)((c & 0x3f) | 0x80);
1285 return 3;
1286 }
1287 if (c < 0x110000) {
1288 buf[0] = (char)((c >> 18) | UTF8_cval4);
1289 buf[1] = (char)(((c >> 12) & 0x3f) | 0x80
1290 buf[2] = (char)(((c >> 6) & 0x3f) | 0x80)
1291 buf[3] = (char)((c & 0x3f) | 0x80);
1292 return 4;
1293 }
1294 return 0; /* LCOV_EXCL_LINE: this case too
1295 }
1296
1297 int FASTCALL
1298 XmlUtf16Encode(int charNum, unsigned short *b
1299 if (charNum < 0)
1300 return 0;
1301 if (charNum < 0x10000) {
1302 buf[0] = (unsigned short)charNum;
1303 return 1;
1304 }
1305 if (charNum < 0x110000) {
1306 charNum -= 0x10000;
1307 buf[0] = (unsigned short)((charNum >> 10)
1308 buf[1] = (unsigned short)((charNum & 0x3F
1309 return 2;
1310 }
1311 return 0;
1312 }
1313
1314 struct unknown_encoding {
1315 struct normal_encoding normal;
1316 CONVERTER convert;
1317 void *userData;
1318 unsigned short utf16[256];
1319 char utf8[256][4];
1320 };
1321
1322 #define AS_UNKNOWN_ENCODING(enc) ((const stru
1323
1324 int
1325 XmlSizeOfUnknownEncoding(void) {
1326 return sizeof(struct unknown_encoding);
1327 }
1328
1329 static int PTRFASTCALL
1330 unknown_isName(const ENCODING *enc, const cha
1331 const struct unknown_encoding *uenc = AS_UN
1332 int c = uenc->convert(uenc->userData, p);
1333 if (c & ~0xFFFF)
1334 return 0;
1335 return UCS2_GET_NAMING(namePages, c >> 8, c
1336 }
1337
1338 static int PTRFASTCALL
1339 unknown_isNmstrt(const ENCODING *enc, const c
1340 const struct unknown_encoding *uenc = AS_UN
1341 int c = uenc->convert(uenc->userData, p);
1342 if (c & ~0xFFFF)
1343 return 0;
1344 return UCS2_GET_NAMING(nmstrtPages, c >> 8,
1345 }
1346
1347 static int PTRFASTCALL
1348 unknown_isInvalid(const ENCODING *enc, const
1349 const struct unknown_encoding *uenc = AS_UN
1350 int c = uenc->convert(uenc->userData, p);
1351 return (c & ~0xFFFF) || checkCharRefNumber(
1352 }
1353
1354 static enum XML_Convert_Result PTRCALL
1355 unknown_toUtf8(const ENCODING *enc, const cha
1356 char **toP, const char *toLim)
1357 const struct unknown_encoding *uenc = AS_UN
1358 char buf[XML_UTF8_ENCODE_MAX];
1359 for (;;) {
1360 const char *utf8;
1361 int n;
1362 if (*fromP == fromLim)
1363 return XML_CONVERT_COMPLETED;
1364 utf8 = uenc->utf8[(unsigned char)**fromP]
1365 n = *utf8++;
1366 if (n == 0) {
1367 int c = uenc->convert(uenc->userData, *
1368 n = XmlUtf8Encode(c, buf);
1369 if (n > toLim - *toP)
1370 return XML_CONVERT_OUTPUT_EXHAUSTED;
1371 utf8 = buf;
1372 *fromP += (AS_NORMAL_ENCODING(enc)->typ
1373 - (BT_LEAD2 - 2));
1374 } else {
1375 if (n > toLim - *toP)
1376 return XML_CONVERT_OUTPUT_EXHAUSTED;
1377 (*fromP)++;
1378 }
1379 memcpy(*toP, utf8, n);
1380 *toP += n;
1381 }
1382 }
1383
1384 static enum XML_Convert_Result PTRCALL
1385 unknown_toUtf16(const ENCODING *enc, const ch
1386 unsigned short **toP, const u
1387 const struct unknown_encoding *uenc = AS_UN
1388 while (*fromP < fromLim && *toP < toLim) {
1389 unsigned short c = uenc->utf16[(unsigned
1390 if (c == 0) {
1391 c = (unsigned short)uenc->convert(uenc-
1392 *fromP += (AS_NORMAL_ENCODING(enc)->typ
1393 - (BT_LEAD2 - 2));
1394 } else
1395 (*fromP)++;
1396 *(*toP)++ = c;
1397 }
1398
1399 if ((*toP == toLim) && (*fromP < fromLim))
1400 return XML_CONVERT_OUTPUT_EXHAUSTED;
1401 else
1402 return XML_CONVERT_COMPLETED;
1403 }
1404
1405 ENCODING *
1406 XmlInitUnknownEncoding(void *mem, int *table,
1407 void *userData) {
1408 int i;
1409 struct unknown_encoding *e = (struct unknow
1410 memcpy(mem, &latin1_encoding, sizeof(struct
1411 for (i = 0; i < 128; i++)
1412 if (latin1_encoding.type[i] != BT_OTHER
1413 && latin1_encoding.type[i] != BT_NONX
1414 return 0;
1415 for (i = 0; i < 256; i++) {
1416 int c = table[i];
1417 if (c == -1) {
1418 e->normal.type[i] = BT_MALFORM;
1419 /* This shouldn't really get used. */
1420 e->utf16[i] = 0xFFFF;
1421 e->utf8[i][0] = 1;
1422 e->utf8[i][1] = 0;
1423 } else if (c < 0) {
1424 if (c < -4)
1425 return 0;
1426 /* Multi-byte sequences need a converte
1427 if (! convert)
1428 return 0;
1429 e->normal.type[i] = (unsigned char)(BT_
1430 e->utf8[i][0] = 0;
1431 e->utf16[i] = 0;
1432 } else if (c < 0x80) {
1433 if (latin1_encoding.type[c] != BT_OTHER
1434 && latin1_encoding.type[c] != BT_NO
1435 return 0;
1436 e->normal.type[i] = latin1_encoding.typ
1437 e->utf8[i][0] = 1;
1438 e->utf8[i][1] = (char)c;
1439 e->utf16[i] = (unsigned short)(c == 0 ?
1440 } else if (checkCharRefNumber(c) < 0) {
1441 e->normal.type[i] = BT_NONXML;
1442 /* This shouldn't really get used. */
1443 e->utf16[i] = 0xFFFF;
1444 e->utf8[i][0] = 1;
1445 e->utf8[i][1] = 0;
1446 } else {
1447 if (c > 0xFFFF)
1448 return 0;
1449 if (UCS2_GET_NAMING(nmstrtPages, c >> 8
1450 e->normal.type[i] = BT_NMSTRT;
1451 else if (UCS2_GET_NAMING(namePages, c >
1452 e->normal.type[i] = BT_NAME;
1453 else
1454 e->normal.type[i] = BT_OTHER;
1455 e->utf8[i][0] = (char)XmlUtf8Encode(c,
1456 e->utf16[i] = (unsigned short)c;
1457 }
1458 }
1459 e->userData = userData;
1460 e->convert = convert;
1461 if (convert) {
1462 e->normal.isName2 = unknown_isName;
1463 e->normal.isName3 = unknown_isName;
1464 e->normal.isName4 = unknown_isName;
1465 e->normal.isNmstrt2 = unknown_isNmstrt;
1466 e->normal.isNmstrt3 = unknown_isNmstrt;
1467 e->normal.isNmstrt4 = unknown_isNmstrt;
1468 e->normal.isInvalid2 = unknown_isInvalid;
1469 e->normal.isInvalid3 = unknown_isInvalid;
1470 e->normal.isInvalid4 = unknown_isInvalid;
1471 }
1472 e->normal.enc.utf8Convert = unknown_toUtf8;
1473 e->normal.enc.utf16Convert = unknown_toUtf1
1474 return &(e->normal.enc);
1475 }
1476
1477 /* If this enumeration is changed, getEncodin
1478 must also be changed. */
1479 enum {
1480 UNKNOWN_ENC = -1,
1481 ISO_8859_1_ENC = 0,
1482 US_ASCII_ENC,
1483 UTF_8_ENC,
1484 UTF_16_ENC,
1485 UTF_16BE_ENC,
1486 UTF_16LE_ENC,
1487 /* must match encodingNames up to here */
1488 NO_ENC
1489 };
1490
1491 static const char KW_ISO_8859_1[]
1492 = {ASCII_I, ASCII_S, ASCII_O, ASCII_M
1493 ASCII_5, ASCII_9, ASCII_MINUS, ASCII_1
1494 static const char KW_US_ASCII[]
1495 = {ASCII_U, ASCII_S, ASCII_MINUS, ASCII_A
1496 ASCII_C, ASCII_I, ASCII_I, '\0'};
1497 static const char KW_UTF_8[]
1498 = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS
1499 static const char KW_UTF_16[]
1500 = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS
1501 static const char KW_UTF_16BE[]
1502 = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS
1503 ASCII_6, ASCII_B, ASCII_E, '\0'};
1504 static const char KW_UTF_16LE[]
1505 = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS
1506 ASCII_6, ASCII_L, ASCII_E, '\0'};
1507
1508 static int FASTCALL
1509 getEncodingIndex(const char *name) {
1510 static const char *const encodingNames[] =
1511 KW_ISO_8859_1, KW_US_ASCII, KW_UTF_8, K
1512 };
1513 int i;
1514 if (name == NULL)
1515 return NO_ENC;
1516 for (i = 0; i < (int)(sizeof(encodingNames)
1517 if (streqci(name, encodingNames[i]))
1518 return i;
1519 return UNKNOWN_ENC;
1520 }
1521
1522 /* For binary compatibility, we store the ind
1523 specified at initialization in the isUtf16
1524 */
1525
1526 #define INIT_ENC_INDEX(enc) ((int)(enc)->init
1527 #define SET_INIT_ENC_INDEX(enc, i) ((enc)->in
1528
1529 /* This is what detects the encoding. encodi
1530 encoding indices to encodings; INIT_ENC_IN
1531 the external (protocol) specified encoding
1532 XML_CONTENT_STATE if we're parsing an exte
1533 XML_PROLOG_STATE otherwise.
1534 */
1535
1536 static int
1537 initScan(const ENCODING *const *encodingTable
1538 int state, const char *ptr, const ch
1539 const ENCODING **encPtr;
1540
1541 if (ptr >= end)
1542 return XML_TOK_NONE;
1543 encPtr = enc->encPtr;
1544 if (ptr + 1 == end) {
1545 /* only a single byte available for auto-
1546 #ifndef XML_DTD /* FIXME */
1547 /* a well-formed document entity must hav
1548 if (state != XML_CONTENT_STATE)
1549 return XML_TOK_PARTIAL;
1550 #endif
1551 /* so we're parsing an external text enti
1552 /* if UTF-16 was externally specified, th
1553 switch (INIT_ENC_INDEX(enc)) {
1554 case UTF_16_ENC:
1555 case UTF_16LE_ENC:
1556 case UTF_16BE_ENC:
1557 return XML_TOK_PARTIAL;
1558 }
1559 switch ((unsigned char)*ptr) {
1560 case 0xFE:
1561 case 0xFF:
1562 case 0xEF: /* possibly first byte of UTF-
1563 if (INIT_ENC_INDEX(enc) == ISO_8859_1_E
1564 break;
1565 /* fall through */
1566 case 0x00:
1567 case 0x3C:
1568 return XML_TOK_PARTIAL;
1569 }
1570 } else {
1571 switch (((unsigned char)ptr[0] << 8) | (u
1572 case 0xFEFF:
1573 if (INIT_ENC_INDEX(enc) == ISO_8859_1_E
1574 break;
1575 *nextTokPtr = ptr + 2;
1576 *encPtr = encodingTable[UTF_16BE_ENC];
1577 return XML_TOK_BOM;
1578 /* 00 3C is handled in the default case *
1579 case 0x3C00:
1580 if ((INIT_ENC_INDEX(enc) == UTF_16BE_EN
1581 || INIT_ENC_INDEX(enc) == UTF_16_E
1582 && state == XML_CONTENT_STATE)
1583 break;
1584 *encPtr = encodingTable[UTF_16LE_ENC];
1585 return XmlTok(*encPtr, state, ptr, end,
1586 case 0xFFFE:
1587 if (INIT_ENC_INDEX(enc) == ISO_8859_1_E
1588 break;
1589 *nextTokPtr = ptr + 2;
1590 *encPtr = encodingTable[UTF_16LE_ENC];
1591 return XML_TOK_BOM;
1592 case 0xEFBB:
1593 /* Maybe a UTF-8 BOM (EF BB BF) */
1594 /* If there's an explicitly specified (
1595 of ISO-8859-1 or some flavour of UTF
1596 and this is an external text entity,
1597 don't look for the BOM,
1598 because it might be a legal data.
1599 */
1600 if (state == XML_CONTENT_STATE) {
1601 int e = INIT_ENC_INDEX(enc);
1602 if (e == ISO_8859_1_ENC || e == UTF_1
1603 || e == UTF_16_ENC)
1604 break;
1605 }
1606 if (ptr + 2 == end)
1607 return XML_TOK_PARTIAL;
1608 if ((unsigned char)ptr[2] == 0xBF) {
1609 *nextTokPtr = ptr + 3;
1610 *encPtr = encodingTable[UTF_8_ENC];
1611 return XML_TOK_BOM;
1612 }
1613 break;
1614 default:
1615 if (ptr[0] == '\0') {
1616 /* 0 isn't a legal data character. Fu
1617 entity can only start with ASCII c
1618 way this can fail to be big-endian
1619 external parsed general entity tha
1620 UTF-16LE.
1621 */
1622 if (state == XML_CONTENT_STATE && INI
1623 break;
1624 *encPtr = encodingTable[UTF_16BE_ENC]
1625 return XmlTok(*encPtr, state, ptr, en
1626 } else if (ptr[1] == '\0') {
1627 /* We could recover here in the case:
1628 - parsing an external entity
1629 - second byte is 0
1630 - no externally specified encodin
1631 - no encoding declaration
1632 by assuming UTF-16LE. But we don'
1633 presented just with a single byte,
1634 whether we needed further bytes.
1635 */
1636 if (state == XML_CONTENT_STATE)
1637 break;
1638 *encPtr = encodingTable[UTF_16LE_ENC]
1639 return XmlTok(*encPtr, state, ptr, en
1640 }
1641 break;
1642 }
1643 }
1644 *encPtr = encodingTable[INIT_ENC_INDEX(enc)
1645 return XmlTok(*encPtr, state, ptr, end, nex
1646 }
1647
1648 #define NS(x) x
1649 #define ns(x) x
1650 #define XML_TOK_NS_C
1651 #include "xmltok_ns.c"
1652 #undef XML_TOK_NS_C
1653 #undef NS
1654 #undef ns
1655
1656 #ifdef XML_NS
1657
1658 # define NS(x) x##NS
1659 # define ns(x) x##_ns
1660
1661 # define XML_TOK_NS_C
1662 # include "xmltok_ns.c"
1663 # undef XML_TOK_NS_C
1664
1665 # undef NS
1666 # undef ns
1667
1668 ENCODING *
1669 XmlInitUnknownEncodingNS(void *mem, int *tabl
1670 void *userData) {
1671 ENCODING *enc = XmlInitUnknownEncoding(mem,
1672 if (enc)
1673 ((struct normal_encoding *)enc)->type[ASC
1674 return enc;
1675 }
1676
1677 #endif /* XML_NS */
1678