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