---

wbxml_parser.c

Go to the documentation of this file.

/*
 * WBXML Lib, the WBXML Library.
 * Copyright (C) 2002-2003  Aymerick Jéhanne
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License (version 2.1) as published by the Free Software Foundation.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * LGPL v2.1: http://www.gnu.org/licenses/lgpl.txt
 *
 * Author Contact: libwbxml@jehanne.org
 * WBXML Lib home: http://libwbxml.jehanne.org
 */
 
#include <stdlib.h>
#include <string.h>

#include "wbxml.h"


/* Memory management related defines */
#define WBXML_PARSER_MALLOC_BLOCK 5000
#define WBXML_PARSER_STRING_TABLE_MALLOC_BLOCK 200
#define WBXML_PARSER_ATTR_VALUE_MALLOC_BLOCK 100

#define WBXML_PARSER_BEST_EFFORT 1

#define WBXML_PARSER_UNKNOWN_STRING ((WB_UTINY *)"unknown")

#define WBXML_PARSER_MAX_ENTITY_CODE 999999


typedef enum WBXMLTokenType_e {
    WBXML_TAG_TOKEN,        
    WBXML_ATTR_TOKEN        
} WBXMLTokenType;


struct WBXMLParser_s {
    void *user_data;                            
    WBXMLContentHandler *content_hdl;   
    WBXMLBuffer *wbxml;                 
    WBXMLBuffer *strstbl;               
    const WBXMLLangEntry *langTable;    
    const WBXMLLangEntry *mainTable;    
    const WBXMLTagEntry *current_tag;   
    WBXMLLanguage lang_forced;          
    WB_ULONG public_id;                 
    WB_LONG  public_id_index;           
    WB_LONG  charset;                   
    WB_ULONG pos;                       
    WBXMLVersion version;               
    WB_UTINY tagCodePage;               
    WB_UTINY attrCodePage;              
};



/***************************************************
 *    Private Functions prototypes
 */

/* WBXML Parser functions */
static void wbxml_parser_reinit(WBXMLParser *parser);

/* Check functions */
static WB_BOOL is_token(WBXMLParser *parser, WB_UTINY token);
static WB_BOOL is_literal(WBXMLParser *parser);
static WB_BOOL is_attr_value(WBXMLParser *parser);
static WB_BOOL is_string(WBXMLParser *parser);
static WB_BOOL is_extension(WBXMLParser *parser);
static WB_BOOL check_public_id(WBXMLParser *parser);

/* Parse functions */
static WBXMLError parse_version(WBXMLParser *parser);
static WBXMLError parse_publicid(WBXMLParser *parser);
static WBXMLError parse_charset(WBXMLParser *parser);
static WBXMLError parse_strtbl(WBXMLParser *parser);
static WBXMLError parse_body(WBXMLParser *parser);

static WBXMLError parse_pi(WBXMLParser *parser);
static WBXMLError parse_element(WBXMLParser *parser);
static void free_attrs_table(WBXMLAttribute **attrs);

static WBXMLError parse_switch_page(WBXMLParser *parser, WBXMLTokenType code_space);
static WBXMLError parse_stag(WBXMLParser *parser, WB_UTINY *tag, WBXMLTag **element);
static WBXMLError parse_tag(WBXMLParser *parser, WB_UTINY *tag, WBXMLTag **element);
static WBXMLError parse_attribute(WBXMLParser *parser, WBXMLAttribute **attr);
static WBXMLError parse_content(WBXMLParser *parser, WB_UTINY **content, WB_LONG *len, WB_BOOL *static_content);

static WBXMLError parse_string(WBXMLParser *parser, WB_UTINY **str, WB_LONG *len);
static WBXMLError parse_extension(WBXMLParser *parser, WBXMLTokenType code_space, WB_UTINY **ext, WB_LONG *len);
static WBXMLError parse_entity(WBXMLParser *parser, WB_UTINY **entity, WB_LONG *len);
static WBXMLError parse_opaque(WBXMLParser *parser, WB_UTINY **data, WB_LONG *len);

static WBXMLError parse_literal(WBXMLParser *parser, WB_UTINY *tag, WB_UTINY **result);

static WBXMLError parse_attr_start(WBXMLParser *parser, WBXMLAttributeName **name, WB_UTINY **value);
static WBXMLError parse_attr_value(WBXMLParser *parser, WB_UTINY **value, WB_LONG *len, WB_BOOL *static_value);

static WBXMLError parse_termstr(WBXMLParser *parser, WB_UTINY **str, WB_LONG *len);
static WBXMLError parse_inline(WBXMLParser *parser, WB_UTINY **str, WB_LONG *len);
static WBXMLError parse_tableref(WBXMLParser *parser, WB_UTINY **str, WB_LONG *len);
static WBXMLError parse_entcode(WBXMLParser *parser, WB_ULONG *result);

static WBXMLError get_strtbl_reference(WBXMLParser *parser, WB_ULONG index, WB_UTINY **str, WB_LONG *len);

/* Basic Types Parse functions */
static WBXMLError parse_uint8(WBXMLParser *parser, WB_UTINY *result);
static WBXMLError parse_mb_uint32(WBXMLParser *parser, WB_ULONG *result);

/* Language Specific Decoding Functions */
static WBXMLError decode_datetime(WBXMLBuffer *buff);

static WBXMLError decode_opaque_content(WBXMLParser *parser, WB_UTINY **data, WB_LONG *len, WB_BOOL *static_content);

#if defined( WBXML_SUPPORT_WV )
static WBXMLError decode_wv_content(WBXMLParser *parser, WB_UTINY **data, WB_LONG *len, WB_BOOL *static_content);
static WBXMLError decode_wv_integer(WB_UTINY **data, WB_LONG *len);
static WBXMLError decode_wv_datetime(WB_UTINY **data, WB_LONG *len);
#endif /* WBXML_SUPPORT_WV */

#if defined( WBXML_SUPPORT_DRMREL )
static WBXMLError decode_drmrel_keyvalue(WB_UTINY **data, WB_LONG *len);
#endif /* WBXML_SUPPORT_DRMREL */

/* Macro for error handling */
#define CHECK_ERROR if (ret != WBXML_OK) return ret;


/***************************************************
 *    Public Functions
 */

WBXML_DECLARE(WBXMLParser *) wbxml_parser_create(void)
{
    WBXMLParser *parser = NULL;

    parser = (WBXMLParser *) wbxml_malloc(sizeof(WBXMLParser));
    if (parser == NULL) {
        return NULL;
    }
    
    parser->wbxml = NULL;
    parser->user_data = NULL;
    parser->content_hdl = NULL;
    parser->strstbl = NULL;
    parser->langTable = NULL;

    /* Default Main WBXML Languages Table */
    parser->mainTable = wbxml_tables_get_main();

    parser->current_tag = NULL;

    parser->lang_forced = WBXML_LANG_UNKNOWN;
    parser->public_id = WBXML_PUBLIC_ID_UNKNOWN;    
    parser->public_id_index = -1;
    parser->charset = -1;
    parser->version = WBXML_VERSION_UNKNOWN;    
    
    parser->pos = 0;
    parser->tagCodePage = 0;
    parser->attrCodePage = 0;

    return parser;
}


WBXML_DECLARE(void) wbxml_parser_destroy(WBXMLParser *parser)
{
    if (parser == NULL)
        return;
    
    wbxml_buffer_destroy(parser->wbxml);
    wbxml_buffer_destroy(parser->strstbl);

    wbxml_free(parser);
}


