wbxml_parser.c

WAP Binary XML 简单地说

  
    /* Skip ENTITY */
    parser->pos++;
  
    if ( (ret = parse_entcode(parser, &code)) != WBXML_OK ) {
        return ret;
    }
  
    /* Build Entity */
    if ( code > WBXML_PARSER_MAX_ENTITY_CODE )  {
        return WBXML_ERROR_ENTITY_CODE_OVERFLOW;
    }
  
    /**
     * WARNING: If you change the entity variable length (10 chars), change too
     *          'WBXML_PARSER_MAX_ENTITY_CODE' defined in this file !
     */
    sprintf(entity, "&#%u;", code);

    /* Create result buffer */
    if ( (*result = wbxml_buffer_create_from_cstr(entity)) == NULL ) {
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;
    }
  
  return WBXML_OK;
}


/**
 * @brief Parse WBXML opaque
 * @param parser The WBXML Parser
 * @param result Resulting opaque data parsed
 * @return WBXML_OK if parsing is OK, an error code otherwise
 * @note opaque = OPAQUE length *byte
 * @note length = mb_u_int32
 */
static WBXMLError parse_opaque(WBXMLParser *parser, WBXMLBuffer **result)
{
    WB_ULONG   len = 0;
    WBXMLError ret = WBXML_OK;
  
    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing opaque", parser->pos));
  
    if (parser->version < WBXML_VERSION_11)
        WBXML_WARNING((WBXML_PARSER, "No 'opaque' support in WBXML < %s", WBXML_VERSION_TEXT_11));
  
    /* Skip OPAQUE */
    parser->pos++;
  
    if ((ret = parse_mb_uint32(parser, &len)) != WBXML_OK) {
        return ret;
    }

    /* Check that length specified in OPAQUE doesn't overflow wbxml length */
    if (parser->pos + len > wbxml_buffer_len(parser->wbxml)) {
        return WBXML_ERROR_BAD_OPAQUE_LENGTH;
    }

    /**
     * Create result buffer (don't create a static buffer, because this can be
     * modified while trying to decode this content)
     */
    *result = wbxml_buffer_create(wbxml_buffer_get_cstr(parser->wbxml) + parser->pos, len, len);
    if (*result == NULL) {
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;
    }
  
    parser->pos += len;
  
    return ret;
}


/**
 * @brief Parse WBXML literalTag
 * @param parser The WBXML Parser
 * @param mask   Resulting tag mask (WBXML_TOKEN_MASK          |
 *                                   WBXML_TOKEN_WITH_CONTENT  |
 *                                   WBXML_TOKEN_WITH_ATTRS    |
 *                                   (WBXML_TOKEN_WITH_CONTENT || WBXML_TOKEN_WITH_ATTRS))
 * @param result The resulting parsed literal
 * @return WBXML_OK if parsing is OK, an error code otherwise
 * @note    result = ( literalTag index )
 *            literalTag = LITERAL | LITERAL_A | LITERAL_C | LITERAL_AC
 */
static WBXMLError parse_literal(WBXMLParser  *parser,
                                WB_UTINY     *mask,
                                WBXMLBuffer **result)
{
    WBXMLError ret     = WBXML_OK;
    WB_UTINY   token   = 0;
    WB_ULONG   index   = 0;
  
    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing literalTag", parser->pos));
  
    /* Parse literalTag */
    if ( (ret = parse_uint8(parser, &token)) != WBXML_OK ) {
        return ret;
    }
  
    /* Parse index */
    if ( (ret = parse_mb_uint32(parser, &index)) != WBXML_OK ) {
        return ret;
    }
  
    /* Get string */
    if ( (ret = get_strtbl_reference(parser, index, result)) != WBXML_OK ) {
        return ret;
    }

    /* Build Tag Mask */
    switch(token) {
    case WBXML_LITERAL:
        *mask = WBXML_TOKEN_MASK;
        break;

    case WBXML_LITERAL_C:
        *mask = WBXML_TOKEN_WITH_CONTENT;
        break;

    case WBXML_LITERAL_A:
        *mask = WBXML_TOKEN_WITH_ATTRS;
        break;

    case WBXML_LITERAL_AC:
        *mask = ( WBXML_TOKEN_WITH_CONTENT | WBXML_TOKEN_WITH_ATTRS );
        break;

    default:
        return WBXML_ERROR_INTERNAL;
    }
  
    return WBXML_OK;
}


