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