00001
00002
00003
00004
00005 #include <stddef.h>
00006
00007 #ifdef COMPILED_FROM_DSP
00008 #include "winconfig.h"
00009 #elif defined(MACOS_CLASSIC)
00010 #include "macconfig.h"
00011 #elif defined(__amigaos4__)
00012 #include "amigaconfig.h"
00013 #elif defined(__WATCOMC__)
00014 #include "watcomconfig.h"
00015 #else
00016 #ifdef HAVE_EXPAT_CONFIG_H
00017 #include <expat_config.h>
00018 #endif
00019 #endif
00020
00021 #include "expat_external.h"
00022 #include "internal.h"
00023 #include "xmlrole.h"
00024 #include "ascii.h"
00025
00026
00027
00028
00029
00030
00031
00032
00033 static const char KW_ANY[] = {
00034 ASCII_A, ASCII_N, ASCII_Y, '\0' };
00035 static const char KW_ATTLIST[] = {
00036 ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' };
00037 static const char KW_CDATA[] = {
00038 ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
00039 static const char KW_DOCTYPE[] = {
00040 ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' };
00041 static const char KW_ELEMENT[] = {
00042 ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' };
00043 static const char KW_EMPTY[] = {
00044 ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' };
00045 static const char KW_ENTITIES[] = {
00046 ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S,
00047 '\0' };
00048 static const char KW_ENTITY[] = {
00049 ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
00050 static const char KW_FIXED[] = {
00051 ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' };
00052 static const char KW_ID[] = {
00053 ASCII_I, ASCII_D, '\0' };
00054 static const char KW_IDREF[] = {
00055 ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
00056 static const char KW_IDREFS[] = {
00057 ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
00058 #ifdef XML_DTD
00059 static const char KW_IGNORE[] = {
00060 ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' };
00061 #endif
00062 static const char KW_IMPLIED[] = {
00063 ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' };
00064 #ifdef XML_DTD
00065 static const char KW_INCLUDE[] = {
00066 ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' };
00067 #endif
00068 static const char KW_NDATA[] = {
00069 ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
00070 static const char KW_NMTOKEN[] = {
00071 ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
00072 static const char KW_NMTOKENS[] = {
00073 ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S,
00074 '\0' };
00075 static const char KW_NOTATION[] =
00076 { ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N,
00077 '\0' };
00078 static const char KW_PCDATA[] = {
00079 ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
00080 static const char KW_PUBLIC[] = {
00081 ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' };
00082 static const char KW_REQUIRED[] = {
00083 ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D,
00084 '\0' };
00085 static const char KW_SYSTEM[] = {
00086 ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' };
00087
00088 #ifndef MIN_BYTES_PER_CHAR
00089 #define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
00090 #endif
00091
00092 #ifdef XML_DTD
00093 #define setTopLevel(state) \
00094 ((state)->handler = ((state)->documentEntity \
00095 ? internalSubset \
00096 : externalSubset1))
00097 #else
00098 #define setTopLevel(state) ((state)->handler = internalSubset)
00099 #endif
00100
00101 typedef int PTRCALL PROLOG_HANDLER(PROLOG_STATE *state,
00102 int tok,
00103 const char *ptr,
00104 const char *end,
00105 const ENCODING *enc);
00106
00107 static PROLOG_HANDLER
00108 prolog0, prolog1, prolog2,
00109 doctype0, doctype1, doctype2, doctype3, doctype4, doctype5,
00110 internalSubset,
00111 entity0, entity1, entity2, entity3, entity4, entity5, entity6,
00112 entity7, entity8, entity9, entity10,
00113 notation0, notation1, notation2, notation3, notation4,
00114 attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6,
00115 attlist7, attlist8, attlist9,
00116 element0, element1, element2, element3, element4, element5, element6,
00117 element7,
00118 #ifdef XML_DTD
00119 externalSubset0, externalSubset1,
00120 condSect0, condSect1, condSect2,
00121 #endif
00122 declClose,
00123 error;
00124
00125 static int FASTCALL common(PROLOG_STATE *state, int tok);
00126
00127 static int PTRCALL
00128 prolog0(PROLOG_STATE *state,
00129 int tok,
00130 const char *ptr,
00131 const char *end,
00132 const ENCODING *enc)
00133 {
00134 switch (tok) {
00135 case XML_TOK_PROLOG_S:
00136 state->handler = prolog1;
00137 return XML_ROLE_NONE;
00138 case XML_TOK_XML_DECL:
00139 state->handler = prolog1;
00140 return XML_ROLE_XML_DECL;
00141 case XML_TOK_PI:
00142 state->handler = prolog1;
00143 return XML_ROLE_PI;
00144 case XML_TOK_COMMENT:
00145 state->handler = prolog1;
00146 return XML_ROLE_COMMENT;
00147 case XML_TOK_BOM:
00148 return XML_ROLE_NONE;
00149 case XML_TOK_DECL_OPEN:
00150 if (!XmlNameMatchesAscii(enc,
00151 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
00152 end,
00153 KW_DOCTYPE))
00154 break;
00155 state->handler = doctype0;
00156 return XML_ROLE_DOCTYPE_NONE;
00157 case XML_TOK_INSTANCE_START:
00158 state->handler = error;
00159 return XML_ROLE_INSTANCE_START;
00160 }
00161 return common(state, tok);
00162 }
00163
00164 static int PTRCALL
00165 prolog1(PROLOG_STATE *state,
00166 int tok,
00167 const char *ptr,
00168 const char *end,
00169 const ENCODING *enc)
00170 {
00171 switch (tok) {
00172 case XML_TOK_PROLOG_S:
00173 return XML_ROLE_NONE;
00174 case XML_TOK_PI:
00175 return XML_ROLE_PI;
00176 case XML_TOK_COMMENT:
00177 return XML_ROLE_COMMENT;
00178 case XML_TOK_BOM:
00179 return XML_ROLE_NONE;
00180 case XML_TOK_DECL_OPEN:
00181 if (!XmlNameMatchesAscii(enc,
00182 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
00183 end,
00184 KW_DOCTYPE))
00185 break;
00186 state->handler = doctype0;
00187 return XML_ROLE_DOCTYPE_NONE;
00188 case XML_TOK_INSTANCE_START:
00189 state->handler = error;
00190 return XML_ROLE_INSTANCE_START;
00191 }
00192 return common(state, tok);
00193 }
00194
00195 static int PTRCALL
00196 prolog2(PROLOG_STATE *state,
00197 int tok,
00198 const char *ptr,
00199 const char *end,
00200 const ENCODING *enc)
00201 {
00202 switch (tok) {
00203 case XML_TOK_PROLOG_S:
00204 return XML_ROLE_NONE;
00205 case XML_TOK_PI:
00206 return XML_ROLE_PI;
00207 case XML_TOK_COMMENT:
00208 return XML_ROLE_COMMENT;
00209 case XML_TOK_INSTANCE_START:
00210 state->handler = error;
00211 return XML_ROLE_INSTANCE_START;
00212 }
00213 return common(state, tok);
00214 }
00215
00216 static int PTRCALL
00217 doctype0(PROLOG_STATE *state,
00218 int tok,
00219 const char *ptr,
00220 const char *end,
00221 const ENCODING *enc)
00222 {
00223 switch (tok) {
00224 case XML_TOK_PROLOG_S:
00225 return XML_ROLE_DOCTYPE_NONE;
00226 case XML_TOK_NAME:
00227 case XML_TOK_PREFIXED_NAME:
00228 state->handler = doctype1;
00229 return XML_ROLE_DOCTYPE_NAME;
00230 }
00231 return common(state, tok);
00232 }
00233
00234 static int PTRCALL
00235 doctype1(PROLOG_STATE *state,
00236 int tok,
00237 const char *ptr,
00238 const char *end,
00239 const ENCODING *enc)
00240 {
00241 switch (tok) {
00242 case XML_TOK_PROLOG_S:
00243 return XML_ROLE_DOCTYPE_NONE;
00244 case XML_TOK_OPEN_BRACKET:
00245 state->handler = internalSubset;
00246 return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
00247 case XML_TOK_DECL_CLOSE:
00248 state->handler = prolog2;
00249 return XML_ROLE_DOCTYPE_CLOSE;
00250 case XML_TOK_NAME:
00251 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
00252 state->handler = doctype3;
00253 return XML_ROLE_DOCTYPE_NONE;
00254 }
00255 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
00256 state->handler = doctype2;
00257 return XML_ROLE_DOCTYPE_NONE;
00258 }
00259 break;
00260 }
00261 return common(state, tok);
00262 }
00263
00264 static int PTRCALL
00265 doctype2(PROLOG_STATE *state,
00266 int tok,
00267 const char *ptr,
00268 const char *end,
00269 const ENCODING *enc)
00270 {
00271 switch (tok) {
00272 case XML_TOK_PROLOG_S:
00273 return XML_ROLE_DOCTYPE_NONE;
00274 case XML_TOK_LITERAL:
00275 state->handler = doctype3;
00276 return XML_ROLE_DOCTYPE_PUBLIC_ID;
00277 }
00278 return common(state, tok);
00279 }
00280
00281 static int PTRCALL
00282 doctype3(PROLOG_STATE *state,
00283 int tok,
00284 const char *ptr,
00285 const char *end,
00286 const ENCODING *enc)
00287 {
00288 switch (tok) {
00289 case XML_TOK_PROLOG_S:
00290 return XML_ROLE_DOCTYPE_NONE;
00291 case XML_TOK_LITERAL:
00292 state->handler = doctype4;
00293 return XML_ROLE_DOCTYPE_SYSTEM_ID;
00294 }
00295 return common(state, tok);
00296 }
00297
00298 static int PTRCALL
00299 doctype4(PROLOG_STATE *state,
00300 int tok,
00301 const char *ptr,
00302 const char *end,
00303 const ENCODING *enc)
00304 {
00305 switch (tok) {
00306 case XML_TOK_PROLOG_S:
00307 return XML_ROLE_DOCTYPE_NONE;
00308 case XML_TOK_OPEN_BRACKET:
00309 state->handler = internalSubset;
00310 return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
00311 case XML_TOK_DECL_CLOSE:
00312 state->handler = prolog2;
00313 return XML_ROLE_DOCTYPE_CLOSE;
00314 }
00315 return common(state, tok);
00316 }
00317
00318 static int PTRCALL
00319 doctype5(PROLOG_STATE *state,
00320 int tok,
00321 const char *ptr,
00322 const char *end,
00323 const ENCODING *enc)
00324 {
00325 switch (tok) {
00326 case XML_TOK_PROLOG_S:
00327 return XML_ROLE_DOCTYPE_NONE;
00328 case XML_TOK_DECL_CLOSE:
00329 state->handler = prolog2;
00330 return XML_ROLE_DOCTYPE_CLOSE;
00331 }
00332 return common(state, tok);
00333 }
00334
00335 static int PTRCALL
00336 internalSubset(PROLOG_STATE *state,
00337 int tok,
00338 const char *ptr,
00339 const char *end,
00340 const ENCODING *enc)
00341 {
00342 switch (tok) {
00343 case XML_TOK_PROLOG_S:
00344 return XML_ROLE_NONE;
00345 case XML_TOK_DECL_OPEN:
00346 if (XmlNameMatchesAscii(enc,
00347 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
00348 end,
00349 KW_ENTITY)) {
00350 state->handler = entity0;
00351 return XML_ROLE_ENTITY_NONE;
00352 }
00353 if (XmlNameMatchesAscii(enc,
00354 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
00355 end,
00356 KW_ATTLIST)) {
00357 state->handler = attlist0;
00358 return XML_ROLE_ATTLIST_NONE;
00359 }
00360 if (XmlNameMatchesAscii(enc,
00361 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
00362 end,
00363 KW_ELEMENT)) {
00364 state->handler = element0;
00365 return XML_ROLE_ELEMENT_NONE;
00366 }
00367 if (XmlNameMatchesAscii(enc,
00368 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
00369 end,
00370 KW_NOTATION)) {
00371 state->handler = notation0;
00372 return XML_ROLE_NOTATION_NONE;
00373 }
00374 break;
00375 case XML_TOK_PI:
00376 return XML_ROLE_PI;
00377 case XML_TOK_COMMENT:
00378 return XML_ROLE_COMMENT;
00379 case XML_TOK_PARAM_ENTITY_REF:
00380 return XML_ROLE_PARAM_ENTITY_REF;
00381 case XML_TOK_CLOSE_BRACKET:
00382 state->handler = doctype5;
00383 return XML_ROLE_DOCTYPE_NONE;
00384 case XML_TOK_NONE:
00385 return XML_ROLE_NONE;
00386 }
00387 return common(state, tok);
00388 }
00389
00390 #ifdef XML_DTD
00391
00392 static int PTRCALL
00393 externalSubset0(PROLOG_STATE *state,
00394 int tok,
00395 const char *ptr,
00396 const char *end,
00397 const ENCODING *enc)
00398 {
00399 state->handler = externalSubset1;
00400 if (tok == XML_TOK_XML_DECL)
00401 return XML_ROLE_TEXT_DECL;
00402 return externalSubset1(state, tok, ptr, end, enc);
00403 }
00404
00405 static int PTRCALL
00406 externalSubset1(PROLOG_STATE *state,
00407 int tok,
00408 const char *ptr,
00409 const char *end,
00410 const ENCODING *enc)
00411 {
00412 switch (tok) {
00413 case XML_TOK_COND_SECT_OPEN:
00414 state->handler = condSect0;
00415 return XML_ROLE_NONE;
00416 case XML_TOK_COND_SECT_CLOSE:
00417 if (state->includeLevel == 0)
00418 break;
00419 state->includeLevel -= 1;
00420 return XML_ROLE_NONE;
00421 case XML_TOK_PROLOG_S:
00422 return XML_ROLE_NONE;
00423 case XML_TOK_CLOSE_BRACKET:
00424 break;
00425 case XML_TOK_NONE:
00426 if (state->includeLevel)
00427 break;
00428 return XML_ROLE_NONE;
00429 default:
00430 return internalSubset(state, tok, ptr, end, enc);
00431 }
00432 return common(state, tok);
00433 }
00434
00435 #endif
00436
00437 static int PTRCALL
00438 entity0(PROLOG_STATE *state,
00439 int tok,
00440 const char *ptr,
00441 const char *end,
00442 const ENCODING *enc)
00443 {
00444 switch (tok) {
00445 case XML_TOK_PROLOG_S:
00446 return XML_ROLE_ENTITY_NONE;
00447 case XML_TOK_PERCENT:
00448 state->handler = entity1;
00449 return XML_ROLE_ENTITY_NONE;
00450 case XML_TOK_NAME:
00451 state->handler = entity2;
00452 return XML_ROLE_GENERAL_ENTITY_NAME;
00453 }
00454 return common(state, tok);
00455 }
00456
00457 static int PTRCALL
00458 entity1(PROLOG_STATE *state,
00459 int tok,
00460 const char *ptr,
00461 const char *end,
00462 const ENCODING *enc)
00463 {
00464 switch (tok) {
00465 case XML_TOK_PROLOG_S:
00466 return XML_ROLE_ENTITY_NONE;
00467 case XML_TOK_NAME:
00468 state->handler = entity7;
00469 return XML_ROLE_PARAM_ENTITY_NAME;
00470 }
00471 return common(state, tok);
00472 }
00473
00474 static int PTRCALL
00475 entity2(PROLOG_STATE *state,
00476 int tok,
00477 const char *ptr,
00478 const char *end,
00479 const ENCODING *enc)
00480 {
00481 switch (tok) {
00482 case XML_TOK_PROLOG_S:
00483 return XML_ROLE_ENTITY_NONE;
00484 case XML_TOK_NAME:
00485 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
00486 state->handler = entity4;
00487 return XML_ROLE_ENTITY_NONE;
00488 }
00489 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
00490 state->handler = entity3;
00491 return XML_ROLE_ENTITY_NONE;
00492 }
00493 break;
00494 case XML_TOK_LITERAL:
00495 state->handler = declClose;
00496 state->role_none = XML_ROLE_ENTITY_NONE;
00497 return XML_ROLE_ENTITY_VALUE;
00498 }
00499 return common(state, tok);
00500 }
00501
00502 static int PTRCALL
00503 entity3(PROLOG_STATE *state,
00504 int tok,
00505 const char *ptr,
00506 const char *end,
00507 const ENCODING *enc)
00508 {
00509 switch (tok) {
00510 case XML_TOK_PROLOG_S:
00511 return XML_ROLE_ENTITY_NONE;
00512 case XML_TOK_LITERAL:
00513 state->handler = entity4;
00514 return XML_ROLE_ENTITY_PUBLIC_ID;
00515 }
00516 return common(state, tok);
00517 }
00518
00519 static int PTRCALL
00520 entity4(PROLOG_STATE *state,
00521 int tok,
00522 const char *ptr,
00523 const char *end,
00524 const ENCODING *enc)
00525 {
00526 switch (tok) {
00527 case XML_TOK_PROLOG_S:
00528 return XML_ROLE_ENTITY_NONE;
00529 case XML_TOK_LITERAL:
00530 state->handler = entity5;
00531 return XML_ROLE_ENTITY_SYSTEM_ID;
00532 }
00533 return common(state, tok);
00534 }
00535
00536 static int PTRCALL
00537 entity5(PROLOG_STATE *state,
00538 int tok,
00539 const char *ptr,
00540 const char *end,
00541 const ENCODING *enc)
00542 {
00543 switch (tok) {
00544 case XML_TOK_PROLOG_S:
00545 return XML_ROLE_ENTITY_NONE;
00546 case XML_TOK_DECL_CLOSE:
00547 setTopLevel(state);
00548 return XML_ROLE_ENTITY_COMPLETE;
00549 case XML_TOK_NAME:
00550 if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
00551 state->handler = entity6;
00552 return XML_ROLE_ENTITY_NONE;
00553 }
00554 break;
00555 }
00556 return common(state, tok);
00557 }
00558
00559 static int PTRCALL
00560 entity6(PROLOG_STATE *state,
00561 int tok,
00562 const char *ptr,
00563 const char *end,
00564 const ENCODING *enc)
00565 {
00566 switch (tok) {
00567 case XML_TOK_PROLOG_S:
00568 return XML_ROLE_ENTITY_NONE;
00569 case XML_TOK_NAME:
00570 state->handler = declClose;
00571 state->role_none = XML_ROLE_ENTITY_NONE;
00572 return XML_ROLE_ENTITY_NOTATION_NAME;
00573 }
00574 return common(state, tok);
00575 }
00576
00577 static int PTRCALL
00578 entity7(PROLOG_STATE *state,
00579 int tok,
00580 const char *ptr,
00581 const char *end,
00582 const ENCODING *enc)
00583 {
00584 switch (tok) {
00585 case XML_TOK_PROLOG_S:
00586 return XML_ROLE_ENTITY_NONE;
00587 case XML_TOK_NAME:
00588 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
00589 state->handler = entity9;
00590 return XML_ROLE_ENTITY_NONE;
00591 }
00592 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
00593 state->handler = entity8;
00594 return XML_ROLE_ENTITY_NONE;
00595 }
00596 break;
00597 case XML_TOK_LITERAL:
00598 state->handler = declClose;
00599 state->role_none = XML_ROLE_ENTITY_NONE;
00600 return XML_ROLE_ENTITY_VALUE;
00601 }
00602 return common(state, tok);
00603 }
00604
00605 static int PTRCALL
00606 entity8(PROLOG_STATE *state,
00607 int tok,
00608 const char *ptr,
00609 const char *end,
00610 const ENCODING *enc)
00611 {
00612 switch (tok) {
00613 case XML_TOK_PROLOG_S:
00614 return XML_ROLE_ENTITY_NONE;
00615 case XML_TOK_LITERAL:
00616 state->handler = entity9;
00617 return XML_ROLE_ENTITY_PUBLIC_ID;
00618 }
00619 return common(state, tok);
00620 }
00621
00622 static int PTRCALL
00623 entity9(PROLOG_STATE *state,
00624 int tok,
00625 const char *ptr,
00626 const char *end,
00627 const ENCODING *enc)
00628 {
00629 switch (tok) {
00630 case XML_TOK_PROLOG_S:
00631 return XML_ROLE_ENTITY_NONE;
00632 case XML_TOK_LITERAL:
00633 state->handler = entity10;
00634 return XML_ROLE_ENTITY_SYSTEM_ID;
00635 }
00636 return common(state, tok);
00637 }
00638
00639 static int PTRCALL
00640 entity10(PROLOG_STATE *state,
00641 int tok,
00642 const char *ptr,
00643 const char *end,
00644 const ENCODING *enc)
00645 {
00646 switch (tok) {
00647 case XML_TOK_PROLOG_S:
00648 return XML_ROLE_ENTITY_NONE;
00649 case XML_TOK_DECL_CLOSE:
00650 setTopLevel(state);
00651 return XML_ROLE_ENTITY_COMPLETE;
00652 }
00653 return common(state, tok);
00654 }
00655
00656 static int PTRCALL
00657 notation0(PROLOG_STATE *state,
00658 int tok,
00659 const char *ptr,
00660 const char *end,
00661 const ENCODING *enc)
00662 {
00663 switch (tok) {
00664 case XML_TOK_PROLOG_S:
00665 return XML_ROLE_NOTATION_NONE;
00666 case XML_TOK_NAME:
00667 state->handler = notation1;
00668 return XML_ROLE_NOTATION_NAME;
00669 }
00670 return common(state, tok);
00671 }
00672
00673 static int PTRCALL
00674 notation1(PROLOG_STATE *state,
00675 int tok,
00676 const char *ptr,
00677 const char *end,
00678 const ENCODING *enc)
00679 {
00680 switch (tok) {
00681 case XML_TOK_PROLOG_S:
00682 return XML_ROLE_NOTATION_NONE;
00683 case XML_TOK_NAME:
00684 if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
00685 state->handler = notation3;
00686 return XML_ROLE_NOTATION_NONE;
00687 }
00688 if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
00689 state->handler = notation2;
00690 return XML_ROLE_NOTATION_NONE;
00691 }
00692 break;
00693 }
00694 return common(state, tok);
00695 }
00696
00697 static int PTRCALL
00698 notation2(PROLOG_STATE *state,
00699 int tok,
00700 const char *ptr,
00701 const char *end,
00702 const ENCODING *enc)
00703 {
00704 switch (tok) {
00705 case XML_TOK_PROLOG_S:
00706 return XML_ROLE_NOTATION_NONE;
00707 case XML_TOK_LITERAL:
00708 state->handler = notation4;
00709 return XML_ROLE_NOTATION_PUBLIC_ID;
00710 }
00711 return common(state, tok);
00712 }
00713
00714 static int PTRCALL
00715 notation3(PROLOG_STATE *state,
00716 int tok,
00717 const char *ptr,
00718 const char *end,
00719 const ENCODING *enc)
00720 {
00721 switch (tok) {
00722 case XML_TOK_PROLOG_S:
00723 return XML_ROLE_NOTATION_NONE;
00724 case XML_TOK_LITERAL:
00725 state->handler = declClose;
00726 state->role_none = XML_ROLE_NOTATION_NONE;
00727 return XML_ROLE_NOTATION_SYSTEM_ID;
00728 }
00729 return common(state, tok);
00730 }
00731
00732 static int PTRCALL
00733 notation4(PROLOG_STATE *state,
00734 int tok,
00735 const char *ptr,
00736 const char *end,
00737 const ENCODING *enc)
00738 {
00739 switch (tok) {
00740 case XML_TOK_PROLOG_S:
00741 return XML_ROLE_NOTATION_NONE;
00742 case XML_TOK_LITERAL:
00743 state->handler = declClose;
00744 state->role_none = XML_ROLE_NOTATION_NONE;
00745 return XML_ROLE_NOTATION_SYSTEM_ID;
00746 case XML_TOK_DECL_CLOSE:
00747 setTopLevel(state);
00748 return XML_ROLE_NOTATION_NO_SYSTEM_ID;
00749 }
00750 return common(state, tok);
00751 }
00752
00753 static int PTRCALL
00754 attlist0(PROLOG_STATE *state,
00755 int tok,
00756 const char *ptr,
00757 const char *end,
00758 const ENCODING *enc)
00759 {
00760 switch (tok) {
00761 case XML_TOK_PROLOG_S:
00762 return XML_ROLE_ATTLIST_NONE;
00763 case XML_TOK_NAME:
00764 case XML_TOK_PREFIXED_NAME:
00765 state->handler = attlist1;
00766 return XML_ROLE_ATTLIST_ELEMENT_NAME;
00767 }
00768 return common(state, tok);
00769 }
00770
00771 static int PTRCALL
00772 attlist1(PROLOG_STATE *state,
00773 int tok,
00774 const char *ptr,
00775 const char *end,
00776 const ENCODING *enc)
00777 {
00778 switch (tok) {
00779 case XML_TOK_PROLOG_S:
00780 return XML_ROLE_ATTLIST_NONE;
00781 case XML_TOK_DECL_CLOSE:
00782 setTopLevel(state);
00783 return XML_ROLE_ATTLIST_NONE;
00784 case XML_TOK_NAME:
00785 case XML_TOK_PREFIXED_NAME:
00786 state->handler = attlist2;
00787 return XML_ROLE_ATTRIBUTE_NAME;
00788 }
00789 return common(state, tok);
00790 }
00791
00792 static int PTRCALL
00793 attlist2(PROLOG_STATE *state,
00794 int tok,
00795 const char *ptr,
00796 const char *end,
00797 const ENCODING *enc)
00798 {
00799 switch (tok) {
00800 case XML_TOK_PROLOG_S:
00801 return XML_ROLE_ATTLIST_NONE;
00802 case XML_TOK_NAME:
00803 {
00804 static const char * const types[] = {
00805 KW_CDATA,
00806 KW_ID,
00807 KW_IDREF,
00808 KW_IDREFS,
00809 KW_ENTITY,
00810 KW_ENTITIES,
00811 KW_NMTOKEN,
00812 KW_NMTOKENS,
00813 };
00814 int i;
00815 for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
00816 if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
00817 state->handler = attlist8;
00818 return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
00819 }
00820 }
00821 if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
00822 state->handler = attlist5;
00823 return XML_ROLE_ATTLIST_NONE;
00824 }
00825 break;
00826 case XML_TOK_OPEN_PAREN:
00827 state->handler = attlist3;
00828 return XML_ROLE_ATTLIST_NONE;
00829 }
00830 return common(state, tok);
00831 }
00832
00833 static int PTRCALL
00834 attlist3(PROLOG_STATE *state,
00835 int tok,
00836 const char *ptr,
00837 const char *end,
00838 const ENCODING *enc)
00839 {
00840 switch (tok) {
00841 case XML_TOK_PROLOG_S:
00842 return XML_ROLE_ATTLIST_NONE;
00843 case XML_TOK_NMTOKEN:
00844 case XML_TOK_NAME:
00845 case XML_TOK_PREFIXED_NAME:
00846 state->handler = attlist4;
00847 return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
00848 }
00849 return common(state, tok);
00850 }
00851
00852 static int PTRCALL
00853 attlist4(PROLOG_STATE *state,
00854 int tok,
00855 const char *ptr,
00856 const char *end,
00857 const ENCODING *enc)
00858 {
00859 switch (tok) {
00860 case XML_TOK_PROLOG_S:
00861 return XML_ROLE_ATTLIST_NONE;
00862 case XML_TOK_CLOSE_PAREN:
00863 state->handler = attlist8;
00864 return XML_ROLE_ATTLIST_NONE;
00865 case XML_TOK_OR:
00866 state->handler = attlist3;
00867 return XML_ROLE_ATTLIST_NONE;
00868 }
00869 return common(state, tok);
00870 }
00871
00872 static int PTRCALL
00873 attlist5(PROLOG_STATE *state,
00874 int tok,
00875 const char *ptr,
00876 const char *end,
00877 const ENCODING *enc)
00878 {
00879 switch (tok) {
00880 case XML_TOK_PROLOG_S:
00881 return XML_ROLE_ATTLIST_NONE;
00882 case XML_TOK_OPEN_PAREN:
00883 state->handler = attlist6;
00884 return XML_ROLE_ATTLIST_NONE;
00885 }
00886 return common(state, tok);
00887 }
00888
00889 static int PTRCALL
00890 attlist6(PROLOG_STATE *state,
00891 int tok,
00892 const char *ptr,
00893 const char *end,
00894 const ENCODING *enc)
00895 {
00896 switch (tok) {
00897 case XML_TOK_PROLOG_S:
00898 return XML_ROLE_ATTLIST_NONE;
00899 case XML_TOK_NAME:
00900 state->handler = attlist7;
00901 return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
00902 }
00903 return common(state, tok);
00904 }
00905
00906 static int PTRCALL
00907 attlist7(PROLOG_STATE *state,
00908 int tok,
00909 const char *ptr,
00910 const char *end,
00911 const ENCODING *enc)
00912 {
00913 switch (tok) {
00914 case XML_TOK_PROLOG_S:
00915 return XML_ROLE_ATTLIST_NONE;
00916 case XML_TOK_CLOSE_PAREN:
00917 state->handler = attlist8;
00918 return XML_ROLE_ATTLIST_NONE;
00919 case XML_TOK_OR:
00920 state->handler = attlist6;
00921 return XML_ROLE_ATTLIST_NONE;
00922 }
00923 return common(state, tok);
00924 }
00925
00926
00927 static int PTRCALL
00928 attlist8(PROLOG_STATE *state,
00929 int tok,
00930 const char *ptr,
00931 const char *end,
00932 const ENCODING *enc)
00933 {
00934 switch (tok) {
00935 case XML_TOK_PROLOG_S:
00936 return XML_ROLE_ATTLIST_NONE;
00937 case XML_TOK_POUND_NAME:
00938 if (XmlNameMatchesAscii(enc,
00939 ptr + MIN_BYTES_PER_CHAR(enc),
00940 end,
00941 KW_IMPLIED)) {
00942 state->handler = attlist1;
00943 return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
00944 }
00945 if (XmlNameMatchesAscii(enc,
00946 ptr + MIN_BYTES_PER_CHAR(enc),
00947 end,
00948 KW_REQUIRED)) {
00949 state->handler = attlist1;
00950 return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
00951 }
00952 if (XmlNameMatchesAscii(enc,
00953 ptr + MIN_BYTES_PER_CHAR(enc),
00954 end,
00955 KW_FIXED)) {
00956 state->handler = attlist9;
00957 return XML_ROLE_ATTLIST_NONE;
00958 }
00959 break;
00960 case XML_TOK_LITERAL:
00961 state->handler = attlist1;
00962 return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
00963 }
00964 return common(state, tok);
00965 }
00966
00967 static int PTRCALL
00968 attlist9(PROLOG_STATE *state,
00969 int tok,
00970 const char *ptr,
00971 const char *end,
00972 const ENCODING *enc)
00973 {
00974 switch (tok) {
00975 case XML_TOK_PROLOG_S:
00976 return XML_ROLE_ATTLIST_NONE;
00977 case XML_TOK_LITERAL:
00978 state->handler = attlist1;
00979 return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
00980 }
00981 return common(state, tok);
00982 }
00983
00984 static int PTRCALL
00985 element0(PROLOG_STATE *state,
00986 int tok,
00987 const char *ptr,
00988 const char *end,
00989 const ENCODING *enc)
00990 {
00991 switch (tok) {
00992 case XML_TOK_PROLOG_S:
00993 return XML_ROLE_ELEMENT_NONE;
00994 case XML_TOK_NAME:
00995 case XML_TOK_PREFIXED_NAME:
00996 state->handler = element1;
00997 return XML_ROLE_ELEMENT_NAME;
00998 }
00999 return common(state, tok);
01000 }
01001
01002 static int PTRCALL
01003 element1(PROLOG_STATE *state,
01004 int tok,
01005 const char *ptr,
01006 const char *end,
01007 const ENCODING *enc)
01008 {
01009 switch (tok) {
01010 case XML_TOK_PROLOG_S:
01011 return XML_ROLE_ELEMENT_NONE;
01012 case XML_TOK_NAME:
01013 if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
01014 state->handler = declClose;
01015 state->role_none = XML_ROLE_ELEMENT_NONE;
01016 return XML_ROLE_CONTENT_EMPTY;
01017 }
01018 if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
01019 state->handler = declClose;
01020 state->role_none = XML_ROLE_ELEMENT_NONE;
01021 return XML_ROLE_CONTENT_ANY;
01022 }
01023 break;
01024 case XML_TOK_OPEN_PAREN:
01025 state->handler = element2;
01026 state->level = 1;
01027 return XML_ROLE_GROUP_OPEN;
01028 }
01029 return common(state, tok);
01030 }
01031
01032 static int PTRCALL
01033 element2(PROLOG_STATE *state,
01034 int tok,
01035 const char *ptr,
01036 const char *end,
01037 const ENCODING *enc)
01038 {
01039 switch (tok) {
01040 case XML_TOK_PROLOG_S:
01041 return XML_ROLE_ELEMENT_NONE;
01042 case XML_TOK_POUND_NAME:
01043 if (XmlNameMatchesAscii(enc,
01044 ptr + MIN_BYTES_PER_CHAR(enc),
01045 end,
01046 KW_PCDATA)) {
01047 state->handler = element3;
01048 return XML_ROLE_CONTENT_PCDATA;
01049 }
01050 break;
01051 case XML_TOK_OPEN_PAREN:
01052 state->level = 2;
01053 state->handler = element6;
01054 return XML_ROLE_GROUP_OPEN;
01055 case XML_TOK_NAME:
01056 case XML_TOK_PREFIXED_NAME:
01057 state->handler = element7;
01058 return XML_ROLE_CONTENT_ELEMENT;
01059 case XML_TOK_NAME_QUESTION:
01060 state->handler = element7;
01061 return XML_ROLE_CONTENT_ELEMENT_OPT;
01062 case XML_TOK_NAME_ASTERISK:
01063 state->handler = element7;
01064 return XML_ROLE_CONTENT_ELEMENT_REP;
01065 case XML_TOK_NAME_PLUS:
01066 state->handler = element7;
01067 return XML_ROLE_CONTENT_ELEMENT_PLUS;
01068 }
01069 return common(state, tok);
01070 }
01071
01072 static int PTRCALL
01073 element3(PROLOG_STATE *state,
01074 int tok,
01075 const char *ptr,
01076 const char *end,
01077 const ENCODING *enc)
01078 {
01079 switch (tok) {
01080 case XML_TOK_PROLOG_S:
01081 return XML_ROLE_ELEMENT_NONE;
01082 case XML_TOK_CLOSE_PAREN:
01083 state->handler = declClose;
01084 state->role_none = XML_ROLE_ELEMENT_NONE;
01085 return XML_ROLE_GROUP_CLOSE;
01086 case XML_TOK_CLOSE_PAREN_ASTERISK:
01087 state->handler = declClose;
01088 state->role_none = XML_ROLE_ELEMENT_NONE;
01089 return XML_ROLE_GROUP_CLOSE_REP;
01090 case XML_TOK_OR:
01091 state->handler = element4;
01092 return XML_ROLE_ELEMENT_NONE;
01093 }
01094 return common(state, tok);
01095 }
01096
01097 static int PTRCALL
01098 element4(PROLOG_STATE *state,
01099 int tok,
01100 const char *ptr,
01101 const char *end,
01102 const ENCODING *enc)
01103 {
01104 switch (tok) {
01105 case XML_TOK_PROLOG_S:
01106 return XML_ROLE_ELEMENT_NONE;
01107 case XML_TOK_NAME:
01108 case XML_TOK_PREFIXED_NAME:
01109 state->handler = element5;
01110 return XML_ROLE_CONTENT_ELEMENT;
01111 }
01112 return common(state, tok);
01113 }
01114
01115 static int PTRCALL
01116 element5(PROLOG_STATE *state,
01117 int tok,
01118 const char *ptr,
01119 const char *end,
01120 const ENCODING *enc)
01121 {
01122 switch (tok) {
01123 case XML_TOK_PROLOG_S:
01124 return XML_ROLE_ELEMENT_NONE;
01125 case XML_TOK_CLOSE_PAREN_ASTERISK:
01126 state->handler = declClose;
01127 state->role_none = XML_ROLE_ELEMENT_NONE;
01128 return XML_ROLE_GROUP_CLOSE_REP;
01129 case XML_TOK_OR:
01130 state->handler = element4;
01131 return XML_ROLE_ELEMENT_NONE;
01132 }
01133 return common(state, tok);
01134 }
01135
01136 static int PTRCALL
01137 element6(PROLOG_STATE *state,
01138 int tok,
01139 const char *ptr,
01140 const char *end,
01141 const ENCODING *enc)
01142 {
01143 switch (tok) {
01144 case XML_TOK_PROLOG_S:
01145 return XML_ROLE_ELEMENT_NONE;
01146 case XML_TOK_OPEN_PAREN:
01147 state->level += 1;
01148 return XML_ROLE_GROUP_OPEN;
01149 case XML_TOK_NAME:
01150 case XML_TOK_PREFIXED_NAME:
01151 state->handler = element7;
01152 return XML_ROLE_CONTENT_ELEMENT;
01153 case XML_TOK_NAME_QUESTION:
01154 state->handler = element7;
01155 return XML_ROLE_CONTENT_ELEMENT_OPT;
01156 case XML_TOK_NAME_ASTERISK:
01157 state->handler = element7;
01158 return XML_ROLE_CONTENT_ELEMENT_REP;
01159 case XML_TOK_NAME_PLUS:
01160 state->handler = element7;
01161 return XML_ROLE_CONTENT_ELEMENT_PLUS;
01162 }
01163 return common(state, tok);
01164 }
01165
01166 static int PTRCALL
01167 element7(PROLOG_STATE *state,
01168 int tok,
01169 const char *ptr,
01170 const char *end,
01171 const ENCODING *enc)
01172 {
01173 switch (tok) {
01174 case XML_TOK_PROLOG_S:
01175 return XML_ROLE_ELEMENT_NONE;
01176 case XML_TOK_CLOSE_PAREN:
01177 state->level -= 1;
01178 if (state->level == 0) {
01179 state->handler = declClose;
01180 state->role_none = XML_ROLE_ELEMENT_NONE;
01181 }
01182 return XML_ROLE_GROUP_CLOSE;
01183 case XML_TOK_CLOSE_PAREN_ASTERISK:
01184 state->level -= 1;
01185 if (state->level == 0) {
01186 state->handler = declClose;
01187 state->role_none = XML_ROLE_ELEMENT_NONE;
01188 }
01189 return XML_ROLE_GROUP_CLOSE_REP;
01190 case XML_TOK_CLOSE_PAREN_QUESTION:
01191 state->level -= 1;
01192 if (state->level == 0) {
01193 state->handler = declClose;
01194 state->role_none = XML_ROLE_ELEMENT_NONE;
01195 }
01196 return XML_ROLE_GROUP_CLOSE_OPT;
01197 case XML_TOK_CLOSE_PAREN_PLUS:
01198 state->level -= 1;
01199 if (state->level == 0) {
01200 state->handler = declClose;
01201 state->role_none = XML_ROLE_ELEMENT_NONE;
01202 }
01203 return XML_ROLE_GROUP_CLOSE_PLUS;
01204 case XML_TOK_COMMA:
01205 state->handler = element6;
01206 return XML_ROLE_GROUP_SEQUENCE;
01207 case XML_TOK_OR:
01208 state->handler = element6;
01209 return XML_ROLE_GROUP_CHOICE;
01210 }
01211 return common(state, tok);
01212 }
01213
01214 #ifdef XML_DTD
01215
01216 static int PTRCALL
01217 condSect0(PROLOG_STATE *state,
01218 int tok,
01219 const char *ptr,
01220 const char *end,
01221 const ENCODING *enc)
01222 {
01223 switch (tok) {
01224 case XML_TOK_PROLOG_S:
01225 return XML_ROLE_NONE;
01226 case XML_TOK_NAME:
01227 if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
01228 state->handler = condSect1;
01229 return XML_ROLE_NONE;
01230 }
01231 if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
01232 state->handler = condSect2;
01233 return XML_ROLE_NONE;
01234 }
01235 break;
01236 }
01237 return common(state, tok);
01238 }
01239
01240 static int PTRCALL
01241 condSect1(PROLOG_STATE *state,
01242 int tok,
01243 const char *ptr,
01244 const char *end,
01245 const ENCODING *enc)
01246 {
01247 switch (tok) {
01248 case XML_TOK_PROLOG_S:
01249 return XML_ROLE_NONE;
01250 case XML_TOK_OPEN_BRACKET:
01251 state->handler = externalSubset1;
01252 state->includeLevel += 1;
01253 return XML_ROLE_NONE;
01254 }
01255 return common(state, tok);
01256 }
01257
01258 static int PTRCALL
01259 condSect2(PROLOG_STATE *state,
01260 int tok,
01261 const char *ptr,
01262 const char *end,
01263 const ENCODING *enc)
01264 {
01265 switch (tok) {
01266 case XML_TOK_PROLOG_S:
01267 return XML_ROLE_NONE;
01268 case XML_TOK_OPEN_BRACKET:
01269 state->handler = externalSubset1;
01270 return XML_ROLE_IGNORE_SECT;
01271 }
01272 return common(state, tok);
01273 }
01274
01275 #endif
01276
01277 static int PTRCALL
01278 declClose(PROLOG_STATE *state,
01279 int tok,
01280 const char *ptr,
01281 const char *end,
01282 const ENCODING *enc)
01283 {
01284 switch (tok) {
01285 case XML_TOK_PROLOG_S:
01286 return state->role_none;
01287 case XML_TOK_DECL_CLOSE:
01288 setTopLevel(state);
01289 return state->role_none;
01290 }
01291 return common(state, tok);
01292 }
01293
01294 static int PTRCALL
01295 error(PROLOG_STATE *state,
01296 int tok,
01297 const char *ptr,
01298 const char *end,
01299 const ENCODING *enc)
01300 {
01301 return XML_ROLE_NONE;
01302 }
01303
01304 static int FASTCALL
01305 common(PROLOG_STATE *state, int tok)
01306 {
01307 #ifdef XML_DTD
01308 if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
01309 return XML_ROLE_INNER_PARAM_ENTITY_REF;
01310 #endif
01311 state->handler = error;
01312 return XML_ROLE_ERROR;
01313 }
01314
01315 void
01316 XmlPrologStateInit(PROLOG_STATE *state)
01317 {
01318 state->handler = prolog0;
01319 #ifdef XML_DTD
01320 state->documentEntity = 1;
01321 state->includeLevel = 0;
01322 state->inEntityValue = 0;
01323 #endif
01324 }
01325
01326 #ifdef XML_DTD
01327
01328 void
01329 XmlPrologStateInitExternalEntity(PROLOG_STATE *state)
01330 {
01331 state->handler = externalSubset0;
01332 state->documentEntity = 0;
01333 state->includeLevel = 0;
01334 }
01335
01336 #endif