| /////////////////////////////////////////////////////////////////////////// | |
| // | |
| // Copyright (c) 2000-2003 Intel Corporation | |
| // All rights reserved. | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are met: | |
| // | |
| // * Redistributions of source code must retain the above copyright notice, | |
| // this list of conditions and the following disclaimer. | |
| // * Redistributions in binary form must reproduce the above copyright notice, | |
| // this list of conditions and the following disclaimer in the documentation | |
| // and/or other materials provided with the distribution. | |
| // * Neither name of Intel Corporation nor the names of its contributors | |
| // may be used to endorse or promote products derived from this software | |
| // without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR | |
| // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |
| // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
| // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |
| // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY | |
| // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
| // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
| // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| // | |
| /////////////////////////////////////////////////////////////////////////// | |
| #include "xmlparser.h" | |
| /*================================================================ | |
| * XmlNodeInit | |
| * Intializes a node. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| void | |
| XmlNodeInit( XmlNode * nodeptr ) | |
| { | |
| assert( nodeptr != NULL ); | |
| memset( nodeptr, 0, sizeof( XmlNode ) ); | |
| } | |
| /*================================================================ | |
| * XmlCDATASectionInit | |
| * Initializes a CDATASection node. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| void | |
| XmlCDATASectionInit( XmlCDATASection * nodeptr ) | |
| { | |
| memset( nodeptr, 0, sizeof( XmlCDATASection ) ); | |
| } | |
| /*================================================================ | |
| * XmlCDATASectionFree | |
| * XFREEs a CDATASection node. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| void | |
| XmlCDATASectionFree( | |
| Pool * pool, | |
| XmlCDATASection * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| XmlNodeFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| ( XmlNode * ) nodeptr ); | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeFreeSingleNode | |
| * XFREEs a node content. | |
| * Internal to parser only. | |
| * | |
| *=================================================================*/ | |
| void | |
| XmlNodeFreeSingleNode( | |
| Pool * pool, | |
| XmlNode * nodeptr ) | |
| { | |
| XmlElement *element = NULL; | |
| if ( nodeptr != NULL ) | |
| { | |
| if ( nodeptr->nodeName != NULL ) | |
| { | |
| PFREE( nodeptr->nodeName ); | |
| } | |
| if ( nodeptr->nodeValue != NULL ) | |
| { | |
| PFREE( nodeptr->nodeValue ); | |
| } | |
| if ( nodeptr->namespaceURI != NULL ) | |
| { | |
| PFREE( nodeptr->namespaceURI ); | |
| } | |
| if ( nodeptr->prefix != NULL ) | |
| { | |
| PFREE( nodeptr->prefix ); | |
| } | |
| if ( nodeptr->localName != NULL ) | |
| { | |
| PFREE( nodeptr->localName ); | |
| } | |
| if ( nodeptr->nodeType == XML_ELEMENT_NODE ) | |
| { | |
| element = ( XmlElement * ) nodeptr; | |
| PFREE( element->tagName ); | |
| } | |
| PFREE( nodeptr ); | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeFree | |
| * Frees all nodes under nodeptr subtree. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| void | |
| XmlNodeFree( | |
| Pool * pool, | |
| XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| XmlNodeFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr->firstChild ); | |
| XmlNodeFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr->nextSibling ); | |
| XmlNodeFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr->firstAttr ); | |
| XmlNodeFreeSingleNode( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr ); | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeGetNodeName | |
| * Returns the nodename(the qualified name) | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| const char * | |
| XmlNodeGetNodeName( XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| return ( nodeptr->nodeName ); | |
| } | |
| return NULL; | |
| } | |
| /*================================================================ | |
| * XmlNodeGetLocalName | |
| * Returns the node local name | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| const char * | |
| XmlNodeGetLocalName( XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| return ( nodeptr->localName ); | |
| } | |
| return NULL; | |
| } | |
| /*================================================================ | |
| * XmlNodeSetNamespaceURI | |
| * sets the namespace URI of the node. | |
| * Internal function. | |
| * Return: | |
| * XML_OK or failure | |
| * | |
| *=================================================================*/ | |
| int | |
| XmlNodeSetNamespaceURI( | |
| Pool * pool, | |
| XmlNode * nodeptr, | |
| IN char *namespaceURI ) | |
| { | |
| if ( nodeptr == NULL ) | |
| { | |
| return XML_INVALID_PARAMETER; | |
| } | |
| if ( nodeptr->namespaceURI != NULL ) | |
| { | |
| PFREE( nodeptr->namespaceURI ); | |
| nodeptr->namespaceURI = NULL; | |
| } | |
| if ( namespaceURI != NULL ) | |
| { | |
| nodeptr->namespaceURI = PSTRDUP( namespaceURI ); | |
| if ( nodeptr->namespaceURI == NULL ) | |
| { | |
| return XML_INSUFFICIENT_MEMORY; | |
| } | |
| } | |
| return XML_OK; | |
| } | |
| /*================================================================ | |
| * XmlNodeSetPrefix | |
| * set the prefix of the node. | |
| * Internal to parser only. | |
| * Returns: | |
| * XML_OK or failure. | |
| * | |
| *=================================================================*/ | |
| int | |
| XmlNodeSetPrefix( | |
| Pool * pool, | |
| XmlNode * nodeptr, | |
| IN char *prefix ) | |
| { | |
| if ( nodeptr == NULL ) | |
| { | |
| return XML_INVALID_PARAMETER; | |
| } | |
| if ( nodeptr->prefix != NULL ) | |
| { | |
| PFREE( nodeptr->prefix ); | |
| nodeptr->prefix = NULL; | |
| } | |
| if ( prefix != NULL ) | |
| { | |
| nodeptr->prefix = PSTRDUP( prefix ); | |
| if ( nodeptr->prefix == NULL ) | |
| { | |
| return XML_INSUFFICIENT_MEMORY; | |
| } | |
| } | |
| return XML_OK; | |
| } | |
| /*================================================================ | |
| * XmlNodeSetLocalName | |
| * set the localName of the node. | |
| * Internal to parser only. | |
| * Returns: | |
| * XML_OK or failure. | |
| * | |
| *=================================================================*/ | |
| int | |
| XmlNodeSetLocalName( | |
| Pool * pool, | |
| XmlNode * nodeptr, | |
| IN char *localName ) | |
| { | |
| assert( nodeptr != NULL ); | |
| if ( nodeptr->localName != NULL ) | |
| { | |
| PFREE( nodeptr->localName ); | |
| nodeptr->localName = NULL; | |
| } | |
| if ( localName != NULL ) | |
| { | |
| nodeptr->localName = PSTRDUP( localName ); | |
| if ( nodeptr->localName == NULL ) | |
| { | |
| return XML_INSUFFICIENT_MEMORY; | |
| } | |
| } | |
| return XML_OK; | |
| } | |
| /*================================================================ | |
| * XmlNodeGetNodeNamespaceURI | |
| * Returns the node namespaceURI | |
| * External function. | |
| * Returns: | |
| * the namespaceURI of the node | |
| * | |
| *=================================================================*/ | |
| const char * | |
| XmlNodeGetNamespaceURI( XmlNode * nodeptr ) | |
| { | |
| char * retNamespaceURI = NULL; | |
| if ( nodeptr != NULL ) | |
| { | |
| retNamespaceURI = nodeptr->namespaceURI; | |
| } | |
| return retNamespaceURI; | |
| } | |
| /*================================================================ | |
| * XmlNodeGetPrefix | |
| * Returns the node prefix | |
| * External function. | |
| * Returns: | |
| * the prefix of the node. | |
| * | |
| *=================================================================*/ | |
| char * | |
| XmlNodeGetPrefix( XmlNode * nodeptr ) | |
| { | |
| char * prefix = NULL; | |
| if ( nodeptr != NULL ) | |
| { | |
| prefix = nodeptr->prefix; | |
| } | |
| return prefix; | |
| } | |
| /*================================================================ | |
| * XmlNodeGetNodeValue | |
| * Returns the nodeValue of this node | |
| * External function. | |
| * Return: | |
| * the nodeValue of the node. | |
| * | |
| *=================================================================*/ | |
| char * | |
| XmlNodeGetNodeValue( XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| return ( nodeptr->nodeValue ); | |
| } | |
| return NULL; | |
| } | |
| /*================================================================ | |
| * XmlNodeSetNodeValue | |
| * Sets the nodeValue | |
| * Internal function. | |
| * Returns: | |
| * XML_OK or failure | |
| * | |
| *=================================================================*/ | |
| int | |
| XmlNodeSetNodeValue( | |
| Pool * pool, | |
| XmlNode * nodeptr, | |
| const char *newNodeValue ) | |
| { | |
| int rc = XML_OK; | |
| if ( nodeptr == NULL ) | |
| { | |
| return XML_INVALID_PARAMETER; | |
| } | |
| if ( nodeptr->nodeValue != NULL ) | |
| { | |
| PFREE( nodeptr->nodeValue ); | |
| nodeptr->nodeValue = NULL; | |
| } | |
| if ( newNodeValue != NULL ) | |
| { | |
| nodeptr->nodeValue = XmlStrduptrim( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newNodeValue ); | |
| if ( nodeptr->nodeValue == NULL ) | |
| { | |
| return XML_INSUFFICIENT_MEMORY; | |
| } | |
| } | |
| return rc; | |
| } | |
| /*================================================================ | |
| * XmlNodeGetNodeType | |
| * Gets the NodeType of this node | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| int | |
| XmlNodeGetNodeType( XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| return ( nodeptr->nodeType ); | |
| } | |
| else | |
| { | |
| return ( XML_INVALID_NODE ); | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeGetParentNode | |
| * Get the parent node | |
| * External function. | |
| * Return: | |
| * | |
| *=================================================================*/ | |
| XmlNode * | |
| XmlNodeGetParentNode( XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| return nodeptr->parentNode; | |
| } | |
| else | |
| { | |
| return NULL; | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeGetFirstChild | |
| * Returns the first child of nodeptr. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| XmlNode * | |
| XmlNodeGetFirstChild( XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| return nodeptr->firstChild; | |
| } | |
| else | |
| { | |
| return NULL; | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeGetLastChild | |
| * Returns the last child of nodeptr. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| XmlNode * | |
| XmlNodeGetLastChild( XmlNode * nodeptr ) | |
| { | |
| XmlNode * prev; | |
| XmlNode * next; | |
| if ( nodeptr != NULL ) | |
| { | |
| prev = nodeptr; | |
| next = nodeptr->firstChild; | |
| while ( next != NULL ) | |
| { | |
| prev = next; | |
| next = next->nextSibling; | |
| } | |
| return prev; | |
| } | |
| else | |
| { | |
| return NULL; | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeGetPreviousSibling | |
| * returns the previous sibling node of nodeptr. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| XmlNode * | |
| XmlNodeGetPreviousSibling( XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| return nodeptr->prevSibling; | |
| } | |
| else | |
| { | |
| return NULL; | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeGetNextSibling | |
| * Returns the next sibling node. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| XmlNode * | |
| XmlNodeGetNextSibling( XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| return nodeptr->nextSibling; | |
| } | |
| else | |
| { | |
| return NULL; | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeGetOwnerDocument | |
| * Returns the owner document node. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| XmlDocument * | |
| XmlNodeGetOwnerDocument( XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| return ( XmlDocument * ) nodeptr->ownerDocument; | |
| } | |
| else | |
| { | |
| return NULL; | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeIsAncestor | |
| * check if ancestorNode is ancestor of toFind | |
| * Internal to parser only. | |
| * Returns: | |
| * TRUE or FALSE | |
| * | |
| *=================================================================*/ | |
| BOOL | |
| XmlNodeIsAncestor( XmlNode * ancestorNode, | |
| XmlNode * toFind ) | |
| { | |
| BOOL found = FALSE; | |
| if ( ( ancestorNode != NULL ) && ( toFind != NULL ) ) | |
| { | |
| if ( toFind->parentNode == ancestorNode ) | |
| { | |
| return TRUE; | |
| } | |
| else | |
| { | |
| found = | |
| XmlNodeIsAncestor( ancestorNode->firstChild, toFind ); | |
| if ( found == FALSE ) | |
| { | |
| found = | |
| XmlNodeIsAncestor( ancestorNode->nextSibling, | |
| toFind ); | |
| } | |
| } | |
| } | |
| return found; | |
| } | |
| /*================================================================ | |
| * XmlNodeIsParent | |
| * Check whether toFind is a children of nodeptr. | |
| * Internal to parser only. | |
| * Return: | |
| * TRUE or FALSE | |
| * | |
| *=================================================================*/ | |
| BOOL | |
| XmlNodeIsParent( XmlNode * nodeptr, | |
| XmlNode * toFind ) | |
| { | |
| BOOL found = FALSE; | |
| assert( nodeptr != NULL && toFind != NULL ); | |
| if ( toFind->parentNode == nodeptr ) | |
| { | |
| found = TRUE; | |
| } | |
| return found; | |
| } | |
| /*================================================================ | |
| * XmlNodeAllowChildren | |
| * Check to see whether nodeptr allows children of type newChild. | |
| * Internal to parser only. | |
| * Returns: | |
| * TRUE, if nodeptr can have newChild as children | |
| * FALSE,if nodeptr cannot have newChild as children | |
| * | |
| *=================================================================*/ | |
| BOOL | |
| XmlNodeAllowChildren( XmlNode * nodeptr, | |
| XmlNode * newChild ) | |
| { | |
| assert( nodeptr != NULL && newChild != NULL ); | |
| switch ( nodeptr->nodeType ) | |
| { | |
| case XML_ATTRIBUTE_NODE: | |
| case XML_TEXT_NODE: | |
| case XML_CDATA_SECTION_NODE: | |
| return FALSE; | |
| break; | |
| case XML_ELEMENT_NODE: | |
| if ( ( newChild->nodeType == XML_ATTRIBUTE_NODE ) || | |
| ( newChild->nodeType == XML_DOCUMENT_NODE ) ) | |
| { | |
| return FALSE; | |
| } | |
| break; | |
| case XML_DOCUMENT_NODE: | |
| if ( newChild->nodeType != XML_ELEMENT_NODE ) | |
| { | |
| return FALSE; | |
| } | |
| default: | |
| break; | |
| } | |
| return TRUE; | |
| } | |
| /*================================================================ | |
| * XmlNodeCompare | |
| * Compare two nodes to see whether they are the same node. | |
| * Parent, sibling and children node are ignored. | |
| * Internal to parser only. | |
| * Returns: | |
| * TRUE, the two nodes are the same. | |
| * FALSE, the two nodes are not the same. | |
| * | |
| *=================================================================*/ | |
| BOOL | |
| XmlNodeCompare( XmlNode * srcNode, | |
| XmlNode * destNode ) | |
| { | |
| assert( srcNode != NULL && destNode != NULL ); | |
| if ( ( srcNode == destNode ) || | |
| ( strcmp( srcNode->nodeName, destNode->nodeName ) == 0 && | |
| strcmp( srcNode->nodeValue, destNode->nodeValue ) == 0 && | |
| ( srcNode->nodeType == destNode->nodeType ) && | |
| strcmp( srcNode->namespaceURI, destNode->namespaceURI ) == 0 && | |
| strcmp( srcNode->prefix, destNode->prefix ) == 0 && | |
| strcmp( srcNode->localName, destNode->localName ) == 0 ) ) | |
| { | |
| return TRUE; | |
| } | |
| else | |
| { | |
| return FALSE; | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeInsertBefore | |
| * Inserts the node newChild before the existing child node refChild. | |
| * If refChild is null, insert newChild at the end of the list of | |
| * children. If the newChild is already in the tree, it is first | |
| * removed. | |
| * External function. | |
| * Parameters: | |
| * newChild: the node to insert. | |
| * Returns: | |
| * | |
| *=================================================================*/ | |
| int | |
| XmlNodeInsertBefore( XmlNode * nodeptr, | |
| XmlNode * newChild, | |
| XmlNode * refChild ) | |
| { | |
| int ret = XML_OK; | |
| if ( ( nodeptr == NULL ) || ( newChild == NULL ) ) | |
| { | |
| return XML_INVALID_PARAMETER; | |
| } | |
| // whether nodeptr allow children of the type of newChild | |
| if ( XmlNodeAllowChildren( nodeptr, newChild ) == FALSE ) | |
| { | |
| return XML_HIERARCHY_REQUEST_ERR; | |
| } | |
| // or if newChild is one of nodeptr's ancestors | |
| if ( XmlNodeIsAncestor( newChild, nodeptr ) == TRUE ) | |
| { | |
| return XML_HIERARCHY_REQUEST_ERR; | |
| } | |
| // if newChild was created from a different document | |
| if ( nodeptr->ownerDocument != newChild->ownerDocument ) | |
| { | |
| return XML_WRONG_DOCUMENT_ERR; | |
| } | |
| // if refChild is not a child of nodeptr | |
| if ( XmlNodeIsParent( nodeptr, refChild ) == FALSE ) | |
| { | |
| return XML_NOT_FOUND_ERR; | |
| } | |
| if ( refChild != NULL ) | |
| { | |
| if ( XmlNodeIsParent( nodeptr, newChild ) == TRUE ) | |
| { | |
| XmlNodeRemoveChild( nodeptr, newChild, NULL ); | |
| newChild->nextSibling = NULL; | |
| newChild->prevSibling = NULL; | |
| } | |
| newChild->nextSibling = refChild; | |
| if ( refChild->prevSibling != NULL ) | |
| { | |
| ( refChild->prevSibling )->nextSibling = newChild; | |
| newChild->prevSibling = refChild->prevSibling; | |
| } | |
| refChild->prevSibling = newChild; | |
| if ( newChild->prevSibling == NULL ) | |
| { | |
| nodeptr->firstChild = newChild; | |
| } | |
| newChild->parentNode = nodeptr; | |
| } | |
| else | |
| { | |
| ret = XmlNodeAppendChild( nodeptr, newChild ); | |
| } | |
| return ret; | |
| } | |
| /*================================================================ | |
| * XmlNodeReplaceChild | |
| * Replaces the child node oldChild with newChild in the list of children, | |
| * and returns the oldChild node. | |
| * External function. | |
| * Parameters: | |
| * newChild: the new node to put in the child list. | |
| * oldChild: the node being replaced in the list. | |
| * returnNode: the node replaced. | |
| * Return Value: | |
| * XML_OK | |
| * XML_INVALID_PARAMETER: if anyone of nodeptr, newChild or oldChild is NULL. | |
| * XML_HIERARCHY_REQUEST_ERR: if the newChild is ancestor of nodeptr or nodeptr | |
| * is of a type that does not allow children of the | |
| * type of the newChild node. | |
| * XML_WRONG_DOCUMENT_ERR: if newChild was created from a different document than | |
| * the one that created this node. | |
| * XML_NOT_FOUND_ERR: if oldChild is not a child of nodeptr. | |
| * | |
| *=================================================================*/ | |
| int | |
| XmlNodeReplaceChild( XmlNode * nodeptr, | |
| XmlNode * newChild, | |
| XmlNode * oldChild, | |
| OUT XmlNode ** returnNode ) | |
| { | |
| int ret = XML_OK; | |
| if ( ( nodeptr == NULL ) || ( newChild == NULL ) | |
| || ( oldChild == NULL ) ) | |
| { | |
| return XML_INVALID_PARAMETER; | |
| } | |
| // if nodetype of nodeptr does not allow children of the type of newChild | |
| // needs to add later | |
| // or if newChild is one of nodeptr's ancestors | |
| if ( XmlNodeIsAncestor( newChild, nodeptr ) == TRUE ) | |
| { | |
| return XML_HIERARCHY_REQUEST_ERR; | |
| } | |
| if ( XmlNodeAllowChildren( nodeptr, newChild ) == FALSE ) | |
| { | |
| return XML_HIERARCHY_REQUEST_ERR; | |
| } | |
| // if newChild was created from a different document | |
| if ( nodeptr->ownerDocument != newChild->ownerDocument ) | |
| { | |
| return XML_WRONG_DOCUMENT_ERR; | |
| } | |
| // if refChild is not a child of nodeptr | |
| if ( XmlNodeIsParent( nodeptr, oldChild ) != TRUE ) | |
| { | |
| return XML_NOT_FOUND_ERR; | |
| } | |
| ret = XmlNodeInsertBefore( nodeptr, newChild, oldChild ); | |
| if ( ret != XML_OK ) | |
| { | |
| return ret; | |
| } | |
| ret = XmlNodeRemoveChild( nodeptr, oldChild, returnNode ); | |
| return ret; | |
| } | |
| /*================================================================ | |
| * XmlNodeRemoveChild | |
| * Removes the child node indicated by oldChild from the list of | |
| * children, and returns it. | |
| * External function. | |
| * Parameters: | |
| * oldChild: the node being removed. | |
| * returnNode: the node removed. | |
| * Return Value: | |
| * XML_OK | |
| * XML_NOT_FOUND_ERR: if oldChild is not a child of this node. | |
| * XML_INVALID_PARAMETER: if either oldChild or nodeptr is NULL | |
| * | |
| *=================================================================*/ | |
| int | |
| XmlNodeRemoveChild( XmlNode * nodeptr, | |
| XmlNode * oldChild, | |
| OUT XmlNode ** returnNode ) | |
| { | |
| if ( ( nodeptr == NULL ) || ( oldChild == NULL ) ) | |
| { | |
| return XML_INVALID_PARAMETER; | |
| } | |
| if ( XmlNodeIsParent( nodeptr, oldChild ) == FALSE ) | |
| { | |
| return XML_NOT_FOUND_ERR; | |
| } | |
| if ( oldChild->prevSibling != NULL ) | |
| { | |
| ( oldChild->prevSibling )->nextSibling = oldChild->nextSibling; | |
| } | |
| if ( nodeptr->firstChild == oldChild ) | |
| { | |
| nodeptr->firstChild = oldChild->nextSibling; | |
| } | |
| if ( oldChild->nextSibling != NULL ) | |
| { | |
| ( oldChild->nextSibling )->prevSibling = oldChild->prevSibling; | |
| } | |
| oldChild->nextSibling = NULL; | |
| oldChild->prevSibling = NULL; | |
| oldChild->parentNode = NULL; | |
| if ( returnNode != NULL ) | |
| { | |
| *returnNode = oldChild; | |
| } | |
| return XML_OK; | |
| } | |
| /*======================================================================================== | |
| * XmlNodeAppendChild | |
| * Adds the node newChild to the end of the list of children of this node. | |
| * If the newChild is already in the tree, it is first removed. | |
| * External function. | |
| * Parameter: | |
| * newChild: the node to add. | |
| * Return Value: | |
| * XML_OK | |
| * XML_INVALID_PARAMETER: if either nodeptr or newChild is NULL | |
| * XML_WRONG_DOCUMENT_ERR: if newChild was created from a different document than | |
| * the one that created nodeptr. | |
| * XML_HIERARCHY_REQUEST_ERR: if newChild is ancestor of nodeptr or if nodeptr is of | |
| * a type that does not allow children of the type of the | |
| * newChild node. | |
| * | |
| *========================================================================================*/ | |
| int | |
| XmlNodeAppendChild( XmlNode * nodeptr, | |
| XmlNode * newChild ) | |
| { | |
| XmlNode * prev = NULL; | |
| XmlNode * next = NULL; | |
| if ( ( nodeptr == NULL ) || ( newChild == NULL ) ) | |
| { | |
| return XML_INVALID_PARAMETER; | |
| } | |
| // if newChild was created from a different document | |
| if ( ( newChild->ownerDocument != NULL ) && | |
| ( nodeptr->ownerDocument != newChild->ownerDocument ) ) | |
| { | |
| return XML_WRONG_DOCUMENT_ERR; | |
| } | |
| // if newChild is an ancestor of nodeptr | |
| if ( XmlNodeIsAncestor( newChild, nodeptr ) == TRUE ) | |
| { | |
| return XML_HIERARCHY_REQUEST_ERR; | |
| } | |
| // if nodeptr does not allow to have newChild as children | |
| if ( XmlNodeAllowChildren( nodeptr, newChild ) == FALSE ) | |
| { | |
| return XML_HIERARCHY_REQUEST_ERR; | |
| } | |
| if ( XmlNodeIsParent( nodeptr, newChild ) == TRUE ) | |
| { | |
| XmlNodeRemoveChild( nodeptr, newChild, NULL ); | |
| } | |
| // set the parent node pointer | |
| newChild->parentNode = nodeptr; | |
| newChild->ownerDocument = nodeptr->ownerDocument; | |
| //if the first child | |
| if ( nodeptr->firstChild == NULL ) | |
| { | |
| nodeptr->firstChild = newChild; | |
| } | |
| else | |
| { | |
| prev = nodeptr->firstChild; | |
| next = prev->nextSibling; | |
| while ( next != NULL ) | |
| { | |
| prev = next; | |
| next = prev->nextSibling; | |
| } | |
| prev->nextSibling = newChild; | |
| newChild->prevSibling = prev; | |
| } | |
| return XML_OK; | |
| } | |
| /*================================================================ | |
| * XmlNodeCloneTextNode | |
| * Returns a clone of nodeptr | |
| * Internal to parser only. | |
| * | |
| *=================================================================*/ | |
| XmlNode * | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| XmlNodeCloneTextNode(Pool * pool, XmlNode * nodeptr ) | |
| #else | |
| XmlNodeCloneTextNode( XmlNode * nodeptr ) | |
| #endif | |
| { | |
| XmlNode * newNode = NULL; | |
| assert( nodeptr != NULL ); | |
| newNode = ( XmlNode * ) PMALLOC( sizeof( XmlNode ) ); | |
| if ( newNode == NULL ) | |
| { | |
| return NULL; | |
| } | |
| else | |
| { | |
| XmlNodeInit( newNode ); | |
| XmlNodeSetNodeName( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newNode, nodeptr->nodeName ); | |
| XmlNodeSetNodeValue( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newNode, nodeptr->nodeValue ); | |
| newNode->nodeType = XML_TEXT_NODE; | |
| } | |
| return newNode; | |
| } | |
| /*================================================================ | |
| * XmlNodeCloneCDATASect | |
| * Return a clone of CDATASection node. | |
| * Internal to parser only. | |
| * | |
| *=================================================================*/ | |
| XmlCDATASection * | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| XmlNodeCloneCDATASect(Pool * pool, XmlCDATASection * nodeptr ) | |
| #else | |
| XmlNodeCloneCDATASect( XmlCDATASection * nodeptr ) | |
| #endif | |
| { | |
| XmlCDATASection *newCDATA = NULL; | |
| XmlNode * newNode; | |
| XmlNode * srcNode; | |
| assert( nodeptr != NULL ); | |
| newCDATA = | |
| ( XmlCDATASection * ) PMALLOC( sizeof( XmlCDATASection ) ); | |
| if ( newCDATA != NULL ) | |
| { | |
| newNode = ( XmlNode * ) newCDATA; | |
| XmlNodeInit( newNode ); | |
| srcNode = ( XmlNode * ) nodeptr; | |
| XmlNodeSetNodeName( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newNode, srcNode->nodeName ); | |
| XmlNodeSetNodeValue( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newNode, srcNode->nodeValue ); | |
| newNode->nodeType = XML_CDATA_SECTION_NODE; | |
| } | |
| return newCDATA; | |
| } | |
| /*================================================================ | |
| * XmlNodeCloneElement | |
| * returns a clone of element node | |
| * Internal to parser only. | |
| * | |
| *=================================================================*/ | |
| XmlElement * | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| XmlNodeCloneElement(Pool * pool, XmlElement * nodeptr ) | |
| #else | |
| XmlNodeCloneElement( XmlElement * nodeptr ) | |
| #endif | |
| { | |
| XmlElement *newElement; | |
| XmlNode * elementNode; | |
| XmlNode * srcNode; | |
| int rc; | |
| assert( nodeptr != NULL ); | |
| newElement = ( XmlElement * ) PMALLOC( sizeof( XmlElement ) ); | |
| if ( newElement == NULL ) | |
| { | |
| return NULL; | |
| } | |
| XmlElementInit( newElement ); | |
| rc = XmlElementSetTagName( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newElement, nodeptr->tagName ); | |
| if ( rc != XML_OK ) | |
| { | |
| goto ErrorHandle; | |
| } | |
| elementNode = ( XmlNode * ) newElement; | |
| srcNode = ( XmlNode * ) nodeptr; | |
| rc = XmlNodeSetNodeName( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| elementNode, srcNode->nodeName ); | |
| if ( rc != XML_OK ) | |
| { | |
| goto ErrorHandle; | |
| } | |
| rc = XmlNodeSetNodeValue( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| elementNode, srcNode->nodeValue ); | |
| if ( rc != XML_OK ) | |
| { | |
| goto ErrorHandle; | |
| } | |
| rc = XmlNodeSetNamespaceURI( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| elementNode, srcNode->namespaceURI ); | |
| if ( rc != XML_OK ) | |
| { | |
| goto ErrorHandle; | |
| } | |
| rc = XmlNodeSetPrefix( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| elementNode, srcNode->prefix ); | |
| if ( rc != XML_OK ) | |
| { | |
| goto ErrorHandle; | |
| } | |
| rc = XmlNodeSetLocalName( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| elementNode, srcNode->localName ); | |
| if ( rc != XML_OK ) | |
| { | |
| goto ErrorHandle; | |
| } | |
| elementNode->nodeType = XML_ELEMENT_NODE; | |
| return newElement; | |
| ErrorHandle: | |
| XmlElementFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newElement ); | |
| return NULL; | |
| } | |
| /*================================================================ | |
| * XmlNodeCloneDoc | |
| * Returns a clone of document node | |
| * Internal to parser only. | |
| * | |
| *=================================================================*/ | |
| XmlDocument * | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| XmlNodeCloneDoc(Pool * pool, XmlDocument * nodeptr) | |
| #else | |
| XmlNodeCloneDoc(XmlDocument * nodeptr) | |
| #endif | |
| { | |
| XmlDocument *newDoc; | |
| XmlNode * docNode; | |
| int rc; | |
| assert( nodeptr != NULL ); | |
| newDoc = ( XmlDocument * ) PMALLOC( sizeof( XmlDocument ) ); | |
| if ( newDoc == NULL ) | |
| { | |
| return NULL; | |
| } | |
| XmlDocumentInit( newDoc ); | |
| docNode = ( XmlNode * ) newDoc; | |
| rc = XmlNodeSetNodeName( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| docNode, DOCUMENTNODENAME ); | |
| if ( rc != XML_OK ) | |
| { | |
| XmlDocumentFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newDoc ); | |
| return NULL; | |
| } | |
| newDoc->node.nodeType = XML_DOCUMENT_NODE; | |
| return newDoc; | |
| } | |
| /*================================================================ | |
| * XmlNodeCloneAttr | |
| * Returns a clone of attribute node | |
| * Internal to parser only | |
| * | |
| *=================================================================*/ | |
| XmlAttribute * | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| XmlNodeCloneAttr(Pool * pool, XmlAttribute * nodeptr ) | |
| #else | |
| XmlNodeCloneAttr( XmlAttribute * nodeptr ) | |
| #endif | |
| { | |
| XmlAttribute *newAttr; | |
| XmlNode * attrNode; | |
| XmlNode * srcNode; | |
| int rc; | |
| assert( nodeptr != NULL ); | |
| newAttr = ( XmlAttribute * ) PMALLOC( sizeof( XmlAttribute ) ); | |
| if ( newAttr == NULL ) | |
| { | |
| return NULL; | |
| } | |
| XmlAttrInit( newAttr ); | |
| attrNode = ( XmlNode * ) newAttr; | |
| srcNode = ( XmlNode * ) nodeptr; | |
| rc = XmlNodeSetNodeName( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| attrNode, srcNode->nodeName ); | |
| if ( rc != XML_OK ) | |
| { | |
| XmlAttrFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newAttr ); | |
| return NULL; | |
| } | |
| rc = XmlNodeSetNodeValue( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| attrNode, srcNode->nodeValue ); | |
| if ( rc != XML_OK ) | |
| { | |
| XmlAttrFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newAttr ); | |
| return NULL; | |
| } | |
| //check to see whether we need to split prefix and localname for attribute | |
| rc = XmlNodeSetNamespaceURI( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| attrNode, srcNode->namespaceURI ); | |
| if ( rc != XML_OK ) | |
| { | |
| XmlAttrFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newAttr ); | |
| return NULL; | |
| } | |
| rc = XmlNodeSetPrefix( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| attrNode, srcNode->prefix ); | |
| if ( rc != XML_OK ) | |
| { | |
| XmlAttrFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newAttr ); | |
| return NULL; | |
| } | |
| rc = XmlNodeSetLocalName( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| attrNode, srcNode->localName ); | |
| if ( rc != XML_OK ) | |
| { | |
| XmlAttrFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newAttr ); | |
| return NULL; | |
| } | |
| attrNode->nodeType = XML_ATTRIBUTE_NODE; | |
| return newAttr; | |
| } | |
| /*================================================================ | |
| * XmlNodeCloneAttrDirect | |
| * Return a clone of attribute node, with specified field set | |
| * to TRUE. | |
| * | |
| *=================================================================*/ | |
| XmlAttribute * | |
| XmlNodeCloneAttrDirect( | |
| Pool * pool, | |
| XmlAttribute * nodeptr ) | |
| { | |
| XmlAttribute *newAttr; | |
| assert( nodeptr != NULL ); | |
| newAttr = XmlNodeCloneAttr( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr ); | |
| if ( newAttr != NULL ) | |
| { | |
| newAttr->specified = TRUE; | |
| } | |
| return newAttr; | |
| } | |
| void | |
| XmlNodeSetSiblingNodesParent( XmlNode * nodeptr ) | |
| { | |
| XmlNode * parentNode = nodeptr->parentNode; | |
| XmlNode * nextptr = nodeptr->nextSibling; | |
| while ( nextptr != NULL ) | |
| { | |
| nextptr->parentNode = parentNode; | |
| nextptr = nextptr->nextSibling; | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeCloneNodeTreeRecursive | |
| * recursive functions that clones node tree of nodeptr. | |
| * Internal to parser only. | |
| * | |
| *=================================================================*/ | |
| XmlNode * | |
| XmlNodeCloneNodeTreeRecursive( | |
| Pool * pool, | |
| XmlNode * nodeptr, | |
| IN BOOL deep ) | |
| { | |
| XmlNode * newNode = NULL; | |
| XmlElement *newElement; | |
| XmlAttribute *newAttr = NULL; | |
| XmlCDATASection *newCDATA = NULL; | |
| XmlDocument *newDoc; | |
| XmlNode * nextSib; | |
| if ( nodeptr != NULL ) | |
| { | |
| switch ( nodeptr->nodeType ) | |
| { | |
| case XML_ELEMENT_NODE: | |
| newElement = | |
| XmlNodeCloneElement( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| ( XmlElement * ) nodeptr ); | |
| if(NULL == newElement) | |
| { | |
| return NULL; | |
| } | |
| newElement->node.firstAttr = | |
| XmlNodeCloneNodeTreeRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr->firstAttr, | |
| deep ); | |
| if ( deep ) | |
| { | |
| newElement->node.firstChild = | |
| XmlNodeCloneNodeTreeRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr-> | |
| firstChild, | |
| deep ); | |
| if ( newElement->node.firstChild != NULL ) | |
| { | |
| ( newElement->node.firstChild )->parentNode = | |
| ( XmlNode * ) newElement; | |
| XmlNodeSetSiblingNodesParent( newElement->node. | |
| firstChild ); | |
| } | |
| nextSib = | |
| XmlNodeCloneNodeTreeRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr-> | |
| nextSibling, | |
| deep ); | |
| newElement->node.nextSibling = nextSib; | |
| if ( nextSib != NULL ) | |
| { | |
| nextSib->prevSibling = ( XmlNode * ) newElement; | |
| } | |
| } | |
| newNode = ( XmlNode * ) newElement; | |
| break; | |
| case XML_ATTRIBUTE_NODE: | |
| newAttr = XmlNodeCloneAttr( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| ( XmlAttribute * ) nodeptr ); | |
| if(NULL == newAttr) | |
| { | |
| return NULL; | |
| } | |
| nextSib = | |
| XmlNodeCloneNodeTreeRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr->nextSibling, | |
| deep ); | |
| newAttr->node.nextSibling = nextSib; | |
| if ( nextSib != NULL ) | |
| { | |
| nextSib->prevSibling = ( XmlNode * ) newAttr; | |
| } | |
| newNode = ( XmlNode * ) newAttr; | |
| break; | |
| case XML_TEXT_NODE: | |
| newNode = XmlNodeCloneTextNode( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr ); | |
| break; | |
| case XML_CDATA_SECTION_NODE: | |
| newCDATA = | |
| XmlNodeCloneCDATASect( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| ( XmlCDATASection * ) | |
| nodeptr ); | |
| newNode = ( XmlNode * ) newCDATA; | |
| break; | |
| case XML_DOCUMENT_NODE: | |
| newDoc = XmlNodeCloneDoc( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| ( XmlDocument * ) nodeptr ); | |
| if(NULL == newDoc) | |
| { | |
| return NULL; | |
| } | |
| newNode = ( XmlNode * ) newDoc; | |
| if ( deep ) | |
| { | |
| newNode->firstChild = | |
| XmlNodeCloneNodeTreeRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr-> | |
| firstChild, | |
| deep ); | |
| if ( newNode->firstChild != NULL ) | |
| { | |
| newNode->firstChild->parentNode = newNode; | |
| } | |
| } | |
| break; | |
| case XML_INVALID_NODE: | |
| case XML_ENTITY_REFERENCE_NODE: | |
| case XML_ENTITY_NODE: | |
| case XML_PROCESSING_INSTRUCTION_NODE: | |
| case XML_COMMENT_NODE: | |
| case XML_DOCUMENT_TYPE_NODE: | |
| case XML_DOCUMENT_FRAGMENT_NODE: | |
| case XML_NOTATION_NODE: | |
| break; | |
| } | |
| } | |
| return newNode; | |
| } | |
| /*================================================================ | |
| * XmlNodeCloneNodeTree | |
| * clones a node tree. | |
| * Internal to parser only. | |
| * | |
| *=================================================================*/ | |
| XmlNode * | |
| XmlNodeCloneNodeTree( | |
| Pool * pool, | |
| XmlNode * nodeptr, | |
| IN BOOL deep ) | |
| { | |
| XmlNode * newNode = NULL; | |
| XmlElement *newElement; | |
| XmlNode * childNode; | |
| assert( nodeptr != NULL ); | |
| switch ( nodeptr->nodeType ) | |
| { | |
| case XML_ELEMENT_NODE: | |
| newElement = | |
| XmlNodeCloneElement( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| ( XmlElement * ) nodeptr ); | |
| if(NULL == newElement) | |
| { | |
| return NULL; | |
| } | |
| newElement->node.firstAttr = | |
| XmlNodeCloneNodeTreeRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr->firstAttr, | |
| deep ); | |
| if ( deep ) | |
| { | |
| newElement->node.firstChild = | |
| XmlNodeCloneNodeTreeRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr->firstChild, | |
| deep ); | |
| childNode = newElement->node.firstChild; | |
| while ( childNode != NULL ) | |
| { | |
| childNode->parentNode = ( XmlNode * ) newElement; | |
| childNode = childNode->nextSibling; | |
| } | |
| newElement->node.nextSibling = NULL; | |
| } | |
| newNode = ( XmlNode * ) newElement; | |
| break; | |
| case XML_ATTRIBUTE_NODE: | |
| case XML_TEXT_NODE: | |
| case XML_CDATA_SECTION_NODE: | |
| case XML_DOCUMENT_NODE: | |
| newNode = XmlNodeCloneNodeTreeRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr, deep ); | |
| break; | |
| case XML_INVALID_NODE: | |
| case XML_ENTITY_REFERENCE_NODE: | |
| case XML_ENTITY_NODE: | |
| case XML_PROCESSING_INSTRUCTION_NODE: | |
| case XML_COMMENT_NODE: | |
| case XML_DOCUMENT_TYPE_NODE: | |
| case XML_DOCUMENT_FRAGMENT_NODE: | |
| case XML_NOTATION_NODE: | |
| break; | |
| } | |
| if(NULL != newNode) | |
| { | |
| // by spec, the duplicate node has no parent | |
| newNode->parentNode = NULL; | |
| } | |
| return newNode; | |
| } | |
| /*================================================================ | |
| * XmlNodeCloneNode | |
| * Clones a node, if deep==TRUE, clones subtree under nodeptr. | |
| * External function. | |
| * Returns: | |
| * the cloned node or NULL if error occurs. | |
| * | |
| *=================================================================*/ | |
| XmlNode * | |
| XmlNodeCloneNode( | |
| Pool * pool, | |
| XmlNode * nodeptr, | |
| IN BOOL deep ) | |
| { | |
| XmlNode * newNode; | |
| XmlAttribute *newAttrNode; | |
| if ( nodeptr == NULL ) | |
| { | |
| return NULL; | |
| } | |
| switch ( nodeptr->nodeType ) | |
| { | |
| case XML_ATTRIBUTE_NODE: | |
| newAttrNode = | |
| XmlNodeCloneAttrDirect( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| ( XmlAttribute * ) nodeptr ); | |
| return ( XmlNode * ) newAttrNode; | |
| break; | |
| default: | |
| newNode = XmlNodeCloneNodeTree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| nodeptr, deep ); | |
| return newNode; | |
| break; | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeGetChildNodes | |
| * Returns a XmlNodeList of all the child nodes of nodeptr. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| XmlNodeList * | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| XmlNodeGetChildNodes(Pool * pool, XmlNode * nodeptr ) | |
| #else | |
| XmlNodeGetChildNodes( XmlNode * nodeptr ) | |
| #endif | |
| { | |
| XmlNode * tempNode; | |
| XmlNodeList *newNodeList; | |
| int rc; | |
| if ( nodeptr == NULL ) | |
| { | |
| return NULL; | |
| } | |
| newNodeList = ( XmlNodeList * ) PMALLOC( sizeof( XmlNodeList ) ); | |
| if ( newNodeList == NULL ) | |
| { | |
| return NULL; | |
| } | |
| XmlNodeListInit( newNodeList ); | |
| tempNode = nodeptr->firstChild; | |
| while ( tempNode != NULL ) | |
| { | |
| rc = XmlNodeListAddToNodeList( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| &newNodeList, tempNode ); | |
| if ( rc != XML_OK ) | |
| { | |
| XmlNodeListFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| newNodeList ); | |
| return NULL; | |
| } | |
| tempNode = tempNode->nextSibling; | |
| } | |
| return newNodeList; | |
| } | |
| /*================================================================ | |
| * XmlNodeGetAttributes | |
| * returns a namedNodeMap of attributes of nodeptr | |
| * External function. | |
| * Returns: | |
| * | |
| *=================================================================*/ | |
| XmlNamedNodeMap * | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| XmlNodeGetAttributes(Pool * pool, XmlNode * nodeptr ) | |
| #else | |
| XmlNodeGetAttributes( XmlNode * nodeptr ) | |
| #endif | |
| { | |
| XmlNamedNodeMap *returnNamedNodeMap = NULL; | |
| XmlNode * tempNode; | |
| int rc; | |
| if ( nodeptr == NULL ) | |
| { | |
| return NULL; | |
| } | |
| if ( nodeptr->nodeType == XML_ELEMENT_NODE ) | |
| { | |
| returnNamedNodeMap = | |
| ( XmlNamedNodeMap * ) PMALLOC( sizeof( XmlNamedNodeMap ) ); | |
| if ( returnNamedNodeMap == NULL ) | |
| { | |
| return NULL; | |
| } | |
| XmlNamedNodeMapInit( returnNamedNodeMap ); | |
| tempNode = nodeptr->firstAttr; | |
| while ( tempNode != NULL ) | |
| { | |
| rc = XmlNamedNodeMapAddToNamedNodeMap( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| &returnNamedNodeMap, | |
| tempNode ); | |
| if ( rc != XML_OK ) | |
| { | |
| XmlNamedNodeMapFree( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| returnNamedNodeMap ); | |
| return NULL; | |
| } | |
| tempNode = tempNode->nextSibling; | |
| } | |
| return returnNamedNodeMap; | |
| } | |
| else // if not an ELEMENT_NODE | |
| { | |
| return NULL; | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeHasChildNodes | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| BOOL | |
| XmlNodeHasChildNodes( XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr == NULL ) | |
| { | |
| return FALSE; | |
| } | |
| return ( nodeptr->firstChild != NULL ); | |
| } | |
| /*================================================================ | |
| * XmlNodeHasAttributes | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| BOOL | |
| XmlNodeHasAttributes( XmlNode * nodeptr ) | |
| { | |
| if ( nodeptr != NULL ) | |
| { | |
| if ( ( nodeptr->nodeType == XML_ELEMENT_NODE ) | |
| && ( nodeptr->firstAttr != NULL ) ) | |
| { | |
| return TRUE; | |
| } | |
| } | |
| return FALSE; | |
| } | |
| /*================================================================ | |
| * XmlNodeGetElementsByTagNameRecursive | |
| * Recursively traverse the whole tree, search for element | |
| * with the given tagname. | |
| * Internal to parser. | |
| * | |
| *=================================================================*/ | |
| void | |
| XmlNodeGetElementsByTagNameRecursive( | |
| Pool * pool, | |
| XmlNode * n, | |
| IN char *tagname, | |
| OUT XmlNodeList ** list ) | |
| { | |
| const char *name; | |
| if ( n != NULL ) | |
| { | |
| if ( XmlNodeGetNodeType( n ) == XML_ELEMENT_NODE ) | |
| { | |
| name = XmlNodeGetNodeName( n )? XmlNodeGetNodeName( n ):""; | |
| if ( strcmp( tagname, name ) == 0 | |
| || strcmp( tagname, "*" ) == 0 ) | |
| { | |
| XmlNodeListAddToNodeList( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| list, n ); | |
| } | |
| } | |
| XmlNodeGetElementsByTagNameRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| XmlNodeGetFirstChild | |
| ( n ), tagname, list ); | |
| XmlNodeGetElementsByTagNameRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| XmlNodeGetNextSibling | |
| ( n ), tagname, list ); | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeGetElementsByTagName | |
| * Returns a nodeList of all descendant Elements with a given | |
| * tagName, in the order in which they are encountered in a | |
| * traversal of this element tree. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| void | |
| XmlNodeGetElementsByTagName( | |
| Pool * pool, | |
| XmlNode * n, | |
| IN char *tagname, | |
| OUT XmlNodeList ** list ) | |
| { | |
| const char *name; | |
| assert( n != NULL && tagname != NULL ); | |
| if ( XmlNodeGetNodeType( n ) == XML_ELEMENT_NODE ) | |
| { | |
| name = XmlNodeGetNodeName( n )?XmlNodeGetNodeName( n ):""; | |
| if ( strcmp( tagname, name ) == 0 || strcmp( tagname, "*" ) == 0 ) | |
| { | |
| XmlNodeListAddToNodeList( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| list, n ); | |
| } | |
| } | |
| XmlNodeGetElementsByTagNameRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| XmlNodeGetFirstChild( n ), | |
| tagname, list ); | |
| } | |
| /*================================================================ | |
| * XmlNodeGetElementsByTagNameNSRecursive | |
| * Internal function to parser. | |
| * | |
| * | |
| *=================================================================*/ | |
| void | |
| XmlNodeGetElementsByTagNameNSRecursive( | |
| Pool * pool, | |
| XmlNode * n, | |
| const char *namespaceURI, | |
| const char *localName, | |
| OUT XmlNodeList ** list ) | |
| { | |
| const char * nsURI; | |
| const char * name; | |
| if ( n != NULL ) | |
| { | |
| if ( XmlNodeGetNodeType( n ) == XML_ELEMENT_NODE ) | |
| { | |
| name = XmlNodeGetLocalName( n ); | |
| nsURI = XmlNodeGetNamespaceURI( n ); | |
| if ( ( name != NULL ) && ( nsURI != NULL ) && | |
| ( strcmp( namespaceURI, nsURI ) == 0 | |
| || strcmp( namespaceURI, "*" ) == 0 ) | |
| && ( strcmp( name, localName ) == 0 | |
| || strcmp( localName, "*" ) == 0 ) ) | |
| { | |
| XmlNodeListAddToNodeList( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| list, n ); | |
| } | |
| } | |
| XmlNodeGetElementsByTagNameNSRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| XmlNodeGetFirstChild | |
| ( n ), namespaceURI, | |
| localName, list ); | |
| XmlNodeGetElementsByTagNameNSRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| XmlNodeGetNextSibling | |
| ( n ), namespaceURI, | |
| localName, list ); | |
| } | |
| } | |
| /*================================================================ | |
| * XmlNodeGetElementsByTagNameNS | |
| * Returns a nodeList of all the descendant Elements with a given | |
| * local name and namespace URI in the order in which they are | |
| * encountered in a preorder traversal of this Elememt tree. | |
| * External function. | |
| * | |
| *=================================================================*/ | |
| void | |
| XmlNodeGetElementsByTagNameNS( | |
| Pool * pool, | |
| XmlNode * n, | |
| const char *namespaceURI, | |
| const char *localName, | |
| OUT XmlNodeList ** list ) | |
| { | |
| const char * nsURI; | |
| const char * name; | |
| assert( n != NULL && namespaceURI != NULL && localName != NULL ); | |
| if ( XmlNodeGetNodeType( n ) == XML_ELEMENT_NODE ) | |
| { | |
| name = XmlNodeGetLocalName( n ); | |
| nsURI = XmlNodeGetNamespaceURI( n ); | |
| if ( ( name != NULL ) && ( nsURI != NULL ) && | |
| ( strcmp( namespaceURI, nsURI ) == 0 | |
| || strcmp( namespaceURI, "*" ) == 0 ) | |
| && ( strcmp( name, localName ) == 0 | |
| || strcmp( localName, "*" ) == 0 ) ) | |
| { | |
| XmlNodeListAddToNodeList( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| list, n ); | |
| } | |
| } | |
| XmlNodeGetElementsByTagNameNSRecursive( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| XmlNodeGetFirstChild( n ), | |
| namespaceURI, localName, | |
| list ); | |
| } | |
| /*================================================================ | |
| * XmlNodeSetNodeName | |
| * Internal to parser only. | |
| * | |
| *=================================================================*/ | |
| int | |
| XmlNodeSetNodeName( | |
| Pool * pool, | |
| XmlNode * node, | |
| const char * qualifiedName ) | |
| { | |
| int rc = XML_OK; | |
| assert( node != NULL ); | |
| if ( node->nodeName != NULL ) | |
| { | |
| PFREE( node->nodeName ); | |
| node->nodeName = NULL; | |
| } | |
| if ( qualifiedName != NULL ) | |
| { | |
| // set the name part | |
| node->nodeName = PSTRDUP( qualifiedName ); | |
| if ( node->nodeName == NULL ) | |
| { | |
| return XML_INSUFFICIENT_MEMORY; | |
| } | |
| rc = XmlParserSetNodePrefixAndLocalName( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| node ); | |
| if ( rc != XML_OK ) | |
| { | |
| PFREE( node->nodeName ); | |
| } | |
| } | |
| return rc; | |
| } | |
| /*================================================================ | |
| * XmlNodeSetNodeProperties | |
| * Internal to parser only. | |
| * | |
| *=================================================================*/ | |
| int | |
| XmlNodeSetNodeProperties( | |
| Pool * pool, | |
| XmlNode * destNode, | |
| XmlNode * src ) | |
| { | |
| int rc; | |
| assert( destNode != NULL || src != NULL ); | |
| rc = XmlNodeSetNodeValue( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| destNode, src->nodeValue ); | |
| if ( rc != XML_OK ) | |
| { | |
| goto ErrorHandler; | |
| } | |
| rc = XmlNodeSetLocalName( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| destNode, src->localName ); | |
| if ( rc != XML_OK ) | |
| { | |
| goto ErrorHandler; | |
| } | |
| rc = XmlNodeSetPrefix( | |
| #ifdef USE_CWMP_MEMORY_POOL | |
| pool , | |
| #endif | |
| destNode, src->prefix ); | |
| if ( rc != XML_OK ) | |
| { | |
| goto ErrorHandler; | |
| } | |
| // set nodetype | |
| destNode->nodeType = src->nodeType; | |
| return XML_OK; | |
| ErrorHandler: | |
| #ifndef USE_CWMP_MEMORY_POOL | |
| if ( destNode->nodeName != NULL ) | |
| { | |
| PFREE( destNode->nodeName ); | |
| destNode->nodeName = NULL; | |
| } | |
| if ( destNode->nodeValue != NULL ) | |
| { | |
| PFREE( destNode->nodeValue ); | |
| destNode->nodeValue = NULL; | |
| } | |
| if ( destNode->localName != NULL ) | |
| { | |
| PFREE( destNode->localName ); | |
| destNode->localName = NULL; | |
| } | |
| #endif | |
| return XML_INSUFFICIENT_MEMORY; | |
| } |