WBXML_DECLARE(WBXMLError) wbxml_parser_parse(WBXMLParser *parser, WB_UTINY *wbxml, WB_ULONG wbxml_len)
{
    WBXMLError ret = WBXML_OK;

    if (parser == NULL)
        return WBXML_ERROR_NULL_PARSER;

    if ((wbxml == NULL) || (wbxml_len <= 0))
        return WBXML_ERROR_EMPTY_WBXML;

    /* Reinitialize WBXML Parser */
    wbxml_parser_reinit(parser);

    parser->wbxml = wbxml_buffer_create(wbxml, wbxml_len, WBXML_PARSER_MALLOC_BLOCK);
    if (parser->wbxml == NULL)
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;

    /* WBXML Version */
    ret = parse_version(parser);
    CHECK_ERROR

    if (parser->version > WBXML_VERSION_13)
        WBXML_WARNING((WBXML_PARSER, "This library only supports WBXML " WBXML_VERSION_TEXT_13));

    /* WBXML Public ID */
    ret = parse_publicid(parser);
    CHECK_ERROR

    /* Ignore Document Public ID if user has forced use of another Public ID */
    if (parser->lang_forced != WBXML_LANG_UNKNOWN)
        parser->public_id = wbxml_tables_get_wbxml_publicid(wbxml_tables_get_main(), parser->lang_forced);

    /* No charset in WBXML 1.0 */
    if (parser->version != WBXML_VERSION_10) {
        ret = parse_charset(parser);
        CHECK_ERROR

    }

    /* WBXML String Table */
    ret = parse_strtbl(parser);
    CHECK_ERROR

    /* Now that we have parsed String Table, we can check Public ID */
    if (!check_public_id(parser)) {
        WBXML_ERROR((WBXML_PARSER, "PublicID not found"));
        return WBXML_ERROR_UNKNOWN_PUBLIC_ID;
    }

    /* Call to WBXMLStartDocumentHandler */
    if ((parser->content_hdl != NULL) && (parser->content_hdl->start_document_clb != NULL))
        parser->content_hdl->start_document_clb(parser->user_data, parser->charset, parser->langTable);

    /* WBXML Body */
    ret = parse_body(parser);
    CHECK_ERROR

    /* Call to WBXMLEndDocumentHandler */
    if ((parser->content_hdl != NULL) && (parser->content_hdl->end_document_clb != NULL))
        parser->content_hdl->end_document_clb(parser->user_data);

    return ret;
}


WBXML_DECLARE(void) wbxml_parser_set_user_data(WBXMLParser *parser, void *user_data)
{
    if (parser != NULL)
        parser->user_data = user_data;
}


WBXML_DECLARE(void) wbxml_parser_set_content_handler(WBXMLParser *parser, WBXMLContentHandler *content_handler)
{
    if (parser != NULL)
        parser->content_hdl = content_handler;
}


WBXML_DECLARE(void) wbxml_parser_set_main_table(WBXMLParser *parser, const WBXMLLangEntry *main_table)
{
    if (parser != NULL)
        parser->mainTable = main_table;
}


WBXML_DECLARE(WB_BOOL) wbxml_parser_set_language(WBXMLParser *parser, WBXMLLanguage lang)
{
    if (parser != NULL) {
        parser->lang_forced = lang;
        return TRUE;
    }

    return FALSE;
}


WBXML_DECLARE(WB_ULONG) wbxml_parser_get_wbxml_public_id(WBXMLParser *parser)
{
    if ((parser != NULL) && (parser->langTable != NULL) && (parser->langTable->publicID != NULL))
        return parser->langTable->publicID->wbxmlPublicID;
    else
        return WBXML_PUBLIC_ID_UNKNOWN;
}


WBXML_DECLARE(const WB_UTINY *) wbxml_parser_get_xml_public_id(WBXMLParser *parser)
{
    if ((parser != NULL) && (parser->langTable != NULL) && (parser->langTable->publicID != NULL))
        return (const WB_UTINY *) parser->langTable->publicID->xmlPublicID;
    else
        return NULL;
}


WBXML_DECLARE(WBXMLVersion) wbxml_parser_get_wbxml_version(WBXMLParser *parser)
{
    if (parser != NULL)
        return parser->version;
    else
        return WBXML_VERSION_UNKNOWN;
}


WBXML_DECLARE(WB_LONG) wbxml_parser_get_current_byte_index(WBXMLParser *parser)
{
    if (parser != NULL)
        return parser->pos - 1;
    else
        return 0;
}


/***************************************************
 *    Private Functions
 */

/**************************
 * WBXML Parser functions
 */

static void wbxml_parser_reinit(WBXMLParser *parser)
{
    if (parser == NULL)
        return;

    wbxml_buffer_destroy(parser->wbxml);
    parser->wbxml = NULL;

    wbxml_buffer_destroy(parser->strstbl);
    parser->strstbl = NULL;

    parser->langTable = NULL;

    parser->current_tag = NULL;

    parser->public_id = WBXML_PUBLIC_ID_UNKNOWN;    
    parser->public_id_index = -1;
    parser->charset = -1;
    parser->version = WBXML_VERSION_UNKNOWN;    

    parser->pos = 0;
    parser->tagCodePage = 0;
    parser->attrCodePage = 0;    
}


/******************
 * Check functions
 */

static WB_BOOL is_token(WBXMLParser *parser, WB_UTINY token)
{
    WB_UTINY result;

    if (!wbxml_buffer_get_char(parser->wbxml, parser->pos, &result))
        return FALSE;

    return (result == token);
}


static WB_BOOL is_literal(WBXMLParser *parser)
{
    WB_UTINY result;

    if (!wbxml_buffer_get_char(parser->wbxml, parser->pos, &result))
        return FALSE;

    return ((result == WBXML_LITERAL) || (result == WBXML_LITERAL_A) || (result == WBXML_LITERAL_C) || (result == WBXML_LITERAL_AC));
}


static WB_BOOL is_attr_value(WBXMLParser *parser)
{
    WB_UTINY cur_byte, next_byte;

    /* Get current byte */
    if (!wbxml_buffer_get_char(parser->wbxml, parser->pos, &cur_byte))
        return FALSE;

    /* If current byte is a switch page, check that following token is an Attribute Value token */
    if (is_token(parser, WBXML_SWITCH_PAGE)) {
        if (!wbxml_buffer_get_char(parser->wbxml, parser->pos + 2, &next_byte))
            return FALSE;

        /* Attribute Value is greater than or equal to 128 */
        if ((next_byte & 0x80) == 0x80)
            return TRUE;
    }

    /* Else, check current byte is an Attribute Value, a string, an extension, an entity or an opaque */
    if (((cur_byte & 0x80) == 0x80) ||
        (is_string(parser)) ||
        (is_extension(parser)) ||
        (is_token(parser, WBXML_ENTITY)) ||
        (is_token(parser, WBXML_OPAQUE)))
        return TRUE;

    return FALSE;
}


static WB_BOOL is_string(WBXMLParser *parser)
{
    return (is_token(parser, WBXML_STR_I) || is_token(parser, WBXML_STR_T));
}


static WB_BOOL is_extension(WBXMLParser *parser)
{
    WB_UTINY cur_byte;

    /* If current byte is a switch page, check the following token */
    if (is_token(parser, WBXML_SWITCH_PAGE)) {
        if (!wbxml_buffer_get_char(parser->wbxml, parser->pos + 2, &cur_byte))
            return FALSE;
    }
    else {
        if (!wbxml_buffer_get_char(parser->wbxml, parser->pos, &cur_byte))
            return FALSE;
    }

    return ((cur_byte == WBXML_EXT_I_0) || (cur_byte == WBXML_EXT_I_1) || (cur_byte == WBXML_EXT_I_2) ||
            (cur_byte == WBXML_EXT_T_0) || (cur_byte == WBXML_EXT_T_1) || (cur_byte == WBXML_EXT_T_2) ||
            (cur_byte == WBXML_EXT_0)   || (cur_byte == WBXML_EXT_1)   || (cur_byte == WBXML_EXT_2));
}


