1 /*
2 Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
3 See the file COPYING for copying permission.
4 */
5 
6 static char RCSId[]
7   = "Header";
vtk_expat_GetXMLRole_RCSId()8 const char* vtk_expat_GetXMLRole_RCSId()
9 {
10   /* Avoid warning about unused static without removing RCSId from original. */
11   return RCSId;
12 }
13 
14 #include <vtkexpat/expatConfig.h>
15 
16 #include "xmlrole.h"
17 #include "ascii.h"
18 
19 /* Doesn't check:
20 
21  that ,| are not mixed in a model group
22  content of literals
23 
24 */
25 
26 static const char KW_ANY[] = { ASCII_A, ASCII_N, ASCII_Y, '\0' };
27 static const char KW_ATTLIST[] = { ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' };
28 static const char KW_CDATA[] = { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
29 static const char KW_DOCTYPE[] = { ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' };
30 static const char KW_ELEMENT[] = { ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' };
31 static const char KW_EMPTY[] = { ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' };
32 static const char KW_ENTITIES[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' };
33 static const char KW_ENTITY[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
34 static const char KW_FIXED[] = { ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' };
35 static const char KW_ID[] = { ASCII_I, ASCII_D, '\0' };
36 static const char KW_IDREF[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
37 static const char KW_IDREFS[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
38 static const char KW_IGNORE[] = { ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' };
39 static const char KW_IMPLIED[] = { ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' };
40 static const char KW_INCLUDE[] = { ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' };
41 static const char KW_NDATA[] = { ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
42 static const char KW_NMTOKEN[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
43 static const char KW_NMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' };
44 static const char KW_NOTATION[] = { ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, '\0' };
45 static const char KW_PCDATA[] = { ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
46 static const char KW_PUBLIC[] = { ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' };
47 static const char KW_REQUIRED[] = { ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D, '\0' };
48 static const char KW_SYSTEM[] = { ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' };
49 
50 #ifndef MIN_BYTES_PER_CHAR
51 #define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
52 #endif
53 
54 #ifdef XML_DTD
55 #define setTopLevel(state) \
56   ((state)->handler = ((state)->documentEntity \
57                        ? internalSubset \
58                        : externalSubset1))
59 #else /* not XML_DTD */
60 #define setTopLevel(state) ((state)->handler = internalSubset)
61 #endif /* not XML_DTD */
62 
63 typedef int PROLOG_HANDLER(PROLOG_STATE *state,
64                            int tok,
65                            const char *ptr,
66                            const char *end,
67                            const ENCODING *enc);
68 
69 static PROLOG_HANDLER
70   prolog0, prolog1, prolog2,
71   doctype0, doctype1, doctype2, doctype3, doctype4, doctype5,
72   internalSubset,
73   entity0, entity1, entity2, entity3, entity4, entity5, entity6,
74   entity7, entity8, entity9,
75   notation0, notation1, notation2, notation3, notation4,
76   attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6,
77   attlist7, attlist8, attlist9,
78   element0, element1, element2, element3, element4, element5, element6,
79   element7,
80 #ifdef XML_DTD
81   externalSubset0, externalSubset1,
82   condSect0, condSect1, condSect2,
83 #endif /* XML_DTD */
84   declClose,
85   error;
86 
87 static
88 int common(PROLOG_STATE *state, int tok);
89 
90 static
prolog0(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)91 int prolog0(PROLOG_STATE *state,
92             int tok,
93             const char *ptr,
94             const char *end,
95             const ENCODING *enc)
96 {
97   switch (tok) {
98   case XML_TOK_PROLOG_S:
99     state->handler = prolog1;
100     return XML_ROLE_NONE;
101   case XML_TOK_XML_DECL:
102     state->handler = prolog1;
103     return XML_ROLE_XML_DECL;
104   case XML_TOK_PI:
105     state->handler = prolog1;
106     return XML_ROLE_NONE;
107   case XML_TOK_COMMENT:
108     state->handler = prolog1;
109   case XML_TOK_BOM:
110     return XML_ROLE_NONE;
111   case XML_TOK_DECL_OPEN:
112     if (!XmlNameMatchesAscii(enc,
113                              ptr + 2 * MIN_BYTES_PER_CHAR(enc),
114                              end,
115                              KW_DOCTYPE))
116       break;
117     state->handler = doctype0;
118     return XML_ROLE_NONE;
119   case XML_TOK_INSTANCE_START:
120     state->handler = error;
121     return XML_ROLE_INSTANCE_START;
122   }
123   return common(state, tok);
124 }
125 
126 static
prolog1(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)127 int prolog1(PROLOG_STATE *state,
128             int tok,
129             const char *ptr,
130             const char *end,
131             const ENCODING *enc)
132 {
133   switch (tok) {
134   case XML_TOK_PROLOG_S:
135     return XML_ROLE_NONE;
136   case XML_TOK_PI:
137   case XML_TOK_COMMENT:
138   case XML_TOK_BOM:
139     return XML_ROLE_NONE;
140   case XML_TOK_DECL_OPEN:
141     if (!XmlNameMatchesAscii(enc,
142                              ptr + 2 * MIN_BYTES_PER_CHAR(enc),
143                              end,
144                              KW_DOCTYPE))
145       break;
146     state->handler = doctype0;
147     return XML_ROLE_NONE;
148   case XML_TOK_INSTANCE_START:
149     state->handler = error;
150     return XML_ROLE_INSTANCE_START;
151   }
152   return common(state, tok);
153 }
154 
155 static
prolog2(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)156 int prolog2(PROLOG_STATE *state,
157             int tok,
158             const char *ptr,
159             const char *end,
160             const ENCODING *enc)
161 {
162   vtkExpatUnused(ptr);
163   vtkExpatUnused(end);
164   vtkExpatUnused(enc);
165   switch (tok) {
166   case XML_TOK_PROLOG_S:
167     return XML_ROLE_NONE;
168   case XML_TOK_PI:
169   case XML_TOK_COMMENT:
170     return XML_ROLE_NONE;
171   case XML_TOK_INSTANCE_START:
172     state->handler = error;
173     return XML_ROLE_INSTANCE_START;
174   }
175   return common(state, tok);
176 }
177 
178 static
doctype0(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)179 int doctype0(PROLOG_STATE *state,
180              int tok,
181              const char *ptr,
182              const char *end,
183              const ENCODING *enc)
184 {
185   vtkExpatUnused(ptr);
186   vtkExpatUnused(end);
187   vtkExpatUnused(enc);
188   switch (tok) {
189   case XML_TOK_PROLOG_S:
190     return XML_ROLE_NONE;
191   case XML_TOK_NAME:
192   case XML_TOK_PREFIXED_NAME:
193     state->handler = doctype1;
194     return XML_ROLE_DOCTYPE_NAME;
195   }
196   return common(state, tok);
197 }
198 
199 static
doctype1(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)200 int doctype1(PROLOG_STATE *state,
201              int tok,
202              const char *ptr,
203              const char *end,
204              const ENCODING *enc)
205 {
206   switch (tok) {
207   case XML_TOK_PROLOG_S:
208     return XML_ROLE_NONE;
209   case XML_TOK_OPEN_BRACKET:
210     state->handler = internalSubset;
211     return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
212   case XML_TOK_DECL_CLOSE:
213     state->handler = prolog2;
214     return XML_ROLE_DOCTYPE_CLOSE;
215   case XML_TOK_NAME:
216     if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
217       state->handler = doctype3;
218       return XML_ROLE_NONE;
219     }
220     if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
221       state->handler = doctype2;
222       return XML_ROLE_NONE;
223     }
224     break;
225   }
226   return common(state, tok);
227 }
228 
229 static
doctype2(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)230 int doctype2(PROLOG_STATE *state,
231              int tok,
232              const char *ptr,
233              const char *end,
234              const ENCODING *enc)
235 {
236   vtkExpatUnused(ptr);
237   vtkExpatUnused(end);
238   vtkExpatUnused(enc);
239   switch (tok) {
240   case XML_TOK_PROLOG_S:
241     return XML_ROLE_NONE;
242   case XML_TOK_LITERAL:
243     state->handler = doctype3;
244     return XML_ROLE_DOCTYPE_PUBLIC_ID;
245   }
246   return common(state, tok);
247 }
248 
249 static
doctype3(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)250 int doctype3(PROLOG_STATE *state,
251              int tok,
252              const char *ptr,
253              const char *end,
254              const ENCODING *enc)
255 {
256   vtkExpatUnused(ptr);
257   vtkExpatUnused(end);
258   vtkExpatUnused(enc);
259   switch (tok) {
260   case XML_TOK_PROLOG_S:
261     return XML_ROLE_NONE;
262   case XML_TOK_LITERAL:
263     state->handler = doctype4;
264     return XML_ROLE_DOCTYPE_SYSTEM_ID;
265   }
266   return common(state, tok);
267 }
268 
269 static
doctype4(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)270 int doctype4(PROLOG_STATE *state,
271              int tok,
272              const char *ptr,
273              const char *end,
274              const ENCODING *enc)
275 {
276   vtkExpatUnused(ptr);
277   vtkExpatUnused(end);
278   vtkExpatUnused(enc);
279   switch (tok) {
280   case XML_TOK_PROLOG_S:
281     return XML_ROLE_NONE;
282   case XML_TOK_OPEN_BRACKET:
283     state->handler = internalSubset;
284     return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
285   case XML_TOK_DECL_CLOSE:
286     state->handler = prolog2;
287     return XML_ROLE_DOCTYPE_CLOSE;
288   }
289   return common(state, tok);
290 }
291 
292 static
doctype5(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)293 int doctype5(PROLOG_STATE *state,
294              int tok,
295              const char *ptr,
296              const char *end,
297              const ENCODING *enc)
298 {
299   vtkExpatUnused(ptr);
300   vtkExpatUnused(end);
301   vtkExpatUnused(enc);
302   switch (tok) {
303   case XML_TOK_PROLOG_S:
304     return XML_ROLE_NONE;
305   case XML_TOK_DECL_CLOSE:
306     state->handler = prolog2;
307     return XML_ROLE_DOCTYPE_CLOSE;
308   }
309   return common(state, tok);
310 }
311 
312 static
internalSubset(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)313 int internalSubset(PROLOG_STATE *state,
314                    int tok,
315                    const char *ptr,
316                    const char *end,
317                    const ENCODING *enc)
318 {
319   switch (tok) {
320   case XML_TOK_PROLOG_S:
321     return XML_ROLE_NONE;
322   case XML_TOK_DECL_OPEN:
323     if (XmlNameMatchesAscii(enc,
324                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
325                             end,
326                             KW_ENTITY)) {
327       state->handler = entity0;
328       return XML_ROLE_NONE;
329     }
330     if (XmlNameMatchesAscii(enc,
331                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
332                             end,
333                             KW_ATTLIST)) {
334       state->handler = attlist0;
335       return XML_ROLE_NONE;
336     }
337     if (XmlNameMatchesAscii(enc,
338                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
339                             end,
340                             KW_ELEMENT)) {
341       state->handler = element0;
342       return XML_ROLE_NONE;
343     }
344     if (XmlNameMatchesAscii(enc,
345                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
346                             end,
347                             KW_NOTATION)) {
348       state->handler = notation0;
349       return XML_ROLE_NONE;
350     }
351     break;
352   case XML_TOK_PI:
353   case XML_TOK_COMMENT:
354     return XML_ROLE_NONE;
355   case XML_TOK_PARAM_ENTITY_REF:
356     return XML_ROLE_PARAM_ENTITY_REF;
357   case XML_TOK_CLOSE_BRACKET:
358     state->handler = doctype5;
359     return XML_ROLE_NONE;
360   }
361   return common(state, tok);
362 }
363 
364 #ifdef XML_DTD
365 
366 static
externalSubset0(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)367 int externalSubset0(PROLOG_STATE *state,
368                     int tok,
369                     const char *ptr,
370                     const char *end,
371                     const ENCODING *enc)
372 {
373   state->handler = externalSubset1;
374   if (tok == XML_TOK_XML_DECL)
375     return XML_ROLE_TEXT_DECL;
376   return externalSubset1(state, tok, ptr, end, enc);
377 }
378 
379 static
externalSubset1(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)380 int externalSubset1(PROLOG_STATE *state,
381                     int tok,
382                     const char *ptr,
383                     const char *end,
384                     const ENCODING *enc)
385 {
386   switch (tok) {
387   case XML_TOK_COND_SECT_OPEN:
388     state->handler = condSect0;
389     return XML_ROLE_NONE;
390   case XML_TOK_COND_SECT_CLOSE:
391     if (state->includeLevel == 0)
392       break;
393     state->includeLevel -= 1;
394     return XML_ROLE_NONE;
395   case XML_TOK_PROLOG_S:
396     return XML_ROLE_NONE;
397   case XML_TOK_CLOSE_BRACKET:
398     break;
399   case XML_TOK_NONE:
400     if (state->includeLevel)
401       break;
402     return XML_ROLE_NONE;
403   default:
404     return internalSubset(state, tok, ptr, end, enc);
405   }
406   return common(state, tok);
407 }
408 
409 #endif /* XML_DTD */
410 
411 static
entity0(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)412 int entity0(PROLOG_STATE *state,
413             int tok,
414             const char *ptr,
415             const char *end,
416             const ENCODING *enc)
417 {
418   vtkExpatUnused(ptr);
419   vtkExpatUnused(end);
420   vtkExpatUnused(enc);
421   switch (tok) {
422   case XML_TOK_PROLOG_S:
423     return XML_ROLE_NONE;
424   case XML_TOK_PERCENT:
425     state->handler = entity1;
426     return XML_ROLE_NONE;
427   case XML_TOK_NAME:
428     state->handler = entity2;
429     return XML_ROLE_GENERAL_ENTITY_NAME;
430   }
431   return common(state, tok);
432 }
433 
434 static
entity1(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)435 int entity1(PROLOG_STATE *state,
436             int tok,
437             const char *ptr,
438             const char *end,
439             const ENCODING *enc)
440 {
441   vtkExpatUnused(ptr);
442   vtkExpatUnused(end);
443   vtkExpatUnused(enc);
444   switch (tok) {
445   case XML_TOK_PROLOG_S:
446     return XML_ROLE_NONE;
447   case XML_TOK_NAME:
448     state->handler = entity7;
449     return XML_ROLE_PARAM_ENTITY_NAME;
450   }
451   return common(state, tok);
452 }
453 
454 static
entity2(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)455 int entity2(PROLOG_STATE *state,
456             int tok,
457             const char *ptr,
458             const char *end,
459             const ENCODING *enc)
460 {
461   switch (tok) {
462   case XML_TOK_PROLOG_S:
463     return XML_ROLE_NONE;
464   case XML_TOK_NAME:
465     if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
466       state->handler = entity4;
467       return XML_ROLE_NONE;
468     }
469     if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
470       state->handler = entity3;
471       return XML_ROLE_NONE;
472     }
473     break;
474   case XML_TOK_LITERAL:
475     state->handler = declClose;
476     return XML_ROLE_ENTITY_VALUE;
477   }
478   return common(state, tok);
479 }
480 
481 static
entity3(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)482 int entity3(PROLOG_STATE *state,
483             int tok,
484             const char *ptr,
485             const char *end,
486             const ENCODING *enc)
487 {
488   vtkExpatUnused(ptr);
489   vtkExpatUnused(end);
490   vtkExpatUnused(enc);
491   switch (tok) {
492   case XML_TOK_PROLOG_S:
493     return XML_ROLE_NONE;
494   case XML_TOK_LITERAL:
495     state->handler = entity4;
496     return XML_ROLE_ENTITY_PUBLIC_ID;
497   }
498   return common(state, tok);
499 }
500 
501 
502 static
entity4(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)503 int entity4(PROLOG_STATE *state,
504             int tok,
505             const char *ptr,
506             const char *end,
507             const ENCODING *enc)
508 {
509   vtkExpatUnused(ptr);
510   vtkExpatUnused(end);
511   vtkExpatUnused(enc);
512   switch (tok) {
513   case XML_TOK_PROLOG_S:
514     return XML_ROLE_NONE;
515   case XML_TOK_LITERAL:
516     state->handler = entity5;
517     return XML_ROLE_ENTITY_SYSTEM_ID;
518   }
519   return common(state, tok);
520 }
521 
522 static
entity5(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)523 int entity5(PROLOG_STATE *state,
524             int tok,
525             const char *ptr,
526             const char *end,
527             const ENCODING *enc)
528 {
529   switch (tok) {
530   case XML_TOK_PROLOG_S:
531     return XML_ROLE_NONE;
532   case XML_TOK_DECL_CLOSE:
533     setTopLevel(state);
534     return XML_ROLE_ENTITY_COMPLETE;
535   case XML_TOK_NAME:
536     if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
537       state->handler = entity6;
538       return XML_ROLE_NONE;
539     }
540     break;
541   }
542   return common(state, tok);
543 }
544 
545 static
entity6(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)546 int entity6(PROLOG_STATE *state,
547             int tok,
548             const char *ptr,
549             const char *end,
550             const ENCODING *enc)
551 {
552   vtkExpatUnused(ptr);
553   vtkExpatUnused(end);
554   vtkExpatUnused(enc);
555   switch (tok) {
556   case XML_TOK_PROLOG_S:
557     return XML_ROLE_NONE;
558   case XML_TOK_NAME:
559     state->handler = declClose;
560     return XML_ROLE_ENTITY_NOTATION_NAME;
561   }
562   return common(state, tok);
563 }
564 
565 static
entity7(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)566 int entity7(PROLOG_STATE *state,
567             int tok,
568             const char *ptr,
569             const char *end,
570             const ENCODING *enc)
571 {
572   switch (tok) {
573   case XML_TOK_PROLOG_S:
574     return XML_ROLE_NONE;
575   case XML_TOK_NAME:
576     if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
577       state->handler = entity9;
578       return XML_ROLE_NONE;
579     }
580     if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
581       state->handler = entity8;
582       return XML_ROLE_NONE;
583     }
584     break;
585   case XML_TOK_LITERAL:
586     state->handler = declClose;
587     return XML_ROLE_ENTITY_VALUE;
588   }
589   return common(state, tok);
590 }
591 
592 static
entity8(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)593 int entity8(PROLOG_STATE *state,
594             int tok,
595             const char *ptr,
596             const char *end,
597             const ENCODING *enc)
598 {
599   vtkExpatUnused(ptr);
600   vtkExpatUnused(end);
601   vtkExpatUnused(enc);
602   switch (tok) {
603   case XML_TOK_PROLOG_S:
604     return XML_ROLE_NONE;
605   case XML_TOK_LITERAL:
606     state->handler = entity9;
607     return XML_ROLE_ENTITY_PUBLIC_ID;
608   }
609   return common(state, tok);
610 }
611 
612 static
entity9(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)613 int entity9(PROLOG_STATE *state,
614             int tok,
615             const char *ptr,
616             const char *end,
617             const ENCODING *enc)
618 {
619   vtkExpatUnused(ptr);
620   vtkExpatUnused(end);
621   vtkExpatUnused(enc);
622   switch (tok) {
623   case XML_TOK_PROLOG_S:
624     return XML_ROLE_NONE;
625   case XML_TOK_LITERAL:
626     state->handler = declClose;
627     return XML_ROLE_ENTITY_SYSTEM_ID;
628   }
629   return common(state, tok);
630 }
631 
632 static
notation0(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)633 int notation0(PROLOG_STATE *state,
634               int tok,
635               const char *ptr,
636               const char *end,
637               const ENCODING *enc)
638 {
639   vtkExpatUnused(ptr);
640   vtkExpatUnused(end);
641   vtkExpatUnused(enc);
642   switch (tok) {
643   case XML_TOK_PROLOG_S:
644     return XML_ROLE_NONE;
645   case XML_TOK_NAME:
646     state->handler = notation1;
647     return XML_ROLE_NOTATION_NAME;
648   }
649   return common(state, tok);
650 }
651 
652 static
notation1(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)653 int notation1(PROLOG_STATE *state,
654               int tok,
655               const char *ptr,
656               const char *end,
657               const ENCODING *enc)
658 {
659   switch (tok) {
660   case XML_TOK_PROLOG_S:
661     return XML_ROLE_NONE;
662   case XML_TOK_NAME:
663     if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
664       state->handler = notation3;
665       return XML_ROLE_NONE;
666     }
667     if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
668       state->handler = notation2;
669       return XML_ROLE_NONE;
670     }
671     break;
672   }
673   return common(state, tok);
674 }
675 
676 static
notation2(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)677 int notation2(PROLOG_STATE *state,
678               int tok,
679               const char *ptr,
680               const char *end,
681               const ENCODING *enc)
682 {
683   vtkExpatUnused(ptr);
684   vtkExpatUnused(end);
685   vtkExpatUnused(enc);
686   switch (tok) {
687   case XML_TOK_PROLOG_S:
688     return XML_ROLE_NONE;
689   case XML_TOK_LITERAL:
690     state->handler = notation4;
691     return XML_ROLE_NOTATION_PUBLIC_ID;
692   }
693   return common(state, tok);
694 }
695 
696 static
notation3(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)697 int notation3(PROLOG_STATE *state,
698               int tok,
699               const char *ptr,
700               const char *end,
701               const ENCODING *enc)
702 {
703   vtkExpatUnused(ptr);
704   vtkExpatUnused(end);
705   vtkExpatUnused(enc);
706   switch (tok) {
707   case XML_TOK_PROLOG_S:
708     return XML_ROLE_NONE;
709   case XML_TOK_LITERAL:
710     state->handler = declClose;
711     return XML_ROLE_NOTATION_SYSTEM_ID;
712   }
713   return common(state, tok);
714 }
715 
716 static
notation4(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)717 int notation4(PROLOG_STATE *state,
718               int tok,
719               const char *ptr,
720               const char *end,
721               const ENCODING *enc)
722 {
723   vtkExpatUnused(ptr);
724   vtkExpatUnused(end);
725   vtkExpatUnused(enc);
726   switch (tok) {
727   case XML_TOK_PROLOG_S:
728     return XML_ROLE_NONE;
729   case XML_TOK_LITERAL:
730     state->handler = declClose;
731     return XML_ROLE_NOTATION_SYSTEM_ID;
732   case XML_TOK_DECL_CLOSE:
733     setTopLevel(state);
734     return XML_ROLE_NOTATION_NO_SYSTEM_ID;
735   }
736   return common(state, tok);
737 }
738 
739 static
attlist0(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)740 int attlist0(PROLOG_STATE *state,
741              int tok,
742              const char *ptr,
743              const char *end,
744              const ENCODING *enc)
745 {
746   vtkExpatUnused(ptr);
747   vtkExpatUnused(end);
748   vtkExpatUnused(enc);
749   switch (tok) {
750   case XML_TOK_PROLOG_S:
751     return XML_ROLE_NONE;
752   case XML_TOK_NAME:
753   case XML_TOK_PREFIXED_NAME:
754     state->handler = attlist1;
755     return XML_ROLE_ATTLIST_ELEMENT_NAME;
756   }
757   return common(state, tok);
758 }
759 
760 static
attlist1(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)761 int attlist1(PROLOG_STATE *state,
762              int tok,
763              const char *ptr,
764              const char *end,
765              const ENCODING *enc)
766 {
767   vtkExpatUnused(ptr);
768   vtkExpatUnused(end);
769   vtkExpatUnused(enc);
770   switch (tok) {
771   case XML_TOK_PROLOG_S:
772     return XML_ROLE_NONE;
773   case XML_TOK_DECL_CLOSE:
774     setTopLevel(state);
775     return XML_ROLE_NONE;
776   case XML_TOK_NAME:
777   case XML_TOK_PREFIXED_NAME:
778     state->handler = attlist2;
779     return XML_ROLE_ATTRIBUTE_NAME;
780   }
781   return common(state, tok);
782 }
783 
784 static
attlist2(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)785 int attlist2(PROLOG_STATE *state,
786              int tok,
787              const char *ptr,
788              const char *end,
789              const ENCODING *enc)
790 {
791   vtkExpatUnused(ptr);
792   vtkExpatUnused(end);
793   vtkExpatUnused(enc);
794   switch (tok) {
795   case XML_TOK_PROLOG_S:
796     return XML_ROLE_NONE;
797   case XML_TOK_NAME:
798     {
799       static const char *types[] = {
800         KW_CDATA,
801         KW_ID,
802         KW_IDREF,
803         KW_IDREFS,
804         KW_ENTITY,
805         KW_ENTITIES,
806         KW_NMTOKEN,
807         KW_NMTOKENS,
808       };
809       int i;
810       for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
811         if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
812           state->handler = attlist8;
813           return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
814         }
815     }
816     if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
817       state->handler = attlist5;
818       return XML_ROLE_NONE;
819     }
820     break;
821   case XML_TOK_OPEN_PAREN:
822     state->handler = attlist3;
823     return XML_ROLE_NONE;
824   }
825   return common(state, tok);
826 }
827 
828 static
attlist3(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)829 int attlist3(PROLOG_STATE *state,
830              int tok,
831              const char *ptr,
832              const char *end,
833              const ENCODING *enc)
834 {
835   vtkExpatUnused(ptr);
836   vtkExpatUnused(end);
837   vtkExpatUnused(enc);
838   switch (tok) {
839   case XML_TOK_PROLOG_S:
840     return XML_ROLE_NONE;
841   case XML_TOK_NMTOKEN:
842   case XML_TOK_NAME:
843   case XML_TOK_PREFIXED_NAME:
844     state->handler = attlist4;
845     return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
846   }
847   return common(state, tok);
848 }
849 
850 static
attlist4(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)851 int attlist4(PROLOG_STATE *state,
852              int tok,
853              const char *ptr,
854              const char *end,
855              const ENCODING *enc)
856 {
857   vtkExpatUnused(ptr);
858   vtkExpatUnused(end);
859   vtkExpatUnused(enc);
860   switch (tok) {
861   case XML_TOK_PROLOG_S:
862     return XML_ROLE_NONE;
863   case XML_TOK_CLOSE_PAREN:
864     state->handler = attlist8;
865     return XML_ROLE_NONE;
866   case XML_TOK_OR:
867     state->handler = attlist3;
868     return XML_ROLE_NONE;
869   }
870   return common(state, tok);
871 }
872 
873 static
attlist5(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)874 int attlist5(PROLOG_STATE *state,
875              int tok,
876              const char *ptr,
877              const char *end,
878              const ENCODING *enc)
879 {
880   vtkExpatUnused(ptr);
881   vtkExpatUnused(end);
882   vtkExpatUnused(enc);
883   switch (tok) {
884   case XML_TOK_PROLOG_S:
885     return XML_ROLE_NONE;
886   case XML_TOK_OPEN_PAREN:
887     state->handler = attlist6;
888     return XML_ROLE_NONE;
889   }
890   return common(state, tok);
891 }
892 
893 
894 static
attlist6(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)895 int attlist6(PROLOG_STATE *state,
896              int tok,
897              const char *ptr,
898              const char *end,
899              const ENCODING *enc)
900 {
901   vtkExpatUnused(ptr);
902   vtkExpatUnused(end);
903   vtkExpatUnused(enc);
904   switch (tok) {
905   case XML_TOK_PROLOG_S:
906     return XML_ROLE_NONE;
907   case XML_TOK_NAME:
908     state->handler = attlist7;
909     return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
910   }
911   return common(state, tok);
912 }
913 
914 static
attlist7(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)915 int attlist7(PROLOG_STATE *state,
916              int tok,
917              const char *ptr,
918              const char *end,
919              const ENCODING *enc)
920 {
921   vtkExpatUnused(ptr);
922   vtkExpatUnused(end);
923   vtkExpatUnused(enc);
924   switch (tok) {
925   case XML_TOK_PROLOG_S:
926     return XML_ROLE_NONE;
927   case XML_TOK_CLOSE_PAREN:
928     state->handler = attlist8;
929     return XML_ROLE_NONE;
930   case XML_TOK_OR:
931     state->handler = attlist6;
932     return XML_ROLE_NONE;
933   }
934   return common(state, tok);
935 }
936 
937 /* default value */
938 static
attlist8(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)939 int attlist8(PROLOG_STATE *state,
940              int tok,
941              const char *ptr,
942              const char *end,
943              const ENCODING *enc)
944 {
945   vtkExpatUnused(ptr);
946   vtkExpatUnused(end);
947   vtkExpatUnused(enc);
948   switch (tok) {
949   case XML_TOK_PROLOG_S:
950     return XML_ROLE_NONE;
951   case XML_TOK_POUND_NAME:
952     if (XmlNameMatchesAscii(enc,
953                             ptr + MIN_BYTES_PER_CHAR(enc),
954                             end,
955                             KW_IMPLIED)) {
956       state->handler = attlist1;
957       return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
958     }
959     if (XmlNameMatchesAscii(enc,
960                             ptr + MIN_BYTES_PER_CHAR(enc),
961                             end,
962                             KW_REQUIRED)) {
963       state->handler = attlist1;
964       return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
965     }
966     if (XmlNameMatchesAscii(enc,
967                             ptr + MIN_BYTES_PER_CHAR(enc),
968                             end,
969                             KW_FIXED)) {
970       state->handler = attlist9;
971       return XML_ROLE_NONE;
972     }
973     break;
974   case XML_TOK_LITERAL:
975     state->handler = attlist1;
976     return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
977   }
978   return common(state, tok);
979 }
980 
981 static
attlist9(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)982 int attlist9(PROLOG_STATE *state,
983              int tok,
984              const char *ptr,
985              const char *end,
986              const ENCODING *enc)
987 {
988   vtkExpatUnused(ptr);
989   vtkExpatUnused(end);
990   vtkExpatUnused(enc);
991   switch (tok) {
992   case XML_TOK_PROLOG_S:
993     return XML_ROLE_NONE;
994   case XML_TOK_LITERAL:
995     state->handler = attlist1;
996     return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
997   }
998   return common(state, tok);
999 }
1000 
1001 static
element0(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1002 int element0(PROLOG_STATE *state,
1003              int tok,
1004              const char *ptr,
1005              const char *end,
1006              const ENCODING *enc)
1007 {
1008   vtkExpatUnused(ptr);
1009   vtkExpatUnused(end);
1010   vtkExpatUnused(enc);
1011   switch (tok) {
1012   case XML_TOK_PROLOG_S:
1013     return XML_ROLE_NONE;
1014   case XML_TOK_NAME:
1015   case XML_TOK_PREFIXED_NAME:
1016     state->handler = element1;
1017     return XML_ROLE_ELEMENT_NAME;
1018   }
1019   return common(state, tok);
1020 }
1021 
1022 static
element1(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1023 int element1(PROLOG_STATE *state,
1024              int tok,
1025              const char *ptr,
1026              const char *end,
1027              const ENCODING *enc)
1028 {
1029   vtkExpatUnused(ptr);
1030   vtkExpatUnused(end);
1031   vtkExpatUnused(enc);
1032   switch (tok) {
1033   case XML_TOK_PROLOG_S:
1034     return XML_ROLE_NONE;
1035   case XML_TOK_NAME:
1036     if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
1037       state->handler = declClose;
1038       return XML_ROLE_CONTENT_EMPTY;
1039     }
1040     if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
1041       state->handler = declClose;
1042       return XML_ROLE_CONTENT_ANY;
1043     }
1044     break;
1045   case XML_TOK_OPEN_PAREN:
1046     state->handler = element2;
1047     state->level = 1;
1048     return XML_ROLE_GROUP_OPEN;
1049   }
1050   return common(state, tok);
1051 }
1052 
1053 static
element2(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1054 int element2(PROLOG_STATE *state,
1055              int tok,
1056              const char *ptr,
1057              const char *end,
1058              const ENCODING *enc)
1059 {
1060   vtkExpatUnused(ptr);
1061   vtkExpatUnused(end);
1062   vtkExpatUnused(enc);
1063   switch (tok) {
1064   case XML_TOK_PROLOG_S:
1065     return XML_ROLE_NONE;
1066   case XML_TOK_POUND_NAME:
1067     if (XmlNameMatchesAscii(enc,
1068                             ptr + MIN_BYTES_PER_CHAR(enc),
1069                             end,
1070                             KW_PCDATA)) {
1071       state->handler = element3;
1072       return XML_ROLE_CONTENT_PCDATA;
1073     }
1074     break;
1075   case XML_TOK_OPEN_PAREN:
1076     state->level = 2;
1077     state->handler = element6;
1078     return XML_ROLE_GROUP_OPEN;
1079   case XML_TOK_NAME:
1080   case XML_TOK_PREFIXED_NAME:
1081     state->handler = element7;
1082     return XML_ROLE_CONTENT_ELEMENT;
1083   case XML_TOK_NAME_QUESTION:
1084     state->handler = element7;
1085     return XML_ROLE_CONTENT_ELEMENT_OPT;
1086   case XML_TOK_NAME_ASTERISK:
1087     state->handler = element7;
1088     return XML_ROLE_CONTENT_ELEMENT_REP;
1089   case XML_TOK_NAME_PLUS:
1090     state->handler = element7;
1091     return XML_ROLE_CONTENT_ELEMENT_PLUS;
1092   }
1093   return common(state, tok);
1094 }
1095 
1096 static
element3(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1097 int element3(PROLOG_STATE *state,
1098              int tok,
1099              const char *ptr,
1100              const char *end,
1101              const ENCODING *enc)
1102 {
1103   vtkExpatUnused(ptr);
1104   vtkExpatUnused(end);
1105   vtkExpatUnused(enc);
1106   switch (tok) {
1107   case XML_TOK_PROLOG_S:
1108     return XML_ROLE_NONE;
1109   case XML_TOK_CLOSE_PAREN:
1110     state->handler = declClose;
1111     return XML_ROLE_GROUP_CLOSE;
1112   case XML_TOK_CLOSE_PAREN_ASTERISK:
1113     state->handler = declClose;
1114     return XML_ROLE_GROUP_CLOSE_REP;
1115   case XML_TOK_OR:
1116     state->handler = element4;
1117     return XML_ROLE_NONE;
1118   }
1119   return common(state, tok);
1120 }
1121 
1122 static
element4(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1123 int element4(PROLOG_STATE *state,
1124              int tok,
1125              const char *ptr,
1126              const char *end,
1127              const ENCODING *enc)
1128 {
1129   vtkExpatUnused(ptr);
1130   vtkExpatUnused(end);
1131   vtkExpatUnused(enc);
1132   switch (tok) {
1133   case XML_TOK_PROLOG_S:
1134     return XML_ROLE_NONE;
1135   case XML_TOK_NAME:
1136   case XML_TOK_PREFIXED_NAME:
1137     state->handler = element5;
1138     return XML_ROLE_CONTENT_ELEMENT;
1139   }
1140   return common(state, tok);
1141 }
1142 
1143 static
element5(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1144 int element5(PROLOG_STATE *state,
1145              int tok,
1146              const char *ptr,
1147              const char *end,
1148              const ENCODING *enc)
1149 {
1150   vtkExpatUnused(ptr);
1151   vtkExpatUnused(end);
1152   vtkExpatUnused(enc);
1153   switch (tok) {
1154   case XML_TOK_PROLOG_S:
1155     return XML_ROLE_NONE;
1156   case XML_TOK_CLOSE_PAREN_ASTERISK:
1157     state->handler = declClose;
1158     return XML_ROLE_GROUP_CLOSE_REP;
1159   case XML_TOK_OR:
1160     state->handler = element4;
1161     return XML_ROLE_NONE;
1162   }
1163   return common(state, tok);
1164 }
1165 
1166 static
element6(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1167 int element6(PROLOG_STATE *state,
1168              int tok,
1169              const char *ptr,
1170              const char *end,
1171              const ENCODING *enc)
1172 {
1173   vtkExpatUnused(ptr);
1174   vtkExpatUnused(end);
1175   vtkExpatUnused(enc);
1176   switch (tok) {
1177   case XML_TOK_PROLOG_S:
1178     return XML_ROLE_NONE;
1179   case XML_TOK_OPEN_PAREN:
1180     state->level += 1;
1181     return XML_ROLE_GROUP_OPEN;
1182   case XML_TOK_NAME:
1183   case XML_TOK_PREFIXED_NAME:
1184     state->handler = element7;
1185     return XML_ROLE_CONTENT_ELEMENT;
1186   case XML_TOK_NAME_QUESTION:
1187     state->handler = element7;
1188     return XML_ROLE_CONTENT_ELEMENT_OPT;
1189   case XML_TOK_NAME_ASTERISK:
1190     state->handler = element7;
1191     return XML_ROLE_CONTENT_ELEMENT_REP;
1192   case XML_TOK_NAME_PLUS:
1193     state->handler = element7;
1194     return XML_ROLE_CONTENT_ELEMENT_PLUS;
1195   }
1196   return common(state, tok);
1197 }
1198 
1199 static
element7(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1200 int element7(PROLOG_STATE *state,
1201              int tok,
1202              const char *ptr,
1203              const char *end,
1204              const ENCODING *enc)
1205 {
1206   vtkExpatUnused(ptr);
1207   vtkExpatUnused(end);
1208   vtkExpatUnused(enc);
1209   switch (tok) {
1210   case XML_TOK_PROLOG_S:
1211     return XML_ROLE_NONE;
1212   case XML_TOK_CLOSE_PAREN:
1213     state->level -= 1;
1214     if (state->level == 0)
1215       state->handler = declClose;
1216     return XML_ROLE_GROUP_CLOSE;
1217   case XML_TOK_CLOSE_PAREN_ASTERISK:
1218     state->level -= 1;
1219     if (state->level == 0)
1220       state->handler = declClose;
1221     return XML_ROLE_GROUP_CLOSE_REP;
1222   case XML_TOK_CLOSE_PAREN_QUESTION:
1223     state->level -= 1;
1224     if (state->level == 0)
1225       state->handler = declClose;
1226     return XML_ROLE_GROUP_CLOSE_OPT;
1227   case XML_TOK_CLOSE_PAREN_PLUS:
1228     state->level -= 1;
1229     if (state->level == 0)
1230       state->handler = declClose;
1231     return XML_ROLE_GROUP_CLOSE_PLUS;
1232   case XML_TOK_COMMA:
1233     state->handler = element6;
1234     return XML_ROLE_GROUP_SEQUENCE;
1235   case XML_TOK_OR:
1236     state->handler = element6;
1237     return XML_ROLE_GROUP_CHOICE;
1238   }
1239   return common(state, tok);
1240 }
1241 
1242 #ifdef XML_DTD
1243 
1244 static
condSect0(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1245 int condSect0(PROLOG_STATE *state,
1246               int tok,
1247               const char *ptr,
1248               const char *end,
1249               const ENCODING *enc)
1250 {
1251   vtkExpatUnused(ptr);
1252   vtkExpatUnused(end);
1253   vtkExpatUnused(enc);
1254   switch (tok) {
1255   case XML_TOK_PROLOG_S:
1256     return XML_ROLE_NONE;
1257   case XML_TOK_NAME:
1258     if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
1259       state->handler = condSect1;
1260       return XML_ROLE_NONE;
1261     }
1262     if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
1263       state->handler = condSect2;
1264       return XML_ROLE_NONE;
1265     }
1266     break;
1267   }
1268   return common(state, tok);
1269 }
1270 
1271 static
condSect1(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1272 int condSect1(PROLOG_STATE *state,
1273               int tok,
1274               const char *ptr,
1275               const char *end,
1276               const ENCODING *enc)
1277 {
1278   vtkExpatUnused(ptr);
1279   vtkExpatUnused(end);
1280   vtkExpatUnused(enc);
1281   switch (tok) {
1282   case XML_TOK_PROLOG_S:
1283     return XML_ROLE_NONE;
1284   case XML_TOK_OPEN_BRACKET:
1285     state->handler = externalSubset1;
1286     state->includeLevel += 1;
1287     return XML_ROLE_NONE;
1288   }
1289   return common(state, tok);
1290 }
1291 
1292 static
condSect2(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1293 int condSect2(PROLOG_STATE *state,
1294               int tok,
1295               const char *ptr,
1296               const char *end,
1297               const ENCODING *enc)
1298 {
1299   vtkExpatUnused(ptr);
1300   vtkExpatUnused(end);
1301   vtkExpatUnused(enc);
1302   switch (tok) {
1303   case XML_TOK_PROLOG_S:
1304     return XML_ROLE_NONE;
1305   case XML_TOK_OPEN_BRACKET:
1306     state->handler = externalSubset1;
1307     return XML_ROLE_IGNORE_SECT;
1308   }
1309   return common(state, tok);
1310 }
1311 
1312 #endif /* XML_DTD */
1313 
1314 static
declClose(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1315 int declClose(PROLOG_STATE *state,
1316               int tok,
1317               const char *ptr,
1318               const char *end,
1319               const ENCODING *enc)
1320 {
1321   vtkExpatUnused(ptr);
1322   vtkExpatUnused(end);
1323   vtkExpatUnused(enc);
1324   switch (tok) {
1325   case XML_TOK_PROLOG_S:
1326     return XML_ROLE_NONE;
1327   case XML_TOK_DECL_CLOSE:
1328     setTopLevel(state);
1329     return XML_ROLE_NONE;
1330   }
1331   return common(state, tok);
1332 }
1333 
1334 #if 0
1335 
1336 static
1337 int ignore(PROLOG_STATE *state,
1338            int tok,
1339            const char *ptr,
1340            const char *end,
1341            const ENCODING *enc)
1342 {
1343   vtkExpatUnused(ptr);
1344   vtkExpatUnused(end);
1345   vtkExpatUnused(enc);
1346   switch (tok) {
1347   case XML_TOK_DECL_CLOSE:
1348     state->handler = internalSubset;
1349     return 0;
1350   default:
1351     return XML_ROLE_NONE;
1352   }
1353   return common(state, tok);
1354 }
1355 #endif
1356 
1357 static
error(PROLOG_STATE * state,int tok,const char * ptr,const char * end,const ENCODING * enc)1358 int error(PROLOG_STATE *state,
1359           int tok,
1360           const char *ptr,
1361           const char *end,
1362           const ENCODING *enc)
1363 {
1364   vtkExpatUnused(state);
1365   vtkExpatUnused(tok);
1366   vtkExpatUnused(ptr);
1367   vtkExpatUnused(end);
1368   vtkExpatUnused(enc);
1369   return XML_ROLE_NONE;
1370 }
1371 
1372 static
common(PROLOG_STATE * state,int tok)1373 int common(PROLOG_STATE *state, int tok)
1374 {
1375 #ifdef XML_DTD
1376   if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
1377     return XML_ROLE_INNER_PARAM_ENTITY_REF;
1378 #endif
1379   state->handler = error;
1380   return XML_ROLE_ERROR;
1381 }
1382 
XmlPrologStateInit(PROLOG_STATE * state)1383 void XmlPrologStateInit(PROLOG_STATE *state)
1384 {
1385   state->handler = prolog0;
1386 #ifdef XML_DTD
1387   state->documentEntity = 1;
1388   state->includeLevel = 0;
1389 #endif /* XML_DTD */
1390 }
1391 
1392 #ifdef XML_DTD
1393 
XmlPrologStateInitExternalEntity(PROLOG_STATE * state)1394 void XmlPrologStateInitExternalEntity(PROLOG_STATE *state)
1395 {
1396   state->handler = externalSubset0;
1397   state->documentEntity = 0;
1398   state->includeLevel = 0;
1399 }
1400 
1401 #endif /* XML_DTD */
1402