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