libdom.c

Go to the documentation of this file.

/*
 * Copyright 2012 Vincent Sanders <vince@netsurf-browser.org>
 *
 * This file is part of NetSurf, http://www.netsurf-browser.org/
 *
 * NetSurf is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * NetSurf 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
/** \file
 * libdom utilities (implementation).
 */
 
#include <assert.h>
#include <string.h>
#include <dom/dom.h>
 
#include "utils/config.h"
#include "utils/log.h"
#include "utils/libdom.h"
 
 
/* exported interface documented in libdom.h */
dom_node *libdom_find_first_element(dom_node *parent, lwc_string *element_name)
{
        dom_node *element;
        dom_exception exc;
        dom_string *node_name = NULL;
        dom_node_type node_type;
        dom_node *next_node;
 
        exc = dom_node_get_first_child(parent, &element);
        if ((exc != DOM_NO_ERR) || (element == NULL)) {
                return NULL;
        }
 
        /* find first node thats a element */
        do {
                exc = dom_node_get_node_type(element, &node_type);
 
                if ((exc == DOM_NO_ERR) && (node_type == DOM_ELEMENT_NODE)) {
                        exc = dom_node_get_node_name(element, &node_name);
                        if ((exc == DOM_NO_ERR) && (node_name != NULL)) {
                                if (dom_string_caseless_lwc_isequal(node_name,
                                                     element_name)) {
                                        dom_string_unref(node_name);
                                        break;
                                }
                                dom_string_unref(node_name);
                        }
                }
 
                exc = dom_node_get_next_sibling(element, &next_node);
                dom_node_unref(element);
                if (exc == DOM_NO_ERR) {
                        element = next_node;
                } else {
                        element = NULL;
                }
        } while (element != NULL);
 
        return element;
}
 
/* exported interface documented in libdom.h */
/* TODO: return appropriate errors */
nserror libdom_iterate_child_elements(dom_node *parent,
                libdom_iterate_cb cb, void *ctx)
{
        dom_nodelist *children;
        uint32_t index, num_children;
        dom_exception error;
 
        error = dom_node_get_child_nodes(parent, &children);
        if (error != DOM_NO_ERR || children == NULL)
                return NSERROR_NOMEM;
 
        error = dom_nodelist_get_length(children, &num_children);
        if (error != DOM_NO_ERR) {
                dom_nodelist_unref(children);
                return NSERROR_NOMEM;
        }
 
        for (index = 0; index < num_children; index++) {
                dom_node *child;
                dom_node_type type;
 
                error = dom_nodelist_item(children, index, &child);
                if (error != DOM_NO_ERR) {
                        dom_nodelist_unref(children);
                        return NSERROR_NOMEM;
                }
 
                error = dom_node_get_node_type(child, &type);
                if (error == DOM_NO_ERR && type == DOM_ELEMENT_NODE) {
                        nserror err = cb(child, ctx);
                        if (err != NSERROR_OK) {
                                dom_node_unref(child);
                                dom_nodelist_unref(children);
                                return err;
                        }
                }
 
                dom_node_unref(child);
        }
 
        dom_nodelist_unref(children);
 
        return NSERROR_OK;
}
 
/* exported interface documented in libdom.h */
nserror libdom_hubbub_error_to_nserror(dom_hubbub_error error)
{
        switch (error) {
 
        /* HUBBUB_REPROCESS is not handled here because it can
         * never occur outside the hubbub treebuilder
         */
 
        case DOM_HUBBUB_OK:
                /* parsed ok */
                return NSERROR_OK;
 
        case (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_PAUSED):
                /* hubbub input paused */
                return NSERROR_OK;
 
        case DOM_HUBBUB_NOMEM:
                /* out of memory error from DOM */
                return NSERROR_NOMEM;
 
        case DOM_HUBBUB_BADPARM:
                /* Bad parameter passed to creation */
                return NSERROR_BAD_PARAMETER;
 
        case DOM_HUBBUB_DOM:
                /* DOM call returned error */
                return NSERROR_DOM;
 
        case (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_ENCODINGCHANGE):
                /* encoding changed */
                return NSERROR_ENCODING_CHANGE;
 
        case (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_NOMEM):
                /* out of memory error from parser */
                return NSERROR_NOMEM;
 
        case (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_BADPARM):
                return NSERROR_BAD_PARAMETER;
 
        case (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_INVALID):
                return NSERROR_INVALID;
 
        case (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_FILENOTFOUND):
                return NSERROR_NOT_FOUND;
 
        case (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_NEEDDATA):
                return NSERROR_NEED_DATA;
 
        case (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_BADENCODING):
                return NSERROR_BAD_ENCODING;
 
        case (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_UNKNOWN):
                /* currently only generated by the libdom hubbub binding */
                return NSERROR_DOM;
        default:
                /* unknown error */
                /** @todo better error handling and reporting */
                return NSERROR_UNKNOWN;
        }
        return NSERROR_UNKNOWN;
}
 
 
static void ignore_dom_msg(uint32_t severity, void *ctx, const char *msg, ...)
{
}
 
 
 