/**
 * @brief Parse WBXML attrStart
 * @param parser The WBXML Parser
 * @param name The Attribute Name parsed
 * @param value The Attribute Value associated, if any
 * @return WBXML_OK if parsing is OK, an error code otherwise
 * @note attrStart = ([switchPage] ATTRSTART) | ( LITERAL index )
 */
static WBXMLError parse_attr_start(WBXMLParser         *parser,
                                   WBXMLAttributeName **name,
                                   const WB_UTINY     **value)
{
    WBXMLBuffer *literal_str = NULL;
    WB_UTINY     literal     = 0;    
    WB_UTINY     tag         = 0;
    WBXMLError   ret         = WBXML_OK;
    WB_ULONG     index       = 0;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing attrStart", parser->pos));
  
  
    /**************************
     * Case: ( LITERAL index ) 
     */
  
    if (is_token(parser, WBXML_LITERAL)) {
        if ((ret = parse_literal(parser, &literal, &literal_str)) != WBXML_OK) {
            return ret;
        }
    
        if ((*name = wbxml_attribute_name_create_literal(wbxml_buffer_get_cstr(literal_str))) == NULL) {
            ret = WBXML_ERROR_NOT_ENOUGH_MEMORY;
        }
    
        /**
         * @todo Return Warning if 'literal' is different from 'WBML_TOKEN_MASK' (because it MUST be a 'LITERAL' token, not
         *       LITERAL_A, nor LITERAL_C, nor LITERAL_AC
         */

        wbxml_buffer_destroy(literal_str);
        return WBXML_OK;
    }
  
  
    /***********************************
     * Case: ( [switchPage] ATTRSTART )
     */
  
    /* Parse switchPage */
    if (is_token(parser, WBXML_SWITCH_PAGE)) {
        if ((ret = parse_switch_page(parser, WBXML_ATTR_TOKEN)) != WBXML_OK) {
            return ret;
        }
    }
  
    /* Parse UINT8 */
    if ((ret = parse_uint8(parser, &tag)) != WBXML_OK) {
        return ret;
    }
  
    WBXML_DEBUG((WBXML_PARSER, "\tToken: 0x%X", tag));
  
    /* Search tag in Tags Table */
    if (parser->langTable == NULL) {
        return WBXML_ERROR_LANG_TABLE_UNDEFINED;
    }
  
    if (parser->langTable->attrTable == NULL) { 
        return WBXML_ERROR_ATTR_TABLE_UNDEFINED;
    }

    while ((parser->langTable->attrTable[index].xmlName != NULL) &&
           ((parser->langTable->attrTable[index].wbxmlToken != tag) ||
            (parser->langTable->attrTable[index].wbxmlCodePage != parser->attrCodePage)))
    {
        index++;
    }
  
    if (parser->langTable->attrTable[index].xmlName == NULL) {
#if WBXML_PARSER_BEST_EFFORT
        /* Create "unknown" Attribute Name */
        if ((*name = wbxml_attribute_name_create_literal(WBXML_PARSER_UNKNOWN_STRING)) == NULL) {
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;
        }
    
        return WBXML_OK;
#else
        return WBXML_ERROR_UNKNOWN_ATTR;
#endif /* WBXML_PARSER_BEST_EFFORT */
    }
  
    /* Create Token Attribute Name */
    if ((*name = wbxml_attribute_name_create(WBXML_VALUE_TOKEN)) == NULL) {
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;
    }
  
    (*name)->u.token = &(parser->langTable->attrTable[index]);
  
    /* Get Attribute start value (if any) */
    if (parser->langTable->attrTable[index].xmlValue != NULL) {
        *value = (const WB_UTINY *) parser->langTable->attrTable[index].xmlValue;
    }
  
    return WBXML_OK;
}


/**
 * @brief Parse WBXML attrValue
 * @param parser [in]  The WBXML Parser
 * @param result [out] The resulting Value parsed
 * @return WBXML_OK if parsing is OK, an error code otherwise
 * @note attrValue = ([switchPage] ATTRVALUE) | string | extension | entity | opaque
 */
