xmltok_impl_c.h

Simple Jabber Client for Symbian Platform

                        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 PREFIX(scanPercent)(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_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 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_PARTIAL;
}

static
int 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_PARTIAL;
            *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 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)
            return XML_TOK_TRAILING_CR;
        /* 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_PARTIAL;
        if (CHAR_MATCHES(enc, ptr, ']')) {
            if (ptr + MINBPC(enc) == end)
                return XML_TOK_PARTIAL;
            if (CHAR_MATCHES(enc, ptr + MINBPC(enc), '>')) {
                *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_PARTIAL;
        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 XML_TOK_PARTIAL;
}

static
int 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 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)
                return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
            *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)