source: trunk/poppler/expat-1.95.8/lib/xmlrole.c @ 14

Last change on this file since 14 was 2, checked in by Eugene Romanenko, 16 years ago

First import

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