Deleted Added
sdiff udiff text old ( 104349 ) new ( 178848 )
full compact
xmltok_impl.c (104349) xmltok_impl.c (178848)
1/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
2 See the file COPYING for copying permission.
3*/
4
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
5#ifndef IS_INVALID_CHAR
6#define IS_INVALID_CHAR(enc, ptr, n) (0)
7#endif
8
9#define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
10 case BT_LEAD ## n: \
11 if (end - ptr < n) \
12 return XML_TOK_PARTIAL_CHAR; \

--- 68 unchanged lines hidden (view full) ---

81 CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
82
83#ifndef PREFIX
84#define PREFIX(ident) ident
85#endif
86
87/* ptr points to character following "<!-" */
88
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; \

--- 68 unchanged lines hidden (view full) ---

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
89static int FASTCALL
92static int PTRCALL
90PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
91 const char *end, const char **nextTokPtr)
92{
93 if (ptr != end) {
94 if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
95 *nextTokPtr = ptr;
96 return XML_TOK_INVALID;
97 }

--- 21 unchanged lines hidden (view full) ---

119 }
120 }
121 }
122 return XML_TOK_PARTIAL;
123}
124
125/* ptr points to character following "<!" */
126
93PREFIX(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 }

--- 21 unchanged lines hidden (view full) ---

122 }
123 }
124 }
125 return XML_TOK_PARTIAL;
126}
127
128/* ptr points to character following "<!" */
129
127static int FASTCALL
130static int PTRCALL
128PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
129 const char *end, const char **nextTokPtr)
130{
131 if (ptr == end)
132 return XML_TOK_PARTIAL;
133 switch (BYTE_TYPE(enc, ptr)) {
134 case BT_MINUS:
135 return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);

--- 30 unchanged lines hidden (view full) ---

166 default:
167 *nextTokPtr = ptr;
168 return XML_TOK_INVALID;
169 }
170 }
171 return XML_TOK_PARTIAL;
172}
173
131PREFIX(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);

--- 30 unchanged lines hidden (view full) ---

