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