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