1 /*
2 __ __ _
3 ___\ \/ /_ __ __ _| |_
4 / _ \\ /| '_ \ / _` | __|
5 | __// \| |_) | (_| | |_
6 \___/_/\_\ .__/ \__,_|\__|
7 |_| XML parser
8
9 Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
10 Copyright (c) 2000 Clark Cooper <coopercc@users.sourceforge.net>
11 Copyright (c) 2001-2003 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
12 Copyright (c) 2002 Greg Stein <gstein@users.sourceforge.net>
13 Copyright (c) 2002-2016 Karl Waclawek <karl@waclawek.net>
14 Copyright (c) 2005-2009 Steven Solie <steven@solie.ca>
15 Copyright (c) 2016-2022 Sebastian Pipping <sebastian@pipping.org>
16 Copyright (c) 2016 Pascal Cuoq <cuoq@trust-in-soft.com>
17 Copyright (c) 2016 Don Lewis <truckman@apache.org>
18 Copyright (c) 2017 Rhodri James <rhodri@wildebeest.org.uk>
19 Copyright (c) 2017 Alexander Bluhm <alexander.bluhm@gmx.net>
20 Copyright (c) 2017 Benbuck Nason <bnason@netflix.com>
21 Copyright (c) 2017 José Gutiérrez de la Concha <jose@zeroc.com>
22 Copyright (c) 2019 David Loffredo <loffredo@steptools.com>
23 Copyright (c) 2021 Dong-hee Na <donghee.na@python.org>
24 Copyright (c) 2022 Martin Ettl <ettl.martin78@googlemail.com>
25 Licensed under the MIT license:
26
27 Permission is hereby granted, free of charge, to any person obtaining
28 a copy of this software and associated documentation files (the
29 "Software"), to deal in the Software without restriction, including
30 without limitation the rights to use, copy, modify, merge, publish,
31 distribute, sublicense, and/or sell copies of the Software, and to permit
32 persons to whom the Software is furnished to do so, subject to the
33 following conditions:
34
35 The above copyright notice and this permission notice shall be included
36 in all copies or substantial portions of the Software.
37
38 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
39 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
40 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
41 NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
42 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
43 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
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(ignoreSectionTok)
64 #else
65 # define IGNORE_SECTION_TOK_VTABLE /* as nothing */
66 #endif
67
68 #define VTABLE1 \
69 {PREFIX(prologTok), PREFIX(contentTok), \
70 PREFIX(cdataSectionTok) IGNORE_SECTION_TOK_VTABLE}, \
71 {PREFIX(attributeValueTok), PREFIX(entityValueTok)}, \
72 PREFIX(nameMatchesAscii), PREFIX(nameLength), PREFIX(skipS), \
73 PREFIX(getAtts), PREFIX(charRefNumber), PREFIX(predefinedEntityName), \
74 PREFIX(updatePosition), PREFIX(isPublicId)
75
76 #define VTABLE VTABLE1, PREFIX(toUtf8), PREFIX(toUtf16)
77
78 #define UCS2_GET_NAMING(pages, hi, lo) \
79 (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo)&0x1F)))
80
81 /* A 2 byte UTF-8 representation splits the characters 11 bits between
82 the bottom 5 and 6 bits of the bytes. We need 8 bits to index into
83 pages, 3 bits to add to that index and 5 bits to generate the mask.
84 */
85 #define UTF8_GET_NAMING2(pages, byte) \
86 (namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3) \
87 + ((((byte)[0]) & 3) << 1) + ((((byte)[1]) >> 5) & 1)] \
88 & (1u << (((byte)[1]) & 0x1F)))
89
90 /* A 3 byte UTF-8 representation splits the characters 16 bits between
91 the bottom 4, 6 and 6 bits of the bytes. We need 8 bits to index
92 into pages, 3 bits to add to that index and 5 bits to generate the
93 mask.
94 */
95 #define UTF8_GET_NAMING3(pages, byte) \
96 (namingBitmap \
97 [((pages)[((((byte)[0]) & 0xF) << 4) + ((((byte)[1]) >> 2) & 0xF)] \
98 << 3) \
99 + ((((byte)[1]) & 3) << 1) + ((((byte)[2]) >> 5) & 1)] \
100 & (1u << (((byte)[2]) & 0x1F)))
101
102 /* Detection of invalid UTF-8 sequences is based on Table 3.1B
103 of Unicode 3.2: http://www.unicode.org/unicode/reports/tr28/
104 with the additional restriction of not allowing the Unicode
105 code points 0xFFFF and 0xFFFE (sequences EF,BF,BF and EF,BF,BE).
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)[1] & 0xC0) == 0xC0)
114
115 #define UTF8_INVALID3(p) \
116 (((p)[2] & 0x80) == 0 \
117 || ((*p) == 0xEF && (p)[1] == 0xBF ? (p)[2] > 0xBD \
118 : ((p)[2] & 0xC0) == 0xC0) \
119 || ((*p) == 0xE0 \
120 ? (p)[1] < 0xA0 || ((p)[1] & 0xC0) == 0xC0 \
121 : ((p)[1] & 0x80) == 0 \
122 || ((*p) == 0xED ? (p)[1] > 0x9F : ((p)[1] & 0xC0) == 0xC0)))
123
124 #define UTF8_INVALID4(p) \
125 (((p)[3] & 0x80) == 0 || ((p)[3] & 0xC0) == 0xC0 || ((p)[2] & 0x80) == 0 \
126 || ((p)[2] & 0xC0) == 0xC0 \
127 || ((*p) == 0xF0 \
128 ? (p)[1] < 0x90 || ((p)[1] & 0xC0) == 0xC0 \
129 : ((p)[1] & 0x80) == 0 \
130 || ((*p) == 0xF4 ? (p)[1] > 0x8F : ((p)[1] & 0xC0) == 0xC0)))
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 *p) {
141 UNUSED_P(enc);
142 return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
143 }
144
145 static int PTRFASTCALL
146 utf8_isName3(const ENCODING *enc, const char *p) {
147 UNUSED_P(enc);
148 return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
149 }
150
151 #define utf8_isName4 isNever
152
153 static int PTRFASTCALL
154 utf8_isNmstrt2(const ENCODING *enc, const char *p) {
155 UNUSED_P(enc);
156 return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
157 }
158
159 static int PTRFASTCALL
160 utf8_isNmstrt3(const ENCODING *enc, const char *p) {
161 UNUSED_P(enc);
162 return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
163 }
164
165 #define utf8_isNmstrt4 isNever
166
167 static int PTRFASTCALL
168 utf8_isInvalid2(const ENCODING *enc, const char *p) {
169 UNUSED_P(enc);
170 return UTF8_INVALID2((const unsigned char *)p);
171 }
172
173 static int PTRFASTCALL
174 utf8_isInvalid3(const ENCODING *enc, const char *p) {
175 UNUSED_P(enc);
176 return UTF8_INVALID3((const unsigned char *)p);
177 }
178
179 static int PTRFASTCALL
180 utf8_isInvalid4(const ENCODING *enc, const char *p) {
181 UNUSED_P(enc);
182 return UTF8_INVALID4((const unsigned char *)p);
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 *, const char *);
190 int(PTRFASTCALL *isNameMin)(const ENCODING *, const char *);
191 int(PTRFASTCALL *isNmstrtMin)(const ENCODING *, const char *);
192 int(PTRFASTCALL *byteToAscii)(const ENCODING *, const char *);
193 int(PTRCALL *charMatches)(const ENCODING *, const char *, int);
194 #endif /* XML_MIN_SIZE */
195 int(PTRFASTCALL *isName2)(const ENCODING *, const char *);
196 int(PTRFASTCALL *isName3)(const ENCODING *, const char *);
197 int(PTRFASTCALL *isName4)(const ENCODING *, const char *);
198 int(PTRFASTCALL *isNmstrt2)(const ENCODING *, const char *);
199 int(PTRFASTCALL *isNmstrt3)(const ENCODING *, const char *);
200 int(PTRFASTCALL *isNmstrt4)(const ENCODING *, const char *);
201 int(PTRFASTCALL *isInvalid2)(const ENCODING *, const char *);
202 int(PTRFASTCALL *isInvalid3)(const ENCODING *, const char *);
203 int(PTRFASTCALL *isInvalid4)(const ENCODING *, const char *);
204 };
205
206 #define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc))
207
208 #ifdef XML_MIN_SIZE
209
210 # define STANDARD_VTABLE(E) \
211 E##byteType, E##isNameMin, E##isNmstrtMin, E##byteToAscii, E##charMatches,
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##isNmstrt2, E##isNmstrt3, \
221 E##isNmstrt4, E##isInvalid2, E##isInvalid3, E##isInvalid4
222
223 #define NULL_VTABLE \
224 /* isName2 */ NULL, /* isName3 */ NULL, /* isName4 */ NULL, \
225 /* isNmstrt2 */ NULL, /* isNmstrt3 */ NULL, /* isNmstrt4 */ NULL, \
226 /* isInvalid2 */ NULL, /* isInvalid3 */ NULL, /* isInvalid4 */ NULL
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[(unsigned char)*(p)])
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_ENCODING(enc)->byteType(enc, p))
254 #else
255 # define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p)
256 #endif
257
258 #ifdef XML_MIN_SIZE
259 # define BYTE_TO_ASCII(enc, p) (AS_NORMAL_ENCODING(enc)->byteToAscii(enc, p))
260 static int PTRFASTCALL
261 sb_byteToAscii(const ENCODING *enc, const char *p) {
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_ENCODING(enc)->isName##n(enc, p))
270 #define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p))
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(enc, p))
275 #else
276 # define IS_INVALID_CHAR(enc, p, n) \
277 (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p))
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, p))
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, p, c))
293 static int PTRCALL
294 sb_charMatches(const ENCODING *enc, const char *p, int c) {
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 byte of N byte sequence */
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(const char *from,
327 const char **fromLimRef) {
328 const char *fromLim = *fromLimRef;
329 size_t walked = 0;
330 for (; fromLim > from; fromLim--, walked++) {
331 const unsigned char prev = (unsigned char)fromLim[-1];
332 if ((prev & 0xf8u)
333 == 0xf0u) { /* 4-byte character, lead by 0b11110xxx byte */
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, lead by 0b1110xxxx byte */
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, lead by 0b110xxxxx byte */
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, matching 0b0xxxxxxx */
358 break;
359 }
360 }
361 *fromLimRef = fromLim;
362 }
363
364 static enum XML_Convert_Result PTRCALL
365 utf8_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
366 char **toP, const char *toLim) {
367 bool input_incomplete = false;
368 bool output_exhausted = false;
369
370 /* Avoid copying partial characters (due to limited space). */
371 const ptrdiff_t bytesAvailable = fromLim - *fromP;
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 incomplete input). */
380 {
381 const char *const fromLimBefore = fromLim;
382 _INTERNAL_trim_to_complete_utf8_characters(*fromP, &fromLim);
383 if (fromLim < fromLimBefore) {
384 input_incomplete = true;
385 }
386 }
387
388 {
389 const ptrdiff_t bytesToCopy = fromLim - *fromP;
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 **fromP, const char *fromLim,
405 unsigned short **toP, const unsigned short *toLim) {
406 enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
407 unsigned short *to = *toP;
408 const char *from = *fromP;
409 while (from < fromLim && to < toLim) {
410 switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
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] & 0x1f) << 6) | (from[1] & 0x3f));
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) << 12) | ((from[1] & 0x3f) << 6)
425 | (from[2] & 0x3f));
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] & 0x3f) << 12)
439 | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
440 n -= 0x10000;
441 to[0] = (unsigned short)((n >> 10) | 0xD800);
442 to[1] = (unsigned short)((n & 0x3FF) | 0xDC00);
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_encoding_ns
461 = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
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_encoding
470 = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
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_utf8_encoding_ns
482 = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
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_utf8_encoding
492 = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
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 **fromP, const char *fromLim,
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 **fromP, const char *fromLim,
526 unsigned short **toP, const unsigned short *toLim) {
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_encoding_ns
540 = {{VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0},
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_encoding
550 = {{VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0},
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 **fromP, const char *fromLim,
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_encoding_ns
575 = {{VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0},
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_encoding
585 = {{VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0},
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 high surrogate (W1) */
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 low surrogate (W2) */
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##toUtf8( \
622 const ENCODING *enc, const char **fromP, const char *fromLim, \
623 char **toP, const char *toLim) { \
624 const char *from = *fromP; \
625 UNUSED_P(enc); \
626 fromLim = from + (((fromLim - from) >> 1) << 1); /* shrink to even */ \
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_EXHAUSTED; \
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) | UTF8_cval2); \
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 bytes */ \
663 *(*toP)++ = ((hi >> 4) | UTF8_cval3); \
664 *(*toP)++ = (((hi & 0xf) << 2) | (lo >> 6) | 0x80); \
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) & 0x3)) + 1; \
680 *(*toP)++ = (char)((plane >> 2) | UTF8_cval4); \
681 *(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80); \
682 from += 2; \
683 lo2 = GET_LO(from); \
684 *(*toP)++ = (((lo & 0x3) << 4) | ((GET_HI(from) & 0x3) << 2) \
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##toUtf16( \
699 const ENCODING *enc, const char **fromP, const char *fromLim, \
700 unsigned short **toP, const unsigned short *toLim) { \
701 enum XML_Convert_Result res = XML_CONVERT_COMPLETED; \
702 UNUSED_P(enc); \
703 fromLim = *fromP + (((fromLim - *fromP) >> 1) << 1); /* shrink to even */ \
704 /* Avoid copying first half only of surrogate */ \
705 if (fromLim - *fromP > ((toLim - *toP) << 1) \
706 && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) { \
707 fromLim -= 2; \
708 res = XML_CONVERT_INPUT_INCOMPLETE; \
709 } \
710 for (; *fromP < fromLim && *toP < toLim; *fromP += 2) \
711 *(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP); \
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)), ((ptr)[1] = ((ch) >> 8)))
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)), ((ptr)[1] = ((ch)&0xFF)))
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 *)(enc))->type[(unsigned char)*(p)] \
742 : unicode_byte_type((p)[1], (p)[0]))
743 #define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1)
744 #define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c))
745 #define LITTLE2_IS_NAME_CHAR_MINBPC(p) \
746 UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0])
747 #define LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) \
748 UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0])
749
750 #ifdef XML_MIN_SIZE
751
752 static int PTRFASTCALL
753 little2_byteType(const ENCODING *enc, const char *p) {
754 return LITTLE2_BYTE_TYPE(enc, p);
755 }
756
757 static int PTRFASTCALL
758 little2_byteToAscii(const ENCODING *enc, const char *p) {
759 UNUSED_P(enc);
760 return LITTLE2_BYTE_TO_ASCII(p);
761 }
762
763 static int PTRCALL
764 little2_charMatches(const ENCODING *enc, const char *p, int c) {
765 UNUSED_P(enc);
766 return LITTLE2_CHAR_MATCHES(p, c);
767 }
768
769 static int PTRFASTCALL
770 little2_isNameMin(const ENCODING *enc, const char *p) {
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 char *p) {
777 UNUSED_P(enc);
778 return LITTLE2_IS_NMSTRT_CHAR_MINBPC(p);
779 }
780
781 # undef VTABLE
782 # define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16
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 bytes available. */
790 # define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
791 # define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p)
792 # define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c)
793 # define IS_NAME_CHAR(enc, p, n) 0
794 # define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p)
795 # define IS_NMSTRT_CHAR(enc, p, n) (0)
796 # define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p)
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_encoding_ns
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_encoding
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_little2_encoding_ns
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_little2_encoding
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))->type[(unsigned char)(p)[1]] \
877 : unicode_byte_type((p)[0], (p)[1]))
878 #define BIG2_BYTE_TO_ASCII(p) ((p)[0] == 0 ? (p)[1] : -1)
879 #define BIG2_CHAR_MATCHES(p, c) ((p)[0] == 0 && (p)[1] == (c))
880 #define BIG2_IS_NAME_CHAR_MINBPC(p) \
881 UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1])
882 #define BIG2_IS_NMSTRT_CHAR_MINBPC(p) \
883 UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[0], (unsigned char)p[1])
884
885 #ifdef XML_MIN_SIZE
886
887 static int PTRFASTCALL
888 big2_byteType(const ENCODING *enc, const char *p) {
889 return BIG2_BYTE_TYPE(enc, p);
890 }
891
892 static int PTRFASTCALL
893 big2_byteToAscii(const ENCODING *enc, const char *p) {
894 UNUSED_P(enc);
895 return BIG2_BYTE_TO_ASCII(p);
896 }
897
898 static int PTRCALL
899 big2_charMatches(const ENCODING *enc, const char *p, int c) {
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 *p) {
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 char *p) {
912 UNUSED_P(enc);
913 return BIG2_IS_NMSTRT_CHAR_MINBPC(p);
914 }
915
916 # undef VTABLE
917 # define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16
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 bytes available. */
925 # define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
926 # define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(p)
927 # define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(p, c)
928 # define IS_NAME_CHAR(enc, p, n) 0
929 # define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(p)
930 # define IS_NMSTRT_CHAR(enc, p, n) (0)
931 # define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(p)
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_encoding_ns
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_encoding
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_big2_encoding_ns
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_big2_encoding
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 executed. streqci() is
1020 * only called from two places, both of which guarantee to put
1021 * upper-case strings into s2.
1022 */
1023 c2 += ASCII_A - ASCII_a; /* LCOV_EXCL_LINE */
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 char *ptr, const char *end,
1034 POSITION *pos) {
1035 UNUSED_P(enc);
1036 normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
1037 }
1038
1039 static int
1040 toAscii(const ENCODING *enc, const char *ptr, const char *end) {
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 space or there's an S
1063 followed by name=val.
1064 */
1065 static int
1066 parsePseudoAttribute(const ENCODING *enc, const char *ptr, const char *end,
1067 const char **namePtr, const char **nameEndPtr,
1068 const char **valPtr, const char **nextTokPtr) {
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, end)));
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) && ! (ASCII_A <= c && c <= ASCII_Z)
1132 && ! (ASCII_0 <= c && c <= ASCII_9) && c != ASCII_PERIOD
1133 && c != ASCII_MINUS && c != ASCII_UNDERSCORE) {
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, ASCII_i, ASCII_o, ASCII_n, '\0'};
1144
1145 static const char KW_encoding[] = {ASCII_e, ASCII_n, ASCII_c, ASCII_o, ASCII_d,
1146 ASCII_i, ASCII_n, ASCII_g, '\0'};
1147
1148 static const char KW_standalone[]
1149 = {ASCII_s, ASCII_t, ASCII_a, ASCII_n, ASCII_d, ASCII_a,
1150 ASCII_l, ASCII_o, ASCII_n, ASCII_e, '\0'};
1151
1152 static const char KW_yes[] = {ASCII_y, ASCII_e, ASCII_s, '\0'};
1153
1154 static const char KW_no[] = {ASCII_n, ASCII_o, '\0'};
1155
1156 static int
1157 doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *, const char *,
1158 const char *),
1159 int isGeneralTextEntity, const ENCODING *enc, const char *ptr,
1160 const char *end, const char **badPtr, const char **versionPtr,
1161 const char **versionEndPtr, const char **encodingName,
1162 const ENCODING **encoding, int *standalone) {
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, &name, &nameEnd, &val, &ptr)
1169 || ! name) {
1170 *badPtr = ptr;
1171 return 0;
1172 }
1173 if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_version)) {
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, &name, &nameEnd, &val, &ptr)) {
1184 *badPtr = ptr;
1185 return 0;
1186 }
1187 if (! name) {
1188 if (isGeneralTextEntity) {
1189 /* a TextDecl must have an EncodingDecl */
1190 *badPtr = ptr;
1191 return 0;
1192 }
1193 return 1;
1194 }
1195 }
1196 if (XmlNameMatchesAscii(enc, name, nameEnd, KW_encoding)) {
1197 int c = toAscii(enc, val, end);
1198 if (! (ASCII_a <= c && c <= ASCII_z) && ! (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, ptr - enc->minBytesPerChar);
1206 if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
1207 *badPtr = ptr;
1208 return 0;
1209 }
1210 if (! name)
1211 return 1;
1212 }
1213 if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_standalone)
1214 || isGeneralTextEntity) {
1215 *badPtr = name;
1216 return 0;
1217 }
1218 if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_yes)) {
1219 if (standalone)
1220 *standalone = 1;
1221 } else if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_no)) {
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_NONXML)
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 for N byte sequence */
1265 min2 = 0x80,
1266 min3 = 0x800,
1267 min4 = 0x10000
1268 };
1269
1270 if (c < 0)
1271 return 0; /* LCOV_EXCL_LINE: this case is always eliminated beforehand */
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 is eliminated before calling */
1295 }
1296
1297 int FASTCALL
1298 XmlUtf16Encode(int charNum, unsigned short *buf) {
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) + 0xD800);
1308 buf[1] = (unsigned short)((charNum & 0x3FF) + 0xDC00);
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 struct unknown_encoding *)(enc))
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 char *p) {
1331 const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
1332 int c = uenc->convert(uenc->userData, p);
1333 if (c & ~0xFFFF)
1334 return 0;
1335 return UCS2_GET_NAMING(namePages, c >> 8, c & 0xFF);
1336 }
1337
1338 static int PTRFASTCALL
1339 unknown_isNmstrt(const ENCODING *enc, const char *p) {
1340 const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
1341 int c = uenc->convert(uenc->userData, p);
1342 if (c & ~0xFFFF)
1343 return 0;
1344 return UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xFF);
1345 }
1346
1347 static int PTRFASTCALL
1348 unknown_isInvalid(const ENCODING *enc, const char *p) {
1349 const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
1350 int c = uenc->convert(uenc->userData, p);
1351 return (c & ~0xFFFF) || checkCharRefNumber(c) < 0;
1352 }
1353
1354 static enum XML_Convert_Result PTRCALL
1355 unknown_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
1356 char **toP, const char *toLim) {
1357 const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
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, *fromP);
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)->type[(unsigned char)**fromP]
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 char **fromP, const char *fromLim,
1386 unsigned short **toP, const unsigned short *toLim) {
1387 const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
1388 while (*fromP < fromLim && *toP < toLim) {
1389 unsigned short c = uenc->utf16[(unsigned char)**fromP];
1390 if (c == 0) {
1391 c = (unsigned short)uenc->convert(uenc->userData, *fromP);
1392 *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
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, CONVERTER convert,
1407 void *userData) {
1408 int i;
1409 struct unknown_encoding *e = (struct unknown_encoding *)mem;
1410 memcpy(mem, &latin1_encoding, sizeof(struct normal_encoding));
1411 for (i = 0; i < 128; i++)
1412 if (latin1_encoding.type[i] != BT_OTHER
1413 && latin1_encoding.type[i] != BT_NONXML && table[i] != i)
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 converter function */
1427 if (! convert)
1428 return 0;
1429 e->normal.type[i] = (unsigned char)(BT_LEAD2 - (c + 2));
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_NONXML && c != i)
1435 return 0;
1436 e->normal.type[i] = latin1_encoding.type[c];
1437 e->utf8[i][0] = 1;
1438 e->utf8[i][1] = (char)c;
1439 e->utf16[i] = (unsigned short)(c == 0 ? 0xFFFF : c);
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, c & 0xff))
1450 e->normal.type[i] = BT_NMSTRT;
1451 else if (UCS2_GET_NAMING(namePages, c >> 8, c & 0xff))
1452 e->normal.type[i] = BT_NAME;
1453 else
1454 e->normal.type[i] = BT_OTHER;
1455 e->utf8[i][0] = (char)XmlUtf8Encode(c, e->utf8[i] + 1);
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_toUtf16;
1474 return &(e->normal.enc);
1475 }
1476
1477 /* If this enumeration is changed, getEncodingIndex and encodings
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_MINUS, ASCII_8, ASCII_8,
1493 ASCII_5, ASCII_9, ASCII_MINUS, ASCII_1, '\0'};
1494 static const char KW_US_ASCII[]
1495 = {ASCII_U, ASCII_S, ASCII_MINUS, ASCII_A, ASCII_S,
1496 ASCII_C, ASCII_I, ASCII_I, '\0'};
1497 static const char KW_UTF_8[]
1498 = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_8, '\0'};
1499 static const char KW_UTF_16[]
1500 = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, '\0'};
1501 static const char KW_UTF_16BE[]
1502 = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1,
1503 ASCII_6, ASCII_B, ASCII_E, '\0'};
1504 static const char KW_UTF_16LE[]
1505 = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1,
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, KW_UTF_16, KW_UTF_16BE, KW_UTF_16LE,
1512 };
1513 int i;
1514 if (name == NULL)
1515 return NO_ENC;
1516 for (i = 0; i < (int)(sizeof(encodingNames) / sizeof(encodingNames[0])); i++)
1517 if (streqci(name, encodingNames[i]))
1518 return i;
1519 return UNKNOWN_ENC;
1520 }
1521
1522 /* For binary compatibility, we store the index of the encoding
1523 specified at initialization in the isUtf16 member.
1524 */
1525
1526 #define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16)
1527 #define SET_INIT_ENC_INDEX(enc, i) ((enc)->initEnc.isUtf16 = (char)i)
1528
1529 /* This is what detects the encoding. encodingTable maps from
1530 encoding indices to encodings; INIT_ENC_INDEX(enc) is the index of
1531 the external (protocol) specified encoding; state is
1532 XML_CONTENT_STATE if we're parsing an external text entity, and
1533 XML_PROLOG_STATE otherwise.
1534 */
1535
1536 static int
1537 initScan(const ENCODING *const *encodingTable, const INIT_ENCODING *enc,
1538 int state, const char *ptr, const char *end, const char **nextTokPtr) {
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-detection */
1546 #ifndef XML_DTD /* FIXME */
1547 /* a well-formed document entity must have more than one byte */
1548 if (state != XML_CONTENT_STATE)
1549 return XML_TOK_PARTIAL;
1550 #endif
1551 /* so we're parsing an external text entity... */
1552 /* if UTF-16 was externally specified, then we need at least 2 bytes */
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-8 BOM */
1563 if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
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) | (unsigned char)ptr[1]) {
1572 case 0xFEFF:
1573 if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
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_ENC
1581 || INIT_ENC_INDEX(enc) == UTF_16_ENC)
1582 && state == XML_CONTENT_STATE)
1583 break;
1584 *encPtr = encodingTable[UTF_16LE_ENC];
1585 return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
1586 case 0xFFFE:
1587 if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
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 (external) encoding
1595 of ISO-8859-1 or some flavour of UTF-16
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_16BE_ENC || e == UTF_16LE_ENC
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. Furthermore a document
1617 entity can only start with ASCII characters. So the only
1618 way this can fail to be big-endian UTF-16 if it it's an
1619 external parsed general entity that's labelled as
1620 UTF-16LE.
1621 */
1622 if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC)
1623 break;
1624 *encPtr = encodingTable[UTF_16BE_ENC];
1625 return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
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 encoding
1631 - no encoding declaration
1632 by assuming UTF-16LE. But we don't, because this would mean when
1633 presented just with a single byte, we couldn't reliably determine
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, end, nextTokPtr);
1640 }
1641 break;
1642 }
1643 }
1644 *encPtr = encodingTable[INIT_ENC_INDEX(enc)];
1645 return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
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 *table, CONVERTER convert,
1670 void *userData) {
1671 ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData);
1672 if (enc)
1673 ((struct normal_encoding *)enc)->type[ASCII_COLON] = BT_COLON;
1674 return enc;
1675 }
1676
1677 #endif /* XML_NS */