mirror of
https://github.com/netsurf-browser/netsurf
synced 2024-11-23 14:59:47 +03:00
559 lines
13 KiB
C
559 lines
13 KiB
C
/*
|
|
* 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;
|
|
}
|