4 / _ \\ /| '_ \ / _` | __|
5 | __// \| |_) | (_| | |_
6 \___/_/\_\ .__/ \__,_|\__|
9 Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
10 Copyright (c) 2000-2017 Expat development team
11 Licensed under the MIT license:
13 Permission is hereby granted, free of charge, to any person obtaining
14 a copy of this software and associated documentation files (the
15 "Software"), to deal in the Software without restriction, including
16 without limitation the rights to use, copy, modify, merge, publish,
17 distribute, sublicense, and/or sell copies of the Software, and to permit
18 persons to whom the Software is furnished to do so, subject to the
21 The above copyright notice and this permission notice shall be included
22 in all copies or substantial portions of the Software.
24 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
27 NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
28 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
29 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
30 USE OR OTHER DEALINGS IN THE SOFTWARE.
36 #include "winconfig.h"
38 #ifdef HAVE_EXPAT_CONFIG_H
39 #include <expat_config.h>
41 #endif /* ndef _WIN32 */
43 #include "expat_external.h"
50 that ,| are not mixed in a model group
55 static const char KW_ANY[] = {
56 ASCII_A, ASCII_N, ASCII_Y, '\0' };
57 static const char KW_ATTLIST[] = {
58 ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' };
59 static const char KW_CDATA[] = {
60 ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
61 static const char KW_DOCTYPE[] = {
62 ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' };
63 static const char KW_ELEMENT[] = {
64 ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' };
65 static const char KW_EMPTY[] = {
66 ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' };
67 static const char KW_ENTITIES[] = {
68 ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S,
70 static const char KW_ENTITY[] = {
71 ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
72 static const char KW_FIXED[] = {
73 ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' };
74 static const char KW_ID[] = {
75 ASCII_I, ASCII_D, '\0' };
76 static const char KW_IDREF[] = {
77 ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
78 static const char KW_IDREFS[] = {
79 ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
81 static const char KW_IGNORE[] = {
82 ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' };
84 static const char KW_IMPLIED[] = {
85 ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' };
87 static const char KW_INCLUDE[] = {
88 ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' };
90 static const char KW_NDATA[] = {
91 ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
92 static const char KW_NMTOKEN[] = {
93 ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
94 static const char KW_NMTOKENS[] = {
95 ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S,
97 static const char KW_NOTATION[] =
98 { ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N,
100 static const char KW_PCDATA[] = {
101 ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
102 static const char KW_PUBLIC[] = {
103 ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' };
104 static const char KW_REQUIRED[] = {
105 ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D,
107 static const char KW_SYSTEM[] = {
108 ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' };
110 #ifndef MIN_BYTES_PER_CHAR
111 #define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
115 #define setTopLevel(state) \
116 ((state)->handler = ((state)->documentEntity \
119 #else /* not XML_DTD */
120 #define setTopLevel(state) ((state)->handler = internalSubset)
121 #endif /* not XML_DTD */
123 typedef int PTRCALL PROLOG_HANDLER(PROLOG_STATE *state,
127 const ENCODING *enc);
129 static PROLOG_HANDLER
130 prolog0, prolog1, prolog2,
131 doctype0, doctype1, doctype2, doctype3, doctype4, doctype5,
133 entity0, entity1, entity2, entity3, entity4, entity5, entity6,
134 entity7, entity8, entity9, entity10,
135 notation0, notation1, notation2, notation3, notation4,
136 attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6,
137 attlist7, attlist8, attlist9,
138 element0, element1, element2, element3, element4, element5, element6,
141 externalSubset0, externalSubset1,
142 condSect0, condSect1, condSect2,
147 static int FASTCALL common(PROLOG_STATE *state, int tok);
150 prolog0(PROLOG_STATE *state,
157 case XML_TOK_PROLOG_S:
158 state->handler = prolog1;
159 return XML_ROLE_NONE;
160 case XML_TOK_XML_DECL:
161 state->handler = prolog1;
162 return XML_ROLE_XML_DECL;
164 state->handler = prolog1;
166 case XML_TOK_COMMENT:
167 state->handler = prolog1;
168 return XML_ROLE_COMMENT;
170 return XML_ROLE_NONE;
171 case XML_TOK_DECL_OPEN:
172 if (!XmlNameMatchesAscii(enc,
173 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
177 state->handler = doctype0;
178 return XML_ROLE_DOCTYPE_NONE;
179 case XML_TOK_INSTANCE_START:
180 state->handler = error;
181 return XML_ROLE_INSTANCE_START;
183 return common(state, tok);
187 prolog1(PROLOG_STATE *state,
194 case XML_TOK_PROLOG_S:
195 return XML_ROLE_NONE;
198 case XML_TOK_COMMENT:
199 return XML_ROLE_COMMENT;
201 /* This case can never arise. To reach this role function, the
202 * parse must have passed through prolog0 and therefore have had
203 * some form of input, even if only a space. At that point, a
204 * byte order mark is no longer a valid character (though
205 * technically it should be interpreted as a non-breaking space),
206 * so will be rejected by the tokenizing stages.
208 return XML_ROLE_NONE; /* LCOV_EXCL_LINE */
209 case XML_TOK_DECL_OPEN:
210 if (!XmlNameMatchesAscii(enc,
211 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
215 state->handler = doctype0;
216 return XML_ROLE_DOCTYPE_NONE;
217 case XML_TOK_INSTANCE_START:
218 state->handler = error;
219 return XML_ROLE_INSTANCE_START;
221 return common(state, tok);
225 prolog2(PROLOG_STATE *state,
227 const char *UNUSED_P(ptr),
228 const char *UNUSED_P(end),
229 const ENCODING *UNUSED_P(enc))
232 case XML_TOK_PROLOG_S:
233 return XML_ROLE_NONE;
236 case XML_TOK_COMMENT:
237 return XML_ROLE_COMMENT;
238 case XML_TOK_INSTANCE_START:
239 state->handler = error;
240 return XML_ROLE_INSTANCE_START;
242 return common(state, tok);
246 doctype0(PROLOG_STATE *state,
248 const char *UNUSED_P(ptr),
249 const char *UNUSED_P(end),
250 const ENCODING *UNUSED_P(enc))
253 case XML_TOK_PROLOG_S:
254 return XML_ROLE_DOCTYPE_NONE;
256 case XML_TOK_PREFIXED_NAME:
257 state->handler = doctype1;
258 return XML_ROLE_DOCTYPE_NAME;
260 return common(state, tok);
264 doctype1(PROLOG_STATE *state,
271 case XML_TOK_PROLOG_S:
272 return XML_ROLE_DOCTYPE_NONE;
273 case XML_TOK_OPEN_BRACKET:
274 state->handler = internalSubset;
275 return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
276 case XML_TOK_DECL_CLOSE:
277 state->handler = prolog2;
278 return XML_ROLE_DOCTYPE_CLOSE;
280 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
281 state->handler = doctype3;
282 return XML_ROLE_DOCTYPE_NONE;
284 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
285 state->handler = doctype2;
286 return XML_ROLE_DOCTYPE_NONE;
290 return common(state, tok);
294 doctype2(PROLOG_STATE *state,
296 const char *UNUSED_P(ptr),
297 const char *UNUSED_P(end),
298 const ENCODING *UNUSED_P(enc))
301 case XML_TOK_PROLOG_S:
302 return XML_ROLE_DOCTYPE_NONE;
303 case XML_TOK_LITERAL:
304 state->handler = doctype3;
305 return XML_ROLE_DOCTYPE_PUBLIC_ID;
307 return common(state, tok);
311 doctype3(PROLOG_STATE *state,
313 const char *UNUSED_P(ptr),
314 const char *UNUSED_P(end),
315 const ENCODING *UNUSED_P(enc))
318 case XML_TOK_PROLOG_S:
319 return XML_ROLE_DOCTYPE_NONE;
320 case XML_TOK_LITERAL:
321 state->handler = doctype4;
322 return XML_ROLE_DOCTYPE_SYSTEM_ID;
324 return common(state, tok);
328 doctype4(PROLOG_STATE *state,
330 const char *UNUSED_P(ptr),
331 const char *UNUSED_P(end),
332 const ENCODING *UNUSED_P(enc))
335 case XML_TOK_PROLOG_S:
336 return XML_ROLE_DOCTYPE_NONE;
337 case XML_TOK_OPEN_BRACKET:
338 state->handler = internalSubset;
339 return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
340 case XML_TOK_DECL_CLOSE:
341 state->handler = prolog2;
342 return XML_ROLE_DOCTYPE_CLOSE;
344 return common(state, tok);
348 doctype5(PROLOG_STATE *state,
350 const char *UNUSED_P(ptr),
351 const char *UNUSED_P(end),
352 const ENCODING *UNUSED_P(enc))
355 case XML_TOK_PROLOG_S:
356 return XML_ROLE_DOCTYPE_NONE;
357 case XML_TOK_DECL_CLOSE:
358 state->handler = prolog2;
359 return XML_ROLE_DOCTYPE_CLOSE;
361 return common(state, tok);
365 internalSubset(PROLOG_STATE *state,
372 case XML_TOK_PROLOG_S:
373 return XML_ROLE_NONE;
374 case XML_TOK_DECL_OPEN:
375 if (XmlNameMatchesAscii(enc,
376 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
379 state->handler = entity0;
380 return XML_ROLE_ENTITY_NONE;
382 if (XmlNameMatchesAscii(enc,
383 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
386 state->handler = attlist0;
387 return XML_ROLE_ATTLIST_NONE;
389 if (XmlNameMatchesAscii(enc,
390 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
393 state->handler = element0;
394 return XML_ROLE_ELEMENT_NONE;
396 if (XmlNameMatchesAscii(enc,
397 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
400 state->handler = notation0;
401 return XML_ROLE_NOTATION_NONE;
406 case XML_TOK_COMMENT:
407 return XML_ROLE_COMMENT;
408 case XML_TOK_PARAM_ENTITY_REF:
409 return XML_ROLE_PARAM_ENTITY_REF;
410 case XML_TOK_CLOSE_BRACKET:
411 state->handler = doctype5;
412 return XML_ROLE_DOCTYPE_NONE;
414 return XML_ROLE_NONE;
416 return common(state, tok);
422 externalSubset0(PROLOG_STATE *state,
428 state->handler = externalSubset1;
429 if (tok == XML_TOK_XML_DECL)
430 return XML_ROLE_TEXT_DECL;
431 return externalSubset1(state, tok, ptr, end, enc);
435 externalSubset1(PROLOG_STATE *state,
442 case XML_TOK_COND_SECT_OPEN:
443 state->handler = condSect0;
444 return XML_ROLE_NONE;
445 case XML_TOK_COND_SECT_CLOSE:
446 if (state->includeLevel == 0)
448 state->includeLevel -= 1;
449 return XML_ROLE_NONE;
450 case XML_TOK_PROLOG_S:
451 return XML_ROLE_NONE;
452 case XML_TOK_CLOSE_BRACKET:
455 if (state->includeLevel)
457 return XML_ROLE_NONE;
459 return internalSubset(state, tok, ptr, end, enc);
461 return common(state, tok);
467 entity0(PROLOG_STATE *state,
469 const char *UNUSED_P(ptr),
470 const char *UNUSED_P(end),
471 const ENCODING *UNUSED_P(enc))
474 case XML_TOK_PROLOG_S:
475 return XML_ROLE_ENTITY_NONE;
476 case XML_TOK_PERCENT:
477 state->handler = entity1;
478 return XML_ROLE_ENTITY_NONE;
480 state->handler = entity2;
481 return XML_ROLE_GENERAL_ENTITY_NAME;
483 return common(state, tok);
487 entity1(PROLOG_STATE *state,
489 const char *UNUSED_P(ptr),
490 const char *UNUSED_P(end),
491 const ENCODING *UNUSED_P(enc))
494 case XML_TOK_PROLOG_S:
495 return XML_ROLE_ENTITY_NONE;
497 state->handler = entity7;
498 return XML_ROLE_PARAM_ENTITY_NAME;
500 return common(state, tok);
504 entity2(PROLOG_STATE *state,
511 case XML_TOK_PROLOG_S:
512 return XML_ROLE_ENTITY_NONE;
514 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
515 state->handler = entity4;
516 return XML_ROLE_ENTITY_NONE;
518 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
519 state->handler = entity3;
520 return XML_ROLE_ENTITY_NONE;
523 case XML_TOK_LITERAL:
524 state->handler = declClose;
525 state->role_none = XML_ROLE_ENTITY_NONE;
526 return XML_ROLE_ENTITY_VALUE;
528 return common(state, tok);
532 entity3(PROLOG_STATE *state,
534 const char *UNUSED_P(ptr),
535 const char *UNUSED_P(end),
536 const ENCODING *UNUSED_P(enc))
539 case XML_TOK_PROLOG_S:
540 return XML_ROLE_ENTITY_NONE;
541 case XML_TOK_LITERAL:
542 state->handler = entity4;
543 return XML_ROLE_ENTITY_PUBLIC_ID;
545 return common(state, tok);
549 entity4(PROLOG_STATE *state,
551 const char *UNUSED_P(ptr),
552 const char *UNUSED_P(end),
553 const ENCODING *UNUSED_P(enc))
556 case XML_TOK_PROLOG_S:
557 return XML_ROLE_ENTITY_NONE;
558 case XML_TOK_LITERAL:
559 state->handler = entity5;
560 return XML_ROLE_ENTITY_SYSTEM_ID;
562 return common(state, tok);
566 entity5(PROLOG_STATE *state,
573 case XML_TOK_PROLOG_S:
574 return XML_ROLE_ENTITY_NONE;
575 case XML_TOK_DECL_CLOSE:
577 return XML_ROLE_ENTITY_COMPLETE;
579 if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
580 state->handler = entity6;
581 return XML_ROLE_ENTITY_NONE;
585 return common(state, tok);
589 entity6(PROLOG_STATE *state,
591 const char *UNUSED_P(ptr),
592 const char *UNUSED_P(end),
593 const ENCODING *UNUSED_P(enc))
596 case XML_TOK_PROLOG_S:
597 return XML_ROLE_ENTITY_NONE;
599 state->handler = declClose;
600 state->role_none = XML_ROLE_ENTITY_NONE;
601 return XML_ROLE_ENTITY_NOTATION_NAME;
603 return common(state, tok);
607 entity7(PROLOG_STATE *state,
614 case XML_TOK_PROLOG_S:
615 return XML_ROLE_ENTITY_NONE;
617 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
618 state->handler = entity9;
619 return XML_ROLE_ENTITY_NONE;
621 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
622 state->handler = entity8;
623 return XML_ROLE_ENTITY_NONE;
626 case XML_TOK_LITERAL:
627 state->handler = declClose;
628 state->role_none = XML_ROLE_ENTITY_NONE;
629 return XML_ROLE_ENTITY_VALUE;
631 return common(state, tok);
635 entity8(PROLOG_STATE *state,
637 const char *UNUSED_P(ptr),
638 const char *UNUSED_P(end),
639 const ENCODING *UNUSED_P(enc))
642 case XML_TOK_PROLOG_S:
643 return XML_ROLE_ENTITY_NONE;
644 case XML_TOK_LITERAL:
645 state->handler = entity9;
646 return XML_ROLE_ENTITY_PUBLIC_ID;
648 return common(state, tok);
652 entity9(PROLOG_STATE *state,
654 const char *UNUSED_P(ptr),
655 const char *UNUSED_P(end),
656 const ENCODING *UNUSED_P(enc))
659 case XML_TOK_PROLOG_S:
660 return XML_ROLE_ENTITY_NONE;
661 case XML_TOK_LITERAL:
662 state->handler = entity10;
663 return XML_ROLE_ENTITY_SYSTEM_ID;
665 return common(state, tok);
669 entity10(PROLOG_STATE *state,
671 const char *UNUSED_P(ptr),
672 const char *UNUSED_P(end),
673 const ENCODING *UNUSED_P(enc))
676 case XML_TOK_PROLOG_S:
677 return XML_ROLE_ENTITY_NONE;
678 case XML_TOK_DECL_CLOSE:
680 return XML_ROLE_ENTITY_COMPLETE;
682 return common(state, tok);
686 notation0(PROLOG_STATE *state,
688 const char *UNUSED_P(ptr),
689 const char *UNUSED_P(end),
690 const ENCODING *UNUSED_P(enc))
693 case XML_TOK_PROLOG_S:
694 return XML_ROLE_NOTATION_NONE;
696 state->handler = notation1;
697 return XML_ROLE_NOTATION_NAME;
699 return common(state, tok);
703 notation1(PROLOG_STATE *state,
710 case XML_TOK_PROLOG_S:
711 return XML_ROLE_NOTATION_NONE;
713 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
714 state->handler = notation3;
715 return XML_ROLE_NOTATION_NONE;
717 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
718 state->handler = notation2;
719 return XML_ROLE_NOTATION_NONE;
723 return common(state, tok);
727 notation2(PROLOG_STATE *state,
729 const char *UNUSED_P(ptr),
730 const char *UNUSED_P(end),
731 const ENCODING *UNUSED_P(enc))
734 case XML_TOK_PROLOG_S:
735 return XML_ROLE_NOTATION_NONE;
736 case XML_TOK_LITERAL:
737 state->handler = notation4;
738 return XML_ROLE_NOTATION_PUBLIC_ID;
740 return common(state, tok);
744 notation3(PROLOG_STATE *state,
746 const char *UNUSED_P(ptr),
747 const char *UNUSED_P(end),
748 const ENCODING *UNUSED_P(enc))
751 case XML_TOK_PROLOG_S:
752 return XML_ROLE_NOTATION_NONE;
753 case XML_TOK_LITERAL:
754 state->handler = declClose;
755 state->role_none = XML_ROLE_NOTATION_NONE;
756 return XML_ROLE_NOTATION_SYSTEM_ID;
758 return common(state, tok);
762 notation4(PROLOG_STATE *state,
764 const char *UNUSED_P(ptr),
765 const char *UNUSED_P(end),
766 const ENCODING *UNUSED_P(enc))
769 case XML_TOK_PROLOG_S:
770 return XML_ROLE_NOTATION_NONE;
771 case XML_TOK_LITERAL:
772 state->handler = declClose;
773 state->role_none = XML_ROLE_NOTATION_NONE;
774 return XML_ROLE_NOTATION_SYSTEM_ID;
775 case XML_TOK_DECL_CLOSE:
777 return XML_ROLE_NOTATION_NO_SYSTEM_ID;
779 return common(state, tok);
783 attlist0(PROLOG_STATE *state,
785 const char *UNUSED_P(ptr),
786 const char *UNUSED_P(end),
787 const ENCODING *UNUSED_P(enc))
790 case XML_TOK_PROLOG_S:
791 return XML_ROLE_ATTLIST_NONE;
793 case XML_TOK_PREFIXED_NAME:
794 state->handler = attlist1;
795 return XML_ROLE_ATTLIST_ELEMENT_NAME;
797 return common(state, tok);
801 attlist1(PROLOG_STATE *state,
803 const char *UNUSED_P(ptr),
804 const char *UNUSED_P(end),
805 const ENCODING *UNUSED_P(enc))
808 case XML_TOK_PROLOG_S:
809 return XML_ROLE_ATTLIST_NONE;
810 case XML_TOK_DECL_CLOSE:
812 return XML_ROLE_ATTLIST_NONE;
814 case XML_TOK_PREFIXED_NAME:
815 state->handler = attlist2;
816 return XML_ROLE_ATTRIBUTE_NAME;
818 return common(state, tok);
822 attlist2(PROLOG_STATE *state,
829 case XML_TOK_PROLOG_S:
830 return XML_ROLE_ATTLIST_NONE;
833 static const char * const types[] = {
844 for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
845 if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
846 state->handler = attlist8;
847 return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
850 if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
851 state->handler = attlist5;
852 return XML_ROLE_ATTLIST_NONE;
855 case XML_TOK_OPEN_PAREN:
856 state->handler = attlist3;
857 return XML_ROLE_ATTLIST_NONE;
859 return common(state, tok);
863 attlist3(PROLOG_STATE *state,
865 const char *UNUSED_P(ptr),
866 const char *UNUSED_P(end),
867 const ENCODING *UNUSED_P(enc))
870 case XML_TOK_PROLOG_S:
871 return XML_ROLE_ATTLIST_NONE;
872 case XML_TOK_NMTOKEN:
874 case XML_TOK_PREFIXED_NAME:
875 state->handler = attlist4;
876 return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
878 return common(state, tok);
882 attlist4(PROLOG_STATE *state,
884 const char *UNUSED_P(ptr),
885 const char *UNUSED_P(end),
886 const ENCODING *UNUSED_P(enc))
889 case XML_TOK_PROLOG_S:
890 return XML_ROLE_ATTLIST_NONE;
891 case XML_TOK_CLOSE_PAREN:
892 state->handler = attlist8;
893 return XML_ROLE_ATTLIST_NONE;
895 state->handler = attlist3;
896 return XML_ROLE_ATTLIST_NONE;
898 return common(state, tok);
902 attlist5(PROLOG_STATE *state,
904 const char *UNUSED_P(ptr),
905 const char *UNUSED_P(end),
906 const ENCODING *UNUSED_P(enc))
909 case XML_TOK_PROLOG_S:
910 return XML_ROLE_ATTLIST_NONE;
911 case XML_TOK_OPEN_PAREN:
912 state->handler = attlist6;
913 return XML_ROLE_ATTLIST_NONE;
915 return common(state, tok);
919 attlist6(PROLOG_STATE *state,
921 const char *UNUSED_P(ptr),
922 const char *UNUSED_P(end),
923 const ENCODING *UNUSED_P(enc))
926 case XML_TOK_PROLOG_S:
927 return XML_ROLE_ATTLIST_NONE;
929 state->handler = attlist7;
930 return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
932 return common(state, tok);
936 attlist7(PROLOG_STATE *state,
938 const char *UNUSED_P(ptr),
939 const char *UNUSED_P(end),
940 const ENCODING *UNUSED_P(enc))
943 case XML_TOK_PROLOG_S:
944 return XML_ROLE_ATTLIST_NONE;
945 case XML_TOK_CLOSE_PAREN:
946 state->handler = attlist8;
947 return XML_ROLE_ATTLIST_NONE;
949 state->handler = attlist6;
950 return XML_ROLE_ATTLIST_NONE;
952 return common(state, tok);
957 attlist8(PROLOG_STATE *state,
964 case XML_TOK_PROLOG_S:
965 return XML_ROLE_ATTLIST_NONE;
966 case XML_TOK_POUND_NAME:
967 if (XmlNameMatchesAscii(enc,
968 ptr + MIN_BYTES_PER_CHAR(enc),
971 state->handler = attlist1;
972 return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
974 if (XmlNameMatchesAscii(enc,
975 ptr + MIN_BYTES_PER_CHAR(enc),
978 state->handler = attlist1;
979 return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
981 if (XmlNameMatchesAscii(enc,
982 ptr + MIN_BYTES_PER_CHAR(enc),
985 state->handler = attlist9;
986 return XML_ROLE_ATTLIST_NONE;
989 case XML_TOK_LITERAL:
990 state->handler = attlist1;
991 return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
993 return common(state, tok);
997 attlist9(PROLOG_STATE *state,
999 const char *UNUSED_P(ptr),
1000 const char *UNUSED_P(end),
1001 const ENCODING *UNUSED_P(enc))
1004 case XML_TOK_PROLOG_S:
1005 return XML_ROLE_ATTLIST_NONE;
1006 case XML_TOK_LITERAL:
1007 state->handler = attlist1;
1008 return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
1010 return common(state, tok);
1014 element0(PROLOG_STATE *state,
1016 const char *UNUSED_P(ptr),
1017 const char *UNUSED_P(end),
1018 const ENCODING *UNUSED_P(enc))
1021 case XML_TOK_PROLOG_S:
1022 return XML_ROLE_ELEMENT_NONE;
1024 case XML_TOK_PREFIXED_NAME:
1025 state->handler = element1;
1026 return XML_ROLE_ELEMENT_NAME;
1028 return common(state, tok);
1032 element1(PROLOG_STATE *state,
1036 const ENCODING *enc)
1039 case XML_TOK_PROLOG_S:
1040 return XML_ROLE_ELEMENT_NONE;
1042 if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
1043 state->handler = declClose;
1044 state->role_none = XML_ROLE_ELEMENT_NONE;
1045 return XML_ROLE_CONTENT_EMPTY;
1047 if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
1048 state->handler = declClose;
1049 state->role_none = XML_ROLE_ELEMENT_NONE;
1050 return XML_ROLE_CONTENT_ANY;
1053 case XML_TOK_OPEN_PAREN:
1054 state->handler = element2;
1056 return XML_ROLE_GROUP_OPEN;
1058 return common(state, tok);
1062 element2(PROLOG_STATE *state,
1066 const ENCODING *enc)
1069 case XML_TOK_PROLOG_S:
1070 return XML_ROLE_ELEMENT_NONE;
1071 case XML_TOK_POUND_NAME:
1072 if (XmlNameMatchesAscii(enc,
1073 ptr + MIN_BYTES_PER_CHAR(enc),
1076 state->handler = element3;
1077 return XML_ROLE_CONTENT_PCDATA;
1080 case XML_TOK_OPEN_PAREN:
1082 state->handler = element6;
1083 return XML_ROLE_GROUP_OPEN;
1085 case XML_TOK_PREFIXED_NAME:
1086 state->handler = element7;
1087 return XML_ROLE_CONTENT_ELEMENT;
1088 case XML_TOK_NAME_QUESTION:
1089 state->handler = element7;
1090 return XML_ROLE_CONTENT_ELEMENT_OPT;
1091 case XML_TOK_NAME_ASTERISK:
1092 state->handler = element7;
1093 return XML_ROLE_CONTENT_ELEMENT_REP;
1094 case XML_TOK_NAME_PLUS:
1095 state->handler = element7;
1096 return XML_ROLE_CONTENT_ELEMENT_PLUS;
1098 return common(state, tok);
1102 element3(PROLOG_STATE *state,
1104 const char *UNUSED_P(ptr),
1105 const char *UNUSED_P(end),
1106 const ENCODING *UNUSED_P(enc))
1109 case XML_TOK_PROLOG_S:
1110 return XML_ROLE_ELEMENT_NONE;
1111 case XML_TOK_CLOSE_PAREN:
1112 state->handler = declClose;
1113 state->role_none = XML_ROLE_ELEMENT_NONE;
1114 return XML_ROLE_GROUP_CLOSE;
1115 case XML_TOK_CLOSE_PAREN_ASTERISK:
1116 state->handler = declClose;
1117 state->role_none = XML_ROLE_ELEMENT_NONE;
1118 return XML_ROLE_GROUP_CLOSE_REP;
1120 state->handler = element4;
1121 return XML_ROLE_ELEMENT_NONE;
1123 return common(state, tok);
1127 element4(PROLOG_STATE *state,
1129 const char *UNUSED_P(ptr),
1130 const char *UNUSED_P(end),
1131 const ENCODING *UNUSED_P(enc))
1134 case XML_TOK_PROLOG_S:
1135 return XML_ROLE_ELEMENT_NONE;
1137 case XML_TOK_PREFIXED_NAME:
1138 state->handler = element5;
1139 return XML_ROLE_CONTENT_ELEMENT;
1141 return common(state, tok);
1145 element5(PROLOG_STATE *state,
1147 const char *UNUSED_P(ptr),
1148 const char *UNUSED_P(end),
1149 const ENCODING *UNUSED_P(enc))
1152 case XML_TOK_PROLOG_S:
1153 return XML_ROLE_ELEMENT_NONE;
1154 case XML_TOK_CLOSE_PAREN_ASTERISK:
1155 state->handler = declClose;
1156 state->role_none = XML_ROLE_ELEMENT_NONE;
1157 return XML_ROLE_GROUP_CLOSE_REP;
1159 state->handler = element4;
1160 return XML_ROLE_ELEMENT_NONE;
1162 return common(state, tok);
1166 element6(PROLOG_STATE *state,
1168 const char *UNUSED_P(ptr),
1169 const char *UNUSED_P(end),
1170 const ENCODING *UNUSED_P(enc))
1173 case XML_TOK_PROLOG_S:
1174 return XML_ROLE_ELEMENT_NONE;
1175 case XML_TOK_OPEN_PAREN:
1177 return XML_ROLE_GROUP_OPEN;
1179 case XML_TOK_PREFIXED_NAME:
1180 state->handler = element7;
1181 return XML_ROLE_CONTENT_ELEMENT;
1182 case XML_TOK_NAME_QUESTION:
1183 state->handler = element7;
1184 return XML_ROLE_CONTENT_ELEMENT_OPT;
1185 case XML_TOK_NAME_ASTERISK:
1186 state->handler = element7;
1187 return XML_ROLE_CONTENT_ELEMENT_REP;
1188 case XML_TOK_NAME_PLUS:
1189 state->handler = element7;
1190 return XML_ROLE_CONTENT_ELEMENT_PLUS;
1192 return common(state, tok);
1196 element7(PROLOG_STATE *state,
1198 const char *UNUSED_P(ptr),
1199 const char *UNUSED_P(end),
1200 const ENCODING *UNUSED_P(enc))
1203 case XML_TOK_PROLOG_S:
1204 return XML_ROLE_ELEMENT_NONE;
1205 case XML_TOK_CLOSE_PAREN:
1207 if (state->level == 0) {
1208 state->handler = declClose;
1209 state->role_none = XML_ROLE_ELEMENT_NONE;
1211 return XML_ROLE_GROUP_CLOSE;
1212 case XML_TOK_CLOSE_PAREN_ASTERISK:
1214 if (state->level == 0) {
1215 state->handler = declClose;
1216 state->role_none = XML_ROLE_ELEMENT_NONE;
1218 return XML_ROLE_GROUP_CLOSE_REP;
1219 case XML_TOK_CLOSE_PAREN_QUESTION:
1221 if (state->level == 0) {
1222 state->handler = declClose;
1223 state->role_none = XML_ROLE_ELEMENT_NONE;
1225 return XML_ROLE_GROUP_CLOSE_OPT;
1226 case XML_TOK_CLOSE_PAREN_PLUS:
1228 if (state->level == 0) {
1229 state->handler = declClose;
1230 state->role_none = XML_ROLE_ELEMENT_NONE;
1232 return XML_ROLE_GROUP_CLOSE_PLUS;
1234 state->handler = element6;
1235 return XML_ROLE_GROUP_SEQUENCE;
1237 state->handler = element6;
1238 return XML_ROLE_GROUP_CHOICE;
1240 return common(state, tok);
1246 condSect0(PROLOG_STATE *state,
1250 const ENCODING *enc)
1253 case XML_TOK_PROLOG_S:
1254 return XML_ROLE_NONE;
1256 if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
1257 state->handler = condSect1;
1258 return XML_ROLE_NONE;
1260 if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
1261 state->handler = condSect2;
1262 return XML_ROLE_NONE;
1266 return common(state, tok);
1270 condSect1(PROLOG_STATE *state,
1272 const char *UNUSED_P(ptr),
1273 const char *UNUSED_P(end),
1274 const ENCODING *UNUSED_P(enc))
1277 case XML_TOK_PROLOG_S:
1278 return XML_ROLE_NONE;
1279 case XML_TOK_OPEN_BRACKET:
1280 state->handler = externalSubset1;
1281 state->includeLevel += 1;
1282 return XML_ROLE_NONE;
1284 return common(state, tok);
1288 condSect2(PROLOG_STATE *state,
1290 const char *UNUSED_P(ptr),
1291 const char *UNUSED_P(end),
1292 const ENCODING *UNUSED_P(enc))
1295 case XML_TOK_PROLOG_S:
1296 return XML_ROLE_NONE;
1297 case XML_TOK_OPEN_BRACKET:
1298 state->handler = externalSubset1;
1299 return XML_ROLE_IGNORE_SECT;
1301 return common(state, tok);
1304 #endif /* XML_DTD */
1307 declClose(PROLOG_STATE *state,
1309 const char *UNUSED_P(ptr),
1310 const char *UNUSED_P(end),
1311 const ENCODING *UNUSED_P(enc))
1314 case XML_TOK_PROLOG_S:
1315 return state->role_none;
1316 case XML_TOK_DECL_CLOSE:
1318 return state->role_none;
1320 return common(state, tok);
1323 /* This function will only be invoked if the internal logic of the
1324 * parser has broken down. It is used in two cases:
1326 * 1: When the XML prolog has been finished. At this point the
1327 * processor (the parser level above these role handlers) should
1328 * switch from prologProcessor to contentProcessor and reinitialise
1329 * the handler function.
1331 * 2: When an error has been detected (via common() below). At this
1332 * point again the processor should be switched to errorProcessor,
1333 * which will never call a handler.
1335 * The result of this is that error() can only be called if the
1336 * processor switch failed to happen, which is an internal error and
1337 * therefore we shouldn't be able to provoke it simply by using the
1338 * library. It is a necessary backstop, however, so we merely exclude
1339 * it from the coverage statistics.
1344 error(PROLOG_STATE *UNUSED_P(state),
1346 const char *UNUSED_P(ptr),
1347 const char *UNUSED_P(end),
1348 const ENCODING *UNUSED_P(enc))
1350 return XML_ROLE_NONE;
1352 /* LCOV_EXCL_STOP */
1355 common(PROLOG_STATE *state, int tok)
1358 if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
1359 return XML_ROLE_INNER_PARAM_ENTITY_REF;
1361 state->handler = error;
1362 return XML_ROLE_ERROR;
1366 XmlPrologStateInit(PROLOG_STATE *state)
1368 state->handler = prolog0;
1370 state->documentEntity = 1;
1371 state->includeLevel = 0;
1372 state->inEntityValue = 0;
1373 #endif /* XML_DTD */
1379 XmlPrologStateInitExternalEntity(PROLOG_STATE *state)
1381 state->handler = externalSubset0;
1382 state->documentEntity = 0;
1383 state->includeLevel = 0;
1386 #endif /* XML_DTD */