169 default:
170 *nextTokPtr = ptr;
171 return XML_TOK_INVALID;
172 }
173 }
174 return XML_TOK_PARTIAL;
175}
176
174static int FASTCALL
177static int PTRCALL
175PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr,
176 const char *end, int *tokPtr)
177{
178 int upper = 0;
179 *tokPtr = XML_TOK_PI;
180 if (end - ptr != MINBPC(enc)*3)
181 return 1;
182 switch (BYTE_TO_ASCII(enc, ptr)) {

--- 28 unchanged lines hidden (view full) ---

211 if (upper)
212 return 0;
213 *tokPtr = XML_TOK_XML_DECL;
214 return 1;
215}
216
217/* ptr points to character following "<?" */
218
178PREFIX(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)) {

--- 28 unchanged lines hidden (view full) ---

214 if (upper)
215 return 0;
216 *tokPtr = XML_TOK_XML_DECL;
217 return 1;
218}
219
220/* ptr points to character following "<?" */
221
219static int FASTCALL
222static int PTRCALL
220PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
221 const char *end, const char **nextTokPtr)
222{
223 int tok;
224 const char *target = ptr;
225 if (ptr == end)
226 return XML_TOK_PARTIAL;
227 switch (BYTE_TYPE(enc, ptr)) {

--- 45 unchanged lines hidden (view full) ---

273 default:
274 *nextTokPtr = ptr;
275 return XML_TOK_INVALID;
276 }
277 }
278 return XML_TOK_PARTIAL;
279}
280
223PREFIX(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)) {

--- 45 unchanged lines hidden (view full) ---

276 default:
277 *nextTokPtr = ptr;
278 return XML_TOK_INVALID;
279 }
280 }
281 return XML_TOK_PARTIAL;
282}
283
281static int FASTCALL
284static int PTRCALL
282PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr,
283 const char *end, const char **nextTokPtr)
284{
285 static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A,
286 ASCII_T, ASCII_A, ASCII_LSQB };
287 int i;
288 /* CDATA[ */
289 if (end - ptr < 6 * MINBPC(enc))
290 return XML_TOK_PARTIAL;
291 for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
292 if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
293 *nextTokPtr = ptr;
294 return XML_TOK_INVALID;
295 }
296 }
297 *nextTokPtr = ptr;
298 return XML_TOK_CDATA_SECT_OPEN;
299}
300
285PREFIX(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
301static int FASTCALL
304static int PTRCALL
302PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
303 const char *end, const char **nextTokPtr)
304{
305 if (ptr == end)
306 return XML_TOK_NONE;
307 if (MINBPC(enc) > 1) {
308 size_t n = end - ptr;
309 if (n & (MINBPC(enc) - 1)) {

--- 61 unchanged lines hidden (view full) ---

371 }
372 }
373 *nextTokPtr = ptr;
374 return XML_TOK_DATA_CHARS;
375}
376
377/* ptr points to character following "</" */
378
305PREFIX(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)) {

--- 61 unchanged lines hidden (view full) ---

374 }
375 }
376 *nextTokPtr = ptr;
377 return XML_TOK_DATA_CHARS;
378}
379
380/* ptr points to character following "</" */
381
379static int FASTCALL
382static int PTRCALL
380PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
381 const char *end, const char **nextTokPtr)
382{
383 if (ptr == end)
384 return XML_TOK_PARTIAL;
385 switch (BYTE_TYPE(enc, ptr)) {
386 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
387 default:

--- 32 unchanged lines hidden (view full) ---

420 return XML_TOK_INVALID;
421 }
422 }
423 return XML_TOK_PARTIAL;
424}
425
426/* ptr points to character following "&#X" */
427
383PREFIX(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:

--- 32 unchanged lines hidden (view full) ---

423 return XML_TOK_INVALID;
424 }
425 }
426 return XML_TOK_PARTIAL;
427}
428
429/* ptr points to character following "&#X" */
430
428static int FASTCALL
431static int PTRCALL
429PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
430 const char *end, const char **nextTokPtr)
431{
432 if (ptr != end) {
433 switch (BYTE_TYPE(enc, ptr)) {
434 case BT_DIGIT:
435 case BT_HEX:
436 break;

--- 15 unchanged lines hidden (view full) ---

452 }
453 }
454 }
455 return XML_TOK_PARTIAL;
456}
457
458/* ptr points to character following "&#" */
459
432PREFIX(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;

--- 15 unchanged lines hidden (view full) ---

455 }
456 }
457 }
458 return XML_TOK_PARTIAL;
459}
460
461/* ptr points to character following "&#" */
462
460static int FASTCALL
463static int PTRCALL
461PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
462 const char *end, const char **nextTokPtr)
463{
464 if (ptr != end) {
465 if (CHAR_MATCHES(enc, ptr, ASCII_x))
466 return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
467 switch (BYTE_TYPE(enc, ptr)) {
468 case BT_DIGIT:

--- 15 unchanged lines hidden (view full) ---

484 }
485 }
486 }
487 return XML_TOK_PARTIAL;
488}
489
490/* ptr points to character following "&" */
491
464PREFIX(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:

--- 15 unchanged lines hidden (view full) ---

487 }
488 }
489 }
490 return XML_TOK_PARTIAL;
491}
492
493/* ptr points to character following "&" */
494
492static int FASTCALL
495static int PTRCALL
493PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
494 const char **nextTokPtr)
495{
496 if (ptr == end)
497 return XML_TOK_PARTIAL;
498 switch (BYTE_TYPE(enc, ptr)) {
499 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
500 case BT_NUM:

--- 13 unchanged lines hidden (view full) ---

514 return XML_TOK_INVALID;
515 }
516 }
517 return XML_TOK_PARTIAL;
518}
519
520/* ptr points to character following first character of attribute name */
521
496PREFIX(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:

--- 13 unchanged lines hidden (view full) ---

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
522static int FASTCALL
525static int PTRCALL
523PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
524 const char **nextTokPtr)
525{
526#ifdef XML_NS
527 int hadColon = 0;
528#endif
529 while (ptr != end) {
530 switch (BYTE_TYPE(enc, ptr)) {

--- 142 unchanged lines hidden (view full) ---

673 return XML_TOK_INVALID;
674 }
675 }
676 return XML_TOK_PARTIAL;
677}
678
679/* ptr points to character following "<" */
680
526PREFIX(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)) {

--- 142 unchanged lines hidden (view full) ---

676 return XML_TOK_INVALID;
677 }
678 }
679 return XML_TOK_PARTIAL;
680}
681
682/* ptr points to character following "<" */
683
681static int FASTCALL
684static int PTRCALL
682PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
683 const char **nextTokPtr)
684{
685#ifdef XML_NS
686 int hadColon;
687#endif
688 if (ptr == end)
689 return XML_TOK_PARTIAL;

--- 83 unchanged lines hidden (view full) ---

773 default:
774 *nextTokPtr = ptr;
775 return XML_TOK_INVALID;
776 }
777 }
778 return XML_TOK_PARTIAL;
779}
780
685PREFIX(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;

--- 83 unchanged lines hidden (view full) ---

776 default:
777 *nextTokPtr = ptr;
778 return XML_TOK_INVALID;
779 }
780 }
781 return XML_TOK_PARTIAL;
782}
783
781static int FASTCALL
784static int PTRCALL
782PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
783 const char **nextTokPtr)
784{
785 if (ptr == end)
786 return XML_TOK_NONE;
787 if (MINBPC(enc) > 1) {
788 size_t n = end - ptr;
789 if (n & (MINBPC(enc) - 1)) {

--- 82 unchanged lines hidden (view full) ---

872 }
873 }
874 *nextTokPtr = ptr;
875 return XML_TOK_DATA_CHARS;
876}
877
878/* ptr points to character following "%" */
879
785PREFIX(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)) {

--- 82 unchanged lines hidden (view full) ---

875 }
876 }
877 *nextTokPtr = ptr;
878 return XML_TOK_DATA_CHARS;
879}
880
881/* ptr points to character following "%" */
882
880static int FASTCALL
883static int PTRCALL
881PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
882 const char **nextTokPtr)
883{
884 if (ptr == end)
884PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
885 const char **nextTokPtr)
886{
887 if (ptr == end)
885 return XML_TOK_PARTIAL;
888 return -XML_TOK_PERCENT;
886 switch (BYTE_TYPE(enc, ptr)) {
887 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
888 case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
889 *nextTokPtr = ptr;
890 return XML_TOK_PERCENT;
891 default:
892 *nextTokPtr = ptr;
893 return XML_TOK_INVALID;

--- 7 unchanged lines hidden (view full) ---

901 default:
902 *nextTokPtr = ptr;
903 return XML_TOK_INVALID;
904 }
905 }
906 return XML_TOK_PARTIAL;
907}
908
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;