static WB_BOOL check_public_id(WBXMLParser *parser)
{
    WB_LONG index = 0, len = 0;
    WB_UTINY *public_id = NULL;

    WBXML_DEBUG((WBXML_PARSER, "\t  Checking PublicID"));

    /* First check if we can figure out the Public ID */
    if ((parser->lang_forced == WBXML_LANG_UNKNOWN) && 
        (parser->public_id == WBXML_PUBLIC_ID_UNKNOWN) && 
        (parser->public_id_index == -1))
    {
        return FALSE;
    }


    /********************************************************
     * Case 1: Language is forced by user
     */

    if (parser->lang_forced != WBXML_LANG_UNKNOWN) {
        /* Search Language Entry */
        while (parser->mainTable[index].langID != -1) {
            if (parser->mainTable[index].langID == parser->lang_forced) {
                parser->langTable = &(parser->mainTable[index]);

                WBXML_DEBUG((WBXML_PARSER, "\t  Language Forced - PublicID : '%s'", parser->mainTable[index].publicID->xmlPublicID));

                return TRUE;
            }

            index++;
        }
    }


    /********************************************************
     * Case 2: Public ID is a normal token 
     *         (found in WBXML Document, or forced by user)
     */

    if (parser->public_id != WBXML_PUBLIC_ID_UNKNOWN) {
        WBXML_DEBUG((WBXML_PARSER, "\t  PublicID token: 0x%X", parser->public_id));

        /* Search Public ID Table */
        while (parser->mainTable[index].publicID != NULL) {
            if (parser->mainTable[index].publicID->wbxmlPublicID == parser->public_id) {
                parser->langTable = &(parser->mainTable[index]);

                WBXML_DEBUG((WBXML_PARSER, "\t  PublicID : '%s'", parser->mainTable[index].publicID->xmlPublicID));

                return TRUE;
            }

            index++;
        }
    }


    /********************************************************
     * Case 3: Public ID referenced in String Table 
     */
    if (parser->public_id_index != -1) {
        WBXML_DEBUG((WBXML_PARSER, "\t  PublicID is in String Table (index: 0x%X)", parser->public_id_index));

        if (get_strtbl_reference(parser, (WB_ULONG) parser->public_id_index, &public_id, &len) != WBXML_OK) {
            WBXML_ERROR((WBXML_PARSER, "Bad publicID reference in string table"));
            return FALSE;
        }

        WBXML_DEBUG((WBXML_PARSER, "\t  PublicID : '%s'", public_id));

        /* Search Public ID Table */
        while (parser->mainTable[index].publicID != NULL)
        {
            if ((parser->mainTable[index].publicID->xmlPublicID != NULL) && 
                (WBXML_STRCASECMP(parser->mainTable[index].publicID->xmlPublicID, public_id) == 0))
            {
                parser->langTable = &(parser->mainTable[index]);
                /* parser->public_id = parser->mainTable[index].publicID->wbxmlPublicID; */
                return TRUE;
            }

            index++;
        }
    }

    /* Public ID not found in Tables */
    return FALSE;
}



/***************************
 *    WBXML Parse functions
 */

static WBXMLError parse_version(WBXMLParser *parser)
{   
    WBXMLError ret = WBXML_OK;
    
    if ((ret = parse_uint8(parser, (WB_UTINY*) &parser->version)) != WBXML_OK)
        return ret;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsed version: '0x%X'", parser->pos - 1, (WB_TINY) parser->version));

    return WBXML_OK;
}


static WBXMLError parse_publicid(WBXMLParser *parser)
{
    WB_UTINY public_id;

    if (!wbxml_buffer_get_char(parser->wbxml, parser->pos, &public_id))
        return WBXML_ERROR_END_OF_BUFFER;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsed publicid: '0x%X'", parser->pos, public_id));

    if (public_id == 0x00) {
        parser->pos++;

        /* Get index (we will retreive the Public ID latter) */
        return parse_mb_uint32(parser, (WB_ULONG *)&parser->public_id_index);
    }
    else {
        /* Get Public ID */
        return parse_mb_uint32(parser, &parser->public_id);        
    }
}


static WBXMLError parse_charset(WBXMLParser *parser)
{   
    WB_ULONG startpos = parser->pos;
    WBXMLError ret = parse_mb_uint32(parser, (WB_ULONG *)&parser->charset);

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsed charset: '0x%X'", startpos, parser->charset));

    return ret;
}


static WBXMLError parse_strtbl(WBXMLParser *parser)
{
    WB_UTINY *data = NULL;
    WB_ULONG strtbl_len = 0;
    WBXMLError ret = WBXML_OK;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing strtbl", parser->pos));

    /* Get String Table Length */
    ret = parse_mb_uint32(parser, &strtbl_len);
    if (ret != WBXML_OK)
        return WBXML_ERROR_END_OF_BUFFER;

    if (strtbl_len > 0) {
        /* Check this string table length */
        if (parser->pos + strtbl_len > wbxml_buffer_len(parser->wbxml))
            return WBXML_ERROR_STRTBL_LENGTH;

        /* Get String Table */
        data = wbxml_buffer_get_cstr(parser->wbxml);
        parser->strstbl = wbxml_buffer_create(data + parser->pos, strtbl_len, WBXML_PARSER_STRING_TABLE_MALLOC_BLOCK);
        if (parser->strstbl == NULL)
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;

        parser->pos = parser->pos + strtbl_len;
    }

    return WBXML_OK;
}


static WBXMLError parse_body(WBXMLParser *parser)
{
    WBXMLError ret = WBXML_OK;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing body", parser->pos));

    while (is_token(parser, WBXML_PI)) {
        if ((ret = parse_pi(parser)) != WBXML_OK)
            return ret;
    }

    if ((ret = parse_element(parser)) != WBXML_OK)
        return ret;

    while (is_token(parser, WBXML_PI)) {
        if ((ret = parse_pi(parser)) != WBXML_OK)
            return ret;
    }

    return WBXML_OK;
}


static WBXMLError parse_pi(WBXMLParser *parser)
{
    WBXMLAttributeName *name = NULL;
    WB_UTINY *value = NULL;
    WBXMLBuffer *attr_value = NULL;
    WB_LONG len = 0;
    WBXMLError ret = WBXML_OK;
    WB_BOOL static_value;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing PI", parser->pos));

    /* Skip PI */
    parser->pos++;    

    /* Parse attrStart */
    ret = parse_attr_start(parser, &name, &value);
    if (ret != WBXML_OK)
        return ret;

    if (value != NULL)
        attr_value = wbxml_buffer_create(value, WBXML_STRLEN(value), WBXML_PARSER_ATTR_VALUE_MALLOC_BLOCK);
    else
        attr_value = wbxml_buffer_create(NULL, 0, WBXML_PARSER_ATTR_VALUE_MALLOC_BLOCK);

    if (attr_value == NULL) {
        wbxml_attribute_name_destroy(name);
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;
    }

    while (!is_token(parser, WBXML_END)) 
    {
        static_value = TRUE;

        /* Parse attrValue */
        ret = parse_attr_value(parser, &value, &len, &static_value);
        if (ret != WBXML_OK) {
            wbxml_attribute_name_destroy(name);
            wbxml_buffer_destroy(attr_value);
            return ret;
        }

        if (!wbxml_buffer_append_data(attr_value, value, len)) {
            wbxml_attribute_name_destroy(name);
            wbxml_buffer_destroy(attr_value);
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;
        }

        if (!static_value) {
            wbxml_free(value);
            value = NULL;
        }
    }

    /* Skip END */
    parser->pos++;

    /* Append NULL char to attr value */
    if (wbxml_buffer_len(attr_value) > 0)
        wbxml_buffer_append_char(attr_value, '\0');

    /* Call to WBXMLProcessingInstructionHandler */
    if ((parser->content_hdl != NULL) && (parser->content_hdl->pi_clb != NULL))
        parser->content_hdl->pi_clb(parser->user_data, wbxml_attribute_name_get_xml_name(name), wbxml_buffer_get_cstr(attr_value));
    
    wbxml_attribute_name_destroy(name);
    wbxml_buffer_destroy(attr_value);

    return WBXML_OK;
}


