version 1.1.1.2, 2013/07/22 01:22:19
|
version 1.1.1.3, 2014/06/15 19:53:30
|
Line 41
|
Line 41
|
#include <libxml/debugXML.h> |
#include <libxml/debugXML.h> |
#endif |
#endif |
|
|
|
#include "buf.h" |
|
#include "save.h" |
|
|
int __xmlRegisterCallbacks = 0; |
int __xmlRegisterCallbacks = 0; |
|
|
/************************************************************************ |
/************************************************************************ |
Line 311 xmlSplitQName2(const xmlChar *name, xmlChar **prefix)
|
Line 314 xmlSplitQName2(const xmlChar *name, xmlChar **prefix)
|
* parse an XML qualified name string,i |
* parse an XML qualified name string,i |
* |
* |
* returns NULL if it is not a Qualified Name, otherwise, update len |
* returns NULL if it is not a Qualified Name, otherwise, update len |
* with the lenght in byte of the prefix and return a pointer | * with the length in byte of the prefix and return a pointer |
* to the start of the name without the prefix |
* to the start of the name without the prefix |
*/ |
*/ |
|
|
Line 1265 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
Line 1268 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
const xmlChar *cur = value, *end = cur + len; |
const xmlChar *cur = value, *end = cur + len; |
const xmlChar *q; |
const xmlChar *q; |
xmlEntityPtr ent; |
xmlEntityPtr ent; |
xmlBufferPtr buffer; | xmlBufPtr buf; |
|
|
if (value == NULL) return(NULL); |
if (value == NULL) return(NULL); |
|
|
buffer = xmlBufferCreateSize(0); | buf = xmlBufCreateSize(0); |
if (buffer == NULL) return(NULL); | if (buf == NULL) return(NULL); |
xmlBufferSetAllocationScheme(buffer, XML_BUFFER_ALLOC_HYBRID); | xmlBufSetAllocationScheme(buf, XML_BUFFER_ALLOC_HYBRID); |
|
|
q = cur; |
q = cur; |
while ((cur < end) && (*cur != 0)) { |
while ((cur < end) && (*cur != 0)) { |
Line 1283 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
Line 1286 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
* Save the current text. |
* Save the current text. |
*/ |
*/ |
if (cur != q) { |
if (cur != q) { |
if (xmlBufferAdd(buffer, q, cur - q)) | if (xmlBufAdd(buf, q, cur - q)) |
goto out; |
goto out; |
} |
} |
q = cur; |
q = cur; |
Line 1360 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
Line 1363 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
if ((ent != NULL) && |
if ((ent != NULL) && |
(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { |
(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { |
|
|
if (xmlBufferCat(buffer, ent->content)) | if (xmlBufCat(buf, ent->content)) |
goto out; |
goto out; |
|
|
} else { |
} else { |
/* |
/* |
* Flush buffer so far |
* Flush buffer so far |
*/ |
*/ |
if (buffer->use) { | if (!xmlBufIsEmpty(buf)) { |
node = xmlNewDocText(doc, NULL); |
node = xmlNewDocText(doc, NULL); |
if (node == NULL) { |
if (node == NULL) { |
if (val != NULL) xmlFree(val); |
if (val != NULL) xmlFree(val); |
goto out; |
goto out; |
} |
} |
node->content = xmlBufferDetach(buffer); | node->content = xmlBufDetach(buf); |
|
|
if (last == NULL) { |
if (last == NULL) { |
last = ret = node; |
last = ret = node; |
Line 1415 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
Line 1418 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
q = cur; |
q = cur; |
} |
} |
if (charval != 0) { |
if (charval != 0) { |
xmlChar buf[10]; | xmlChar buffer[10]; |
int l; |
int l; |
|
|
l = xmlCopyCharMultiByte(buf, charval); | l = xmlCopyCharMultiByte(buffer, charval); |
buf[l] = 0; | buffer[l] = 0; |
|
|
if (xmlBufferCat(buffer, buf)) | if (xmlBufCat(buf, buffer)) |
goto out; |
goto out; |
charval = 0; |
charval = 0; |
} |
} |
Line 1433 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
Line 1436 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
/* |
/* |
* Handle the last piece of text. |
* Handle the last piece of text. |
*/ |
*/ |
if (xmlBufferAdd(buffer, q, cur - q)) | if (xmlBufAdd(buf, q, cur - q)) |
goto out; |
goto out; |
} |
} |
|
|
if (buffer->use) { | if (!xmlBufIsEmpty(buf)) { |
node = xmlNewDocText(doc, NULL); |
node = xmlNewDocText(doc, NULL); |
if (node == NULL) goto out; |
if (node == NULL) goto out; |
node->content = xmlBufferDetach(buffer); | node->content = xmlBufDetach(buf); |
|
|
if (last == NULL) { |
if (last == NULL) { |
last = ret = node; |
last = ret = node; |
Line 1452 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
Line 1455 xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *
|
} |
} |
|
|
out: |
out: |
xmlBufferFree(buffer); | xmlBufFree(buf); |
return(ret); |
return(ret); |
} |
} |
|
|
Line 1473 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
Line 1476 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
const xmlChar *cur = value; |
const xmlChar *cur = value; |
const xmlChar *q; |
const xmlChar *q; |
xmlEntityPtr ent; |
xmlEntityPtr ent; |
xmlBufferPtr buffer; | xmlBufPtr buf; |
|
|
if (value == NULL) return(NULL); |
if (value == NULL) return(NULL); |
|
|
buffer = xmlBufferCreateSize(0); | buf = xmlBufCreateSize(0); |
if (buffer == NULL) return(NULL); | if (buf == NULL) return(NULL); |
xmlBufferSetAllocationScheme(buffer, XML_BUFFER_ALLOC_HYBRID); | xmlBufSetAllocationScheme(buf, XML_BUFFER_ALLOC_HYBRID); |
|
|
q = cur; |
q = cur; |
while (*cur != 0) { |
while (*cur != 0) { |
Line 1491 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
Line 1494 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
* Save the current text. |
* Save the current text. |
*/ |
*/ |
if (cur != q) { |
if (cur != q) { |
if (xmlBufferAdd(buffer, q, cur - q)) | if (xmlBufAdd(buf, q, cur - q)) |
goto out; |
goto out; |
} |
} |
q = cur; |
q = cur; |
Line 1556 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
Line 1559 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
if ((ent != NULL) && |
if ((ent != NULL) && |
(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { |
(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { |
|
|
if (xmlBufferCat(buffer, ent->content)) | if (xmlBufCat(buf, ent->content)) |
goto out; |
goto out; |
|
|
} else { |
} else { |
/* |
/* |
* Flush buffer so far |
* Flush buffer so far |
*/ |
*/ |
if (buffer->use) { | if (!xmlBufIsEmpty(buf)) { |
node = xmlNewDocText(doc, NULL); |
node = xmlNewDocText(doc, NULL); |
node->content = xmlBufferDetach(buffer); | node->content = xmlBufDetach(buf); |
|
|
if (last == NULL) { |
if (last == NULL) { |
last = ret = node; |
last = ret = node; |
Line 1606 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
Line 1609 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
q = cur; |
q = cur; |
} |
} |
if (charval != 0) { |
if (charval != 0) { |
xmlChar buf[10]; | xmlChar buffer[10]; |
int len; |
int len; |
|
|
len = xmlCopyCharMultiByte(buf, charval); | len = xmlCopyCharMultiByte(buffer, charval); |
buf[len] = 0; | buffer[len] = 0; |
|
|
if (xmlBufferCat(buffer, buf)) | if (xmlBufCat(buf, buffer)) |
goto out; |
goto out; |
charval = 0; |
charval = 0; |
} |
} |
Line 1623 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
Line 1626 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
/* |
/* |
* Handle the last piece of text. |
* Handle the last piece of text. |
*/ |
*/ |
xmlBufferAdd(buffer, q, cur - q); | xmlBufAdd(buf, q, cur - q); |
} |
} |
|
|
if (buffer->use) { | if (!xmlBufIsEmpty(buf)) { |
node = xmlNewDocText(doc, NULL); |
node = xmlNewDocText(doc, NULL); |
node->content = xmlBufferDetach(buffer); | node->content = xmlBufDetach(buf); |
|
|
if (last == NULL) { |
if (last == NULL) { |
last = ret = node; |
last = ret = node; |
Line 1638 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
Line 1641 xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *val
|
} |
} |
|
|
out: |
out: |
xmlBufferFree(buffer); | xmlBufFree(buf); |
return(ret); |
return(ret); |
} |
} |
|
|
Line 1659 xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, i
|
Line 1662 xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, i
|
xmlNodePtr node = list; |
xmlNodePtr node = list; |
xmlChar *ret = NULL; |
xmlChar *ret = NULL; |
xmlEntityPtr ent; |
xmlEntityPtr ent; |
|
int attr; |
|
|
if (list == NULL) |
if (list == NULL) |
return (NULL); |
return (NULL); |
|
if ((list->parent != NULL) && (list->parent->type == XML_ATTRIBUTE_NODE)) |
|
attr = 1; |
|
else |
|
attr = 0; |
|
|
while (node != NULL) { |
while (node != NULL) { |
if ((node->type == XML_TEXT_NODE) || |
if ((node->type == XML_TEXT_NODE) || |
Line 1671 xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, i
|
Line 1679 xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, i
|
} else { |
} else { |
xmlChar *buffer; |
xmlChar *buffer; |
|
|
buffer = xmlEncodeEntitiesReentrant(doc, node->content); | if (attr) |
| buffer = xmlEncodeAttributeEntities(doc, node->content); |
| else |
| buffer = xmlEncodeEntitiesReentrant(doc, node->content); |
if (buffer != NULL) { |
if (buffer != NULL) { |
ret = xmlStrcat(ret, buffer); |
ret = xmlStrcat(ret, buffer); |
xmlFree(buffer); |
xmlFree(buffer); |
Line 2777 void
|
Line 2788 void
|
xmlSetTreeDoc(xmlNodePtr tree, xmlDocPtr doc) { |
xmlSetTreeDoc(xmlNodePtr tree, xmlDocPtr doc) { |
xmlAttrPtr prop; |
xmlAttrPtr prop; |
|
|
if (tree == NULL) | if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL)) |
return; |
return; |
if (tree->doc != doc) { |
if (tree->doc != doc) { |
if(tree->type == XML_ELEMENT_NODE) { |
if(tree->type == XML_ELEMENT_NODE) { |
Line 2805 void
|
Line 2816 void
|
xmlSetListDoc(xmlNodePtr list, xmlDocPtr doc) { |
xmlSetListDoc(xmlNodePtr list, xmlDocPtr doc) { |
xmlNodePtr cur; |
xmlNodePtr cur; |
|
|
if (list == NULL) | if ((list == NULL) || (list->type == XML_NAMESPACE_DECL)) |
return; |
return; |
cur = list; |
cur = list; |
while (cur != NULL) { |
while (cur != NULL) { |
Line 2912 static xmlNodePtr
|
Line 2923 static xmlNodePtr
|
xmlAddPropSibling(xmlNodePtr prev, xmlNodePtr cur, xmlNodePtr prop) { |
xmlAddPropSibling(xmlNodePtr prev, xmlNodePtr cur, xmlNodePtr prop) { |
xmlAttrPtr attr; |
xmlAttrPtr attr; |
|
|
if (cur->type != XML_ATTRIBUTE_NODE) | if ((cur == NULL) || (cur->type != XML_ATTRIBUTE_NODE) || |
| (prop == NULL) || (prop->type != XML_ATTRIBUTE_NODE) || |
| ((prev != NULL) && (prev->type != XML_ATTRIBUTE_NODE))) |
return(NULL); |
return(NULL); |
|
|
/* check if an attribute with the same name exists */ |
/* check if an attribute with the same name exists */ |
Line 2960 xmlAddPropSibling(xmlNodePtr prev, xmlNodePtr cur, xml
|
Line 2973 xmlAddPropSibling(xmlNodePtr prev, xmlNodePtr cur, xml
|
*/ |
*/ |
xmlNodePtr |
xmlNodePtr |
xmlAddNextSibling(xmlNodePtr cur, xmlNodePtr elem) { |
xmlAddNextSibling(xmlNodePtr cur, xmlNodePtr elem) { |
if (cur == NULL) { | if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlAddNextSibling : cur == NULL\n"); |
"xmlAddNextSibling : cur == NULL\n"); |
#endif |
#endif |
return(NULL); |
return(NULL); |
} |
} |
if (elem == NULL) { | if ((elem == NULL) || (elem->type == XML_NAMESPACE_DECL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlAddNextSibling : elem == NULL\n"); |
"xmlAddNextSibling : elem == NULL\n"); |
Line 3038 xmlAddNextSibling(xmlNodePtr cur, xmlNodePtr elem) {
|
Line 3051 xmlAddNextSibling(xmlNodePtr cur, xmlNodePtr elem) {
|
*/ |
*/ |
xmlNodePtr |
xmlNodePtr |
xmlAddPrevSibling(xmlNodePtr cur, xmlNodePtr elem) { |
xmlAddPrevSibling(xmlNodePtr cur, xmlNodePtr elem) { |
if (cur == NULL) { | if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlAddPrevSibling : cur == NULL\n"); |
"xmlAddPrevSibling : cur == NULL\n"); |
#endif |
#endif |
return(NULL); |
return(NULL); |
} |
} |
if (elem == NULL) { | if ((elem == NULL) || (elem->type == XML_NAMESPACE_DECL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlAddPrevSibling : elem == NULL\n"); |
"xmlAddPrevSibling : elem == NULL\n"); |
Line 3116 xmlNodePtr
|
Line 3129 xmlNodePtr
|
xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem) { |
xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem) { |
xmlNodePtr parent; |
xmlNodePtr parent; |
|
|
if (cur == NULL) { | if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlAddSibling : cur == NULL\n"); |
"xmlAddSibling : cur == NULL\n"); |
Line 3124 xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem) {
|
Line 3137 xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem) {
|
return(NULL); |
return(NULL); |
} |
} |
|
|
if (elem == NULL) { | if ((elem == NULL) || (elem->type == XML_NAMESPACE_DECL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlAddSibling : elem == NULL\n"); |
"xmlAddSibling : elem == NULL\n"); |
Line 3192 xmlNodePtr
|
Line 3205 xmlNodePtr
|
xmlAddChildList(xmlNodePtr parent, xmlNodePtr cur) { |
xmlAddChildList(xmlNodePtr parent, xmlNodePtr cur) { |
xmlNodePtr prev; |
xmlNodePtr prev; |
|
|
if (parent == NULL) { | if ((parent == NULL) || (parent->type == XML_NAMESPACE_DECL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlAddChildList : parent == NULL\n"); |
"xmlAddChildList : parent == NULL\n"); |
Line 3200 xmlAddChildList(xmlNodePtr parent, xmlNodePtr cur) {
|
Line 3213 xmlAddChildList(xmlNodePtr parent, xmlNodePtr cur) {
|
return(NULL); |
return(NULL); |
} |
} |
|
|
if (cur == NULL) { | if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlAddChildList : child == NULL\n"); |
"xmlAddChildList : child == NULL\n"); |
Line 3278 xmlNodePtr
|
Line 3291 xmlNodePtr
|
xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) { |
xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) { |
xmlNodePtr prev; |
xmlNodePtr prev; |
|
|
if (parent == NULL) { | if ((parent == NULL) || (parent->type == XML_NAMESPACE_DECL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlAddChild : parent == NULL\n"); |
"xmlAddChild : parent == NULL\n"); |
Line 3286 xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
|
Line 3299 xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
|
return(NULL); |
return(NULL); |
} |
} |
|
|
if (cur == NULL) { | if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlAddChild : child == NULL\n"); |
"xmlAddChild : child == NULL\n"); |
Line 3400 xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
|
Line 3413 xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
|
*/ |
*/ |
xmlNodePtr |
xmlNodePtr |
xmlGetLastChild(xmlNodePtr parent) { |
xmlGetLastChild(xmlNodePtr parent) { |
if (parent == NULL) { | if ((parent == NULL) || (parent->type == XML_NAMESPACE_DECL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlGetLastChild : parent == NULL\n"); |
"xmlGetLastChild : parent == NULL\n"); |
Line 3752 xmlFreeNode(xmlNodePtr cur) {
|
Line 3765 xmlFreeNode(xmlNodePtr cur) {
|
* Unlink a node from it's current context, the node is not freed |
* Unlink a node from it's current context, the node is not freed |
* If one need to free the node, use xmlFreeNode() routine after the |
* If one need to free the node, use xmlFreeNode() routine after the |
* unlink to discard it. |
* unlink to discard it. |
|
* Note that namespace nodes can't be unlinked as they do not have |
|
* pointer to their parent. |
*/ |
*/ |
void |
void |
xmlUnlinkNode(xmlNodePtr cur) { |
xmlUnlinkNode(xmlNodePtr cur) { |
Line 3762 xmlUnlinkNode(xmlNodePtr cur) {
|
Line 3777 xmlUnlinkNode(xmlNodePtr cur) {
|
#endif |
#endif |
return; |
return; |
} |
} |
|
if (cur->type == XML_NAMESPACE_DECL) |
|
return; |
if (cur->type == XML_DTD_NODE) { |
if (cur->type == XML_DTD_NODE) { |
xmlDocPtr doc; |
xmlDocPtr doc; |
doc = cur->doc; |
doc = cur->doc; |
Line 3830 xmlUnlinkNode(xmlNodePtr cur) {
|
Line 3847 xmlUnlinkNode(xmlNodePtr cur) {
|
xmlNodePtr |
xmlNodePtr |
xmlReplaceNode(xmlNodePtr old, xmlNodePtr cur) { |
xmlReplaceNode(xmlNodePtr old, xmlNodePtr cur) { |
if (old == cur) return(NULL); |
if (old == cur) return(NULL); |
if ((old == NULL) || (old->parent == NULL)) { | if ((old == NULL) || (old->type == XML_NAMESPACE_DECL) || |
| (old->parent == NULL)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlReplaceNode : old == NULL or without parent\n"); |
"xmlReplaceNode : old == NULL or without parent\n"); |
#endif |
#endif |
return(NULL); |
return(NULL); |
} |
} |
if (cur == NULL) { | if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) { |
xmlUnlinkNode(old); |
xmlUnlinkNode(old); |
return(old); |
return(old); |
} |
} |
Line 3951 xmlCopyPropInternal(xmlDocPtr doc, xmlNodePtr target,
|
Line 3969 xmlCopyPropInternal(xmlDocPtr doc, xmlNodePtr target,
|
xmlAttrPtr ret; |
xmlAttrPtr ret; |
|
|
if (cur == NULL) return(NULL); |
if (cur == NULL) return(NULL); |
|
if ((target != NULL) && (target->type != XML_ELEMENT_NODE)) |
|
return(NULL); |
if (target != NULL) |
if (target != NULL) |
ret = xmlNewDocProp(target->doc, cur->name, NULL); |
ret = xmlNewDocProp(target->doc, cur->name, NULL); |
else if (doc != NULL) |
else if (doc != NULL) |
Line 4070 xmlCopyPropList(xmlNodePtr target, xmlAttrPtr cur) {
|
Line 4090 xmlCopyPropList(xmlNodePtr target, xmlAttrPtr cur) {
|
xmlAttrPtr ret = NULL; |
xmlAttrPtr ret = NULL; |
xmlAttrPtr p = NULL,q; |
xmlAttrPtr p = NULL,q; |
|
|
|
if ((target != NULL) && (target->type != XML_ELEMENT_NODE)) |
|
return(NULL); |
while (cur != NULL) { |
while (cur != NULL) { |
q = xmlCopyProp(target, cur); |
q = xmlCopyProp(target, cur); |
if (q == NULL) |
if (q == NULL) |
Line 4515 xmlCopyDoc(xmlDocPtr doc, int recursive) {
|
Line 4537 xmlCopyDoc(xmlDocPtr doc, int recursive) {
|
************************************************************************/ |
************************************************************************/ |
|
|
/** |
/** |
* xmlGetLineNo: | * xmlGetLineNoInternal: |
* @node: valid node |
* @node: valid node |
|
* @depth: used to limit any risk of recursion |
* |
* |
* Get line number of @node. This requires activation of this option | * Get line number of @node. |
* before invoking the parser by calling xmlLineNumbersDefault(1) | * Try to override the limitation of lines being store in 16 bits ints |
* |
* |
* Returns the line number if successful, -1 otherwise |
* Returns the line number if successful, -1 otherwise |
*/ |
*/ |
long | static long |
xmlGetLineNo(xmlNodePtr node) | xmlGetLineNoInternal(xmlNodePtr node, int depth) |
{ |
{ |
long result = -1; |
long result = -1; |
|
|
|
if (depth >= 5) |
|
return(-1); |
|
|
if (!node) |
if (!node) |
return result; |
return result; |
if ((node->type == XML_ELEMENT_NODE) || |
if ((node->type == XML_ELEMENT_NODE) || |
(node->type == XML_TEXT_NODE) || |
(node->type == XML_TEXT_NODE) || |
(node->type == XML_COMMENT_NODE) || |
(node->type == XML_COMMENT_NODE) || |
(node->type == XML_PI_NODE)) | (node->type == XML_PI_NODE)) { |
result = (long) node->line; | if (node->line == 65535) { |
else if ((node->prev != NULL) && | if ((node->type == XML_TEXT_NODE) && (node->psvi != NULL)) |
| result = (long) node->psvi; |
| else if ((node->type == XML_ELEMENT_NODE) && |
| (node->children != NULL)) |
| result = xmlGetLineNoInternal(node->children, depth + 1); |
| else if (node->next != NULL) |
| result = xmlGetLineNoInternal(node->next, depth + 1); |
| else if (node->prev != NULL) |
| result = xmlGetLineNoInternal(node->prev, depth + 1); |
| } |
| if ((result == -1) || (result == 65535)) |
| result = (long) node->line; |
| } else if ((node->prev != NULL) && |
((node->prev->type == XML_ELEMENT_NODE) || |
((node->prev->type == XML_ELEMENT_NODE) || |
(node->prev->type == XML_TEXT_NODE) || |
(node->prev->type == XML_TEXT_NODE) || |
(node->prev->type == XML_COMMENT_NODE) || |
(node->prev->type == XML_COMMENT_NODE) || |
(node->prev->type == XML_PI_NODE))) |
(node->prev->type == XML_PI_NODE))) |
result = xmlGetLineNo(node->prev); | result = xmlGetLineNoInternal(node->prev, depth + 1); |
else if ((node->parent != NULL) && |
else if ((node->parent != NULL) && |
(node->parent->type == XML_ELEMENT_NODE)) |
(node->parent->type == XML_ELEMENT_NODE)) |
result = xmlGetLineNo(node->parent); | result = xmlGetLineNoInternal(node->parent, depth + 1); |
|
|
return result; |
return result; |
} |
} |
|
|
|
/** |
|
* xmlGetLineNo: |
|
* @node: valid node |
|
* |
|
* Get line number of @node. |
|
* Try to override the limitation of lines being store in 16 bits ints |
|
* if XML_PARSE_BIG_LINES parser option was used |
|
* |
|
* Returns the line number if successful, -1 otherwise |
|
*/ |
|
long |
|
xmlGetLineNo(xmlNodePtr node) |
|
{ |
|
return(xmlGetLineNoInternal(node, 0)); |
|
} |
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) |
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) |
/** |
/** |
* xmlGetNodePath: |
* xmlGetNodePath: |
Line 4570 xmlGetNodePath(xmlNodePtr node)
|
Line 4624 xmlGetNodePath(xmlNodePtr node)
|
char nametemp[100]; |
char nametemp[100]; |
int occur = 0, generic; |
int occur = 0, generic; |
|
|
if (node == NULL) | if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) |
return (NULL); |
return (NULL); |
|
|
buf_len = 500; |
buf_len = 500; |
Line 4835 xmlDocSetRootElement(xmlDocPtr doc, xmlNodePtr root) {
|
Line 4889 xmlDocSetRootElement(xmlDocPtr doc, xmlNodePtr root) {
|
xmlNodePtr old = NULL; |
xmlNodePtr old = NULL; |
|
|
if (doc == NULL) return(NULL); |
if (doc == NULL) return(NULL); |
if (root == NULL) | if ((root == NULL) || (root->type == XML_NAMESPACE_DECL)) |
return(NULL); |
return(NULL); |
xmlUnlinkNode(root); |
xmlUnlinkNode(root); |
xmlSetTreeDoc(root, doc); |
xmlSetTreeDoc(root, doc); |
Line 4922 xmlChar *
|
Line 4976 xmlChar *
|
xmlNodeGetLang(xmlNodePtr cur) { |
xmlNodeGetLang(xmlNodePtr cur) { |
xmlChar *lang; |
xmlChar *lang; |
|
|
|
if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) |
|
return(NULL); |
while (cur != NULL) { |
while (cur != NULL) { |
lang = xmlGetNsProp(cur, BAD_CAST "lang", XML_XML_NAMESPACE); |
lang = xmlGetNsProp(cur, BAD_CAST "lang", XML_XML_NAMESPACE); |
if (lang != NULL) |
if (lang != NULL) |
Line 5001 int
|
Line 5057 int
|
xmlNodeGetSpacePreserve(xmlNodePtr cur) { |
xmlNodeGetSpacePreserve(xmlNodePtr cur) { |
xmlChar *space; |
xmlChar *space; |
|
|
|
if ((cur == NULL) || (cur->type != XML_ELEMENT_NODE)) |
|
return(-1); |
while (cur != NULL) { |
while (cur != NULL) { |
space = xmlGetNsProp(cur, BAD_CAST "space", XML_XML_NAMESPACE); |
space = xmlGetNsProp(cur, BAD_CAST "space", XML_XML_NAMESPACE); |
if (space != NULL) { |
if (space != NULL) { |
Line 5167 xmlNodeGetBase(xmlDocPtr doc, xmlNodePtr cur) {
|
Line 5225 xmlNodeGetBase(xmlDocPtr doc, xmlNodePtr cur) {
|
|
|
if ((cur == NULL) && (doc == NULL)) |
if ((cur == NULL) && (doc == NULL)) |
return(NULL); |
return(NULL); |
|
if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL)) |
|
return(NULL); |
if (doc == NULL) doc = cur->doc; |
if (doc == NULL) doc = cur->doc; |
if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE)) { |
if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE)) { |
cur = doc->children; |
cur = doc->children; |
Line 5246 xmlNodeGetBase(xmlDocPtr doc, xmlNodePtr cur) {
|
Line 5306 xmlNodeGetBase(xmlDocPtr doc, xmlNodePtr cur) {
|
int |
int |
xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr cur) |
xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr cur) |
{ |
{ |
|
xmlBufPtr buf; |
|
int ret; |
|
|
if ((cur == NULL) || (buffer == NULL)) return(-1); |
if ((cur == NULL) || (buffer == NULL)) return(-1); |
|
buf = xmlBufFromBuffer(buffer); |
|
ret = xmlBufGetNodeContent(buf, cur); |
|
buffer = xmlBufBackToBuffer(buf); |
|
if ((ret < 0) || (buffer == NULL)) |
|
return(-1); |
|
return(0); |
|
} |
|
|
|
/** |
|
* xmlBufGetNodeContent: |
|
* @buf: a buffer xmlBufPtr |
|
* @cur: the node being read |
|
* |
|
* Read the value of a node @cur, this can be either the text carried |
|
* directly by this node if it's a TEXT node or the aggregate string |
|
* of the values carried by this node child's (TEXT and ENTITY_REF). |
|
* Entity references are substituted. |
|
* Fills up the buffer @buffer with this value |
|
* |
|
* Returns 0 in case of success and -1 in case of error. |
|
*/ |
|
int |
|
xmlBufGetNodeContent(xmlBufPtr buf, xmlNodePtr cur) |
|
{ |
|
if ((cur == NULL) || (buf == NULL)) return(-1); |
switch (cur->type) { |
switch (cur->type) { |
case XML_CDATA_SECTION_NODE: |
case XML_CDATA_SECTION_NODE: |
case XML_TEXT_NODE: |
case XML_TEXT_NODE: |
xmlBufferCat(buffer, cur->content); | xmlBufCat(buf, cur->content); |
break; |
break; |
case XML_DOCUMENT_FRAG_NODE: |
case XML_DOCUMENT_FRAG_NODE: |
case XML_ELEMENT_NODE:{ |
case XML_ELEMENT_NODE:{ |
Line 5261 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr c
|
Line 5349 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr c
|
case XML_CDATA_SECTION_NODE: |
case XML_CDATA_SECTION_NODE: |
case XML_TEXT_NODE: |
case XML_TEXT_NODE: |
if (tmp->content != NULL) |
if (tmp->content != NULL) |
xmlBufferCat(buffer, tmp->content); | xmlBufCat(buf, tmp->content); |
break; |
break; |
case XML_ENTITY_REF_NODE: |
case XML_ENTITY_REF_NODE: |
xmlNodeBufGetContent(buffer, tmp); | xmlBufGetNodeContent(buf, tmp); |
break; |
break; |
default: |
default: |
break; |
break; |
Line 5308 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr c
|
Line 5396 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr c
|
|
|
while (tmp != NULL) { |
while (tmp != NULL) { |
if (tmp->type == XML_TEXT_NODE) |
if (tmp->type == XML_TEXT_NODE) |
xmlBufferCat(buffer, tmp->content); | xmlBufCat(buf, tmp->content); |
else |
else |
xmlNodeBufGetContent(buffer, tmp); | xmlBufGetNodeContent(buf, tmp); |
tmp = tmp->next; |
tmp = tmp->next; |
} |
} |
break; |
break; |
} |
} |
case XML_COMMENT_NODE: |
case XML_COMMENT_NODE: |
case XML_PI_NODE: |
case XML_PI_NODE: |
xmlBufferCat(buffer, cur->content); | xmlBufCat(buf, cur->content); |
break; |
break; |
case XML_ENTITY_REF_NODE:{ |
case XML_ENTITY_REF_NODE:{ |
xmlEntityPtr ent; |
xmlEntityPtr ent; |
Line 5335 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr c
|
Line 5423 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr c
|
* xmlNodeGetContent() which handles all possible node types */ |
* xmlNodeGetContent() which handles all possible node types */ |
tmp = ent->children; |
tmp = ent->children; |
while (tmp) { |
while (tmp) { |
xmlNodeBufGetContent(buffer, tmp); | xmlBufGetNodeContent(buf, tmp); |
tmp = tmp->next; |
tmp = tmp->next; |
} |
} |
break; |
break; |
Line 5357 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr c
|
Line 5445 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr c
|
if ((cur->type == XML_ELEMENT_NODE) || |
if ((cur->type == XML_ELEMENT_NODE) || |
(cur->type == XML_TEXT_NODE) || |
(cur->type == XML_TEXT_NODE) || |
(cur->type == XML_CDATA_SECTION_NODE)) { |
(cur->type == XML_CDATA_SECTION_NODE)) { |
xmlNodeBufGetContent(buffer, cur); | xmlBufGetNodeContent(buf, cur); |
} |
} |
cur = cur->next; |
cur = cur->next; |
} |
} |
break; |
break; |
case XML_NAMESPACE_DECL: |
case XML_NAMESPACE_DECL: |
xmlBufferCat(buffer, ((xmlNsPtr) cur)->href); | xmlBufCat(buf, ((xmlNsPtr) cur)->href); |
break; |
break; |
case XML_ELEMENT_DECL: |
case XML_ELEMENT_DECL: |
case XML_ATTRIBUTE_DECL: |
case XML_ATTRIBUTE_DECL: |
Line 5372 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr c
|
Line 5460 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr c
|
} |
} |
return(0); |
return(0); |
} |
} |
|
|
/** |
/** |
* xmlNodeGetContent: |
* xmlNodeGetContent: |
* @cur: the node being read |
* @cur: the node being read |
Line 5391 xmlNodeGetContent(xmlNodePtr cur)
|
Line 5480 xmlNodeGetContent(xmlNodePtr cur)
|
switch (cur->type) { |
switch (cur->type) { |
case XML_DOCUMENT_FRAG_NODE: |
case XML_DOCUMENT_FRAG_NODE: |
case XML_ELEMENT_NODE:{ |
case XML_ELEMENT_NODE:{ |
xmlBufferPtr buffer; | xmlBufPtr buf; |
xmlChar *ret; |
xmlChar *ret; |
|
|
buffer = xmlBufferCreateSize(64); | buf = xmlBufCreateSize(64); |
if (buffer == NULL) | if (buf == NULL) |
return (NULL); |
return (NULL); |
xmlNodeBufGetContent(buffer, cur); | xmlBufGetNodeContent(buf, cur); |
ret = buffer->content; | ret = xmlBufDetach(buf); |
buffer->content = NULL; | xmlBufFree(buf); |
xmlBufferFree(buffer); | |
return (ret); |
return (ret); |
} |
} |
case XML_ATTRIBUTE_NODE: |
case XML_ATTRIBUTE_NODE: |
Line 5412 xmlNodeGetContent(xmlNodePtr cur)
|
Line 5500 xmlNodeGetContent(xmlNodePtr cur)
|
return (NULL); |
return (NULL); |
case XML_ENTITY_REF_NODE:{ |
case XML_ENTITY_REF_NODE:{ |
xmlEntityPtr ent; |
xmlEntityPtr ent; |
xmlBufferPtr buffer; | xmlBufPtr buf; |
xmlChar *ret; |
xmlChar *ret; |
|
|
/* lookup entity declaration */ |
/* lookup entity declaration */ |
Line 5420 xmlNodeGetContent(xmlNodePtr cur)
|
Line 5508 xmlNodeGetContent(xmlNodePtr cur)
|
if (ent == NULL) |
if (ent == NULL) |
return (NULL); |
return (NULL); |
|
|
buffer = xmlBufferCreate(); | buf = xmlBufCreate(); |
if (buffer == NULL) | if (buf == NULL) |
return (NULL); |
return (NULL); |
|
|
xmlNodeBufGetContent(buffer, cur); | xmlBufGetNodeContent(buf, cur); |
|
|
ret = buffer->content; | ret = xmlBufDetach(buf); |
buffer->content = NULL; | xmlBufFree(buf); |
xmlBufferFree(buffer); | |
return (ret); |
return (ret); |
} |
} |
case XML_ENTITY_NODE: |
case XML_ENTITY_NODE: |
Line 5443 xmlNodeGetContent(xmlNodePtr cur)
|
Line 5530 xmlNodeGetContent(xmlNodePtr cur)
|
case XML_DOCB_DOCUMENT_NODE: |
case XML_DOCB_DOCUMENT_NODE: |
#endif |
#endif |
case XML_HTML_DOCUMENT_NODE: { |
case XML_HTML_DOCUMENT_NODE: { |
xmlBufferPtr buffer; | xmlBufPtr buf; |
xmlChar *ret; |
xmlChar *ret; |
|
|
buffer = xmlBufferCreate(); | buf = xmlBufCreate(); |
if (buffer == NULL) | if (buf == NULL) |
return (NULL); |
return (NULL); |
|
|
xmlNodeBufGetContent(buffer, (xmlNodePtr) cur); | xmlBufGetNodeContent(buf, (xmlNodePtr) cur); |
|
|
ret = buffer->content; | ret = xmlBufDetach(buf); |
buffer->content = NULL; | xmlBufFree(buf); |
xmlBufferFree(buffer); | |
return (ret); |
return (ret); |
} |
} |
case XML_NAMESPACE_DECL: { |
case XML_NAMESPACE_DECL: { |
Line 5775 xmlGetNsList(xmlDocPtr doc ATTRIBUTE_UNUSED, xmlNodePt
|
Line 5861 xmlGetNsList(xmlDocPtr doc ATTRIBUTE_UNUSED, xmlNodePt
|
int maxns = 10; |
int maxns = 10; |
int i; |
int i; |
|
|
|
if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) |
|
return(NULL); |
|
|
while (node != NULL) { |
while (node != NULL) { |
if (node->type == XML_ELEMENT_NODE) { |
if (node->type == XML_ELEMENT_NODE) { |
cur = node->nsDef; |
cur = node->nsDef; |
Line 5873 xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlC
|
Line 5962 xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlC
|
xmlNsPtr cur; |
xmlNsPtr cur; |
xmlNodePtr orig = node; |
xmlNodePtr orig = node; |
|
|
if (node == NULL) return(NULL); | if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) return(NULL); |
if ((nameSpace != NULL) && |
if ((nameSpace != NULL) && |
(xmlStrEqual(nameSpace, (const xmlChar *)"xml"))) { |
(xmlStrEqual(nameSpace, (const xmlChar *)"xml"))) { |
if ((doc == NULL) && (node->type == XML_ELEMENT_NODE)) { |
if ((doc == NULL) && (node->type == XML_ELEMENT_NODE)) { |
Line 6003 xmlSearchNsByHref(xmlDocPtr doc, xmlNodePtr node, cons
|
Line 6092 xmlSearchNsByHref(xmlDocPtr doc, xmlNodePtr node, cons
|
xmlNodePtr orig = node; |
xmlNodePtr orig = node; |
int is_attr; |
int is_attr; |
|
|
if ((node == NULL) || (href == NULL)) | if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) || (href == NULL)) |
return (NULL); |
return (NULL); |
if (xmlStrEqual(href, XML_XML_NAMESPACE)) { |
if (xmlStrEqual(href, XML_XML_NAMESPACE)) { |
/* |
/* |
Line 6094 xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xm
|
Line 6183 xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xm
|
xmlChar prefix[50]; |
xmlChar prefix[50]; |
int counter = 1; |
int counter = 1; |
|
|
if (tree == NULL) { | if ((tree == NULL) || (tree->type != XML_ELEMENT_NODE)) { |
#ifdef DEBUG_TREE |
#ifdef DEBUG_TREE |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlNewReconciliedNs : tree == NULL\n"); |
"xmlNewReconciliedNs : tree == NULL\n"); |
Line 7951 xmlDOMWrapNSNormGatherInScopeNs(xmlNsMapPtr *map,
|
Line 8040 xmlDOMWrapNSNormGatherInScopeNs(xmlNsMapPtr *map,
|
|
|
if ((map == NULL) || (*map != NULL)) |
if ((map == NULL) || (*map != NULL)) |
return (-1); |
return (-1); |
|
if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) |
|
return (-1); |
/* |
/* |
* Get in-scope ns-decls of @parent. |
* Get in-scope ns-decls of @parent. |
*/ |
*/ |
Line 8218 xmlSearchNsByNamespaceStrict(xmlDocPtr doc, xmlNodePtr
|
Line 8309 xmlSearchNsByNamespaceStrict(xmlDocPtr doc, xmlNodePtr
|
|
|
if ((doc == NULL) || (nsName == NULL) || (retNs == NULL)) |
if ((doc == NULL) || (nsName == NULL) || (retNs == NULL)) |
return (-1); |
return (-1); |
|
if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) |
|
return(-1); |
|
|
*retNs = NULL; |
*retNs = NULL; |
if (xmlStrEqual(nsName, XML_XML_NAMESPACE)) { |
if (xmlStrEqual(nsName, XML_XML_NAMESPACE)) { |
Line 8316 xmlSearchNsByPrefixStrict(xmlDocPtr doc, xmlNodePtr no
|
Line 8409 xmlSearchNsByPrefixStrict(xmlDocPtr doc, xmlNodePtr no
|
xmlNodePtr cur; |
xmlNodePtr cur; |
xmlNsPtr ns; |
xmlNsPtr ns; |
|
|
if ((doc == NULL) || (node == NULL)) | if ((doc == NULL) || (node == NULL) || (node->type == XML_NAMESPACE_DECL)) |
return (-1); | return(-1); |
|
|
if (retNs) |
if (retNs) |
*retNs = NULL; |
*retNs = NULL; |
Line 8385 xmlDOMWrapNSNormDeclareNsForced(xmlDocPtr doc,
|
Line 8478 xmlDOMWrapNSNormDeclareNsForced(xmlDocPtr doc,
|
char buf[50]; |
char buf[50]; |
const xmlChar *pref; |
const xmlChar *pref; |
int counter = 0; |
int counter = 0; |
|
|
|
if ((doc == NULL) || (elem == NULL) || (elem->type != XML_ELEMENT_NODE)) |
|
return(NULL); |
/* |
/* |
* Create a ns-decl on @anchor. |
* Create a ns-decl on @anchor. |
*/ |
*/ |
Line 8901 xmlDOMWrapAdoptBranch(xmlDOMWrapCtxtPtr ctxt,
|
Line 8997 xmlDOMWrapAdoptBranch(xmlDOMWrapCtxtPtr ctxt,
|
parnsdone = 0; |
parnsdone = 0; |
|
|
cur = node; |
cur = node; |
|
if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL)) |
|
goto internal_error; |
|
|
while (cur != NULL) { |
while (cur != NULL) { |
/* |
/* |
* Paranoid source-doc sanity check. |
* Paranoid source-doc sanity check. |
Line 9280 xmlDOMWrapCloneNode(xmlDOMWrapCtxtPtr ctxt,
|
Line 9379 xmlDOMWrapCloneNode(xmlDOMWrapCtxtPtr ctxt,
|
*resNode = NULL; |
*resNode = NULL; |
|
|
cur = node; |
cur = node; |
|
if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL)) |
|
return(-1); |
|
|
while (cur != NULL) { |
while (cur != NULL) { |
if (cur->doc != sourceDoc) { |
if (cur->doc != sourceDoc) { |
/* |
/* |
Line 9797 xmlDOMWrapAdoptAttr(xmlDOMWrapCtxtPtr ctxt,
|
Line 9899 xmlDOMWrapAdoptAttr(xmlDOMWrapCtxtPtr ctxt,
|
if (attr->children == NULL) |
if (attr->children == NULL) |
return (0); |
return (0); |
cur = attr->children; |
cur = attr->children; |
|
if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL)) |
|
goto internal_error; |
while (cur != NULL) { |
while (cur != NULL) { |
cur->doc = destDoc; |
cur->doc = destDoc; |
switch (cur->type) { |
switch (cur->type) { |
Line 9881 xmlDOMWrapAdoptNode(xmlDOMWrapCtxtPtr ctxt,
|
Line 9985 xmlDOMWrapAdoptNode(xmlDOMWrapCtxtPtr ctxt,
|
xmlNodePtr destParent, |
xmlNodePtr destParent, |
int options) |
int options) |
{ |
{ |
if ((node == NULL) || (destDoc == NULL) || | if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) || |
| (destDoc == NULL) || |
((destParent != NULL) && (destParent->doc != destDoc))) |
((destParent != NULL) && (destParent->doc != destDoc))) |
return(-1); |
return(-1); |
/* |
/* |