--- 7 unchanged lines hidden (view full) ---

904 default:
905 *nextTokPtr = ptr;
906 return XML_TOK_INVALID;
907 }
908 }
909 return XML_TOK_PARTIAL;
910}
911
909static int FASTCALL
912static int PTRCALL
910PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
911 const char **nextTokPtr)
912{
913 if (ptr == end)
914 return XML_TOK_PARTIAL;
915 switch (BYTE_TYPE(enc, ptr)) {
916 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
917 default:

--- 10 unchanged lines hidden (view full) ---

928 default:
929 *nextTokPtr = ptr;
930 return XML_TOK_INVALID;
931 }
932 }
933 return -XML_TOK_POUND_NAME;
934}
935
913PREFIX(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:

--- 10 unchanged lines hidden (view full) ---

931 default:
932 *nextTokPtr = ptr;
933 return XML_TOK_INVALID;
934 }
935 }
936 return -XML_TOK_POUND_NAME;
937}
938
936static int FASTCALL
939static int PTRCALL
937PREFIX(scanLit)(int open, const ENCODING *enc,
938 const char *ptr, const char *end,
939 const char **nextTokPtr)
940{
941 while (ptr != end) {
942 int t = BYTE_TYPE(enc, ptr);
943 switch (t) {
944 INVALID_CASES(ptr, nextTokPtr)

--- 15 unchanged lines hidden (view full) ---

960 default:
961 ptr += MINBPC(enc);
962 break;
963 }
964 }
965 return XML_TOK_PARTIAL;
966}
967
940PREFIX(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)

--- 15 unchanged lines hidden (view full) ---

