/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd | |
See the file COPYING for copying permission. | |
*/ | |
#ifndef IS_INVALID_CHAR | |
#define IS_INVALID_CHAR(enc, ptr, n) (0) | |
#endif | |
#define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \ | |
case BT_LEAD ## n: \ | |
if (end - ptr < n) \ | |
return XML_TOK_PARTIAL_CHAR; \ | |
if (IS_INVALID_CHAR(enc, ptr, n)) { \ | |
*(nextTokPtr) = (ptr); \ | |
return XML_TOK_INVALID; \ | |
} \ | |
ptr += n; \ | |
break; | |
#define INVALID_CASES(ptr, nextTokPtr) \ | |
INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | |
INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | |
INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | |
case BT_NONXML: \ | |
case BT_MALFORM: \ | |
case BT_TRAIL: \ | |
*(nextTokPtr) = (ptr); \ | |
return XML_TOK_INVALID; | |
#define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \ | |
case BT_LEAD ## n: \ | |
if (end - ptr < n) \ | |
return XML_TOK_PARTIAL_CHAR; \ | |
if (!IS_NAME_CHAR(enc, ptr, n)) { \ | |
*nextTokPtr = ptr; \ | |
return XML_TOK_INVALID; \ | |
} \ | |
ptr += n; \ | |
break; | |
#define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \ | |
case BT_NONASCII: \ | |
if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | |
*nextTokPtr = ptr; \ | |
return XML_TOK_INVALID; \ | |
} \ | |
case BT_NMSTRT: \ | |
case BT_HEX: \ | |
case BT_DIGIT: \ | |
case BT_NAME: \ | |
case BT_MINUS: \ | |
ptr += MINBPC(enc); \ | |
break; \ | |
CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | |
CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | |
CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | |
#define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \ | |
case BT_LEAD ## n: \ | |
if (end - ptr < n) \ | |
return XML_TOK_PARTIAL_CHAR; \ | |
if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \ | |
*nextTokPtr = ptr; \ | |
return XML_TOK_INVALID; \ | |
} \ | |
ptr += n; \ | |
break; | |
#define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \ | |
case BT_NONASCII: \ | |
if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | |
*nextTokPtr = ptr; \ | |
return XML_TOK_INVALID; \ | |
} \ | |
case BT_NMSTRT: \ | |
case BT_HEX: \ | |
ptr += MINBPC(enc); \ | |
break; \ | |
CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | |
CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | |
CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | |
#ifndef PREFIX | |
#define PREFIX(ident) ident | |
#endif | |
/* ptr points to character following "<!-" */ | |
static int PTRCALL | |
PREFIX(scanComment)(const ENCODING *enc, const char *ptr, | |
const char *end, const char **nextTokPtr) | |
{ | |
if (ptr != end) { | |
if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
ptr += MINBPC(enc); | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
INVALID_CASES(ptr, nextTokPtr) | |
case BT_MINUS: | |
if ((ptr += MINBPC(enc)) == end) | |
return XML_TOK_PARTIAL; | |
if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) { | |
if ((ptr += MINBPC(enc)) == end) | |
return XML_TOK_PARTIAL; | |
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_COMMENT; | |
} | |
break; | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
/* ptr points to character following "<!" */ | |
static int PTRCALL | |
PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, | |
const char *end, const char **nextTokPtr) | |
{ | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_MINUS: | |
return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
case BT_LSQB: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_COND_SECT_OPEN; | |
case BT_NMSTRT: | |
case BT_HEX: | |
ptr += MINBPC(enc); | |
break; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_PERCNT: | |
if (ptr + MINBPC(enc) == end) | |
return XML_TOK_PARTIAL; | |
/* don't allow <!ENTITY% foo "whatever"> */ | |
switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) { | |
case BT_S: case BT_CR: case BT_LF: case BT_PERCNT: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
/* fall through */ | |
case BT_S: case BT_CR: case BT_LF: | |
*nextTokPtr = ptr; | |
return XML_TOK_DECL_OPEN; | |
case BT_NMSTRT: | |
case BT_HEX: | |
ptr += MINBPC(enc); | |
break; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
static int PTRCALL | |
PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, | |
const char *end, int *tokPtr) | |
{ | |
int upper = 0; | |
*tokPtr = XML_TOK_PI; | |
if (end - ptr != MINBPC(enc)*3) | |
return 1; | |
switch (BYTE_TO_ASCII(enc, ptr)) { | |
case ASCII_x: | |
break; | |
case ASCII_X: | |
upper = 1; | |
break; | |
default: | |
return 1; | |
} | |
ptr += MINBPC(enc); | |
switch (BYTE_TO_ASCII(enc, ptr)) { | |
case ASCII_m: | |
break; | |
case ASCII_M: | |
upper = 1; | |
break; | |
default: | |
return 1; | |
} | |
ptr += MINBPC(enc); | |
switch (BYTE_TO_ASCII(enc, ptr)) { | |
case ASCII_l: | |
break; | |
case ASCII_L: | |
upper = 1; | |
break; | |
default: | |
return 1; | |
} | |
if (upper) | |
return 0; | |
*tokPtr = XML_TOK_XML_DECL; | |
return 1; | |
} | |
/* ptr points to character following "<?" */ | |
static int PTRCALL | |
PREFIX(scanPi)(const ENCODING *enc, const char *ptr, | |
const char *end, const char **nextTokPtr) | |
{ | |
int tok; | |
const char *target = ptr; | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
case BT_S: case BT_CR: case BT_LF: | |
if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
ptr += MINBPC(enc); | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
INVALID_CASES(ptr, nextTokPtr) | |
case BT_QUEST: | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
*nextTokPtr = ptr + MINBPC(enc); | |
return tok; | |
} | |
break; | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
} | |
return XML_TOK_PARTIAL; | |
case BT_QUEST: | |
if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
*nextTokPtr = ptr + MINBPC(enc); | |
return tok; | |
} | |
/* fall through */ | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
static int PTRCALL | |
PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, | |
const char *end, const char **nextTokPtr) | |
{ | |
static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A, | |
ASCII_T, ASCII_A, ASCII_LSQB }; | |
int i; | |
/* CDATA[ */ | |
if (end - ptr < 6 * MINBPC(enc)) | |
return XML_TOK_PARTIAL; | |
for (i = 0; i < 6; i++, ptr += MINBPC(enc)) { | |
if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_CDATA_SECT_OPEN; | |
} | |
static int PTRCALL | |
PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, | |
const char *end, const char **nextTokPtr) | |
{ | |
if (ptr == end) | |
return XML_TOK_NONE; | |
if (MINBPC(enc) > 1) { | |
size_t n = end - ptr; | |
if (n & (MINBPC(enc) - 1)) { | |
n &= ~(MINBPC(enc) - 1); | |
if (n == 0) | |
return XML_TOK_PARTIAL; | |
end = ptr + n; | |
} | |
} | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_RSQB: | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB)) | |
break; | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
ptr -= MINBPC(enc); | |
break; | |
} | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_CDATA_SECT_CLOSE; | |
case BT_CR: | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
if (BYTE_TYPE(enc, ptr) == BT_LF) | |
ptr += MINBPC(enc); | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_NEWLINE; | |
case BT_LF: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_DATA_NEWLINE; | |
INVALID_CASES(ptr, nextTokPtr) | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
#define LEAD_CASE(n) \ | |
case BT_LEAD ## n: \ | |
if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | |
*nextTokPtr = ptr; \ | |
return XML_TOK_DATA_CHARS; \ | |
} \ | |
ptr += n; \ | |
break; | |
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
#undef LEAD_CASE | |
case BT_NONXML: | |
case BT_MALFORM: | |
case BT_TRAIL: | |
case BT_CR: | |
case BT_LF: | |
case BT_RSQB: | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
} | |
/* ptr points to character following "</" */ | |
static int PTRCALL | |
PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, | |
const char *end, const char **nextTokPtr) | |
{ | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
case BT_S: case BT_CR: case BT_LF: | |
for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_S: case BT_CR: case BT_LF: | |
break; | |
case BT_GT: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_END_TAG; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
return XML_TOK_PARTIAL; | |
#ifdef XML_NS | |
case BT_COLON: | |
/* no need to check qname syntax here, | |
since end-tag must match exactly */ | |
ptr += MINBPC(enc); | |
break; | |
#endif | |
case BT_GT: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_END_TAG; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
/* ptr points to character following "&#X" */ | |
static int PTRCALL | |
PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, | |
const char *end, const char **nextTokPtr) | |
{ | |
if (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_DIGIT: | |
case BT_HEX: | |
break; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_DIGIT: | |
case BT_HEX: | |
break; | |
case BT_SEMI: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_CHAR_REF; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
/* ptr points to character following "&#" */ | |
static int PTRCALL | |
PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, | |
const char *end, const char **nextTokPtr) | |
{ | |
if (ptr != end) { | |
if (CHAR_MATCHES(enc, ptr, ASCII_x)) | |
return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_DIGIT: | |
break; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_DIGIT: | |
break; | |
case BT_SEMI: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_CHAR_REF; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
/* ptr points to character following "&" */ | |
static int PTRCALL | |
PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end, | |
const char **nextTokPtr) | |
{ | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
case BT_NUM: | |
return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
case BT_SEMI: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_ENTITY_REF; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
/* ptr points to character following first character of attribute name */ | |
static int PTRCALL | |
PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end, | |
const char **nextTokPtr) | |
{ | |
#ifdef XML_NS | |
int hadColon = 0; | |
#endif | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
#ifdef XML_NS | |
case BT_COLON: | |
if (hadColon) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
hadColon = 1; | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
break; | |
#endif | |
case BT_S: case BT_CR: case BT_LF: | |
for (;;) { | |
int t; | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
t = BYTE_TYPE(enc, ptr); | |
if (t == BT_EQUALS) | |
break; | |
switch (t) { | |
case BT_S: | |
case BT_LF: | |
case BT_CR: | |
break; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
/* fall through */ | |
case BT_EQUALS: | |
{ | |
int open; | |
#ifdef XML_NS | |
hadColon = 0; | |
#endif | |
for (;;) { | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
open = BYTE_TYPE(enc, ptr); | |
if (open == BT_QUOT || open == BT_APOS) | |
break; | |
switch (open) { | |
case BT_S: | |
case BT_LF: | |
case BT_CR: | |
break; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
ptr += MINBPC(enc); | |
/* in attribute value */ | |
for (;;) { | |
int t; | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
t = BYTE_TYPE(enc, ptr); | |
if (t == open) | |
break; | |
switch (t) { | |
INVALID_CASES(ptr, nextTokPtr) | |
case BT_AMP: | |
{ | |
int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr); | |
if (tok <= 0) { | |
if (tok == XML_TOK_INVALID) | |
*nextTokPtr = ptr; | |
return tok; | |
} | |
break; | |
} | |
case BT_LT: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
} | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_S: | |
case BT_CR: | |
case BT_LF: | |
break; | |
case BT_SOL: | |
goto sol; | |
case BT_GT: | |
goto gt; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
/* ptr points to closing quote */ | |
for (;;) { | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
case BT_S: case BT_CR: case BT_LF: | |
continue; | |
case BT_GT: | |
gt: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_START_TAG_WITH_ATTS; | |
case BT_SOL: | |
sol: | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_EMPTY_ELEMENT_WITH_ATTS; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
break; | |
} | |
break; | |
} | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
/* ptr points to character following "<" */ | |
static int PTRCALL | |
PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end, | |
const char **nextTokPtr) | |
{ | |
#ifdef XML_NS | |
int hadColon; | |
#endif | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
case BT_EXCL: | |
if ((ptr += MINBPC(enc)) == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_MINUS: | |
return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
case BT_LSQB: | |
return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), | |
end, nextTokPtr); | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
case BT_QUEST: | |
return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
case BT_SOL: | |
return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
#ifdef XML_NS | |
hadColon = 0; | |
#endif | |
/* we have a start-tag */ | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
#ifdef XML_NS | |
case BT_COLON: | |
if (hadColon) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
hadColon = 1; | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
break; | |
#endif | |
case BT_S: case BT_CR: case BT_LF: | |
{ | |
ptr += MINBPC(enc); | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
case BT_GT: | |
goto gt; | |
case BT_SOL: | |
goto sol; | |
case BT_S: case BT_CR: case BT_LF: | |
ptr += MINBPC(enc); | |
continue; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr); | |
} | |
return XML_TOK_PARTIAL; | |
} | |
case BT_GT: | |
gt: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_START_TAG_NO_ATTS; | |
case BT_SOL: | |
sol: | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_EMPTY_ELEMENT_NO_ATTS; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
static int PTRCALL | |
PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end, | |
const char **nextTokPtr) | |
{ | |
if (ptr == end) | |
return XML_TOK_NONE; | |
if (MINBPC(enc) > 1) { | |
size_t n = end - ptr; | |
if (n & (MINBPC(enc) - 1)) { | |
n &= ~(MINBPC(enc) - 1); | |
if (n == 0) | |
return XML_TOK_PARTIAL; | |
end = ptr + n; | |
} | |
} | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_LT: | |
return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
case BT_AMP: | |
return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
case BT_CR: | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_TRAILING_CR; | |
if (BYTE_TYPE(enc, ptr) == BT_LF) | |
ptr += MINBPC(enc); | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_NEWLINE; | |
case BT_LF: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_DATA_NEWLINE; | |
case BT_RSQB: | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_TRAILING_RSQB; | |
if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB)) | |
break; | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_TRAILING_RSQB; | |
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
ptr -= MINBPC(enc); | |
break; | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
INVALID_CASES(ptr, nextTokPtr) | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
#define LEAD_CASE(n) \ | |
case BT_LEAD ## n: \ | |
if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | |
*nextTokPtr = ptr; \ | |
return XML_TOK_DATA_CHARS; \ | |
} \ | |
ptr += n; \ | |
break; | |
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
#undef LEAD_CASE | |
case BT_RSQB: | |
if (ptr + MINBPC(enc) != end) { | |
if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) { | |
ptr += MINBPC(enc); | |
break; | |
} | |
if (ptr + 2*MINBPC(enc) != end) { | |
if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) { | |
ptr += MINBPC(enc); | |
break; | |
} | |
*nextTokPtr = ptr + 2*MINBPC(enc); | |
return XML_TOK_INVALID; | |
} | |
} | |
/* fall through */ | |
case BT_AMP: | |
case BT_LT: | |
case BT_NONXML: | |
case BT_MALFORM: | |
case BT_TRAIL: | |
case BT_CR: | |
case BT_LF: | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
} | |
/* ptr points to character following "%" */ | |
static int PTRCALL | |
PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end, | |
const char **nextTokPtr) | |
{ | |
if (ptr == end) | |
return -XML_TOK_PERCENT; | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
case BT_S: case BT_LF: case BT_CR: case BT_PERCNT: | |
*nextTokPtr = ptr; | |
return XML_TOK_PERCENT; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
case BT_SEMI: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_PARAM_ENTITY_REF; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
static int PTRCALL | |
PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end, | |
const char **nextTokPtr) | |
{ | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
case BT_CR: case BT_LF: case BT_S: | |
case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR: | |
*nextTokPtr = ptr; | |
return XML_TOK_POUND_NAME; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
return -XML_TOK_POUND_NAME; | |
} | |
static int PTRCALL | |
PREFIX(scanLit)(int open, const ENCODING *enc, | |
const char *ptr, const char *end, | |
const char **nextTokPtr) | |
{ | |
while (ptr != end) { | |
int t = BYTE_TYPE(enc, ptr); | |
switch (t) { | |
INVALID_CASES(ptr, nextTokPtr) | |
case BT_QUOT: | |
case BT_APOS: | |
ptr += MINBPC(enc); | |
if (t != open) | |
break; | |
if (ptr == end) | |
return -XML_TOK_LITERAL; | |
*nextTokPtr = ptr; | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_S: case BT_CR: case BT_LF: | |
case BT_GT: case BT_PERCNT: case BT_LSQB: | |
return XML_TOK_LITERAL; | |
default: | |
return XML_TOK_INVALID; | |
} | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
static int PTRCALL | |
PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end, | |
const char **nextTokPtr) | |
{ | |
int tok; | |
if (ptr == end) | |
return XML_TOK_NONE; | |
if (MINBPC(enc) > 1) { | |
size_t n = end - ptr; | |
if (n & (MINBPC(enc) - 1)) { | |
n &= ~(MINBPC(enc) - 1); | |
if (n == 0) | |
return XML_TOK_PARTIAL; | |
end = ptr + n; | |
} | |
} | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_QUOT: | |
return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr); | |
case BT_APOS: | |
return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr); | |
case BT_LT: | |
{ | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_EXCL: | |
return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
case BT_QUEST: | |
return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
case BT_NMSTRT: | |
case BT_HEX: | |
case BT_NONASCII: | |
case BT_LEAD2: | |
case BT_LEAD3: | |
case BT_LEAD4: | |
*nextTokPtr = ptr - MINBPC(enc); | |
return XML_TOK_INSTANCE_START; | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
case BT_CR: | |
if (ptr + MINBPC(enc) == end) { | |
*nextTokPtr = end; | |
/* indicate that this might be part of a CR/LF pair */ | |
return -XML_TOK_PROLOG_S; | |
} | |
/* fall through */ | |
case BT_S: case BT_LF: | |
for (;;) { | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
break; | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_S: case BT_LF: | |
break; | |
case BT_CR: | |
/* don't split CR/LF pair */ | |
if (ptr + MINBPC(enc) != end) | |
break; | |
/* fall through */ | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_PROLOG_S; | |
} | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_PROLOG_S; | |
case BT_PERCNT: | |
return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
case BT_COMMA: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_COMMA; | |
case BT_LSQB: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_OPEN_BRACKET; | |
case BT_RSQB: | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return -XML_TOK_CLOSE_BRACKET; | |
if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) { | |
if (ptr + MINBPC(enc) == end) | |
return XML_TOK_PARTIAL; | |
if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) { | |
*nextTokPtr = ptr + 2*MINBPC(enc); | |
return XML_TOK_COND_SECT_CLOSE; | |
} | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_CLOSE_BRACKET; | |
case BT_LPAR: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_OPEN_PAREN; | |
case BT_RPAR: | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return -XML_TOK_CLOSE_PAREN; | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_AST: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_CLOSE_PAREN_ASTERISK; | |
case BT_QUEST: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_CLOSE_PAREN_QUESTION; | |
case BT_PLUS: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_CLOSE_PAREN_PLUS; | |
case BT_CR: case BT_LF: case BT_S: | |
case BT_GT: case BT_COMMA: case BT_VERBAR: | |
case BT_RPAR: | |
*nextTokPtr = ptr; | |
return XML_TOK_CLOSE_PAREN; | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
case BT_VERBAR: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_OR; | |
case BT_GT: | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_DECL_CLOSE; | |
case BT_NUM: | |
return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
#define LEAD_CASE(n) \ | |
case BT_LEAD ## n: \ | |
if (end - ptr < n) \ | |
return XML_TOK_PARTIAL_CHAR; \ | |
if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ | |
ptr += n; \ | |
tok = XML_TOK_NAME; \ | |
break; \ | |
} \ | |
if (IS_NAME_CHAR(enc, ptr, n)) { \ | |
ptr += n; \ | |
tok = XML_TOK_NMTOKEN; \ | |
break; \ | |
} \ | |
*nextTokPtr = ptr; \ | |
return XML_TOK_INVALID; | |
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
#undef LEAD_CASE | |
case BT_NMSTRT: | |
case BT_HEX: | |
tok = XML_TOK_NAME; | |
ptr += MINBPC(enc); | |
break; | |
case BT_DIGIT: | |
case BT_NAME: | |
case BT_MINUS: | |
#ifdef XML_NS | |
case BT_COLON: | |
#endif | |
tok = XML_TOK_NMTOKEN; | |
ptr += MINBPC(enc); | |
break; | |
case BT_NONASCII: | |
if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { | |
ptr += MINBPC(enc); | |
tok = XML_TOK_NAME; | |
break; | |
} | |
if (IS_NAME_CHAR_MINBPC(enc, ptr)) { | |
ptr += MINBPC(enc); | |
tok = XML_TOK_NMTOKEN; | |
break; | |
} | |
/* fall through */ | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
case BT_GT: case BT_RPAR: case BT_COMMA: | |
case BT_VERBAR: case BT_LSQB: case BT_PERCNT: | |
case BT_S: case BT_CR: case BT_LF: | |
*nextTokPtr = ptr; | |
return tok; | |
#ifdef XML_NS | |
case BT_COLON: | |
ptr += MINBPC(enc); | |
switch (tok) { | |
case XML_TOK_NAME: | |
if (ptr == end) | |
return XML_TOK_PARTIAL; | |
tok = XML_TOK_PREFIXED_NAME; | |
switch (BYTE_TYPE(enc, ptr)) { | |
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) | |
default: | |
tok = XML_TOK_NMTOKEN; | |
break; | |
} | |
break; | |
case XML_TOK_PREFIXED_NAME: | |
tok = XML_TOK_NMTOKEN; | |
break; | |
} | |
break; | |
#endif | |
case BT_PLUS: | |
if (tok == XML_TOK_NMTOKEN) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_NAME_PLUS; | |
case BT_AST: | |
if (tok == XML_TOK_NMTOKEN) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_NAME_ASTERISK; | |
case BT_QUEST: | |
if (tok == XML_TOK_NMTOKEN) { | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_NAME_QUESTION; | |
default: | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
} | |
} | |
return -tok; | |
} | |
static int PTRCALL | |
PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, | |
const char *end, const char **nextTokPtr) | |
{ | |
const char *start; | |
if (ptr == end) | |
return XML_TOK_NONE; | |
start = ptr; | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
#define LEAD_CASE(n) \ | |
case BT_LEAD ## n: ptr += n; break; | |
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
#undef LEAD_CASE | |
case BT_AMP: | |
if (ptr == start) | |
return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
case BT_LT: | |
/* this is for inside entity references */ | |
*nextTokPtr = ptr; | |
return XML_TOK_INVALID; | |
case BT_LF: | |
if (ptr == start) { | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_DATA_NEWLINE; | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
case BT_CR: | |
if (ptr == start) { | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_TRAILING_CR; | |
if (BYTE_TYPE(enc, ptr) == BT_LF) | |
ptr += MINBPC(enc); | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_NEWLINE; | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
case BT_S: | |
if (ptr == start) { | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_ATTRIBUTE_VALUE_S; | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
} | |
static int PTRCALL | |
PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, | |
const char *end, const char **nextTokPtr) | |
{ | |
const char *start; | |
if (ptr == end) | |
return XML_TOK_NONE; | |
start = ptr; | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
#define LEAD_CASE(n) \ | |
case BT_LEAD ## n: ptr += n; break; | |
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
#undef LEAD_CASE | |
case BT_AMP: | |
if (ptr == start) | |
return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
case BT_PERCNT: | |
if (ptr == start) { | |
int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), | |
end, nextTokPtr); | |
return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok; | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
case BT_LF: | |
if (ptr == start) { | |
*nextTokPtr = ptr + MINBPC(enc); | |
return XML_TOK_DATA_NEWLINE; | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
case BT_CR: | |
if (ptr == start) { | |
ptr += MINBPC(enc); | |
if (ptr == end) | |
return XML_TOK_TRAILING_CR; | |
if (BYTE_TYPE(enc, ptr) == BT_LF) | |
ptr += MINBPC(enc); | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_NEWLINE; | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
} | |
*nextTokPtr = ptr; | |
return XML_TOK_DATA_CHARS; | |
} | |
#ifdef XML_DTD | |
static int PTRCALL | |
PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, | |
const char *end, const char **nextTokPtr) | |
{ | |
int level = 0; | |
if (MINBPC(enc) > 1) { | |
size_t n = end - ptr; | |
if (n & (MINBPC(enc) - 1)) { | |
n &= ~(MINBPC(enc) - 1); | |
end = ptr + n; | |
} | |
} | |
while (ptr != end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
INVALID_CASES(ptr, nextTokPtr) | |
case BT_LT: | |
if ((ptr += MINBPC(enc)) == end) | |
return XML_TOK_PARTIAL; | |
if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) { | |
if ((ptr += MINBPC(enc)) == end) | |
return XML_TOK_PARTIAL; | |
if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) { | |
++level; | |
ptr += MINBPC(enc); | |
} | |
} | |
break; | |
case BT_RSQB: | |
if ((ptr += MINBPC(enc)) == end) | |
return XML_TOK_PARTIAL; | |
if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) { | |
if ((ptr += MINBPC(enc)) == end) | |
return XML_TOK_PARTIAL; | |
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) { | |
ptr += MINBPC(enc); | |
if (level == 0) { | |
*nextTokPtr = ptr; | |
return XML_TOK_IGNORE_SECT; | |
} | |
--level; | |
} | |
} | |
break; | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
} | |
return XML_TOK_PARTIAL; | |
} | |
#endif /* XML_DTD */ | |
static int PTRCALL | |
PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end, | |
const char **badPtr) | |
{ | |
ptr += MINBPC(enc); | |
end -= MINBPC(enc); | |
for (; ptr != end; ptr += MINBPC(enc)) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_DIGIT: | |
case BT_HEX: | |
case BT_MINUS: | |
case BT_APOS: | |
case BT_LPAR: | |
case BT_RPAR: | |
case BT_PLUS: | |
case BT_COMMA: | |
case BT_SOL: | |
case BT_EQUALS: | |
case BT_QUEST: | |
case BT_CR: | |
case BT_LF: | |
case BT_SEMI: | |
case BT_EXCL: | |
case BT_AST: | |
case BT_PERCNT: | |
case BT_NUM: | |
#ifdef XML_NS | |
case BT_COLON: | |
#endif | |
break; | |
case BT_S: | |
if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) { | |
*badPtr = ptr; | |
return 0; | |
} | |
break; | |
case BT_NAME: | |
case BT_NMSTRT: | |
if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f)) | |
break; | |
default: | |
switch (BYTE_TO_ASCII(enc, ptr)) { | |
case 0x24: /* $ */ | |
case 0x40: /* @ */ | |
break; | |
default: | |
*badPtr = ptr; | |
return 0; | |
} | |
break; | |
} | |
} | |
return 1; | |
} | |
/* This must only be called for a well-formed start-tag or empty | |
element tag. Returns the number of attributes. Pointers to the | |
first attsMax attributes are stored in atts. | |
*/ | |
static int PTRCALL | |
PREFIX(getAtts)(const ENCODING *enc, const char *ptr, | |
int attsMax, ATTRIBUTE *atts) | |
{ | |
enum { other, inName, inValue } state = inName; | |
int nAtts = 0; | |
int open = 0; /* defined when state == inValue; | |
initialization just to shut up compilers */ | |
for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
#define START_NAME \ | |
if (state == other) { \ | |
if (nAtts < attsMax) { \ | |
atts[nAtts].name = ptr; \ | |
atts[nAtts].normalized = 1; \ | |
} \ | |
state = inName; \ | |
} | |
#define LEAD_CASE(n) \ | |
case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break; | |
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
#undef LEAD_CASE | |
case BT_NONASCII: | |
case BT_NMSTRT: | |
case BT_HEX: | |
START_NAME | |
break; | |
#undef START_NAME | |
case BT_QUOT: | |
if (state != inValue) { | |
if (nAtts < attsMax) | |
atts[nAtts].valuePtr = ptr + MINBPC(enc); | |
state = inValue; | |
open = BT_QUOT; | |
} | |
else if (open == BT_QUOT) { | |
state = other; | |
if (nAtts < attsMax) | |
atts[nAtts].valueEnd = ptr; | |
nAtts++; | |
} | |
break; | |
case BT_APOS: | |
if (state != inValue) { | |
if (nAtts < attsMax) | |
atts[nAtts].valuePtr = ptr + MINBPC(enc); | |
state = inValue; | |
open = BT_APOS; | |
} | |
else if (open == BT_APOS) { | |
state = other; | |
if (nAtts < attsMax) | |
atts[nAtts].valueEnd = ptr; | |
nAtts++; | |
} | |
break; | |
case BT_AMP: | |
if (nAtts < attsMax) | |
atts[nAtts].normalized = 0; | |
break; | |
case BT_S: | |
if (state == inName) | |
state = other; | |
else if (state == inValue | |
&& nAtts < attsMax | |
&& atts[nAtts].normalized | |
&& (ptr == atts[nAtts].valuePtr | |
|| BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE | |
|| BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE | |
|| BYTE_TYPE(enc, ptr + MINBPC(enc)) == open)) | |
atts[nAtts].normalized = 0; | |
break; | |
case BT_CR: case BT_LF: | |
/* This case ensures that the first attribute name is counted | |
Apart from that we could just change state on the quote. */ | |
if (state == inName) | |
state = other; | |
else if (state == inValue && nAtts < attsMax) | |
atts[nAtts].normalized = 0; | |
break; | |
case BT_GT: | |
case BT_SOL: | |
if (state != inValue) | |
return nAtts; | |
break; | |
default: | |
break; | |
} | |
} | |
/* not reached */ | |
} | |
static int PTRFASTCALL | |
PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) | |
{ | |
int result = 0; | |
/* skip &# */ | |
ptr += 2*MINBPC(enc); | |
if (CHAR_MATCHES(enc, ptr, ASCII_x)) { | |
for (ptr += MINBPC(enc); | |
!CHAR_MATCHES(enc, ptr, ASCII_SEMI); | |
ptr += MINBPC(enc)) { | |
int c = BYTE_TO_ASCII(enc, ptr); | |
switch (c) { | |
case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4: | |
case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9: | |
result <<= 4; | |
result |= (c - ASCII_0); | |
break; | |
case ASCII_A: case ASCII_B: case ASCII_C: | |
case ASCII_D: case ASCII_E: case ASCII_F: | |
result <<= 4; | |
result += 10 + (c - ASCII_A); | |
break; | |
case ASCII_a: case ASCII_b: case ASCII_c: | |
case ASCII_d: case ASCII_e: case ASCII_f: | |
result <<= 4; | |
result += 10 + (c - ASCII_a); | |
break; | |
} | |
if (result >= 0x110000) | |
return -1; | |
} | |
} | |
else { | |
for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) { | |
int c = BYTE_TO_ASCII(enc, ptr); | |
result *= 10; | |
result += (c - ASCII_0); | |
if (result >= 0x110000) | |
return -1; | |
} | |
} | |
return checkCharRefNumber(result); | |
} | |
static int PTRCALL | |
PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr, | |
const char *end) | |
{ | |
switch ((end - ptr)/MINBPC(enc)) { | |
case 2: | |
if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) { | |
switch (BYTE_TO_ASCII(enc, ptr)) { | |
case ASCII_l: | |
return ASCII_LT; | |
case ASCII_g: | |
return ASCII_GT; | |
} | |
} | |
break; | |
case 3: | |
if (CHAR_MATCHES(enc, ptr, ASCII_a)) { | |
ptr += MINBPC(enc); | |
if (CHAR_MATCHES(enc, ptr, ASCII_m)) { | |
ptr += MINBPC(enc); | |
if (CHAR_MATCHES(enc, ptr, ASCII_p)) | |
return ASCII_AMP; | |
} | |
} | |
break; | |
case 4: | |
switch (BYTE_TO_ASCII(enc, ptr)) { | |
case ASCII_q: | |
ptr += MINBPC(enc); | |
if (CHAR_MATCHES(enc, ptr, ASCII_u)) { | |
ptr += MINBPC(enc); | |
if (CHAR_MATCHES(enc, ptr, ASCII_o)) { | |
ptr += MINBPC(enc); | |
if (CHAR_MATCHES(enc, ptr, ASCII_t)) | |
return ASCII_QUOT; | |
} | |
} | |
break; | |
case ASCII_a: | |
ptr += MINBPC(enc); | |
if (CHAR_MATCHES(enc, ptr, ASCII_p)) { | |
ptr += MINBPC(enc); | |
if (CHAR_MATCHES(enc, ptr, ASCII_o)) { | |
ptr += MINBPC(enc); | |
if (CHAR_MATCHES(enc, ptr, ASCII_s)) | |
return ASCII_APOS; | |
} | |
} | |
break; | |
} | |
} | |
return 0; | |
} | |
static int PTRCALL | |
PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2) | |
{ | |
for (;;) { | |
switch (BYTE_TYPE(enc, ptr1)) { | |
#define LEAD_CASE(n) \ | |
case BT_LEAD ## n: \ | |
if (*ptr1++ != *ptr2++) \ | |
return 0; | |
LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2) | |
#undef LEAD_CASE | |
/* fall through */ | |
if (*ptr1++ != *ptr2++) | |
return 0; | |
break; | |
case BT_NONASCII: | |
case BT_NMSTRT: | |
#ifdef XML_NS | |
case BT_COLON: | |
#endif | |
case BT_HEX: | |
case BT_DIGIT: | |
case BT_NAME: | |
case BT_MINUS: | |
if (*ptr2++ != *ptr1++) | |
return 0; | |
if (MINBPC(enc) > 1) { | |
if (*ptr2++ != *ptr1++) | |
return 0; | |
if (MINBPC(enc) > 2) { | |
if (*ptr2++ != *ptr1++) | |
return 0; | |
if (MINBPC(enc) > 3) { | |
if (*ptr2++ != *ptr1++) | |
return 0; | |
} | |
} | |
} | |
break; | |
default: | |
if (MINBPC(enc) == 1 && *ptr1 == *ptr2) | |
return 1; | |
switch (BYTE_TYPE(enc, ptr2)) { | |
case BT_LEAD2: | |
case BT_LEAD3: | |
case BT_LEAD4: | |
case BT_NONASCII: | |
case BT_NMSTRT: | |
#ifdef XML_NS | |
case BT_COLON: | |
#endif | |
case BT_HEX: | |
case BT_DIGIT: | |
case BT_NAME: | |
case BT_MINUS: | |
return 0; | |
default: | |
return 1; | |
} | |
} | |
} | |
/* not reached */ | |
} | |
static int PTRCALL | |
PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1, | |
const char *end1, const char *ptr2) | |
{ | |
for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) { | |
if (ptr1 == end1) | |
return 0; | |
if (!CHAR_MATCHES(enc, ptr1, *ptr2)) | |
return 0; | |
} | |
return ptr1 == end1; | |
} | |
static int PTRFASTCALL | |
PREFIX(nameLength)(const ENCODING *enc, const char *ptr) | |
{ | |
const char *start = ptr; | |
for (;;) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
#define LEAD_CASE(n) \ | |
case BT_LEAD ## n: ptr += n; break; | |
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
#undef LEAD_CASE | |
case BT_NONASCII: | |
case BT_NMSTRT: | |
#ifdef XML_NS | |
case BT_COLON: | |
#endif | |
case BT_HEX: | |
case BT_DIGIT: | |
case BT_NAME: | |
case BT_MINUS: | |
ptr += MINBPC(enc); | |
break; | |
default: | |
return (int)(ptr - start); | |
} | |
} | |
} | |
static const char * PTRFASTCALL | |
PREFIX(skipS)(const ENCODING *enc, const char *ptr) | |
{ | |
for (;;) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
case BT_LF: | |
case BT_CR: | |
case BT_S: | |
ptr += MINBPC(enc); | |
break; | |
default: | |
return ptr; | |
} | |
} | |
} | |
static void PTRCALL | |
PREFIX(updatePosition)(const ENCODING *enc, | |
const char *ptr, | |
const char *end, | |
POSITION *pos) | |
{ | |
while (ptr < end) { | |
switch (BYTE_TYPE(enc, ptr)) { | |
#define LEAD_CASE(n) \ | |
case BT_LEAD ## n: \ | |
ptr += n; \ | |
break; | |
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) | |
#undef LEAD_CASE | |
case BT_LF: | |
pos->columnNumber = (XML_Size)-1; | |
pos->lineNumber++; | |
ptr += MINBPC(enc); | |
break; | |
case BT_CR: | |
pos->lineNumber++; | |
ptr += MINBPC(enc); | |
if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF) | |
ptr += MINBPC(enc); | |
pos->columnNumber = (XML_Size)-1; | |
break; | |
default: | |
ptr += MINBPC(enc); | |
break; | |
} | |
pos->columnNumber++; | |
} | |
} | |
#undef DO_LEAD_CASE | |
#undef MULTIBYTE_CASES | |
#undef INVALID_CASES | |
#undef CHECK_NAME_CASE | |
#undef CHECK_NAME_CASES | |
#undef CHECK_NMSTRT_CASE | |
#undef CHECK_NMSTRT_CASES | |