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