static WBXMLError parse_element(WBXMLParser *parser)
{
    WBXMLTag *element = NULL;
    WBXMLAttribute *attr = NULL;
    WBXMLAttribute **attrs = NULL;
    WB_UTINY *content = NULL;

    WB_ULONG attrs_nb = 0;
    WB_LONG len;
    WBXMLError ret = WBXML_OK;
    WB_UTINY tag;
    WB_BOOL static_content, is_empty;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing element", parser->pos));

    if (is_token(parser, WBXML_SWITCH_PAGE)) {
        ret = parse_switch_page(parser, WBXML_TAG_TOKEN);
        if (ret != WBXML_OK)
            return ret;
    }

    /* Parse Tag */
    ret = parse_stag(parser, &tag, &element);
    if (ret != WBXML_OK)
        return ret;

    /* Set Current Tag */
    if (element->type == WBXML_VALUE_TOKEN)
        parser->current_tag = element->u.token;

    /* Parse Attributes */
    if (tag & WBXML_TOKEN_WITH_ATTRS) {
        /* There must be at least one attribute */
        do {
            /* Parse attribute */
            ret = parse_attribute(parser, &attr);
            if (ret != WBXML_OK) {
                wbxml_tag_destroy(element);
                free_attrs_table(attrs);
                return ret;
            }

            /* Append this attribute in WBXMLAttribute **attrs table */
            attrs_nb++;

            attrs = wbxml_realloc(attrs, (attrs_nb + 1) * sizeof(*attrs));
            if (attrs == NULL) {
                /* Clean-up */
                wbxml_tag_destroy(element);
                wbxml_attribute_destroy(attr);
                free_attrs_table(attrs);
                return WBXML_ERROR_NOT_ENOUGH_MEMORY;
            }

            attrs[(attrs_nb - 1)] = attr;
            attrs[attrs_nb] = NULL;
        } while (!is_token(parser, WBXML_END));

        /* Skip END */
        parser->pos++;
    }

    /* Is it an empty element ? */
    is_empty = !(tag & WBXML_TOKEN_WITH_CONTENT);

    /* Call WBXMLStartElementHandler */
    if ((parser->content_hdl != NULL) && (parser->content_hdl->start_element_clb != NULL))
        parser->content_hdl->start_element_clb(parser->user_data, element, attrs, is_empty);

    /* Free Attributes */
    free_attrs_table(attrs);

    /* Parse Content */
    if (!is_empty) {
        /* There can be NO content */
        while (!is_token(parser, WBXML_END)) 
        {
            static_content = TRUE;

            ret = parse_content(parser, &content, &len, &static_content);
            if (ret != WBXML_OK) {
                wbxml_tag_destroy(element);
                return ret;
            }

            /* Call WBXMLCharactersHandler if content is not NULL */
            if ((content != NULL) && (parser->content_hdl != NULL) && (parser->content_hdl->characters_clb != NULL))
                parser->content_hdl->characters_clb(parser->user_data, content, 0, len);

            /* Free content if it is not static content */
            if (!static_content)
                wbxml_free(content);

            content = NULL;
        }

        /* Skip END */
        parser->pos++;
    }

    /* Call WBXMLEndElementHandler */
    if ((parser->content_hdl != NULL) && (parser->content_hdl->end_element_clb != NULL))
        parser->content_hdl->end_element_clb(parser->user_data, element, is_empty);

    /* Free Tag */
    wbxml_tag_destroy(element);

    /* Reset Current Tag */
    parser->current_tag = NULL;

    return WBXML_OK;
}


static void free_attrs_table(WBXMLAttribute **attrs)
{
    WB_LONG i = 0;

    if (attrs != NULL) {
        while (attrs[i] != NULL) {
            /* Free attribute */
            wbxml_attribute_destroy(attrs[i++]);
        }
        wbxml_free(attrs);
    }
}


static WBXMLError parse_switch_page(WBXMLParser *parser, WBXMLTokenType code_space)
{
    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing switchPage", parser->pos));

    if ((WB_UTINY) parser->version < (WB_UTINY) WBXML_VERSION_12)
        WBXML_WARNING((WBXML_PARSER, "No Switch Page mecanism possible in WBXML < %s", WBXML_VERSION_TEXT_12));

    /* Skip SWITCH_PAGE token */
    parser->pos++;

    /* Change Code Page in correct Code Space */
    if (code_space == WBXML_TAG_TOKEN)
        return parse_uint8(parser, &parser->tagCodePage);
    else
        if (code_space == WBXML_ATTR_TOKEN)
            return parse_uint8(parser, &parser->attrCodePage);
        else
            return WBXML_ERROR_INTERNAL;
}


static WBXMLError parse_stag(WBXMLParser *parser, WB_UTINY *tag, WBXMLTag **element)
{
    WB_UTINY *name = NULL;
    WBXMLError ret = WBXML_OK;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing stag", parser->pos));

    if (is_literal(parser)) {
        if ((ret = parse_literal(parser, tag, &name)) != WBXML_OK)
            return ret;

        /* Create Element Tag */
        if ((*element = wbxml_tag_create_literal(name)) == NULL)
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;

        return WBXML_OK;
    }

    return parse_tag(parser, tag, element);
}


static WBXMLError parse_tag(WBXMLParser *parser, WB_UTINY *tag, WBXMLTag **element)
{
    WB_ULONG index = 0;
    WB_UTINY token;
    WBXMLError ret = WBXML_OK;

    /* Parse UINT8 */
    ret = parse_uint8(parser, tag);
    if (ret != WBXML_OK)
        return ret;

    /* Remove ATTR and CONTENT bits */
    token = *tag & WBXML_TOKEN_MASK;

    /* Search tag in Tags Table */
    if (parser->langTable == NULL)
        return WBXML_ERROR_LANG_TABLE_UNDEFINED;

    if (parser->langTable->tagTable == NULL)
        return WBXML_ERROR_TAG_TABLE_UNDEFINED;

    
    while ((parser->langTable->tagTable[index].xmlName != NULL) &&
           ((parser->langTable->tagTable[index].wbxmlToken != token) ||
            (parser->langTable->tagTable[index].wbxmlCodePage != parser->tagCodePage))) {
        index++;
    }


        if (parser->langTable->tagTable[index].xmlName == NULL) {
#if WBXML_PARSER_BEST_EFFORT
        /* Create "unknown" Tag Element */
                if ((*element = wbxml_tag_create_literal(WBXML_PARSER_UNKNOWN_STRING)) == NULL)
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;

                return WBXML_OK;
#else
                return WBXML_ERROR_UNKNOWN_TAG;
#endif /* WBXML_PARSER_BEST_EFFORT */
        }

        if ((*element = wbxml_tag_create(WBXML_VALUE_TOKEN)) == NULL)
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;

    (*element)->u.token = &(parser->langTable->tagTable[index]);

    WBXML_DEBUG((WBXML_PARSER, "(%d) Token: 0x%X", parser->pos - 1, token));
    
    return WBXML_OK;
}


