---

wbxml_tree_clb_xml.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
 */
 
#if defined( HAVE_EXPAT )

#include <string.h> /* For strlen() */

#include "wbxml.h"


/* Private Functions Prototypes */
static WBXMLTreeAttribute *construct_attribute_list(const WBXMLLangEntry *lang_table, const XML_Char **attrs);
static void add_node_to_tree(WBXMLTreeNode *node, WBXMLTreeClbCtx *ctx);


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

void wbxml_tree_clb_xml_doctype_decl(void *ctx, const XML_Char *doctypeName, 
                                const XML_Char *sysid, const XML_Char *pubid, 
                                int has_internal_subset)
{    
    WBXMLTreeClbCtx *tree_ctx = (WBXMLTreeClbCtx *) ctx;
    const WBXMLLangEntry *lang_table = NULL;

    /* Search for Language Table, given the XML Public ID and System ID */
    lang_table = wbxml_tables_search_table(wbxml_tables_get_main(), 
                                           (const WB_UTINY *) pubid, 
                                           (const WB_UTINY *) sysid, 
                                           NULL);

    if (lang_table != NULL) {
        /* Ho Yeah ! We got it ! */
        tree_ctx->tree->lang = lang_table;
    }
    else {
        /* We will try to find the Language Table, given the Root Element */
        WBXML_WARNING((WBXML_CONV, "Language Table NOT found, given the XML Public ID and System ID"));
    }
}


void wbxml_tree_clb_xml_start_element(void *ctx, const XML_Char *localName, const XML_Char **attrs)
{
    WBXMLTreeClbCtx *tree_ctx = (WBXMLTreeClbCtx *) ctx;
    const WBXMLLangEntry *lang_table = NULL;
    const WBXMLTagEntry *tag_entry = NULL;
    WBXMLTreeNode *node = NULL;
    WBXMLTag *tag = NULL;    

    /* Check for Error */
    if (tree_ctx->error != WBXML_OK)
        return;

    /* Are we skipping a whole node ? */
    if (tree_ctx->skip_lvl > 0) {
        tree_ctx->skip_lvl++;
        return;
    }

    if (tree_ctx->current == NULL) {
        /* This is the Root Element */
        if (tree_ctx->tree->lang == NULL) {
            /* Language Table not already found: Search again */
            lang_table = wbxml_tables_search_table(wbxml_tables_get_main(), 
                                                   NULL, 
                                                   NULL, 
                                                   (const WB_UTINY *) localName);
        
            if (lang_table == NULL) {
                /* Damn, this is an unknown language for us... */
                tree_ctx->error = WBXML_ERROR_UNKNOWN_XML_LANGUAGE;
                return;
            }
            else {
                /* Well, we hope this was the Language we are searching for.. let's try with it :| */
                tree_ctx->tree->lang = lang_table;
            }
        }
    }

    /* Search for XML Tag Name in Table */
    if ((tag_entry = wbxml_tables_get_tag_from_xml(tree_ctx->tree->lang, (const WB_UTINY *) localName)) != NULL)
        tag = wbxml_tag_create_token(tag_entry);
    else
        tag = wbxml_tag_create_literal((WB_UTINY *) localName);

    if (tag == NULL) {
        tree_ctx->error = WBXML_ERROR_NOT_ENOUGH_MEMORY;
        return;
    }

#if defined( WBXML_SUPPORT_SYNCML )
    /* If this is an embedded (not root) "DevInf" document, skip it */
    if ((WBXML_STRCMP(localName, "DevInf") == 0) &&
        (tree_ctx->current != NULL))
    {
        tree_ctx->skip_start = XML_GetCurrentByteIndex(tree_ctx->xml_parser);

        /* Skip this node */
        tree_ctx->skip_lvl++;

        /* Destroy tag */
        wbxml_tag_destroy(tag);
        return;
    }
#endif /* WBXML_SUPPORT_SYNCML */

    /* Create a new Node */
    if ((node = wbxml_tree_node_create(WBXML_TREE_ELEMENT_NODE)) == NULL) {
        tree_ctx->error = WBXML_ERROR_NOT_ENOUGH_MEMORY;
        return;
    }

    /* Set Node Tag */
    node->name = tag;

    /* Set Attributes */
    if ((attrs != NULL) && (*attrs != NULL))
    {
        if ((node->attrs = construct_attribute_list(tree_ctx->tree->lang, attrs)) == NULL) {
            wbxml_tree_node_destroy(node);
            tree_ctx->error = WBXML_ERROR_NOT_ENOUGH_MEMORY;
            return;
        }
    }

    /* Add this Node to Tree  */
    add_node_to_tree(node, tree_ctx);
}


