Find file
Fetching contributors…
Cannot retrieve contributors at this time
282 lines (245 sloc) 7.04 KB
/* dom.h
* $Id$
* Author: Christian Glahn (2001)
*
* This header file provides some definitions for wrapper functions.
* These functions hide most of libxml2 code, and should make the
* code in the XS file more readable .
*
* The Functions are sorted in four parts:
* part 0 ..... general wrapper functions which do not belong
* to any of the other parts and not specified in DOM.
* part A ..... wrapper functions for general nodeaccess
* part B ..... document wrapper
* part C ..... element wrapper
*
* I did not implement any Text, CDATASection or comment wrapper functions,
* since it is pretty straightforeward to access these nodes.
*/
#ifndef __LIBXML_DOM_H__
#define __LIBXML_DOM_H__
#ifdef __cplusplus
extern "C" {
#endif
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include "ppport.h"
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxml/encoding.h>
#include <libxml/xmlerror.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/parserInternals.h>
#include <libxml/xmlIO.h>
#include <libxml/xpathInternals.h>
#include <libxml/globals.h>
#include <stdio.h>
#ifdef __cplusplus
}
#endif
/**
* part 0:
*
* unsortet.
**/
void
domReconcileNs(xmlNodePtr tree);
/**
* NAME domParseChar
* TYPE function
* SYNOPSIS
* int utf8char = domParseChar( curchar, &len );
*
* The current char value, if using UTF-8 this may actually span
* multiple bytes in the given string. This function parses an utf8
* character from a string into a UTF8 character (an integer). It uses
* a slightly modified version of libxml2's character parser. libxml2
* itself does not provide any function to parse characters dircetly
* from a string and test if they are valid utf8 characters.
*
* XML::LibXML uses this function rather than perls native UTF8
* support for two reasons:
* 1) perls UTF8 handling functions often lead to encoding errors,
* which partly comes, that they are badly documented.
* 2) not all perl versions XML::LibXML intends to run with have native
* UTF8 support.
*
* domParseChar() allows to use the very same code with all versions
* of perl :)
*
* Returns the current char value and its length
*
* NOTE: If the character passed to this function is not a UTF
* character, the return value will be 0 and the length of the
* character is -1!
*/
int
domParseChar( xmlChar *characters, int *len );
xmlNodePtr
domReadWellBalancedString( xmlDocPtr doc, xmlChar* string, int repair );
/**
* NAME domIsParent
* TYPE function
*
* tests if a node is an ancestor of another node
*
* SYNOPSIS
* if ( domIsParent(cur, ref) ) ...
*
* this function is very useful to resolve if an operation would cause
* circular references.
*
* the function returns 1 if the ref node is a parent of the cur node.
*/
int
domIsParent( xmlNodePtr cur, xmlNodePtr ref );
/**
* NAME domTestHierarchy
* TYPE function
*
* tests the general hierachy error
*
* SYNOPSIS
* if ( domTestHierarchy(cur, ref) ) ...
*
* this function tests the general hierarchy error.
* it tests if the ref node would cause any hierarchical error for
* cur node. the function evaluates domIsParent() internally.
*
* the function will retrun 1 if there is no hierarchical error found.
* otherwise it returns 0.
*/
int
domTestHierarchy( xmlNodePtr cur, xmlNodePtr ref );
/**
* NAME domTestDocument
* TYPE function
* SYNOPSIS
* if ( domTestDocument(cur, ref) )...
*
* this function extends the domTestHierarchy() function. It tests if the
* cur node is a document and if so, it will check if the ref node can be
* inserted. (e.g. Attribute or Element nodes must not be appended to a
* document node)
*/
int
domTestDocument( xmlNodePtr cur, xmlNodePtr ref );
/**
* NAME domAddNodeToList
* TYPE function
* SYNOPSIS
* domAddNodeToList( cur, prevNode, nextNode )
*
* This function inserts a node between the two nodes prevNode
* and nextNode. prevNode and nextNode MUST be adjacent nodes,
* otherwise the function leads into undefined states.
* Either prevNode or nextNode can be NULL to mark, that the
* node has to be inserted to the beginning or the end of the
* nodelist. in such case the given reference node has to be
* first or the last node in the list.
*
* if prevNode is the same node as cur node (or in case of a
* Fragment its first child) only the parent information will
* get updated.
*
* The function behaves different to libxml2's list functions.
* The function is aware about document fragments.
* the function does not perform any text node normalization!
*
* NOTE: this function does not perform any highlevel
* errorhandling. use this function with caution, since it can
* lead into undefined states.
*
* the function will return 1 if the cur node is appended to
* the list. otherwise the function returns 0.
*/
int
domAddNodeToList( xmlNodePtr cur, xmlNodePtr prev, xmlNodePtr next );
/**
* part A:
*
* class Node
**/
/* A.1 DOM specified section */
xmlChar *
domName( xmlNodePtr node );
void
domSetName( xmlNodePtr node, xmlChar* name );
xmlNodePtr
domAppendChild( xmlNodePtr self,
xmlNodePtr newChild );
xmlNodePtr
domReplaceChild( xmlNodePtr self,
xmlNodePtr newChlid,
xmlNodePtr oldChild );
xmlNodePtr
domRemoveChild( xmlNodePtr self,
xmlNodePtr Child );
xmlNodePtr
domInsertBefore( xmlNodePtr self,
xmlNodePtr newChild,
xmlNodePtr refChild );
xmlNodePtr
domInsertAfter( xmlNodePtr self,
xmlNodePtr newChild,
xmlNodePtr refChild );
/* A.3 extra functionality not specified in DOM L1/2*/
xmlChar*
domGetNodeValue( xmlNodePtr self );
void
domSetNodeValue( xmlNodePtr self, xmlChar* value );
xmlNodePtr
domReplaceNode( xmlNodePtr old, xmlNodePtr new );
/**
* part B:
*
* class Document
**/
/**
* NAME domImportNode
* TYPE function
* SYNOPSIS
* node = domImportNode( document, node, move, reconcileNS);
*
* the function will import a node to the given document. it will work safe
* with namespaces and subtrees.
*
* if move is set to 1, then the node will be entirely removed from its
* original document. if move is set to 0, the node will be copied with the
* deep option.
*
* if reconcileNS is 1, namespaces are reconciled.
*
* the function will return the imported node on success. otherwise NULL
* is returned
*/
xmlNodePtr
domImportNode( xmlDocPtr document, xmlNodePtr node, int move, int reconcileNS );
/**
* part C:
*
* class Element
**/
xmlNodeSetPtr
domGetElementsByTagName( xmlNodePtr self, xmlChar* name );
xmlNodeSetPtr
domGetElementsByTagNameNS( xmlNodePtr self, xmlChar* nsURI, xmlChar* name );
xmlNsPtr
domNewNs ( xmlNodePtr elem , xmlChar *prefix, xmlChar *href );
xmlAttrPtr
domGetAttrNode(xmlNodePtr node, const xmlChar *qname);
xmlAttrPtr
domSetAttributeNode( xmlNodePtr node , xmlAttrPtr attr );
int
domNodeNormalize( xmlNodePtr node );
int
domNodeNormalizeList( xmlNodePtr nodelist );
int
domRemoveNsRefs(xmlNodePtr tree, xmlNsPtr ns);
void
domAttrSerializeContent(xmlBufferPtr buffer, xmlAttrPtr attr);
void
domClearPSVI(xmlNodePtr tree);
#endif