2 Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
3 See the file copying.txt for copying permission.
5 #include "xmlrpc_config.h"
13 that ,| are not mixed in a model group
18 static const char KW_ANY[] = { ASCII_A, ASCII_N, ASCII_Y, '\0' };
19 static const char KW_ATTLIST[] = { ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' };
20 static const char KW_CDATA[] = { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
21 static const char KW_DOCTYPE[] = { ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' };
22 static const char KW_ELEMENT[] = { ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' };
23 static const char KW_EMPTY[] = { ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' };
24 static const char KW_ENTITIES[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' };
25 static const char KW_ENTITY[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
26 static const char KW_FIXED[] = { ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' };
27 static const char KW_ID[] = { ASCII_I, ASCII_D, '\0' };
28 static const char KW_IDREF[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
29 static const char KW_IDREFS[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
30 static const char KW_IGNORE[] = { ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' };
31 static const char KW_IMPLIED[] = { ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' };
32 static const char KW_INCLUDE[] = { ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' };
33 static const char KW_NDATA[] = { ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
34 static const char KW_NMTOKEN[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
35 static const char KW_NMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' };
36 static const char KW_NOTATION[] = { ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, '\0' };
37 static const char KW_PCDATA[] = { ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
38 static const char KW_PUBLIC[] = { ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' };
39 static const char KW_REQUIRED[] = { ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D, '\0' };
40 static const char KW_SYSTEM[] = { ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' };
42 #ifndef MIN_BYTES_PER_CHAR
43 #define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
47 #define setTopLevel(state) \
48 ((state)->handler = ((state)->documentEntity \
51 #else /* not XML_DTD */
52 #define setTopLevel(state) ((state)->handler = internalSubset)
53 #endif /* not XML_DTD */
55 typedef int PROLOG_HANDLER(PROLOG_STATE *state,
62 prolog0, prolog1, prolog2,
63 doctype0, doctype1, doctype2, doctype3, doctype4, doctype5,
65 entity0, entity1, entity2, entity3, entity4, entity5, entity6,
66 entity7, entity8, entity9,
67 notation0, notation1, notation2, notation3, notation4,
68 attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6,
69 attlist7, attlist8, attlist9,
70 element0, element1, element2, element3, element4, element5, element6,
73 externalSubset0, externalSubset1,
74 condSect0, condSect1, condSect2,
80 int common(PROLOG_STATE *state, int tok);
83 int prolog0(PROLOG_STATE *state,
90 case XML_TOK_PROLOG_S:
91 state->handler = prolog1;
93 case XML_TOK_XML_DECL:
94 state->handler = prolog1;
95 return XML_ROLE_XML_DECL;
97 state->handler = prolog1;
100 state->handler = prolog1;
102 return XML_ROLE_NONE;
103 case XML_TOK_DECL_OPEN:
104 if (!XmlNameMatchesAscii(enc,
105 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
109 state->handler = doctype0;
110 return XML_ROLE_NONE;
111 case XML_TOK_INSTANCE_START:
112 state->handler = error;
113 return XML_ROLE_INSTANCE_START;
115 return common(state, tok);
119 int prolog1(PROLOG_STATE *state,
126 case XML_TOK_PROLOG_S:
127 return XML_ROLE_NONE;
129 case XML_TOK_COMMENT:
131 return XML_ROLE_NONE;
132 case XML_TOK_DECL_OPEN:
133 if (!XmlNameMatchesAscii(enc,
134 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
138 state->handler = doctype0;
139 return XML_ROLE_NONE;
140 case XML_TOK_INSTANCE_START:
141 state->handler = error;
142 return XML_ROLE_INSTANCE_START;
144 return common(state, tok);
148 int prolog2(PROLOG_STATE *state,
150 const char *ptr ATTR_UNUSED,
151 const char *end ATTR_UNUSED,
152 const ENCODING *enc ATTR_UNUSED)
155 case XML_TOK_PROLOG_S:
156 return XML_ROLE_NONE;
158 case XML_TOK_COMMENT:
159 return XML_ROLE_NONE;
160 case XML_TOK_INSTANCE_START:
161 state->handler = error;
162 return XML_ROLE_INSTANCE_START;
164 return common(state, tok);
168 int doctype0(PROLOG_STATE *state,
170 const char *ptr ATTR_UNUSED,
171 const char *end ATTR_UNUSED,
172 const ENCODING *enc ATTR_UNUSED)
175 case XML_TOK_PROLOG_S:
176 return XML_ROLE_NONE;
178 case XML_TOK_PREFIXED_NAME:
179 state->handler = doctype1;
180 return XML_ROLE_DOCTYPE_NAME;
182 return common(state, tok);
186 int doctype1(PROLOG_STATE *state,
193 case XML_TOK_PROLOG_S:
194 return XML_ROLE_NONE;
195 case XML_TOK_OPEN_BRACKET:
196 state->handler = internalSubset;
197 return XML_ROLE_NONE;
198 case XML_TOK_DECL_CLOSE:
199 state->handler = prolog2;
200 return XML_ROLE_DOCTYPE_CLOSE;
202 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
203 state->handler = doctype3;
204 return XML_ROLE_NONE;
206 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
207 state->handler = doctype2;
208 return XML_ROLE_NONE;
212 return common(state, tok);
216 int doctype2(PROLOG_STATE *state,
218 const char *ptr ATTR_UNUSED,
219 const char *end ATTR_UNUSED,
220 const ENCODING *enc ATTR_UNUSED)
223 case XML_TOK_PROLOG_S:
224 return XML_ROLE_NONE;
225 case XML_TOK_LITERAL:
226 state->handler = doctype3;
227 return XML_ROLE_DOCTYPE_PUBLIC_ID;
229 return common(state, tok);
233 int doctype3(PROLOG_STATE *state,
235 const char *ptr ATTR_UNUSED,
236 const char *end ATTR_UNUSED,
237 const ENCODING *enc ATTR_UNUSED)
240 case XML_TOK_PROLOG_S:
241 return XML_ROLE_NONE;
242 case XML_TOK_LITERAL:
243 state->handler = doctype4;
244 return XML_ROLE_DOCTYPE_SYSTEM_ID;
246 return common(state, tok);
250 int doctype4(PROLOG_STATE *state,
252 const char *ptr ATTR_UNUSED,
253 const char *end ATTR_UNUSED,
254 const ENCODING *enc ATTR_UNUSED)
257 case XML_TOK_PROLOG_S:
258 return XML_ROLE_NONE;
259 case XML_TOK_OPEN_BRACKET:
260 state->handler = internalSubset;
261 return XML_ROLE_NONE;
262 case XML_TOK_DECL_CLOSE:
263 state->handler = prolog2;
264 return XML_ROLE_DOCTYPE_CLOSE;
266 return common(state, tok);
270 int doctype5(PROLOG_STATE *state,
272 const char *ptr ATTR_UNUSED,
273 const char *end ATTR_UNUSED,
274 const ENCODING *enc ATTR_UNUSED)
277 case XML_TOK_PROLOG_S:
278 return XML_ROLE_NONE;
279 case XML_TOK_DECL_CLOSE:
280 state->handler = prolog2;
281 return XML_ROLE_DOCTYPE_CLOSE;
283 return common(state, tok);
287 int internalSubset(PROLOG_STATE *state,
294 case XML_TOK_PROLOG_S:
295 return XML_ROLE_NONE;
296 case XML_TOK_DECL_OPEN:
297 if (XmlNameMatchesAscii(enc,
298 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
301 state->handler = entity0;
302 return XML_ROLE_NONE;
304 if (XmlNameMatchesAscii(enc,
305 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
308 state->handler = attlist0;
309 return XML_ROLE_NONE;
311 if (XmlNameMatchesAscii(enc,
312 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
315 state->handler = element0;
316 return XML_ROLE_NONE;
318 if (XmlNameMatchesAscii(enc,
319 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
322 state->handler = notation0;
323 return XML_ROLE_NONE;
327 case XML_TOK_COMMENT:
328 return XML_ROLE_NONE;
329 case XML_TOK_PARAM_ENTITY_REF:
330 return XML_ROLE_PARAM_ENTITY_REF;
331 case XML_TOK_CLOSE_BRACKET:
332 state->handler = doctype5;
333 return XML_ROLE_NONE;
335 return common(state, tok);
341 int externalSubset0(PROLOG_STATE *state,
347 state->handler = externalSubset1;
348 if (tok == XML_TOK_XML_DECL)
349 return XML_ROLE_TEXT_DECL;
350 return externalSubset1(state, tok, ptr, end, enc);
354 int externalSubset1(PROLOG_STATE *state,
361 case XML_TOK_COND_SECT_OPEN:
362 state->handler = condSect0;
363 return XML_ROLE_NONE;
364 case XML_TOK_COND_SECT_CLOSE:
365 if (state->includeLevel == 0)
367 state->includeLevel -= 1;
368 return XML_ROLE_NONE;
369 case XML_TOK_PROLOG_S:
370 return XML_ROLE_NONE;
371 case XML_TOK_CLOSE_BRACKET:
374 if (state->includeLevel)
376 return XML_ROLE_NONE;
378 return internalSubset(state, tok, ptr, end, enc);
380 return common(state, tok);
386 int entity0(PROLOG_STATE *state,
388 const char *ptr ATTR_UNUSED,
389 const char *end ATTR_UNUSED,
390 const ENCODING *enc ATTR_UNUSED)
393 case XML_TOK_PROLOG_S:
394 return XML_ROLE_NONE;
395 case XML_TOK_PERCENT:
396 state->handler = entity1;
397 return XML_ROLE_NONE;
399 state->handler = entity2;
400 return XML_ROLE_GENERAL_ENTITY_NAME;
402 return common(state, tok);
406 int entity1(PROLOG_STATE *state,
408 const char *ptr ATTR_UNUSED,
409 const char *end ATTR_UNUSED,
410 const ENCODING *enc ATTR_UNUSED)
413 case XML_TOK_PROLOG_S:
414 return XML_ROLE_NONE;
416 state->handler = entity7;
417 return XML_ROLE_PARAM_ENTITY_NAME;
419 return common(state, tok);
423 int entity2(PROLOG_STATE *state,
430 case XML_TOK_PROLOG_S:
431 return XML_ROLE_NONE;
433 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
434 state->handler = entity4;
435 return XML_ROLE_NONE;
437 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
438 state->handler = entity3;
439 return XML_ROLE_NONE;
442 case XML_TOK_LITERAL:
443 state->handler = declClose;
444 return XML_ROLE_ENTITY_VALUE;
446 return common(state, tok);
450 int entity3(PROLOG_STATE *state,
452 const char *ptr ATTR_UNUSED,
453 const char *end ATTR_UNUSED,
454 const ENCODING *enc ATTR_UNUSED)
457 case XML_TOK_PROLOG_S:
458 return XML_ROLE_NONE;
459 case XML_TOK_LITERAL:
460 state->handler = entity4;
461 return XML_ROLE_ENTITY_PUBLIC_ID;
463 return common(state, tok);
468 int entity4(PROLOG_STATE *state,
470 const char *ptr ATTR_UNUSED,
471 const char *end ATTR_UNUSED,
472 const ENCODING *enc ATTR_UNUSED)
475 case XML_TOK_PROLOG_S:
476 return XML_ROLE_NONE;
477 case XML_TOK_LITERAL:
478 state->handler = entity5;
479 return XML_ROLE_ENTITY_SYSTEM_ID;
481 return common(state, tok);
485 int entity5(PROLOG_STATE *state,
492 case XML_TOK_PROLOG_S:
493 return XML_ROLE_NONE;
494 case XML_TOK_DECL_CLOSE:
496 return XML_ROLE_EXTERNAL_GENERAL_ENTITY_NO_NOTATION;
498 if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
499 state->handler = entity6;
500 return XML_ROLE_NONE;
504 return common(state, tok);
508 int entity6(PROLOG_STATE *state,
510 const char *ptr ATTR_UNUSED,
511 const char *end ATTR_UNUSED,
512 const ENCODING *enc ATTR_UNUSED)
515 case XML_TOK_PROLOG_S:
516 return XML_ROLE_NONE;
518 state->handler = declClose;
519 return XML_ROLE_ENTITY_NOTATION_NAME;
521 return common(state, tok);
525 int entity7(PROLOG_STATE *state,
532 case XML_TOK_PROLOG_S:
533 return XML_ROLE_NONE;
535 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
536 state->handler = entity9;
537 return XML_ROLE_NONE;
539 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
540 state->handler = entity8;
541 return XML_ROLE_NONE;
544 case XML_TOK_LITERAL:
545 state->handler = declClose;
546 return XML_ROLE_ENTITY_VALUE;
548 return common(state, tok);
552 int entity8(PROLOG_STATE *state,
554 const char *ptr ATTR_UNUSED,
555 const char *end ATTR_UNUSED,
556 const ENCODING *enc ATTR_UNUSED)
559 case XML_TOK_PROLOG_S:
560 return XML_ROLE_NONE;
561 case XML_TOK_LITERAL:
562 state->handler = entity9;
563 return XML_ROLE_ENTITY_PUBLIC_ID;
565 return common(state, tok);
569 int entity9(PROLOG_STATE *state,
571 const char *ptr ATTR_UNUSED,
572 const char *end ATTR_UNUSED,
573 const ENCODING *enc ATTR_UNUSED)
576 case XML_TOK_PROLOG_S:
577 return XML_ROLE_NONE;
578 case XML_TOK_LITERAL:
579 state->handler = declClose;
580 return XML_ROLE_ENTITY_SYSTEM_ID;
582 return common(state, tok);
586 int notation0(PROLOG_STATE *state,
588 const char *ptr ATTR_UNUSED,
589 const char *end ATTR_UNUSED,
590 const ENCODING *enc ATTR_UNUSED)
593 case XML_TOK_PROLOG_S:
594 return XML_ROLE_NONE;
596 state->handler = notation1;
597 return XML_ROLE_NOTATION_NAME;
599 return common(state, tok);
603 int notation1(PROLOG_STATE *state,
610 case XML_TOK_PROLOG_S:
611 return XML_ROLE_NONE;
613 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
614 state->handler = notation3;
615 return XML_ROLE_NONE;
617 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
618 state->handler = notation2;
619 return XML_ROLE_NONE;
623 return common(state, tok);
627 int notation2(PROLOG_STATE *state,
629 const char *ptr ATTR_UNUSED,
630 const char *end ATTR_UNUSED,
631 const ENCODING *enc ATTR_UNUSED)
634 case XML_TOK_PROLOG_S:
635 return XML_ROLE_NONE;
636 case XML_TOK_LITERAL:
637 state->handler = notation4;
638 return XML_ROLE_NOTATION_PUBLIC_ID;
640 return common(state, tok);
644 int notation3(PROLOG_STATE *state,
646 const char *ptr ATTR_UNUSED,
647 const char *end ATTR_UNUSED,
648 const ENCODING *enc ATTR_UNUSED)
651 case XML_TOK_PROLOG_S:
652 return XML_ROLE_NONE;
653 case XML_TOK_LITERAL:
654 state->handler = declClose;
655 return XML_ROLE_NOTATION_SYSTEM_ID;
657 return common(state, tok);
661 int notation4(PROLOG_STATE *state,
663 const char *ptr ATTR_UNUSED,
664 const char *end ATTR_UNUSED,
665 const ENCODING *enc ATTR_UNUSED)
668 case XML_TOK_PROLOG_S:
669 return XML_ROLE_NONE;
670 case XML_TOK_LITERAL:
671 state->handler = declClose;
672 return XML_ROLE_NOTATION_SYSTEM_ID;
673 case XML_TOK_DECL_CLOSE:
675 return XML_ROLE_NOTATION_NO_SYSTEM_ID;
677 return common(state, tok);
681 int attlist0(PROLOG_STATE *state,
683 const char *ptr ATTR_UNUSED,
684 const char *end ATTR_UNUSED,
685 const ENCODING *enc ATTR_UNUSED)
688 case XML_TOK_PROLOG_S:
689 return XML_ROLE_NONE;
691 case XML_TOK_PREFIXED_NAME:
692 state->handler = attlist1;
693 return XML_ROLE_ATTLIST_ELEMENT_NAME;
695 return common(state, tok);
699 int attlist1(PROLOG_STATE *state,
701 const char *ptr ATTR_UNUSED,
702 const char *end ATTR_UNUSED,
703 const ENCODING *enc ATTR_UNUSED)
706 case XML_TOK_PROLOG_S:
707 return XML_ROLE_NONE;
708 case XML_TOK_DECL_CLOSE:
710 return XML_ROLE_NONE;
712 case XML_TOK_PREFIXED_NAME:
713 state->handler = attlist2;
714 return XML_ROLE_ATTRIBUTE_NAME;
716 return common(state, tok);
720 int attlist2(PROLOG_STATE *state,
727 case XML_TOK_PROLOG_S:
728 return XML_ROLE_NONE;
731 static const char *types[] = {
742 for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
743 if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
744 state->handler = attlist8;
745 return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
748 if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
749 state->handler = attlist5;
750 return XML_ROLE_NONE;
753 case XML_TOK_OPEN_PAREN:
754 state->handler = attlist3;
755 return XML_ROLE_NONE;
757 return common(state, tok);
761 int attlist3(PROLOG_STATE *state,
763 const char *ptr ATTR_UNUSED,
764 const char *end ATTR_UNUSED,
765 const ENCODING *enc ATTR_UNUSED)
768 case XML_TOK_PROLOG_S:
769 return XML_ROLE_NONE;
770 case XML_TOK_NMTOKEN:
772 case XML_TOK_PREFIXED_NAME:
773 state->handler = attlist4;
774 return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
776 return common(state, tok);
780 int attlist4(PROLOG_STATE *state,
782 const char *ptr ATTR_UNUSED,
783 const char *end ATTR_UNUSED,
784 const ENCODING *enc ATTR_UNUSED)
787 case XML_TOK_PROLOG_S:
788 return XML_ROLE_NONE;
789 case XML_TOK_CLOSE_PAREN:
790 state->handler = attlist8;
791 return XML_ROLE_NONE;
793 state->handler = attlist3;
794 return XML_ROLE_NONE;
796 return common(state, tok);
800 int attlist5(PROLOG_STATE *state,
802 const char *ptr ATTR_UNUSED,
803 const char *end ATTR_UNUSED,
804 const ENCODING *enc ATTR_UNUSED)
807 case XML_TOK_PROLOG_S:
808 return XML_ROLE_NONE;
809 case XML_TOK_OPEN_PAREN:
810 state->handler = attlist6;
811 return XML_ROLE_NONE;
813 return common(state, tok);
818 int attlist6(PROLOG_STATE *state,
820 const char *ptr ATTR_UNUSED,
821 const char *end ATTR_UNUSED,
822 const ENCODING *enc ATTR_UNUSED)
825 case XML_TOK_PROLOG_S:
826 return XML_ROLE_NONE;
828 state->handler = attlist7;
829 return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
831 return common(state, tok);
835 int attlist7(PROLOG_STATE *state,
837 const char *ptr ATTR_UNUSED,
838 const char *end ATTR_UNUSED,
839 const ENCODING *enc ATTR_UNUSED)
842 case XML_TOK_PROLOG_S:
843 return XML_ROLE_NONE;
844 case XML_TOK_CLOSE_PAREN:
845 state->handler = attlist8;
846 return XML_ROLE_NONE;
848 state->handler = attlist6;
849 return XML_ROLE_NONE;
851 return common(state, tok);
856 int attlist8(PROLOG_STATE *state,
863 case XML_TOK_PROLOG_S:
864 return XML_ROLE_NONE;
865 case XML_TOK_POUND_NAME:
866 if (XmlNameMatchesAscii(enc,
867 ptr + MIN_BYTES_PER_CHAR(enc),
870 state->handler = attlist1;
871 return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
873 if (XmlNameMatchesAscii(enc,
874 ptr + MIN_BYTES_PER_CHAR(enc),
877 state->handler = attlist1;
878 return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
880 if (XmlNameMatchesAscii(enc,
881 ptr + MIN_BYTES_PER_CHAR(enc),
884 state->handler = attlist9;
885 return XML_ROLE_NONE;
888 case XML_TOK_LITERAL:
889 state->handler = attlist1;
890 return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
892 return common(state, tok);
896 int attlist9(PROLOG_STATE *state,
898 const char *ptr ATTR_UNUSED,
899 const char *end ATTR_UNUSED,
900 const ENCODING *enc ATTR_UNUSED)
903 case XML_TOK_PROLOG_S:
904 return XML_ROLE_NONE;
905 case XML_TOK_LITERAL:
906 state->handler = attlist1;
907 return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
909 return common(state, tok);
913 int element0(PROLOG_STATE *state,
915 const char *ptr ATTR_UNUSED,
916 const char *end ATTR_UNUSED,
917 const ENCODING *enc ATTR_UNUSED)
920 case XML_TOK_PROLOG_S:
921 return XML_ROLE_NONE;
923 case XML_TOK_PREFIXED_NAME:
924 state->handler = element1;
925 return XML_ROLE_ELEMENT_NAME;
927 return common(state, tok);
931 int element1(PROLOG_STATE *state,
938 case XML_TOK_PROLOG_S:
939 return XML_ROLE_NONE;
941 if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
942 state->handler = declClose;
943 return XML_ROLE_CONTENT_EMPTY;
945 if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
946 state->handler = declClose;
947 return XML_ROLE_CONTENT_ANY;
950 case XML_TOK_OPEN_PAREN:
951 state->handler = element2;
953 return XML_ROLE_GROUP_OPEN;
955 return common(state, tok);
959 int element2(PROLOG_STATE *state,
966 case XML_TOK_PROLOG_S:
967 return XML_ROLE_NONE;
968 case XML_TOK_POUND_NAME:
969 if (XmlNameMatchesAscii(enc,
970 ptr + MIN_BYTES_PER_CHAR(enc),
973 state->handler = element3;
974 return XML_ROLE_CONTENT_PCDATA;
977 case XML_TOK_OPEN_PAREN:
979 state->handler = element6;
980 return XML_ROLE_GROUP_OPEN;
982 case XML_TOK_PREFIXED_NAME:
983 state->handler = element7;
984 return XML_ROLE_CONTENT_ELEMENT;
985 case XML_TOK_NAME_QUESTION:
986 state->handler = element7;
987 return XML_ROLE_CONTENT_ELEMENT_OPT;
988 case XML_TOK_NAME_ASTERISK:
989 state->handler = element7;
990 return XML_ROLE_CONTENT_ELEMENT_REP;
991 case XML_TOK_NAME_PLUS:
992 state->handler = element7;
993 return XML_ROLE_CONTENT_ELEMENT_PLUS;
995 return common(state, tok);
999 int element3(PROLOG_STATE *state,
1001 const char *ptr ATTR_UNUSED,
1002 const char *end ATTR_UNUSED,
1003 const ENCODING *enc ATTR_UNUSED)
1006 case XML_TOK_PROLOG_S:
1007 return XML_ROLE_NONE;
1008 case XML_TOK_CLOSE_PAREN:
1009 case XML_TOK_CLOSE_PAREN_ASTERISK:
1010 state->handler = declClose;
1011 return XML_ROLE_GROUP_CLOSE_REP;
1013 state->handler = element4;
1014 return XML_ROLE_NONE;
1016 return common(state, tok);
1020 int element4(PROLOG_STATE *state,
1022 const char *ptr ATTR_UNUSED,
1023 const char *end ATTR_UNUSED,
1024 const ENCODING *enc ATTR_UNUSED)
1027 case XML_TOK_PROLOG_S:
1028 return XML_ROLE_NONE;
1030 case XML_TOK_PREFIXED_NAME:
1031 state->handler = element5;
1032 return XML_ROLE_CONTENT_ELEMENT;
1034 return common(state, tok);
1038 int element5(PROLOG_STATE *state,
1040 const char *ptr ATTR_UNUSED,
1041 const char *end ATTR_UNUSED,
1042 const ENCODING *enc ATTR_UNUSED)
1045 case XML_TOK_PROLOG_S:
1046 return XML_ROLE_NONE;
1047 case XML_TOK_CLOSE_PAREN_ASTERISK:
1048 state->handler = declClose;
1049 return XML_ROLE_GROUP_CLOSE_REP;
1051 state->handler = element4;
1052 return XML_ROLE_NONE;
1054 return common(state, tok);
1058 int element6(PROLOG_STATE *state,
1060 const char *ptr ATTR_UNUSED,
1061 const char *end ATTR_UNUSED,
1062 const ENCODING *enc ATTR_UNUSED)
1065 case XML_TOK_PROLOG_S:
1066 return XML_ROLE_NONE;
1067 case XML_TOK_OPEN_PAREN:
1069 return XML_ROLE_GROUP_OPEN;
1071 case XML_TOK_PREFIXED_NAME:
1072 state->handler = element7;
1073 return XML_ROLE_CONTENT_ELEMENT;
1074 case XML_TOK_NAME_QUESTION:
1075 state->handler = element7;
1076 return XML_ROLE_CONTENT_ELEMENT_OPT;
1077 case XML_TOK_NAME_ASTERISK:
1078 state->handler = element7;
1079 return XML_ROLE_CONTENT_ELEMENT_REP;
1080 case XML_TOK_NAME_PLUS:
1081 state->handler = element7;
1082 return XML_ROLE_CONTENT_ELEMENT_PLUS;
1084 return common(state, tok);
1088 int element7(PROLOG_STATE *state,
1090 const char *ptr ATTR_UNUSED,
1091 const char *end ATTR_UNUSED,
1092 const ENCODING *enc ATTR_UNUSED)
1095 case XML_TOK_PROLOG_S:
1096 return XML_ROLE_NONE;
1097 case XML_TOK_CLOSE_PAREN:
1099 if (state->level == 0)
1100 state->handler = declClose;
1101 return XML_ROLE_GROUP_CLOSE;
1102 case XML_TOK_CLOSE_PAREN_ASTERISK:
1104 if (state->level == 0)
1105 state->handler = declClose;
1106 return XML_ROLE_GROUP_CLOSE_REP;
1107 case XML_TOK_CLOSE_PAREN_QUESTION:
1109 if (state->level == 0)
1110 state->handler = declClose;
1111 return XML_ROLE_GROUP_CLOSE_OPT;
1112 case XML_TOK_CLOSE_PAREN_PLUS:
1114 if (state->level == 0)
1115 state->handler = declClose;
1116 return XML_ROLE_GROUP_CLOSE_PLUS;
1118 state->handler = element6;
1119 return XML_ROLE_GROUP_SEQUENCE;
1121 state->handler = element6;
1122 return XML_ROLE_GROUP_CHOICE;
1124 return common(state, tok);
1130 int condSect0(PROLOG_STATE *state,
1134 const ENCODING *enc)
1137 case XML_TOK_PROLOG_S:
1138 return XML_ROLE_NONE;
1140 if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
1141 state->handler = condSect1;
1142 return XML_ROLE_NONE;
1144 if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
1145 state->handler = condSect2;
1146 return XML_ROLE_NONE;
1150 return common(state, tok);
1154 int condSect1(PROLOG_STATE *state,
1158 const ENCODING *enc)
1161 case XML_TOK_PROLOG_S:
1162 return XML_ROLE_NONE;
1163 case XML_TOK_OPEN_BRACKET:
1164 state->handler = externalSubset1;
1165 state->includeLevel += 1;
1166 return XML_ROLE_NONE;
1168 return common(state, tok);
1172 int condSect2(PROLOG_STATE *state,
1176 const ENCODING *enc)
1179 case XML_TOK_PROLOG_S:
1180 return XML_ROLE_NONE;
1181 case XML_TOK_OPEN_BRACKET:
1182 state->handler = externalSubset1;
1183 return XML_ROLE_IGNORE_SECT;
1185 return common(state, tok);
1188 #endif /* XML_DTD */
1191 int declClose(PROLOG_STATE *state,
1193 const char *ptr ATTR_UNUSED,
1194 const char *end ATTR_UNUSED,
1195 const ENCODING *enc ATTR_UNUSED)
1198 case XML_TOK_PROLOG_S:
1199 return XML_ROLE_NONE;
1200 case XML_TOK_DECL_CLOSE:
1202 return XML_ROLE_NONE;
1204 return common(state, tok);
1210 int ignore(PROLOG_STATE *state,
1214 const ENCODING *enc)
1217 case XML_TOK_DECL_CLOSE:
1218 state->handler = internalSubset;
1221 return XML_ROLE_NONE;
1223 return common(state, tok);
1228 int error(PROLOG_STATE *state ATTR_UNUSED,
1229 int tok ATTR_UNUSED,
1230 const char *ptr ATTR_UNUSED,
1231 const char *end ATTR_UNUSED,
1232 const ENCODING *enc ATTR_UNUSED)
1234 return XML_ROLE_NONE;
1238 int common(PROLOG_STATE *state, int tok ATTR_UNUSED)
1241 if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
1242 return XML_ROLE_INNER_PARAM_ENTITY_REF;
1244 state->handler = error;
1245 return XML_ROLE_ERROR;
1248 void xmlrpc_XmlPrologStateInit(PROLOG_STATE *state)
1250 state->handler = prolog0;
1252 state->documentEntity = 1;
1253 state->includeLevel = 0;
1254 #endif /* XML_DTD */
1259 void XmlPrologStateInitExternalEntity(PROLOG_STATE *state)
1261 state->handler = externalSubset0;
1262 state->documentEntity = 0;
1263 state->includeLevel = 0;
1266 #endif /* XML_DTD */