]> git.saurik.com Git - wxWidgets.git/blob - src/expat/lib/xmlrole.c
projects / wxWidgets.git / blob
? search:


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