1 /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
2    See the file COPYING for copying permission.
3 */
4 
5 /* This file is included! */
6 #ifdef XML_TOK_IMPL_C
7 
8 #ifndef IS_INVALID_CHAR
9 #define IS_INVALID_CHAR(enc, ptr, n) (0)
10 #endif
11 
12 #define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
13     case BT_LEAD ## n: \
14       if (end - ptr < n) \
15         return XML_TOK_PARTIAL_CHAR; \
16       if (IS_INVALID_CHAR(enc, ptr, n)) { \
17         *(nextTokPtr) = (ptr); \
18         return XML_TOK_INVALID; \
19       } \
20       ptr += n; \
21       break;
22 
23 #define INVALID_CASES(ptr, nextTokPtr) \
24   INVALID_LEAD_CASE(2, ptr, nextTokPtr) \
25   INVALID_LEAD_CASE(3, ptr, nextTokPtr) \
26   INVALID_LEAD_CASE(4, ptr, nextTokPtr) \
27   case BT_NONXML: \
28   case BT_MALFORM: \
29   case BT_TRAIL: \
30     *(nextTokPtr) = (ptr); \
31     return XML_TOK_INVALID;
32 
33 #define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
34    case BT_LEAD ## n: \
35      if (end - ptr < n) \
36        return XML_TOK_PARTIAL_CHAR; \
37      if (!IS_NAME_CHAR(enc, ptr, n)) { \
38        *nextTokPtr = ptr; \
39        return XML_TOK_INVALID; \
40      } \
41      ptr += n; \
42      break;
43 
44 #define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
45   case BT_NONASCII: \
46     if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \
47       *nextTokPtr = ptr; \
48       return XML_TOK_INVALID; \
49     } \
50   case BT_NMSTRT: \
51   case BT_HEX: \
52   case BT_DIGIT: \
53   case BT_NAME: \
54   case BT_MINUS: \
55     ptr += MINBPC(enc); \
56     break; \
57   CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
58   CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
59   CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
60 
61 #define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
62    case BT_LEAD ## n: \
63      if (end - ptr < n) \
64        return XML_TOK_PARTIAL_CHAR; \
65      if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \
66        *nextTokPtr = ptr; \
67        return XML_TOK_INVALID; \
68      } \
69      ptr += n; \
70      break;
71 
72 #define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
73   case BT_NONASCII: \
74     if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
75       *nextTokPtr = ptr; \
76       return XML_TOK_INVALID; \
77     } \
78   case BT_NMSTRT: \
79   case BT_HEX: \
80     ptr += MINBPC(enc); \
81     break; \
82   CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
83   CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
84   CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
85 
86 #ifndef PREFIX
87 #define PREFIX(ident) ident
88 #endif
89 
90 /* ptr points to character following "<!-" */
91 
92 static int PTRCALL
PREFIX(scanComment)93 PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
94                     const char *end, const char **nextTokPtr)
95 {
96   if (ptr < end) {
97     if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
98       *nextTokPtr = ptr;
99       return XML_TOK_INVALID;
100     }
101     ptr += MINBPC(enc);
102     while (ptr < end) {
103       switch (BYTE_TYPE(enc, ptr)) {
104       INVALID_CASES(ptr, nextTokPtr)
105       case BT_MINUS:
106         if ((ptr += MINBPC(enc)) == end)
107           return XML_TOK_PARTIAL;
108         if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
109           if ((ptr += MINBPC(enc)) == end)
110             return XML_TOK_PARTIAL;
111           if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
112             *nextTokPtr = ptr;
113             return XML_TOK_INVALID;
114           }
115           *nextTokPtr = ptr + MINBPC(enc);
116           return XML_TOK_COMMENT;
117         }
118         break;
119       default:
120         ptr += MINBPC(enc);
121         break;
122       }
123     }
124   }
125   return XML_TOK_PARTIAL;
126 }
127 
128 /* ptr points to character following "<!" */
129 
130 static int PTRCALL
PREFIX(scanDecl)131 PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
132                  const char *end, const char **nextTokPtr)
133 {
134   if (ptr == end)
135     return XML_TOK_PARTIAL;
136   switch (BYTE_TYPE(enc, ptr)) {
137   case BT_MINUS:
138     return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
139   case BT_LSQB:
140     *nextTokPtr = ptr + MINBPC(enc);
141     return XML_TOK_COND_SECT_OPEN;
142   case BT_NMSTRT:
143   case BT_HEX:
144     ptr += MINBPC(enc);
145     break;
146   default:
147     *nextTokPtr = ptr;
148     return XML_TOK_INVALID;
149   }
150   while (ptr < end) {
151     switch (BYTE_TYPE(enc, ptr)) {
152     case BT_PERCNT:
153       if (ptr + MINBPC(enc) == end)
154         return XML_TOK_PARTIAL;
155       /* don't allow <!ENTITY% foo "whatever"> */
156       switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
157       case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
158         *nextTokPtr = ptr;
159         return XML_TOK_INVALID;
160       }
161       /* fall through */
162     case BT_S: case BT_CR: case BT_LF:
163       *nextTokPtr = ptr;
164       return XML_TOK_DECL_OPEN;
165     case BT_NMSTRT:
166     case BT_HEX:
167       ptr += MINBPC(enc);
168       break;
169     default:
170       *nextTokPtr = ptr;
171       return XML_TOK_INVALID;
172     }
173   }
174   return XML_TOK_PARTIAL;
175 }
176 
177 static int PTRCALL
PREFIX(checkPiTarget)178 PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr,
179                       const char *end, int *tokPtr)
180 {
181   int upper = 0;
182   *tokPtr = XML_TOK_PI;
183   if (end - ptr != MINBPC(enc)*3)
184     return 1;
185   switch (BYTE_TO_ASCII(enc, ptr)) {
186   case ASCII_x:
187     break;
188   case ASCII_X:
189     upper = 1;
190     break;
191   default:
192     return 1;
193   }
194   ptr += MINBPC(enc);
195   switch (BYTE_TO_ASCII(enc, ptr)) {
196   case ASCII_m:
197     break;
198   case ASCII_M:
199     upper = 1;
200     break;
201   default:
202     return 1;
203   }
204   ptr += MINBPC(enc);
205   switch (BYTE_TO_ASCII(enc, ptr)) {
206   case ASCII_l:
207     break;
208   case ASCII_L:
209     upper = 1;
210     break;
211   default:
212     return 1;
213   }
214   if (upper)
215     return 0;
216   *tokPtr = XML_TOK_XML_DECL;
217   return 1;
218 }
219 
220 /* ptr points to character following "<?" */
221 
222 static int PTRCALL
PREFIX(scanPi)223 PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
224                const char *end, const char **nextTokPtr)
225 {
226   int tok;
227   const char *target = ptr;
228   if (ptr == end)
229     return XML_TOK_PARTIAL;
230   switch (BYTE_TYPE(enc, ptr)) {
231   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
232   default:
233     *nextTokPtr = ptr;
234     return XML_TOK_INVALID;
235   }
236   while (ptr < end) {
237     switch (BYTE_TYPE(enc, ptr)) {
238     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
239     case BT_S: case BT_CR: case BT_LF:
240       if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
241         *nextTokPtr = ptr;
242         return XML_TOK_INVALID;
243       }
244       ptr += MINBPC(enc);
245       while (ptr < end) {
246         switch (BYTE_TYPE(enc, ptr)) {
247         INVALID_CASES(ptr, nextTokPtr)
248         case BT_QUEST:
249           ptr += MINBPC(enc);
250           if (ptr == end)
251             return XML_TOK_PARTIAL;
252           if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
253             *nextTokPtr = ptr + MINBPC(enc);
254             return tok;
255           }
256           break;
257         default:
258           ptr += MINBPC(enc);
259           break;
260         }
261       }
262       return XML_TOK_PARTIAL;
263     case BT_QUEST:
264       if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
265         *nextTokPtr = ptr;
266         return XML_TOK_INVALID;
267       }
268       ptr += MINBPC(enc);
269       if (ptr == end)
270         return XML_TOK_PARTIAL;
271       if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
272         *nextTokPtr = ptr + MINBPC(enc);
273         return tok;
274       }
275       /* fall through */
276     default:
277       *nextTokPtr = ptr;
278       return XML_TOK_INVALID;
279     }
280   }
281   return XML_TOK_PARTIAL;
282 }
283 
284 static int PTRCALL
PREFIX(scanCdataSection)285 PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr,
286                          const char *end, const char **nextTokPtr)
287 {
288   static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A,
289                                      ASCII_T, ASCII_A, ASCII_LSQB };
290   int i;
291   /* CDATA[ */
292   if (end - ptr < 6 * MINBPC(enc))
293     return XML_TOK_PARTIAL;
294   for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
295     if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
296       *nextTokPtr = ptr;
297       return XML_TOK_INVALID;
298     }
299   }
300   *nextTokPtr = ptr;
301   return XML_TOK_CDATA_SECT_OPEN;
302 }
303 
304 static int PTRCALL
PREFIX(cdataSectionTok)305 PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
306                         const char *end, const char **nextTokPtr)
307 {
308   if (ptr >= end)
309     return XML_TOK_NONE;
310   if (MINBPC(enc) > 1) {
311     size_t n = end - ptr;
312     if (n & (MINBPC(enc) - 1)) {
313       n &= ~(MINBPC(enc) - 1);
314       if (n == 0)
315         return XML_TOK_PARTIAL;
316       end = ptr + n;
317     }
318   }
319   switch (BYTE_TYPE(enc, ptr)) {
320   case BT_RSQB:
321     ptr += MINBPC(enc);
322     if (ptr == end)
323       return XML_TOK_PARTIAL;
324     if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
325       break;
326     ptr += MINBPC(enc);
327     if (ptr == end)
328       return XML_TOK_PARTIAL;
329     if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
330       ptr -= MINBPC(enc);
331       break;
332     }
333     *nextTokPtr = ptr + MINBPC(enc);
334     return XML_TOK_CDATA_SECT_CLOSE;
335   case BT_CR:
336     ptr += MINBPC(enc);
337     if (ptr == end)
338       return XML_TOK_PARTIAL;
339     if (BYTE_TYPE(enc, ptr) == BT_LF)
340       ptr += MINBPC(enc);
341     *nextTokPtr = ptr;
342     return XML_TOK_DATA_NEWLINE;
343   case BT_LF:
344     *nextTokPtr = ptr + MINBPC(enc);
345     return XML_TOK_DATA_NEWLINE;
346   INVALID_CASES(ptr, nextTokPtr)
347   default:
348     ptr += MINBPC(enc);
349     break;
350   }
351   while (ptr < end) {
352     switch (BYTE_TYPE(enc, ptr)) {
353 #define LEAD_CASE(n) \
354     case BT_LEAD ## n: \
355       if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
356         *nextTokPtr = ptr; \
357         return XML_TOK_DATA_CHARS; \
358       } \
359       ptr += n; \
360       break;
361     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
362 #undef LEAD_CASE
363     case BT_NONXML:
364     case BT_MALFORM:
365     case BT_TRAIL:
366     case BT_CR:
367     case BT_LF:
368     case BT_RSQB:
369       *nextTokPtr = ptr;
370       return XML_TOK_DATA_CHARS;
371     default:
372       ptr += MINBPC(enc);
373       break;
374     }
375   }
376   *nextTokPtr = ptr;
377   return XML_TOK_DATA_CHARS;
378 }
379 
380 /* ptr points to character following "</" */
381 
382 static int PTRCALL
PREFIX(scanEndTag)383 PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
384                    const char *end, const char **nextTokPtr)
385 {
386   if (ptr == end)
387     return XML_TOK_PARTIAL;
388   switch (BYTE_TYPE(enc, ptr)) {
389   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
390   default:
391     *nextTokPtr = ptr;
392     return XML_TOK_INVALID;
393   }
394   while (ptr < end) {
395     switch (BYTE_TYPE(enc, ptr)) {
396     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
397     case BT_S: case BT_CR: case BT_LF:
398       for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
399         switch (BYTE_TYPE(enc, ptr)) {
400         case BT_S: case BT_CR: case BT_LF:
401           break;
402         case BT_GT:
403           *nextTokPtr = ptr + MINBPC(enc);
404           return XML_TOK_END_TAG;
405         default:
406           *nextTokPtr = ptr;
407           return XML_TOK_INVALID;
408         }
409       }
410       return XML_TOK_PARTIAL;
411 #ifdef XML_NS
412     case BT_COLON:
413       /* no need to check qname syntax here,
414          since end-tag must match exactly */
415       ptr += MINBPC(enc);
416       break;
417 #endif
418     case BT_GT:
419       *nextTokPtr = ptr + MINBPC(enc);
420       return XML_TOK_END_TAG;
421     default:
422       *nextTokPtr = ptr;
423       return XML_TOK_INVALID;
424     }
425   }
426   return XML_TOK_PARTIAL;
427 }
428 
429 /* ptr points to character following "&#X" */
430 
431 static int PTRCALL
PREFIX(scanHexCharRef)432 PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
433                        const char *end, const char **nextTokPtr)
434 {
435   if (ptr < end) {
436     switch (BYTE_TYPE(enc, ptr)) {
437     case BT_DIGIT:
438     case BT_HEX:
439       break;
440     default:
441       *nextTokPtr = ptr;
442       return XML_TOK_INVALID;
443     }
444     for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
445       switch (BYTE_TYPE(enc, ptr)) {
446       case BT_DIGIT:
447       case BT_HEX:
448         break;
449       case BT_SEMI:
450         *nextTokPtr = ptr + MINBPC(enc);
451         return XML_TOK_CHAR_REF;
452       default:
453         *nextTokPtr = ptr;
454         return XML_TOK_INVALID;
455       }
456     }
457   }
458   return XML_TOK_PARTIAL;
459 }
460 
461 /* ptr points to character following "&#" */
462 
463 static int PTRCALL
PREFIX(scanCharRef)464 PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
465                     const char *end, const char **nextTokPtr)
466 {
467   if (ptr < end) {
468     if (CHAR_MATCHES(enc, ptr, ASCII_x))
469       return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
470     switch (BYTE_TYPE(enc, ptr)) {
471     case BT_DIGIT:
472       break;
473     default:
474       *nextTokPtr = ptr;
475       return XML_TOK_INVALID;
476     }
477     for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
478       switch (BYTE_TYPE(enc, ptr)) {
479       case BT_DIGIT:
480         break;
481       case BT_SEMI:
482         *nextTokPtr = ptr + MINBPC(enc);
483         return XML_TOK_CHAR_REF;
484       default:
485         *nextTokPtr = ptr;
486         return XML_TOK_INVALID;
487       }
488     }
489   }
490   return XML_TOK_PARTIAL;
491 }
492 
493 /* ptr points to character following "&" */
494 
495 static int PTRCALL
PREFIX(scanRef)496 PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
497                 const char **nextTokPtr)
498 {
499   if (ptr == end)
500     return XML_TOK_PARTIAL;
501   switch (BYTE_TYPE(enc, ptr)) {
502   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
503   case BT_NUM:
504     return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
505   default:
506     *nextTokPtr = ptr;
507     return XML_TOK_INVALID;
508   }
509   while (ptr < end) {
510     switch (BYTE_TYPE(enc, ptr)) {
511     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
512     case BT_SEMI:
513       *nextTokPtr = ptr + MINBPC(enc);
514       return XML_TOK_ENTITY_REF;
515     default:
516       *nextTokPtr = ptr;
517       return XML_TOK_INVALID;
518     }
519   }
520   return XML_TOK_PARTIAL;
521 }
522 
523 /* ptr points to character following first character of attribute name */
524 
525 static int PTRCALL
PREFIX(scanAtts)526 PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
527                  const char **nextTokPtr)
528 {
529 #ifdef XML_NS
530   int hadColon = 0;
531 #endif
532   while (ptr < end) {
533     switch (BYTE_TYPE(enc, ptr)) {
534     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
535 #ifdef XML_NS
536     case BT_COLON:
537       if (hadColon) {
538         *nextTokPtr = ptr;
539         return XML_TOK_INVALID;
540       }
541       hadColon = 1;
542       ptr += MINBPC(enc);
543       if (ptr == end)
544         return XML_TOK_PARTIAL;
545       switch (BYTE_TYPE(enc, ptr)) {
546       CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
547       default:
548         *nextTokPtr = ptr;
549         return XML_TOK_INVALID;
550       }
551       break;
552 #endif
553     case BT_S: case BT_CR: case BT_LF:
554       for (;;) {
555         int t;
556 
557         ptr += MINBPC(enc);
558         if (ptr == end)
559           return XML_TOK_PARTIAL;
560         t = BYTE_TYPE(enc, ptr);
561         if (t == BT_EQUALS)
562           break;
563         switch (t) {
564         case BT_S:
565         case BT_LF:
566         case BT_CR:
567           break;
568         default:
569           *nextTokPtr = ptr;
570           return XML_TOK_INVALID;
571         }
572       }
573     /* fall through */
574     case BT_EQUALS:
575       {
576         int open;
577 #ifdef XML_NS
578         hadColon = 0;
579 #endif
580         for (;;) {
581           ptr += MINBPC(enc);
582           if (ptr == end)
583             return XML_TOK_PARTIAL;
584           open = BYTE_TYPE(enc, ptr);
585           if (open == BT_QUOT || open == BT_APOS)
586             break;
587           switch (open) {
588           case BT_S:
589           case BT_LF:
590           case BT_CR:
591             break;
592           default:
593             *nextTokPtr = ptr;
594             return XML_TOK_INVALID;
595           }
596         }
597         ptr += MINBPC(enc);
598         /* in attribute value */
599         for (;;) {
600           int t;
601           if (ptr == end)
602             return XML_TOK_PARTIAL;
603           t = BYTE_TYPE(enc, ptr);
604           if (t == open)
605             break;
606           switch (t) {
607           INVALID_CASES(ptr, nextTokPtr)
608           case BT_AMP:
609             {
610               int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
611               if (tok <= 0) {
612                 if (tok == XML_TOK_INVALID)
613                   *nextTokPtr = ptr;
614                 return tok;
615               }
616               break;
617             }
618           case BT_LT:
619             *nextTokPtr = ptr;
620             return XML_TOK_INVALID;
621           default:
622             ptr += MINBPC(enc);
623             break;
624           }
625         }
626         ptr += MINBPC(enc);
627         if (ptr == end)
628           return XML_TOK_PARTIAL;
629         switch (BYTE_TYPE(enc, ptr)) {
630         case BT_S:
631         case BT_CR:
632         case BT_LF:
633           break;
634         case BT_SOL:
635           goto sol;
636         case BT_GT:
637           goto gt;
638         default:
639           *nextTokPtr = ptr;
640           return XML_TOK_INVALID;
641         }
642         /* ptr points to closing quote */
643         for (;;) {
644           ptr += MINBPC(enc);
645           if (ptr == end)
646             return XML_TOK_PARTIAL;
647           switch (BYTE_TYPE(enc, ptr)) {
648           CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
649           case BT_S: case BT_CR: case BT_LF:
650             continue;
651           case BT_GT:
652           gt:
653             *nextTokPtr = ptr + MINBPC(enc);
654             return XML_TOK_START_TAG_WITH_ATTS;
655           case BT_SOL:
656           sol:
657             ptr += MINBPC(enc);
658             if (ptr == end)
659               return XML_TOK_PARTIAL;
660             if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
661               *nextTokPtr = ptr;
662               return XML_TOK_INVALID;
663             }
664             *nextTokPtr = ptr + MINBPC(enc);
665             return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
666           default:
667             *nextTokPtr = ptr;
668             return XML_TOK_INVALID;
669           }
670           break;
671         }
672         break;
673       }
674     default:
675       *nextTokPtr = ptr;
676       return XML_TOK_INVALID;
677     }
678   }
679   return XML_TOK_PARTIAL;
680 }
681 
682 /* ptr points to character following "<" */
683 
684 static int PTRCALL
PREFIX(scanLt)685 PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
686                const char **nextTokPtr)
687 {
688 #ifdef XML_NS
689   int hadColon;
690 #endif
691   if (ptr == end)
692     return XML_TOK_PARTIAL;
693   switch (BYTE_TYPE(enc, ptr)) {
694   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
695   case BT_EXCL:
696     if ((ptr += MINBPC(enc)) == end)
697       return XML_TOK_PARTIAL;
698     switch (BYTE_TYPE(enc, ptr)) {
699     case BT_MINUS:
700       return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
701     case BT_LSQB:
702       return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc),
703                                       end, nextTokPtr);
704     }
705     *nextTokPtr = ptr;
706     return XML_TOK_INVALID;
707   case BT_QUEST:
708     return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
709   case BT_SOL:
710     return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
711   default:
712     *nextTokPtr = ptr;
713     return XML_TOK_INVALID;
714   }
715 #ifdef XML_NS
716   hadColon = 0;
717 #endif
718   /* we have a start-tag */
719   while (ptr < end) {
720     switch (BYTE_TYPE(enc, ptr)) {
721     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
722 #ifdef XML_NS
723     case BT_COLON:
724       if (hadColon) {
725         *nextTokPtr = ptr;
726         return XML_TOK_INVALID;
727       }
728       hadColon = 1;
729       ptr += MINBPC(enc);
730       if (ptr == end)
731         return XML_TOK_PARTIAL;
732       switch (BYTE_TYPE(enc, ptr)) {
733       CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
734       default:
735         *nextTokPtr = ptr;
736         return XML_TOK_INVALID;
737       }
738       break;
739 #endif
740     case BT_S: case BT_CR: case BT_LF:
741       {
742         ptr += MINBPC(enc);
743         while (ptr < end) {
744           switch (BYTE_TYPE(enc, ptr)) {
745           CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
746           case BT_GT:
747             goto gt;
748           case BT_SOL:
749             goto sol;
750           case BT_S: case BT_CR: case BT_LF:
751             ptr += MINBPC(enc);
752             continue;
753           default:
754             *nextTokPtr = ptr;
755             return XML_TOK_INVALID;
756           }
757           return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
758         }
759         return XML_TOK_PARTIAL;
760       }
761     case BT_GT:
762     gt:
763       *nextTokPtr = ptr + MINBPC(enc);
764       return XML_TOK_START_TAG_NO_ATTS;
765     case BT_SOL:
766     sol:
767       ptr += MINBPC(enc);
768       if (ptr == end)
769         return XML_TOK_PARTIAL;
770       if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
771         *nextTokPtr = ptr;
772         return XML_TOK_INVALID;
773       }
774       *nextTokPtr = ptr + MINBPC(enc);
775       return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
776     default:
777       *nextTokPtr = ptr;
778       return XML_TOK_INVALID;
779     }
780   }
781   return XML_TOK_PARTIAL;
782 }
783 
784 static int PTRCALL
PREFIX(contentTok)785 PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
786                    const char **nextTokPtr)
787 {
788   if (ptr >= end)
789     return XML_TOK_NONE;
790   if (MINBPC(enc) > 1) {
791     size_t n = end - ptr;
792     if (n & (MINBPC(enc) - 1)) {
793       n &= ~(MINBPC(enc) - 1);
794       if (n == 0)
795         return XML_TOK_PARTIAL;
796       end = ptr + n;
797     }
798   }
799   switch (BYTE_TYPE(enc, ptr)) {
800   case BT_LT:
801     return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
802   case BT_AMP:
803     return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
804   case BT_CR:
805     ptr += MINBPC(enc);
806     if (ptr == end)
807       return XML_TOK_TRAILING_CR;
808     if (BYTE_TYPE(enc, ptr) == BT_LF)
809       ptr += MINBPC(enc);
810     *nextTokPtr = ptr;
811     return XML_TOK_DATA_NEWLINE;
812   case BT_LF:
813     *nextTokPtr = ptr + MINBPC(enc);
814     return XML_TOK_DATA_NEWLINE;
815   case BT_RSQB:
816     ptr += MINBPC(enc);
817     if (ptr == end)
818       return XML_TOK_TRAILING_RSQB;
819     if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
820       break;
821     ptr += MINBPC(enc);
822     if (ptr == end)
823       return XML_TOK_TRAILING_RSQB;
824     if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
825       ptr -= MINBPC(enc);
826       break;
827     }
828     *nextTokPtr = ptr;
829     return XML_TOK_INVALID;
830   INVALID_CASES(ptr, nextTokPtr)
831   default:
832     ptr += MINBPC(enc);
833     break;
834   }
835   while (ptr < end) {
836     switch (BYTE_TYPE(enc, ptr)) {
837 #define LEAD_CASE(n) \
838     case BT_LEAD ## n: \
839       if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
840         *nextTokPtr = ptr; \
841         return XML_TOK_DATA_CHARS; \
842       } \
843       ptr += n; \
844       break;
845     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
846 #undef LEAD_CASE
847     case BT_RSQB:
848       if (ptr + MINBPC(enc) != end) {
849          if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
850            ptr += MINBPC(enc);
851            break;
852          }
853          if (ptr + 2*MINBPC(enc) != end) {
854            if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) {
855              ptr += MINBPC(enc);
856              break;
857            }
858            *nextTokPtr = ptr + 2*MINBPC(enc);
859            return XML_TOK_INVALID;
860          }
861       }
862       /* fall through */
863     case BT_AMP:
864     case BT_LT:
865     case BT_NONXML:
866     case BT_MALFORM:
867     case BT_TRAIL:
868     case BT_CR:
869     case BT_LF:
870       *nextTokPtr = ptr;
871       return XML_TOK_DATA_CHARS;
872     default:
873       ptr += MINBPC(enc);
874       break;
875     }
876   }
877   *nextTokPtr = ptr;
878   return XML_TOK_DATA_CHARS;
879 }
880 
881 /* ptr points to character following "%" */
882 
883 static int PTRCALL
PREFIX(scanPercent)884 PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
885                     const char **nextTokPtr)
886 {
887   if (ptr == end)
888     return XML_TOK_PARTIAL;
889   switch (BYTE_TYPE(enc, ptr)) {
890   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
891   case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
892     *nextTokPtr = ptr;
893     return XML_TOK_PERCENT;
894   default:
895     *nextTokPtr = ptr;
896     return XML_TOK_INVALID;
897   }
898   while (ptr < end) {
899     switch (BYTE_TYPE(enc, ptr)) {
900     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
901     case BT_SEMI:
902       *nextTokPtr = ptr + MINBPC(enc);
903       return XML_TOK_PARAM_ENTITY_REF;
904     default:
905       *nextTokPtr = ptr;
906       return XML_TOK_INVALID;
907     }
908   }
909   return XML_TOK_PARTIAL;
910 }
911 
912 static int PTRCALL
PREFIX(scanPoundName)913 PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
914                       const char **nextTokPtr)
915 {
916   if (ptr == end)
917     return XML_TOK_PARTIAL;
918   switch (BYTE_TYPE(enc, ptr)) {
919   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
920   default:
921     *nextTokPtr = ptr;
922     return XML_TOK_INVALID;
923   }
924   while (ptr < end) {
925     switch (BYTE_TYPE(enc, ptr)) {
926     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
927     case BT_CR: case BT_LF: case BT_S:
928     case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR:
929       *nextTokPtr = ptr;
930       return XML_TOK_POUND_NAME;
931     default:
932       *nextTokPtr = ptr;
933       return XML_TOK_INVALID;
934     }
935   }
936   return -XML_TOK_POUND_NAME;
937 }
938 
939 static int PTRCALL
PREFIX(scanLit)940 PREFIX(scanLit)(int open, const ENCODING *enc,
941                 const char *ptr, const char *end,
942                 const char **nextTokPtr)
943 {
944   while (ptr < end) {
945     int t = BYTE_TYPE(enc, ptr);
946     switch (t) {
947     INVALID_CASES(ptr, nextTokPtr)
948     case BT_QUOT:
949     case BT_APOS:
950       ptr += MINBPC(enc);
951       if (t != open)
952         break;
953       if (ptr == end)
954         return -XML_TOK_LITERAL;
955       *nextTokPtr = ptr;
956       switch (BYTE_TYPE(enc, ptr)) {
957       case BT_S: case BT_CR: case BT_LF:
958       case BT_GT: case BT_PERCNT: case BT_LSQB:
959         return XML_TOK_LITERAL;
960       default:
961         return XML_TOK_INVALID;
962       }
963     default:
964       ptr += MINBPC(enc);
965       break;
966     }
967   }
968   return XML_TOK_PARTIAL;
969 }
970 
971 static int PTRCALL
PREFIX(prologTok)972 PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
973                   const char **nextTokPtr)
974 {
975   int tok;
976   if (ptr >= end)
977     return XML_TOK_NONE;
978   if (MINBPC(enc) > 1) {
979     size_t n = end - ptr;
980     if (n & (MINBPC(enc) - 1)) {
981       n &= ~(MINBPC(enc) - 1);
982       if (n == 0)
983         return XML_TOK_PARTIAL;
984       end = ptr + n;
985     }
986   }
987   switch (BYTE_TYPE(enc, ptr)) {
988   case BT_QUOT:
989     return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
990   case BT_APOS:
991     return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
992   case BT_LT:
993     {
994       ptr += MINBPC(enc);
995       if (ptr == end)
996         return XML_TOK_PARTIAL;
997       switch (BYTE_TYPE(enc, ptr)) {
998       case BT_EXCL:
999         return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1000       case BT_QUEST:
1001         return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1002       case BT_NMSTRT:
1003       case BT_HEX:
1004       case BT_NONASCII:
1005       case BT_LEAD2:
1006       case BT_LEAD3:
1007       case BT_LEAD4:
1008         *nextTokPtr = ptr - MINBPC(enc);
1009         return XML_TOK_INSTANCE_START;
1010       }
1011       *nextTokPtr = ptr;
1012       return XML_TOK_INVALID;
1013     }
1014   case BT_CR:
1015     if (ptr + MINBPC(enc) == end) {
1016       *nextTokPtr = end;
1017       /* indicate that this might be part of a CR/LF pair */
1018       return -XML_TOK_PROLOG_S;
1019     }
1020     /* fall through */
1021   case BT_S: case BT_LF:
1022     for (;;) {
1023       ptr += MINBPC(enc);
1024       if (ptr == end)
1025         break;
1026       switch (BYTE_TYPE(enc, ptr)) {
1027       case BT_S: case BT_LF:
1028         break;
1029       case BT_CR:
1030         /* don't split CR/LF pair */
1031         if (ptr + MINBPC(enc) != end)
1032           break;
1033         /* fall through */
1034       default:
1035         *nextTokPtr = ptr;
1036         return XML_TOK_PROLOG_S;
1037       }
1038     }
1039     *nextTokPtr = ptr;
1040     return XML_TOK_PROLOG_S;
1041   case BT_PERCNT:
1042     return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1043   case BT_COMMA:
1044     *nextTokPtr = ptr + MINBPC(enc);
1045     return XML_TOK_COMMA;
1046   case BT_LSQB:
1047     *nextTokPtr = ptr + MINBPC(enc);
1048     return XML_TOK_OPEN_BRACKET;
1049   case BT_RSQB:
1050     ptr += MINBPC(enc);
1051     if (ptr == end)
1052       return -XML_TOK_CLOSE_BRACKET;
1053     if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1054       if (ptr + MINBPC(enc) == end)
1055         return XML_TOK_PARTIAL;
1056       if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
1057         *nextTokPtr = ptr + 2*MINBPC(enc);
1058         return XML_TOK_COND_SECT_CLOSE;
1059       }
1060     }
1061     *nextTokPtr = ptr;
1062     return XML_TOK_CLOSE_BRACKET;
1063   case BT_LPAR:
1064     *nextTokPtr = ptr + MINBPC(enc);
1065     return XML_TOK_OPEN_PAREN;
1066   case BT_RPAR:
1067     ptr += MINBPC(enc);
1068     if (ptr == end)
1069       return -XML_TOK_CLOSE_PAREN;
1070     switch (BYTE_TYPE(enc, ptr)) {
1071     case BT_AST:
1072       *nextTokPtr = ptr + MINBPC(enc);
1073       return XML_TOK_CLOSE_PAREN_ASTERISK;
1074     case BT_QUEST:
1075       *nextTokPtr = ptr + MINBPC(enc);
1076       return XML_TOK_CLOSE_PAREN_QUESTION;
1077     case BT_PLUS:
1078       *nextTokPtr = ptr + MINBPC(enc);
1079       return XML_TOK_CLOSE_PAREN_PLUS;
1080     case BT_CR: case BT_LF: case BT_S:
1081     case BT_GT: case BT_COMMA: case BT_VERBAR:
1082     case BT_RPAR:
1083       *nextTokPtr = ptr;
1084       return XML_TOK_CLOSE_PAREN;
1085     }
1086     *nextTokPtr = ptr;
1087     return XML_TOK_INVALID;
1088   case BT_VERBAR:
1089     *nextTokPtr = ptr + MINBPC(enc);
1090     return XML_TOK_OR;
1091   case BT_GT:
1092     *nextTokPtr = ptr + MINBPC(enc);
1093     return XML_TOK_DECL_CLOSE;
1094   case BT_NUM:
1095     return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1096 #define LEAD_CASE(n) \
1097   case BT_LEAD ## n: \
1098     if (end - ptr < n) \
1099       return XML_TOK_PARTIAL_CHAR; \
1100     if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
1101       ptr += n; \
1102       tok = XML_TOK_NAME; \
1103       break; \
1104     } \
1105     if (IS_NAME_CHAR(enc, ptr, n)) { \
1106       ptr += n; \
1107       tok = XML_TOK_NMTOKEN; \
1108       break; \
1109     } \
1110     *nextTokPtr = ptr; \
1111     return XML_TOK_INVALID;
1112     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1113 #undef LEAD_CASE
1114   case BT_NMSTRT:
1115   case BT_HEX:
1116     tok = XML_TOK_NAME;
1117     ptr += MINBPC(enc);
1118     break;
1119   case BT_DIGIT:
1120   case BT_NAME:
1121   case BT_MINUS:
1122 #ifdef XML_NS
1123   case BT_COLON:
1124 #endif
1125     tok = XML_TOK_NMTOKEN;
1126     ptr += MINBPC(enc);
1127     break;
1128   case BT_NONASCII:
1129     if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
1130       ptr += MINBPC(enc);
1131       tok = XML_TOK_NAME;
1132       break;
1133     }
1134     if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
1135       ptr += MINBPC(enc);
1136       tok = XML_TOK_NMTOKEN;
1137       break;
1138     }
1139     /* fall through */
1140   default:
1141     *nextTokPtr = ptr;
1142     return XML_TOK_INVALID;
1143   }
1144   while (ptr < end) {
1145     switch (BYTE_TYPE(enc, ptr)) {
1146     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1147     case BT_GT: case BT_RPAR: case BT_COMMA:
1148     case BT_VERBAR: case BT_LSQB: case BT_PERCNT:
1149     case BT_S: case BT_CR: case BT_LF:
1150       *nextTokPtr = ptr;
1151       return tok;
1152 #ifdef XML_NS
1153     case BT_COLON:
1154       ptr += MINBPC(enc);
1155       switch (tok) {
1156       case XML_TOK_NAME:
1157         if (ptr == end)
1158           return XML_TOK_PARTIAL;
1159         tok = XML_TOK_PREFIXED_NAME;
1160         switch (BYTE_TYPE(enc, ptr)) {
1161         CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1162         default:
1163           tok = XML_TOK_NMTOKEN;
1164           break;
1165         }
1166         break;
1167       case XML_TOK_PREFIXED_NAME:
1168         tok = XML_TOK_NMTOKEN;
1169         break;
1170       }
1171       break;
1172 #endif
1173     case BT_PLUS:
1174       if (tok == XML_TOK_NMTOKEN)  {
1175         *nextTokPtr = ptr;
1176         return XML_TOK_INVALID;
1177       }
1178       *nextTokPtr = ptr + MINBPC(enc);
1179       return XML_TOK_NAME_PLUS;
1180     case BT_AST:
1181       if (tok == XML_TOK_NMTOKEN)  {
1182         *nextTokPtr = ptr;
1183         return XML_TOK_INVALID;
1184       }
1185       *nextTokPtr = ptr + MINBPC(enc);
1186       return XML_TOK_NAME_ASTERISK;
1187     case BT_QUEST:
1188       if (tok == XML_TOK_NMTOKEN)  {
1189         *nextTokPtr = ptr;
1190         return XML_TOK_INVALID;
1191       }
1192       *nextTokPtr = ptr + MINBPC(enc);
1193       return XML_TOK_NAME_QUESTION;
1194     default:
1195       *nextTokPtr = ptr;
1196       return XML_TOK_INVALID;
1197     }
1198   }
1199   return -tok;
1200 }
1201 
1202 static int PTRCALL
PREFIX(attributeValueTok)1203 PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
1204                           const char *end, const char **nextTokPtr)
1205 {
1206   const char *start;
1207   if (ptr >= end)
1208     return XML_TOK_NONE;
1209   start = ptr;
1210   while (ptr < end) {
1211     switch (BYTE_TYPE(enc, ptr)) {
1212 #define LEAD_CASE(n) \
1213     case BT_LEAD ## n: ptr += n; break;
1214     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1215 #undef LEAD_CASE
1216     case BT_AMP:
1217       if (ptr == start)
1218         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1219       *nextTokPtr = ptr;
1220       return XML_TOK_DATA_CHARS;
1221     case BT_LT:
1222       /* this is for inside entity references */
1223       *nextTokPtr = ptr;
1224       return XML_TOK_INVALID;
1225     case BT_LF:
1226       if (ptr == start) {
1227         *nextTokPtr = ptr + MINBPC(enc);
1228         return XML_TOK_DATA_NEWLINE;
1229       }
1230       *nextTokPtr = ptr;
1231       return XML_TOK_DATA_CHARS;
1232     case BT_CR:
1233       if (ptr == start) {
1234         ptr += MINBPC(enc);
1235         if (ptr == end)
1236           return XML_TOK_TRAILING_CR;
1237         if (BYTE_TYPE(enc, ptr) == BT_LF)
1238           ptr += MINBPC(enc);
1239         *nextTokPtr = ptr;
1240         return XML_TOK_DATA_NEWLINE;
1241       }
1242       *nextTokPtr = ptr;
1243       return XML_TOK_DATA_CHARS;
1244     case BT_S:
1245       if (ptr == start) {
1246         *nextTokPtr = ptr + MINBPC(enc);
1247         return XML_TOK_ATTRIBUTE_VALUE_S;
1248       }
1249       *nextTokPtr = ptr;
1250       return XML_TOK_DATA_CHARS;
1251     default:
1252       ptr += MINBPC(enc);
1253       break;
1254     }
1255   }
1256   *nextTokPtr = ptr;
1257   return XML_TOK_DATA_CHARS;
1258 }
1259 
1260 static int PTRCALL
PREFIX(entityValueTok)1261 PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
1262                        const char *end, const char **nextTokPtr)
1263 {
1264   const char *start;
1265   if (ptr >= end)
1266     return XML_TOK_NONE;
1267   start = ptr;
1268   while (ptr < end) {
1269     switch (BYTE_TYPE(enc, ptr)) {
1270 #define LEAD_CASE(n) \
1271     case BT_LEAD ## n: ptr += n; break;
1272     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1273 #undef LEAD_CASE
1274     case BT_AMP:
1275       if (ptr == start)
1276         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1277       *nextTokPtr = ptr;
1278       return XML_TOK_DATA_CHARS;
1279     case BT_PERCNT:
1280       if (ptr == start) {
1281         int tok =  PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
1282                                        end, nextTokPtr);
1283         return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
1284       }
1285       *nextTokPtr = ptr;
1286       return XML_TOK_DATA_CHARS;
1287     case BT_LF:
1288       if (ptr == start) {
1289         *nextTokPtr = ptr + MINBPC(enc);
1290         return XML_TOK_DATA_NEWLINE;
1291       }
1292       *nextTokPtr = ptr;
1293       return XML_TOK_DATA_CHARS;
1294     case BT_CR:
1295       if (ptr == start) {
1296         ptr += MINBPC(enc);
1297         if (ptr == end)
1298           return XML_TOK_TRAILING_CR;
1299         if (BYTE_TYPE(enc, ptr) == BT_LF)
1300           ptr += MINBPC(enc);
1301         *nextTokPtr = ptr;
1302         return XML_TOK_DATA_NEWLINE;
1303       }
1304       *nextTokPtr = ptr;
1305       return XML_TOK_DATA_CHARS;
1306     default:
1307       ptr += MINBPC(enc);
1308       break;
1309     }
1310   }
1311   *nextTokPtr = ptr;
1312   return XML_TOK_DATA_CHARS;
1313 }
1314 
1315 #ifdef XML_DTD
1316 
1317 static int PTRCALL
PREFIX(ignoreSectionTok)1318 PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
1319                          const char *end, const char **nextTokPtr)
1320 {
1321   int level = 0;
1322   if (MINBPC(enc) > 1) {
1323     size_t n = end - ptr;
1324     if (n & (MINBPC(enc) - 1)) {
1325       n &= ~(MINBPC(enc) - 1);
1326       end = ptr + n;
1327     }
1328   }
1329   while (ptr < end) {
1330     switch (BYTE_TYPE(enc, ptr)) {
1331     INVALID_CASES(ptr, nextTokPtr)
1332     case BT_LT:
1333       if ((ptr += MINBPC(enc)) == end)
1334         return XML_TOK_PARTIAL;
1335       if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
1336         if ((ptr += MINBPC(enc)) == end)
1337           return XML_TOK_PARTIAL;
1338         if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
1339           ++level;
1340           ptr += MINBPC(enc);
1341         }
1342       }
1343       break;
1344     case BT_RSQB:
1345       if ((ptr += MINBPC(enc)) == end)
1346         return XML_TOK_PARTIAL;
1347       if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1348         if ((ptr += MINBPC(enc)) == end)
1349           return XML_TOK_PARTIAL;
1350         if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
1351           ptr += MINBPC(enc);
1352           if (level == 0) {
1353             *nextTokPtr = ptr;
1354             return XML_TOK_IGNORE_SECT;
1355           }
1356           --level;
1357         }
1358       }
1359       break;
1360     default:
1361       ptr += MINBPC(enc);
1362       break;
1363     }
1364   }
1365   return XML_TOK_PARTIAL;
1366 }
1367 
1368 #endif /* XML_DTD */
1369 
1370 static int PTRCALL
PREFIX(isPublicId)1371 PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
1372                    const char **badPtr)
1373 {
1374   ptr += MINBPC(enc);
1375   end -= MINBPC(enc);
1376   for (; ptr < end; ptr += MINBPC(enc)) {
1377     switch (BYTE_TYPE(enc, ptr)) {
1378     case BT_DIGIT:
1379     case BT_HEX:
1380     case BT_MINUS:
1381     case BT_APOS:
1382     case BT_LPAR:
1383     case BT_RPAR:
1384     case BT_PLUS:
1385     case BT_COMMA:
1386     case BT_SOL:
1387     case BT_EQUALS:
1388     case BT_QUEST:
1389     case BT_CR:
1390     case BT_LF:
1391     case BT_SEMI:
1392     case BT_EXCL:
1393     case BT_AST:
1394     case BT_PERCNT:
1395     case BT_NUM:
1396 #ifdef XML_NS
1397     case BT_COLON:
1398 #endif
1399       break;
1400     case BT_S:
1401       if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
1402         *badPtr = ptr;
1403         return 0;
1404       }
1405       break;
1406     case BT_NAME:
1407     case BT_NMSTRT:
1408       if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
1409         break;
1410     default:
1411       switch (BYTE_TO_ASCII(enc, ptr)) {
1412       case 0x24: /* $ */
1413       case 0x40: /* @ */
1414         break;
1415       default:
1416         *badPtr = ptr;
1417         return 0;
1418       }
1419       break;
1420     }
1421   }
1422   return 1;
1423 }
1424 
1425 /* This must only be called for a well-formed start-tag or empty
1426    element tag.  Returns the number of attributes.  Pointers to the
1427    first attsMax attributes are stored in atts.
1428 */
1429 
1430 static int PTRCALL
PREFIX(getAtts)1431 PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
1432                 int attsMax, ATTRIBUTE *atts)
1433 {
1434   enum { other, inName, inValue } state = inName;
1435   int nAtts = 0;
1436   int open = 0; /* defined when state == inValue;
1437                    initialization just to shut up compilers */
1438 
1439   for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
1440     switch (BYTE_TYPE(enc, ptr)) {
1441 #define START_NAME \
1442       if (state == other) { \
1443         if (nAtts < attsMax) { \
1444           atts[nAtts].name = ptr; \
1445           atts[nAtts].normalized = 1; \
1446         } \
1447         state = inName; \
1448       }
1449 #define LEAD_CASE(n) \
1450     case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
1451     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1452 #undef LEAD_CASE
1453     case BT_NONASCII:
1454     case BT_NMSTRT:
1455     case BT_HEX:
1456       START_NAME
1457       break;
1458 #undef START_NAME
1459     case BT_QUOT:
1460       if (state != inValue) {
1461         if (nAtts < attsMax)
1462           atts[nAtts].valuePtr = ptr + MINBPC(enc);
1463         state = inValue;
1464         open = BT_QUOT;
1465       }
1466       else if (open == BT_QUOT) {
1467         state = other;
1468         if (nAtts < attsMax)
1469           atts[nAtts].valueEnd = ptr;
1470         nAtts++;
1471       }
1472       break;
1473     case BT_APOS:
1474       if (state != inValue) {
1475         if (nAtts < attsMax)
1476           atts[nAtts].valuePtr = ptr + MINBPC(enc);
1477         state = inValue;
1478         open = BT_APOS;
1479       }
1480       else if (open == BT_APOS) {
1481         state = other;
1482         if (nAtts < attsMax)
1483           atts[nAtts].valueEnd = ptr;
1484         nAtts++;
1485       }
1486       break;
1487     case BT_AMP:
1488       if (nAtts < attsMax)
1489         atts[nAtts].normalized = 0;
1490       break;
1491     case BT_S:
1492       if (state == inName)
1493         state = other;
1494       else if (state == inValue
1495                && nAtts < attsMax
1496                && atts[nAtts].normalized
1497                && (ptr == atts[nAtts].valuePtr
1498                    || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
1499                    || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
1500                    || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
1501         atts[nAtts].normalized = 0;
1502       break;
1503     case BT_CR: case BT_LF:
1504       /* This case ensures that the first attribute name is counted
1505          Apart from that we could just change state on the quote. */
1506       if (state == inName)
1507         state = other;
1508       else if (state == inValue && nAtts < attsMax)
1509         atts[nAtts].normalized = 0;
1510       break;
1511     case BT_GT:
1512     case BT_SOL:
1513       if (state != inValue)
1514         return nAtts;
1515       break;
1516     default:
1517       break;
1518     }
1519   }
1520   /* not reached */
1521 }
1522 
1523 static int PTRFASTCALL
PREFIX(charRefNumber)1524 PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
1525 {
1526   int result = 0;
1527   /* skip &# */
1528   ptr += 2*MINBPC(enc);
1529   if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
1530     for (ptr += MINBPC(enc);
1531          !CHAR_MATCHES(enc, ptr, ASCII_SEMI);
1532          ptr += MINBPC(enc)) {
1533       int c = BYTE_TO_ASCII(enc, ptr);
1534       switch (c) {
1535       case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4:
1536       case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9:
1537         result <<= 4;
1538         result |= (c - ASCII_0);
1539         break;
1540       case ASCII_A: case ASCII_B: case ASCII_C:
1541       case ASCII_D: case ASCII_E: case ASCII_F:
1542         result <<= 4;
1543         result += 10 + (c - ASCII_A);
1544         break;
1545       case ASCII_a: case ASCII_b: case ASCII_c:
1546       case ASCII_d: case ASCII_e: case ASCII_f:
1547         result <<= 4;
1548         result += 10 + (c - ASCII_a);
1549         break;
1550       }
1551       if (result >= 0x110000)
1552         return -1;
1553     }
1554   }
1555   else {
1556     for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
1557       int c = BYTE_TO_ASCII(enc, ptr);
1558       result *= 10;
1559       result += (c - ASCII_0);
1560       if (result >= 0x110000)
1561         return -1;
1562     }
1563   }
1564   return checkCharRefNumber(result);
1565 }
1566 
1567 static int PTRCALL
PREFIX(predefinedEntityName)1568 PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
1569                              const char *end)
1570 {
1571   switch ((end - ptr)/MINBPC(enc)) {
1572   case 2:
1573     if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
1574       switch (BYTE_TO_ASCII(enc, ptr)) {
1575       case ASCII_l:
1576         return ASCII_LT;
1577       case ASCII_g:
1578         return ASCII_GT;
1579       }
1580     }
1581     break;
1582   case 3:
1583     if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
1584       ptr += MINBPC(enc);
1585       if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
1586         ptr += MINBPC(enc);
1587         if (CHAR_MATCHES(enc, ptr, ASCII_p))
1588           return ASCII_AMP;
1589       }
1590     }
1591     break;
1592   case 4:
1593     switch (BYTE_TO_ASCII(enc, ptr)) {
1594     case ASCII_q:
1595       ptr += MINBPC(enc);
1596       if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
1597         ptr += MINBPC(enc);
1598         if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
1599           ptr += MINBPC(enc);
1600           if (CHAR_MATCHES(enc, ptr, ASCII_t))
1601             return ASCII_QUOT;
1602         }
1603       }
1604       break;
1605     case ASCII_a:
1606       ptr += MINBPC(enc);
1607       if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
1608         ptr += MINBPC(enc);
1609         if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
1610           ptr += MINBPC(enc);
1611           if (CHAR_MATCHES(enc, ptr, ASCII_s))
1612             return ASCII_APOS;
1613         }
1614       }
1615       break;
1616     }
1617   }
1618   return 0;
1619 }
1620 
1621 static int PTRCALL
PREFIX(sameName)1622 PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
1623 {
1624   for (;;) {
1625     switch (BYTE_TYPE(enc, ptr1)) {
1626 #define LEAD_CASE(n) \
1627     case BT_LEAD ## n: \
1628       if (*ptr1++ != *ptr2++) \
1629         return 0;
1630     LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2)
1631 #undef LEAD_CASE
1632       /* fall through */
1633       if (*ptr1++ != *ptr2++)
1634         return 0;
1635       break;
1636     case BT_NONASCII:
1637     case BT_NMSTRT:
1638 #ifdef XML_NS
1639     case BT_COLON:
1640 #endif
1641     case BT_HEX:
1642     case BT_DIGIT:
1643     case BT_NAME:
1644     case BT_MINUS:
1645       if (*ptr2++ != *ptr1++)
1646         return 0;
1647       if (MINBPC(enc) > 1) {
1648         if (*ptr2++ != *ptr1++)
1649           return 0;
1650         if (MINBPC(enc) > 2) {
1651           if (*ptr2++ != *ptr1++)
1652             return 0;
1653           if (MINBPC(enc) > 3) {
1654             if (*ptr2++ != *ptr1++)
1655               return 0;
1656           }
1657         }
1658       }
1659       break;
1660     default:
1661       if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
1662         return 1;
1663       switch (BYTE_TYPE(enc, ptr2)) {
1664       case BT_LEAD2:
1665       case BT_LEAD3:
1666       case BT_LEAD4:
1667       case BT_NONASCII:
1668       case BT_NMSTRT:
1669 #ifdef XML_NS
1670       case BT_COLON:
1671 #endif
1672       case BT_HEX:
1673       case BT_DIGIT:
1674       case BT_NAME:
1675       case BT_MINUS:
1676         return 0;
1677       default:
1678         return 1;
1679       }
1680     }
1681   }
1682   /* not reached */
1683 }
1684 
1685 static int PTRCALL
PREFIX(nameMatchesAscii)1686 PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
1687                          const char *end1, const char *ptr2)
1688 {
1689   for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
1690     if (ptr1 == end1)
1691       return 0;
1692     if (!CHAR_MATCHES(enc, ptr1, *ptr2))
1693       return 0;
1694   }
1695   return ptr1 == end1;
1696 }
1697 
1698 static int PTRFASTCALL
PREFIX(nameLength)1699 PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
1700 {
1701   const char *start = ptr;
1702   for (;;) {
1703     switch (BYTE_TYPE(enc, ptr)) {
1704 #define LEAD_CASE(n) \
1705     case BT_LEAD ## n: ptr += n; break;
1706     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1707 #undef LEAD_CASE
1708     case BT_NONASCII:
1709     case BT_NMSTRT:
1710 #ifdef XML_NS
1711     case BT_COLON:
1712 #endif
1713     case BT_HEX:
1714     case BT_DIGIT:
1715     case BT_NAME:
1716     case BT_MINUS:
1717       ptr += MINBPC(enc);
1718       break;
1719     default:
1720       return (int)(ptr - start);
1721     }
1722   }
1723 }
1724 
1725 static const char * PTRFASTCALL
PREFIX(skipS)1726 PREFIX(skipS)(const ENCODING *enc, const char *ptr)
1727 {
1728   for (;;) {
1729     switch (BYTE_TYPE(enc, ptr)) {
1730     case BT_LF:
1731     case BT_CR:
1732     case BT_S:
1733       ptr += MINBPC(enc);
1734       break;
1735     default:
1736       return ptr;
1737     }
1738   }
1739 }
1740 
1741 static void PTRCALL
PREFIX(updatePosition)1742 PREFIX(updatePosition)(const ENCODING *enc,
1743                        const char *ptr,
1744                        const char *end,
1745                        POSITION *pos)
1746 {
1747   while (ptr < end) {
1748     switch (BYTE_TYPE(enc, ptr)) {
1749 #define LEAD_CASE(n) \
1750     case BT_LEAD ## n: \
1751       ptr += n; \
1752       break;
1753     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1754 #undef LEAD_CASE
1755     case BT_LF:
1756       pos->columnNumber = (XML_Size)-1;
1757       pos->lineNumber++;
1758       ptr += MINBPC(enc);
1759       break;
1760     case BT_CR:
1761       pos->lineNumber++;
1762       ptr += MINBPC(enc);
1763       if (ptr < end && BYTE_TYPE(enc, ptr) == BT_LF)
1764         ptr += MINBPC(enc);
1765       pos->columnNumber = (XML_Size)-1;
1766       break;
1767     default:
1768       ptr += MINBPC(enc);
1769       break;
1770     }
1771     pos->columnNumber++;
1772   }
1773 }
1774 
1775 #undef DO_LEAD_CASE
1776 #undef MULTIBYTE_CASES
1777 #undef INVALID_CASES
1778 #undef CHECK_NAME_CASE
1779 #undef CHECK_NAME_CASES
1780 #undef CHECK_NMSTRT_CASE
1781 #undef CHECK_NMSTRT_CASES
1782 
1783 #endif /* XML_TOK_IMPL_C */
1784