xmlrole.c

Simple Jabber Client for Symbian Platform

static
int 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_NONE;
    case XML_TOK_LITERAL:
        state->handler = notation4;
        return XML_ROLE_NOTATION_PUBLIC_ID;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_LITERAL:
        state->handler = declClose;
        return XML_ROLE_NOTATION_SYSTEM_ID;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_LITERAL:
        state->handler = declClose;
        return XML_ROLE_NOTATION_SYSTEM_ID;
    case XML_TOK_DECL_CLOSE:
        state->handler = internalSubset;
        return XML_ROLE_NOTATION_NO_SYSTEM_ID;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_NAME:
    case XML_TOK_PREFIXED_NAME:
        state->handler = attlist1;
        return XML_ROLE_ATTLIST_ELEMENT_NAME;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_DECL_CLOSE:
        state->handler = internalSubset;
        return XML_ROLE_NONE;
    case XML_TOK_NAME:
    case XML_TOK_PREFIXED_NAME:
        state->handler = attlist2;
        return XML_ROLE_ATTRIBUTE_NAME;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_NAME:
        {
            static const char* const types[] = {
                "CDATA",
                "ID",
                "IDREF",
                "IDREFS",
                "ENTITY",
                "ENTITIES",
                "NMTOKEN",
                "NMTOKENS",
            };
            int i;
            for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
                if (XmlNameMatchesAscii(enc, ptr, types[i])) {
                    state->handler = attlist8;
                    return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
                }
        }
        if (XmlNameMatchesAscii(enc, ptr, "NOTATION")) {
            state->handler = attlist5;
            return XML_ROLE_NONE;
        }
        break;
    case XML_TOK_OPEN_PAREN:
        state->handler = attlist3;
        return XML_ROLE_NONE;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_NMTOKEN:
    case XML_TOK_NAME:
    case XML_TOK_PREFIXED_NAME:
        state->handler = attlist4;
        return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_CLOSE_PAREN:
        state->handler = attlist8;
        return XML_ROLE_NONE;
    case XML_TOK_OR:
        state->handler = attlist3;
        return XML_ROLE_NONE;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_OPEN_PAREN:
        state->handler = attlist6;
        return XML_ROLE_NONE;
    }
    return syntaxError(state);
}


static
int 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_NONE;
    case XML_TOK_NAME:
        state->handler = attlist7;
        return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_CLOSE_PAREN:
        state->handler = attlist8;
        return XML_ROLE_NONE;
    case XML_TOK_OR:
        state->handler = attlist6;
        return XML_ROLE_NONE;
    }
    return syntaxError(state);
}

/* default value */
static
int 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_NONE;
    case XML_TOK_POUND_NAME:
        if (XmlNameMatchesAscii(enc,
                                ptr + MIN_BYTES_PER_CHAR(enc),
                                "IMPLIED")) {
            state->handler = attlist1;
            return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
        }
        if (XmlNameMatchesAscii(enc,
                                ptr + MIN_BYTES_PER_CHAR(enc),
                                "REQUIRED")) {
            state->handler = attlist1;
            return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
        }
        if (XmlNameMatchesAscii(enc,
                                ptr + MIN_BYTES_PER_CHAR(enc),
                                "FIXED")) {
            state->handler = attlist9;
            return XML_ROLE_NONE;
        }
        break;
    case XML_TOK_LITERAL:
        state->handler = attlist1;
        return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_LITERAL:
        state->handler = attlist1;
        return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_NAME:
    case XML_TOK_PREFIXED_NAME:
        state->handler = element1;
        return XML_ROLE_ELEMENT_NAME;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_NAME:
        if (XmlNameMatchesAscii(enc, ptr, "EMPTY")) {
            state->handler = declClose;
            return XML_ROLE_CONTENT_EMPTY;
        }
        if (XmlNameMatchesAscii(enc, ptr, "ANY")) {
            state->handler = declClose;
            return XML_ROLE_CONTENT_ANY;
        }
        break;
    case XML_TOK_OPEN_PAREN:
        state->handler = element2;
        state->level = 1;
        return XML_ROLE_GROUP_OPEN;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_POUND_NAME:
        if (XmlNameMatchesAscii(enc,
                                ptr + MIN_BYTES_PER_CHAR(enc),
                                "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 syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_CLOSE_PAREN:
    case XML_TOK_CLOSE_PAREN_ASTERISK:
        state->handler = declClose;
        return XML_ROLE_GROUP_CLOSE_REP;
    case XML_TOK_OR:
        state->handler = element4;
        return XML_ROLE_NONE;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_NAME:
    case XML_TOK_PREFIXED_NAME:
        state->handler = element5;
        return XML_ROLE_CONTENT_ELEMENT;
    }
    return syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_CLOSE_PAREN_ASTERISK:
        state->handler = declClose;
        return XML_ROLE_GROUP_CLOSE_REP;
    case XML_TOK_OR:
        state->handler = element4;
        return XML_ROLE_NONE;
    }
    return syntaxError(state);
}

static
int 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_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 syntaxError(state);
}

static
int 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_NONE;
    case XML_TOK_CLOSE_PAREN:
        state->level -= 1;
        if (state->level == 0)
            state->handler = declClose;
        return XML_ROLE_GROUP_CLOSE;
    case XML_TOK_CLOSE_PAREN_ASTERISK:
        state->level -= 1;
        if (state->level == 0)
            state->handler = declClose;
        return XML_ROLE_GROUP_CLOSE_REP;
    case XML_TOK_CLOSE_PAREN_QUESTION:
        state->level -= 1;
        if (state->level == 0)
            state->handler = declClose;
        return XML_ROLE_GROUP_CLOSE_OPT;
    case XML_TOK_CLOSE_PAREN_PLUS:
        state->level -= 1;
        if (state->level == 0)
            state->handler = declClose;
        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 syntaxError(state);
}

static
int declClose(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_CLOSE:
        state->handler = internalSubset;
        return XML_ROLE_NONE;
    }
    return syntaxError(state);
}

#if 0

static
int ignore(PROLOG_STATE *state,
           int tok,
           const char *ptr,
           const char *end,
           const ENCODING *enc)
{
    switch (tok) {
    case XML_TOK_DECL_CLOSE:
        state->handler = internalSubset;
        return 0;
    default:
        return XML_ROLE_NONE;
    }
    return syntaxError(state);
}
#endif

static
int error(PROLOG_STATE *state,
          int tok,
          const char *ptr,
          const char *end,
          const ENCODING *enc)
{
    return XML_ROLE_NONE;
}

static
int syntaxError(PROLOG_STATE *state)
{
    state->handler = error;
    return XML_ROLE_ERROR;
}

void XmlPrologStateInit(PROLOG_STATE *state)
{
    state->handler = prolog0;
}