xmltok_impl_c.h

Simple Jabber Client for Symbian Platform

        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 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 PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
                        const char **nextTokPtr)
{
    if (ptr != end) {
        if (CHAR_MATCHES(enc, ptr, '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 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 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, '>')) {
                            *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 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, '>')) {
                *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 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, ']'))
            break;
        ptr += MINBPC(enc);
        if (ptr == end)
            return XML_TOK_TRAILING_RSQB;
        if (!CHAR_MATCHES(enc, ptr, '>')) {
            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), ']')) {
                    ptr += MINBPC(enc);
                    break;
                }
                if (ptr + 2*MINBPC(enc) != end) {
                    if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), '>')) {