void wbxml_tree_clb_xml_end_element(void *ctx, const XML_Char *localName)
{
    WBXMLTreeClbCtx *tree_ctx = (WBXMLTreeClbCtx *) ctx;
#if defined( WBXML_SUPPORT_SYNCML )
    WBXMLBuffer *devinf_doc = NULL;
    WBXMLTree *tree = NULL;
    WBXMLError ret = WBXML_OK;
    WBXMLTreeNode *node = NULL;
#endif /* WBXML_SUPPORT_SYNCML */

    /* Check for Error */
    if (tree_ctx->error != WBXML_OK)
        return;

    /* Are we skipping a whole node ? */
    if (tree_ctx->skip_lvl > 0) {
        if (tree_ctx->skip_lvl == 1)
        {
            /* End of skipped node */

#if defined( WBXML_SUPPORT_SYNCML )
            if (WBXML_STRCMP(localName, "DevInf") == 0) {
                /* Get embedded DevInf Document */
                devinf_doc = wbxml_buffer_create(tree_ctx->input_buff + tree_ctx->skip_start, 
                                                 XML_GetCurrentByteIndex(tree_ctx->xml_parser) - tree_ctx->skip_start,
                                                 XML_GetCurrentByteIndex(tree_ctx->xml_parser) - tree_ctx->skip_start + 10);

                /* Check Buffer Creation and addd </DevInf> ending tag */
                if ((devinf_doc == NULL) || (!wbxml_buffer_append_cstr(devinf_doc, "</DevInf>")))
                {
                    tree_ctx->error = WBXML_ERROR_NOT_ENOUGH_MEMORY;
                    wbxml_buffer_destroy(devinf_doc);
                    return;
                }

                WBXML_DEBUG((WBXML_PARSER, "\t DevInf Doc : '%s'", wbxml_buffer_get_cstr(devinf_doc)));

                /* Parse 'DevInf' Document */
                if ((ret = wbxml_tree_from_xml(wbxml_buffer_get_cstr(devinf_doc), &tree)) != WBXML_OK) {
                    tree_ctx->error = ret;
                    wbxml_buffer_destroy(devinf_doc);
                    return;
                }

                /* Create a new Node */
                if ((node = wbxml_tree_node_create(WBXML_TREE_TREE_NODE)) == NULL) {
                    tree_ctx->error = WBXML_ERROR_NOT_ENOUGH_MEMORY;
                    wbxml_tree_destroy(tree);
                    wbxml_buffer_destroy(devinf_doc);
                    return;
                }

                /* Set Tree */
                node->tree = tree;

                /* Add this Node to Tree  */
                add_node_to_tree(node, tree_ctx);

                /* Clean-up */
                wbxml_buffer_destroy(devinf_doc);
                tree_ctx->skip_lvl = 0;
            }
#endif /* WBXML_SUPPORT_SYNCML */
        }
        else {
            tree_ctx->skip_lvl--;
            return;
        }
    }

    if (tree_ctx->current == NULL) {
        tree_ctx->error = WBXML_ERROR_INTERNAL;
        return;
    }

    if (tree_ctx->current->parent == NULL) {
        /* This must be the Root Element */
        if (tree_ctx->current != tree_ctx->tree->root) {
            tree_ctx->error = WBXML_ERROR_INTERNAL;
        }
    }
    else {
        /* Go back one step upper in the tree */
        tree_ctx->current = tree_ctx->current->parent;
    }
}


void wbxml_tree_clb_xml_start_cdata(void *ctx)
{
    WBXMLTreeClbCtx *tree_ctx = (WBXMLTreeClbCtx *) ctx;

    /* Check for Error */
    if (tree_ctx->error != WBXML_OK)
        return;

    /* Are we skipping a whole node ? */
    if (tree_ctx->skip_lvl > 0)
        return;

}


void wbxml_tree_clb_xml_end_cdata(void *ctx)
{
    WBXMLTreeClbCtx *tree_ctx = (WBXMLTreeClbCtx *) ctx;

    /* Check for Error */
    if (tree_ctx->error != WBXML_OK)
        return;

    /* Are we skipping a whole node ? */
    if (tree_ctx->skip_lvl > 0)
        return;
}


