source: branches/branch-1-0/src/helpers/xmlrole.c

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

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