963 default:
964 ptr += MINBPC(enc);
965 break;
966 }
967 }
968 return XML_TOK_PARTIAL;
969}
970
968static int FASTCALL
971static int PTRCALL
969PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
970 const char **nextTokPtr)
971{
972 int tok;
973 if (ptr == end)
974 return XML_TOK_NONE;
975 if (MINBPC(enc) > 1) {
976 size_t n = end - ptr;

--- 214 unchanged lines hidden (view full) ---

1191 default:
1192 *nextTokPtr = ptr;
1193 return XML_TOK_INVALID;
1194 }
1195 }
1196 return -tok;
1197}
1198
972PREFIX(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;

--- 214 unchanged lines hidden (view full) ---

1194 default:
1195 *nextTokPtr = ptr;
1196 return XML_TOK_INVALID;
1197 }
1198 }
1199 return -tok;
1200}
1201
1199static int FASTCALL
1202static int PTRCALL
1200PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
1201 const char *end, const char **nextTokPtr)
1202{
1203 const char *start;
1204 if (ptr == end)
1205 return XML_TOK_NONE;
1206 start = ptr;
1207 while (ptr != end) {

--- 41 unchanged lines hidden (view full) ---

1249 ptr += MINBPC(enc);
1250 break;
1251 }
1252 }
1253 *nextTokPtr = ptr;
1254 return XML_TOK_DATA_CHARS;
1255}
1256
1203PREFIX(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) {

--- 41 unchanged lines hidden (view full) ---

1252 ptr += MINBPC(enc);
1253 break;
1254 }
1255 }
1256 *nextTokPtr = ptr;
1257 return XML_TOK_DATA_CHARS;
1258}
1259
1257static int FASTCALL
1260static int PTRCALL
1258PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
1259 const char *end, const char **nextTokPtr)
1260{
1261 const char *start;
1262 if (ptr == end)
1263 return XML_TOK_NONE;
1264 start = ptr;
1265 while (ptr != end) {

--- 40 unchanged lines hidden (view full) ---

1306 }
1307 }
1308 *nextTokPtr = ptr;
1309 return XML_TOK_DATA_CHARS;
1310}
1311
1312#ifdef XML_DTD
1313
1261PREFIX(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) {

--- 40 unchanged lines hidden (view full) ---

1309 }
1310 }
1311 *nextTokPtr = ptr;
1312 return XML_TOK_DATA_CHARS;
1313}
1314
1315#ifdef XML_DTD
1316
1314static int FASTCALL
1317static int PTRCALL
1315PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
1316 const char *end, const char **nextTokPtr)
1317{
1318 int level = 0;
1319 if (MINBPC(enc) > 1) {
1320 size_t n = end - ptr;
1321 if (n & (MINBPC(enc) - 1)) {
1322 n &= ~(MINBPC(enc) - 1);

--- 36 unchanged lines hidden (view full) ---

1359 break;
1360 }
1361 }
1362 return XML_TOK_PARTIAL;
1363}
1364
1365#endif /* XML_DTD */
1366
1318PREFIX(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);

--- 36 unchanged lines hidden (view full) ---

1362 break;
1363 }
1364 }
1365 return XML_TOK_PARTIAL;
1366}
1367
1368#endif /* XML_DTD */
1369
1367static int FASTCALL
1370static int PTRCALL
1368PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
1369 const char **badPtr)
1370{
1371 ptr += MINBPC(enc);
1372 end -= MINBPC(enc);
1373 for (; ptr != end; ptr += MINBPC(enc)) {
1374 switch (BYTE_TYPE(enc, ptr)) {
1375 case BT_DIGIT:

--- 43 unchanged lines hidden (view full) ---

1419 return 1;
1420}
1421
1422/* This must only be called for a well-formed start-tag or empty
1423 element tag. Returns the number of attributes. Pointers to the
1424 first attsMax attributes are stored in atts.
1425*/
1426
1371PREFIX(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:

--- 43 unchanged lines hidden (view full) ---

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
1427static int FASTCALL
1430static int PTRCALL
1428PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
1429 int attsMax, ATTRIBUTE *atts)
1430{
1431 enum { other, inName, inValue } state = inName;
1432 int nAtts = 0;
1433 int open = 0; /* defined when state == inValue;
1434 initialization just to shut up compilers */
1435

--- 76 unchanged lines hidden (view full) ---

1512 break;
1513 default:
1514 break;
1515 }
1516 }
1517 /* not reached */
1518}
1519
1431PREFIX(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

--- 76 unchanged lines hidden (view full) ---

1515 break;
1516 default:
1517 break;
1518 }
1519 }
1520 /* not reached */
1521}
1522
1520static int FASTCALL
1523static int PTRFASTCALL
1521PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
1522{
1523 int result = 0;
1524 /* skip &# */
1525 ptr += 2*MINBPC(enc);
1526 if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
1527 for (ptr += MINBPC(enc);
1528 !CHAR_MATCHES(enc, ptr, ASCII_SEMI);

--- 27 unchanged lines hidden (view full) ---

1556 result += (c - ASCII_0);
1557 if (result >= 0x110000)
1558 return -1;
1559 }
1560 }
1561 return checkCharRefNumber(result);
1562}
1563
1524PREFIX(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);

--- 27 unchanged lines hidden (view full) ---

