source: trunk/src/helpers/xmlrole.c@ 42

Last change on this file since 42 was 38, checked in by umoeller, 25 years ago

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