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