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

Last change on this file since 75 was 75, checked in by umoeller, 24 years ago

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