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