embedaddon/libxml2/tree.c - diff

Return to tree.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2

Diff for /embedaddon/libxml2/tree.c between versions 1.1.1.2 and 1.1.1.3

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);
/*	/*

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1.1.2
changed lines
	Added in v.1.1.1.3