mirrors
/
netsurf
mirror of https://github.com/netsurf-browser/netsurf
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
netsurf/utils/libdom.c

559 lines
13 KiB
C
Raw Blame History

/*
* 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 */
bool libdom_treewalk(dom_node *root,
bool (*callback)(dom_node *node, dom_string *name, void *ctx),
void *ctx)
{
dom_node *node;
bool result = true;
node = dom_node_ref(root); /* tree root */
while (node != NULL) {
dom_node *next = NULL;
dom_node_type type;
dom_string *name;
dom_exception exc;
exc = dom_node_get_first_child(node, &next);
if (exc != DOM_NO_ERR) {
dom_node_unref(node);
break;
}
if (next != NULL) {
/* 1. Got children */
dom_node_unref(node);
node = next;
} else {
/* No children; siblings & ancestor's siblings */
while (node != NULL) {
exc = dom_node_get_next_sibling(node, &next);
if (exc != DOM_NO_ERR) {
dom_node_unref(node);
node = NULL;
break;
}
if (next != NULL) {
/* 2. Got sibling */
break;
}
exc = dom_node_get_parent_node(node, &next);
if (exc != DOM_NO_ERR) {
dom_node_unref(node);
node = NULL;
break;
}
/* 3. Try parent */
dom_node_unref(node);
node = next;
}
if (node == NULL)
break;
dom_node_unref(node);
node = next;
}
assert(node != NULL);
exc = dom_node_get_node_type(node, &type);
if ((exc != DOM_NO_ERR) || (type != DOM_ELEMENT_NODE))
continue;
exc = dom_node_get_node_name(node, &name);
if (exc != DOM_NO_ERR)
continue;
result = callback(node, name, ctx);
dom_string_unref(name);
if (result == false) {
break; /* callback caused early termination */
}
}
return result;
}
/* libdom_treewalk context for libdom_find_element */
struct find_element_ctx {
lwc_string *search;
dom_node *found;
};
/* libdom_treewalk callback for libdom_find_element */
static bool libdom_find_element_callback(dom_node *node, dom_string *name,
void *ctx)
{
struct find_element_ctx *data = ctx;
if (dom_string_caseless_lwc_isequal(name, data->search)) {
/* Found element */
data->found = node;
return false; /* Discontinue search */
}
return true; /* Continue search */
}
/* exported interface documented in libdom.h */
dom_node *libdom_find_element(dom_node *node, lwc_string *element_name)
{
struct find_element_ctx data;
assert(element_name != NULL);
if (node == NULL)
return NULL;
data.search = element_name;
data.found = NULL;
libdom_treewalk(node, libdom_find_element_callback, &data);
return data.found;
}
/* 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;
}
Reference in New Issue View Git Blame Copy Permalink