kolibrios/programs/network/netsurf/libdom/bindings/xml/libxml_xmlparser.c
Dmitry Pereverzev (SoUrcerer) 370da47fa0 Netsurf initial port (still needs native ui and cURL)
git-svn-id: svn://kolibrios.org@3584 a494cfbc-eb01-0410-851d-a64ba20cac60
2013-06-01 17:14:14 +00:00

1336 lines
36 KiB
C

/*
* This file is part of libdom.
* Licensed under the MIT License,
* http://www.opensource.org/licenses/mit-license.php
* Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org>
*/
#include <stdbool.h>
#include <string.h>
#include <assert.h>
#include <libxml/parser.h>
#include <libxml/SAX2.h>
#include <libxml/xmlerror.h>
#include <dom/dom.h>
#include <libwapcaplet/libwapcaplet.h>
#include "xmlerror.h"
#include "xmlparser.h"
#include "utils.h"
#include "core/document.h"
static void xml_parser_start_document(void *ctx);
static void xml_parser_end_document(void *ctx);
static void xml_parser_start_element_ns(void *ctx, const xmlChar *localname,
const xmlChar *prefix, const xmlChar *URI,
int nb_namespaces, const xmlChar **namespaces,
int nb_attributes, int nb_defaulted,
const xmlChar **attributes);
static void xml_parser_end_element_ns(void *ctx, const xmlChar *localname,
const xmlChar *prefix, const xmlChar *URI);
static dom_exception xml_parser_link_nodes(dom_xml_parser *parser,
struct dom_node *dom, xmlNodePtr xml);
static void xml_parser_add_node(dom_xml_parser *parser, struct dom_node *parent,
xmlNodePtr child);
static void xml_parser_add_element_node(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child);
static void xml_parser_add_text_node(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child);
static void xml_parser_add_cdata_section(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child);
static void xml_parser_add_entity_reference(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child);
static void xml_parser_add_entity(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child);
static void xml_parser_add_comment(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child);
static void xml_parser_add_document_type(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child);
static void xml_parser_internal_subset(void *ctx, const xmlChar *name,
const xmlChar *ExternalID, const xmlChar *SystemID);
static int xml_parser_is_standalone(void *ctx);
static int xml_parser_has_internal_subset(void *ctx);
static int xml_parser_has_external_subset(void *ctx);
static xmlParserInputPtr xml_parser_resolve_entity(void *ctx,
const xmlChar *publicId, const xmlChar *systemId);
static xmlEntityPtr xml_parser_get_entity(void *ctx, const xmlChar *name);
static void xml_parser_entity_decl(void *ctx, const xmlChar *name,
int type, const xmlChar *publicId, const xmlChar *systemId,
xmlChar *content);
static void xml_parser_notation_decl(void *ctx, const xmlChar *name,
const xmlChar *publicId, const xmlChar *systemId);
static void xml_parser_attribute_decl(void *ctx, const xmlChar *elem,
const xmlChar *fullname, int type, int def,
const xmlChar *defaultValue, xmlEnumerationPtr tree);
static void xml_parser_element_decl(void *ctx, const xmlChar *name,
int type, xmlElementContentPtr content);
static void xml_parser_unparsed_entity_decl(void *ctx, const xmlChar *name,
const xmlChar *publicId, const xmlChar *systemId,
const xmlChar *notationName);
static void xml_parser_set_document_locator(void *ctx, xmlSAXLocatorPtr loc);
static void xml_parser_reference(void *ctx, const xmlChar *name);
static void xml_parser_characters(void *ctx, const xmlChar *ch, int len);
static void xml_parser_comment(void *ctx, const xmlChar *value);
static xmlEntityPtr xml_parser_get_parameter_entity(void *ctx,
const xmlChar *name);
static void xml_parser_cdata_block(void *ctx, const xmlChar *value, int len);
static void xml_parser_external_subset(void *ctx, const xmlChar *name,
const xmlChar *ExternalID, const xmlChar *SystemID);
/**
* libdom XML parser object
*/
struct dom_xml_parser {
xmlParserCtxtPtr xml_ctx; /**< libxml parser context */
struct dom_document *doc; /**< DOM Document we're building */
dom_string *udkey; /**< Key for DOM node user data */
dom_msg msg; /**< Informational message function */
void *mctx; /**< Pointer to client data */
};
/**
* SAX callback dispatch table
*/
static xmlSAXHandler sax_handler = {
.internalSubset = xml_parser_internal_subset,
.isStandalone = xml_parser_is_standalone,
.hasInternalSubset = xml_parser_has_internal_subset,
.hasExternalSubset = xml_parser_has_external_subset,
.resolveEntity = xml_parser_resolve_entity,
.getEntity = xml_parser_get_entity,
.entityDecl = xml_parser_entity_decl,
.notationDecl = xml_parser_notation_decl,
.attributeDecl = xml_parser_attribute_decl,
.elementDecl = xml_parser_element_decl,
.unparsedEntityDecl = xml_parser_unparsed_entity_decl,
.setDocumentLocator = xml_parser_set_document_locator,
.startDocument = xml_parser_start_document,
.endDocument = xml_parser_end_document,
.startElement = NULL,
.endElement = NULL,
.reference = xml_parser_reference,
.characters = xml_parser_characters,
.ignorableWhitespace = xml_parser_characters,
.processingInstruction = NULL,
.comment = xml_parser_comment,
.warning = NULL,
.error = NULL,
.fatalError = NULL,
.getParameterEntity = xml_parser_get_parameter_entity,
.cdataBlock = xml_parser_cdata_block,
.externalSubset = xml_parser_external_subset,
.initialized = XML_SAX2_MAGIC,
._private = NULL,
.startElementNs = xml_parser_start_element_ns,
.endElementNs = xml_parser_end_element_ns,
.serror = NULL
};
static void *dom_xml_alloc(void *ptr, size_t len, void *pw)
{
UNUSED(pw);
if (ptr == NULL)
return len > 0 ? malloc(len) : NULL;
if (len == 0) {
free(ptr);
return NULL;
}
return realloc(ptr, len);
}
/**
* Create an XML parser instance
*
* \param enc Source charset, or NULL
* \param int_enc Desired charset of document buffer (UTF-8 or UTF-16)
* \param msg Informational message function
* \param mctx Pointer to client-specific private data
* \return Pointer to instance, or NULL on memory exhaustion
*
* Neither ::enc nor ::int_enc are used here.
* libxml only supports a UTF-8 document buffer and forcibly setting the
* parser encoding is not yet implemented
*/
dom_xml_parser *dom_xml_parser_create(const char *enc, const char *int_enc,
dom_msg msg, void *mctx, dom_document **document)
{
dom_xml_parser *parser;
dom_exception err;
int ret;
UNUSED(enc);
UNUSED(int_enc);
parser = dom_xml_alloc(NULL, sizeof(dom_xml_parser), NULL);
if (parser == NULL) {
msg(DOM_MSG_CRITICAL, mctx, "No memory for parser");
return NULL;
}
parser->xml_ctx =
xmlCreatePushParserCtxt(&sax_handler, parser, "", 0, NULL);
if (parser->xml_ctx == NULL) {
dom_xml_alloc(parser, 0, NULL);
msg(DOM_MSG_CRITICAL, mctx, "Failed to create XML parser");
return NULL;
}
/* Set options of parsing context */
ret = xmlCtxtUseOptions(parser->xml_ctx, XML_PARSE_DTDATTR |
XML_PARSE_DTDLOAD);
if (ret != 0) {
xmlFreeParserCtxt(parser->xml_ctx);
dom_xml_alloc(parser, 0, NULL);
msg(DOM_MSG_CRITICAL, mctx, "Failed setting parser options");
return NULL;
}
/* Create key for user data registration */
err = dom_string_create((const uint8_t *) "__xmlnode",
SLEN("__xmlnode"), &parser->udkey);
if (err != DOM_NO_ERR) {
xmlFreeParserCtxt(parser->xml_ctx);
dom_xml_alloc(parser, 0, NULL);
msg(DOM_MSG_CRITICAL, mctx, "No memory for userdata key");
return NULL;
}
err = dom_implementation_create_document(
DOM_IMPLEMENTATION_XML,
/* namespace */ NULL,
/* qname */ NULL,
/* doctype */ NULL,
NULL,
NULL,
document);
if (err != DOM_NO_ERR) {
xmlFreeParserCtxt(parser->xml_ctx);
dom_string_unref(parser->udkey);
dom_xml_alloc(parser, 0, NULL);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"Failed creating document");
return NULL;
}
parser->doc = (dom_document *) dom_node_ref(*document);
parser->msg = msg;
parser->mctx = mctx;
return parser;
}
/**
* Destroy an XML parser instance
*
* \param parser The parser instance to destroy
*/
void dom_xml_parser_destroy(dom_xml_parser *parser)
{
dom_string_unref(parser->udkey);
dom_node_unref(parser->doc);
xmlFreeDoc(parser->xml_ctx->myDoc);
xmlFreeParserCtxt(parser->xml_ctx);
dom_xml_alloc(parser, 0, NULL);
}
/**
* Parse a chunk of data
*
* \param parser The XML parser instance to use for parsing
* \param data Pointer to data chunk
* \param len Byte length of data chunk
* \return DOM_XML_OK on success, DOM_XML_EXTERNAL_ERR | <libxml error> on failure
*/
dom_xml_error dom_xml_parser_parse_chunk(dom_xml_parser *parser,
uint8_t *data, size_t len)
{
xmlParserErrors err;
err = xmlParseChunk(parser->xml_ctx, (char *) data, len, 0);
if (err != XML_ERR_OK) {
parser->msg(DOM_MSG_ERROR, parser->mctx,
"xmlParseChunk failed: %d", err);
return DOM_XML_EXTERNAL_ERR | err;
}
return DOM_XML_OK;
}
/**
* Notify parser that datastream is empty
*
* \param parser The XML parser instance to notify
* \return DOM_XML_OK on success, DOM_XML_EXTERNAL_ERR | <libxml error> on failure
*
* This will force any remaining data through the parser
*/
dom_xml_error dom_xml_parser_completed(dom_xml_parser *parser)
{
xmlParserErrors err;
err = xmlParseChunk(parser->xml_ctx, "", 0, 1);
if (err != XML_ERR_OK) {
parser->msg(DOM_MSG_ERROR, parser->mctx,
"xmlParseChunk failed: %d", err);
return DOM_XML_EXTERNAL_ERR | err;
}
return DOM_XML_OK;
}
/**
* Handle a document start SAX event
*
* \param ctx The callback context
*/
void xml_parser_start_document(void *ctx)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
dom_exception err;
/* Invoke libxml2's default behaviour */
xmlSAX2StartDocument(parser->xml_ctx);
/* Link nodes together */
err = xml_parser_link_nodes(parser, (struct dom_node *) parser->doc,
(xmlNodePtr) parser->xml_ctx->myDoc);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_WARNING, parser->mctx,
"Not able to link document nodes");
}
}
/**
* Handle a document end SAX event
*
* \param ctx The callback context
*/
void xml_parser_end_document(void *ctx)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlNodePtr node;
xmlNodePtr n;
dom_exception err;
/* Invoke libxml2's default behaviour */
xmlSAX2EndDocument(parser->xml_ctx);
/* If there is no document, we can't do anything */
if (parser->doc == NULL) {
parser->msg(DOM_MSG_WARNING, parser->mctx,
"No document in end_document");
return;
}
/* We need to mirror any child nodes at the end of the list of
* children which occur after the last Element node in the list */
/* Get XML node */
err = dom_node_get_user_data((struct dom_node *) parser->doc,
parser->udkey, (void **) (void *) &node);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_WARNING, parser->mctx,
"Failed finding XML node");
return;
}
/* Find last Element node, if any */
for (n = node->last; n != NULL; n = n->prev) {
if (n->type == XML_ELEMENT_NODE)
break;
}
if (n == NULL) {
/* No Element node found; entire list needs mirroring */
n = node->children;
} else {
/* Found last Element; skip over it */
n = n->next;
}
/* Now, mirror nodes in the DOM */
for (; n != NULL; n = n->next) {
xml_parser_add_node(parser,
(struct dom_node *) node->_private, n);
}
}
/**
* Handle an element open SAX event
*
* \param ctx The callback context
* \param localname The local name of the element
* \param prefix The element namespace prefix
* \param URI The element namespace URI
* \param nb_namespaces The number of namespace definitions
* \param namespaces Array of nb_namespaces prefix/URI pairs
* \param nb_attributes The total number of attributes
* \param nb_defaulted The number of defaulted attributes
* \param attributes Array of nb_attributes attribute values
*
* The number of non-defaulted attributes is ::nb_attributes - ::nb_defaulted
* The defaulted attributes are at the end of the array ::attributes.
*/
void xml_parser_start_element_ns(void *ctx, const xmlChar *localname,
const xmlChar *prefix, const xmlChar *URI,
int nb_namespaces, const xmlChar **namespaces,
int nb_attributes, int nb_defaulted,
const xmlChar **attributes)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlNodePtr parent = parser->xml_ctx->node;
/* Invoke libxml2's default behaviour */
xmlSAX2StartElementNs(parser->xml_ctx, localname, prefix, URI,
nb_namespaces, namespaces, nb_attributes,
nb_defaulted, attributes);
/* If there is no document, we can't do anything */
if (parser->doc == NULL) {
parser->msg(DOM_MSG_WARNING, parser->mctx,
"No document in start_element_ns");
return;
}
if (parent == NULL) {
/* No parent; use document */
parent = (xmlNodePtr) parser->xml_ctx->myDoc;
}
if (parent->type == XML_DOCUMENT_NODE ||
parent->type == XML_ELEMENT_NODE) {
/* Mirror in the DOM all children of the parent node
* between the previous Element child (or the start,
* whichever is encountered first) and the Element
* just created */
xmlNodePtr n;
/* Find previous element node, if any */
for (n = parser->xml_ctx->node->prev; n != NULL;
n = n->prev) {
if (n->type == XML_ELEMENT_NODE)
break;
}
if (n == NULL) {
/* No previous Element; use parent's children */
n = parent->children;
} else {
/* Previous Element; skip over it */
n = n->next;
}
/* Now, mirror nodes in the DOM */
for (; n != parser->xml_ctx->node; n = n->next) {
xml_parser_add_node(parser,
(struct dom_node *) parent->_private,
n);
}
}
/* Mirror the created node and its attributes in the DOM */
xml_parser_add_node(parser, (struct dom_node *) parent->_private,
parser->xml_ctx->node);
}
/**
* Handle an element close SAX event
*
* \param ctx The callback context
* \param localname The local name of the element
* \param prefix The element namespace prefix
* \param URI The element namespace URI
*/
void xml_parser_end_element_ns(void *ctx, const xmlChar *localname,
const xmlChar *prefix, const xmlChar *URI)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlNodePtr node = parser->xml_ctx->node;
xmlNodePtr n;
/* Invoke libxml2's default behaviour */
xmlSAX2EndElementNs(parser->xml_ctx, localname, prefix, URI);
/* If there is no document, we can't do anything */
if (parser->doc == NULL) {
parser->msg(DOM_MSG_WARNING, parser->mctx,
"No document in end_element_ns");
return;
}
/* If node wasn't linked, we can't do anything */
if (node->_private == NULL) {
parser->msg(DOM_MSG_WARNING, parser->mctx,
"Node '%s' not linked", node->name);
return;
}
/* We need to mirror any child nodes at the end of the list of
* children which occur after the last Element node in the list */
/* Find last Element node, if any */
for (n = node->last; n != NULL; n = n->prev) {
if (n->type == XML_ELEMENT_NODE)
break;
}
if (n == NULL) {
/* No Element node found; entire list needs mirroring */
n = node->children;
} else {
/* Found last Element; skip over it */
n = n->next;
}
/* Now, mirror nodes in the DOM */
for (; n != NULL; n = n->next) {
xml_parser_add_node(parser,
(struct dom_node *) node->_private, n);
}
}
/**
* Link a DOM and XML node together
*
* \param parser The parser context
* \param dom The DOM node
* \param xml The XML node
* \return DOM_NO_ERR on success, appropriate error otherwise
*/
dom_exception xml_parser_link_nodes(dom_xml_parser *parser,
struct dom_node *dom, xmlNodePtr xml)
{
void *prev_data;
dom_exception err;
/* Register XML node as user data for DOM node */
err = dom_node_set_user_data(dom, parser->udkey, xml, NULL,
&prev_data);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_ERROR, parser->mctx,
"Failed setting user data: %d", err);
return err;
}
/* Register DOM node with the XML node */
xml->_private = dom;
return DOM_NO_ERR;
}
/**
* Add a node to the DOM
*
* \param parser The parser context
* \param parent The parent DOM node
* \param child The xmlNode to mirror in the DOM as a child of parent
*/
void xml_parser_add_node(dom_xml_parser *parser, struct dom_node *parent,
xmlNodePtr child)
{
static const char *node_types[] = {
"THIS_IS_NOT_A_NODE",
"XML_ELEMENT_NODE",
"XML_ATTRIBUTE_NODE",
"XML_TEXT_NODE",
"XML_CDATA_SECTION_NODE",
"XML_ENTITY_REF_NODE",
"XML_ENTITY_NODE",
"XML_PI_NODE",
"XML_COMMENT_NODE",
"XML_DOCUMENT_NODE",
"XML_DOCUMENT_TYPE_NODE",
"XML_DOCUMENT_FRAG_NODE",
"XML_NOTATION_NODE",
"XML_HTML_DOCUMENT_NODE",
"XML_DTD_NODE",
"XML_ELEMENT_DECL",
"XML_ATTRIBUTE_DECL",
"XML_ENTITY_DECL",
"XML_NAMESPACE_DECL",
"XML_XINCLUDE_START",
"XML_XINCLUDE_END",
"XML_DOCB_DOCUMENT_NODE"
};
switch (child->type) {
case XML_ELEMENT_NODE:
xml_parser_add_element_node(parser, parent, child);
break;
case XML_TEXT_NODE:
xml_parser_add_text_node(parser, parent, child);
break;
case XML_CDATA_SECTION_NODE:
xml_parser_add_cdata_section(parser, parent, child);
break;
case XML_ENTITY_REF_NODE:
xml_parser_add_entity_reference(parser, parent, child);
break;
case XML_COMMENT_NODE:
xml_parser_add_comment(parser, parent, child);
break;
case XML_DTD_NODE:
xml_parser_add_document_type(parser, parent, child);
break;
case XML_ENTITY_DECL:
xml_parser_add_entity(parser, parent, child);
break;
default:
parser->msg(DOM_MSG_NOTICE, parser->mctx,
"Unsupported node type: %s",
node_types[child->type]);
}
}
/**
* Add an element node to the DOM
*
* \param parser The parser context
* \param parent The parent DOM node
* \param child The xmlNode to mirror in the DOM as a child of parent
*/
void xml_parser_add_element_node(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child)
{
struct dom_element *el, *ins_el = NULL;
xmlAttrPtr a;
dom_exception err;
/* Create the element node */
if (child->ns == NULL) {
/* No namespace */
dom_string *tag_name;
/* Create tag name DOM string */
err = dom_string_create(child->name,
strlen((const char *) child->name), &tag_name);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for tag name");
return;
}
/* Create element node */
err = dom_document_create_element(parser->doc,
tag_name, &el);
if (err != DOM_NO_ERR) {
dom_string_unref(tag_name);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"Failed creating element '%s'",
child->name);
return;
}
/* No longer need tag name */
dom_string_unref(tag_name);
} else {
/* Namespace */
dom_string *namespace;
dom_string *qname;
size_t qnamelen = (child->ns->prefix != NULL ?
strlen((const char *) child->ns->prefix) : 0) +
(child->ns->prefix != NULL ? 1 : 0) /* ':' */ +
strlen((const char *) child->name);
uint8_t qnamebuf[qnamelen + 1 /* '\0' */];
/* Create namespace DOM string */
err = dom_string_create(
child->ns->href,
strlen((const char *) child->ns->href),
&namespace);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for namespace");
return;
}
/* QName is "prefix:localname",
* or "localname" if there is no prefix */
sprintf((char *) qnamebuf, "%s%s%s",
child->ns->prefix != NULL ?
(const char *) child->ns->prefix : "",
child->ns->prefix != NULL ? ":" : "",
(const char *) child->name);
/* Create qname DOM string */
err = dom_string_create(
qnamebuf,
qnamelen,
&qname);
if (err != DOM_NO_ERR) {
dom_string_unref(namespace);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for qname");
return;
}
/* Create element node */
err = dom_document_create_element_ns(parser->doc,
namespace, qname, &el);
if (err != DOM_NO_ERR) {
dom_string_unref(namespace);
dom_string_unref(qname);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"Failed creating element '%s'",
qnamebuf);
return;
}
/* No longer need namespace / qname */
dom_string_unref(namespace);
dom_string_unref(qname);
}
/* Add attributes to created element */
for (a = child->properties; a != NULL; a = a->next) {
struct dom_attr *attr, *prev_attr;
xmlNodePtr c;
/* Create attribute node */
if (a->ns == NULL) {
/* Attribute has no namespace */
dom_string *name;
/* Create attribute name DOM string */
err = dom_string_create(
a->name,
strlen((const char *) a->name),
&name);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for attribute name");
goto cleanup;
}
/* Create attribute */
err = dom_document_create_attribute(parser->doc,
name, &attr);
if (err != DOM_NO_ERR) {
dom_string_unref(name);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"Failed creating attribute \
'%s'", a->name);
goto cleanup;
}
/* No longer need attribute name */
dom_string_unref(name);
} else {
/* Attribute has namespace */
dom_string *namespace;
dom_string *qname;
size_t qnamelen = (a->ns->prefix != NULL ?
strlen((const char *) a->ns->prefix) : 0) +
(a->ns->prefix != NULL ? 1 : 0) /* ':' */ +
strlen((const char *) a->name);
uint8_t qnamebuf[qnamelen + 1 /* '\0' */];
/* Create namespace DOM string */
err = dom_string_create(
a->ns->href,
strlen((const char *) a->ns->href),
&namespace);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for namespace");
return;
}
/* QName is "prefix:localname",
* or "localname" if there is no prefix */
sprintf((char *) qnamebuf, "%s%s%s",
a->ns->prefix != NULL ?
(const char *) a->ns->prefix : "",
a->ns->prefix != NULL ? ":" : "",
(const char *) a->name);
/* Create qname DOM string */
err = dom_string_create(
qnamebuf,
qnamelen,
&qname);
if (err != DOM_NO_ERR) {
dom_string_unref(namespace);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for qname");
return;
}
/* Create attribute */
err = dom_document_create_attribute_ns(parser->doc,
namespace, qname, &attr);
if (err != DOM_NO_ERR) {
dom_string_unref(namespace);
dom_string_unref(qname);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"Failed creating attribute \
'%s'", qnamebuf);
return;
}
/* No longer need namespace / qname */
dom_string_unref(namespace);
dom_string_unref(qname);
}
/* Clone subtree (attribute value) */
for (c = a->children; c != NULL; c = c->next) {
xml_parser_add_node(parser,
(struct dom_node *) attr, c);
}
/* Link nodes together */
err = xml_parser_link_nodes(parser,
(struct dom_node *) attr, (xmlNodePtr) a);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) attr);
goto cleanup;
}
if (a->ns == NULL) {
/* And add attribute to the element */
err = dom_element_set_attribute_node(el, attr,
&prev_attr);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) attr);
parser->msg(DOM_MSG_ERROR, parser->mctx,
"Failed attaching attribute \
'%s'", a->name);
goto cleanup;
}
} else {
err = dom_element_set_attribute_node_ns(el, attr,
&prev_attr);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) attr);
parser->msg(DOM_MSG_ERROR, parser->mctx,
"Failed attaching attribute \
'%s'", a->name);
goto cleanup;
}
}
/* We're not interested in the previous attribute (if any) */
if (prev_attr != NULL && prev_attr != attr)
dom_node_unref((struct dom_node *) prev_attr);
/* We're no longer interested in the attribute node */
dom_node_unref((struct dom_node *) attr);
}
/* Append element to parent */
err = dom_node_append_child(parent, (struct dom_node *) el,
(struct dom_node **) (void *) &ins_el);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_ERROR, parser->mctx,
"Failed attaching element '%s'",
child->name);
goto cleanup;
}
/* We're not interested in the inserted element */
if (ins_el != NULL)
dom_node_unref((struct dom_node *) ins_el);
/* Link nodes together */
err = xml_parser_link_nodes(parser, (struct dom_node *) el,
child);
if (err != DOM_NO_ERR) {
goto cleanup;
}
/* No longer interested in element node */
dom_node_unref((struct dom_node *) el);
return;
cleanup:
/* No longer want node (any attributes attached to it
* will be cleaned up with it) */
dom_node_unref((struct dom_node *) el);
return;
}
/**
* Add a text node to the DOM
*
* \param parser The parser context
* \param parent The parent DOM node
* \param child The xmlNode to mirror in the DOM as a child of parent
*/
void xml_parser_add_text_node(dom_xml_parser *parser, struct dom_node *parent,
xmlNodePtr child)
{
struct dom_text *text, *ins_text = NULL;
dom_string *data;
dom_exception err;
/* Create DOM string data for text node */
err = dom_string_create(child->content,
strlen((const char *) child->content), &data);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for text node contents ");
return;
}
/* Create text node */
err = dom_document_create_text_node(parser->doc, data, &text);
if (err != DOM_NO_ERR) {
dom_string_unref(data);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for text node");
return;
}
/* No longer need data */
dom_string_unref(data);
/* Append text node to parent */
err = dom_node_append_child(parent, (struct dom_node *) text,
(struct dom_node **) (void *) &ins_text);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) text);
parser->msg(DOM_MSG_ERROR, parser->mctx,
"Failed attaching text node");
return;
}
/* We're not interested in the inserted text node */
if (ins_text != NULL)
dom_node_unref((struct dom_node *) ins_text);
/* Link nodes together */
err = xml_parser_link_nodes(parser, (struct dom_node *) text,
child);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) text);
return;
}
/* No longer interested in text node */
dom_node_unref((struct dom_node *) text);
}
/**
* Add a cdata section to the DOM
*
* \param parser The parser context
* \param parent The parent DOM node
* \param child The xmlNode to mirror in the DOM as a child of parent
*/
void xml_parser_add_cdata_section(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child)
{
struct dom_cdata_section *cdata, *ins_cdata = NULL;
dom_string *data;
dom_exception err;
/* Create DOM string data for cdata section */
err = dom_string_create(child->content,
strlen((const char *) child->content), &data);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for cdata section contents");
return;
}
/* Create cdata section */
err = dom_document_create_cdata_section(parser->doc, data, &cdata);
if (err != DOM_NO_ERR) {
dom_string_unref(data);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for cdata section");
return;
}
/* No longer need data */
dom_string_unref(data);
/* Append cdata section to parent */
err = dom_node_append_child(parent, (struct dom_node *) cdata,
(struct dom_node **) (void *) &ins_cdata);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) cdata);
parser->msg(DOM_MSG_ERROR, parser->mctx,
"Failed attaching cdata section");
return;
}
/* We're not interested in the inserted cdata section */
if (ins_cdata != NULL)
dom_node_unref((struct dom_node *) ins_cdata);
/* Link nodes together */
err = xml_parser_link_nodes(parser, (struct dom_node *) cdata,
child);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) cdata);
return;
}
/* No longer interested in cdata section */
dom_node_unref((struct dom_node *) cdata);
}
/**
* Add an entity reference to the DOM
*
* \param parser The parser context
* \param parent The parent DOM node
* \param child The xmlNode to mirror in the DOM as a child of parent
*/
void xml_parser_add_entity_reference(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child)
{
struct dom_entity_reference *entity, *ins_entity = NULL;
dom_string *name;
xmlNodePtr c;
dom_exception err;
/* Create name of entity reference */
err = dom_string_create(child->name,
strlen((const char *) child->name), &name);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for entity reference name");
return;
}
/* Create text node */
err = dom_document_create_entity_reference(parser->doc, name,
&entity);
if (err != DOM_NO_ERR) {
dom_string_unref(name);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for entity reference");
return;
}
/* No longer need name */
dom_string_unref(name);
/* Mirror subtree (reference value) */
for (c = child->children; c != NULL; c = c->next) {
xml_parser_add_node(parser, (struct dom_node *) entity, c);
}
/* Append entity reference to parent */
err = dom_node_append_child(parent, (struct dom_node *) entity,
(struct dom_node **) (void *) &ins_entity);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) entity);
parser->msg(DOM_MSG_ERROR, parser->mctx,
"Failed attaching entity reference");
return;
}
/* We're not interested in the inserted entity reference */
if (ins_entity != NULL)
dom_node_unref((struct dom_node *) ins_entity);
/* Link nodes together */
err = xml_parser_link_nodes(parser, (struct dom_node *) entity,
child);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) entity);
return;
}
/* No longer interested in entity reference */
dom_node_unref((struct dom_node *) entity);
}
static void xml_parser_add_entity(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child)
{
UNUSED(parser);
UNUSED(parent);
UNUSED(child);
}
/**
* Add a comment to the DOM
*
* \param parser The parser context
* \param parent The parent DOM node
* \param child The xmlNode to mirror in the DOM as a child of parent
*/
void xml_parser_add_comment(dom_xml_parser *parser, struct dom_node *parent,
xmlNodePtr child)
{
struct dom_comment *comment, *ins_comment = NULL;
dom_string *data;
dom_exception err;
/* Create DOM string data for comment */
err = dom_string_create(child->content,
strlen((const char *) child->content), &data);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for comment data");
return;
}
/* Create comment */
err = dom_document_create_comment(parser->doc, data, &comment);
if (err != DOM_NO_ERR) {
dom_string_unref(data);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"No memory for comment node");
return;
}
/* No longer need data */
dom_string_unref(data);
/* Append comment to parent */
err = dom_node_append_child(parent, (struct dom_node *) comment,
(struct dom_node **) (void *) &ins_comment);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) comment);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"Failed attaching comment node");
return;
}
/* We're not interested in the inserted comment */
if (ins_comment != NULL)
dom_node_unref((struct dom_node *) ins_comment);
/* Link nodes together */
err = xml_parser_link_nodes(parser, (struct dom_node *) comment,
child);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) comment);
return;
}
/* No longer interested in comment */
dom_node_unref((struct dom_node *) comment);
}
/**
* Add a document type to the DOM
*
* \param parser The parser context
* \param parent The parent DOM node
* \param child The xmlNode to mirror in the DOM as a child of parent
*/
void xml_parser_add_document_type(dom_xml_parser *parser,
struct dom_node *parent, xmlNodePtr child)
{
xmlDtdPtr dtd = (xmlDtdPtr) child;
struct dom_document_type *doctype, *ins_doctype = NULL;
const char *qname, *public_id, *system_id;
dom_exception err;
/* Create qname for doctype */
qname = (const char *) dtd->name;
/* Create public ID for doctype */
public_id = dtd->ExternalID != NULL ?
(const char *) dtd->ExternalID : "";
/* Create system ID for doctype */
system_id = dtd->SystemID != NULL ?
(const char *) dtd->SystemID : "";
/* Create doctype */
err = dom_implementation_create_document_type(
qname, public_id, system_id,
&doctype);
if (err != DOM_NO_ERR) {
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"Failed to create document type");
return;
}
/* Add doctype to document */
err = dom_node_append_child(parent, (struct dom_node *) doctype,
(struct dom_node **) (void *) &ins_doctype);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) doctype);
parser->msg(DOM_MSG_CRITICAL, parser->mctx,
"Failed attaching doctype");
return;
}
/* Not interested in inserted node */
if (ins_doctype != NULL)
dom_node_unref((struct dom_node *) ins_doctype);
/* Link nodes together */
err = xml_parser_link_nodes(parser, (struct dom_node *) doctype,
child);
if (err != DOM_NO_ERR) {
dom_node_unref((struct dom_node *) doctype);
return;
}
/* No longer interested in doctype */
dom_node_unref((struct dom_node *) doctype);
}
/* ------------------------------------------------------------------------*/
void xml_parser_internal_subset(void *ctx, const xmlChar *name,
const xmlChar *ExternalID, const xmlChar *SystemID)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2InternalSubset(parser->xml_ctx, name, ExternalID, SystemID);
}
int xml_parser_is_standalone(void *ctx)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
return xmlSAX2IsStandalone(parser->xml_ctx);
}
int xml_parser_has_internal_subset(void *ctx)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
return xmlSAX2HasInternalSubset(parser->xml_ctx);
}
int xml_parser_has_external_subset(void *ctx)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
return xmlSAX2HasExternalSubset(parser->xml_ctx);
}
xmlParserInputPtr xml_parser_resolve_entity(void *ctx,
const xmlChar *publicId, const xmlChar *systemId)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
return xmlSAX2ResolveEntity(parser->xml_ctx, publicId, systemId);
}
xmlEntityPtr xml_parser_get_entity(void *ctx, const xmlChar *name)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
return xmlSAX2GetEntity(parser->xml_ctx, name);
}
void xml_parser_entity_decl(void *ctx, const xmlChar *name,
int type, const xmlChar *publicId, const xmlChar *systemId,
xmlChar *content)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2EntityDecl(parser->xml_ctx, name, type, publicId, systemId,
content);
}
void xml_parser_notation_decl(void *ctx, const xmlChar *name,
const xmlChar *publicId, const xmlChar *systemId)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2NotationDecl(parser->xml_ctx, name, publicId, systemId);
}
void xml_parser_attribute_decl(void *ctx, const xmlChar *elem,
const xmlChar *fullname, int type, int def,
const xmlChar *defaultValue, xmlEnumerationPtr tree)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2AttributeDecl(parser->xml_ctx, elem, fullname, type, def,
defaultValue, tree);
}
void xml_parser_element_decl(void *ctx, const xmlChar *name,
int type, xmlElementContentPtr content)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2ElementDecl(parser->xml_ctx, name, type, content);
}
void xml_parser_unparsed_entity_decl(void *ctx, const xmlChar *name,
const xmlChar *publicId, const xmlChar *systemId,
const xmlChar *notationName)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2UnparsedEntityDecl(parser->xml_ctx, name, publicId,
systemId, notationName);
}
void xml_parser_set_document_locator(void *ctx, xmlSAXLocatorPtr loc)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2SetDocumentLocator(parser->xml_ctx, loc);
}
void xml_parser_reference(void *ctx, const xmlChar *name)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2Reference(parser->xml_ctx, name);
}
void xml_parser_characters(void *ctx, const xmlChar *ch, int len)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2Characters(parser->xml_ctx, ch, len);
}
void xml_parser_comment(void *ctx, const xmlChar *value)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2Comment(parser->xml_ctx, value);
}
xmlEntityPtr xml_parser_get_parameter_entity(void *ctx, const xmlChar *name)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
return xmlSAX2GetParameterEntity(parser->xml_ctx, name);
}
void xml_parser_cdata_block(void *ctx, const xmlChar *value, int len)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2CDataBlock(parser->xml_ctx, value, len);
}
void xml_parser_external_subset(void *ctx, const xmlChar *name,
const xmlChar *ExternalID, const xmlChar *SystemID)
{
dom_xml_parser *parser = (dom_xml_parser *) ctx;
xmlSAX2ExternalSubset(parser->xml_ctx, name, ExternalID, SystemID);
}