static WBXMLError parse_attribute(WBXMLParser *parser, WBXMLAttribute **attr)
{
    WBXMLAttributeName *attr_name = NULL;
    WBXMLBuffer *attr_value = NULL;
    WB_UTINY *value = NULL;
    WB_LONG len;
    WBXMLError ret = WBXML_OK;
    WB_BOOL static_value;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing attribute", parser->pos));

    /* Parse attrStart */
    ret = parse_attr_start(parser, &attr_name, &value);
    if (ret != WBXML_OK)
        return ret;

    if (value != NULL)
        attr_value = wbxml_buffer_create(value, WBXML_STRLEN(value), WBXML_PARSER_ATTR_VALUE_MALLOC_BLOCK);
    else
        attr_value = wbxml_buffer_create(NULL, 0, WBXML_PARSER_ATTR_VALUE_MALLOC_BLOCK);

    if (attr_value == NULL) {
        wbxml_attribute_name_destroy(attr_name);        
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;
    }
    
    /* Construct Attribute Value */
    while (is_attr_value(parser)) 
    {
        static_value = TRUE;

        /* Parse attrValue */
        ret = parse_attr_value(parser, &value, &len, &static_value);
        if (ret != WBXML_OK) {
            wbxml_attribute_name_destroy(attr_name);
            wbxml_buffer_destroy(attr_value);
            return ret;
        }

        if (len > 0) {
            if (!wbxml_buffer_append_data(attr_value, value, len)) {
                wbxml_attribute_name_destroy(attr_name);
                wbxml_buffer_destroy(attr_value);
                return WBXML_ERROR_NOT_ENOUGH_MEMORY;
            }
        }

        if (!static_value) {
            wbxml_free(value);
            value = NULL;
        }
    }

    if ((wbxml_buffer_len(attr_value) > 0) && (attr_name->type == WBXML_VALUE_TOKEN)) 
    {
        /* Handle Language Specific Attribute Values */
        switch (parser->langTable->langID) {
#if defined( WBXML_SUPPORT_SI )
        case WBXML_LANG_SI10:
            /* SI 1.0: Decode date for 'created' and 'si-expires' attributes */
            if ((attr_name->u.token->wbxmlCodePage == 0x00) && 
                ((attr_name->u.token->wbxmlToken == 0x0a) || (attr_name->u.token->wbxmlToken == 0x10)))
            {
                if ((ret = decode_datetime(attr_value)) != WBXML_OK) {
                    wbxml_attribute_name_destroy(attr_name);
                    wbxml_buffer_destroy(attr_value);
                    return ret;
                }
            }
            break;
#endif /* WBXML_SUPPORT_SI */

#if defined( WBXML_SUPPORT_EMN )
        case WBXML_LANG_EMN10:
            /* EMN 1.0: Decode date for 'timestamp' attribute */
            if ((attr_name->u.token->wbxmlCodePage == 0x00) && (attr_name->u.token->wbxmlToken == 0x05))
            {
                if ((ret = decode_datetime(attr_value)) != WBXML_OK) {
                    wbxml_attribute_name_destroy(attr_name);
                    wbxml_buffer_destroy(attr_value);
                    return ret;
                }
            }
            break;
#endif /* WBXML_SUPPORT_EMN */

        default:
            break;
        }
    }

    /* Append NULL char to attr value */
    if (wbxml_buffer_len(attr_value) > 0)
        wbxml_buffer_append_char(attr_value, '\0');

    if ((*attr = wbxml_attribute_create()) == NULL) {
        wbxml_attribute_name_destroy(attr_name);
        wbxml_buffer_destroy(attr_value);
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;
    }

    (*attr)->name = attr_name;
    (*attr)->value = attr_value;

    return WBXML_OK;
}


static WBXMLError parse_content(WBXMLParser *parser, WB_UTINY **content, WB_LONG *len, WB_BOOL *static_content)
{
    WB_UTINY cur_byte;
    WBXMLError ret = WBXML_OK;

    /* Debug */
    if (!wbxml_buffer_get_char(parser->wbxml, parser->pos, &cur_byte))
        return WBXML_ERROR_END_OF_BUFFER;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing content: '0x%X'", parser->pos, cur_byte));
    
    *static_content = FALSE;

    /* extension */
    if (is_extension(parser))
        return parse_extension(parser, WBXML_TAG_TOKEN, content, len);

    /* entity */
    if (is_token(parser, WBXML_ENTITY))
        return parse_entity(parser, content, len);

    *static_content = TRUE;

    /* string */
    if (is_string(parser))
        return parse_string(parser, content, len);

    /* opaque */
    if (is_token(parser, WBXML_OPAQUE)) {
        if ((ret = parse_opaque(parser, content, len)) != WBXML_OK)
            return ret;

        return decode_opaque_content(parser, content, len, static_content);
    }

    /* pi */
    if (is_token(parser, WBXML_PI))
        return parse_pi(parser);

    return parse_element(parser);
}


static WBXMLError parse_string(WBXMLParser *parser, WB_UTINY **str, WB_LONG *len)
{
    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing string", parser->pos));

    if (is_token(parser, WBXML_STR_I))
        return parse_inline(parser, str, len);

    if (is_token(parser, WBXML_STR_T))
        return parse_tableref(parser, str, len);

    return WBXML_ERROR_STRING_EXPECTED;
}


static WBXMLError parse_extension(WBXMLParser *parser, WBXMLTokenType code_space, WB_UTINY **ext, WB_LONG *len)
{
    WBXMLError ret = WBXML_OK;
    WB_UTINY token;

#if ( defined ( WBXML_SUPPORT_WML ) || defined ( WBXML_SUPPORT_WTA ) )
    WB_UTINY var_begin[3] = "$(",
             var_end[2] = ")",
             escape[8] = ":escape",
             unesc[7] = ":unesc",
             noesc[7] = ":noesc",
             *var = NULL;

    WB_LONG var_len;
    WB_ULONG index;
#endif /* WBXML_SUPPORT_WML || WBXML_SUPPORT_WTA */

#if defined ( WBXML_SUPPORT_WV )
    WB_ULONG ext_value;
    WB_UTINY tab_index;
#endif /* WBXML_SUPPORT_WV */

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing extension", parser->pos));

    /* Parse switchPage */
    if (is_token(parser, WBXML_SWITCH_PAGE)) {
        ret = parse_switch_page(parser, code_space);
        if (ret != WBXML_OK)
            return ret;
    }

    /* Get Extension Token */
    ret = parse_uint8(parser, &token);
    if (ret != WBXML_OK)
        return ret;

    *len = 0;

    switch(parser->langTable->langID) {
#if defined( WBXML_SUPPORT_WML )
    case WBXML_LANG_WML10:
    case WBXML_LANG_WML11:
    case WBXML_LANG_WML12:
    case WBXML_LANG_WML13:
#endif /* WBXML_SUPPORT_WML */

#if defined( WBXML_SUPPORT_WTA )
    case WBXML_LANG_WTAWML12:
#endif /* WBXML_SUPPORT_WTA */

#if ( defined( WBXML_SUPPORT_WML ) || defined( WBXML_SUPPORT_WTA ) )
        /*****************************
         * WML Variable Substitution 
         */

        switch(token) {
        case WBXML_EXT_0:
        case WBXML_EXT_1:
        case WBXML_EXT_2:
            WBXML_WARNING((WBXML_PARSER, "This extension token is reserved for futur use (ignoring)"));
            return WBXML_OK;
        case WBXML_EXT_I_0:
        case WBXML_EXT_I_1:
        case WBXML_EXT_I_2:
            /* Inline variable */
            if ((ret = parse_termstr(parser, &var, &var_len)) != WBXML_OK) {
                WBXML_ERROR((WBXML_PARSER, "Bad Inline Extension"));
                return ret;
            }
            break;
        case WBXML_EXT_T_0:
        case WBXML_EXT_T_1:
        case WBXML_EXT_T_2:
            /* Index in String Table */
            if ((ret = parse_mb_uint32(parser, &index)) != WBXML_OK)
                return ret;

            if ((ret = get_strtbl_reference(parser, index, &var, &var_len)) != WBXML_OK) {
                WBXML_ERROR((WBXML_PARSER, "Bad Extension reference in string table"));
                return ret;
            }
            break;
        default:
            return WBXML_ERROR_UNKNOWN_EXTENSION_TOKEN;
        }

        /* Build Variable */
        *ext = (WB_UTINY*) wbxml_malloc(WBXML_STRLEN(var_begin) + var_len + WBXML_STRLEN(escape) + WBXML_STRLEN(var_end) + 1);
        if (*ext == NULL)
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;    

        /* Generate "$(" */
        memcpy(*ext + *len, var_begin, WBXML_STRLEN(var_begin));
        *len += WBXML_STRLEN(var_begin);

        /* Generate 'variable' */
        memcpy(*ext + *len, var, var_len);
        *len += WBXML_STRLEN(var);

        switch(token) {
        case WBXML_EXT_I_0:
        case WBXML_EXT_T_0:
            /* Generate ":escape" */
            memcpy(*ext + *len, escape, WBXML_STRLEN(escape));
            *len += WBXML_STRLEN(escape);
            break;
        case WBXML_EXT_I_1:
        case WBXML_EXT_T_1:
            /* Generate ":unesc" */
            memcpy(*ext + *len, unesc, WBXML_STRLEN(unesc));
            *len += WBXML_STRLEN(unesc);
            break;
        case WBXML_EXT_I_2:
        case WBXML_EXT_T_2:
            /* Generate ":noesc" */
            memcpy(*ext + *len, noesc, WBXML_STRLEN(noesc));
            *len += WBXML_STRLEN(noesc);
            break;
        default:
            return WBXML_ERROR_UNKNOWN_EXTENSION_TOKEN;
        }

        /* Generate ")" */
        memcpy(*ext + *len, var_end, WBXML_STRLEN(var_end));
        *len += WBXML_STRLEN(var_end);        
        break;
#endif /* WBXML_SUPPORT_WML || WBXML_SUPPORT_WTA */
        
#if defined( WBXML_SUPPORT_WV )
    case WBXML_LANG_WV_CSP11:
    case WBXML_LANG_WV_CSP12:
        if (token != WBXML_EXT_T_0) {
            WBXML_ERROR((WBXML_PARSER, "Only EXT_T_0 extensions authorized with Wireless Village CSP"));
            return WBXML_OK;
        }

        /* Get Extension Value Token */
        if ((ret = parse_mb_uint32(parser, &ext_value)) != WBXML_OK)
            return ret;

        /* Search Token in Extension Value Table */
        if (parser->langTable == NULL)
            return WBXML_ERROR_LANG_TABLE_UNDEFINED;

        if (parser->langTable->extValueTable == NULL)
            return WBXML_ERROR_EXT_VALUE_TABLE_UNDEFINED;

        tab_index = 0;

        while ((parser->langTable->extValueTable[tab_index].xmlName != NULL) &&
               (parser->langTable->extValueTable[tab_index].wbxmlToken != ext_value)) {
            tab_index++;
        }

            if (parser->langTable->extValueTable[tab_index].xmlName == NULL) {
#if WBXML_PARSER_BEST_EFFORT
                    *ext = (WB_UTINY *) wbxml_strdup((const WB_TINY*) WBXML_PARSER_UNKNOWN_STRING);
            *len = WBXML_STRLEN(WBXML_PARSER_UNKNOWN_STRING);
                    return WBXML_OK;
#else
                    return WBXML_ERROR_UNKNOWN_EXTENSION_VALUE;
#endif /* WBXML_PARSER_BEST_EFFORT */
            }

        *ext = (WB_UTINY *) wbxml_strdup((const WB_TINY*) parser->langTable->extValueTable[tab_index].xmlName);
        *len = WBXML_STRLEN(parser->langTable->extValueTable[tab_index].xmlName);
        break;
#endif /* WBXML_SUPPORT_WV */
    
    default:
        WBXML_ERROR((WBXML_PARSER, "Extension tokens not allowed with this Document !"));
    }

    return WBXML_OK;
}


