mirror of
https://gitlab.gnome.org/GNOME/libxml2.git
synced 2025-08-01 10:06:59 +03:00
Fixing #74186, made sure all boolean expressions get fully parenthesized,
* c14n.c: Fixing #74186, made sure all boolean expressions get fully parenthesized, ran indent on the output * configure.in HTMLtree.c SAX.c c14n.c debugXML.c tree.c xpointer.c include/libxml/tree.h: also #74186 related, removed the --with-buffers option, and all the preprocessor conditional sections that were resulting from it. Daniel
This commit is contained in:
Daniel Veillard
@ -1,3 +1,12 @@
|
||||
Mon Mar 11 10:10:30 CET 2002 Daniel Veillard <daniel@veillard.com>
|
||||
|
||||
* c14n.c: Fixing #74186, made sure all boolean expressions
|
||||
get fully parenthesized, ran indent on the output
|
||||
* configure.in HTMLtree.c SAX.c c14n.c debugXML.c tree.c xpointer.c
|
||||
include/libxml/tree.h: also #74186 related, removed the
|
||||
--with-buffers option, and all the preprocessor conditional
|
||||
sections that were resulting from it.
|
||||
|
||||
Sun Mar 10 17:47:58 CET 2002 Daniel Veillard <daniel@veillard.com>
|
||||
|
||||
* valid.c: applied patch from Dodji Seketeli fixing an
|
||||
|
||||
55
HTMLtree.c
55
HTMLtree.c
@ -102,11 +102,7 @@ found_meta:
|
||||
if ((attr->children != NULL) &&
|
||||
(attr->children->type == XML_TEXT_NODE) &&
|
||||
(attr->children->next == NULL)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
value = attr->children->content;
|
||||
#else
|
||||
value = xmlBufferContent(attr->children->content);
|
||||
#endif
|
||||
if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))
|
||||
&& (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
|
||||
http = 1;
|
||||
@ -249,11 +245,7 @@ found_meta:
|
||||
if ((attr->children != NULL) &&
|
||||
(attr->children->type == XML_TEXT_NODE) &&
|
||||
(attr->children->next == NULL)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
value = attr->children->content;
|
||||
#else
|
||||
value = xmlBufferContent(attr->children->content);
|
||||
#endif
|
||||
if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))
|
||||
&& (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
|
||||
http = 1;
|
||||
@ -449,12 +441,7 @@ htmlNodeDumpFormat(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
|
||||
(!xmlStrEqual(cur->parent->name, BAD_CAST "script")))) {
|
||||
xmlChar *buffer;
|
||||
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
buffer = xmlEncodeEntitiesReentrant(doc, cur->content);
|
||||
#else
|
||||
buffer = xmlEncodeEntitiesReentrant(doc,
|
||||
xmlBufferContent(cur->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
xmlBufferWriteCHAR(buf, buffer);
|
||||
xmlFree(buffer);
|
||||
@ -468,11 +455,7 @@ htmlNodeDumpFormat(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
|
||||
if (cur->type == HTML_COMMENT_NODE) {
|
||||
if (cur->content != NULL) {
|
||||
xmlBufferWriteChar(buf, "<!--");
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlBufferWriteCHAR(buf, cur->content);
|
||||
#else
|
||||
xmlBufferWriteCHAR(buf, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
xmlBufferWriteChar(buf, "-->");
|
||||
}
|
||||
return;
|
||||
@ -484,11 +467,7 @@ htmlNodeDumpFormat(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
|
||||
xmlBufferWriteCHAR(buf, cur->name);
|
||||
if (cur->content != NULL) {
|
||||
xmlBufferWriteChar(buf, " ");
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlBufferWriteCHAR(buf, cur->content);
|
||||
#else
|
||||
xmlBufferWriteCHAR(buf, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
}
|
||||
xmlBufferWriteChar(buf, ">");
|
||||
return;
|
||||
@ -501,11 +480,7 @@ htmlNodeDumpFormat(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
|
||||
}
|
||||
if (cur->type == HTML_PRESERVE_NODE) {
|
||||
if (cur->content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlBufferWriteCHAR(buf, cur->content);
|
||||
#else
|
||||
xmlBufferWriteCHAR(buf, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
}
|
||||
return;
|
||||
}
|
||||
@ -553,12 +528,7 @@ htmlNodeDumpFormat(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
|
||||
if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
|
||||
xmlChar *buffer;
|
||||
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
buffer = xmlEncodeEntitiesReentrant(doc, cur->content);
|
||||
#else
|
||||
buffer = xmlEncodeEntitiesReentrant(doc,
|
||||
xmlBufferContent(cur->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
xmlBufferWriteCHAR(buf, buffer);
|
||||
xmlFree(buffer);
|
||||
@ -944,12 +914,7 @@ htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
|
||||
(!xmlStrEqual(cur->parent->name, BAD_CAST "script")))) {
|
||||
xmlChar *buffer;
|
||||
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
buffer = xmlEncodeEntitiesReentrant(doc, cur->content);
|
||||
#else
|
||||
buffer = xmlEncodeEntitiesReentrant(doc,
|
||||
xmlBufferContent(cur->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
xmlOutputBufferWriteString(buf, (const char *)buffer);
|
||||
xmlFree(buffer);
|
||||
@ -963,12 +928,7 @@ htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
|
||||
if (cur->type == HTML_COMMENT_NODE) {
|
||||
if (cur->content != NULL) {
|
||||
xmlOutputBufferWriteString(buf, "<!--");
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlOutputBufferWriteString(buf, (const char *)cur->content);
|
||||
#else
|
||||
xmlOutputBufferWriteString(buf, (const char *)
|
||||
xmlBufferContent(cur->content));
|
||||
#endif
|
||||
xmlOutputBufferWriteString(buf, "-->");
|
||||
}
|
||||
return;
|
||||
@ -980,12 +940,7 @@ htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
|
||||
xmlOutputBufferWriteString(buf, (const char *)cur->name);
|
||||
if (cur->content != NULL) {
|
||||
xmlOutputBufferWriteString(buf, " ");
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlOutputBufferWriteString(buf, (const char *)cur->content);
|
||||
#else
|
||||
xmlOutputBufferWriteString(buf, (const char *)
|
||||
xmlBufferContent(cur->content));
|
||||
#endif
|
||||
}
|
||||
xmlOutputBufferWriteString(buf, ">");
|
||||
return;
|
||||
@ -998,12 +953,7 @@ htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
|
||||
}
|
||||
if (cur->type == HTML_PRESERVE_NODE) {
|
||||
if (cur->content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlOutputBufferWriteString(buf, (const char *)cur->content);
|
||||
#else
|
||||
xmlOutputBufferWriteString(buf, (const char *)
|
||||
xmlBufferContent(cur->content));
|
||||
#endif
|
||||
}
|
||||
return;
|
||||
}
|
||||
@ -1058,12 +1008,7 @@ htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
|
||||
* invalids to charrefs
|
||||
*/
|
||||
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlOutputBufferWriteString(buf, (const char *) cur->content);
|
||||
#else
|
||||
xmlOutputBufferWriteString(buf,
|
||||
(const char *) xmlBufferContent(cur->content));
|
||||
#endif
|
||||
}
|
||||
if (cur->children != NULL) {
|
||||
if ((format) && (info != NULL) && (!info->isinline) &&
|
||||
|
||||
8
SAX.c
8
SAX.c
@ -1453,18 +1453,15 @@ characters(void *ctx, const xmlChar *ch, int len)
|
||||
if (lastChild == NULL) {
|
||||
/* first node, first time */
|
||||
xmlNodeAddContentLen(ctxt->node, ch, len);
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
if (ctxt->node->children != NULL) {
|
||||
ctxt->nodelen = len;
|
||||
ctxt->nodemem = len + 1;
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
int coalesceText = (lastChild != NULL) &&
|
||||
(lastChild->type == XML_TEXT_NODE) &&
|
||||
(lastChild->name == xmlStringText);
|
||||
if ((coalesceText) && (ctxt->nodemem != 0)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
/*
|
||||
* The whole point of maintaining nodelen and nodemem,
|
||||
* xmlTextConcat is too costly, i.e. compute length,
|
||||
@ -1491,9 +1488,6 @@ characters(void *ctx, const xmlChar *ch, int len)
|
||||
memcpy(&lastChild->content[ctxt->nodelen], ch, len);
|
||||
ctxt->nodelen += len;
|
||||
lastChild->content[ctxt->nodelen] = 0;
|
||||
#else
|
||||
xmlTextConcat(lastChild, ch, len);
|
||||
#endif
|
||||
} else if (coalesceText) {
|
||||
xmlTextConcat(lastChild, ch, len);
|
||||
if (ctxt->node->children != NULL) {
|
||||
@ -1504,12 +1498,10 @@ characters(void *ctx, const xmlChar *ch, int len)
|
||||
/* Mixed content, first time */
|
||||
lastChild = xmlNewTextLen(ch, len);
|
||||
xmlAddChild(ctxt->node, lastChild);
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
if (ctxt->node->children != NULL) {
|
||||
ctxt->nodelen = len;
|
||||
ctxt->nodemem = len + 1;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
288
c14n.c
288
c14n.c
@ -55,10 +55,8 @@ typedef struct _xmlC14NCtx {
|
||||
} xmlC14NCtx, *xmlC14NCtxPtr;
|
||||
|
||||
|
||||
static int xmlC14NProcessNode (xmlC14NCtxPtr ctx,
|
||||
xmlNodePtr cur);
|
||||
static int xmlC14NProcessNodeList (xmlC14NCtxPtr ctx,
|
||||
xmlNodePtr cur);
|
||||
static int xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur);
|
||||
static int xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur);
|
||||
typedef enum {
|
||||
XMLC14N_NORMALIZE_ATTR = 0,
|
||||
XMLC14N_NORMALIZE_COMMENT = 1,
|
||||
@ -94,15 +92,18 @@ static xmlChar* xmlC11NNormalizeString (const xmlChar *input,
|
||||
*
|
||||
* Returns 1 if the node is visible or 0 otherwise.
|
||||
*/
|
||||
|
||||
/* todo: make it a define? */
|
||||
static int
|
||||
xmlC14NIsVisible(xmlC14NCtxPtr ctx, void *node) {
|
||||
xmlC14NIsVisible(xmlC14NCtxPtr ctx, void *node)
|
||||
{
|
||||
/*
|
||||
* If the input is an XPath node-set, then the node-set must explicitly
|
||||
* contain every node to be rendered to the canonical form.
|
||||
*/
|
||||
if(ctx->visible_nodes != NULL &&
|
||||
!xmlXPathNodeSetContains(ctx->visible_nodes, (xmlNodePtr)node)) {
|
||||
if ((ctx->visible_nodes != NULL) &&
|
||||
(!xmlXPathNodeSetContains(ctx->visible_nodes, (xmlNodePtr) node)))
|
||||
{
|
||||
return (0);
|
||||
}
|
||||
|
||||
@ -118,12 +119,16 @@ xmlC14NIsVisible(xmlC14NCtxPtr ctx, void *node) {
|
||||
*
|
||||
* Returns 1 if the node is default or 0 otherwise
|
||||
*/
|
||||
|
||||
/* todo: make it a define? */
|
||||
static int
|
||||
xmlC14NIsXmlNs(xmlNsPtr ns) {
|
||||
return (ns != NULL &&
|
||||
xmlStrEqual(ns->prefix, BAD_CAST "xml") &&
|
||||
xmlStrEqual(ns->href, BAD_CAST "http://www.w3.org/XML/1998/namespace"));
|
||||
xmlC14NIsXmlNs(xmlNsPtr ns)
|
||||
{
|
||||
return ((ns != NULL) &&
|
||||
(xmlStrEqual(ns->prefix, BAD_CAST "xml")) &&
|
||||
(xmlStrEqual(ns->href,
|
||||
BAD_CAST
|
||||
"http://www.w3.org/XML/1998/namespace")));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -136,16 +141,18 @@ xmlC14NIsXmlNs(xmlNsPtr ns) {
|
||||
* Returns 1 if we already wrote this namespace or 0 otherwise
|
||||
*/
|
||||
static int
|
||||
xmlExcC14NIsRendered(xmlC14NCtxPtr ctx, xmlNsPtr ns) {
|
||||
xmlExcC14NIsRendered(xmlC14NCtxPtr ctx, xmlNsPtr ns)
|
||||
{
|
||||
int i;
|
||||
|
||||
if(ctx == NULL || ctx->ns_rendered == NULL || ns == NULL) {
|
||||
if ((ctx == NULL) || (ctx->ns_rendered == NULL) || (ns == NULL)) {
|
||||
return (0);
|
||||
}
|
||||
|
||||
if (ctx->ns_rendered->nodeTab != NULL) {
|
||||
for (i = ctx->ns_rendered->nodeNr - 1; i >= 0; --i) {
|
||||
xmlNsPtr ns1 = (xmlNsPtr) ctx->ns_rendered->nodeTab[i];
|
||||
|
||||
if (xmlStrEqual(ns1->prefix, ns->prefix)) {
|
||||
return (xmlStrEqual(ns1->href, ns->href));
|
||||
}
|
||||
@ -155,7 +162,7 @@ xmlExcC14NIsRendered(xmlC14NCtxPtr ctx, xmlNsPtr ns) {
|
||||
* if the default namespace xmlns="" is not defined yet then
|
||||
* we do not want to print it out
|
||||
*/
|
||||
return(xmlStrlen(ns->prefix) == 0 && xmlStrlen(ns->href) == 0);
|
||||
return ((xmlStrlen(ns->prefix) == 0) && (xmlStrlen(ns->href) == 0));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -168,10 +175,14 @@ xmlExcC14NIsRendered(xmlC14NCtxPtr ctx, xmlNsPtr ns) {
|
||||
* Returns -1 if ns1 < ns2, 0 if ns1 == ns2 or 1 if ns1 > ns2.
|
||||
*/
|
||||
static int
|
||||
xmlC14NNamespacesCompare(xmlNsPtr ns1, xmlNsPtr ns2) {
|
||||
if(ns1 == ns2) return(0);
|
||||
if(ns1 == NULL) return(-1);
|
||||
if(ns2 == NULL) return(1);
|
||||
xmlC14NNamespacesCompare(xmlNsPtr ns1, xmlNsPtr ns2)
|
||||
{
|
||||
if (ns1 == ns2)
|
||||
return (0);
|
||||
if (ns1 == NULL)
|
||||
return (-1);
|
||||
if (ns2 == NULL)
|
||||
return (1);
|
||||
|
||||
return (xmlStrcmp(ns1->prefix, ns2->prefix));
|
||||
}
|
||||
@ -187,9 +198,10 @@ xmlC14NNamespacesCompare(xmlNsPtr ns1, xmlNsPtr ns2) {
|
||||
* Returns 1 on success or 0 on fail.
|
||||
*/
|
||||
static int
|
||||
xmlC14NPrintNamespaces(const xmlNsPtr ns, xmlC14NCtxPtr ctx) {
|
||||
xmlC14NPrintNamespaces(const xmlNsPtr ns, xmlC14NCtxPtr ctx)
|
||||
{
|
||||
|
||||
if(ns == NULL || ctx == NULL) {
|
||||
if ((ns == NULL) || (ctx == NULL)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NPrintNamespace: namespace or context pointer is null\n");
|
||||
@ -249,13 +261,14 @@ xmlC14NPrintNamespaces(const xmlNsPtr ns, xmlC14NCtxPtr ctx) {
|
||||
* Returns 0 on success or -1 on fail.
|
||||
*/
|
||||
static int
|
||||
xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur)
|
||||
{
|
||||
xmlNsPtr ns;
|
||||
xmlListPtr list;
|
||||
xmlNodePtr visible_parent;
|
||||
xmlNsPtr prev;
|
||||
|
||||
if(ctx == NULL || cur == NULL || cur->type != XML_ELEMENT_NODE) {
|
||||
if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NProcessNamespacesAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
|
||||
@ -266,7 +279,8 @@ xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
/*
|
||||
* Create a sorted list to store element namespaces
|
||||
*/
|
||||
list = xmlListCreate(NULL, (xmlListDataCompare)xmlC14NNamespacesCompare);
|
||||
list =
|
||||
xmlListCreate(NULL, (xmlListDataCompare) xmlC14NNamespacesCompare);
|
||||
if (list == NULL) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
@ -277,7 +291,8 @@ xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
|
||||
/* find nearest visible parent */
|
||||
visible_parent = cur->parent;
|
||||
while(visible_parent != NULL && !xmlC14NIsVisible(ctx, visible_parent)) {
|
||||
while ((visible_parent != NULL) &&
|
||||
(!xmlC14NIsVisible(ctx, visible_parent))) {
|
||||
visible_parent = visible_parent->parent;
|
||||
}
|
||||
|
||||
@ -293,7 +308,7 @@ xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
* first of all ignore default "xml" namespace and
|
||||
* already included namespace
|
||||
*/
|
||||
if(xmlC14NIsXmlNs(ns) || xmlListSearch(list, ns) != NULL) {
|
||||
if ((xmlC14NIsXmlNs(ns)) || (xmlListSearch(list, ns) != NULL)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -308,9 +323,11 @@ xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
* and empty href)
|
||||
*/
|
||||
prev = xmlSearchNs(ctx->doc, visible_parent, ns->prefix);
|
||||
if(prev == NULL && (xmlStrlen(ns->prefix) > 0 || xmlStrlen(ns->href) > 0)) {
|
||||
if ((prev == NULL) && ((xmlStrlen(ns->prefix) > 0) ||
|
||||
(xmlStrlen(ns->href) > 0))) {
|
||||
xmlListInsert(list, ns);
|
||||
} else if(prev != NULL && !xmlStrEqual(ns->href, prev->href)) {
|
||||
} else if ((prev != NULL)
|
||||
&& (!xmlStrEqual(ns->href, prev->href))) {
|
||||
xmlListInsert(list, ns);
|
||||
}
|
||||
}
|
||||
@ -320,7 +337,8 @@ xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
/*
|
||||
* print out all elements from list
|
||||
*/
|
||||
xmlListWalk(list, (xmlListWalker)xmlC14NPrintNamespaces, (const void*)ctx);
|
||||
xmlListWalk(list, (xmlListWalker) xmlC14NPrintNamespaces,
|
||||
(const void *) ctx);
|
||||
|
||||
/*
|
||||
* Cleanup
|
||||
@ -360,12 +378,13 @@ xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
* Returns 0 on success or -1 on fail.
|
||||
*/
|
||||
static int
|
||||
xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur)
|
||||
{
|
||||
xmlListPtr list;
|
||||
xmlAttrPtr attr;
|
||||
xmlNsPtr ns;
|
||||
|
||||
if(ctx == NULL || cur == NULL || cur->type != XML_ELEMENT_NODE) {
|
||||
if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlExcC14NProcessNamespacesAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
|
||||
@ -373,7 +392,7 @@ xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if(!ctx->exclusive || ctx->ns_rendered == NULL) {
|
||||
if ((!ctx->exclusive) || (ctx->ns_rendered == NULL)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlExcC14NProcessNamespacesAxis: called for non-exclusive canonization or rendered stack is NULL.\n");
|
||||
@ -385,7 +404,8 @@ xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
/*
|
||||
* Create a sorted list to store element namespaces
|
||||
*/
|
||||
list = xmlListCreate(NULL, (xmlListDataCompare)xmlC14NNamespacesCompare);
|
||||
list =
|
||||
xmlListCreate(NULL, (xmlListDataCompare) xmlC14NNamespacesCompare);
|
||||
if (list == NULL) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
@ -400,7 +420,8 @@ xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
* todo: do we need to check for default "xml:" namespace
|
||||
*/
|
||||
ns = (cur->ns != NULL) ? cur->ns : xmlSearchNs(ctx->doc, cur, NULL);
|
||||
if(ns != NULL && !xmlC14NIsXmlNs(ns) && xmlListSearch(list, ns) == NULL) {
|
||||
if ((ns != NULL) && (!xmlC14NIsXmlNs(ns)) &&
|
||||
(xmlListSearch(list, ns) == NULL)) {
|
||||
if (!xmlExcC14NIsRendered(ctx, ns)) {
|
||||
xmlListInsert(list, ns);
|
||||
xmlXPathNodeSetAdd(ctx->ns_rendered, (xmlNodePtr) ns);
|
||||
@ -413,10 +434,12 @@ xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
* default namespace
|
||||
*/
|
||||
if (xmlC14NIsVisible(ctx, attr)) {
|
||||
ns = (attr->ns != NULL) ? attr->ns : xmlSearchNs(ctx->doc, cur, NULL);
|
||||
if(ns != NULL && xmlC14NIsVisible(ctx, attr) && !xmlC14NIsXmlNs(ns)) {
|
||||
if(xmlListSearch(list, ns) == NULL &&
|
||||
!xmlExcC14NIsRendered(ctx, ns)) {
|
||||
ns = (attr->ns != NULL) ? attr->ns : xmlSearchNs(ctx->doc, cur,
|
||||
NULL);
|
||||
if ((ns != NULL) && (xmlC14NIsVisible(ctx, attr)) &&
|
||||
(!xmlC14NIsXmlNs(ns))) {
|
||||
if ((xmlListSearch(list, ns) == NULL)
|
||||
&& (!xmlExcC14NIsRendered(ctx, ns))) {
|
||||
xmlListInsert(list, ns);
|
||||
xmlXPathNodeSetAdd(ctx->ns_rendered, (xmlNodePtr) ns);
|
||||
}
|
||||
@ -437,11 +460,12 @@ xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
/*
|
||||
* Special values for namespace with empty prefix
|
||||
*/
|
||||
if(xmlStrEqual(prefix, BAD_CAST "#default") || xmlStrEqual(prefix, BAD_CAST "")) {
|
||||
if (xmlStrEqual(prefix, BAD_CAST "#default")
|
||||
|| xmlStrEqual(prefix, BAD_CAST "")) {
|
||||
prefix = NULL;
|
||||
}
|
||||
ns = xmlSearchNs(ctx->doc, cur, prefix);
|
||||
if(ns != NULL && !xmlC14NIsXmlNs(ns)) {
|
||||
if ((ns != NULL) && (!xmlC14NIsXmlNs(ns))) {
|
||||
if (xmlListSearch(list, ns) == NULL &&
|
||||
!xmlExcC14NIsRendered(ctx, ns)) {
|
||||
xmlListInsert(list, ns);
|
||||
@ -454,7 +478,8 @@ xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
/*
|
||||
* print out all elements from list
|
||||
*/
|
||||
xmlListWalk(list, (xmlListWalker)xmlC14NPrintNamespaces, (const void*)ctx);
|
||||
xmlListWalk(list, (xmlListWalker) xmlC14NPrintNamespaces,
|
||||
(const void *) ctx);
|
||||
|
||||
/*
|
||||
* Cleanup
|
||||
@ -474,15 +499,19 @@ xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
* Returns -1 if attr1 < attr2, 0 if attr1 == attr2 or 1 if attr1 > attr2.
|
||||
*/
|
||||
static int
|
||||
xmlC14NAttrsCompare(xmlAttrPtr attr1, xmlAttrPtr attr2) {
|
||||
xmlC14NAttrsCompare(xmlAttrPtr attr1, xmlAttrPtr attr2)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
/*
|
||||
* Simple cases
|
||||
*/
|
||||
if(attr1 == attr2) return(0);
|
||||
if(attr1 == NULL) return(-1);
|
||||
if(attr2 == NULL) return(1);
|
||||
if (attr1 == attr2)
|
||||
return (0);
|
||||
if (attr1 == NULL)
|
||||
return (-1);
|
||||
if (attr2 == NULL)
|
||||
return (1);
|
||||
if (attr1->ns == attr2->ns) {
|
||||
return (xmlStrcmp(attr1->name, attr2->name));
|
||||
}
|
||||
@ -492,10 +521,14 @@ xmlC14NAttrsCompare(xmlAttrPtr attr1, xmlAttrPtr attr2) {
|
||||
* because the default namespace is not applied to
|
||||
* unqualified attributes
|
||||
*/
|
||||
if(attr1->ns == NULL) return(-1);
|
||||
if(attr2->ns == NULL) return(1);
|
||||
if(attr1->ns->prefix == NULL) return(-1);
|
||||
if(attr2->ns->prefix == NULL) return(1);
|
||||
if (attr1->ns == NULL)
|
||||
return (-1);
|
||||
if (attr2->ns == NULL)
|
||||
return (1);
|
||||
if (attr1->ns->prefix == NULL)
|
||||
return (-1);
|
||||
if (attr2->ns->prefix == NULL)
|
||||
return (1);
|
||||
|
||||
ret = xmlStrcmp(attr1->ns->href, attr2->ns->href);
|
||||
if (ret == 0) {
|
||||
@ -518,11 +551,12 @@ xmlC14NAttrsCompare(xmlAttrPtr attr1, xmlAttrPtr attr2) {
|
||||
* Returns 1 on success or 0 on fail.
|
||||
*/
|
||||
static int
|
||||
xmlC14NPrintAttrs(const xmlAttrPtr attr, xmlC14NCtxPtr ctx) {
|
||||
xmlC14NPrintAttrs(const xmlAttrPtr attr, xmlC14NCtxPtr ctx)
|
||||
{
|
||||
xmlChar *value;
|
||||
xmlChar *buffer;
|
||||
|
||||
if(attr == NULL || ctx == NULL) {
|
||||
if ((attr == NULL) || (ctx == NULL)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NPrintAttrs: attr == NULL or ctx == NULL\n");
|
||||
@ -532,7 +566,8 @@ xmlC14NPrintAttrs(const xmlAttrPtr attr, xmlC14NCtxPtr ctx) {
|
||||
|
||||
xmlOutputBufferWriteString(ctx->buf, " ");
|
||||
if (attr->ns != NULL && xmlStrlen(attr->ns->prefix) > 0) {
|
||||
xmlOutputBufferWriteString(ctx->buf, (const char *) attr->ns->prefix);
|
||||
xmlOutputBufferWriteString(ctx->buf,
|
||||
(const char *) attr->ns->prefix);
|
||||
xmlOutputBufferWriteString(ctx->buf, ":");
|
||||
}
|
||||
xmlOutputBufferWriteString(ctx->buf, (const char *) attr->name);
|
||||
@ -590,11 +625,12 @@ xmlC14NPrintAttrs(const xmlAttrPtr attr, xmlC14NCtxPtr ctx) {
|
||||
* Returns 0 on success or -1 on fail.
|
||||
*/
|
||||
static int
|
||||
xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur)
|
||||
{
|
||||
xmlAttrPtr attr;
|
||||
xmlListPtr list;
|
||||
|
||||
if(ctx == NULL || cur == NULL || cur->type != XML_ELEMENT_NODE) {
|
||||
if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NProcessAttrsAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
|
||||
@ -630,7 +666,8 @@ xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
* include attributes in "xml" namespace defined in ancestors
|
||||
* (only for non-exclusive XML Canonicalization)
|
||||
*/
|
||||
if(!ctx->exclusive && cur->parent != NULL && !xmlC14NIsVisible(ctx, cur->parent)) {
|
||||
if ((!ctx->exclusive) && (cur->parent != NULL)
|
||||
&& (!xmlC14NIsVisible(ctx, cur->parent))) {
|
||||
/*
|
||||
* If XPath node-set is not specified then the parent is always
|
||||
* visible!
|
||||
@ -639,7 +676,8 @@ xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
while (cur != NULL) {
|
||||
attr = cur->properties;
|
||||
while (attr != NULL) {
|
||||
if(attr->ns != NULL && xmlStrEqual(attr->ns->prefix, BAD_CAST "xml")) {
|
||||
if ((attr->ns != NULL)
|
||||
&& (xmlStrEqual(attr->ns->prefix, BAD_CAST "xml"))) {
|
||||
if (xmlListSearch(list, attr) == NULL) {
|
||||
xmlListInsert(list, attr);
|
||||
}
|
||||
@ -653,7 +691,8 @@ xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
/*
|
||||
* print out all elements from list
|
||||
*/
|
||||
xmlListWalk(list, (xmlListWalker)xmlC14NPrintAttrs, (const void*)ctx);
|
||||
xmlListWalk(list, (xmlListWalker) xmlC14NPrintAttrs,
|
||||
(const void *) ctx);
|
||||
|
||||
/*
|
||||
* Cleanup
|
||||
@ -672,10 +711,11 @@ xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
* Returns 0 if the node has no relative namespaces or -1 otherwise.
|
||||
*/
|
||||
static int
|
||||
xmlC14NCheckForRelativeNamespaces(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
xmlC14NCheckForRelativeNamespaces(xmlC14NCtxPtr ctx, xmlNodePtr cur)
|
||||
{
|
||||
xmlNsPtr ns;
|
||||
|
||||
if(ctx == NULL || cur == NULL || cur->type != XML_ELEMENT_NODE) {
|
||||
if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NCheckForRelativeNamespaces: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
|
||||
@ -692,7 +732,8 @@ xmlC14NCheckForRelativeNamespaces(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
if (uri == NULL) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NCheckForRelativeNamespaces: unable to parse uri=\"%s\".\n", ns->href);
|
||||
"xmlC14NCheckForRelativeNamespaces: unable to parse uri=\"%s\".\n",
|
||||
ns->href);
|
||||
#endif
|
||||
return (-1);
|
||||
}
|
||||
@ -700,7 +741,9 @@ xmlC14NCheckForRelativeNamespaces(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
xmlFreeURI(uri);
|
||||
return (-1);
|
||||
}
|
||||
if(!xmlStrEqual((const xmlChar *) uri->scheme, BAD_CAST "urn") && xmlStrlen((const xmlChar *) uri->server) == 0) {
|
||||
if ((!xmlStrEqual
|
||||
((const xmlChar *) uri->scheme, BAD_CAST "urn"))
|
||||
&& (xmlStrlen((const xmlChar *) uri->server) == 0)) {
|
||||
xmlFreeURI(uri);
|
||||
return (-1);
|
||||
}
|
||||
@ -733,11 +776,12 @@ xmlC14NCheckForRelativeNamespaces(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
* Returns non-negative value on success or negative value on fail
|
||||
*/
|
||||
static int
|
||||
xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible) {
|
||||
xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)
|
||||
{
|
||||
int ret;
|
||||
int ns_rendered_pos = 0;
|
||||
|
||||
if(ctx == NULL || cur == NULL || cur->type != XML_ELEMENT_NODE) {
|
||||
if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NProcessElementNode: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
|
||||
@ -763,7 +807,7 @@ xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible) {
|
||||
* Save ns_rendered stack position for exclusive
|
||||
* processing
|
||||
*/
|
||||
if(ctx->exclusive && ctx->ns_rendered != NULL) {
|
||||
if ((ctx->exclusive) && (ctx->ns_rendered != NULL)) {
|
||||
ns_rendered_pos = ctx->ns_rendered->nodeNr;
|
||||
}
|
||||
|
||||
@ -773,8 +817,9 @@ xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible) {
|
||||
}
|
||||
xmlOutputBufferWriteString(ctx->buf, "<");
|
||||
|
||||
if(cur->ns != NULL && xmlStrlen(cur->ns->prefix) > 0) {
|
||||
xmlOutputBufferWriteString(ctx->buf, (const char *)cur->ns->prefix);
|
||||
if ((cur->ns != NULL) && (xmlStrlen(cur->ns->prefix) > 0)) {
|
||||
xmlOutputBufferWriteString(ctx->buf,
|
||||
(const char *) cur->ns->prefix);
|
||||
xmlOutputBufferWriteString(ctx->buf, ":");
|
||||
}
|
||||
xmlOutputBufferWriteString(ctx->buf, (const char *) cur->name);
|
||||
@ -815,8 +860,9 @@ xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible) {
|
||||
}
|
||||
if (visible) {
|
||||
xmlOutputBufferWriteString(ctx->buf, "</");
|
||||
if(cur->ns != NULL && xmlStrlen(cur->ns->prefix) > 0) {
|
||||
xmlOutputBufferWriteString(ctx->buf, (const char *)cur->ns->prefix);
|
||||
if ((cur->ns != NULL) && (xmlStrlen(cur->ns->prefix) > 0)) {
|
||||
xmlOutputBufferWriteString(ctx->buf,
|
||||
(const char *) cur->ns->prefix);
|
||||
xmlOutputBufferWriteString(ctx->buf, ":");
|
||||
}
|
||||
xmlOutputBufferWriteString(ctx->buf, (const char *) cur->name);
|
||||
@ -830,7 +876,7 @@ xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible) {
|
||||
* Restore ns_rendered stack position for exclusive
|
||||
* processing
|
||||
*/
|
||||
if(ctx->exclusive && ctx->ns_rendered != NULL) {
|
||||
if ((ctx->exclusive) && (ctx->ns_rendered != NULL)) {
|
||||
ctx->ns_rendered->nodeNr = ns_rendered_pos;
|
||||
}
|
||||
return (0);
|
||||
@ -846,11 +892,12 @@ xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible) {
|
||||
* Returns non-negative value on success or negative value on fail
|
||||
*/
|
||||
static int
|
||||
xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur)
|
||||
{
|
||||
int ret = 0;
|
||||
int visible;
|
||||
|
||||
if(ctx == NULL || cur == NULL) {
|
||||
if ((ctx == NULL) || (cur == NULL)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NProcessNode: Null context or node pointer.\n");
|
||||
@ -874,16 +921,13 @@ xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
*/
|
||||
/* cdata sections are processed as text nodes */
|
||||
/* todo: verify that cdata sections are included in XPath nodes set */
|
||||
if(visible && cur->content != NULL) {
|
||||
if ((visible) && (cur->content != NULL)) {
|
||||
xmlChar *buffer;
|
||||
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
buffer = xmlC11NNormalizeText(cur->content);
|
||||
#else
|
||||
buffer = xmlC11NNormalizeText(xmlBufferContent(cur->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
xmlOutputBufferWriteString(ctx->buf, (const char *)buffer);
|
||||
xmlOutputBufferWriteString(ctx->buf,
|
||||
(const char *) buffer);
|
||||
xmlFree(buffer);
|
||||
} else {
|
||||
#ifdef DEBUG_C14N
|
||||
@ -914,19 +958,18 @@ xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
xmlOutputBufferWriteString(ctx->buf, "<?");
|
||||
}
|
||||
|
||||
xmlOutputBufferWriteString(ctx->buf, (const char *)cur->name);
|
||||
if(cur->content != NULL && *(cur->content) != '\0') {
|
||||
xmlOutputBufferWriteString(ctx->buf,
|
||||
(const char *) cur->name);
|
||||
if ((cur->content != NULL) && (*(cur->content) != '\0')) {
|
||||
xmlChar *buffer;
|
||||
|
||||
xmlOutputBufferWriteString(ctx->buf, " ");
|
||||
|
||||
/* todo: do we need to normalize pi? */
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
buffer = xmlC11NNormalizePI(cur->content);
|
||||
#else
|
||||
buffer = xmlC11NNormalizePI(xmlBufferContent(cur->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
xmlOutputBufferWriteString(ctx->buf, (const char *)buffer);
|
||||
xmlOutputBufferWriteString(ctx->buf,
|
||||
(const char *) buffer);
|
||||
xmlFree(buffer);
|
||||
} else {
|
||||
#ifdef DEBUG_C14N
|
||||
@ -971,13 +1014,10 @@ xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
xmlChar *buffer;
|
||||
|
||||
/* todo: do we need to normalize comment? */
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
buffer = xmlC11NNormalizeComment(cur->content);
|
||||
#else
|
||||
buffer = xmlC11NNormalizeString(xmlBufferContent(cur->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
xmlOutputBufferWriteString(ctx->buf, (const char *)buffer);
|
||||
xmlOutputBufferWriteString(ctx->buf,
|
||||
(const char *) buffer);
|
||||
xmlFree(buffer);
|
||||
} else {
|
||||
#ifdef DEBUG_C14N
|
||||
@ -1038,7 +1078,8 @@ xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
default:
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NProcessNode: unknown node type = %d\n", cur->type);
|
||||
"xmlC14NProcessNode: unknown node type = %d\n",
|
||||
cur->type);
|
||||
#endif
|
||||
return (-1);
|
||||
}
|
||||
@ -1056,7 +1097,8 @@ xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
* Returns non-negative value on success or negative value on fail
|
||||
*/
|
||||
static int
|
||||
xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (ctx == NULL) {
|
||||
@ -1082,7 +1124,8 @@ xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
|
||||
*/
|
||||
|
||||
static void
|
||||
xmlC14NFreeCtx(xmlC14NCtxPtr ctx) {
|
||||
xmlC14NFreeCtx(xmlC14NCtxPtr ctx)
|
||||
{
|
||||
if (ctx == NULL) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
@ -1120,11 +1163,11 @@ xmlC14NFreeCtx(xmlC14NCtxPtr ctx) {
|
||||
static xmlC14NCtxPtr
|
||||
xmlC14NNewCtx(xmlDocPtr doc, xmlNodeSetPtr nodes,
|
||||
int exclusive, xmlChar ** inclusive_ns_prefixes,
|
||||
int with_comments,
|
||||
xmlOutputBufferPtr buf) {
|
||||
int with_comments, xmlOutputBufferPtr buf)
|
||||
{
|
||||
xmlC14NCtxPtr ctx;
|
||||
|
||||
if(doc == NULL || buf == NULL) {
|
||||
if ((doc == NULL) || (buf == NULL)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NNewCtx: pointer to document or output buffer is NULL\n");
|
||||
@ -1208,12 +1251,12 @@ xmlC14NNewCtx(xmlDocPtr doc, xmlNodeSetPtr nodes,
|
||||
int
|
||||
xmlC14NDocSaveTo(xmlDocPtr doc, xmlNodeSetPtr nodes,
|
||||
int exclusive, xmlChar ** inclusive_ns_prefixes,
|
||||
int with_comments,
|
||||
xmlOutputBufferPtr buf) {
|
||||
int with_comments, xmlOutputBufferPtr buf)
|
||||
{
|
||||
xmlC14NCtxPtr ctx;
|
||||
int ret;
|
||||
|
||||
if(buf == NULL || doc == NULL) {
|
||||
if ((buf == NULL) || (doc == NULL)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NDocSaveTo: null return buffer or doc pointer\n");
|
||||
@ -1305,8 +1348,8 @@ xmlC14NDocSaveTo(xmlDocPtr doc, xmlNodeSetPtr nodes,
|
||||
int
|
||||
xmlC14NDocDumpMemory(xmlDocPtr doc, xmlNodeSetPtr nodes,
|
||||
int exclusive, xmlChar ** inclusive_ns_prefixes,
|
||||
int with_comments,
|
||||
xmlChar **doc_txt_ptr) {
|
||||
int with_comments, xmlChar ** doc_txt_ptr)
|
||||
{
|
||||
int ret;
|
||||
xmlOutputBufferPtr buf;
|
||||
|
||||
@ -1352,7 +1395,7 @@ xmlC14NDocDumpMemory(xmlDocPtr doc, xmlNodeSetPtr nodes,
|
||||
}
|
||||
(void) xmlOutputBufferClose(buf);
|
||||
|
||||
if(*doc_txt_ptr == NULL && ret > 0) {
|
||||
if ((*doc_txt_ptr == NULL) && (ret > 0)) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NDocDumpMemory: failed to allocate memory for document text representation\n");
|
||||
@ -1389,8 +1432,8 @@ xmlC14NDocDumpMemory(xmlDocPtr doc, xmlNodeSetPtr nodes,
|
||||
int
|
||||
xmlC14NDocSave(xmlDocPtr doc, xmlNodeSetPtr nodes,
|
||||
int exclusive, xmlChar ** inclusive_ns_prefixes,
|
||||
int with_comments,
|
||||
const char* filename, int compression) {
|
||||
int with_comments, const char *filename, int compression)
|
||||
{
|
||||
xmlOutputBufferPtr buf;
|
||||
int ret;
|
||||
|
||||
@ -1401,9 +1444,9 @@ xmlC14NDocSave(xmlDocPtr doc, xmlNodeSetPtr nodes,
|
||||
#endif
|
||||
return (-1);
|
||||
}
|
||||
|
||||
#ifdef HAVE_ZLIB_H
|
||||
if(compression < 0) compression = xmlGetCompressMode();
|
||||
if (compression < 0)
|
||||
compression = xmlGetCompressMode();
|
||||
#endif
|
||||
|
||||
/*
|
||||
@ -1413,7 +1456,8 @@ xmlC14NDocSave(xmlDocPtr doc, xmlNodeSetPtr nodes,
|
||||
if (buf == NULL) {
|
||||
#ifdef DEBUG_C14N
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlC14NDocSave: unable to create buffer for file=\"%s\" with compressin=%d\n", filename, compression);
|
||||
"xmlC14NDocSave: unable to create buffer for file=\"%s\" with compressin=%d\n",
|
||||
filename, compression);
|
||||
#endif
|
||||
return (-1);
|
||||
}
|
||||
@ -1467,13 +1511,16 @@ xmlC14NDocSave(xmlDocPtr doc, xmlNodeSetPtr nodes,
|
||||
* or NULL if an error occurs
|
||||
*/
|
||||
static xmlChar *
|
||||
xmlC11NNormalizeString(const xmlChar *input, xmlC14NNormalizationMode mode) {
|
||||
xmlC11NNormalizeString(const xmlChar * input,
|
||||
xmlC14NNormalizationMode mode)
|
||||
{
|
||||
const xmlChar *cur = input;
|
||||
xmlChar *buffer = NULL;
|
||||
xmlChar *out = NULL;
|
||||
int buffer_size = 0;
|
||||
|
||||
if (input == NULL) return(NULL);
|
||||
if (input == NULL)
|
||||
return (NULL);
|
||||
|
||||
/*
|
||||
* allocate an translation buffer.
|
||||
@ -1487,54 +1534,54 @@ xmlC11NNormalizeString(const xmlChar *input, xmlC14NNormalizationMode mode) {
|
||||
out = buffer;
|
||||
|
||||
while (*cur != '\0') {
|
||||
if (out - buffer > buffer_size - 10) {
|
||||
if ((out - buffer) > (buffer_size - 10)) {
|
||||
int indx = out - buffer;
|
||||
|
||||
growBufferReentrant();
|
||||
out = &buffer[indx];
|
||||
}
|
||||
|
||||
if (*cur == '<' && (mode == XMLC14N_NORMALIZE_ATTR ||
|
||||
mode == XMLC14N_NORMALIZE_TEXT)) {
|
||||
if ((*cur == '<') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
|
||||
(mode == XMLC14N_NORMALIZE_TEXT))) {
|
||||
*out++ = '&';
|
||||
*out++ = 'l';
|
||||
*out++ = 't';
|
||||
*out++ = ';';
|
||||
} else if (*cur == '>' && (mode == XMLC14N_NORMALIZE_TEXT)) {
|
||||
} else if ((*cur == '>') && (mode == XMLC14N_NORMALIZE_TEXT)) {
|
||||
*out++ = '&';
|
||||
*out++ = 'g';
|
||||
*out++ = 't';
|
||||
*out++ = ';';
|
||||
} else if (*cur == '&' && (mode == XMLC14N_NORMALIZE_ATTR ||
|
||||
mode == XMLC14N_NORMALIZE_TEXT)) {
|
||||
} else if ((*cur == '&') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
|
||||
(mode == XMLC14N_NORMALIZE_TEXT))) {
|
||||
*out++ = '&';
|
||||
*out++ = 'a';
|
||||
*out++ = 'm';
|
||||
*out++ = 'p';
|
||||
*out++ = ';';
|
||||
} else if (*cur == '"' && (mode == XMLC14N_NORMALIZE_ATTR)) {
|
||||
} else if ((*cur == '"') && (mode == XMLC14N_NORMALIZE_ATTR)) {
|
||||
*out++ = '&';
|
||||
*out++ = 'q';
|
||||
*out++ = 'u';
|
||||
*out++ = 'o';
|
||||
*out++ = 't';
|
||||
*out++ = ';';
|
||||
} else if (*cur == '\x09' && (mode == XMLC14N_NORMALIZE_ATTR)) {
|
||||
} else if ((*cur == '\x09') && (mode == XMLC14N_NORMALIZE_ATTR)) {
|
||||
*out++ = '&';
|
||||
*out++ = '#';
|
||||
*out++ = 'x';
|
||||
*out++ = '9';
|
||||
*out++ = ';';
|
||||
} else if (*cur == '\x0A' && (mode == XMLC14N_NORMALIZE_ATTR)) {
|
||||
} else if ((*cur == '\x0A') && (mode == XMLC14N_NORMALIZE_ATTR)) {
|
||||
*out++ = '&';
|
||||
*out++ = '#';
|
||||
*out++ = 'x';
|
||||
*out++ = 'A';
|
||||
*out++ = ';';
|
||||
} else if (*cur == '\x0D' && (mode == XMLC14N_NORMALIZE_ATTR ||
|
||||
mode == XMLC14N_NORMALIZE_TEXT ||
|
||||
mode == XMLC14N_NORMALIZE_COMMENT ||
|
||||
mode == XMLC14N_NORMALIZE_PI)) {
|
||||
} else if ((*cur == '\x0D') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
|
||||
(mode == XMLC14N_NORMALIZE_TEXT) ||
|
||||
(mode == XMLC14N_NORMALIZE_COMMENT) ||
|
||||
(mode == XMLC14N_NORMALIZE_PI))) {
|
||||
*out++ = '&';
|
||||
*out++ = '#';
|
||||
*out++ = 'x';
|
||||
@ -1552,5 +1599,4 @@ xmlC11NNormalizeString(const xmlChar *input, xmlC14NNormalizationMode mode) {
|
||||
*out++ = 0;
|
||||
return (buffer);
|
||||
}
|
||||
|
||||
#endif /* LIBXML_C14N_ENABLED */
|
||||
|
||||
11
configure.in
11
configure.in
@ -233,17 +233,6 @@ if test "$with_python" != "no" ; then
|
||||
fi
|
||||
AM_CONDITIONAL(WITH_PYTHON, test "$PYTHON_INCLUDES" != "")
|
||||
|
||||
|
||||
dnl
|
||||
dnl Use buffers for content
|
||||
dnl
|
||||
|
||||
AC_ARG_WITH(buffers, [ --with-buffers Use buffers for node content])
|
||||
if test "$with_buffers" = "yes" ; then
|
||||
CFLAGS="${CFLAGS} -DXML_USE_BUFFER_CONTENT"
|
||||
XML_CFLAGS="${XML_CFLAGS} -DXML_USE_BUFFER_CONTENT"
|
||||
fi
|
||||
|
||||
dnl
|
||||
dnl Tester makes use of readline if present
|
||||
dnl
|
||||
|
||||
12
debugXML.c
12
debugXML.c
@ -695,11 +695,7 @@ xmlDebugDumpOneNode(FILE * output, xmlNodePtr node, int depth)
|
||||
shift[2 * i + 2] = shift[2 * i + 3] = 0;
|
||||
fprintf(output, shift);
|
||||
fprintf(output, "content=");
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlDebugDumpString(output, node->content);
|
||||
#else
|
||||
xmlDebugDumpString(output, xmlBufferContent(node->content));
|
||||
#endif
|
||||
fprintf(output, "\n");
|
||||
}
|
||||
} else {
|
||||
@ -1105,11 +1101,7 @@ xmlLsCountNode(xmlNodePtr node) {
|
||||
case XML_PI_NODE:
|
||||
case XML_COMMENT_NODE:
|
||||
if (node->content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
ret = xmlStrlen(node->content);
|
||||
#else
|
||||
ret = xmlBufferLength(node->content);
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
case XML_ENTITY_REF_NODE:
|
||||
@ -1215,11 +1207,7 @@ xmlLsOneNode(FILE *output, xmlNodePtr node) {
|
||||
break;
|
||||
case XML_TEXT_NODE:
|
||||
if (node->content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlDebugDumpString(output, node->content);
|
||||
#else
|
||||
xmlDebugDumpString(output, xmlBufferContent(node->content));
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
case XML_CDATA_SECTION_NODE:
|
||||
|
||||
@ -439,11 +439,7 @@ struct _xmlNode {
|
||||
|
||||
/* End of common part */
|
||||
xmlNs *ns; /* pointer to the associated namespace */
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlChar *content; /* the content */
|
||||
#else
|
||||
xmlBufferPtr content; /* the content in a buffer */
|
||||
#endif
|
||||
struct _xmlAttr *properties;/* properties list */
|
||||
xmlNs *nsDef; /* namespace definitions on this node */
|
||||
};
|
||||
|
||||
241
tree.c
241
tree.c
@ -888,20 +888,11 @@ xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine) {
|
||||
if ((node->type == XML_TEXT_NODE) ||
|
||||
(node->type == XML_CDATA_SECTION_NODE)) {
|
||||
if (inLine) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
ret = xmlStrcat(ret, node->content);
|
||||
#else
|
||||
ret = xmlStrcat(ret, xmlBufferContent(node->content));
|
||||
#endif
|
||||
} else {
|
||||
xmlChar *buffer;
|
||||
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
buffer = xmlEncodeEntitiesReentrant(doc, node->content);
|
||||
#else
|
||||
buffer = xmlEncodeEntitiesReentrant(doc,
|
||||
xmlBufferContent(node->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
ret = xmlStrcat(ret, buffer);
|
||||
xmlFree(buffer);
|
||||
@ -913,11 +904,7 @@ xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine) {
|
||||
if (ent != NULL)
|
||||
ret = xmlStrcat(ret, ent->content);
|
||||
else {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
ret = xmlStrcat(ret, node->content);
|
||||
#else
|
||||
ret = xmlStrcat(ret, xmlBufferContent(node->content));
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
xmlChar buf[2];
|
||||
@ -964,20 +951,11 @@ xmlNodeListGetRawString(xmlDocPtr doc, xmlNodePtr list, int inLine) {
|
||||
if ((node->type == XML_TEXT_NODE) ||
|
||||
(node->type == XML_CDATA_SECTION_NODE)) {
|
||||
if (inLine) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
ret = xmlStrcat(ret, node->content);
|
||||
#else
|
||||
ret = xmlStrcat(ret, xmlBufferContent(node->content));
|
||||
#endif
|
||||
} else {
|
||||
xmlChar *buffer;
|
||||
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
buffer = xmlEncodeSpecialChars(doc, node->content);
|
||||
#else
|
||||
buffer = xmlEncodeSpecialChars(doc,
|
||||
xmlBufferContent(node->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
ret = xmlStrcat(ret, buffer);
|
||||
xmlFree(buffer);
|
||||
@ -989,11 +967,7 @@ xmlNodeListGetRawString(xmlDocPtr doc, xmlNodePtr list, int inLine) {
|
||||
if (ent != NULL)
|
||||
ret = xmlStrcat(ret, ent->content);
|
||||
else {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
ret = xmlStrcat(ret, node->content);
|
||||
#else
|
||||
ret = xmlStrcat(ret, xmlBufferContent(node->content));
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
xmlChar buf[2];
|
||||
@ -1353,14 +1327,7 @@ xmlNewPI(const xmlChar *name, const xmlChar *content) {
|
||||
|
||||
cur->name = xmlStrdup(name);
|
||||
if (content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
cur->content = xmlStrdup(content);
|
||||
#else
|
||||
cur->content = xmlBufferCreateSize(0);
|
||||
xmlBufferSetAllocationScheme(cur->content,
|
||||
xmlGetBufferAllocationScheme());
|
||||
xmlBufferAdd(cur->content, content, -1);
|
||||
#endif
|
||||
}
|
||||
return(cur);
|
||||
}
|
||||
@ -1516,14 +1483,7 @@ xmlNewText(const xmlChar *content) {
|
||||
|
||||
cur->name = xmlStringText;
|
||||
if (content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
cur->content = xmlStrdup(content);
|
||||
#else
|
||||
cur->content = xmlBufferCreateSize(0);
|
||||
xmlBufferSetAllocationScheme(cur->content,
|
||||
xmlGetBufferAllocationScheme());
|
||||
xmlBufferAdd(cur->content, content, -1);
|
||||
#endif
|
||||
}
|
||||
return(cur);
|
||||
}
|
||||
@ -1667,20 +1627,7 @@ xmlNewReference(xmlDocPtr doc, const xmlChar *name) {
|
||||
|
||||
ent = xmlGetDocEntity(doc, cur->name);
|
||||
if (ent != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
cur->content = ent->content;
|
||||
#else
|
||||
/*
|
||||
* CJN 11.18.99 this might be a problem, since the xmlBuffer gets
|
||||
* a copy of this pointer. Let's hope we don't manipulate it
|
||||
* later
|
||||
*/
|
||||
cur->content = xmlBufferCreateSize(0);
|
||||
xmlBufferSetAllocationScheme(cur->content,
|
||||
xmlGetBufferAllocationScheme());
|
||||
if (ent->content != NULL)
|
||||
xmlBufferAdd(cur->content, ent->content, -1);
|
||||
#endif
|
||||
/*
|
||||
* The parent pointer in entity is a DTD pointer and thus is NOT
|
||||
* updated. Not sure if this is 100% correct.
|
||||
@ -1735,14 +1682,7 @@ xmlNewTextLen(const xmlChar *content, int len) {
|
||||
|
||||
cur->name = xmlStringText;
|
||||
if (content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
cur->content = xmlStrndup(content, len);
|
||||
#else
|
||||
cur->content = xmlBufferCreateSize(len);
|
||||
xmlBufferSetAllocationScheme(cur->content,
|
||||
xmlGetBufferAllocationScheme());
|
||||
xmlBufferAdd(cur->content, content, len);
|
||||
#endif
|
||||
}
|
||||
return(cur);
|
||||
}
|
||||
@ -1791,14 +1731,7 @@ xmlNewComment(const xmlChar *content) {
|
||||
|
||||
cur->name = xmlStringComment;
|
||||
if (content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
cur->content = xmlStrdup(content);
|
||||
#else
|
||||
cur->content = xmlBufferCreateSize(0);
|
||||
xmlBufferSetAllocationScheme(cur->content,
|
||||
xmlGetBufferAllocationScheme());
|
||||
xmlBufferAdd(cur->content, content, -1);
|
||||
#endif
|
||||
}
|
||||
return(cur);
|
||||
}
|
||||
@ -1830,14 +1763,7 @@ xmlNewCDataBlock(xmlDocPtr doc, const xmlChar *content, int len) {
|
||||
cur->doc = doc;
|
||||
|
||||
if (content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
cur->content = xmlStrndup(content, len);
|
||||
#else
|
||||
cur->content = xmlBufferCreateSize(len);
|
||||
xmlBufferSetAllocationScheme(cur->content,
|
||||
xmlGetBufferAllocationScheme());
|
||||
xmlBufferAdd(cur->content, content, len);
|
||||
#endif
|
||||
}
|
||||
return(cur);
|
||||
}
|
||||
@ -2020,28 +1946,18 @@ xmlAddNextSibling(xmlNodePtr cur, xmlNodePtr elem) {
|
||||
|
||||
if (elem->type == XML_TEXT_NODE) {
|
||||
if (cur->type == XML_TEXT_NODE) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlNodeAddContent(cur, elem->content);
|
||||
#else
|
||||
xmlNodeAddContent(cur, xmlBufferContent(elem->content));
|
||||
#endif
|
||||
xmlFreeNode(elem);
|
||||
return(cur);
|
||||
}
|
||||
if ((cur->next != NULL) && (cur->next->type == XML_TEXT_NODE) &&
|
||||
(cur->name == cur->next->name)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlChar *tmp;
|
||||
|
||||
tmp = xmlStrdup(elem->content);
|
||||
tmp = xmlStrcat(tmp, cur->next->content);
|
||||
xmlNodeSetContent(cur->next, tmp);
|
||||
xmlFree(tmp);
|
||||
#else
|
||||
xmlBufferAddHead(cur->next->content,
|
||||
xmlBufferContent(elem->content),
|
||||
xmlBufferLength(elem->content));
|
||||
#endif
|
||||
xmlFreeNode(elem);
|
||||
return(cur->next);
|
||||
}
|
||||
@ -2108,27 +2024,18 @@ xmlAddPrevSibling(xmlNodePtr cur, xmlNodePtr elem) {
|
||||
|
||||
if (elem->type == XML_TEXT_NODE) {
|
||||
if (cur->type == XML_TEXT_NODE) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlChar *tmp;
|
||||
|
||||
tmp = xmlStrdup(elem->content);
|
||||
tmp = xmlStrcat(tmp, cur->content);
|
||||
xmlNodeSetContent(cur, tmp);
|
||||
xmlFree(tmp);
|
||||
#else
|
||||
xmlBufferAddHead(cur->content, xmlBufferContent(elem->content),
|
||||
xmlBufferLength(elem->content));
|
||||
#endif
|
||||
xmlFreeNode(elem);
|
||||
return(cur);
|
||||
}
|
||||
if ((cur->prev != NULL) && (cur->prev->type == XML_TEXT_NODE) &&
|
||||
(cur->name == cur->prev->name)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlNodeAddContent(cur->prev, elem->content);
|
||||
#else
|
||||
xmlNodeAddContent(cur->prev, xmlBufferContent(elem->content));
|
||||
#endif
|
||||
xmlFreeNode(elem);
|
||||
return(cur->prev);
|
||||
}
|
||||
@ -2217,11 +2124,7 @@ xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem) {
|
||||
xmlUnlinkNode(elem);
|
||||
|
||||
if ((cur->type == XML_TEXT_NODE) && (elem->type == XML_TEXT_NODE)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlNodeAddContent(cur, elem->content);
|
||||
#else
|
||||
xmlNodeAddContent(cur, xmlBufferContent(elem->content));
|
||||
#endif
|
||||
xmlFreeNode(elem);
|
||||
return(cur);
|
||||
}
|
||||
@ -2290,11 +2193,7 @@ xmlAddChildList(xmlNodePtr parent, xmlNodePtr cur) {
|
||||
if ((cur->type == XML_TEXT_NODE) &&
|
||||
(parent->last->type == XML_TEXT_NODE) &&
|
||||
(cur->name == parent->last->name)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlNodeAddContent(parent->last, cur->content);
|
||||
#else
|
||||
xmlNodeAddContent(parent->last, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
/*
|
||||
* if it's the only child, nothing more to be done.
|
||||
*/
|
||||
@ -2365,21 +2264,13 @@ xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
|
||||
if (cur->type == XML_TEXT_NODE) {
|
||||
if ((parent->type == XML_TEXT_NODE) &&
|
||||
(parent->content != NULL)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlNodeAddContent(parent, cur->content);
|
||||
#else
|
||||
xmlNodeAddContent(parent, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
xmlFreeNode(cur);
|
||||
return(parent);
|
||||
}
|
||||
if ((parent->last != NULL) && (parent->last->type == XML_TEXT_NODE) &&
|
||||
(parent->last->name == cur->name)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlNodeAddContent(parent->last, cur->content);
|
||||
#else
|
||||
xmlNodeAddContent(parent->last, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
xmlFreeNode(cur);
|
||||
return(parent->last);
|
||||
}
|
||||
@ -2398,11 +2289,7 @@ xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
|
||||
*/
|
||||
if ((parent->type == XML_TEXT_NODE) &&
|
||||
(parent->content != NULL)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlNodeAddContent(parent, cur->content);
|
||||
#else
|
||||
xmlNodeAddContent(parent, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
xmlFreeNode(cur);
|
||||
return(parent);
|
||||
}
|
||||
@ -2496,11 +2383,7 @@ xmlFreeNodeList(xmlNodePtr cur) {
|
||||
(cur->type != XML_XINCLUDE_START) &&
|
||||
(cur->type != XML_XINCLUDE_END) &&
|
||||
(cur->type != XML_ENTITY_REF_NODE)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
if (cur->content != NULL) xmlFree(cur->content);
|
||||
#else
|
||||
if (cur->content != NULL) xmlBufferFree(cur->content);
|
||||
#endif
|
||||
}
|
||||
if (((cur->type == XML_ELEMENT_NODE) ||
|
||||
(cur->type == XML_XINCLUDE_START) ||
|
||||
@ -2574,11 +2457,7 @@ xmlFreeNode(xmlNodePtr cur) {
|
||||
(cur->type != XML_ENTITY_REF_NODE) &&
|
||||
(cur->type != XML_XINCLUDE_END) &&
|
||||
(cur->type != XML_XINCLUDE_START)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlFree(cur->content);
|
||||
#else
|
||||
xmlBufferFree(cur->content);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
@ -3014,16 +2893,7 @@ xmlStaticCopyNode(const xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent,
|
||||
(node->type != XML_ENTITY_REF_NODE) &&
|
||||
(node->type != XML_XINCLUDE_END) &&
|
||||
(node->type != XML_XINCLUDE_START)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
ret->content = xmlStrdup(node->content);
|
||||
#else
|
||||
ret->content = xmlBufferCreateSize(xmlBufferLength(node->content));
|
||||
xmlBufferSetAllocationScheme(ret->content,
|
||||
xmlGetBufferAllocationScheme());
|
||||
xmlBufferAdd(ret->content,
|
||||
xmlBufferContent(node->content),
|
||||
xmlBufferLength(node->content));
|
||||
#endif
|
||||
}else{
|
||||
if (node->type == XML_ELEMENT_NODE)
|
||||
ret->content = (void*)(long) node->content;
|
||||
@ -3885,12 +3755,7 @@ xmlNodeGetContent(xmlNodePtr cur) {
|
||||
case XML_CDATA_SECTION_NODE:
|
||||
case XML_TEXT_NODE:
|
||||
if (tmp->content != NULL)
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlBufferCat(buffer, tmp->content);
|
||||
#else
|
||||
xmlBufferCat(buffer,
|
||||
xmlBufferContent(tmp->content));
|
||||
#endif
|
||||
break;
|
||||
case XML_ENTITY_REF_NODE: {
|
||||
xmlEntityPtr ent;
|
||||
@ -3949,11 +3814,7 @@ xmlNodeGetContent(xmlNodePtr cur) {
|
||||
case XML_COMMENT_NODE:
|
||||
case XML_PI_NODE:
|
||||
if (cur->content != NULL)
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
return(xmlStrdup(cur->content));
|
||||
#else
|
||||
return(xmlStrdup(xmlBufferContent(cur->content)));
|
||||
#endif
|
||||
return(NULL);
|
||||
case XML_ENTITY_REF_NODE:
|
||||
/*
|
||||
@ -3987,11 +3848,7 @@ xmlNodeGetContent(xmlNodePtr cur) {
|
||||
case XML_CDATA_SECTION_NODE:
|
||||
case XML_TEXT_NODE:
|
||||
if (cur->content != NULL)
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
return(xmlStrdup(cur->content));
|
||||
#else
|
||||
return(xmlStrdup(xmlBufferContent(cur->content)));
|
||||
#endif
|
||||
return(NULL);
|
||||
}
|
||||
return(NULL);
|
||||
@ -4028,23 +3885,12 @@ xmlNodeSetContent(xmlNodePtr cur, const xmlChar *content) {
|
||||
case XML_PI_NODE:
|
||||
case XML_COMMENT_NODE:
|
||||
if (cur->content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlFree(cur->content);
|
||||
#else
|
||||
xmlBufferFree(cur->content);
|
||||
#endif
|
||||
}
|
||||
if (cur->children != NULL) xmlFreeNodeList(cur->children);
|
||||
cur->last = cur->children = NULL;
|
||||
if (content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
cur->content = xmlStrdup(content);
|
||||
#else
|
||||
cur->content = xmlBufferCreateSize(0);
|
||||
xmlBufferSetAllocationScheme(cur->content,
|
||||
xmlGetBufferAllocationScheme());
|
||||
xmlBufferAdd(cur->content, content, -1);
|
||||
#endif
|
||||
} else
|
||||
cur->content = NULL;
|
||||
break;
|
||||
@ -4108,23 +3954,12 @@ xmlNodeSetContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
|
||||
case XML_COMMENT_NODE:
|
||||
case XML_NOTATION_NODE:
|
||||
if (cur->content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlFree(cur->content);
|
||||
#else
|
||||
xmlBufferFree(cur->content);
|
||||
#endif
|
||||
}
|
||||
if (cur->children != NULL) xmlFreeNodeList(cur->children);
|
||||
cur->children = cur->last = NULL;
|
||||
if (content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
cur->content = xmlStrndup(content, len);
|
||||
#else
|
||||
cur->content = xmlBufferCreateSize(len);
|
||||
xmlBufferSetAllocationScheme(cur->content,
|
||||
xmlGetBufferAllocationScheme());
|
||||
xmlBufferAdd(cur->content, content, len);
|
||||
#endif
|
||||
} else
|
||||
cur->content = NULL;
|
||||
break;
|
||||
@ -4196,11 +4031,7 @@ xmlNodeAddContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
|
||||
case XML_COMMENT_NODE:
|
||||
case XML_NOTATION_NODE:
|
||||
if (content != NULL) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
cur->content = xmlStrncat(cur->content, content, len);
|
||||
#else
|
||||
xmlBufferAdd(cur->content, content, len);
|
||||
#endif
|
||||
}
|
||||
case XML_DOCUMENT_NODE:
|
||||
case XML_DTD_NODE:
|
||||
@ -4259,11 +4090,7 @@ xmlTextMerge(xmlNodePtr first, xmlNodePtr second) {
|
||||
if (second->type != XML_TEXT_NODE) return(first);
|
||||
if (second->name != first->name)
|
||||
return(first);
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlNodeAddContent(first, second->content);
|
||||
#else
|
||||
xmlNodeAddContent(first, xmlBufferContent(second->content));
|
||||
#endif
|
||||
xmlUnlinkNode(second);
|
||||
xmlFreeNode(second);
|
||||
return(first);
|
||||
@ -5216,11 +5043,7 @@ xmlIsBlankNode(xmlNodePtr node) {
|
||||
(node->type != XML_CDATA_SECTION_NODE))
|
||||
return(0);
|
||||
if (node->content == NULL) return(1);
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
cur = node->content;
|
||||
#else
|
||||
cur = xmlBufferContent(node->content);
|
||||
#endif
|
||||
while (*cur != 0) {
|
||||
if (!IS_BLANK(*cur)) return(0);
|
||||
cur++;
|
||||
@ -5250,11 +5073,7 @@ xmlTextConcat(xmlNodePtr node, const xmlChar *content, int len) {
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
node->content = xmlStrncat(node->content, content, len);
|
||||
#else
|
||||
xmlBufferAdd(node->content, content, len);
|
||||
#endif
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
@ -6145,12 +5964,7 @@ xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
|
||||
(cur->name != xmlStringTextNoenc)) {
|
||||
xmlChar *buffer;
|
||||
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
buffer = xmlEncodeEntitiesReentrant(doc, cur->content);
|
||||
#else
|
||||
buffer = xmlEncodeEntitiesReentrant(doc,
|
||||
xmlBufferContent(cur->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
xmlBufferWriteCHAR(buf, buffer);
|
||||
xmlFree(buffer);
|
||||
@ -6159,11 +5973,7 @@ xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
|
||||
/*
|
||||
* Disable escaping, needed for XSLT
|
||||
*/
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlBufferWriteCHAR(buf, cur->content);
|
||||
#else
|
||||
xmlBufferWriteCHAR(buf, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
return;
|
||||
@ -6173,11 +5983,7 @@ xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
|
||||
xmlBufferWriteCHAR(buf, cur->name);
|
||||
if (cur->content != NULL) {
|
||||
xmlBufferWriteChar(buf, " ");
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlBufferWriteCHAR(buf, cur->content);
|
||||
#else
|
||||
xmlBufferWriteCHAR(buf, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
}
|
||||
xmlBufferWriteChar(buf, "?>");
|
||||
return;
|
||||
@ -6185,11 +5991,7 @@ xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
|
||||
if (cur->type == XML_COMMENT_NODE) {
|
||||
if (cur->content != NULL) {
|
||||
xmlBufferWriteChar(buf, "<!--");
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlBufferWriteCHAR(buf, cur->content);
|
||||
#else
|
||||
xmlBufferWriteCHAR(buf, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
xmlBufferWriteChar(buf, "-->");
|
||||
}
|
||||
return;
|
||||
@ -6203,11 +6005,7 @@ xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
|
||||
if (cur->type == XML_CDATA_SECTION_NODE) {
|
||||
xmlBufferWriteChar(buf, "<![CDATA[");
|
||||
if (cur->content != NULL)
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlBufferWriteCHAR(buf, cur->content);
|
||||
#else
|
||||
xmlBufferWriteCHAR(buf, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
xmlBufferWriteChar(buf, "]]>");
|
||||
return;
|
||||
}
|
||||
@ -6245,12 +6043,7 @@ xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
|
||||
if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
|
||||
xmlChar *buffer;
|
||||
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
buffer = xmlEncodeEntitiesReentrant(doc, cur->content);
|
||||
#else
|
||||
buffer = xmlEncodeEntitiesReentrant(doc,
|
||||
xmlBufferContent(cur->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
xmlBufferWriteCHAR(buf, buffer);
|
||||
xmlFree(buffer);
|
||||
@ -6551,19 +6344,10 @@ xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
|
||||
(cur->name != xmlStringTextNoenc)) {
|
||||
xmlChar *buffer;
|
||||
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
if (encoding == NULL)
|
||||
buffer = xmlEncodeEntitiesReentrant(doc, cur->content);
|
||||
else
|
||||
buffer = xmlEncodeSpecialChars(doc, cur->content);
|
||||
#else
|
||||
if (encoding == NULL)
|
||||
buffer = xmlEncodeEntitiesReentrant(doc,
|
||||
xmlBufferContent(cur->content));
|
||||
else
|
||||
buffer = xmlEncodeSpecialChars(doc,
|
||||
xmlBufferContent(cur->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
xmlOutputBufferWriteString(buf, (const char *)buffer);
|
||||
xmlFree(buffer);
|
||||
@ -6572,11 +6356,7 @@ xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
|
||||
/*
|
||||
* Disable escaping, needed for XSLT
|
||||
*/
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlOutputBufferWriteString(buf, (const char *) cur->content);
|
||||
#else
|
||||
xmlOutputBufferWriteString(buf, xmlBufferContent(cur->content));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
@ -6588,11 +6368,7 @@ xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
|
||||
xmlOutputBufferWriteString(buf, (const char *)cur->name);
|
||||
if (cur->content != NULL) {
|
||||
xmlOutputBufferWriteString(buf, " ");
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlOutputBufferWriteString(buf, (const char *)cur->content);
|
||||
#else
|
||||
xmlOutputBufferWriteString(buf, (const char *)xmlBufferContent(cur->content));
|
||||
#endif
|
||||
}
|
||||
xmlOutputBufferWriteString(buf, "?>");
|
||||
} else {
|
||||
@ -6605,11 +6381,7 @@ xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
|
||||
if (cur->type == XML_COMMENT_NODE) {
|
||||
if (cur->content != NULL) {
|
||||
xmlOutputBufferWriteString(buf, "<!--");
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlOutputBufferWriteString(buf, (const char *)cur->content);
|
||||
#else
|
||||
xmlOutputBufferWriteString(buf, (const char *)xmlBufferContent(cur->content));
|
||||
#endif
|
||||
xmlOutputBufferWriteString(buf, "-->");
|
||||
}
|
||||
return;
|
||||
@ -6623,11 +6395,7 @@ xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
|
||||
if (cur->type == XML_CDATA_SECTION_NODE) {
|
||||
xmlOutputBufferWriteString(buf, "<![CDATA[");
|
||||
if (cur->content != NULL)
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
xmlOutputBufferWriteString(buf, (const char *)cur->content);
|
||||
#else
|
||||
xmlOutputBufferWriteString(buf, (const char *)xmlBufferContent(cur->content));
|
||||
#endif
|
||||
xmlOutputBufferWriteString(buf, "]]>");
|
||||
return;
|
||||
}
|
||||
@ -6664,19 +6432,10 @@ xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
|
||||
if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
|
||||
xmlChar *buffer;
|
||||
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
if (encoding == NULL)
|
||||
buffer = xmlEncodeEntitiesReentrant(doc, cur->content);
|
||||
else
|
||||
buffer = xmlEncodeSpecialChars(doc, cur->content);
|
||||
#else
|
||||
if (encoding == NULL)
|
||||
buffer = xmlEncodeEntitiesReentrant(doc,
|
||||
xmlBufferContent(cur->content));
|
||||
else
|
||||
buffer = xmlEncodeSpecialChars(doc,
|
||||
xmlBufferContent(cur->content));
|
||||
#endif
|
||||
if (buffer != NULL) {
|
||||
xmlOutputBufferWriteString(buf, (const char *)buffer);
|
||||
xmlFree(buffer);
|
||||
|
||||
45
xpointer.c
45
xpointer.c
@ -1628,11 +1628,7 @@ xmlXPtrNbLocChildren(xmlNodePtr node) {
|
||||
case XML_TEXT_NODE:
|
||||
case XML_CDATA_SECTION_NODE:
|
||||
case XML_ENTITY_REF_NODE:
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
ret = xmlStrlen(node->content);
|
||||
#else
|
||||
ret = xmlBufferLength(node->content);
|
||||
#endif
|
||||
break;
|
||||
default:
|
||||
return(-1);
|
||||
@ -2007,13 +2003,8 @@ xmlXPtrInsideRange(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr loc) {
|
||||
if (node->content == NULL) {
|
||||
return(xmlXPtrNewRange(node, 0, node, 0));
|
||||
} else {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
return(xmlXPtrNewRange(node, 0, node,
|
||||
xmlStrlen(node->content)));
|
||||
#else
|
||||
return(xmlXPtrNewRange(node, 0, node,
|
||||
xmlBufferLength(node->content)));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
case XML_ATTRIBUTE_NODE:
|
||||
@ -2044,13 +2035,8 @@ xmlXPtrInsideRange(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr loc) {
|
||||
if (node->content == NULL) {
|
||||
return(xmlXPtrNewRange(node, 0, node, 0));
|
||||
} else {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
return(xmlXPtrNewRange(node, 0, node,
|
||||
xmlStrlen(node->content)));
|
||||
#else
|
||||
return(xmlXPtrNewRange(node, 0, node,
|
||||
xmlBufferLength(node->content)));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
case XML_ATTRIBUTE_NODE:
|
||||
@ -2319,11 +2305,7 @@ xmlXPtrAdvanceChar(xmlNodePtr *node, int *indx, int bytes) {
|
||||
len = 0;
|
||||
if ((cur->type != XML_ELEMENT_NODE) &&
|
||||
(cur->content != NULL)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
len = xmlStrlen(cur->content);
|
||||
#else
|
||||
len = xmlBufferLength(cur->content);
|
||||
#endif
|
||||
}
|
||||
if (pos > len) {
|
||||
/* Strange, the indx in the text node is greater than it's len */
|
||||
@ -2386,18 +2368,9 @@ xmlXPtrMatchString(const xmlChar *string, xmlNodePtr start, int startindex,
|
||||
return(0);
|
||||
|
||||
if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
len = xmlStrlen(cur->content);
|
||||
#else
|
||||
len = xmlBufferLength(cur->content);
|
||||
#endif
|
||||
if (len >= pos + stringlen) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
match = (!xmlStrncmp(&cur->content[pos], string, stringlen));
|
||||
#else
|
||||
len = (!xmlStrncmp(&xmlBufferContent(cur->content)[pos],
|
||||
string, stringlen));
|
||||
#endif
|
||||
if (match) {
|
||||
#ifdef DEBUG_RANGES
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
@ -2414,12 +2387,7 @@ xmlXPtrMatchString(const xmlChar *string, xmlNodePtr start, int startindex,
|
||||
}
|
||||
} else {
|
||||
int sub = len - pos;
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
match = (!xmlStrncmp(&cur->content[pos], string, sub));
|
||||
#else
|
||||
len = (!xmlStrncmp(&xmlBufferContent(cur->content)[pos],
|
||||
string, sub));
|
||||
#endif
|
||||
if (match) {
|
||||
#ifdef DEBUG_RANGES
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
@ -2482,19 +2450,10 @@ xmlXPtrSearchString(const xmlChar *string, xmlNodePtr *start, int *startindex,
|
||||
|
||||
while (cur != NULL) {
|
||||
if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
len = xmlStrlen(cur->content);
|
||||
#else
|
||||
len = xmlBufferLength(cur->content);
|
||||
#endif
|
||||
while (pos <= len) {
|
||||
if (first != 0) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
str = xmlStrchr(&cur->content[pos], first);
|
||||
#else
|
||||
str = xmlStrchr(&xmlBufferContent(cur->content)[pos],
|
||||
first);
|
||||
#endif
|
||||
if (str != NULL) {
|
||||
pos = (str - (xmlChar *)(cur->content));
|
||||
#ifdef DEBUG_RANGES
|
||||
@ -2580,11 +2539,7 @@ xmlXPtrGetLastChar(xmlNodePtr *node, int *indx) {
|
||||
cur = cur->last;
|
||||
else if ((cur->type != XML_ELEMENT_NODE) &&
|
||||
(cur->content != NULL)) {
|
||||
#ifndef XML_USE_BUFFER_CONTENT
|
||||
len = xmlStrlen(cur->content);
|
||||
#else
|
||||
len = xmlBufferLength(cur->content);
|
||||
#endif
|
||||
break;
|
||||
} else {
|
||||
return(-1);
|
||||
|
||||
Reference in New Issue
Block a user