Mercurial > ~mikael > mcabber > hg
comparison mcabber/libjabber/xmlrole.c @ 25:bf3d6e241714
[/trunk] Changeset 41 by mikael
* Add libjabber to trunk. Let the game begin! :-)
author | mikael |
---|---|
date | Sun, 27 Mar 2005 20:18:21 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
24:e88b15cbf2de | 25:bf3d6e241714 |
---|---|
1 /* | |
2 The contents of this file are subject to the Mozilla Public License | |
3 Version 1.1 (the "License"); you may not use this file except in | |
4 compliance with the License. You may obtain a copy of the License at | |
5 http://www.mozilla.org/MPL/ | |
6 | |
7 Software distributed under the License is distributed on an "AS IS" | |
8 basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the | |
9 License for the specific language governing rights and limitations | |
10 under the License. | |
11 | |
12 The Original Code is expat. | |
13 | |
14 The Initial Developer of the Original Code is James Clark. | |
15 Portions created by James Clark are Copyright (C) 1998, 1999 | |
16 James Clark. All Rights Reserved. | |
17 | |
18 Contributor(s): | |
19 | |
20 Alternatively, the contents of this file may be used under the terms | |
21 of the GNU General Public License (the "GPL"), in which case the | |
22 provisions of the GPL are applicable instead of those above. If you | |
23 wish to allow use of your version of this file only under the terms of | |
24 the GPL and not to allow others to use your version of this file under | |
25 the MPL, indicate your decision by deleting the provisions above and | |
26 replace them with the notice and other provisions required by the | |
27 GPL. If you do not delete the provisions above, a recipient may use | |
28 your version of this file under either the MPL or the GPL. | |
29 */ | |
30 | |
31 #include "xmldef.h" | |
32 #include "xmlrole.h" | |
33 | |
34 /* Doesn't check: | |
35 | |
36 that ,| are not mixed in a model group | |
37 content of literals | |
38 | |
39 */ | |
40 | |
41 #ifndef MIN_BYTES_PER_CHAR | |
42 #define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar) | |
43 #endif | |
44 | |
45 typedef int PROLOG_HANDLER(struct prolog_state *state, | |
46 int tok, | |
47 const char *ptr, | |
48 const char *end, | |
49 const ENCODING *enc); | |
50 | |
51 static PROLOG_HANDLER | |
52 prolog0, prolog1, prolog2, | |
53 doctype0, doctype1, doctype2, doctype3, doctype4, doctype5, | |
54 internalSubset, | |
55 entity0, entity1, entity2, entity3, entity4, entity5, entity6, | |
56 entity7, entity8, entity9, | |
57 notation0, notation1, notation2, notation3, notation4, | |
58 attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6, | |
59 attlist7, attlist8, attlist9, | |
60 element0, element1, element2, element3, element4, element5, element6, | |
61 element7, | |
62 declClose, | |
63 error; | |
64 | |
65 static | |
66 int syntaxError(PROLOG_STATE *); | |
67 | |
68 static | |
69 int prolog0(PROLOG_STATE *state, | |
70 int tok, | |
71 const char *ptr, | |
72 const char *end, | |
73 const ENCODING *enc) | |
74 { | |
75 switch (tok) { | |
76 case XML_TOK_PROLOG_S: | |
77 state->handler = prolog1; | |
78 return XML_ROLE_NONE; | |
79 case XML_TOK_XML_DECL: | |
80 state->handler = prolog1; | |
81 return XML_ROLE_XML_DECL; | |
82 case XML_TOK_PI: | |
83 state->handler = prolog1; | |
84 return XML_ROLE_NONE; | |
85 case XML_TOK_COMMENT: | |
86 state->handler = prolog1; | |
87 case XML_TOK_BOM: | |
88 return XML_ROLE_NONE; | |
89 case XML_TOK_DECL_OPEN: | |
90 if (!XmlNameMatchesAscii(enc, | |
91 ptr + 2 * MIN_BYTES_PER_CHAR(enc), | |
92 "DOCTYPE")) | |
93 break; | |
94 state->handler = doctype0; | |
95 return XML_ROLE_NONE; | |
96 case XML_TOK_INSTANCE_START: | |
97 state->handler = error; | |
98 return XML_ROLE_INSTANCE_START; | |
99 } | |
100 return syntaxError(state); | |
101 } | |
102 | |
103 static | |
104 int prolog1(PROLOG_STATE *state, | |
105 int tok, | |
106 const char *ptr, | |
107 const char *end, | |
108 const ENCODING *enc) | |
109 { | |
110 switch (tok) { | |
111 case XML_TOK_PROLOG_S: | |
112 return XML_ROLE_NONE; | |
113 case XML_TOK_PI: | |
114 case XML_TOK_COMMENT: | |
115 case XML_TOK_BOM: | |
116 return XML_ROLE_NONE; | |
117 case XML_TOK_DECL_OPEN: | |
118 if (!XmlNameMatchesAscii(enc, | |
119 ptr + 2 * MIN_BYTES_PER_CHAR(enc), | |
120 "DOCTYPE")) | |
121 break; | |
122 state->handler = doctype0; | |
123 return XML_ROLE_NONE; | |
124 case XML_TOK_INSTANCE_START: | |
125 state->handler = error; | |
126 return XML_ROLE_INSTANCE_START; | |
127 } | |
128 return syntaxError(state); | |
129 } | |
130 | |
131 static | |
132 int prolog2(PROLOG_STATE *state, | |
133 int tok, | |
134 const char *ptr, | |
135 const char *end, | |
136 const ENCODING *enc) | |
137 { | |
138 switch (tok) { | |
139 case XML_TOK_PROLOG_S: | |
140 return XML_ROLE_NONE; | |
141 case XML_TOK_PI: | |
142 case XML_TOK_COMMENT: | |
143 return XML_ROLE_NONE; | |
144 case XML_TOK_INSTANCE_START: | |
145 state->handler = error; | |
146 return XML_ROLE_INSTANCE_START; | |
147 } | |
148 return syntaxError(state); | |
149 } | |
150 | |
151 static | |
152 int doctype0(PROLOG_STATE *state, | |
153 int tok, | |
154 const char *ptr, | |
155 const char *end, | |
156 const ENCODING *enc) | |
157 { | |
158 switch (tok) { | |
159 case XML_TOK_PROLOG_S: | |
160 return XML_ROLE_NONE; | |
161 case XML_TOK_NAME: | |
162 case XML_TOK_PREFIXED_NAME: | |
163 state->handler = doctype1; | |
164 return XML_ROLE_DOCTYPE_NAME; | |
165 } | |
166 return syntaxError(state); | |
167 } | |
168 | |
169 static | |
170 int doctype1(PROLOG_STATE *state, | |
171 int tok, | |
172 const char *ptr, | |
173 const char *end, | |
174 const ENCODING *enc) | |
175 { | |
176 switch (tok) { | |
177 case XML_TOK_PROLOG_S: | |
178 return XML_ROLE_NONE; | |
179 case XML_TOK_OPEN_BRACKET: | |
180 state->handler = internalSubset; | |
181 return XML_ROLE_NONE; | |
182 case XML_TOK_DECL_CLOSE: | |
183 state->handler = prolog2; | |
184 return XML_ROLE_DOCTYPE_CLOSE; | |
185 case XML_TOK_NAME: | |
186 if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) { | |
187 state->handler = doctype3; | |
188 return XML_ROLE_NONE; | |
189 } | |
190 if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) { | |
191 state->handler = doctype2; | |
192 return XML_ROLE_NONE; | |
193 } | |
194 break; | |
195 } | |
196 return syntaxError(state); | |
197 } | |
198 | |
199 static | |
200 int doctype2(PROLOG_STATE *state, | |
201 int tok, | |
202 const char *ptr, | |
203 const char *end, | |
204 const ENCODING *enc) | |
205 { | |
206 switch (tok) { | |
207 case XML_TOK_PROLOG_S: | |
208 return XML_ROLE_NONE; | |
209 case XML_TOK_LITERAL: | |
210 state->handler = doctype3; | |
211 return XML_ROLE_DOCTYPE_PUBLIC_ID; | |
212 } | |
213 return syntaxError(state); | |
214 } | |
215 | |
216 static | |
217 int doctype3(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_NONE; | |
226 case XML_TOK_LITERAL: | |
227 state->handler = doctype4; | |
228 return XML_ROLE_DOCTYPE_SYSTEM_ID; | |
229 } | |
230 return syntaxError(state); | |
231 } | |
232 | |
233 static | |
234 int doctype4(PROLOG_STATE *state, | |
235 int tok, | |
236 const char *ptr, | |
237 const char *end, | |
238 const ENCODING *enc) | |
239 { | |
240 switch (tok) { | |
241 case XML_TOK_PROLOG_S: | |
242 return XML_ROLE_NONE; | |
243 case XML_TOK_OPEN_BRACKET: | |
244 state->handler = internalSubset; | |
245 return XML_ROLE_NONE; | |
246 case XML_TOK_DECL_CLOSE: | |
247 state->handler = prolog2; | |
248 return XML_ROLE_DOCTYPE_CLOSE; | |
249 } | |
250 return syntaxError(state); | |
251 } | |
252 | |
253 static | |
254 int doctype5(PROLOG_STATE *state, | |
255 int tok, | |
256 const char *ptr, | |
257 const char *end, | |
258 const ENCODING *enc) | |
259 { | |
260 switch (tok) { | |
261 case XML_TOK_PROLOG_S: | |
262 return XML_ROLE_NONE; | |
263 case XML_TOK_DECL_CLOSE: | |
264 state->handler = prolog2; | |
265 return XML_ROLE_DOCTYPE_CLOSE; | |
266 } | |
267 return syntaxError(state); | |
268 } | |
269 | |
270 static | |
271 int internalSubset(PROLOG_STATE *state, | |
272 int tok, | |
273 const char *ptr, | |
274 const char *end, | |
275 const ENCODING *enc) | |
276 { | |
277 switch (tok) { | |
278 case XML_TOK_PROLOG_S: | |
279 return XML_ROLE_NONE; | |
280 case XML_TOK_DECL_OPEN: | |
281 if (XmlNameMatchesAscii(enc, | |
282 ptr + 2 * MIN_BYTES_PER_CHAR(enc), | |
283 "ENTITY")) { | |
284 state->handler = entity0; | |
285 return XML_ROLE_NONE; | |
286 } | |
287 if (XmlNameMatchesAscii(enc, | |
288 ptr + 2 * MIN_BYTES_PER_CHAR(enc), | |
289 "ATTLIST")) { | |
290 state->handler = attlist0; | |
291 return XML_ROLE_NONE; | |
292 } | |
293 if (XmlNameMatchesAscii(enc, | |
294 ptr + 2 * MIN_BYTES_PER_CHAR(enc), | |
295 "ELEMENT")) { | |
296 state->handler = element0; | |
297 return XML_ROLE_NONE; | |
298 } | |
299 if (XmlNameMatchesAscii(enc, | |
300 ptr + 2 * MIN_BYTES_PER_CHAR(enc), | |
301 "NOTATION")) { | |
302 state->handler = notation0; | |
303 return XML_ROLE_NONE; | |
304 } | |
305 break; | |
306 case XML_TOK_PI: | |
307 case XML_TOK_COMMENT: | |
308 return XML_ROLE_NONE; | |
309 case XML_TOK_PARAM_ENTITY_REF: | |
310 return XML_ROLE_PARAM_ENTITY_REF; | |
311 case XML_TOK_CLOSE_BRACKET: | |
312 state->handler = doctype5; | |
313 return XML_ROLE_NONE; | |
314 } | |
315 return syntaxError(state); | |
316 } | |
317 | |
318 static | |
319 int entity0(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_NONE; | |
328 case XML_TOK_PERCENT: | |
329 state->handler = entity1; | |
330 return XML_ROLE_NONE; | |
331 case XML_TOK_NAME: | |
332 state->handler = entity2; | |
333 return XML_ROLE_GENERAL_ENTITY_NAME; | |
334 } | |
335 return syntaxError(state); | |
336 } | |
337 | |
338 static | |
339 int entity1(PROLOG_STATE *state, | |
340 int tok, | |
341 const char *ptr, | |
342 const char *end, | |
343 const ENCODING *enc) | |
344 { | |
345 switch (tok) { | |
346 case XML_TOK_PROLOG_S: | |
347 return XML_ROLE_NONE; | |
348 case XML_TOK_NAME: | |
349 state->handler = entity7; | |
350 return XML_ROLE_PARAM_ENTITY_NAME; | |
351 } | |
352 return syntaxError(state); | |
353 } | |
354 | |
355 static | |
356 int entity2(PROLOG_STATE *state, | |
357 int tok, | |
358 const char *ptr, | |
359 const char *end, | |
360 const ENCODING *enc) | |
361 { | |
362 switch (tok) { | |
363 case XML_TOK_PROLOG_S: | |
364 return XML_ROLE_NONE; | |
365 case XML_TOK_NAME: | |
366 if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) { | |
367 state->handler = entity4; | |
368 return XML_ROLE_NONE; | |
369 } | |
370 if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) { | |
371 state->handler = entity3; | |
372 return XML_ROLE_NONE; | |
373 } | |
374 break; | |
375 case XML_TOK_LITERAL: | |
376 state->handler = declClose; | |
377 return XML_ROLE_ENTITY_VALUE; | |
378 } | |
379 return syntaxError(state); | |
380 } | |
381 | |
382 static | |
383 int entity3(PROLOG_STATE *state, | |
384 int tok, | |
385 const char *ptr, | |
386 const char *end, | |
387 const ENCODING *enc) | |
388 { | |
389 switch (tok) { | |
390 case XML_TOK_PROLOG_S: | |
391 return XML_ROLE_NONE; | |
392 case XML_TOK_LITERAL: | |
393 state->handler = entity4; | |
394 return XML_ROLE_ENTITY_PUBLIC_ID; | |
395 } | |
396 return syntaxError(state); | |
397 } | |
398 | |
399 | |
400 static | |
401 int entity4(PROLOG_STATE *state, | |
402 int tok, | |
403 const char *ptr, | |
404 const char *end, | |
405 const ENCODING *enc) | |
406 { | |
407 switch (tok) { | |
408 case XML_TOK_PROLOG_S: | |
409 return XML_ROLE_NONE; | |
410 case XML_TOK_LITERAL: | |
411 state->handler = entity5; | |
412 return XML_ROLE_ENTITY_SYSTEM_ID; | |
413 } | |
414 return syntaxError(state); | |
415 } | |
416 | |
417 static | |
418 int entity5(PROLOG_STATE *state, | |
419 int tok, | |
420 const char *ptr, | |
421 const char *end, | |
422 const ENCODING *enc) | |
423 { | |
424 switch (tok) { | |
425 case XML_TOK_PROLOG_S: | |
426 return XML_ROLE_NONE; | |
427 case XML_TOK_DECL_CLOSE: | |
428 state->handler = internalSubset; | |
429 return XML_ROLE_NONE; | |
430 case XML_TOK_NAME: | |
431 if (XmlNameMatchesAscii(enc, ptr, "NDATA")) { | |
432 state->handler = entity6; | |
433 return XML_ROLE_NONE; | |
434 } | |
435 break; | |
436 } | |
437 return syntaxError(state); | |
438 } | |
439 | |
440 static | |
441 int entity6(PROLOG_STATE *state, | |
442 int tok, | |
443 const char *ptr, | |
444 const char *end, | |
445 const ENCODING *enc) | |
446 { | |
447 switch (tok) { | |
448 case XML_TOK_PROLOG_S: | |
449 return XML_ROLE_NONE; | |
450 case XML_TOK_NAME: | |
451 state->handler = declClose; | |
452 return XML_ROLE_ENTITY_NOTATION_NAME; | |
453 } | |
454 return syntaxError(state); | |
455 } | |
456 | |
457 static | |
458 int entity7(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_NONE; | |
467 case XML_TOK_NAME: | |
468 if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) { | |
469 state->handler = entity9; | |
470 return XML_ROLE_NONE; | |
471 } | |
472 if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) { | |
473 state->handler = entity8; | |
474 return XML_ROLE_NONE; | |
475 } | |
476 break; | |
477 case XML_TOK_LITERAL: | |
478 state->handler = declClose; | |
479 return XML_ROLE_ENTITY_VALUE; | |
480 } | |
481 return syntaxError(state); | |
482 } | |
483 | |
484 static | |
485 int entity8(PROLOG_STATE *state, | |
486 int tok, | |
487 const char *ptr, | |
488 const char *end, | |
489 const ENCODING *enc) | |
490 { | |
491 switch (tok) { | |
492 case XML_TOK_PROLOG_S: | |
493 return XML_ROLE_NONE; | |
494 case XML_TOK_LITERAL: | |
495 state->handler = entity9; | |
496 return XML_ROLE_ENTITY_PUBLIC_ID; | |
497 } | |
498 return syntaxError(state); | |
499 } | |
500 | |
501 static | |
502 int entity9(PROLOG_STATE *state, | |
503 int tok, | |
504 const char *ptr, | |
505 const char *end, | |
506 const ENCODING *enc) | |
507 { | |
508 switch (tok) { | |
509 case XML_TOK_PROLOG_S: | |
510 return XML_ROLE_NONE; | |
511 case XML_TOK_LITERAL: | |
512 state->handler = declClose; | |
513 return XML_ROLE_ENTITY_SYSTEM_ID; | |
514 } | |
515 return syntaxError(state); | |
516 } | |
517 | |
518 static | |
519 int notation0(PROLOG_STATE *state, | |
520 int tok, | |
521 const char *ptr, | |
522 const char *end, | |
523 const ENCODING *enc) | |
524 { | |
525 switch (tok) { | |
526 case XML_TOK_PROLOG_S: | |
527 return XML_ROLE_NONE; | |
528 case XML_TOK_NAME: | |
529 state->handler = notation1; | |
530 return XML_ROLE_NOTATION_NAME; | |
531 } | |
532 return syntaxError(state); | |
533 } | |
534 | |
535 static | |
536 int notation1(PROLOG_STATE *state, | |
537 int tok, | |
538 const char *ptr, | |
539 const char *end, | |
540 const ENCODING *enc) | |
541 { | |
542 switch (tok) { | |
543 case XML_TOK_PROLOG_S: | |
544 return XML_ROLE_NONE; | |
545 case XML_TOK_NAME: | |
546 if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) { | |
547 state->handler = notation3; | |
548 return XML_ROLE_NONE; | |
549 } | |
550 if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) { | |
551 state->handler = notation2; | |
552 return XML_ROLE_NONE; | |
553 } | |
554 break; | |
555 } | |
556 return syntaxError(state); | |
557 } | |
558 | |
559 static | |
560 int notation2(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_NONE; | |
569 case XML_TOK_LITERAL: | |
570 state->handler = notation4; | |
571 return XML_ROLE_NOTATION_PUBLIC_ID; | |
572 } | |
573 return syntaxError(state); | |
574 } | |
575 | |
576 static | |
577 int notation3(PROLOG_STATE *state, | |
578 int tok, | |
579 const char *ptr, | |
580 const char *end, | |
581 const ENCODING *enc) | |
582 { | |
583 switch (tok) { | |
584 case XML_TOK_PROLOG_S: | |
585 return XML_ROLE_NONE; | |
586 case XML_TOK_LITERAL: | |
587 state->handler = declClose; | |
588 return XML_ROLE_NOTATION_SYSTEM_ID; | |
589 } | |
590 return syntaxError(state); | |
591 } | |
592 | |
593 static | |
594 int notation4(PROLOG_STATE *state, | |
595 int tok, | |
596 const char *ptr, | |
597 const char *end, | |
598 const ENCODING *enc) | |
599 { | |
600 switch (tok) { | |
601 case XML_TOK_PROLOG_S: | |
602 return XML_ROLE_NONE; | |
603 case XML_TOK_LITERAL: | |
604 state->handler = declClose; | |
605 return XML_ROLE_NOTATION_SYSTEM_ID; | |
606 case XML_TOK_DECL_CLOSE: | |
607 state->handler = internalSubset; | |
608 return XML_ROLE_NOTATION_NO_SYSTEM_ID; | |
609 } | |
610 return syntaxError(state); | |
611 } | |
612 | |
613 static | |
614 int attlist0(PROLOG_STATE *state, | |
615 int tok, | |
616 const char *ptr, | |
617 const char *end, | |
618 const ENCODING *enc) | |
619 { | |
620 switch (tok) { | |
621 case XML_TOK_PROLOG_S: | |
622 return XML_ROLE_NONE; | |
623 case XML_TOK_NAME: | |
624 case XML_TOK_PREFIXED_NAME: | |
625 state->handler = attlist1; | |
626 return XML_ROLE_ATTLIST_ELEMENT_NAME; | |
627 } | |
628 return syntaxError(state); | |
629 } | |
630 | |
631 static | |
632 int attlist1(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_NONE; | |
641 case XML_TOK_DECL_CLOSE: | |
642 state->handler = internalSubset; | |
643 return XML_ROLE_NONE; | |
644 case XML_TOK_NAME: | |
645 case XML_TOK_PREFIXED_NAME: | |
646 state->handler = attlist2; | |
647 return XML_ROLE_ATTRIBUTE_NAME; | |
648 } | |
649 return syntaxError(state); | |
650 } | |
651 | |
652 static | |
653 int attlist2(PROLOG_STATE *state, | |
654 int tok, | |
655 const char *ptr, | |
656 const char *end, | |
657 const ENCODING *enc) | |
658 { | |
659 switch (tok) { | |
660 case XML_TOK_PROLOG_S: | |
661 return XML_ROLE_NONE; | |
662 case XML_TOK_NAME: | |
663 { | |
664 static const char *types[] = { | |
665 "CDATA", | |
666 "ID", | |
667 "IDREF", | |
668 "IDREFS", | |
669 "ENTITY", | |
670 "ENTITIES", | |
671 "NMTOKEN", | |
672 "NMTOKENS", | |
673 }; | |
674 int i; | |
675 for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++) | |
676 if (XmlNameMatchesAscii(enc, ptr, types[i])) { | |
677 state->handler = attlist8; | |
678 return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i; | |
679 } | |
680 } | |
681 if (XmlNameMatchesAscii(enc, ptr, "NOTATION")) { | |
682 state->handler = attlist5; | |
683 return XML_ROLE_NONE; | |
684 } | |
685 break; | |
686 case XML_TOK_OPEN_PAREN: | |
687 state->handler = attlist3; | |
688 return XML_ROLE_NONE; | |
689 } | |
690 return syntaxError(state); | |
691 } | |
692 | |
693 static | |
694 int attlist3(PROLOG_STATE *state, | |
695 int tok, | |
696 const char *ptr, | |
697 const char *end, | |
698 const ENCODING *enc) | |
699 { | |
700 switch (tok) { | |
701 case XML_TOK_PROLOG_S: | |
702 return XML_ROLE_NONE; | |
703 case XML_TOK_NMTOKEN: | |
704 case XML_TOK_NAME: | |
705 case XML_TOK_PREFIXED_NAME: | |
706 state->handler = attlist4; | |
707 return XML_ROLE_ATTRIBUTE_ENUM_VALUE; | |
708 } | |
709 return syntaxError(state); | |
710 } | |
711 | |
712 static | |
713 int attlist4(PROLOG_STATE *state, | |
714 int tok, | |
715 const char *ptr, | |
716 const char *end, | |
717 const ENCODING *enc) | |
718 { | |
719 switch (tok) { | |
720 case XML_TOK_PROLOG_S: | |
721 return XML_ROLE_NONE; | |
722 case XML_TOK_CLOSE_PAREN: | |
723 state->handler = attlist8; | |
724 return XML_ROLE_NONE; | |
725 case XML_TOK_OR: | |
726 state->handler = attlist3; | |
727 return XML_ROLE_NONE; | |
728 } | |
729 return syntaxError(state); | |
730 } | |
731 | |
732 static | |
733 int attlist5(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_NONE; | |
742 case XML_TOK_OPEN_PAREN: | |
743 state->handler = attlist6; | |
744 return XML_ROLE_NONE; | |
745 } | |
746 return syntaxError(state); | |
747 } | |
748 | |
749 | |
750 static | |
751 int attlist6(PROLOG_STATE *state, | |
752 int tok, | |
753 const char *ptr, | |
754 const char *end, | |
755 const ENCODING *enc) | |
756 { | |
757 switch (tok) { | |
758 case XML_TOK_PROLOG_S: | |
759 return XML_ROLE_NONE; | |
760 case XML_TOK_NAME: | |
761 state->handler = attlist7; | |
762 return XML_ROLE_ATTRIBUTE_NOTATION_VALUE; | |
763 } | |
764 return syntaxError(state); | |
765 } | |
766 | |
767 static | |
768 int attlist7(PROLOG_STATE *state, | |
769 int tok, | |
770 const char *ptr, | |
771 const char *end, | |
772 const ENCODING *enc) | |
773 { | |
774 switch (tok) { | |
775 case XML_TOK_PROLOG_S: | |
776 return XML_ROLE_NONE; | |
777 case XML_TOK_CLOSE_PAREN: | |
778 state->handler = attlist8; | |
779 return XML_ROLE_NONE; | |
780 case XML_TOK_OR: | |
781 state->handler = attlist6; | |
782 return XML_ROLE_NONE; | |
783 } | |
784 return syntaxError(state); | |
785 } | |
786 | |
787 /* default value */ | |
788 static | |
789 int attlist8(PROLOG_STATE *state, | |
790 int tok, | |
791 const char *ptr, | |
792 const char *end, | |
793 const ENCODING *enc) | |
794 { | |
795 switch (tok) { | |
796 case XML_TOK_PROLOG_S: | |
797 return XML_ROLE_NONE; | |
798 case XML_TOK_POUND_NAME: | |
799 if (XmlNameMatchesAscii(enc, | |
800 ptr + MIN_BYTES_PER_CHAR(enc), | |
801 "IMPLIED")) { | |
802 state->handler = attlist1; | |
803 return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE; | |
804 } | |
805 if (XmlNameMatchesAscii(enc, | |
806 ptr + MIN_BYTES_PER_CHAR(enc), | |
807 "REQUIRED")) { | |
808 state->handler = attlist1; | |
809 return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE; | |
810 } | |
811 if (XmlNameMatchesAscii(enc, | |
812 ptr + MIN_BYTES_PER_CHAR(enc), | |
813 "FIXED")) { | |
814 state->handler = attlist9; | |
815 return XML_ROLE_NONE; | |
816 } | |
817 break; | |
818 case XML_TOK_LITERAL: | |
819 state->handler = attlist1; | |
820 return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE; | |
821 } | |
822 return syntaxError(state); | |
823 } | |
824 | |
825 static | |
826 int attlist9(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_NONE; | |
835 case XML_TOK_LITERAL: | |
836 state->handler = attlist1; | |
837 return XML_ROLE_FIXED_ATTRIBUTE_VALUE; | |
838 } | |
839 return syntaxError(state); | |
840 } | |
841 | |
842 static | |
843 int element0(PROLOG_STATE *state, | |
844 int tok, | |
845 const char *ptr, | |
846 const char *end, | |
847 const ENCODING *enc) | |
848 { | |
849 switch (tok) { | |
850 case XML_TOK_PROLOG_S: | |
851 return XML_ROLE_NONE; | |
852 case XML_TOK_NAME: | |
853 case XML_TOK_PREFIXED_NAME: | |
854 state->handler = element1; | |
855 return XML_ROLE_ELEMENT_NAME; | |
856 } | |
857 return syntaxError(state); | |
858 } | |
859 | |
860 static | |
861 int element1(PROLOG_STATE *state, | |
862 int tok, | |
863 const char *ptr, | |
864 const char *end, | |
865 const ENCODING *enc) | |
866 { | |
867 switch (tok) { | |
868 case XML_TOK_PROLOG_S: | |
869 return XML_ROLE_NONE; | |
870 case XML_TOK_NAME: | |
871 if (XmlNameMatchesAscii(enc, ptr, "EMPTY")) { | |
872 state->handler = declClose; | |
873 return XML_ROLE_CONTENT_EMPTY; | |
874 } | |
875 if (XmlNameMatchesAscii(enc, ptr, "ANY")) { | |
876 state->handler = declClose; | |
877 return XML_ROLE_CONTENT_ANY; | |
878 } | |
879 break; | |
880 case XML_TOK_OPEN_PAREN: | |
881 state->handler = element2; | |
882 state->level = 1; | |
883 return XML_ROLE_GROUP_OPEN; | |
884 } | |
885 return syntaxError(state); | |
886 } | |
887 | |
888 static | |
889 int element2(PROLOG_STATE *state, | |
890 int tok, | |
891 const char *ptr, | |
892 const char *end, | |
893 const ENCODING *enc) | |
894 { | |
895 switch (tok) { | |
896 case XML_TOK_PROLOG_S: | |
897 return XML_ROLE_NONE; | |
898 case XML_TOK_POUND_NAME: | |
899 if (XmlNameMatchesAscii(enc, | |
900 ptr + MIN_BYTES_PER_CHAR(enc), | |
901 "PCDATA")) { | |
902 state->handler = element3; | |
903 return XML_ROLE_CONTENT_PCDATA; | |
904 } | |
905 break; | |
906 case XML_TOK_OPEN_PAREN: | |
907 state->level = 2; | |
908 state->handler = element6; | |
909 return XML_ROLE_GROUP_OPEN; | |
910 case XML_TOK_NAME: | |
911 case XML_TOK_PREFIXED_NAME: | |
912 state->handler = element7; | |
913 return XML_ROLE_CONTENT_ELEMENT; | |
914 case XML_TOK_NAME_QUESTION: | |
915 state->handler = element7; | |
916 return XML_ROLE_CONTENT_ELEMENT_OPT; | |
917 case XML_TOK_NAME_ASTERISK: | |
918 state->handler = element7; | |
919 return XML_ROLE_CONTENT_ELEMENT_REP; | |
920 case XML_TOK_NAME_PLUS: | |
921 state->handler = element7; | |
922 return XML_ROLE_CONTENT_ELEMENT_PLUS; | |
923 } | |
924 return syntaxError(state); | |
925 } | |
926 | |
927 static | |
928 int element3(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_NONE; | |
937 case XML_TOK_CLOSE_PAREN: | |
938 case XML_TOK_CLOSE_PAREN_ASTERISK: | |
939 state->handler = declClose; | |
940 return XML_ROLE_GROUP_CLOSE_REP; | |
941 case XML_TOK_OR: | |
942 state->handler = element4; | |
943 return XML_ROLE_NONE; | |
944 } | |
945 return syntaxError(state); | |
946 } | |
947 | |
948 static | |
949 int element4(PROLOG_STATE *state, | |
950 int tok, | |
951 const char *ptr, | |
952 const char *end, | |
953 const ENCODING *enc) | |
954 { | |
955 switch (tok) { | |
956 case XML_TOK_PROLOG_S: | |
957 return XML_ROLE_NONE; | |
958 case XML_TOK_NAME: | |
959 case XML_TOK_PREFIXED_NAME: | |
960 state->handler = element5; | |
961 return XML_ROLE_CONTENT_ELEMENT; | |
962 } | |
963 return syntaxError(state); | |
964 } | |
965 | |
966 static | |
967 int element5(PROLOG_STATE *state, | |
968 int tok, | |
969 const char *ptr, | |
970 const char *end, | |
971 const ENCODING *enc) | |
972 { | |
973 switch (tok) { | |
974 case XML_TOK_PROLOG_S: | |
975 return XML_ROLE_NONE; | |
976 case XML_TOK_CLOSE_PAREN_ASTERISK: | |
977 state->handler = declClose; | |
978 return XML_ROLE_GROUP_CLOSE_REP; | |
979 case XML_TOK_OR: | |
980 state->handler = element4; | |
981 return XML_ROLE_NONE; | |
982 } | |
983 return syntaxError(state); | |
984 } | |
985 | |
986 static | |
987 int element6(PROLOG_STATE *state, | |
988 int tok, | |
989 const char *ptr, | |
990 const char *end, | |
991 const ENCODING *enc) | |
992 { | |
993 switch (tok) { | |
994 case XML_TOK_PROLOG_S: | |
995 return XML_ROLE_NONE; | |
996 case XML_TOK_OPEN_PAREN: | |
997 state->level += 1; | |
998 return XML_ROLE_GROUP_OPEN; | |
999 case XML_TOK_NAME: | |
1000 case XML_TOK_PREFIXED_NAME: | |
1001 state->handler = element7; | |
1002 return XML_ROLE_CONTENT_ELEMENT; | |
1003 case XML_TOK_NAME_QUESTION: | |
1004 state->handler = element7; | |
1005 return XML_ROLE_CONTENT_ELEMENT_OPT; | |
1006 case XML_TOK_NAME_ASTERISK: | |
1007 state->handler = element7; | |
1008 return XML_ROLE_CONTENT_ELEMENT_REP; | |
1009 case XML_TOK_NAME_PLUS: | |
1010 state->handler = element7; | |
1011 return XML_ROLE_CONTENT_ELEMENT_PLUS; | |
1012 } | |
1013 return syntaxError(state); | |
1014 } | |
1015 | |
1016 static | |
1017 int element7(PROLOG_STATE *state, | |
1018 int tok, | |
1019 const char *ptr, | |
1020 const char *end, | |
1021 const ENCODING *enc) | |
1022 { | |
1023 switch (tok) { | |
1024 case XML_TOK_PROLOG_S: | |
1025 return XML_ROLE_NONE; | |
1026 case XML_TOK_CLOSE_PAREN: | |
1027 state->level -= 1; | |
1028 if (state->level == 0) | |
1029 state->handler = declClose; | |
1030 return XML_ROLE_GROUP_CLOSE; | |
1031 case XML_TOK_CLOSE_PAREN_ASTERISK: | |
1032 state->level -= 1; | |
1033 if (state->level == 0) | |
1034 state->handler = declClose; | |
1035 return XML_ROLE_GROUP_CLOSE_REP; | |
1036 case XML_TOK_CLOSE_PAREN_QUESTION: | |
1037 state->level -= 1; | |
1038 if (state->level == 0) | |
1039 state->handler = declClose; | |
1040 return XML_ROLE_GROUP_CLOSE_OPT; | |
1041 case XML_TOK_CLOSE_PAREN_PLUS: | |
1042 state->level -= 1; | |
1043 if (state->level == 0) | |
1044 state->handler = declClose; | |
1045 return XML_ROLE_GROUP_CLOSE_PLUS; | |
1046 case XML_TOK_COMMA: | |
1047 state->handler = element6; | |
1048 return XML_ROLE_GROUP_SEQUENCE; | |
1049 case XML_TOK_OR: | |
1050 state->handler = element6; | |
1051 return XML_ROLE_GROUP_CHOICE; | |
1052 } | |
1053 return syntaxError(state); | |
1054 } | |
1055 | |
1056 static | |
1057 int declClose(PROLOG_STATE *state, | |
1058 int tok, | |
1059 const char *ptr, | |
1060 const char *end, | |
1061 const ENCODING *enc) | |
1062 { | |
1063 switch (tok) { | |
1064 case XML_TOK_PROLOG_S: | |
1065 return XML_ROLE_NONE; | |
1066 case XML_TOK_DECL_CLOSE: | |
1067 state->handler = internalSubset; | |
1068 return XML_ROLE_NONE; | |
1069 } | |
1070 return syntaxError(state); | |
1071 } | |
1072 | |
1073 #if 0 | |
1074 | |
1075 static | |
1076 int ignore(PROLOG_STATE *state, | |
1077 int tok, | |
1078 const char *ptr, | |
1079 const char *end, | |
1080 const ENCODING *enc) | |
1081 { | |
1082 switch (tok) { | |
1083 case XML_TOK_DECL_CLOSE: | |
1084 state->handler = internalSubset; | |
1085 return 0; | |
1086 default: | |
1087 return XML_ROLE_NONE; | |
1088 } | |
1089 return syntaxError(state); | |
1090 } | |
1091 #endif | |
1092 | |
1093 static | |
1094 int error(PROLOG_STATE *state, | |
1095 int tok, | |
1096 const char *ptr, | |
1097 const char *end, | |
1098 const ENCODING *enc) | |
1099 { | |
1100 return XML_ROLE_NONE; | |
1101 } | |
1102 | |
1103 static | |
1104 int syntaxError(PROLOG_STATE *state) | |
1105 { | |
1106 state->handler = error; | |
1107 return XML_ROLE_ERROR; | |
1108 } | |
1109 | |
1110 void XmlPrologStateInit(PROLOG_STATE *state) | |
1111 { | |
1112 state->handler = prolog0; | |
1113 } |