|
25
|
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 } |
