Mercurial > pidgin3 / file comparison

comparison: src/protocols/jabber/xmltok_impl.c

src/protocols/jabber/xmltok_impl.c

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

Mercurial Repository: pidgin3

mercurial