static WBXMLError parse_entity(WBXMLParser *parser, WB_UTINY **entity, WB_LONG *len)
{
    WB_ULONG code;
    WBXMLError ret = WBXML_OK;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing entity", parser->pos));
    
    /* 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 this variable length (10 chars), change too 'WBXML_PARSER_MAX_ENTITY_CODE' 
     *            defined in this file !
     */
    *entity = (WB_UTINY*) wbxml_malloc(10 * sizeof(WB_UTINY));
    if ((*entity) == NULL)
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;

    *len = sprintf((WB_TINY *)(*entity), "&#%u;", code);

    return WBXML_OK;
}


static WBXMLError parse_opaque(WBXMLParser *parser, WB_UTINY **data, WB_LONG *len)
{
    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++;

    ret = parse_mb_uint32(parser, (WB_ULONG *)len);
    if (ret != WBXML_OK)
        return ret;

    *data = wbxml_buffer_get_cstr(parser->wbxml) + parser->pos;

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

    return ret;
}


static WBXMLError parse_literal(WBXMLParser *parser, WB_UTINY *mask, WB_UTINY **result)
{
    WBXMLError ret = WBXML_OK;
    WB_UTINY token;
    WB_ULONG index;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing literalTag", parser->pos));

    /* Parse literalTag */
    ret = parse_uint8(parser, &token);
    if (ret != WBXML_OK)
        return ret;

    /* Parse index */
    ret = parse_mb_uint32(parser, &index);
    if (ret != WBXML_OK)
        return ret;

    /* Check that index specified is 'normal' */
    if (index > wbxml_buffer_len(parser->strstbl))
        return WBXML_ERROR_BAD_LITERAL_INDEX;

    *result = wbxml_buffer_get_cstr(parser->strstbl) + index;

    /* Check that element length is 'normal' */
    if ((index + WBXML_STRLEN(*result)) > wbxml_buffer_len(parser->strstbl))
        return WBXML_ERROR_LITERAL_NOT_NULL_TERMINATED_IN_STRING_TABLE;

    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;
}


static WBXMLError parse_attr_start(WBXMLParser *parser, WBXMLAttributeName **name, WB_UTINY **value)
{
    WB_UTINY *literal_str = NULL;
    WB_UTINY literal;    
    WB_UTINY tag;
    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)) {
        ret = parse_literal(parser, &literal, &literal_str);
        if (ret != WBXML_OK)
            return ret;

        if ((*name = wbxml_attribute_name_create_literal(literal_str)) == NULL)
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;

        return WBXML_OK;
    }


    /***********************************
     * Case: ( [switchPage] ATTRSTART )
     */

    /* 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;

    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 = (WB_UTINY *) parser->langTable->attrTable[index].xmlValue;
    
    return WBXML_OK;
}


static WBXMLError parse_attr_value(WBXMLParser *parser, WB_UTINY **value, WB_LONG *len, WB_BOOL *static_value)
{
    WB_ULONG index = 0;
    WB_UTINY tag;
    WBXMLError ret = WBXML_OK;

    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing attrValue", parser->pos));

    *static_value = FALSE;

    /* Parse extension */
    if (is_extension(parser))
        return parse_extension(parser, WBXML_ATTR_TOKEN, value, len);

    /* Parse entity */
    if (is_token(parser, WBXML_ENTITY))
        return parse_entity(parser, value, len);

    *static_value = TRUE;

    /* Parse string */
    if (is_string(parser))
        return parse_string(parser, value, len);

    /* 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, value, len);
    }


    /*****************************
     *    ([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->tagCodePage))) {
        index++;
    }

    if (parser->langTable->attrValueTable[index].xmlName == NULL)
        return WBXML_ERROR_UNKNOWN_ATTR_VALUE;

    *value = (WB_UTINY *) parser->langTable->attrValueTable[index].xmlName;
    *len = WBXML_STRLEN(*value);
    
    return WBXML_OK;
}


static WBXMLError parse_termstr(WBXMLParser *parser, WB_UTINY **str, WB_LONG *len)
{
    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing termstr", parser->pos));

    *str = wbxml_buffer_get_cstr(parser->wbxml) + parser->pos;
    *len = WBXML_STRLEN(*str);

    /* Check that the string was NULL terminated */
    if (parser->pos + *len > wbxml_buffer_len(parser->wbxml))
        return WBXML_ERROR_NOT_NULL_TERMINATED_INLINE_STRING;

    /* Skip string (don't forget ending null char) */
    parser->pos = parser->pos + *len + 1;

    WBXML_DEBUG((WBXML_PARSER, "(%d) termstr: %s", parser->pos, *str));

    return WBXML_OK;
}


static WBXMLError parse_inline(WBXMLParser *parser, WB_UTINY **str, WB_LONG *len)
{
    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing inline", parser->pos));

    /* Skip STR_I */
    parser->pos++;

    return parse_termstr(parser, str, len);
}


static WBXMLError parse_tableref(WBXMLParser *parser, WB_UTINY **str, WB_LONG *len)
{
    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, str, len);
}


static WBXMLError parse_entcode(WBXMLParser *parser, WB_ULONG *result)
{
    WBXML_DEBUG((WBXML_PARSER, "(%d) Parsing entcode", parser->pos));

    return parse_mb_uint32(parser, result);
}