1559 result += (c - ASCII_0);
1560 if (result >= 0x110000)
1561 return -1;
1562 }
1563 }
1564 return checkCharRefNumber(result);
1565}
1566
1564static int FASTCALL
1567static int PTRCALL
1565PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
1566 const char *end)
1567{
1568 switch ((end - ptr)/MINBPC(enc)) {
1569 case 2:
1570 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
1571 switch (BYTE_TO_ASCII(enc, ptr)) {
1572 case ASCII_l:

--- 37 unchanged lines hidden (view full) ---

1610 }
1611 }
1612 break;
1613 }
1614 }
1615 return 0;
1616}
1617
1568PREFIX(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:

--- 37 unchanged lines hidden (view full) ---

1613 }
1614 }
1615 break;
1616 }
1617 }
1618 return 0;
1619}
1620
1618static int FASTCALL
1621static int PTRCALL
1619PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
1620{
1621 for (;;) {
1622 switch (BYTE_TYPE(enc, ptr1)) {
1623#define LEAD_CASE(n) \
1624 case BT_LEAD ## n: \
1625 if (*ptr1++ != *ptr2++) \
1626 return 0;

--- 47 unchanged lines hidden (view full) ---

1674 default:
1675 return 1;
1676 }
1677 }
1678 }
1679 /* not reached */
1680}
1681
1622PREFIX(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;

--- 47 unchanged lines hidden (view full) ---

1677 default:
1678 return 1;
1679 }
1680 }
1681 }
1682 /* not reached */
1683}
1684
1682static int FASTCALL
1685static int PTRCALL
1683PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
1684 const char *end1, const char *ptr2)
1685{
1686 for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
1687 if (ptr1 == end1)
1688 return 0;
1689 if (!CHAR_MATCHES(enc, ptr1, *ptr2))
1690 return 0;
1691 }
1692 return ptr1 == end1;
1693}
1694
1686PREFIX(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
1695static int FASTCALL
1698static int PTRFASTCALL
1696PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
1697{
1698 const char *start = ptr;
1699 for (;;) {
1700 switch (BYTE_TYPE(enc, ptr)) {
1701#define LEAD_CASE(n) \
1702 case BT_LEAD ## n: ptr += n; break;
1703 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)

--- 5 unchanged lines hidden (view full) ---

1709#endif
1710 case BT_HEX:
1711 case BT_DIGIT:
1712 case BT_NAME:
1713 case BT_MINUS:
1714 ptr += MINBPC(enc);
1715 break;
1716 default:
1699PREFIX(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)

--- 5 unchanged lines hidden (view full) ---

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:
1717 return ptr - start;
1720 return (int)(ptr - start);
1718 }
1719 }
1720}
1721
1721 }
1722 }
1723}
1724
1722static const char * FASTCALL
1725static const char * PTRFASTCALL
1723PREFIX(skipS)(const ENCODING *enc, const char *ptr)
1724{
1725 for (;;) {
1726 switch (BYTE_TYPE(enc, ptr)) {
1727 case BT_LF:
1728 case BT_CR:
1729 case BT_S:
1730 ptr += MINBPC(enc);
1731 break;
1732 default:
1733 return ptr;
1734 }
1735 }
1736}
1737
1726PREFIX(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
1738static void FASTCALL
1741static void PTRCALL
1739PREFIX(updatePosition)(const ENCODING *enc,
1740 const char *ptr,
1741 const char *end,
1742 POSITION *pos)
1743{
1744 while (ptr != end) {
1745 switch (BYTE_TYPE(enc, ptr)) {
1746#define LEAD_CASE(n) \
1747 case BT_LEAD ## n: \
1748 ptr += n; \
1749 break;
1750 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1751#undef LEAD_CASE
1752 case BT_LF:
1742PREFIX(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:
1753 pos->columnNumber = (unsigned)-1;
1756 pos->columnNumber = (XML_Size)-1;
1754 pos->lineNumber++;
1755 ptr += MINBPC(enc);
1756 break;
1757 case BT_CR:
1758 pos->lineNumber++;
1759 ptr += MINBPC(enc);
1760 if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
1761 ptr += MINBPC(enc);
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);
1762 pos->columnNumber = (unsigned)-1;
1765 pos->columnNumber = (XML_Size)-1;
1763 break;
1764 default:
1765 ptr += MINBPC(enc);
1766 break;
1767 }
1768 pos->columnNumber++;
1769 }
1770}
1771
1772#undef DO_LEAD_CASE
1773#undef MULTIBYTE_CASES
1774#undef INVALID_CASES
1775#undef CHECK_NAME_CASE
1776#undef CHECK_NAME_CASES
1777#undef CHECK_NMSTRT_CASE
1778#undef CHECK_NMSTRT_CASES
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 */