OLD | NEW |
| (Empty) |
1 /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd | |
2 See the file COPYING for copying permission. | |
3 */ | |
4 | |
5 /* This file is included! */ | |
6 #ifdef XML_TOK_IMPL_C | |
7 | |
8 #ifndef IS_INVALID_CHAR | |
9 #define IS_INVALID_CHAR(enc, ptr, n) (0) | |
10 #endif | |
11 | |
12 #define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \ | |
13 case BT_LEAD ## n: \ | |
14 if (end - ptr < n) \ | |
15 return XML_TOK_PARTIAL_CHAR; \ | |
16 if (IS_INVALID_CHAR(enc, ptr, n)) { \ | |
17 *(nextTokPtr) = (ptr); \ | |
18 return XML_TOK_INVALID; \ | |
19 } \ | |
20 ptr += n; \ | |
21 break; | |
22 | |
23 #define INVALID_CASES(ptr, nextTokPtr) \ | |
24 INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | |
25 INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | |
26 INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | |
27 case BT_NONXML: \ | |
28 case BT_MALFORM: \ | |
29 case BT_TRAIL: \ | |
30 *(nextTokPtr) = (ptr); \ | |
31 return XML_TOK_INVALID; | |
32 | |
33 #define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \ | |
34 case BT_LEAD ## n: \ | |
35 if (end - ptr < n) \ | |
36 return XML_TOK_PARTIAL_CHAR; \ | |
37 if (!IS_NAME_CHAR(enc, ptr, n)) { \ | |
38 *nextTokPtr = ptr; \ | |
39 return XML_TOK_INVALID; \ | |
40 } \ | |
41 ptr += n; \ | |
42 break; | |
43 | |
44 #define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \ | |
45 case BT_NONASCII: \ | |
46 if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | |
47 *nextTokPtr = ptr; \ | |
48 return XML_TOK_INVALID; \ | |
49 } \ | |
50 case BT_NMSTRT: \ | |
51 case BT_HEX: \ | |
52 case BT_DIGIT: \ | |
53 case BT_NAME: \ | |
54 case BT_MINUS: \ | |
55 ptr += MINBPC(enc); \ | |
56 break; \ | |
57 CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | |
58 CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | |
59 CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | |
60 | |
61 #define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \ | |
62 case BT_LEAD ## n: \ | |
63 if (end - ptr < n) \ | |
64 return XML_TOK_PARTIAL_CHAR; \ | |
65 if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \ | |
66 *nextTokPtr = ptr; \ | |
67 return XML_TOK_INVALID; \ | |
68 } \ | |
69 ptr += n; \ | |
70 break; | |
71 | |
72 #define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \ | |
73 case BT_NONASCII: \ | |
74 if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | |
75 *nextTokPtr = ptr; \ | |
76 return XML_TOK_INVALID; \ | |
77 } \ | |
78 case BT_NMSTRT: \ | |
79 case BT_HEX: \ | |
80 ptr += MINBPC(enc); \ | |
81 break; \ | |
82 CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | |
83 CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | |
84 CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | |
85 | |
86 #ifndef PREFIX | |
87 #define PREFIX(ident) ident | |
88 #endif | |
89 | |
90 /* ptr points to character following "<!-" */ | |
91 | |
92 static int PTRCALL | |
93 PREFIX(scanComment)(const ENCODING *enc, const char *ptr, | |
94 const char *end, const char **nextTokPtr) | |
95 { | |
96 if (ptr != end) { | |
97 if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) { | |
98 *nextTokPtr = ptr; | |
99 return XML_TOK_INVALID; | |
100 } | |
101 ptr += MINBPC(enc); | |
102 while (ptr != end) { | |
103 switch (BYTE_TYPE(enc, ptr)) { | |
104 INVALID_CASES(ptr, nextTokPtr) | |
105 case BT_MINUS: | |
106 if ((ptr += MINBPC(enc)) == end) | |
107 return XML_TOK_PARTIAL; | |
108 if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) { | |
109 if ((ptr += MINBPC(enc)) == end) | |
110 return XML_TOK_PARTIAL; | |
111 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
112 *nextTokPtr = ptr; | |
113 return XML_TOK_INVALID; | |
114 } | |
115 *nextTokPtr = ptr + MINBPC(enc); | |
116 return XML_TOK_COMMENT; | |
117 } | |
118 break; | |
119 default: | |
120 ptr += MINBPC(enc); | |
121 break; | |
122 } | |
123 } | |
124 } | |
125 return XML_TOK_PARTIAL; | |
126 } | |
127 | |
128 /* ptr points to character following "<!" */ | |
129 | |
130 static int PTRCALL | |
131 PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, | |
132 const char *end, const char **nextTokPtr) | |
133 { | |
134 if (ptr == end) | |
135 return XML_TOK_PARTIAL; | |
136 switch (BYTE_TYPE(enc, ptr)) { | |
137 case BT_MINUS: | |
138 return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
139 case BT_LSQB: | |
140 *nextTokPtr = ptr + MINBPC(enc); | |
141 return XML_TOK_COND_SECT_OPEN; | |
142 case BT_NMSTRT: | |
143 case BT_HEX: | |
144 ptr += MINBPC(enc); | |
145 break; | |
146 default: | |
147 *nextTokPtr = ptr; | |
148 return XML_TOK_INVALID; | |
149 } | |
150 while (ptr != end) { | |
151 switch (BYTE_TYPE(enc, ptr)) { | |
152 case BT_PERCNT: | |
153 if (ptr + MINBPC(enc) == end) | |
154 return XML_TOK_PARTIAL; | |
155 /* don't allow <!ENTITY% foo "whatever"> */ | |
156 switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) { | |
157 case BT_S: case BT_CR: case BT_LF: case BT_PERCNT: | |
158 *nextTokPtr = ptr; | |
159 return XML_TOK_INVALID; | |
160 } | |
161 /* fall through */ | |
162 case BT_S: case BT_CR: case BT_LF: | |
163 *nextTokPtr = ptr; | |
164 return XML_TOK_DECL_OPEN; | |
165 case BT_NMSTRT: | |
166 case BT_HEX: | |
167 ptr += MINBPC(enc); | |
168 break; | |
169 default: | |
170 *nextTokPtr = ptr; | |
171 return XML_TOK_INVALID; | |
172 } | |
173 } | |
174 return XML_TOK_PARTIAL; | |
175 } | |
176 | |
177 static int PTRCALL | |
178 PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, | |
179 const char *end, int *tokPtr) | |
180 { | |
181 int upper = 0; | |
182 *tokPtr = XML_TOK_PI; | |
183 if (end - ptr != MINBPC(enc)*3) | |
184 return 1; | |
185 switch (BYTE_TO_ASCII(enc, ptr)) { | |
186 case ASCII_x: | |
187 break; | |
188 case ASCII_X: | |
189 upper = 1; | |
190 break; | |
191 default: | |
192 return 1; | |
193 } | |
194 ptr += MINBPC(enc); | |
195 switch (BYTE_TO_ASCII(enc, ptr)) { | |
196 case ASCII_m: | |
197 break; | |
198 case ASCII_M: | |
199 upper = 1; | |
200 break; | |
201 default: | |
202 return 1; | |
203 } | |
204 ptr += MINBPC(enc); | |
205 switch (BYTE_TO_ASCII(enc, ptr)) { | |
206 case ASCII_l: | |
207 break; | |
208 case ASCII_L: | |
209 upper = 1; | |
210 break; | |
211 default: | |
212 return 1; | |
213 } | |
214 if (upper) | |
215 return 0; | |
216 *tokPtr = XML_TOK_XML_DECL; | |
217 return 1; | |
218 } | |
219 | |
220 /* ptr points to character following "<?" */ | |
221 | |
222 static int PTRCALL | |
223 PREFIX(scanPi)(const ENCODING *enc, const char *ptr, | |
224 const char *end, const char **nextTokPtr) | |
225 { | |
226 int tok; | |
227 const char *target = ptr; | |
228 if (ptr == end) | |
229 return XML_TOK_PARTIAL; | |
230 switch (BYTE_TYPE(enc, ptr)) { | |
231 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
232 default: | |
233 *nextTokPtr = ptr; | |
234 return XML_TOK_INVALID; | |
235 } | |
236 while (ptr != end) { | |
237 switch (BYTE_TYPE(enc, ptr)) { | |
238 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
239 case BT_S: case BT_CR: case BT_LF: | |
240 if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) { | |
241 *nextTokPtr = ptr; | |
242 return XML_TOK_INVALID; | |
243 } | |
244 ptr += MINBPC(enc); | |
245 while (ptr != end) { | |
246 switch (BYTE_TYPE(enc, ptr)) { | |
247 INVALID_CASES(ptr, nextTokPtr) | |
248 case BT_QUEST: | |
249 ptr += MINBPC(enc); | |
250 if (ptr == end) | |
251 return XML_TOK_PARTIAL; | |
252 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
253 *nextTokPtr = ptr + MINBPC(enc); | |
254 return tok; | |
255 } | |
256 break; | |
257 default: | |
258 ptr += MINBPC(enc); | |
259 break; | |
260 } | |
261 } | |
262 return XML_TOK_PARTIAL; | |
263 case BT_QUEST: | |
264 if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) { | |
265 *nextTokPtr = ptr; | |
266 return XML_TOK_INVALID; | |
267 } | |
268 ptr += MINBPC(enc); | |
269 if (ptr == end) | |
270 return XML_TOK_PARTIAL; | |
271 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
272 *nextTokPtr = ptr + MINBPC(enc); | |
273 return tok; | |
274 } | |
275 /* fall through */ | |
276 default: | |
277 *nextTokPtr = ptr; | |
278 return XML_TOK_INVALID; | |
279 } | |
280 } | |
281 return XML_TOK_PARTIAL; | |
282 } | |
283 | |
284 static int PTRCALL | |
285 PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, | |
286 const char *end, const char **nextTokPtr) | |
287 { | |
288 static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A, | |
289 ASCII_T, ASCII_A, ASCII_LSQB }; | |
290 int i; | |
291 /* CDATA[ */ | |
292 if (end - ptr < 6 * MINBPC(enc)) | |
293 return XML_TOK_PARTIAL; | |
294 for (i = 0; i < 6; i++, ptr += MINBPC(enc)) { | |
295 if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) { | |
296 *nextTokPtr = ptr; | |
297 return XML_TOK_INVALID; | |
298 } | |
299 } | |
300 *nextTokPtr = ptr; | |
301 return XML_TOK_CDATA_SECT_OPEN; | |
302 } | |
303 | |
304 static int PTRCALL | |
305 PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, | |
306 const char *end, const char **nextTokPtr) | |
307 { | |
308 if (ptr == end) | |
309 return XML_TOK_NONE; | |
310 if (MINBPC(enc) > 1) { | |
311 size_t n = end - ptr; | |
312 if (n & (MINBPC(enc) - 1)) { | |
313 n &= ~(MINBPC(enc) - 1); | |
314 if (n == 0) | |
315 return XML_TOK_PARTIAL; | |
316 end = ptr + n; | |
317 } | |
318 } | |
319 switch (BYTE_TYPE(enc, ptr)) { | |
320 case BT_RSQB: | |
321 ptr += MINBPC(enc); | |
322 if (ptr == end) | |
323 return XML_TOK_PARTIAL; | |
324 if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB)) | |
325 break; | |
326 ptr += MINBPC(enc); | |
327 if (ptr == end) | |
328 return XML_TOK_PARTIAL; | |
329 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
330 ptr -= MINBPC(enc); | |
331 break; | |
332 } | |
333 *nextTokPtr = ptr + MINBPC(enc); | |
334 return XML_TOK_CDATA_SECT_CLOSE; | |
335 case BT_CR: | |
336 ptr += MINBPC(enc); | |
337 if (ptr == end) | |
338 return XML_TOK_PARTIAL; | |
339 if (BYTE_TYPE(enc, ptr) == BT_LF) | |
340 ptr += MINBPC(enc); | |
341 *nextTokPtr = ptr; | |
342 return XML_TOK_DATA_NEWLINE; | |
343 case BT_LF: | |
344 *nextTokPtr = ptr + MINBPC(enc); | |
345 return XML_TOK_DATA_NEWLINE; | |
346 INVALID_CASES(ptr, nextTokPtr) | |
347 default: | |
348 ptr += MINBPC(enc); | |
349 break; | |
350 } | |
351 while (ptr != end) { | |
352 switch (BYTE_TYPE(enc, ptr)) { | |
353 #define LEAD_CASE(n) \ | |
354 case BT_LEAD ## n: \ | |
355 if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | |
356 *nextTokPtr = ptr; \ | |
357 return XML_TOK_DATA_CHARS; \ | |
358 } \ | |
359 ptr += n; \ | |
360 break; | |
361 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
362 #undef LEAD_CASE | |
363 case BT_NONXML: | |
364 case BT_MALFORM: | |
365 case BT_TRAIL: | |
366 case BT_CR: | |
367 case BT_LF: | |
368 case BT_RSQB: | |
369 *nextTokPtr = ptr; | |
370 return XML_TOK_DATA_CHARS; | |
371 default: | |
372 ptr += MINBPC(enc); | |
373 break; | |
374 } | |
375 } | |
376 *nextTokPtr = ptr; | |
377 return XML_TOK_DATA_CHARS; | |
378 } | |
379 | |
380 /* ptr points to character following "</" */ | |
381 | |
382 static int PTRCALL | |
383 PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, | |
384 const char *end, const char **nextTokPtr) | |
385 { | |
386 if (ptr == end) | |
387 return XML_TOK_PARTIAL; | |
388 switch (BYTE_TYPE(enc, ptr)) { | |
389 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
390 default: | |
391 *nextTokPtr = ptr; | |
392 return XML_TOK_INVALID; | |
393 } | |
394 while (ptr != end) { | |
395 switch (BYTE_TYPE(enc, ptr)) { | |
396 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
397 case BT_S: case BT_CR: case BT_LF: | |
398 for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) { | |
399 switch (BYTE_TYPE(enc, ptr)) { | |
400 case BT_S: case BT_CR: case BT_LF: | |
401 break; | |
402 case BT_GT: | |
403 *nextTokPtr = ptr + MINBPC(enc); | |
404 return XML_TOK_END_TAG; | |
405 default: | |
406 *nextTokPtr = ptr; | |
407 return XML_TOK_INVALID; | |
408 } | |
409 } | |
410 return XML_TOK_PARTIAL; | |
411 #ifdef XML_NS | |
412 case BT_COLON: | |
413 /* no need to check qname syntax here, | |
414 since end-tag must match exactly */ | |
415 ptr += MINBPC(enc); | |
416 break; | |
417 #endif | |
418 case BT_GT: | |
419 *nextTokPtr = ptr + MINBPC(enc); | |
420 return XML_TOK_END_TAG; | |
421 default: | |
422 *nextTokPtr = ptr; | |
423 return XML_TOK_INVALID; | |
424 } | |
425 } | |
426 return XML_TOK_PARTIAL; | |
427 } | |
428 | |
429 /* ptr points to character following "&#X" */ | |
430 | |
431 static int PTRCALL | |
432 PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, | |
433 const char *end, const char **nextTokPtr) | |
434 { | |
435 if (ptr != end) { | |
436 switch (BYTE_TYPE(enc, ptr)) { | |
437 case BT_DIGIT: | |
438 case BT_HEX: | |
439 break; | |
440 default: | |
441 *nextTokPtr = ptr; | |
442 return XML_TOK_INVALID; | |
443 } | |
444 for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) { | |
445 switch (BYTE_TYPE(enc, ptr)) { | |
446 case BT_DIGIT: | |
447 case BT_HEX: | |
448 break; | |
449 case BT_SEMI: | |
450 *nextTokPtr = ptr + MINBPC(enc); | |
451 return XML_TOK_CHAR_REF; | |
452 default: | |
453 *nextTokPtr = ptr; | |
454 return XML_TOK_INVALID; | |
455 } | |
456 } | |
457 } | |
458 return XML_TOK_PARTIAL; | |
459 } | |
460 | |
461 /* ptr points to character following "&#" */ | |
462 | |
463 static int PTRCALL | |
464 PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, | |
465 const char *end, const char **nextTokPtr) | |
466 { | |
467 if (ptr != end) { | |
468 if (CHAR_MATCHES(enc, ptr, ASCII_x)) | |
469 return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
470 switch (BYTE_TYPE(enc, ptr)) { | |
471 case BT_DIGIT: | |
472 break; | |
473 default: | |
474 *nextTokPtr = ptr; | |
475 return XML_TOK_INVALID; | |
476 } | |
477 for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) { | |
478 switch (BYTE_TYPE(enc, ptr)) { | |
479 case BT_DIGIT: | |
480 break; | |
481 case BT_SEMI: | |
482 *nextTokPtr = ptr + MINBPC(enc); | |
483 return XML_TOK_CHAR_REF; | |
484 default: | |
485 *nextTokPtr = ptr; | |
486 return XML_TOK_INVALID; | |
487 } | |
488 } | |
489 } | |
490 return XML_TOK_PARTIAL; | |
491 } | |
492 | |
493 /* ptr points to character following "&" */ | |
494 | |
495 static int PTRCALL | |
496 PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end, | |
497 const char **nextTokPtr) | |
498 { | |
499 if (ptr == end) | |
500 return XML_TOK_PARTIAL; | |
501 switch (BYTE_TYPE(enc, ptr)) { | |
502 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
503 case BT_NUM: | |
504 return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
505 default: | |
506 *nextTokPtr = ptr; | |
507 return XML_TOK_INVALID; | |
508 } | |
509 while (ptr != end) { | |
510 switch (BYTE_TYPE(enc, ptr)) { | |
511 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
512 case BT_SEMI: | |
513 *nextTokPtr = ptr + MINBPC(enc); | |
514 return XML_TOK_ENTITY_REF; | |
515 default: | |
516 *nextTokPtr = ptr; | |
517 return XML_TOK_INVALID; | |
518 } | |
519 } | |
520 return XML_TOK_PARTIAL; | |
521 } | |
522 | |
523 /* ptr points to character following first character of attribute name */ | |
524 | |
525 static int PTRCALL | |
526 PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end, | |
527 const char **nextTokPtr) | |
528 { | |
529 #ifdef XML_NS | |
530 int hadColon = 0; | |
531 #endif | |
532 while (ptr != end) { | |
533 switch (BYTE_TYPE(enc, ptr)) { | |
534 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
535 #ifdef XML_NS | |
536 case BT_COLON: | |
537 if (hadColon) { | |
538 *nextTokPtr = ptr; | |
539 return XML_TOK_INVALID; | |
540 } | |
541 hadColon = 1; | |
542 ptr += MINBPC(enc); | |
543 if (ptr == end) | |
544 return XML_TOK_PARTIAL; | |
545 switch (BYTE_TYPE(enc, ptr)) { | |
546 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
547 default: | |
548 *nextTokPtr = ptr; | |
549 return XML_TOK_INVALID; | |
550 } | |
551 break; | |
552 #endif | |
553 case BT_S: case BT_CR: case BT_LF: | |
554 for (;;) { | |
555 int t; | |
556 | |
557 ptr += MINBPC(enc); | |
558 if (ptr == end) | |
559 return XML_TOK_PARTIAL; | |
560 t = BYTE_TYPE(enc, ptr); | |
561 if (t == BT_EQUALS) | |
562 break; | |
563 switch (t) { | |
564 case BT_S: | |
565 case BT_LF: | |
566 case BT_CR: | |
567 break; | |
568 default: | |
569 *nextTokPtr = ptr; | |
570 return XML_TOK_INVALID; | |
571 } | |
572 } | |
573 /* fall through */ | |
574 case BT_EQUALS: | |
575 { | |
576 int open; | |
577 #ifdef XML_NS | |
578 hadColon = 0; | |
579 #endif | |
580 for (;;) { | |
581 ptr += MINBPC(enc); | |
582 if (ptr == end) | |
583 return XML_TOK_PARTIAL; | |
584 open = BYTE_TYPE(enc, ptr); | |
585 if (open == BT_QUOT || open == BT_APOS) | |
586 break; | |
587 switch (open) { | |
588 case BT_S: | |
589 case BT_LF: | |
590 case BT_CR: | |
591 break; | |
592 default: | |
593 *nextTokPtr = ptr; | |
594 return XML_TOK_INVALID; | |
595 } | |
596 } | |
597 ptr += MINBPC(enc); | |
598 /* in attribute value */ | |
599 for (;;) { | |
600 int t; | |
601 if (ptr == end) | |
602 return XML_TOK_PARTIAL; | |
603 t = BYTE_TYPE(enc, ptr); | |
604 if (t == open) | |
605 break; | |
606 switch (t) { | |
607 INVALID_CASES(ptr, nextTokPtr) | |
608 case BT_AMP: | |
609 { | |
610 int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr); | |
611 if (tok <= 0) { | |
612 if (tok == XML_TOK_INVALID) | |
613 *nextTokPtr = ptr; | |
614 return tok; | |
615 } | |
616 break; | |
617 } | |
618 case BT_LT: | |
619 *nextTokPtr = ptr; | |
620 return XML_TOK_INVALID; | |
621 default: | |
622 ptr += MINBPC(enc); | |
623 break; | |
624 } | |
625 } | |
626 ptr += MINBPC(enc); | |
627 if (ptr == end) | |
628 return XML_TOK_PARTIAL; | |
629 switch (BYTE_TYPE(enc, ptr)) { | |
630 case BT_S: | |
631 case BT_CR: | |
632 case BT_LF: | |
633 break; | |
634 case BT_SOL: | |
635 goto sol; | |
636 case BT_GT: | |
637 goto gt; | |
638 default: | |
639 *nextTokPtr = ptr; | |
640 return XML_TOK_INVALID; | |
641 } | |
642 /* ptr points to closing quote */ | |
643 for (;;) { | |
644 ptr += MINBPC(enc); | |
645 if (ptr == end) | |
646 return XML_TOK_PARTIAL; | |
647 switch (BYTE_TYPE(enc, ptr)) { | |
648 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
649 case BT_S: case BT_CR: case BT_LF: | |
650 continue; | |
651 case BT_GT: | |
652 gt: | |
653 *nextTokPtr = ptr + MINBPC(enc); | |
654 return XML_TOK_START_TAG_WITH_ATTS; | |
655 case BT_SOL: | |
656 sol: | |
657 ptr += MINBPC(enc); | |
658 if (ptr == end) | |
659 return XML_TOK_PARTIAL; | |
660 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
661 *nextTokPtr = ptr; | |
662 return XML_TOK_INVALID; | |
663 } | |
664 *nextTokPtr = ptr + MINBPC(enc); | |
665 return XML_TOK_EMPTY_ELEMENT_WITH_ATTS; | |
666 default: | |
667 *nextTokPtr = ptr; | |
668 return XML_TOK_INVALID; | |
669 } | |
670 break; | |
671 } | |
672 break; | |
673 } | |
674 default: | |
675 *nextTokPtr = ptr; | |
676 return XML_TOK_INVALID; | |
677 } | |
678 } | |
679 return XML_TOK_PARTIAL; | |
680 } | |
681 | |
682 /* ptr points to character following "<" */ | |
683 | |
684 static int PTRCALL | |
685 PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end, | |
686 const char **nextTokPtr) | |
687 { | |
688 #ifdef XML_NS | |
689 int hadColon; | |
690 #endif | |
691 if (ptr == end) | |
692 return XML_TOK_PARTIAL; | |
693 switch (BYTE_TYPE(enc, ptr)) { | |
694 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
695 case BT_EXCL: | |
696 if ((ptr += MINBPC(enc)) == end) | |
697 return XML_TOK_PARTIAL; | |
698 switch (BYTE_TYPE(enc, ptr)) { | |
699 case BT_MINUS: | |
700 return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
701 case BT_LSQB: | |
702 return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), | |
703 end, nextTokPtr); | |
704 } | |
705 *nextTokPtr = ptr; | |
706 return XML_TOK_INVALID; | |
707 case BT_QUEST: | |
708 return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
709 case BT_SOL: | |
710 return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
711 default: | |
712 *nextTokPtr = ptr; | |
713 return XML_TOK_INVALID; | |
714 } | |
715 #ifdef XML_NS | |
716 hadColon = 0; | |
717 #endif | |
718 /* we have a start-tag */ | |
719 while (ptr != end) { | |
720 switch (BYTE_TYPE(enc, ptr)) { | |
721 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
722 #ifdef XML_NS | |
723 case BT_COLON: | |
724 if (hadColon) { | |
725 *nextTokPtr = ptr; | |
726 return XML_TOK_INVALID; | |
727 } | |
728 hadColon = 1; | |
729 ptr += MINBPC(enc); | |
730 if (ptr == end) | |
731 return XML_TOK_PARTIAL; | |
732 switch (BYTE_TYPE(enc, ptr)) { | |
733 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
734 default: | |
735 *nextTokPtr = ptr; | |
736 return XML_TOK_INVALID; | |
737 } | |
738 break; | |
739 #endif | |
740 case BT_S: case BT_CR: case BT_LF: | |
741 { | |
742 ptr += MINBPC(enc); | |
743 while (ptr != end) { | |
744 switch (BYTE_TYPE(enc, ptr)) { | |
745 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
746 case BT_GT: | |
747 goto gt; | |
748 case BT_SOL: | |
749 goto sol; | |
750 case BT_S: case BT_CR: case BT_LF: | |
751 ptr += MINBPC(enc); | |
752 continue; | |
753 default: | |
754 *nextTokPtr = ptr; | |
755 return XML_TOK_INVALID; | |
756 } | |
757 return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr); | |
758 } | |
759 return XML_TOK_PARTIAL; | |
760 } | |
761 case BT_GT: | |
762 gt: | |
763 *nextTokPtr = ptr + MINBPC(enc); | |
764 return XML_TOK_START_TAG_NO_ATTS; | |
765 case BT_SOL: | |
766 sol: | |
767 ptr += MINBPC(enc); | |
768 if (ptr == end) | |
769 return XML_TOK_PARTIAL; | |
770 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
771 *nextTokPtr = ptr; | |
772 return XML_TOK_INVALID; | |
773 } | |
774 *nextTokPtr = ptr + MINBPC(enc); | |
775 return XML_TOK_EMPTY_ELEMENT_NO_ATTS; | |
776 default: | |
777 *nextTokPtr = ptr; | |
778 return XML_TOK_INVALID; | |
779 } | |
780 } | |
781 return XML_TOK_PARTIAL; | |
782 } | |
783 | |
784 static int PTRCALL | |
785 PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end, | |
786 const char **nextTokPtr) | |
787 { | |
788 if (ptr == end) | |
789 return XML_TOK_NONE; | |
790 if (MINBPC(enc) > 1) { | |
791 size_t n = end - ptr; | |
792 if (n & (MINBPC(enc) - 1)) { | |
793 n &= ~(MINBPC(enc) - 1); | |
794 if (n == 0) | |
795 return XML_TOK_PARTIAL; | |
796 end = ptr + n; | |
797 } | |
798 } | |
799 switch (BYTE_TYPE(enc, ptr)) { | |
800 case BT_LT: | |
801 return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
802 case BT_AMP: | |
803 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
804 case BT_CR: | |
805 ptr += MINBPC(enc); | |
806 if (ptr == end) | |
807 return XML_TOK_TRAILING_CR; | |
808 if (BYTE_TYPE(enc, ptr) == BT_LF) | |
809 ptr += MINBPC(enc); | |
810 *nextTokPtr = ptr; | |
811 return XML_TOK_DATA_NEWLINE; | |
812 case BT_LF: | |
813 *nextTokPtr = ptr + MINBPC(enc); | |
814 return XML_TOK_DATA_NEWLINE; | |
815 case BT_RSQB: | |
816 ptr += MINBPC(enc); | |
817 if (ptr == end) | |
818 return XML_TOK_TRAILING_RSQB; | |
819 if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB)) | |
820 break; | |
821 ptr += MINBPC(enc); | |
822 if (ptr == end) | |
823 return XML_TOK_TRAILING_RSQB; | |
824 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
825 ptr -= MINBPC(enc); | |
826 break; | |
827 } | |
828 *nextTokPtr = ptr; | |
829 return XML_TOK_INVALID; | |
830 INVALID_CASES(ptr, nextTokPtr) | |
831 default: | |
832 ptr += MINBPC(enc); | |
833 break; | |
834 } | |
835 while (ptr != end) { | |
836 switch (BYTE_TYPE(enc, ptr)) { | |
837 #define LEAD_CASE(n) \ | |
838 case BT_LEAD ## n: \ | |
839 if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | |
840 *nextTokPtr = ptr; \ | |
841 return XML_TOK_DATA_CHARS; \ | |
842 } \ | |
843 ptr += n; \ | |
844 break; | |
845 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
846 #undef LEAD_CASE | |
847 case BT_RSQB: | |
848 if (ptr + MINBPC(enc) != end) { | |
849 if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) { | |
850 ptr += MINBPC(enc); | |
851 break; | |
852 } | |
853 if (ptr + 2*MINBPC(enc) != end) { | |
854 if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) { | |
855 ptr += MINBPC(enc); | |
856 break; | |
857 } | |
858 *nextTokPtr = ptr + 2*MINBPC(enc); | |
859 return XML_TOK_INVALID; | |
860 } | |
861 } | |
862 /* fall through */ | |
863 case BT_AMP: | |
864 case BT_LT: | |
865 case BT_NONXML: | |
866 case BT_MALFORM: | |
867 case BT_TRAIL: | |
868 case BT_CR: | |
869 case BT_LF: | |
870 *nextTokPtr = ptr; | |
871 return XML_TOK_DATA_CHARS; | |
872 default: | |
873 ptr += MINBPC(enc); | |
874 break; | |
875 } | |
876 } | |
877 *nextTokPtr = ptr; | |
878 return XML_TOK_DATA_CHARS; | |
879 } | |
880 | |
881 /* ptr points to character following "%" */ | |
882 | |
883 static int PTRCALL | |
884 PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end, | |
885 const char **nextTokPtr) | |
886 { | |
887 if (ptr == end) | |
888 return XML_TOK_PARTIAL; | |
889 switch (BYTE_TYPE(enc, ptr)) { | |
890 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
891 case BT_S: case BT_LF: case BT_CR: case BT_PERCNT: | |
892 *nextTokPtr = ptr; | |
893 return XML_TOK_PERCENT; | |
894 default: | |
895 *nextTokPtr = ptr; | |
896 return XML_TOK_INVALID; | |
897 } | |
898 while (ptr != end) { | |
899 switch (BYTE_TYPE(enc, ptr)) { | |
900 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
901 case BT_SEMI: | |
902 *nextTokPtr = ptr + MINBPC(enc); | |
903 return XML_TOK_PARAM_ENTITY_REF; | |
904 default: | |
905 *nextTokPtr = ptr; | |
906 return XML_TOK_INVALID; | |
907 } | |
908 } | |
909 return XML_TOK_PARTIAL; | |
910 } | |
911 | |
912 static int PTRCALL | |
913 PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end, | |
914 const char **nextTokPtr) | |
915 { | |
916 if (ptr == end) | |
917 return XML_TOK_PARTIAL; | |
918 switch (BYTE_TYPE(enc, ptr)) { | |
919 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
920 default: | |
921 *nextTokPtr = ptr; | |
922 return XML_TOK_INVALID; | |
923 } | |
924 while (ptr != end) { | |
925 switch (BYTE_TYPE(enc, ptr)) { | |
926 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
927 case BT_CR: case BT_LF: case BT_S: | |
928 case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR: | |
929 *nextTokPtr = ptr; | |
930 return XML_TOK_POUND_NAME; | |
931 default: | |
932 *nextTokPtr = ptr; | |
933 return XML_TOK_INVALID; | |
934 } | |
935 } | |
936 return -XML_TOK_POUND_NAME; | |
937 } | |
938 | |
939 static int PTRCALL | |
940 PREFIX(scanLit)(int open, const ENCODING *enc, | |
941 const char *ptr, const char *end, | |
942 const char **nextTokPtr) | |
943 { | |
944 while (ptr != end) { | |
945 int t = BYTE_TYPE(enc, ptr); | |
946 switch (t) { | |
947 INVALID_CASES(ptr, nextTokPtr) | |
948 case BT_QUOT: | |
949 case BT_APOS: | |
950 ptr += MINBPC(enc); | |
951 if (t != open) | |
952 break; | |
953 if (ptr == end) | |
954 return -XML_TOK_LITERAL; | |
955 *nextTokPtr = ptr; | |
956 switch (BYTE_TYPE(enc, ptr)) { | |
957 case BT_S: case BT_CR: case BT_LF: | |
958 case BT_GT: case BT_PERCNT: case BT_LSQB: | |
959 return XML_TOK_LITERAL; | |
960 default: | |
961 return XML_TOK_INVALID; | |
962 } | |
963 default: | |
964 ptr += MINBPC(enc); | |
965 break; | |
966 } | |
967 } | |
968 return XML_TOK_PARTIAL; | |
969 } | |
970 | |
971 static int PTRCALL | |
972 PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end, | |
973 const char **nextTokPtr) | |
974 { | |
975 int tok; | |
976 if (ptr == end) | |
977 return XML_TOK_NONE; | |
978 if (MINBPC(enc) > 1) { | |
979 size_t n = end - ptr; | |
980 if (n & (MINBPC(enc) - 1)) { | |
981 n &= ~(MINBPC(enc) - 1); | |
982 if (n == 0) | |
983 return XML_TOK_PARTIAL; | |
984 end = ptr + n; | |
985 } | |
986 } | |
987 switch (BYTE_TYPE(enc, ptr)) { | |
988 case BT_QUOT: | |
989 return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr); | |
990 case BT_APOS: | |
991 return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr); | |
992 case BT_LT: | |
993 { | |
994 ptr += MINBPC(enc); | |
995 if (ptr == end) | |
996 return XML_TOK_PARTIAL; | |
997 switch (BYTE_TYPE(enc, ptr)) { | |
998 case BT_EXCL: | |
999 return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
1000 case BT_QUEST: | |
1001 return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
1002 case BT_NMSTRT: | |
1003 case BT_HEX: | |
1004 case BT_NONASCII: | |
1005 case BT_LEAD2: | |
1006 case BT_LEAD3: | |
1007 case BT_LEAD4: | |
1008 *nextTokPtr = ptr - MINBPC(enc); | |
1009 return XML_TOK_INSTANCE_START; | |
1010 } | |
1011 *nextTokPtr = ptr; | |
1012 return XML_TOK_INVALID; | |
1013 } | |
1014 case BT_CR: | |
1015 if (ptr + MINBPC(enc) == end) { | |
1016 *nextTokPtr = end; | |
1017 /* indicate that this might be part of a CR/LF pair */ | |
1018 return -XML_TOK_PROLOG_S; | |
1019 } | |
1020 /* fall through */ | |
1021 case BT_S: case BT_LF: | |
1022 for (;;) { | |
1023 ptr += MINBPC(enc); | |
1024 if (ptr == end) | |
1025 break; | |
1026 switch (BYTE_TYPE(enc, ptr)) { | |
1027 case BT_S: case BT_LF: | |
1028 break; | |
1029 case BT_CR: | |
1030 /* don't split CR/LF pair */ | |
1031 if (ptr + MINBPC(enc) != end) | |
1032 break; | |
1033 /* fall through */ | |
1034 default: | |
1035 *nextTokPtr = ptr; | |
1036 return XML_TOK_PROLOG_S; | |
1037 } | |
1038 } | |
1039 *nextTokPtr = ptr; | |
1040 return XML_TOK_PROLOG_S; | |
1041 case BT_PERCNT: | |
1042 return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
1043 case BT_COMMA: | |
1044 *nextTokPtr = ptr + MINBPC(enc); | |
1045 return XML_TOK_COMMA; | |
1046 case BT_LSQB: | |
1047 *nextTokPtr = ptr + MINBPC(enc); | |
1048 return XML_TOK_OPEN_BRACKET; | |
1049 case BT_RSQB: | |
1050 ptr += MINBPC(enc); | |
1051 if (ptr == end) | |
1052 return -XML_TOK_CLOSE_BRACKET; | |
1053 if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) { | |
1054 if (ptr + MINBPC(enc) == end) | |
1055 return XML_TOK_PARTIAL; | |
1056 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) { | |
1057 *nextTokPtr = ptr + 2*MINBPC(enc); | |
1058 return XML_TOK_COND_SECT_CLOSE; | |
1059 } | |
1060 } | |
1061 *nextTokPtr = ptr; | |
1062 return XML_TOK_CLOSE_BRACKET; | |
1063 case BT_LPAR: | |
1064 *nextTokPtr = ptr + MINBPC(enc); | |
1065 return XML_TOK_OPEN_PAREN; | |
1066 case BT_RPAR: | |
1067 ptr += MINBPC(enc); | |
1068 if (ptr == end) | |
1069 return -XML_TOK_CLOSE_PAREN; | |
1070 switch (BYTE_TYPE(enc, ptr)) { | |
1071 case BT_AST: | |
1072 *nextTokPtr = ptr + MINBPC(enc); | |
1073 return XML_TOK_CLOSE_PAREN_ASTERISK; | |
1074 case BT_QUEST: | |
1075 *nextTokPtr = ptr + MINBPC(enc); | |
1076 return XML_TOK_CLOSE_PAREN_QUESTION; | |
1077 case BT_PLUS: | |
1078 *nextTokPtr = ptr + MINBPC(enc); | |
1079 return XML_TOK_CLOSE_PAREN_PLUS; | |
1080 case BT_CR: case BT_LF: case BT_S: | |
1081 case BT_GT: case BT_COMMA: case BT_VERBAR: | |
1082 case BT_RPAR: | |
1083 *nextTokPtr = ptr; | |
1084 return XML_TOK_CLOSE_PAREN; | |
1085 } | |
1086 *nextTokPtr = ptr; | |
1087 return XML_TOK_INVALID; | |
1088 case BT_VERBAR: | |
1089 *nextTokPtr = ptr + MINBPC(enc); | |
1090 return XML_TOK_OR; | |
1091 case BT_GT: | |
1092 *nextTokPtr = ptr + MINBPC(enc); | |
1093 return XML_TOK_DECL_CLOSE; | |
1094 case BT_NUM: | |
1095 return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
1096 #define LEAD_CASE(n) \ | |
1097 case BT_LEAD ## n: \ | |
1098 if (end - ptr < n) \ | |
1099 return XML_TOK_PARTIAL_CHAR; \ | |
1100 if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ | |
1101 ptr += n; \ | |
1102 tok = XML_TOK_NAME; \ | |
1103 break; \ | |
1104 } \ | |
1105 if (IS_NAME_CHAR(enc, ptr, n)) { \ | |
1106 ptr += n; \ | |
1107 tok = XML_TOK_NMTOKEN; \ | |
1108 break; \ | |
1109 } \ | |
1110 *nextTokPtr = ptr; \ | |
1111 return XML_TOK_INVALID; | |
1112 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
1113 #undef LEAD_CASE | |
1114 case BT_NMSTRT: | |
1115 case BT_HEX: | |
1116 tok = XML_TOK_NAME; | |
1117 ptr += MINBPC(enc); | |
1118 break; | |
1119 case BT_DIGIT: | |
1120 case BT_NAME: | |
1121 case BT_MINUS: | |
1122 #ifdef XML_NS | |
1123 case BT_COLON: | |
1124 #endif | |
1125 tok = XML_TOK_NMTOKEN; | |
1126 ptr += MINBPC(enc); | |
1127 break; | |
1128 case BT_NONASCII: | |
1129 if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { | |
1130 ptr += MINBPC(enc); | |
1131 tok = XML_TOK_NAME; | |
1132 break; | |
1133 } | |
1134 if (IS_NAME_CHAR_MINBPC(enc, ptr)) { | |
1135 ptr += MINBPC(enc); | |
1136 tok = XML_TOK_NMTOKEN; | |
1137 break; | |
1138 } | |
1139 /* fall through */ | |
1140 default: | |
1141 *nextTokPtr = ptr; | |
1142 return XML_TOK_INVALID; | |
1143 } | |
1144 while (ptr != end) { | |
1145 switch (BYTE_TYPE(enc, ptr)) { | |
1146 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
1147 case BT_GT: case BT_RPAR: case BT_COMMA: | |
1148 case BT_VERBAR: case BT_LSQB: case BT_PERCNT: | |
1149 case BT_S: case BT_CR: case BT_LF: | |
1150 *nextTokPtr = ptr; | |
1151 return tok; | |
1152 #ifdef XML_NS | |
1153 case BT_COLON: | |
1154 ptr += MINBPC(enc); | |
1155 switch (tok) { | |
1156 case XML_TOK_NAME: | |
1157 if (ptr == end) | |
1158 return XML_TOK_PARTIAL; | |
1159 tok = XML_TOK_PREFIXED_NAME; | |
1160 switch (BYTE_TYPE(enc, ptr)) { | |
1161 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
1162 default: | |
1163 tok = XML_TOK_NMTOKEN; | |
1164 break; | |
1165 } | |
1166 break; | |
1167 case XML_TOK_PREFIXED_NAME: | |
1168 tok = XML_TOK_NMTOKEN; | |
1169 break; | |
1170 } | |
1171 break; | |
1172 #endif | |
1173 case BT_PLUS: | |
1174 if (tok == XML_TOK_NMTOKEN) { | |
1175 *nextTokPtr = ptr; | |
1176 return XML_TOK_INVALID; | |
1177 } | |
1178 *nextTokPtr = ptr + MINBPC(enc); | |
1179 return XML_TOK_NAME_PLUS; | |
1180 case BT_AST: | |
1181 if (tok == XML_TOK_NMTOKEN) { | |
1182 *nextTokPtr = ptr; | |
1183 return XML_TOK_INVALID; | |
1184 } | |
1185 *nextTokPtr = ptr + MINBPC(enc); | |
1186 return XML_TOK_NAME_ASTERISK; | |
1187 case BT_QUEST: | |
1188 if (tok == XML_TOK_NMTOKEN) { | |
1189 *nextTokPtr = ptr; | |
1190 return XML_TOK_INVALID; | |
1191 } | |
1192 *nextTokPtr = ptr + MINBPC(enc); | |
1193 return XML_TOK_NAME_QUESTION; | |
1194 default: | |
1195 *nextTokPtr = ptr; | |
1196 return XML_TOK_INVALID; | |
1197 } | |
1198 } | |
1199 return -tok; | |
1200 } | |
1201 | |
1202 static int PTRCALL | |
1203 PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, | |
1204 const char *end, const char **nextTokPtr) | |
1205 { | |
1206 const char *start; | |
1207 if (ptr == end) | |
1208 return XML_TOK_NONE; | |
1209 start = ptr; | |
1210 while (ptr != end) { | |
1211 switch (BYTE_TYPE(enc, ptr)) { | |
1212 #define LEAD_CASE(n) \ | |
1213 case BT_LEAD ## n: ptr += n; break; | |
1214 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
1215 #undef LEAD_CASE | |
1216 case BT_AMP: | |
1217 if (ptr == start) | |
1218 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
1219 *nextTokPtr = ptr; | |
1220 return XML_TOK_DATA_CHARS; | |
1221 case BT_LT: | |
1222 /* this is for inside entity references */ | |
1223 *nextTokPtr = ptr; | |
1224 return XML_TOK_INVALID; | |
1225 case BT_LF: | |
1226 if (ptr == start) { | |
1227 *nextTokPtr = ptr + MINBPC(enc); | |
1228 return XML_TOK_DATA_NEWLINE; | |
1229 } | |
1230 *nextTokPtr = ptr; | |
1231 return XML_TOK_DATA_CHARS; | |
1232 case BT_CR: | |
1233 if (ptr == start) { | |
1234 ptr += MINBPC(enc); | |
1235 if (ptr == end) | |
1236 return XML_TOK_TRAILING_CR; | |
1237 if (BYTE_TYPE(enc, ptr) == BT_LF) | |
1238 ptr += MINBPC(enc); | |
1239 *nextTokPtr = ptr; | |
1240 return XML_TOK_DATA_NEWLINE; | |
1241 } | |
1242 *nextTokPtr = ptr; | |
1243 return XML_TOK_DATA_CHARS; | |
1244 case BT_S: | |
1245 if (ptr == start) { | |
1246 *nextTokPtr = ptr + MINBPC(enc); | |
1247 return XML_TOK_ATTRIBUTE_VALUE_S; | |
1248 } | |
1249 *nextTokPtr = ptr; | |
1250 return XML_TOK_DATA_CHARS; | |
1251 default: | |
1252 ptr += MINBPC(enc); | |
1253 break; | |
1254 } | |
1255 } | |
1256 *nextTokPtr = ptr; | |
1257 return XML_TOK_DATA_CHARS; | |
1258 } | |
1259 | |
1260 static int PTRCALL | |
1261 PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, | |
1262 const char *end, const char **nextTokPtr) | |
1263 { | |
1264 const char *start; | |
1265 if (ptr == end) | |
1266 return XML_TOK_NONE; | |
1267 start = ptr; | |
1268 while (ptr != end) { | |
1269 switch (BYTE_TYPE(enc, ptr)) { | |
1270 #define LEAD_CASE(n) \ | |
1271 case BT_LEAD ## n: ptr += n; break; | |
1272 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
1273 #undef LEAD_CASE | |
1274 case BT_AMP: | |
1275 if (ptr == start) | |
1276 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
1277 *nextTokPtr = ptr; | |
1278 return XML_TOK_DATA_CHARS; | |
1279 case BT_PERCNT: | |
1280 if (ptr == start) { | |
1281 int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), | |
1282 end, nextTokPtr); | |
1283 return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok; | |
1284 } | |
1285 *nextTokPtr = ptr; | |
1286 return XML_TOK_DATA_CHARS; | |
1287 case BT_LF: | |
1288 if (ptr == start) { | |
1289 *nextTokPtr = ptr + MINBPC(enc); | |
1290 return XML_TOK_DATA_NEWLINE; | |
1291 } | |
1292 *nextTokPtr = ptr; | |
1293 return XML_TOK_DATA_CHARS; | |
1294 case BT_CR: | |
1295 if (ptr == start) { | |
1296 ptr += MINBPC(enc); | |
1297 if (ptr == end) | |
1298 return XML_TOK_TRAILING_CR; | |
1299 if (BYTE_TYPE(enc, ptr) == BT_LF) | |
1300 ptr += MINBPC(enc); | |
1301 *nextTokPtr = ptr; | |
1302 return XML_TOK_DATA_NEWLINE; | |
1303 } | |
1304 *nextTokPtr = ptr; | |
1305 return XML_TOK_DATA_CHARS; | |
1306 default: | |
1307 ptr += MINBPC(enc); | |
1308 break; | |
1309 } | |
1310 } | |
1311 *nextTokPtr = ptr; | |
1312 return XML_TOK_DATA_CHARS; | |
1313 } | |
1314 | |
1315 #ifdef XML_DTD | |
1316 | |
1317 static int PTRCALL | |
1318 PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, | |
1319 const char *end, const char **nextTokPtr) | |
1320 { | |
1321 int level = 0; | |
1322 if (MINBPC(enc) > 1) { | |
1323 size_t n = end - ptr; | |
1324 if (n & (MINBPC(enc) - 1)) { | |
1325 n &= ~(MINBPC(enc) - 1); | |
1326 end = ptr + n; | |
1327 } | |
1328 } | |
1329 while (ptr != end) { | |
1330 switch (BYTE_TYPE(enc, ptr)) { | |
1331 INVALID_CASES(ptr, nextTokPtr) | |
1332 case BT_LT: | |
1333 if ((ptr += MINBPC(enc)) == end) | |
1334 return XML_TOK_PARTIAL; | |
1335 if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) { | |
1336 if ((ptr += MINBPC(enc)) == end) | |
1337 return XML_TOK_PARTIAL; | |
1338 if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) { | |
1339 ++level; | |
1340 ptr += MINBPC(enc); | |
1341 } | |
1342 } | |
1343 break; | |
1344 case BT_RSQB: | |
1345 if ((ptr += MINBPC(enc)) == end) | |
1346 return XML_TOK_PARTIAL; | |
1347 if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) { | |
1348 if ((ptr += MINBPC(enc)) == end) | |
1349 return XML_TOK_PARTIAL; | |
1350 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
1351 ptr += MINBPC(enc); | |
1352 if (level == 0) { | |
1353 *nextTokPtr = ptr; | |
1354 return XML_TOK_IGNORE_SECT; | |
1355 } | |
1356 --level; | |
1357 } | |
1358 } | |
1359 break; | |
1360 default: | |
1361 ptr += MINBPC(enc); | |
1362 break; | |
1363 } | |
1364 } | |
1365 return XML_TOK_PARTIAL; | |
1366 } | |
1367 | |
1368 #endif /* XML_DTD */ | |
1369 | |
1370 static int PTRCALL | |
1371 PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end, | |
1372 const char **badPtr) | |
1373 { | |
1374 ptr += MINBPC(enc); | |
1375 end -= MINBPC(enc); | |
1376 for (; ptr != end; ptr += MINBPC(enc)) { | |
1377 switch (BYTE_TYPE(enc, ptr)) { | |
1378 case BT_DIGIT: | |
1379 case BT_HEX: | |
1380 case BT_MINUS: | |
1381 case BT_APOS: | |
1382 case BT_LPAR: | |
1383 case BT_RPAR: | |
1384 case BT_PLUS: | |
1385 case BT_COMMA: | |
1386 case BT_SOL: | |
1387 case BT_EQUALS: | |
1388 case BT_QUEST: | |
1389 case BT_CR: | |
1390 case BT_LF: | |
1391 case BT_SEMI: | |
1392 case BT_EXCL: | |
1393 case BT_AST: | |
1394 case BT_PERCNT: | |
1395 case BT_NUM: | |
1396 #ifdef XML_NS | |
1397 case BT_COLON: | |
1398 #endif | |
1399 break; | |
1400 case BT_S: | |
1401 if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) { | |
1402 *badPtr = ptr; | |
1403 return 0; | |
1404 } | |
1405 break; | |
1406 case BT_NAME: | |
1407 case BT_NMSTRT: | |
1408 if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f)) | |
1409 break; | |
1410 default: | |
1411 switch (BYTE_TO_ASCII(enc, ptr)) { | |
1412 case 0x24: /* $ */ | |
1413 case 0x40: /* @ */ | |
1414 break; | |
1415 default: | |
1416 *badPtr = ptr; | |
1417 return 0; | |
1418 } | |
1419 break; | |
1420 } | |
1421 } | |
1422 return 1; | |
1423 } | |
1424 | |
1425 /* This must only be called for a well-formed start-tag or empty | |
1426 element tag. Returns the number of attributes. Pointers to the | |
1427 first attsMax attributes are stored in atts. | |
1428 */ | |
1429 | |
1430 static int PTRCALL | |
1431 PREFIX(getAtts)(const ENCODING *enc, const char *ptr, | |
1432 int attsMax, ATTRIBUTE *atts) | |
1433 { | |
1434 enum { other, inName, inValue } state = inName; | |
1435 int nAtts = 0; | |
1436 int open = 0; /* defined when state == inValue; | |
1437 initialization just to shut up compilers */ | |
1438 | |
1439 for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) { | |
1440 switch (BYTE_TYPE(enc, ptr)) { | |
1441 #define START_NAME \ | |
1442 if (state == other) { \ | |
1443 if (nAtts < attsMax) { \ | |
1444 atts[nAtts].name = ptr; \ | |
1445 atts[nAtts].normalized = 1; \ | |
1446 } \ | |
1447 state = inName; \ | |
1448 } | |
1449 #define LEAD_CASE(n) \ | |
1450 case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break; | |
1451 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
1452 #undef LEAD_CASE | |
1453 case BT_NONASCII: | |
1454 case BT_NMSTRT: | |
1455 case BT_HEX: | |
1456 START_NAME | |
1457 break; | |
1458 #undef START_NAME | |
1459 case BT_QUOT: | |
1460 if (state != inValue) { | |
1461 if (nAtts < attsMax) | |
1462 atts[nAtts].valuePtr = ptr + MINBPC(enc); | |
1463 state = inValue; | |
1464 open = BT_QUOT; | |
1465 } | |
1466 else if (open == BT_QUOT) { | |
1467 state = other; | |
1468 if (nAtts < attsMax) | |
1469 atts[nAtts].valueEnd = ptr; | |
1470 nAtts++; | |
1471 } | |
1472 break; | |
1473 case BT_APOS: | |
1474 if (state != inValue) { | |
1475 if (nAtts < attsMax) | |
1476 atts[nAtts].valuePtr = ptr + MINBPC(enc); | |
1477 state = inValue; | |
1478 open = BT_APOS; | |
1479 } | |
1480 else if (open == BT_APOS) { | |
1481 state = other; | |
1482 if (nAtts < attsMax) | |
1483 atts[nAtts].valueEnd = ptr; | |
1484 nAtts++; | |
1485 } | |
1486 break; | |
1487 case BT_AMP: | |
1488 if (nAtts < attsMax) | |
1489 atts[nAtts].normalized = 0; | |
1490 break; | |
1491 case BT_S: | |
1492 if (state == inName) | |
1493 state = other; | |
1494 else if (state == inValue | |
1495 && nAtts < attsMax | |
1496 && atts[nAtts].normalized | |
1497 && (ptr == atts[nAtts].valuePtr | |
1498 || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE | |
1499 || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE | |
1500 || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open)) | |
1501 atts[nAtts].normalized = 0; | |
1502 break; | |
1503 case BT_CR: case BT_LF: | |
1504 /* This case ensures that the first attribute name is counted | |
1505 Apart from that we could just change state on the quote. */ | |
1506 if (state == inName) | |
1507 state = other; | |
1508 else if (state == inValue && nAtts < attsMax) | |
1509 atts[nAtts].normalized = 0; | |
1510 break; | |
1511 case BT_GT: | |
1512 case BT_SOL: | |
1513 if (state != inValue) | |
1514 return nAtts; | |
1515 break; | |
1516 default: | |
1517 break; | |
1518 } | |
1519 } | |
1520 /* not reached */ | |
1521 } | |
1522 | |
1523 static int PTRFASTCALL | |
1524 PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) | |
1525 { | |
1526 int result = 0; | |
1527 /* skip &# */ | |
1528 ptr += 2*MINBPC(enc); | |
1529 if (CHAR_MATCHES(enc, ptr, ASCII_x)) { | |
1530 for (ptr += MINBPC(enc); | |
1531 !CHAR_MATCHES(enc, ptr, ASCII_SEMI); | |
1532 ptr += MINBPC(enc)) { | |
1533 int c = BYTE_TO_ASCII(enc, ptr); | |
1534 switch (c) { | |
1535 case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4: | |
1536 case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9: | |
1537 result <<= 4; | |
1538 result |= (c - ASCII_0); | |
1539 break; | |
1540 case ASCII_A: case ASCII_B: case ASCII_C: | |
1541 case ASCII_D: case ASCII_E: case ASCII_F: | |
1542 result <<= 4; | |
1543 result += 10 + (c - ASCII_A); | |
1544 break; | |
1545 case ASCII_a: case ASCII_b: case ASCII_c: | |
1546 case ASCII_d: case ASCII_e: case ASCII_f: | |
1547 result <<= 4; | |
1548 result += 10 + (c - ASCII_a); | |
1549 break; | |
1550 } | |
1551 if (result >= 0x110000) | |
1552 return -1; | |
1553 } | |
1554 } | |
1555 else { | |
1556 for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) { | |
1557 int c = BYTE_TO_ASCII(enc, ptr); | |
1558 result *= 10; | |
1559 result += (c - ASCII_0); | |
1560 if (result >= 0x110000) | |
1561 return -1; | |
1562 } | |
1563 } | |
1564 return checkCharRefNumber(result); | |
1565 } | |
1566 | |
1567 static int PTRCALL | |
1568 PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr, | |
1569 const char *end) | |
1570 { | |
1571 switch ((end - ptr)/MINBPC(enc)) { | |
1572 case 2: | |
1573 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) { | |
1574 switch (BYTE_TO_ASCII(enc, ptr)) { | |
1575 case ASCII_l: | |
1576 return ASCII_LT; | |
1577 case ASCII_g: | |
1578 return ASCII_GT; | |
1579 } | |
1580 } | |
1581 break; | |
1582 case 3: | |
1583 if (CHAR_MATCHES(enc, ptr, ASCII_a)) { | |
1584 ptr += MINBPC(enc); | |
1585 if (CHAR_MATCHES(enc, ptr, ASCII_m)) { | |
1586 ptr += MINBPC(enc); | |
1587 if (CHAR_MATCHES(enc, ptr, ASCII_p)) | |
1588 return ASCII_AMP; | |
1589 } | |
1590 } | |
1591 break; | |
1592 case 4: | |
1593 switch (BYTE_TO_ASCII(enc, ptr)) { | |
1594 case ASCII_q: | |
1595 ptr += MINBPC(enc); | |
1596 if (CHAR_MATCHES(enc, ptr, ASCII_u)) { | |
1597 ptr += MINBPC(enc); | |
1598 if (CHAR_MATCHES(enc, ptr, ASCII_o)) { | |
1599 ptr += MINBPC(enc); | |
1600 if (CHAR_MATCHES(enc, ptr, ASCII_t)) | |
1601 return ASCII_QUOT; | |
1602 } | |
1603 } | |
1604 break; | |
1605 case ASCII_a: | |
1606 ptr += MINBPC(enc); | |
1607 if (CHAR_MATCHES(enc, ptr, ASCII_p)) { | |
1608 ptr += MINBPC(enc); | |
1609 if (CHAR_MATCHES(enc, ptr, ASCII_o)) { | |
1610 ptr += MINBPC(enc); | |
1611 if (CHAR_MATCHES(enc, ptr, ASCII_s)) | |
1612 return ASCII_APOS; | |
1613 } | |
1614 } | |
1615 break; | |
1616 } | |
1617 } | |
1618 return 0; | |
1619 } | |
1620 | |
1621 static int PTRCALL | |
1622 PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2) | |
1623 { | |
1624 for (;;) { | |
1625 switch (BYTE_TYPE(enc, ptr1)) { | |
1626 #define LEAD_CASE(n) \ | |
1627 case BT_LEAD ## n: \ | |
1628 if (*ptr1++ != *ptr2++) \ | |
1629 return 0; | |
1630 LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2) | |
1631 #undef LEAD_CASE | |
1632 /* fall through */ | |
1633 if (*ptr1++ != *ptr2++) | |
1634 return 0; | |
1635 break; | |
1636 case BT_NONASCII: | |
1637 case BT_NMSTRT: | |
1638 #ifdef XML_NS | |
1639 case BT_COLON: | |
1640 #endif | |
1641 case BT_HEX: | |
1642 case BT_DIGIT: | |
1643 case BT_NAME: | |
1644 case BT_MINUS: | |
1645 if (*ptr2++ != *ptr1++) | |
1646 return 0; | |
1647 if (MINBPC(enc) > 1) { | |
1648 if (*ptr2++ != *ptr1++) | |
1649 return 0; | |
1650 if (MINBPC(enc) > 2) { | |
1651 if (*ptr2++ != *ptr1++) | |
1652 return 0; | |
1653 if (MINBPC(enc) > 3) { | |
1654 if (*ptr2++ != *ptr1++) | |
1655 return 0; | |
1656 } | |
1657 } | |
1658 } | |
1659 break; | |
1660 default: | |
1661 if (MINBPC(enc) == 1 && *ptr1 == *ptr2) | |
1662 return 1; | |
1663 switch (BYTE_TYPE(enc, ptr2)) { | |
1664 case BT_LEAD2: | |
1665 case BT_LEAD3: | |
1666 case BT_LEAD4: | |
1667 case BT_NONASCII: | |
1668 case BT_NMSTRT: | |
1669 #ifdef XML_NS | |
1670 case BT_COLON: | |
1671 #endif | |
1672 case BT_HEX: | |
1673 case BT_DIGIT: | |
1674 case BT_NAME: | |
1675 case BT_MINUS: | |
1676 return 0; | |
1677 default: | |
1678 return 1; | |
1679 } | |
1680 } | |
1681 } | |
1682 /* not reached */ | |
1683 } | |
1684 | |
1685 static int PTRCALL | |
1686 PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1, | |
1687 const char *end1, const char *ptr2) | |
1688 { | |
1689 for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) { | |
1690 if (ptr1 == end1) | |
1691 return 0; | |
1692 if (!CHAR_MATCHES(enc, ptr1, *ptr2)) | |
1693 return 0; | |
1694 } | |
1695 return ptr1 == end1; | |
1696 } | |
1697 | |
1698 static int PTRFASTCALL | |
1699 PREFIX(nameLength)(const ENCODING *enc, const char *ptr) | |
1700 { | |
1701 const char *start = ptr; | |
1702 for (;;) { | |
1703 switch (BYTE_TYPE(enc, ptr)) { | |
1704 #define LEAD_CASE(n) \ | |
1705 case BT_LEAD ## n: ptr += n; break; | |
1706 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
1707 #undef LEAD_CASE | |
1708 case BT_NONASCII: | |
1709 case BT_NMSTRT: | |
1710 #ifdef XML_NS | |
1711 case BT_COLON: | |
1712 #endif | |
1713 case BT_HEX: | |
1714 case BT_DIGIT: | |
1715 case BT_NAME: | |
1716 case BT_MINUS: | |
1717 ptr += MINBPC(enc); | |
1718 break; | |
1719 default: | |
1720 return (int)(ptr - start); | |
1721 } | |
1722 } | |
1723 } | |
1724 | |
1725 static const char * PTRFASTCALL | |
1726 PREFIX(skipS)(const ENCODING *enc, const char *ptr) | |
1727 { | |
1728 for (;;) { | |
1729 switch (BYTE_TYPE(enc, ptr)) { | |
1730 case BT_LF: | |
1731 case BT_CR: | |
1732 case BT_S: | |
1733 ptr += MINBPC(enc); | |
1734 break; | |
1735 default: | |
1736 return ptr; | |
1737 } | |
1738 } | |
1739 } | |
1740 | |
1741 static void PTRCALL | |
1742 PREFIX(updatePosition)(const ENCODING *enc, | |
1743 const char *ptr, | |
1744 const char *end, | |
1745 POSITION *pos) | |
1746 { | |
1747 while (ptr < end) { | |
1748 switch (BYTE_TYPE(enc, ptr)) { | |
1749 #define LEAD_CASE(n) \ | |
1750 case BT_LEAD ## n: \ | |
1751 ptr += n; \ | |
1752 break; | |
1753 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
1754 #undef LEAD_CASE | |
1755 case BT_LF: | |
1756 pos->columnNumber = (XML_Size)-1; | |
1757 pos->lineNumber++; | |
1758 ptr += MINBPC(enc); | |
1759 break; | |
1760 case BT_CR: | |
1761 pos->lineNumber++; | |
1762 ptr += MINBPC(enc); | |
1763 if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF) | |
1764 ptr += MINBPC(enc); | |
1765 pos->columnNumber = (XML_Size)-1; | |
1766 break; | |
1767 default: | |
1768 ptr += MINBPC(enc); | |
1769 break; | |
1770 } | |
1771 pos->columnNumber++; | |
1772 } | |
1773 } | |
1774 | |
1775 #undef DO_LEAD_CASE | |
1776 #undef MULTIBYTE_CASES | |
1777 #undef INVALID_CASES | |
1778 #undef CHECK_NAME_CASE | |
1779 #undef CHECK_NAME_CASES | |
1780 #undef CHECK_NMSTRT_CASE | |
1781 #undef CHECK_NMSTRT_CASES | |
1782 | |
1783 #endif /* XML_TOK_IMPL_C */ | |
OLD | NEW |