static WBXMLError get_strtbl_reference(WBXMLParser *parser, WB_ULONG index, WB_UTINY **str, WB_LONG *len)
{    
    /* Check if strtbl is NULL */
    if (parser->strstbl == NULL)
        return WBXML_ERROR_NULL_STRING_TABLE;

    if (index >= wbxml_buffer_len(parser->strstbl))
        return WBXML_ERROR_INVALID_STRTBL_INDEX;

    *str = wbxml_buffer_get_cstr(parser->strstbl) + index;
    *len = WBXML_STRLEN(*str);

    /* Check that the string was correctly NULL terminated in String Table */
    if (index + *len > wbxml_buffer_len(parser->strstbl))
        return WBXML_ERROR_BAD_NULL_TERMINATED_STRING_IN_STRING_TABLE;

    WBXML_DEBUG((WBXML_PARSER, "(%d) String Table Reference: %s", parser->pos, *str));

    return WBXML_OK;
}


/********************************
 *    Basic Types Parse functions
 */

static WBXMLError parse_uint8(WBXMLParser *parser, WB_UTINY *result)
{
    if (parser == NULL)
        return WBXML_ERROR_NULL_PARSER;

    if (result == NULL)
        return WBXML_ERROR_BAD_PARAMETER;

    if (parser->pos == wbxml_buffer_len(parser->wbxml))
        return WBXML_ERROR_END_OF_BUFFER;

    if (!wbxml_buffer_get_char(parser->wbxml, parser->pos, result))
        return WBXML_ERROR_END_OF_BUFFER;

    parser->pos++;

    return WBXML_OK;
}


static WBXMLError parse_mb_uint32(WBXMLParser *parser, WB_ULONG *result)
{
    WB_ULONG uint = 0, byte_pos;
    WB_UTINY cur_byte;

    if (parser == NULL)
        return WBXML_ERROR_NULL_PARSER;

    if (result == NULL)
        return WBXML_ERROR_BAD_PARAMETER;

    /* It's a 32bit integer, and so it fits to a maximum of 4 bytes */
    for (byte_pos = 0; byte_pos < 5; byte_pos++) {
        /* Get current byte */
        if (!wbxml_buffer_get_char(parser->wbxml, parser->pos, &cur_byte))
            return WBXML_ERROR_END_OF_BUFFER;

        /* Move to next byte */
        parser->pos++;

        /* Update uint value */
        uint = (uint << 7) | ((WB_UTINY)cur_byte & 0x7F);

        /* Check first bit, and stop if value is zero */
        if (!((WB_UTINY)cur_byte & 0x80)) {
            *result = uint;
            return WBXML_OK;
        }
    }

    return WBXML_ERROR_UNVALID_MBUINT32;
}


/****************************************
 * Language Specific Decoding Functions 
 */

#if ( defined( WBXML_SUPPORT_SI ) || defined( WBXML_SUPPORT_EMN ) )

/**************************************
 * SI 1.0 / EMN 1.0
 */

static WBXMLError decode_datetime(WBXMLBuffer *buff)
{
    WB_ULONG len = 0;

    /* Binary to Hexa */
    if (!wbxml_buffer_binary_to_hex(buff, TRUE))
        return WBXML_ERROR_INTERNAL;

    /* Check Integrity */
    len = wbxml_buffer_len(buff);
    if ((len < 8) || (len > 14) || (len == 9) || (len == 11) || (len == 13))
        return WBXML_ERROR_BAD_DATETIME;

    /* Date */

    /* "1999-" */
    if (!wbxml_buffer_insert_cstr(buff, (WB_UTINY *)"-", 4))
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;

    /* "1999-04-" */
    if (!wbxml_buffer_insert_cstr(buff, (WB_UTINY *)"-", 7))
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;

    /* "1999-04-30T" */
    if (!wbxml_buffer_insert_cstr(buff, (WB_UTINY *)"T", 10))
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;

    /* Time */

    /* Append ':' delimiters */
    if (len > 10) {
        if (!wbxml_buffer_insert_cstr(buff, (WB_UTINY *)":", 13))
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;
    }

    if (len > 12) {
        if (!wbxml_buffer_insert_cstr(buff, (WB_UTINY *)":", 16))
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;
    }

    /* Append Trailing Zeros */
    switch (len) {
    case 8:
        if (!wbxml_buffer_append_cstr(buff, (WB_UTINY *)"00:00:00"))
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;
        break;
    case 10:
        if (!wbxml_buffer_append_cstr(buff, (WB_UTINY *)":00:00"))
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;
        break;
    case 12:
        if (!wbxml_buffer_append_cstr(buff, (WB_UTINY *)":00"))
            return WBXML_ERROR_NOT_ENOUGH_MEMORY;
        break;
    default:
        /* 14 : Nothing to do */
        break;
    }

    /* Append ending 'Z' character */
    if (!wbxml_buffer_append_char(buff, 'Z'))
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;

    return WBXML_OK;
}

#endif /* WBXML_SUPPORT_SI || WBXML_SUPPORT_EMN */


static WBXMLError decode_opaque_content(WBXMLParser *parser, WB_UTINY **data, WB_LONG *len, WB_BOOL *static_content)
{
    WBXMLError ret = WBXML_OK;

    /* This function is always called after 'parse_opaque()' into 'parse_content()', and
     * 'parse_opaque()' always output a static buffer.
     */
    *static_content = TRUE;

    switch (parser->langTable->langID) {
#if defined( WBXML_SUPPORT_WV )
    case WBXML_LANG_WV_CSP11:
    case WBXML_LANG_WV_CSP12:
        return decode_wv_content(parser, data, len, static_content);
        break;
#endif /* WBXML_SUPPORT_WV */

#if defined( WBXML_SUPPORT_DRMREL )
    case WBXML_LANG_DRMREL10:
        if ((parser->current_tag->wbxmlCodePage == 0x00) &&
            (parser->current_tag->wbxmlToken == 0x0C))
        {
            /* Decode <KeyValue> */
            if ((ret = decode_drmrel_keyvalue(data, len)) != WBXML_OK)
                return ret;
                
            *static_content = FALSE;
            return WBXML_OK;
        }
        break;
#endif /* WBXML_SUPPORT_DRMREL */    

    default:
        /* NOP */
        break;
    } /* switch */

    return WBXML_OK;
}


#if defined( WBXML_SUPPORT_WV )

/**************************************
 * WV 1.1 / WV 1.2
 */

