| /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd |
| See the file COPYING for copying permission. |
| */ |
| |
| #include <stddef.h> |
| |
| #ifdef COMPILED_FROM_DSP |
| #include "winconfig.h" |
| #elif defined(MACOS_CLASSIC) |
| #include "macconfig.h" |
| #elif defined(__amigaos__) |
| #include "amigaconfig.h" |
| #elif defined(__WATCOMC__) |
| #include "watcomconfig.h" |
| #else |
| #ifdef HAVE_EXPAT_CONFIG_H |
| #include <expat_config.h> |
| #endif |
| #endif /* ndef COMPILED_FROM_DSP */ |
| |
| #include "expat_external.h" |
| #include "internal.h" |
| #include "xmlrole.h" |
| #include "ascii.h" |
| |
| /* Doesn't check: |
| |
| that ,| are not mixed in a model group |
| content of literals |
| |
| */ |
| |
| static const char KW_ANY[] = { |
| ASCII_A, ASCII_N, ASCII_Y, '\0' }; |
| static const char KW_ATTLIST[] = { |
| ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' }; |
| static const char KW_CDATA[] = { |
| ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' }; |
| static const char KW_DOCTYPE[] = { |
| ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' }; |
| static const char KW_ELEMENT[] = { |
| ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' }; |
| static const char KW_EMPTY[] = { |
| ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' }; |
| static const char KW_ENTITIES[] = { |
| ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, |
| '\0' }; |
| static const char KW_ENTITY[] = { |
| ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' }; |
| static const char KW_FIXED[] = { |
| ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' }; |
| static const char KW_ID[] = { |
| ASCII_I, ASCII_D, '\0' }; |
| static const char KW_IDREF[] = { |
| ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' }; |
| static const char KW_IDREFS[] = { |
| ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' }; |
| #ifdef XML_DTD |
| static const char KW_IGNORE[] = { |
| ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' }; |
| #endif |
| static const char KW_IMPLIED[] = { |
| ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' }; |
| #ifdef XML_DTD |
| static const char KW_INCLUDE[] = { |
| ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' }; |
| #endif |
| static const char KW_NDATA[] = { |
| ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' }; |
| static const char KW_NMTOKEN[] = { |
| ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' }; |
| static const char KW_NMTOKENS[] = { |
| ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, |
| '\0' }; |
| static const char KW_NOTATION[] = |
| { ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, |
| '\0' }; |
| static const char KW_PCDATA[] = { |
| ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' }; |
| static const char KW_PUBLIC[] = { |
| ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' }; |
| static const char KW_REQUIRED[] = { |
| ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D, |
| '\0' }; |
| static const char KW_SYSTEM[] = { |
| ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' }; |
| |
| #ifndef MIN_BYTES_PER_CHAR |
| #define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar) |
| #endif |
| |
| #ifdef XML_DTD |
| #define setTopLevel(state) \ |
| ((state)->handler = ((state)->documentEntity \ |
| ? internalSubset \ |
| : externalSubset1)) |
| #else /* not XML_DTD */ |
| #define setTopLevel(state) ((state)->handler = internalSubset) |
| #endif /* not XML_DTD */ |
| |
| typedef int PTRCALL PROLOG_HANDLER(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc); |
| |
| static PROLOG_HANDLER |
| prolog0, prolog1, prolog2, |
| doctype0, doctype1, doctype2, doctype3, doctype4, doctype5, |
| internalSubset, |
| entity0, entity1, entity2, entity3, entity4, entity5, entity6, |
| entity7, entity8, entity9, entity10, |
| notation0, notation1, notation2, notation3, notation4, |
| attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6, |
| attlist7, attlist8, attlist9, |
| element0, element1, element2, element3, element4, element5, element6, |
| element7, |
| #ifdef XML_DTD |
| externalSubset0, externalSubset1, |
| condSect0, condSect1, condSect2, |
| #endif /* XML_DTD */ |
| declClose, |
| error; |
| |
| static int FASTCALL common(PROLOG_STATE *state, int tok); |
| |
| static int PTRCALL |
| prolog0(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| state->handler = prolog1; |
| return XML_ROLE_NONE; |
| case XML_TOK_XML_DECL: |
| state->handler = prolog1; |
| return XML_ROLE_XML_DECL; |
| case XML_TOK_PI: |
| state->handler = prolog1; |
| return XML_ROLE_PI; |
| case XML_TOK_COMMENT: |
| state->handler = prolog1; |
| return XML_ROLE_COMMENT; |
| case XML_TOK_BOM: |
| return XML_ROLE_NONE; |
| case XML_TOK_DECL_OPEN: |
| if (!XmlNameMatchesAscii(enc, |
| ptr + 2 * MIN_BYTES_PER_CHAR(enc), |
| end, |
| KW_DOCTYPE)) |
| break; |
| state->handler = doctype0; |
| return XML_ROLE_DOCTYPE_NONE; |
| case XML_TOK_INSTANCE_START: |
| state->handler = error; |
| return XML_ROLE_INSTANCE_START; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| prolog1(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NONE; |
| case XML_TOK_PI: |
| return XML_ROLE_PI; |
| case XML_TOK_COMMENT: |
| return XML_ROLE_COMMENT; |
| case XML_TOK_BOM: |
| return XML_ROLE_NONE; |
| case XML_TOK_DECL_OPEN: |
| if (!XmlNameMatchesAscii(enc, |
| ptr + 2 * MIN_BYTES_PER_CHAR(enc), |
| end, |
| KW_DOCTYPE)) |
| break; |
| state->handler = doctype0; |
| return XML_ROLE_DOCTYPE_NONE; |
| case XML_TOK_INSTANCE_START: |
| state->handler = error; |
| return XML_ROLE_INSTANCE_START; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| prolog2(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NONE; |
| case XML_TOK_PI: |
| return XML_ROLE_PI; |
| case XML_TOK_COMMENT: |
| return XML_ROLE_COMMENT; |
| case XML_TOK_INSTANCE_START: |
| state->handler = error; |
| return XML_ROLE_INSTANCE_START; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| doctype0(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_DOCTYPE_NONE; |
| case XML_TOK_NAME: |
| case XML_TOK_PREFIXED_NAME: |
| state->handler = doctype1; |
| return XML_ROLE_DOCTYPE_NAME; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| doctype1(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_DOCTYPE_NONE; |
| case XML_TOK_OPEN_BRACKET: |
| state->handler = internalSubset; |
| return XML_ROLE_DOCTYPE_INTERNAL_SUBSET; |
| case XML_TOK_DECL_CLOSE: |
| state->handler = prolog2; |
| return XML_ROLE_DOCTYPE_CLOSE; |
| case XML_TOK_NAME: |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { |
| state->handler = doctype3; |
| return XML_ROLE_DOCTYPE_NONE; |
| } |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { |
| state->handler = doctype2; |
| return XML_ROLE_DOCTYPE_NONE; |
| } |
| break; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| doctype2(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_DOCTYPE_NONE; |
| case XML_TOK_LITERAL: |
| state->handler = doctype3; |
| return XML_ROLE_DOCTYPE_PUBLIC_ID; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| doctype3(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_DOCTYPE_NONE; |
| case XML_TOK_LITERAL: |
| state->handler = doctype4; |
| return XML_ROLE_DOCTYPE_SYSTEM_ID; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| doctype4(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_DOCTYPE_NONE; |
| case XML_TOK_OPEN_BRACKET: |
| state->handler = internalSubset; |
| return XML_ROLE_DOCTYPE_INTERNAL_SUBSET; |
| case XML_TOK_DECL_CLOSE: |
| state->handler = prolog2; |
| return XML_ROLE_DOCTYPE_CLOSE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| doctype5(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_DOCTYPE_NONE; |
| case XML_TOK_DECL_CLOSE: |
| state->handler = prolog2; |
| return XML_ROLE_DOCTYPE_CLOSE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| internalSubset(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NONE; |
| case XML_TOK_DECL_OPEN: |
| if (XmlNameMatchesAscii(enc, |
| ptr + 2 * MIN_BYTES_PER_CHAR(enc), |
| end, |
| KW_ENTITY)) { |
| state->handler = entity0; |
| return XML_ROLE_ENTITY_NONE; |
| } |
| if (XmlNameMatchesAscii(enc, |
| ptr + 2 * MIN_BYTES_PER_CHAR(enc), |
| end, |
| KW_ATTLIST)) { |
| state->handler = attlist0; |
| return XML_ROLE_ATTLIST_NONE; |
| } |
| if (XmlNameMatchesAscii(enc, |
| ptr + 2 * MIN_BYTES_PER_CHAR(enc), |
| end, |
| KW_ELEMENT)) { |
| state->handler = element0; |
| return XML_ROLE_ELEMENT_NONE; |
| } |
| if (XmlNameMatchesAscii(enc, |
| ptr + 2 * MIN_BYTES_PER_CHAR(enc), |
| end, |
| KW_NOTATION)) { |
| state->handler = notation0; |
| return XML_ROLE_NOTATION_NONE; |
| } |
| break; |
| case XML_TOK_PI: |
| return XML_ROLE_PI; |
| case XML_TOK_COMMENT: |
| return XML_ROLE_COMMENT; |
| case XML_TOK_PARAM_ENTITY_REF: |
| return XML_ROLE_PARAM_ENTITY_REF; |
| case XML_TOK_CLOSE_BRACKET: |
| state->handler = doctype5; |
| return XML_ROLE_DOCTYPE_NONE; |
| case XML_TOK_NONE: |
| return XML_ROLE_NONE; |
| } |
| return common(state, tok); |
| } |
| |
| #ifdef XML_DTD |
| |
| static int PTRCALL |
| externalSubset0(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| state->handler = externalSubset1; |
| if (tok == XML_TOK_XML_DECL) |
| return XML_ROLE_TEXT_DECL; |
| return externalSubset1(state, tok, ptr, end, enc); |
| } |
| |
| static int PTRCALL |
| externalSubset1(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_COND_SECT_OPEN: |
| state->handler = condSect0; |
| return XML_ROLE_NONE; |
| case XML_TOK_COND_SECT_CLOSE: |
| if (state->includeLevel == 0) |
| break; |
| state->includeLevel -= 1; |
| return XML_ROLE_NONE; |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NONE; |
| case XML_TOK_CLOSE_BRACKET: |
| break; |
| case XML_TOK_NONE: |
| if (state->includeLevel) |
| break; |
| return XML_ROLE_NONE; |
| default: |
| return internalSubset(state, tok, ptr, end, enc); |
| } |
| return common(state, tok); |
| } |
| |
| #endif /* XML_DTD */ |
| |
| static int PTRCALL |
| entity0(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_PERCENT: |
| state->handler = entity1; |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_NAME: |
| state->handler = entity2; |
| return XML_ROLE_GENERAL_ENTITY_NAME; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| entity1(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_NAME: |
| state->handler = entity7; |
| return XML_ROLE_PARAM_ENTITY_NAME; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| entity2(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_NAME: |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { |
| state->handler = entity4; |
| return XML_ROLE_ENTITY_NONE; |
| } |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { |
| state->handler = entity3; |
| return XML_ROLE_ENTITY_NONE; |
| } |
| break; |
| case XML_TOK_LITERAL: |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ENTITY_NONE; |
| return XML_ROLE_ENTITY_VALUE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| entity3(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_LITERAL: |
| state->handler = entity4; |
| return XML_ROLE_ENTITY_PUBLIC_ID; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| entity4(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_LITERAL: |
| state->handler = entity5; |
| return XML_ROLE_ENTITY_SYSTEM_ID; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| entity5(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_DECL_CLOSE: |
| setTopLevel(state); |
| return XML_ROLE_ENTITY_COMPLETE; |
| case XML_TOK_NAME: |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) { |
| state->handler = entity6; |
| return XML_ROLE_ENTITY_NONE; |
| } |
| break; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| entity6(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_NAME: |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ENTITY_NONE; |
| return XML_ROLE_ENTITY_NOTATION_NAME; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| entity7(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_NAME: |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { |
| state->handler = entity9; |
| return XML_ROLE_ENTITY_NONE; |
| } |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { |
| state->handler = entity8; |
| return XML_ROLE_ENTITY_NONE; |
| } |
| break; |
| case XML_TOK_LITERAL: |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ENTITY_NONE; |
| return XML_ROLE_ENTITY_VALUE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| entity8(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_LITERAL: |
| state->handler = entity9; |
| return XML_ROLE_ENTITY_PUBLIC_ID; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| entity9(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_LITERAL: |
| state->handler = entity10; |
| return XML_ROLE_ENTITY_SYSTEM_ID; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| entity10(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ENTITY_NONE; |
| case XML_TOK_DECL_CLOSE: |
| setTopLevel(state); |
| return XML_ROLE_ENTITY_COMPLETE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| notation0(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NOTATION_NONE; |
| case XML_TOK_NAME: |
| state->handler = notation1; |
| return XML_ROLE_NOTATION_NAME; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| notation1(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NOTATION_NONE; |
| case XML_TOK_NAME: |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { |
| state->handler = notation3; |
| return XML_ROLE_NOTATION_NONE; |
| } |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { |
| state->handler = notation2; |
| return XML_ROLE_NOTATION_NONE; |
| } |
| break; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| notation2(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NOTATION_NONE; |
| case XML_TOK_LITERAL: |
| state->handler = notation4; |
| return XML_ROLE_NOTATION_PUBLIC_ID; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| notation3(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NOTATION_NONE; |
| case XML_TOK_LITERAL: |
| state->handler = declClose; |
| state->role_none = XML_ROLE_NOTATION_NONE; |
| return XML_ROLE_NOTATION_SYSTEM_ID; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| notation4(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NOTATION_NONE; |
| case XML_TOK_LITERAL: |
| state->handler = declClose; |
| state->role_none = XML_ROLE_NOTATION_NONE; |
| return XML_ROLE_NOTATION_SYSTEM_ID; |
| case XML_TOK_DECL_CLOSE: |
| setTopLevel(state); |
| return XML_ROLE_NOTATION_NO_SYSTEM_ID; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| attlist0(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_NAME: |
| case XML_TOK_PREFIXED_NAME: |
| state->handler = attlist1; |
| return XML_ROLE_ATTLIST_ELEMENT_NAME; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| attlist1(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_DECL_CLOSE: |
| setTopLevel(state); |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_NAME: |
| case XML_TOK_PREFIXED_NAME: |
| state->handler = attlist2; |
| return XML_ROLE_ATTRIBUTE_NAME; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| attlist2(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_NAME: |
| { |
| static const char * const types[] = { |
| KW_CDATA, |
| KW_ID, |
| KW_IDREF, |
| KW_IDREFS, |
| KW_ENTITY, |
| KW_ENTITIES, |
| KW_NMTOKEN, |
| KW_NMTOKENS, |
| }; |
| int i; |
| for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++) |
| if (XmlNameMatchesAscii(enc, ptr, end, types[i])) { |
| state->handler = attlist8; |
| return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i; |
| } |
| } |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) { |
| state->handler = attlist5; |
| return XML_ROLE_ATTLIST_NONE; |
| } |
| break; |
| case XML_TOK_OPEN_PAREN: |
| state->handler = attlist3; |
| return XML_ROLE_ATTLIST_NONE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| attlist3(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_NMTOKEN: |
| case XML_TOK_NAME: |
| case XML_TOK_PREFIXED_NAME: |
| state->handler = attlist4; |
| return XML_ROLE_ATTRIBUTE_ENUM_VALUE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| attlist4(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_CLOSE_PAREN: |
| state->handler = attlist8; |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_OR: |
| state->handler = attlist3; |
| return XML_ROLE_ATTLIST_NONE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| attlist5(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_OPEN_PAREN: |
| state->handler = attlist6; |
| return XML_ROLE_ATTLIST_NONE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| attlist6(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_NAME: |
| state->handler = attlist7; |
| return XML_ROLE_ATTRIBUTE_NOTATION_VALUE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| attlist7(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_CLOSE_PAREN: |
| state->handler = attlist8; |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_OR: |
| state->handler = attlist6; |
| return XML_ROLE_ATTLIST_NONE; |
| } |
| return common(state, tok); |
| } |
| |
| /* default value */ |
| static int PTRCALL |
| attlist8(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_POUND_NAME: |
| if (XmlNameMatchesAscii(enc, |
| ptr + MIN_BYTES_PER_CHAR(enc), |
| end, |
| KW_IMPLIED)) { |
| state->handler = attlist1; |
| return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE; |
| } |
| if (XmlNameMatchesAscii(enc, |
| ptr + MIN_BYTES_PER_CHAR(enc), |
| end, |
| KW_REQUIRED)) { |
| state->handler = attlist1; |
| return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE; |
| } |
| if (XmlNameMatchesAscii(enc, |
| ptr + MIN_BYTES_PER_CHAR(enc), |
| end, |
| KW_FIXED)) { |
| state->handler = attlist9; |
| return XML_ROLE_ATTLIST_NONE; |
| } |
| break; |
| case XML_TOK_LITERAL: |
| state->handler = attlist1; |
| return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| attlist9(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ATTLIST_NONE; |
| case XML_TOK_LITERAL: |
| state->handler = attlist1; |
| return XML_ROLE_FIXED_ATTRIBUTE_VALUE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| element0(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ELEMENT_NONE; |
| case XML_TOK_NAME: |
| case XML_TOK_PREFIXED_NAME: |
| state->handler = element1; |
| return XML_ROLE_ELEMENT_NAME; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| element1(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ELEMENT_NONE; |
| case XML_TOK_NAME: |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) { |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ELEMENT_NONE; |
| return XML_ROLE_CONTENT_EMPTY; |
| } |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) { |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ELEMENT_NONE; |
| return XML_ROLE_CONTENT_ANY; |
| } |
| break; |
| case XML_TOK_OPEN_PAREN: |
| state->handler = element2; |
| state->level = 1; |
| return XML_ROLE_GROUP_OPEN; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| element2(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ELEMENT_NONE; |
| case XML_TOK_POUND_NAME: |
| if (XmlNameMatchesAscii(enc, |
| ptr + MIN_BYTES_PER_CHAR(enc), |
| end, |
| KW_PCDATA)) { |
| state->handler = element3; |
| return XML_ROLE_CONTENT_PCDATA; |
| } |
| break; |
| case XML_TOK_OPEN_PAREN: |
| state->level = 2; |
| state->handler = element6; |
| return XML_ROLE_GROUP_OPEN; |
| case XML_TOK_NAME: |
| case XML_TOK_PREFIXED_NAME: |
| state->handler = element7; |
| return XML_ROLE_CONTENT_ELEMENT; |
| case XML_TOK_NAME_QUESTION: |
| state->handler = element7; |
| return XML_ROLE_CONTENT_ELEMENT_OPT; |
| case XML_TOK_NAME_ASTERISK: |
| state->handler = element7; |
| return XML_ROLE_CONTENT_ELEMENT_REP; |
| case XML_TOK_NAME_PLUS: |
| state->handler = element7; |
| return XML_ROLE_CONTENT_ELEMENT_PLUS; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| element3(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ELEMENT_NONE; |
| case XML_TOK_CLOSE_PAREN: |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ELEMENT_NONE; |
| return XML_ROLE_GROUP_CLOSE; |
| case XML_TOK_CLOSE_PAREN_ASTERISK: |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ELEMENT_NONE; |
| return XML_ROLE_GROUP_CLOSE_REP; |
| case XML_TOK_OR: |
| state->handler = element4; |
| return XML_ROLE_ELEMENT_NONE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| element4(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ELEMENT_NONE; |
| case XML_TOK_NAME: |
| case XML_TOK_PREFIXED_NAME: |
| state->handler = element5; |
| return XML_ROLE_CONTENT_ELEMENT; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| element5(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ELEMENT_NONE; |
| case XML_TOK_CLOSE_PAREN_ASTERISK: |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ELEMENT_NONE; |
| return XML_ROLE_GROUP_CLOSE_REP; |
| case XML_TOK_OR: |
| state->handler = element4; |
| return XML_ROLE_ELEMENT_NONE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| element6(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ELEMENT_NONE; |
| case XML_TOK_OPEN_PAREN: |
| state->level += 1; |
| return XML_ROLE_GROUP_OPEN; |
| case XML_TOK_NAME: |
| case XML_TOK_PREFIXED_NAME: |
| state->handler = element7; |
| return XML_ROLE_CONTENT_ELEMENT; |
| case XML_TOK_NAME_QUESTION: |
| state->handler = element7; |
| return XML_ROLE_CONTENT_ELEMENT_OPT; |
| case XML_TOK_NAME_ASTERISK: |
| state->handler = element7; |
| return XML_ROLE_CONTENT_ELEMENT_REP; |
| case XML_TOK_NAME_PLUS: |
| state->handler = element7; |
| return XML_ROLE_CONTENT_ELEMENT_PLUS; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| element7(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_ELEMENT_NONE; |
| case XML_TOK_CLOSE_PAREN: |
| state->level -= 1; |
| if (state->level == 0) { |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ELEMENT_NONE; |
| } |
| return XML_ROLE_GROUP_CLOSE; |
| case XML_TOK_CLOSE_PAREN_ASTERISK: |
| state->level -= 1; |
| if (state->level == 0) { |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ELEMENT_NONE; |
| } |
| return XML_ROLE_GROUP_CLOSE_REP; |
| case XML_TOK_CLOSE_PAREN_QUESTION: |
| state->level -= 1; |
| if (state->level == 0) { |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ELEMENT_NONE; |
| } |
| return XML_ROLE_GROUP_CLOSE_OPT; |
| case XML_TOK_CLOSE_PAREN_PLUS: |
| state->level -= 1; |
| if (state->level == 0) { |
| state->handler = declClose; |
| state->role_none = XML_ROLE_ELEMENT_NONE; |
| } |
| return XML_ROLE_GROUP_CLOSE_PLUS; |
| case XML_TOK_COMMA: |
| state->handler = element6; |
| return XML_ROLE_GROUP_SEQUENCE; |
| case XML_TOK_OR: |
| state->handler = element6; |
| return XML_ROLE_GROUP_CHOICE; |
| } |
| return common(state, tok); |
| } |
| |
| #ifdef XML_DTD |
| |
| static int PTRCALL |
| condSect0(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NONE; |
| case XML_TOK_NAME: |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) { |
| state->handler = condSect1; |
| return XML_ROLE_NONE; |
| } |
| if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) { |
| state->handler = condSect2; |
| return XML_ROLE_NONE; |
| } |
| break; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| condSect1(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NONE; |
| case XML_TOK_OPEN_BRACKET: |
| state->handler = externalSubset1; |
| state->includeLevel += 1; |
| return XML_ROLE_NONE; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| condSect2(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return XML_ROLE_NONE; |
| case XML_TOK_OPEN_BRACKET: |
| state->handler = externalSubset1; |
| return XML_ROLE_IGNORE_SECT; |
| } |
| return common(state, tok); |
| } |
| |
| #endif /* XML_DTD */ |
| |
| static int PTRCALL |
| declClose(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| switch (tok) { |
| case XML_TOK_PROLOG_S: |
| return state->role_none; |
| case XML_TOK_DECL_CLOSE: |
| setTopLevel(state); |
| return state->role_none; |
| } |
| return common(state, tok); |
| } |
| |
| static int PTRCALL |
| error(PROLOG_STATE *state, |
| int tok, |
| const char *ptr, |
| const char *end, |
| const ENCODING *enc) |
| { |
| return XML_ROLE_NONE; |
| } |
| |
| static int FASTCALL |
| common(PROLOG_STATE *state, int tok) |
| { |
| #ifdef XML_DTD |
| if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF) |
| return XML_ROLE_INNER_PARAM_ENTITY_REF; |
| #endif |
| state->handler = error; |
| return XML_ROLE_ERROR; |
| } |
| |
| void |
| XmlPrologStateInit(PROLOG_STATE *state) |
| { |
| state->handler = prolog0; |
| #ifdef XML_DTD |
| state->documentEntity = 1; |
| state->includeLevel = 0; |
| state->inEntityValue = 0; |
| #endif /* XML_DTD */ |
| } |
| |
| #ifdef XML_DTD |
| |
| void |
| XmlPrologStateInitExternalEntity(PROLOG_STATE *state) |
| { |
| state->handler = externalSubset0; |
| state->documentEntity = 0; |
| state->includeLevel = 0; |
| } |
| |
| #endif /* XML_DTD */ |