static WBXMLError parse_attr_value(WBXMLParser  *parser,
                                   WBXMLBuffer **result)
{
    WB_ULONG   index = 0;
    WB_UTINY   tag   = 0;
    WBXMLError ret   = WBXML_OK;
  
    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing attrValue", parser->pos));
  
    /* Parse extension */
    if (is_extension(parser)) {
        return parse_extension(parser, WBXML_ATTR_TOKEN, result);
    }
  
    /* Parse entity */
    if (is_token(parser, WBXML_ENTITY)) {
        return parse_entity(parser, result);
    }
  
    /* Parse string */
    if (is_string(parser)) {
        return parse_string(parser, result);
    }

    /* Parse opaque */
    if (is_token(parser, WBXML_OPAQUE)) {
        if (parser->version < WBXML_VERSION_12) {
            WBXML_ERROR((WBXML_PARSER, "An Attribute value can't be 'opaque' in WBXML version < %s", WBXML_VERSION_TEXT_12));
        }
        
        return parse_opaque(parser, result);
    }
  
  
    /*****************************
     *    ([switchPage] ATTRVALUE)
     */
  
    /* Parse switchPage */
    if (is_token(parser, WBXML_SWITCH_PAGE)) {
        ret = parse_switch_page(parser, WBXML_ATTR_TOKEN);
        if (ret != WBXML_OK) {
            return ret;
        }
    }
  
    /* Parse UINT8 */
    ret = parse_uint8(parser, &tag);
    if (ret != WBXML_OK) {
        return ret;
    }
  
    /* Search tag in Tags Table */
    if (parser->langTable == NULL) {
        return WBXML_ERROR_LANG_TABLE_UNDEFINED;
    }
  
    if (parser->langTable->attrValueTable == NULL) {
        return WBXML_ERROR_ATTR_VALUE_TABLE_UNDEFINED;
    }
  
    while ((parser->langTable->attrValueTable[index].xmlName != NULL) &&
           ((parser->langTable->attrValueTable[index].wbxmlToken != tag) ||
            (parser->langTable->attrValueTable[index].wbxmlCodePage != parser->attrCodePage)))
    {
        index++;
    }
  
    if (parser->langTable->attrValueTable[index].xmlName == NULL) {
        return WBXML_ERROR_UNKNOWN_ATTR_VALUE;
    }

    *result = wbxml_buffer_sta_create_from_cstr(parser->langTable->attrValueTable[index].xmlName);

    return WBXML_OK;
}


/**
 * @brief Parse WBXML termstr
 * @param parser [in]  The WBXML Parser
 * @param result [out] The resulting parsed string
 * @return WBXML_OK if parsing is OK, an error code otherwise
 * @note termstr = charset-dependent string with termination
 */
static WBXMLError parse_termstr(WBXMLParser  *parser,
                                WBXMLBuffer **result)
{
    WB_ULONG   max_len  = 0;
    WBXMLError ret      = WBXML_OK;
  
    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing termstr", parser->pos));

    /* Get max possible string length */
    max_len = wbxml_buffer_len(parser->wbxml) - parser->pos;
  
    /* Convert to UTF-8 Buffer */
    if ((ret = wbxml_charset_conv_term((const WB_TINY *) (wbxml_buffer_get_cstr(parser->wbxml) + parser->pos),
                                       &max_len,
                                       parser->charset,
                                       result,
                                       WBXML_CHARSET_UTF_8)) != WBXML_OK) {
        return ret;
    }

    parser->pos += max_len;
  
    WBXML_DEBUG((WBXML_PARSER, "(%d) termstr: %s", parser->pos, wbxml_buffer_get_cstr(*result)));
  
    return WBXML_OK;
}


/**
 * @brief Parse WBXML inline
 * @param parser [in]  The WBXML Parser
 * @param result [out] The resulting parsed string
 * @return WBXML_OK if parsing is OK, an error code otherwise
 * @note inline = STR_I termstr
 */
static WBXMLError parse_inline(WBXMLParser  *parser,
                               WBXMLBuffer **result)
{
    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing inline", parser->pos));
  
    /* Skip STR_I */
    parser->pos++;
  
    return parse_termstr(parser, result);
}


/**
 * @brief Parse WBXML tableref
 * @param parser The WBXML Parser
 * @param result The resulting parsed string
 * @return WBXML_OK if parsing is OK, an error code otherwise
 * @note tableref = STR_T index
 * @note index = mb_u_int32
 */
static WBXMLError parse_tableref(WBXMLParser  *parser,
                                 WBXMLBuffer **result)
{
    WB_ULONG index;
    WBXMLError ret = WBXML_OK;
  
    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing tableref", parser->pos));
  
    /* Skip STR_T */
    parser->pos++;
  
    /* Parse index */
    if ((ret = parse_mb_uint32(parser, &index)) != WBXML_OK) {
        return ret;
    }
  
    return get_strtbl_reference(parser, index, result);
}


/**
 * @brief Parse WBXML entcode
 * @param parser [in] The WBXML Parser
 * @param result [out] The entcode parsed
 * @return WBXML_OK if parsin