/**
 * Dump attribute/value for an element node
 *
 * \param node  The element node to dump attribute details for
 * \param f file handle to dump to.
 * \param attribute The attribute to dump
 * \return true on success, or false on error
 */
static bool dump_dom_element_attribute(dom_node *node, FILE *f, const char *attribute)
{
        dom_exception exc;
        dom_string *attr = NULL;
        dom_string *attr_value = NULL;
        dom_node_type type;
        const char *string;
        size_t length;
 
        /* Should only have element nodes here */
        exc = dom_node_get_node_type(node, &type);
        if (exc != DOM_NO_ERR) {
                fprintf(f, " Exception raised for node_get_node_type\n");
                return false;
        }
        assert(type == DOM_ELEMENT_NODE);
 
        /* Create a dom_string containing required attribute name. */
        exc = dom_string_create_interned((uint8_t *)attribute,
                                         strlen(attribute), &attr);
        if (exc != DOM_NO_ERR) {
                fprintf(f, " Exception raised for dom_string_create\n");
                return false;
        }
 
        /* Get class attribute's value */
        exc = dom_element_get_attribute(node, attr, &attr_value);
        if (exc != DOM_NO_ERR) {
                fprintf(f, " Exception raised for element_get_attribute\n");
                dom_string_unref(attr);
                return false;
        } else if (attr_value == NULL) {
                /* Element lacks required attribute */
                dom_string_unref(attr);
                return true;
        }
 
        /* Finished with the attr dom_string */
        dom_string_unref(attr);
 
        /* Get attribute value's string data */
        string = dom_string_data(attr_value);
        length = dom_string_byte_length(attr_value);
 
        /* Print attribute info */
        fprintf(f, " %s=\"%.*s\"", attribute, (int)length, string);
 
        /* Finished with the attr_value dom_string */
        dom_string_unref(attr_value);
 
        return true;
}
 
 
/**
 * Print a line in a DOM structure dump for an element
 *
 * \param node   The node to dump
 * \param f file handle to dump to.
 * \param depth  The node's depth
 * \return  true on success, or false on error
 */
