1 /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
2 See the file COPYING for copying permission.
5 #ifdef COMPILED_FROM_DSP
7 #elif defined(MACOS_CLASSIC)
10 #include <expat_config.h>
11 #endif /* ndef COMPILED_FROM_DSP */
17 // Track memory leaks on Windows to the line that new'd the memory
20 #define DEBUG_NEW new( _NORMAL_BLOCK, THIS_FILE, __LINE__ )
23 static char THIS_FILE
[] = __FILE__
;
29 that ,| are not mixed in a model group
34 static const char KW_ANY
[] = {
35 ASCII_A
, ASCII_N
, ASCII_Y
, '\0' };
36 static const char KW_ATTLIST
[] = {
37 ASCII_A
, ASCII_T
, ASCII_T
, ASCII_L
, ASCII_I
, ASCII_S
, ASCII_T
, '\0' };
38 static const char KW_CDATA
[] = {
39 ASCII_C
, ASCII_D
, ASCII_A
, ASCII_T
, ASCII_A
, '\0' };
40 static const char KW_DOCTYPE
[] = {
41 ASCII_D
, ASCII_O
, ASCII_C
, ASCII_T
, ASCII_Y
, ASCII_P
, ASCII_E
, '\0' };
42 static const char KW_ELEMENT
[] = {
43 ASCII_E
, ASCII_L
, ASCII_E
, ASCII_M
, ASCII_E
, ASCII_N
, ASCII_T
, '\0' };
44 static const char KW_EMPTY
[] = {
45 ASCII_E
, ASCII_M
, ASCII_P
, ASCII_T
, ASCII_Y
, '\0' };
46 static const char KW_ENTITIES
[] = {
47 ASCII_E
, ASCII_N
, ASCII_T
, ASCII_I
, ASCII_T
, ASCII_I
, ASCII_E
, ASCII_S
,
49 static const char KW_ENTITY
[] = {
50 ASCII_E
, ASCII_N
, ASCII_T
, ASCII_I
, ASCII_T
, ASCII_Y
, '\0' };
51 static const char KW_FIXED
[] = {
52 ASCII_F
, ASCII_I
, ASCII_X
, ASCII_E
, ASCII_D
, '\0' };
53 static const char KW_ID
[] = {
54 ASCII_I
, ASCII_D
, '\0' };
55 static const char KW_IDREF
[] = {
56 ASCII_I
, ASCII_D
, ASCII_R
, ASCII_E
, ASCII_F
, '\0' };
57 static const char KW_IDREFS
[] = {
58 ASCII_I
, ASCII_D
, ASCII_R
, ASCII_E
, ASCII_F
, ASCII_S
, '\0' };
59 static const char KW_IGNORE
[] = {
60 ASCII_I
, ASCII_G
, ASCII_N
, ASCII_O
, ASCII_R
, ASCII_E
, '\0' };
61 static const char KW_IMPLIED
[] = {
62 ASCII_I
, ASCII_M
, ASCII_P
, ASCII_L
, ASCII_I
, ASCII_E
, ASCII_D
, '\0' };
63 static const char KW_INCLUDE
[] = {
64 ASCII_I
, ASCII_N
, ASCII_C
, ASCII_L
, ASCII_U
, ASCII_D
, ASCII_E
, '\0' };
65 static const char KW_NDATA
[] = {
66 ASCII_N
, ASCII_D
, ASCII_A
, ASCII_T
, ASCII_A
, '\0' };
67 static const char KW_NMTOKEN
[] = {
68 ASCII_N
, ASCII_M
, ASCII_T
, ASCII_O
, ASCII_K
, ASCII_E
, ASCII_N
, '\0' };
69 static const char KW_NMTOKENS
[] = {
70 ASCII_N
, ASCII_M
, ASCII_T
, ASCII_O
, ASCII_K
, ASCII_E
, ASCII_N
, ASCII_S
,
72 static const char KW_NOTATION
[] =
73 { ASCII_N
, ASCII_O
, ASCII_T
, ASCII_A
, ASCII_T
, ASCII_I
, ASCII_O
, ASCII_N
,
75 static const char KW_PCDATA
[] = {
76 ASCII_P
, ASCII_C
, ASCII_D
, ASCII_A
, ASCII_T
, ASCII_A
, '\0' };
77 static const char KW_PUBLIC
[] = {
78 ASCII_P
, ASCII_U
, ASCII_B
, ASCII_L
, ASCII_I
, ASCII_C
, '\0' };
79 static const char KW_REQUIRED
[] = {
80 ASCII_R
, ASCII_E
, ASCII_Q
, ASCII_U
, ASCII_I
, ASCII_R
, ASCII_E
, ASCII_D
,
82 static const char KW_SYSTEM
[] = {
83 ASCII_S
, ASCII_Y
, ASCII_S
, ASCII_T
, ASCII_E
, ASCII_M
, '\0' };
85 #ifndef MIN_BYTES_PER_CHAR
86 #define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
90 #define setTopLevel(state) \
91 ((state)->handler = ((state)->documentEntity \
94 #else /* not XML_DTD */
95 #define setTopLevel(state) ((state)->handler = internalSubset)
96 #endif /* not XML_DTD */
98 typedef int FASTCALL
PROLOG_HANDLER(PROLOG_STATE
*state
,
102 const ENCODING
*enc
);
104 static PROLOG_HANDLER
105 prolog0
, prolog1
, prolog2
,
106 doctype0
, doctype1
, doctype2
, doctype3
, doctype4
, doctype5
,
108 entity0
, entity1
, entity2
, entity3
, entity4
, entity5
, entity6
,
109 entity7
, entity8
, entity9
, entity10
,
110 notation0
, notation1
, notation2
, notation3
, notation4
,
111 attlist0
, attlist1
, attlist2
, attlist3
, attlist4
, attlist5
, attlist6
,
112 attlist7
, attlist8
, attlist9
,
113 element0
, element1
, element2
, element3
, element4
, element5
, element6
,
116 externalSubset0
, externalSubset1
,
117 condSect0
, condSect1
, condSect2
,
122 static int FASTCALL
common(PROLOG_STATE
*state
, int tok
);
125 prolog0(PROLOG_STATE
*state
,
132 case XML_TOK_PROLOG_S
:
133 state
->handler
= prolog1
;
134 return XML_ROLE_NONE
;
135 case XML_TOK_XML_DECL
:
136 state
->handler
= prolog1
;
137 return XML_ROLE_XML_DECL
;
139 state
->handler
= prolog1
;
141 case XML_TOK_COMMENT
:
142 state
->handler
= prolog1
;
143 return XML_ROLE_COMMENT
;
145 return XML_ROLE_NONE
;
146 case XML_TOK_DECL_OPEN
:
147 if (!XmlNameMatchesAscii(enc
,
148 ptr
+ 2 * MIN_BYTES_PER_CHAR(enc
),
152 state
->handler
= doctype0
;
153 return XML_ROLE_DOCTYPE_NONE
;
154 case XML_TOK_INSTANCE_START
:
155 state
->handler
= error
;
156 return XML_ROLE_INSTANCE_START
;
158 return common(state
, tok
);
162 prolog1(PROLOG_STATE
*state
,
169 case XML_TOK_PROLOG_S
:
170 return XML_ROLE_NONE
;
173 case XML_TOK_COMMENT
:
174 return XML_ROLE_COMMENT
;
176 return XML_ROLE_NONE
;
177 case XML_TOK_DECL_OPEN
:
178 if (!XmlNameMatchesAscii(enc
,
179 ptr
+ 2 * MIN_BYTES_PER_CHAR(enc
),
183 state
->handler
= doctype0
;
184 return XML_ROLE_DOCTYPE_NONE
;
185 case XML_TOK_INSTANCE_START
:
186 state
->handler
= error
;
187 return XML_ROLE_INSTANCE_START
;
189 return common(state
, tok
);
193 prolog2(PROLOG_STATE
*state
,
200 case XML_TOK_PROLOG_S
:
201 return XML_ROLE_NONE
;
204 case XML_TOK_COMMENT
:
205 return XML_ROLE_COMMENT
;
206 case XML_TOK_INSTANCE_START
:
207 state
->handler
= error
;
208 return XML_ROLE_INSTANCE_START
;
210 return common(state
, tok
);
214 doctype0(PROLOG_STATE
*state
,
221 case XML_TOK_PROLOG_S
:
222 return XML_ROLE_DOCTYPE_NONE
;
224 case XML_TOK_PREFIXED_NAME
:
225 state
->handler
= doctype1
;
226 return XML_ROLE_DOCTYPE_NAME
;
228 return common(state
, tok
);
232 doctype1(PROLOG_STATE
*state
,
239 case XML_TOK_PROLOG_S
:
240 return XML_ROLE_DOCTYPE_NONE
;
241 case XML_TOK_OPEN_BRACKET
:
242 state
->handler
= internalSubset
;
243 return XML_ROLE_DOCTYPE_INTERNAL_SUBSET
;
244 case XML_TOK_DECL_CLOSE
:
245 state
->handler
= prolog2
;
246 return XML_ROLE_DOCTYPE_CLOSE
;
248 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_SYSTEM
)) {
249 state
->handler
= doctype3
;
250 return XML_ROLE_DOCTYPE_NONE
;
252 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_PUBLIC
)) {
253 state
->handler
= doctype2
;
254 return XML_ROLE_DOCTYPE_NONE
;
258 return common(state
, tok
);
262 doctype2(PROLOG_STATE
*state
,
269 case XML_TOK_PROLOG_S
:
270 return XML_ROLE_DOCTYPE_NONE
;
271 case XML_TOK_LITERAL
:
272 state
->handler
= doctype3
;
273 return XML_ROLE_DOCTYPE_PUBLIC_ID
;
275 return common(state
, tok
);
279 doctype3(PROLOG_STATE
*state
,
286 case XML_TOK_PROLOG_S
:
287 return XML_ROLE_DOCTYPE_NONE
;
288 case XML_TOK_LITERAL
:
289 state
->handler
= doctype4
;
290 return XML_ROLE_DOCTYPE_SYSTEM_ID
;
292 return common(state
, tok
);
296 doctype4(PROLOG_STATE
*state
,
303 case XML_TOK_PROLOG_S
:
304 return XML_ROLE_DOCTYPE_NONE
;
305 case XML_TOK_OPEN_BRACKET
:
306 state
->handler
= internalSubset
;
307 return XML_ROLE_DOCTYPE_INTERNAL_SUBSET
;
308 case XML_TOK_DECL_CLOSE
:
309 state
->handler
= prolog2
;
310 return XML_ROLE_DOCTYPE_CLOSE
;
312 return common(state
, tok
);
316 doctype5(PROLOG_STATE
*state
,
323 case XML_TOK_PROLOG_S
:
324 return XML_ROLE_DOCTYPE_NONE
;
325 case XML_TOK_DECL_CLOSE
:
326 state
->handler
= prolog2
;
327 return XML_ROLE_DOCTYPE_CLOSE
;
329 return common(state
, tok
);
333 internalSubset(PROLOG_STATE
*state
,
340 case XML_TOK_PROLOG_S
:
341 return XML_ROLE_NONE
;
342 case XML_TOK_DECL_OPEN
:
343 if (XmlNameMatchesAscii(enc
,
344 ptr
+ 2 * MIN_BYTES_PER_CHAR(enc
),
347 state
->handler
= entity0
;
348 return XML_ROLE_ENTITY_NONE
;
350 if (XmlNameMatchesAscii(enc
,
351 ptr
+ 2 * MIN_BYTES_PER_CHAR(enc
),
354 state
->handler
= attlist0
;
355 return XML_ROLE_ATTLIST_NONE
;
357 if (XmlNameMatchesAscii(enc
,
358 ptr
+ 2 * MIN_BYTES_PER_CHAR(enc
),
361 state
->handler
= element0
;
362 return XML_ROLE_ELEMENT_NONE
;
364 if (XmlNameMatchesAscii(enc
,
365 ptr
+ 2 * MIN_BYTES_PER_CHAR(enc
),
368 state
->handler
= notation0
;
369 return XML_ROLE_NOTATION_NONE
;
374 case XML_TOK_COMMENT
:
375 return XML_ROLE_COMMENT
;
376 case XML_TOK_PARAM_ENTITY_REF
:
377 return XML_ROLE_PARAM_ENTITY_REF
;
378 case XML_TOK_CLOSE_BRACKET
:
379 state
->handler
= doctype5
;
380 return XML_ROLE_DOCTYPE_NONE
;
382 return common(state
, tok
);
388 externalSubset0(PROLOG_STATE
*state
,
394 state
->handler
= externalSubset1
;
395 if (tok
== XML_TOK_XML_DECL
)
396 return XML_ROLE_TEXT_DECL
;
397 return externalSubset1(state
, tok
, ptr
, end
, enc
);
401 externalSubset1(PROLOG_STATE
*state
,
408 case XML_TOK_COND_SECT_OPEN
:
409 state
->handler
= condSect0
;
410 return XML_ROLE_NONE
;
411 case XML_TOK_COND_SECT_CLOSE
:
412 if (state
->includeLevel
== 0)
414 state
->includeLevel
-= 1;
415 return XML_ROLE_NONE
;
416 case XML_TOK_PROLOG_S
:
417 return XML_ROLE_NONE
;
418 case XML_TOK_CLOSE_BRACKET
:
421 if (state
->includeLevel
)
423 return XML_ROLE_NONE
;
425 return internalSubset(state
, tok
, ptr
, end
, enc
);
427 return common(state
, tok
);
433 entity0(PROLOG_STATE
*state
,
440 case XML_TOK_PROLOG_S
:
441 return XML_ROLE_ENTITY_NONE
;
442 case XML_TOK_PERCENT
:
443 state
->handler
= entity1
;
444 return XML_ROLE_ENTITY_NONE
;
446 state
->handler
= entity2
;
447 return XML_ROLE_GENERAL_ENTITY_NAME
;
449 return common(state
, tok
);
453 entity1(PROLOG_STATE
*state
,
460 case XML_TOK_PROLOG_S
:
461 return XML_ROLE_ENTITY_NONE
;
463 state
->handler
= entity7
;
464 return XML_ROLE_PARAM_ENTITY_NAME
;
466 return common(state
, tok
);
470 entity2(PROLOG_STATE
*state
,
477 case XML_TOK_PROLOG_S
:
478 return XML_ROLE_ENTITY_NONE
;
480 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_SYSTEM
)) {
481 state
->handler
= entity4
;
482 return XML_ROLE_ENTITY_NONE
;
484 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_PUBLIC
)) {
485 state
->handler
= entity3
;
486 return XML_ROLE_ENTITY_NONE
;
489 case XML_TOK_LITERAL
:
490 state
->handler
= declClose
;
491 state
->role_none
= XML_ROLE_ENTITY_NONE
;
492 return XML_ROLE_ENTITY_VALUE
;
494 return common(state
, tok
);
498 entity3(PROLOG_STATE
*state
,
505 case XML_TOK_PROLOG_S
:
506 return XML_ROLE_ENTITY_NONE
;
507 case XML_TOK_LITERAL
:
508 state
->handler
= entity4
;
509 return XML_ROLE_ENTITY_PUBLIC_ID
;
511 return common(state
, tok
);
515 entity4(PROLOG_STATE
*state
,
522 case XML_TOK_PROLOG_S
:
523 return XML_ROLE_ENTITY_NONE
;
524 case XML_TOK_LITERAL
:
525 state
->handler
= entity5
;
526 return XML_ROLE_ENTITY_SYSTEM_ID
;
528 return common(state
, tok
);
532 entity5(PROLOG_STATE
*state
,
539 case XML_TOK_PROLOG_S
:
540 return XML_ROLE_ENTITY_NONE
;
541 case XML_TOK_DECL_CLOSE
:
543 return XML_ROLE_ENTITY_COMPLETE
;
545 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_NDATA
)) {
546 state
->handler
= entity6
;
547 return XML_ROLE_ENTITY_NONE
;
551 return common(state
, tok
);
555 entity6(PROLOG_STATE
*state
,
562 case XML_TOK_PROLOG_S
:
563 return XML_ROLE_ENTITY_NONE
;
565 state
->handler
= declClose
;
566 state
->role_none
= XML_ROLE_ENTITY_NONE
;
567 return XML_ROLE_ENTITY_NOTATION_NAME
;
569 return common(state
, tok
);
573 entity7(PROLOG_STATE
*state
,
580 case XML_TOK_PROLOG_S
:
581 return XML_ROLE_ENTITY_NONE
;
583 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_SYSTEM
)) {
584 state
->handler
= entity9
;
585 return XML_ROLE_ENTITY_NONE
;
587 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_PUBLIC
)) {
588 state
->handler
= entity8
;
589 return XML_ROLE_ENTITY_NONE
;
592 case XML_TOK_LITERAL
:
593 state
->handler
= declClose
;
594 state
->role_none
= XML_ROLE_ENTITY_NONE
;
595 return XML_ROLE_ENTITY_VALUE
;
597 return common(state
, tok
);
601 entity8(PROLOG_STATE
*state
,
608 case XML_TOK_PROLOG_S
:
609 return XML_ROLE_ENTITY_NONE
;
610 case XML_TOK_LITERAL
:
611 state
->handler
= entity9
;
612 return XML_ROLE_ENTITY_PUBLIC_ID
;
614 return common(state
, tok
);
618 entity9(PROLOG_STATE
*state
,
625 case XML_TOK_PROLOG_S
:
626 return XML_ROLE_ENTITY_NONE
;
627 case XML_TOK_LITERAL
:
628 state
->handler
= entity10
;
629 return XML_ROLE_ENTITY_SYSTEM_ID
;
631 return common(state
, tok
);
635 entity10(PROLOG_STATE
*state
,
642 case XML_TOK_PROLOG_S
:
643 return XML_ROLE_ENTITY_NONE
;
644 case XML_TOK_DECL_CLOSE
:
646 return XML_ROLE_ENTITY_COMPLETE
;
648 return common(state
, tok
);
652 notation0(PROLOG_STATE
*state
,
659 case XML_TOK_PROLOG_S
:
660 return XML_ROLE_NOTATION_NONE
;
662 state
->handler
= notation1
;
663 return XML_ROLE_NOTATION_NAME
;
665 return common(state
, tok
);
669 notation1(PROLOG_STATE
*state
,
676 case XML_TOK_PROLOG_S
:
677 return XML_ROLE_NOTATION_NONE
;
679 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_SYSTEM
)) {
680 state
->handler
= notation3
;
681 return XML_ROLE_NOTATION_NONE
;
683 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_PUBLIC
)) {
684 state
->handler
= notation2
;
685 return XML_ROLE_NOTATION_NONE
;
689 return common(state
, tok
);
693 notation2(PROLOG_STATE
*state
,
700 case XML_TOK_PROLOG_S
:
701 return XML_ROLE_NOTATION_NONE
;
702 case XML_TOK_LITERAL
:
703 state
->handler
= notation4
;
704 return XML_ROLE_NOTATION_PUBLIC_ID
;
706 return common(state
, tok
);
710 notation3(PROLOG_STATE
*state
,
717 case XML_TOK_PROLOG_S
:
718 return XML_ROLE_NOTATION_NONE
;
719 case XML_TOK_LITERAL
:
720 state
->handler
= declClose
;
721 state
->role_none
= XML_ROLE_NOTATION_NONE
;
722 return XML_ROLE_NOTATION_SYSTEM_ID
;
724 return common(state
, tok
);
728 notation4(PROLOG_STATE
*state
,
735 case XML_TOK_PROLOG_S
:
736 return XML_ROLE_NOTATION_NONE
;
737 case XML_TOK_LITERAL
:
738 state
->handler
= declClose
;
739 state
->role_none
= XML_ROLE_NOTATION_NONE
;
740 return XML_ROLE_NOTATION_SYSTEM_ID
;
741 case XML_TOK_DECL_CLOSE
:
743 return XML_ROLE_NOTATION_NO_SYSTEM_ID
;
745 return common(state
, tok
);
749 attlist0(PROLOG_STATE
*state
,
756 case XML_TOK_PROLOG_S
:
757 return XML_ROLE_ATTLIST_NONE
;
759 case XML_TOK_PREFIXED_NAME
:
760 state
->handler
= attlist1
;
761 return XML_ROLE_ATTLIST_ELEMENT_NAME
;
763 return common(state
, tok
);
767 attlist1(PROLOG_STATE
*state
,
774 case XML_TOK_PROLOG_S
:
775 return XML_ROLE_ATTLIST_NONE
;
776 case XML_TOK_DECL_CLOSE
:
778 return XML_ROLE_ATTLIST_NONE
;
780 case XML_TOK_PREFIXED_NAME
:
781 state
->handler
= attlist2
;
782 return XML_ROLE_ATTRIBUTE_NAME
;
784 return common(state
, tok
);
788 attlist2(PROLOG_STATE
*state
,
795 case XML_TOK_PROLOG_S
:
796 return XML_ROLE_ATTLIST_NONE
;
799 static const char *types
[] = {
810 for (i
= 0; i
< (int)(sizeof(types
)/sizeof(types
[0])); i
++)
811 if (XmlNameMatchesAscii(enc
, ptr
, end
, types
[i
])) {
812 state
->handler
= attlist8
;
813 return XML_ROLE_ATTRIBUTE_TYPE_CDATA
+ i
;
816 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_NOTATION
)) {
817 state
->handler
= attlist5
;
818 return XML_ROLE_ATTLIST_NONE
;
821 case XML_TOK_OPEN_PAREN
:
822 state
->handler
= attlist3
;
823 return XML_ROLE_ATTLIST_NONE
;
825 return common(state
, tok
);
829 attlist3(PROLOG_STATE
*state
,
836 case XML_TOK_PROLOG_S
:
837 return XML_ROLE_ATTLIST_NONE
;
838 case XML_TOK_NMTOKEN
:
840 case XML_TOK_PREFIXED_NAME
:
841 state
->handler
= attlist4
;
842 return XML_ROLE_ATTRIBUTE_ENUM_VALUE
;
844 return common(state
, tok
);
848 attlist4(PROLOG_STATE
*state
,
855 case XML_TOK_PROLOG_S
:
856 return XML_ROLE_ATTLIST_NONE
;
857 case XML_TOK_CLOSE_PAREN
:
858 state
->handler
= attlist8
;
859 return XML_ROLE_ATTLIST_NONE
;
861 state
->handler
= attlist3
;
862 return XML_ROLE_ATTLIST_NONE
;
864 return common(state
, tok
);
868 attlist5(PROLOG_STATE
*state
,
875 case XML_TOK_PROLOG_S
:
876 return XML_ROLE_ATTLIST_NONE
;
877 case XML_TOK_OPEN_PAREN
:
878 state
->handler
= attlist6
;
879 return XML_ROLE_ATTLIST_NONE
;
881 return common(state
, tok
);
885 attlist6(PROLOG_STATE
*state
,
892 case XML_TOK_PROLOG_S
:
893 return XML_ROLE_ATTLIST_NONE
;
895 state
->handler
= attlist7
;
896 return XML_ROLE_ATTRIBUTE_NOTATION_VALUE
;
898 return common(state
, tok
);
902 attlist7(PROLOG_STATE
*state
,
909 case XML_TOK_PROLOG_S
:
910 return XML_ROLE_ATTLIST_NONE
;
911 case XML_TOK_CLOSE_PAREN
:
912 state
->handler
= attlist8
;
913 return XML_ROLE_ATTLIST_NONE
;
915 state
->handler
= attlist6
;
916 return XML_ROLE_ATTLIST_NONE
;
918 return common(state
, tok
);
923 attlist8(PROLOG_STATE
*state
,
930 case XML_TOK_PROLOG_S
:
931 return XML_ROLE_ATTLIST_NONE
;
932 case XML_TOK_POUND_NAME
:
933 if (XmlNameMatchesAscii(enc
,
934 ptr
+ MIN_BYTES_PER_CHAR(enc
),
937 state
->handler
= attlist1
;
938 return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE
;
940 if (XmlNameMatchesAscii(enc
,
941 ptr
+ MIN_BYTES_PER_CHAR(enc
),
944 state
->handler
= attlist1
;
945 return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE
;
947 if (XmlNameMatchesAscii(enc
,
948 ptr
+ MIN_BYTES_PER_CHAR(enc
),
951 state
->handler
= attlist9
;
952 return XML_ROLE_ATTLIST_NONE
;
955 case XML_TOK_LITERAL
:
956 state
->handler
= attlist1
;
957 return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE
;
959 return common(state
, tok
);
963 attlist9(PROLOG_STATE
*state
,
970 case XML_TOK_PROLOG_S
:
971 return XML_ROLE_ATTLIST_NONE
;
972 case XML_TOK_LITERAL
:
973 state
->handler
= attlist1
;
974 return XML_ROLE_FIXED_ATTRIBUTE_VALUE
;
976 return common(state
, tok
);
980 element0(PROLOG_STATE
*state
,
987 case XML_TOK_PROLOG_S
:
988 return XML_ROLE_ELEMENT_NONE
;
990 case XML_TOK_PREFIXED_NAME
:
991 state
->handler
= element1
;
992 return XML_ROLE_ELEMENT_NAME
;
994 return common(state
, tok
);
998 element1(PROLOG_STATE
*state
,
1002 const ENCODING
*enc
)
1005 case XML_TOK_PROLOG_S
:
1006 return XML_ROLE_ELEMENT_NONE
;
1008 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_EMPTY
)) {
1009 state
->handler
= declClose
;
1010 state
->role_none
= XML_ROLE_ELEMENT_NONE
;
1011 return XML_ROLE_CONTENT_EMPTY
;
1013 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_ANY
)) {
1014 state
->handler
= declClose
;
1015 state
->role_none
= XML_ROLE_ELEMENT_NONE
;
1016 return XML_ROLE_CONTENT_ANY
;
1019 case XML_TOK_OPEN_PAREN
:
1020 state
->handler
= element2
;
1022 return XML_ROLE_GROUP_OPEN
;
1024 return common(state
, tok
);
1028 element2(PROLOG_STATE
*state
,
1032 const ENCODING
*enc
)
1035 case XML_TOK_PROLOG_S
:
1036 return XML_ROLE_ELEMENT_NONE
;
1037 case XML_TOK_POUND_NAME
:
1038 if (XmlNameMatchesAscii(enc
,
1039 ptr
+ MIN_BYTES_PER_CHAR(enc
),
1042 state
->handler
= element3
;
1043 return XML_ROLE_CONTENT_PCDATA
;
1046 case XML_TOK_OPEN_PAREN
:
1048 state
->handler
= element6
;
1049 return XML_ROLE_GROUP_OPEN
;
1051 case XML_TOK_PREFIXED_NAME
:
1052 state
->handler
= element7
;
1053 return XML_ROLE_CONTENT_ELEMENT
;
1054 case XML_TOK_NAME_QUESTION
:
1055 state
->handler
= element7
;
1056 return XML_ROLE_CONTENT_ELEMENT_OPT
;
1057 case XML_TOK_NAME_ASTERISK
:
1058 state
->handler
= element7
;
1059 return XML_ROLE_CONTENT_ELEMENT_REP
;
1060 case XML_TOK_NAME_PLUS
:
1061 state
->handler
= element7
;
1062 return XML_ROLE_CONTENT_ELEMENT_PLUS
;
1064 return common(state
, tok
);
1068 element3(PROLOG_STATE
*state
,
1072 const ENCODING
*enc
)
1075 case XML_TOK_PROLOG_S
:
1076 return XML_ROLE_ELEMENT_NONE
;
1077 case XML_TOK_CLOSE_PAREN
:
1078 state
->handler
= declClose
;
1079 state
->role_none
= XML_ROLE_ELEMENT_NONE
;
1080 return XML_ROLE_GROUP_CLOSE
;
1081 case XML_TOK_CLOSE_PAREN_ASTERISK
:
1082 state
->handler
= declClose
;
1083 state
->role_none
= XML_ROLE_ELEMENT_NONE
;
1084 return XML_ROLE_GROUP_CLOSE_REP
;
1086 state
->handler
= element4
;
1087 return XML_ROLE_ELEMENT_NONE
;
1089 return common(state
, tok
);
1093 element4(PROLOG_STATE
*state
,
1097 const ENCODING
*enc
)
1100 case XML_TOK_PROLOG_S
:
1101 return XML_ROLE_ELEMENT_NONE
;
1103 case XML_TOK_PREFIXED_NAME
:
1104 state
->handler
= element5
;
1105 return XML_ROLE_CONTENT_ELEMENT
;
1107 return common(state
, tok
);
1111 element5(PROLOG_STATE
*state
,
1115 const ENCODING
*enc
)
1118 case XML_TOK_PROLOG_S
:
1119 return XML_ROLE_ELEMENT_NONE
;
1120 case XML_TOK_CLOSE_PAREN_ASTERISK
:
1121 state
->handler
= declClose
;
1122 state
->role_none
= XML_ROLE_ELEMENT_NONE
;
1123 return XML_ROLE_GROUP_CLOSE_REP
;
1125 state
->handler
= element4
;
1126 return XML_ROLE_ELEMENT_NONE
;
1128 return common(state
, tok
);
1132 element6(PROLOG_STATE
*state
,
1136 const ENCODING
*enc
)
1139 case XML_TOK_PROLOG_S
:
1140 return XML_ROLE_ELEMENT_NONE
;
1141 case XML_TOK_OPEN_PAREN
:
1143 return XML_ROLE_GROUP_OPEN
;
1145 case XML_TOK_PREFIXED_NAME
:
1146 state
->handler
= element7
;
1147 return XML_ROLE_CONTENT_ELEMENT
;
1148 case XML_TOK_NAME_QUESTION
:
1149 state
->handler
= element7
;
1150 return XML_ROLE_CONTENT_ELEMENT_OPT
;
1151 case XML_TOK_NAME_ASTERISK
:
1152 state
->handler
= element7
;
1153 return XML_ROLE_CONTENT_ELEMENT_REP
;
1154 case XML_TOK_NAME_PLUS
:
1155 state
->handler
= element7
;
1156 return XML_ROLE_CONTENT_ELEMENT_PLUS
;
1158 return common(state
, tok
);
1162 element7(PROLOG_STATE
*state
,
1166 const ENCODING
*enc
)
1169 case XML_TOK_PROLOG_S
:
1170 return XML_ROLE_ELEMENT_NONE
;
1171 case XML_TOK_CLOSE_PAREN
:
1173 if (state
->level
== 0) {
1174 state
->handler
= declClose
;
1175 state
->role_none
= XML_ROLE_ELEMENT_NONE
;
1177 return XML_ROLE_GROUP_CLOSE
;
1178 case XML_TOK_CLOSE_PAREN_ASTERISK
:
1180 if (state
->level
== 0) {
1181 state
->handler
= declClose
;
1182 state
->role_none
= XML_ROLE_ELEMENT_NONE
;
1184 return XML_ROLE_GROUP_CLOSE_REP
;
1185 case XML_TOK_CLOSE_PAREN_QUESTION
:
1187 if (state
->level
== 0) {
1188 state
->handler
= declClose
;
1189 state
->role_none
= XML_ROLE_ELEMENT_NONE
;
1191 return XML_ROLE_GROUP_CLOSE_OPT
;
1192 case XML_TOK_CLOSE_PAREN_PLUS
:
1194 if (state
->level
== 0) {
1195 state
->handler
= declClose
;
1196 state
->role_none
= XML_ROLE_ELEMENT_NONE
;
1198 return XML_ROLE_GROUP_CLOSE_PLUS
;
1200 state
->handler
= element6
;
1201 return XML_ROLE_GROUP_SEQUENCE
;
1203 state
->handler
= element6
;
1204 return XML_ROLE_GROUP_CHOICE
;
1206 return common(state
, tok
);
1212 condSect0(PROLOG_STATE
*state
,
1216 const ENCODING
*enc
)
1219 case XML_TOK_PROLOG_S
:
1220 return XML_ROLE_NONE
;
1222 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_INCLUDE
)) {
1223 state
->handler
= condSect1
;
1224 return XML_ROLE_NONE
;
1226 if (XmlNameMatchesAscii(enc
, ptr
, end
, KW_IGNORE
)) {
1227 state
->handler
= condSect2
;
1228 return XML_ROLE_NONE
;
1232 return common(state
, tok
);
1236 condSect1(PROLOG_STATE
*state
,
1240 const ENCODING
*enc
)
1243 case XML_TOK_PROLOG_S
:
1244 return XML_ROLE_NONE
;
1245 case XML_TOK_OPEN_BRACKET
:
1246 state
->handler
= externalSubset1
;
1247 state
->includeLevel
+= 1;
1248 return XML_ROLE_NONE
;
1250 return common(state
, tok
);
1254 condSect2(PROLOG_STATE
*state
,
1258 const ENCODING
*enc
)
1261 case XML_TOK_PROLOG_S
:
1262 return XML_ROLE_NONE
;
1263 case XML_TOK_OPEN_BRACKET
:
1264 state
->handler
= externalSubset1
;
1265 return XML_ROLE_IGNORE_SECT
;
1267 return common(state
, tok
);
1270 #endif /* XML_DTD */
1273 declClose(PROLOG_STATE
*state
,
1277 const ENCODING
*enc
)
1280 case XML_TOK_PROLOG_S
:
1281 return state
->role_none
;
1282 case XML_TOK_DECL_CLOSE
:
1284 return state
->role_none
;
1286 return common(state
, tok
);
1290 error(PROLOG_STATE
*state
,
1294 const ENCODING
*enc
)
1296 return XML_ROLE_NONE
;
1300 common(PROLOG_STATE
*state
, int tok
)
1303 if (!state
->documentEntity
&& tok
== XML_TOK_PARAM_ENTITY_REF
)
1304 return XML_ROLE_INNER_PARAM_ENTITY_REF
;
1306 state
->handler
= error
;
1307 return XML_ROLE_ERROR
;
1311 XmlPrologStateInit(PROLOG_STATE
*state
)
1313 state
->handler
= prolog0
;
1315 state
->documentEntity
= 1;
1316 state
->includeLevel
= 0;
1317 state
->inEntityValue
= 0;
1318 #endif /* XML_DTD */
1324 XmlPrologStateInitExternalEntity(PROLOG_STATE
*state
)
1326 state
->handler
= externalSubset0
;
1327 state
->documentEntity
= 0;
1328 state
->includeLevel
= 0;
1331 #endif /* XML_DTD */