void wbxml_tree_clb_xml_characters(void *ctx, const XML_Char *ch, int len)
{
    WBXMLTreeClbCtx *tree_ctx = (WBXMLTreeClbCtx *) ctx;
    WBXMLTreeNode *node = NULL;

    /* Check for Error */
    if (tree_ctx->error != WBXML_OK)
        return;

    /* Are we skipping a whole node ? */
    if (tree_ctx->skip_lvl > 0)
        return;

    /* Create a new Node */
    if ((node = wbxml_tree_node_create(WBXML_TREE_TEXT_NODE)) == NULL) {
        tree_ctx->error = WBXML_ERROR_NOT_ENOUGH_MEMORY;
        return;
    }

    /* Set Content */
    if ((node->content = wbxml_buffer_create(ch, len, len)) == NULL) {
        wbxml_tree_node_destroy(node);
        tree_ctx->error = WBXML_ERROR_NOT_ENOUGH_MEMORY;
        return;
    }

    /* Add this Node to Tree  */
    add_node_to_tree(node, tree_ctx);

    /* Go back one step upper in the tree */
    tree_ctx->current = tree_ctx->current->parent;
}


void wbxml_tree_clb_xml_pi(void *ctx, const XML_Char *target, const XML_Char *data)
{
    WBXMLTreeClbCtx *tree_ctx = (WBXMLTreeClbCtx *) ctx;

    /* Check for Error */
    if (tree_ctx->error != WBXML_OK)
        return;

    /* Are we skipping a whole node ? */
    if (tree_ctx->skip_lvl > 0)
        return;

}


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


static WBXMLTreeAttribute *construct_attribute_list(const WBXMLLangEntry *lang_table, const XML_Char **attrs)
{
    WBXMLTreeAttribute *attr = NULL, *first = NULL, *curr = NULL;
    const WBXMLAttrEntry *attr_entry = NULL;
    const WB_UTINY **p = (const WB_UTINY **) attrs;

    if ((lang_table == NULL) || (attrs == NULL))
        return NULL;

    while (p && *p) {
        /* Create Tree Attribute */
        if ((attr = wbxml_tree_attribute_create()) == NULL) {
            wbxml_tree_attribute_destroy(first);
            return NULL;
        }

        /* Keep the first one somewhere */
        if (p == (const WB_UTINY **) attrs)
            first = attr;

        /* Link it to previous Attribute */
        if (curr != NULL)
            curr->next = attr;

        /* Create Attribute */
        if ((attr->attr = wbxml_attribute_create()) == NULL) {
            wbxml_tree_attribute_destroy(first);
            return NULL;
        }

        /* Set Attribute Name */
        if ((attr_entry = wbxml_tables_get_attr_from_xml(lang_table, (WB_UTINY *) *p, (WB_UTINY *) *(p+1), NULL)) != NULL)
            attr->attr->name = wbxml_attribute_name_create_token(attr_entry);
        else
            attr->attr->name = wbxml_attribute_name_create_literal((WB_UTINY*) *p);

        if (attr->attr->name == NULL) {
            wbxml_tree_attribute_destroy(first);
            return NULL;
        }

        /* Set Attribute Value */
        attr->attr->value = wbxml_buffer_create_real(*(p+1), WBXML_STRLEN(*(p+1)), WBXML_STRLEN(*(p+1)));
        if (attr->attr->value == NULL) {
            wbxml_tree_attribute_destroy(first);
            return NULL;
        }
        
        /* Go to next Attribute */
        curr = attr;

        p += 2;
    }

    return first;
}


static void add_node_to_tree(WBXMLTreeNode *node, WBXMLTreeClbCtx *ctx)
{
    WBXMLTreeNode *parent = NULL, *tmp = NULL;

    /* This is the new Current Node */
    parent = ctx->current;
    node->parent = parent;    
    ctx->current = node;

    /* Check if this is the Root Element */
    if (parent != NULL) {
                /* This is not the Root Element... search for previous sibbling element */
                if (parent->children != NULL) {
            /* Add this Node to end of Sibbling Node list of Parent */
                        tmp = parent->children;
                        
                        while (tmp->next != NULL)
                                tmp = tmp->next;
                        
                        node->prev = tmp;
                        tmp->next = node;
                }
                else {
                        /* No previous sibbling element */
                        parent->children = node;
                }
    }
    else {
        /* This is the Root Element */
        ctx->tree->root = node;
    }
}

#endif /* HAVE_EXPAT */

---