static bool dump_dom_element(dom_node *node, FILE *f, int depth)
{
        dom_exception exc;
        dom_string *node_name = NULL;
        dom_node_type type;
        int i;
        const char *string;
        size_t length;
 
        /* Only interested in element nodes */
        exc = dom_node_get_node_type(node, &type);
        if (exc != DOM_NO_ERR) {
                fprintf(f, "Exception raised for node_get_node_type\n");
                return false;
        } else if (type != DOM_ELEMENT_NODE) {
                /* Nothing to print */
                return true;
        }
 
        /* Get element name */
        exc = dom_node_get_node_name(node, &node_name);
        if (exc != DOM_NO_ERR) {
                fprintf(f, "Exception raised for get_node_name\n");
                return false;
        } else if (node_name == NULL) {
                fprintf(f, "Broken: root_name == NULL\n");
                return false;
        }
 
        /* Print ASCII tree structure for current node */
        if (depth > 0) {
                for (i = 0; i < depth; i++) {
                        fprintf(f, "| ");
                }
                fprintf(f, "+-");
        }
 
        /* Get string data and print element name */
        string = dom_string_data(node_name);
        length = dom_string_byte_length(node_name);
        fprintf(f, "[%.*s]", (int)length, string);
 
        if (length == 5 && strncmp(string, "title", 5) == 0) {
                /* Title tag, gather the title */
                dom_string *str;
                exc = dom_node_get_text_content(node, &str);
                if (exc == DOM_NO_ERR && str != NULL) {
                        fprintf(f, " $%.*s$", (int)dom_string_byte_length(str),
                                dom_string_data(str));
                        dom_string_unref(str);
                }
        }
 
        /* Finished with the node_name dom_string */
        dom_string_unref(node_name);
 
        /* Print the element's id & class, if it has them */
        if (dump_dom_element_attribute(node, f, "id") == false ||
            dump_dom_element_attribute(node, f, "class") == false) {
                /* Error occured */
                fprintf(f, "\n");
                return false;
        }
 
        fprintf(f, "\n");
        return true;
}
 
 
/* exported interface documented in libdom.h */
nserror libdom_dump_structure(dom_node *node, FILE *f, int depth)
{
        dom_exception exc;
        dom_node *child;
        nserror ret;
        dom_node *next_child;
 
        /* Print this node's entry */
        if (dump_dom_element(node, f, depth) == false) {
                /* There was an error; return */
                return NSERROR_DOM;
        }
 
        /* Get the node's first child */
        exc = dom_node_get_first_child(node, &child);
        if (exc != DOM_NO_ERR) {
                fprintf(f, "Exception raised for node_get_first_child\n");
                return NSERROR_DOM;
        } else if (child != NULL) {
                /* node has children;  decend to children's depth */
                depth++;
 
                /* Loop though all node's children */
                do {
                        /* Visit node's descendents */
                        ret = libdom_dump_structure(child, f, depth);
                        if (ret !=NSERROR_OK) {
                                /* There was an error; return */
                                dom_node_unref(child);
                                return NSERROR_DOM;
                        }
 
                        /* Go to next sibling */
                        exc = dom_node_get_next_sibling(child, &next_child);
                        if (exc != DOM_NO_ERR) {
                                fprintf(f, "Exception raised for node_get_next_sibling\n");
                                dom_node_unref(child);
                                return NSERROR_DOM;
                        }
 
                        dom_node_unref(child);
                        child = next_child;
                } while (child != NULL); /* No more children */
        }
 
        return NSERROR_OK;
}
 
 
/* exported interface documented in libdom.h */
nserror libdom_parse_file(const char *filename, const char *encoding, dom_document **doc)
{
        dom_hubbub_parser_params parse_params;
        dom_hubbub_error error;
        dom_hubbub_parser *parser;
        dom_document *document;
        FILE *fp = NULL;
#define BUF_SIZE 512
        uint8_t buf[BUF_SIZE];
 
        fp = fopen(filename, "r");
        if (fp == NULL) {
                return NSERROR_NOT_FOUND;
        }
 
        parse_params.enc = encoding;
        parse_params.fix_enc = false;
        parse_params.enable_script = false;
        parse_params.msg = ignore_dom_msg;
        parse_params.script = NULL;
        parse_params.ctx = NULL;
        parse_params.daf = NULL;
 
        error = dom_hubbub_parser_create(&parse_params, &parser, &document);
        if (error != DOM_HUBBUB_OK) {
                fclose(fp);
                return libdom_hubbub_error_to_nserror(error);
        }
 
        while (feof(fp) == 0) {
                size_t read = fread(buf, sizeof(buf[0]), BUF_SIZE, fp);
 
                error = dom_hubbub_parser_parse_chunk(parser, buf, read);
                if (error != DOM_HUBBUB_OK) {
                        dom_node_unref(document);
                        dom_hubbub_parser_destroy(parser);
                        fclose(fp);
                        return NSERROR_DOM;
                }
        }
 
        error = dom_hubbub_parser_completed(parser);
        if (error != DOM_HUBBUB_OK) {
                dom_node_unref(document);
                dom_hubbub_parser_destroy(parser);
                fclose(fp);
                return libdom_hubbub_error_to_nserror(error);
        }
 
        dom_hubbub_parser_destroy(parser);
        fclose(fp);
 
        *doc = document;
        return NSERROR_OK;
}