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