static WBXMLError decode_wv_content(WBXMLParser *parser, WB_UTINY **data, WB_LONG *len, WB_BOOL *static_content)
{
    WBXMLWVDataType data_type = WBXML_WV_DATA_TYPE_STRING;
    WBXMLError ret = WBXML_OK;

    /* Wireless-Village 1.1 / 1.2 */

    /* 
     *  Specific WV Opaque Data Type Elements:
     *
     *        Integer:
     *            Code (0x00 / 0x0B)
     *            ContentSize (0x00 / 0x0F)
     *            MessageCount (0x00 / 0x1A)
     *            Validity (0x00 / 0x3C)
     *            KeepAliveTime (0x01 / 0x1C)
     *            SearchFindings (0x01 / 0x25)
     *            SearchID (0x01 / 0x26)
     *            SearchIndex (0x01 / 0x27)
     *            SearchLimit (0x01 / 0x28)
     *            TimeToLive (0x01 / 0x32)
     *            AcceptedCharSet (0x03 / 0x05)
     *            AcceptedContentLength (0x03 / 0x06)
     *            MultiTrans (0x03 / 0x0C)
     *            ParserSize (0x03 / 0x0D)
     *            ServerPollMin (0x03 / 0x0E)
     *            TCPPort (0x03 / 0x12)
     *            UDPPort (0x03 / 0x13)
     *            HistoryPeriod (0x09 / 0x08) [WV 1.2]
     *            MaxWatcherList (0x09 / 0x0A) [WV 1.2]
     *
     *        Date and Time:
     *            DateTime (0x00 / 0x11)
     *            DeliveryTime (0x06 / 0x1A)
     *
     *        Binary:
     *            ContentData (0x00 / 0x0D) (only if we have a: "<ContentEncoding>BASE64</ContentEncoding>" associated)
     */

    /***********************************************
     * Check the Data Type, given the Current Tag 
     */

    switch (parser->current_tag->wbxmlCodePage) {
    case 0x00:
        /* Code Page: 0x00 */
        switch (parser->current_tag->wbxmlToken) {
        case 0x0B: /* Code */
        case 0x0F: /* ContentSize */
        case 0x1A: /* MessageCount */
        case 0x3C: /* Validity */
            /* INTEGER */
            data_type = WBXML_WV_DATA_TYPE_INTEGER;
            break;
        case 0x11: /* DateTime */
            /* DATE_AND_TIME */
            data_type = WBXML_WV_DATA_TYPE_DATE_AND_TIME;
            break;
        case 0x0D: /* ContentData */
            /* BINARY */
            /*
            if (base64_encoded)
                data_type = WBXML_WV_DATA_TYPE_BINARY;
            else
            */
                data_type = WBXML_WV_DATA_TYPE_STRING;
            break;
        default:
            /* STRING */
            data_type = WBXML_WV_DATA_TYPE_STRING;
            break;
        }
        break;
    case 0x01:
        /* Code Page: 0x01 */
        switch (parser->current_tag->wbxmlToken) {
        case 0x1C: /* KeepAliveTime */
        case 0x25: /* SearchFindings */
        case 0x26: /* SearchID */
        case 0x27: /* SearchIndex */
        case 0x28: /* SearchLimit */
        case 0x32: /* TimeToLive */
            /* INTEGER */
            data_type = WBXML_WV_DATA_TYPE_INTEGER;
            break;
        default:
            /* STRING */
            data_type = WBXML_WV_DATA_TYPE_STRING;
            break;
        }
        break;
    case 0x03:
        /* Code Page: 0x03 */
        switch (parser->current_tag->wbxmlToken) {
        case 0x05: /* AcceptedCharSet */
        case 0x06: /* AcceptedContentLength */
        case 0x0C: /* MultiTrans */
        case 0x0D: /* ParserSize */
        case 0x0E: /* ServerPollMin */
        case 0x12: /* TCPPort */
        case 0x13: /* UDPPort */
            /* INTEGER */
            data_type = WBXML_WV_DATA_TYPE_INTEGER;
            break;
        default:
            /* STRING */
            data_type = WBXML_WV_DATA_TYPE_STRING;
            break;
        }
        break;
    case 0x06:
        /* Code Page: 0x06 */
        switch (parser->current_tag->wbxmlToken) {
        case 0x1A: /* DeliveryTime */
            /* DATE AND TIME */
            data_type = WBXML_WV_DATA_TYPE_DATE_AND_TIME;
            break;
        default:
            /* STRING */
            data_type = WBXML_WV_DATA_TYPE_STRING;
            break;
        }
        break;
    case 0x09:
        /* Code Page: 0x09 */
        switch (parser->current_tag->wbxmlToken) {
        case 0x08: /* HistoryPeriod */
        case 0x0A: /* MaxWatcherList */
            /* INTEGER */
            data_type = WBXML_WV_DATA_TYPE_INTEGER;
            break;
        default:
            /* STRING */
            data_type = WBXML_WV_DATA_TYPE_STRING;
            break;
        }
        break;
    default:
        data_type = WBXML_WV_DATA_TYPE_STRING;
        break;
    } /* switch */


    /***********************************************
     * Decode the Opaque, given the Data Type found 
     */

    switch (data_type) {
    case WBXML_WV_DATA_TYPE_INTEGER:
        /* Decode Integer */
        if ((ret = decode_wv_integer(data, len)) != WBXML_OK)
            return ret;

        *static_content = FALSE;
        return WBXML_OK;
        break;
    case WBXML_WV_DATA_TYPE_DATE_AND_TIME:
        /* Decode Date and Time */
        if ((ret = decode_wv_datetime(data, len)) != WBXML_OK)
            return ret;

        *static_content = FALSE;
        return WBXML_OK;
        break;
    case WBXML_WV_DATA_TYPE_BINARY:
        break;
    default:
        /* Do nothing. Keep this data as is. */
        break;
    } /* switch */

    return WBXML_OK;
}

static WBXMLError decode_wv_integer(WB_UTINY **data, WB_LONG *len)
{
    WB_LONG i = 0;
    WB_ULONG the_int = 0;
    WB_UTINY ch = 0;
    WB_UTINY tmp[11];

    if ((data == NULL) || (len == NULL) || (*len <= 0))
        return WBXML_ERROR_INTERNAL;

    for (i = 0; i < *len; i++) {
        ch = (*data)[i];
        the_int = (the_int << 8) | (ch & 0xff);
    }

    if (the_int > 0xffffffff)
        return WBXML_ERROR_WV_INTEGER_OVERFLOW;

    sprintf((WB_TINY *)tmp, "%u", the_int);

    if (((*data) = (WB_UTINY *) wbxml_malloc((WBXML_STRLEN(tmp) + 1) * sizeof(WB_UTINY))) == NULL)
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;

    *len = WBXML_STRLEN(tmp);

    memcpy(*data, tmp, *len);
    (*data)[*len] = '\0';

    return WBXML_OK;
}


static WBXMLError decode_wv_datetime(WB_UTINY **data, WB_LONG *len)
{
    WB_UTINY *result = NULL;
    WB_TINY the_year[5], the_month[3],  the_date[3], 
            the_hour[3], the_minute[3], the_second[3];
    WB_ULONG the_value = 0;

    if ((data == NULL) || (*data == NULL) || (len == NULL))
        return WBXML_ERROR_INTERNAL;

    if (*len != 6)
        return WBXML_ERROR_WV_DATETIME_FORMAT;

    if ((result = (WB_UTINY *) wbxml_malloc(17 * sizeof(WB_UTINY))) == NULL)
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;

    /* Get Year */
    the_value = (WB_ULONG) (((*data)[0] << 6) | (((*data)[1] >> 2) && 0x3F));
    sprintf(the_year, "%u", the_value);

    /* Get Month */
    the_value = (WB_ULONG) ((((*data)[1] && 0x03) << 2) | (((*data)[2] >> 6) && 0x3F));
    sprintf(the_month, "%u", the_value);

    /* Get Day */
    the_value = (WB_ULONG) (((*data)[2] >> 1) && 0x1F);
    sprintf(the_date, "%u", the_value);

    /* Get Hour */
    the_value = (WB_ULONG) ((((*data)[2] && 0x01) << 4) | (((*data)[3] >> 4) && 0x0F));
    sprintf(the_hour, "%u", the_value);

    /* Get Minute */
    the_value = (WB_ULONG) ((((*data)[3] && 0x0F) << 2) | (((*data)[4] >> 6) && 0x03));
    sprintf(the_minute, "%u", the_value);

    /* Get Second */
    the_value = (WB_ULONG) ((*data)[4] && 0x3F);
    sprintf(the_second, "%u", the_value);

    /* Get Time Zone */
    if ((*data)[5] == 'Z')
        sprintf((WB_TINY *) result, "%s%s%sT%s%s%sZ", the_year, the_month, the_date, the_hour, the_minute, the_second);
    else
        sprintf((WB_TINY *) result, "%s%s%sT%s%s%s", the_year, the_month, the_date, the_hour, the_minute, the_second);
        
    *data = result;
    *len = WBXML_STRLEN(result);

    return WBXML_OK;
}

#endif /* WBXML_SUPPORT_WV */


#if defined( WBXML_SUPPORT_DRMREL )

/**************************************
 * DRMREL 1.0
 */

static WBXMLError decode_drmrel_keyvalue(WB_UTINY **data, WB_LONG *len)
{
    WB_UTINY *result = NULL;
    
    if ((data == NULL) || (*data == NULL) || (len == NULL))
        return WBXML_ERROR_INTERNAL;
       
    if ((result = wbxml_base64_encode((const WB_UTINY *) *data, *len)) == NULL)
        return WBXML_ERROR_B64_ENC;
    
    *data = result;
    *len = WBXML_STRLEN(result);
    
    return WBXML_OK;
}

#endif /* WBXML_SUPPORT_DRMREL */

---