xmlreader.c revision 38ae7e4efe803ea78b6499cd05a394db32623e41
/*
* xmlreader.c: implements the xmlTextReader streaming node API
*
* NOTE:
* XmlTextReader.Normalization Property won't be supported, since
* it makes the parser non compliant to the XML recommendation
*
* See Copyright for the status of this software.
*
* daniel@veillard.com
*/
/*
* TODOs:
* - XML Schemas validation
*/
#define IN_LIBXML
#include "libxml.h"
#ifdef LIBXML_READER_ENABLED
#include <string.h> /* for memset() only ! */
#include <stdarg.h>
#ifdef HAVE_CTYPE_H
#include <ctype.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#include <libxml/xmlmemory.h>
#include <libxml/xmlreader.h>
#include <libxml/parserInternals.h>
#ifdef LIBXML_SCHEMAS_ENABLED
#include <libxml/xmlschemas.h>
#endif
#ifdef LIBXML_XINCLUDE_ENABLED
#include <libxml/xinclude.h>
#endif
#ifdef LIBXML_PATTERN_ENABLED
#endif
/* #define DEBUG_CALLBACKS */
/* #define DEBUG_READER */
/**
* TODO:
*
* macro to flag unimplemented blocks
*/
#define TODO \
"Unimplemented block at %s:%d\n", \
#ifdef DEBUG_READER
#else
#define DUMP_READER
#endif
#define CHUNK_SIZE 512
/************************************************************************
* *
* The parser: maps the Text Reader API on top of the existing *
* parsing routines building a tree *
* *
************************************************************************/
#define XML_TEXTREADER_INPUT 1
#define XML_TEXTREADER_CTXT 2
typedef enum {
XML_TEXTREADER_NONE = -1,
typedef enum {
struct _xmlTextReader {
int mode; /* the parsing mode */
int allocs; /* what structure were deallocated */
unsigned int base; /* base of the segment in the input */
unsigned int cur; /* current position in the input */
int depth; /* depth of the current node */
int preserve;/* preserve the resulting document */
/* entity stack when traversing entities content */
int entNr; /* Depth of the entities stack */
int entMax; /* Max depth of the entities stack */
/* error handling */
void *errorFuncArg; /* callback function user argument */
#ifdef LIBXML_SCHEMAS_ENABLED
/* Handling of RelaxNG validation */
int rngValidErrors;/* The number of errors detected */
/* Handling of Schemas validation */
int xsdPreserveCtxt; /* 1 if the context was provided by the user */
int xsdValidErrors;/* The number of errors detected */
#endif
#ifdef LIBXML_XINCLUDE_ENABLED
/* Handling of XInclude processing */
int xinclude; /* is xinclude asked for */
int in_xinclude; /* counts for xinclude */
#endif
#ifdef LIBXML_PATTERN_ENABLED
int patternNr; /* number of preserve patterns */
int patternMax; /* max preserve patterns */
#endif
int preserves; /* level of preserves */
int parserFlags; /* the set of options set */
/* Structured error handling */
};
#define NODE_IS_EMPTY 0x1
#define NODE_IS_PRESERVED 0x2
#define NODE_IS_SPRESERVED 0x4
/**
* CONSTSTR:
*
* Macro used to return an interned string
*/
/************************************************************************
* *
* Our own version of the freeing routines as we recycle nodes *
* *
************************************************************************/
/**
* DICT_FREE:
* @str: a string
*
* Free a string if it is not owned by the "dict" dictionnary in the
* current scope
*/
/**
* xmlFreeID:
* @not: A id
*
* Deallocate the memory used by an id definition
*/
static void
}
/**
* xmlTextReaderRemoveID:
* @doc: the document
* @attr: the attribute
*
* Remove the given attribute from the ID table maintained internally.
*
* Returns -1 if the lookup failed and 0 otherwise
*/
static int
return(-1);
return(-1);
return(-1);
return(-1);
}
return(0);
}
/**
* xmlTextReaderFreeProp:
* @reader: the xmlTextReaderPtr used
* @cur: the node
*
* Free a node.
*/
static void
if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
/* Check for ID removal -> leading to invalid references ! */
}
} else {
}
}
/**
* xmlTextReaderFreePropList:
* @reader: the xmlTextReaderPtr used
* @cur: the first property in the list
*
* Free a property and all its siblings, all the children are freed too.
*/
static void
}
}
/**
* xmlTextReaderFreeNodeList:
* @reader: the xmlTextReaderPtr used
* @cur: the first node in the list
*
* Free a node and all its siblings, this is a recursive behaviour, all
* the children are freed too.
*/
static void
return;
}
return;
}
/* unroll to speed up freeing the document */
}
if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
}
/*
* we don't free element names here they are interned now
*/
} else {
}
}
}
}
/**
* xmlTextReaderFreeNode:
* @reader: the xmlTextReaderPtr used
* @cur: the node
*
* Free a node, this is a recursive behaviour, all the children are freed too.
* This doesn't unlink the child from the list, use xmlUnlinkNode() first.
*/
static void
return;
}
return;
}
return;
}
}
if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
}
/*
* we don't free names here they are interned now
*/
} else {
}
}
/**
* xmlTextReaderFreeIDTable:
* @table: An id table
*
* Deallocate the memory used by an ID hash table.
*/
static void
}
/**
* xmlTextReaderFreeDoc:
* @reader: the xmlTextReaderPtr used
* @cur: pointer to the document
*
* Free up all the structures used by a document, tree included.
*/
static void
if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
/*
* Do this before freeing the children list to avoid ID lookups
*/
}
}
}
/************************************************************************
* *
* The reader core parser *
* *
************************************************************************/
#ifdef DEBUG_READER
static void
return;
}
} else {
}
} else {
#ifdef LIBXML_DEBUG_ENABLED
#endif
}
}
#endif
/**
* xmlTextReaderEntPush:
* @reader: the xmlTextReaderPtr used
* @value: the entity reference node
*
* Pushes a new entity reference node on top of the entities stack
*
* Returns 0 in case of error, the index in the stack otherwise
*/
static int
{
return (0);
}
}
return (0);
}
}
}
/**
* xmlTextReaderEntPop:
* @reader: the xmlTextReaderPtr used
*
* Pops the top element entity from the entities stack
*
* Returns the entity just removed
*/
static xmlNodePtr
{
return (NULL);
else
return (ret);
}
/**
* xmlTextReaderStartElement:
* @ctx: the user data (XML parser context)
* @fullname: The element name, including namespace prefix
*
* called when an opening tag has been processed.
*/
static void
#ifdef DEBUG_CALLBACKS
#endif
}
}
/**
* xmlTextReaderEndElement:
* @ctx: the user data (XML parser context)
* @fullname: The element name, including namespace prefix
*
* called when an ending tag has been processed.
*/
static void
#ifdef DEBUG_CALLBACKS
#endif
}
}
/**
* xmlTextReaderStartElementNs:
* @ctx: the user data (XML parser context)
* @localname: the local name of the element
* @prefix: the element namespace prefix if available
* @URI: the element namespace name if available
* @nb_namespaces: number of namespace definitions on that node
* @nb_attributes: the number of attributes on that node
* nb_defaulted: the number of defaulted attributes.
* attribute values.
*
* called when an opening tag has been processed.
*/
static void
xmlTextReaderStartElementNs(void *ctx,
int nb_namespaces,
const xmlChar **namespaces,
int nb_attributes,
int nb_defaulted,
const xmlChar **attributes)
{
#ifdef DEBUG_CALLBACKS
#endif
}
}
/**
* xmlTextReaderEndElementNs:
* @ctx: the user data (XML parser context)
* @localname: the local name of the element
* @prefix: the element namespace prefix if available
* @URI: the element namespace name if available
*
* called when an ending tag has been processed.
*/
static void
xmlTextReaderEndElementNs(void *ctx,
{
#ifdef DEBUG_CALLBACKS
#endif
}
}
/**
* xmlTextReaderCharacters:
* @ctx: the user data (XML parser context)
* @ch: a xmlChar string
* @len: the number of xmlChar
*
* receiving some chars from the parser.
*/
static void
{
#ifdef DEBUG_CALLBACKS
printf("xmlTextReaderCharacters()\n");
#endif
}
}
/**
* xmlTextReaderCDataBlock:
* @ctx: the user data (XML parser context)
* @value: The pcdata content
* @len: the block length
*
* called when a pcdata block has been parsed
*/
static void
{
#ifdef DEBUG_CALLBACKS
printf("xmlTextReaderCDataBlock()\n");
#endif
}
}
/**
* xmlTextReaderPushData:
* @reader: the xmlTextReaderPtr used
*
* Push data down the progressive parser until a significant callback
* got raised.
*
* Returns -1 in case of failure, 0 otherwise
*/
static int
int val, s;
return(-1);
/*
* Refill the buffer unless we are at the end of the stream
*/
if ((val == 0) &&
}
} else if (val < 0) {
if ((oldstate != XML_TEXTREADER_START) ||
return(val);
} else if (val == 0) {
/* mark the end of the stream and process the remains */
break;
}
} else
break;
}
/*
* parse by block of CHUNK_SIZE bytes, various tests show that
* it's the best tradeoff at least on a 1.2GH Duron
*/
CHUNK_SIZE, 0);
return(-1);
} else {
s, 0);
return(-1);
break;
}
}
/*
* Discard the consumed input when needed and possible
*/
if (val >= 0) {
}
}
}
}
/*
* At the end of the stream signal that the work is done to the Push
* parser.
*/
s, 1);
return(-1);
}
}
return(0);
}
#ifdef LIBXML_REGEXP_ENABLED
/**
* xmlTextReaderValidatePush:
* @reader: the xmlTextReaderPtr used
*
* Push the current node for validation
*/
static void
#ifdef LIBXML_VALID_ENABLED
} else {
/* TODO use the BuildQName interface */
}
}
#endif /* LIBXML_VALID_ENABLED */
#ifdef LIBXML_SCHEMAS_ENABLED
int ret;
node);
if (ret == 0) {
/*
* this element requires a full tree
*/
printf("Expand failed !\n");
ret = -1;
} else {
node);
}
}
if (ret != 1)
reader->rngValidErrors++;
}
#endif
}
/**
* xmlTextReaderValidateCData:
* @reader: the xmlTextReaderPtr used
* @data: pointer to the CData
* @len: lenght of the CData block in bytes.
*
* Push some CData for validation
*/
static void
#ifdef LIBXML_VALID_ENABLED
}
#endif /* LIBXML_VALID_ENABLED */
#ifdef LIBXML_SCHEMAS_ENABLED
int ret;
if (ret != 1)
reader->rngValidErrors++;
}
#endif
}
/**
* xmlTextReaderValidatePop:
* @reader: the xmlTextReaderPtr used
*
* Pop the current node from validation
*/
static void
#ifdef LIBXML_VALID_ENABLED
} else {
/* TODO use the BuildQName interface */
}
}
#endif /* LIBXML_VALID_ENABLED */
#ifdef LIBXML_SCHEMAS_ENABLED
int ret;
return;
}
node);
if (ret != 1)
reader->rngValidErrors++;
}
#endif
}
/**
* xmlTextReaderValidateEntity:
* @reader: the xmlTextReaderPtr used
*
* Handle the validation when an entity reference is encountered and
* entity substitution is not activated. As a result the parser interface
* must walk through the entity and do the validation calls
*/
static void
do {
/*
* Case where the underlying tree is not availble, lookup the entity
* and walk it.
*/
}
continue;
} else {
/*
* The error has probably be raised already.
*/
break;
}
#ifdef LIBXML_REGEXP_ENABLED
#endif
}
/*
* go to next node
*/
continue;
}
continue;
}
do {
} else
break;
}
}
}
}
break;
break;
}
}
#endif /* LIBXML_REGEXP_ENABLED */
/**
* xmlTextReaderGetSuccessor:
* @cur: the current node
*
* Get the successor of a node if available.
*
* Returns the successor node or NULL
*/
static xmlNodePtr
do {
return(cur);
}
/**
* xmlTextReaderDoExpand:
* @reader: the xmlTextReaderPtr used
*
* Makes sure that the current node is fully read as well as all its
* descendant. It means the full DOM subtree must be available at the
* end of the call.
*
* Returns 1 if the node was expanded successfully, 0 if there is no more
* nodes to read, or -1 in case of error
*/
static int
int val;
return(-1);
do {
return(1);
return(1);
return(1);
if (val < 0){
return(-1);
}
return(1);
}
/**
* xmlTextReaderCollectSiblings:
* @node: the first child
*
* Traverse depth-first through all sibling nodes and their children
* nodes and concatenate their content. This is an auxiliary function
* to xmlTextReaderReadString.
*
* Returns a string containing the content, or NULL in case of error.
*/
static xmlChar *
{
buffer = xmlBufferCreate();
return NULL;
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
break;
case XML_ELEMENT_NODE: {
break;
}
default:
break;
}
}
return(ret);
}
/**
* xmlTextReaderRead:
* @reader: the xmlTextReaderPtr used
*
* Moves the position of the current instance to the next node in
* the stream, exposing its properties.
*
* Returns 1 if the node was read successfully, 0 if there is no more
* nodes to read, or -1 in case of error
*/
int
return(-1);
return(xmlTextReaderReadTree(reader));
return(-1);
return(-1);
#ifdef DEBUG_READER
#endif
/*
* Initial state
*/
do {
if (val < 0){
return(-1);
}
}
return(-1);
}
} else {
}
}
goto node_found;
}
return(0);
else
return(-1);
}
/*
* If we are not backtracking on ancestors or examined nodes,
* that the parser didn't finished or that we arent at the end
* of stream, continue processing.
*/
((oldstate == XML_TEXTREADER_BACKTRACK) ||
if (val < 0){
return(-1);
}
goto node_end;
}
if (oldstate != XML_TEXTREADER_BACKTRACK) {
goto node_found;
}
}
if ((oldstate == XML_TEXTREADER_ELEMENT) &&
#ifdef LIBXML_XINCLUDE_ENABLED
&& (reader->in_xinclude <= 0)
#endif
) {
goto node_found;
}
#ifdef LIBXML_REGEXP_ENABLED
#endif /* LIBXML_REGEXP_ENABLED */
/*
* Cleanup of the old node
*/
#ifdef LIBXML_XINCLUDE_ENABLED
(reader->in_xinclude == 0) &&
#endif
}
}
goto node_found;
}
if ((oldstate == XML_TEXTREADER_ELEMENT) &&
goto node_found;
}
#ifdef LIBXML_REGEXP_ENABLED
#endif /* LIBXML_REGEXP_ENABLED */
#ifdef LIBXML_DOCB_ENABLED
#endif
if (val != 0)
return(-1);
}
/*
* Cleanup of the old node
*/
#ifdef LIBXML_XINCLUDE_ENABLED
(reader->in_xinclude == 0) &&
#endif
}
goto node_end;
}
#ifdef LIBXML_XINCLUDE_ENABLED
(reader->in_xinclude == 0) &&
#endif
}
/*
* If we are in the middle of a piece of CDATA make sure it's finished
*/
return -1;
}
#ifdef LIBXML_XINCLUDE_ENABLED
/*
* Handle XInclude if asked for
*/
}
/*
* expand that node and process it
*/
return -1;
}
reader->in_xinclude++;
goto get_next_node;
}
reader->in_xinclude--;
goto get_next_node;
}
#endif
/*
* Handle entities enter and exit when in entity replacement mode
*/
/*
* Case where the underlying tree is not availble, lookup the entity
* and walk it.
*/
}
}
#ifdef LIBXML_REGEXP_ENABLED
#endif /* LIBXML_REGEXP_ENABLED */
}
goto get_next_node;
}
#ifdef LIBXML_REGEXP_ENABLED
}
}
#endif /* LIBXML_REGEXP_ENABLED */
#ifdef LIBXML_PATTERN_ENABLED
int i;
break;
}
}
}
#endif /* LIBXML_PATTERN_ENABLED */
#ifdef LIBXML_SCHEMAS_ENABLED
(reader->xsdValidErrors == 0) &&
}
#endif /* LIBXML_PATTERN_ENABLED */
return(1);
return(0);
}
/**
* xmlTextReaderReadState:
* @reader: the xmlTextReaderPtr used
*
* Gets the read state of the reader.
*
* Returns the state value, or -1 in case of error
*/
int
return(-1);
}
/**
* xmlTextReaderExpand:
* @reader: the xmlTextReaderPtr used
*
* Reads the contents of the current node and the full subtree. It then makes
* the subtree available until the next xmlTextReaderRead() call
*
* Returns a node pointer valid until the next xmlTextReaderRead() call
* or NULL in case of error.
*/
return(NULL);
return(NULL);
if (xmlTextReaderDoExpand(reader) < 0)
return(NULL);
}
/**
* xmlTextReaderNext:
* @reader: the xmlTextReaderPtr used
*
* Skip to the node following the current one in document order while
* avoiding the subtree if any.
*
* Returns 1 if the node was read successfully, 0 if there is no more
* nodes to read, or -1 in case of error
*/
int
int ret;
return(-1);
return(xmlTextReaderNextTree(reader));
return(xmlTextReaderRead(reader));
return(xmlTextReaderRead(reader));
return(xmlTextReaderRead(reader));
do {
if (ret != 1)
return(ret);
return(xmlTextReaderRead(reader));
}
#ifdef LIBXML_WRITER_ENABLED
/**
* xmlTextReaderReadInnerXml:
* @reader: the xmlTextReaderPtr used
*
* Reads the contents of the current node, including child nodes and markup.
*
* Returns a string containing the XML content, or NULL if the current node
* is neither an element nor attribute, or has no child nodes. The
* string must be deallocated by the caller.
*/
xmlChar *
{
return NULL;
}
buff = xmlBufferCreate();
buff2 = xmlBufferCreate();
return NULL;
}
}
return resbuf;
}
#endif
#ifdef LIBXML_WRITER_ENABLED
/**
* xmlTextReaderReadOuterXml:
* @reader: the xmlTextReaderPtr used
*
* Reads the contents of the current node, including child nodes and markup.
*
* Returns a string containing the XML content, or NULL if the current node
* is neither an element nor attribute, or has no child nodes. The
* string must be deallocated by the caller.
*/
xmlChar *
{
return NULL;
}
buff = xmlBufferCreate();
return NULL;
}
return resbuf;
}
#endif
/**
* xmlTextReaderReadString:
* @reader: the xmlTextReaderPtr used
*
* Reads the contents of an element or a text node as a string.
*
* Returns a string containing the contents of the Element or Text node,
* or NULL if the reader is positioned on any other type of node.
* The string must be deallocated by the caller.
*/
xmlChar *
{
return(NULL);
case XML_TEXT_NODE:
break;
case XML_ELEMENT_NODE:
}
case XML_ATTRIBUTE_NODE:
break;
default:
break;
}
return(NULL);
}
#if 0
/**
* xmlTextReaderReadBase64:
* @reader: the xmlTextReaderPtr used
* @array: a byte array to store the content.
* @offset: the zero-based index into array where the method should
* begin to write.
* @len: the number of bytes to write.
*
* Reads and decodes the Base64 encoded contents of an element and
* stores the result in a byte buffer.
*
* Returns the number of bytes written to array, or zero if the current
* instance is not positioned on an element or -1 in case of error.
*/
int
unsigned char *array ATTRIBUTE_UNUSED,
int offset ATTRIBUTE_UNUSED,
int len ATTRIBUTE_UNUSED) {
return(-1);
return(-1);
return(0);
return(0);
}
/**
* xmlTextReaderReadBinHex:
* @reader: the xmlTextReaderPtr used
* @array: a byte array to store the content.
* @offset: the zero-based index into array where the method should
* begin to write.
* @len: the number of bytes to write.
*
* Reads and decodes the BinHex encoded contents of an element and
* stores the result in a byte buffer.
*
* Returns the number of bytes written to array, or zero if the current
* instance is not positioned on an element or -1 in case of error.
*/
int
unsigned char *array ATTRIBUTE_UNUSED,
int offset ATTRIBUTE_UNUSED,
int len ATTRIBUTE_UNUSED) {
return(-1);
return(-1);
return(0);
return(0);
}
#endif
/************************************************************************
* *
* Operating on a preparsed tree *
* *
************************************************************************/
static int
{
return(-1);
return(0);
return(0);
}
return(1);
}
return(1);
}
return(1);
}
}
return(1);
}
return(0);
}
return(1);
}
return(1);
}
/**
* xmlTextReaderReadTree:
* @reader: the xmlTextReaderPtr used
*
* Moves the position of the current instance to the next node in
* the stream, exposing its properties.
*
* Returns 1 if the node was read successfully, 0 if there is no more
* nodes to read, or -1 in case of error
*/
static int
return(0);
return(0);
}
goto found_node;
}
goto found_node;
}
goto found_node;
}
}
goto found_node;
}
return(0);
}
goto found_node;
}
goto next_node;
return(1);
}
/**
* xmlTextReaderNextSibling:
* @reader: the xmlTextReaderPtr used
*
* Skip to the node following the current one in document order while
* avoiding the subtree if any.
* Currently implemented only for Readers built on a document
*
* Returns 1 if the node was read successfully, 0 if there is no more
* nodes to read, or -1 in case of error
*/
int
return(-1);
/* TODO */
return(-1);
}
return(0);
return(xmlTextReaderNextTree(reader));
return(1);
}
return(0);
}
/************************************************************************
* *
* Constructor and destructors *
* *
************************************************************************/
/**
* xmlNewTextReader:
* @input: the xmlParserInputBufferPtr used to read data
* @URI: the URI information for the source if available
*
* Create an xmlTextReader structure fed with @input
*
* Returns the new xmlTextReaderPtr or NULL in case of error
*/
return(NULL);
"xmlNewTextReader : malloc failed\n");
return(NULL);
}
"xmlNewTextReader : malloc failed\n");
return(NULL);
}
"xmlNewTextReader : malloc failed\n");
return(NULL);
}
#ifdef LIBXML_SAX1_ENABLED
#endif /* LIBXML_SAX1_ENABLED */
#ifdef LIBXML_SAX1_ENABLED
} else {
}
#endif /* LIBXML_SAX1_ENABLED */
}
} else {
}
"xmlNewTextReader : malloc failed\n");
return(NULL);
}
/*
* use the parser dictionnary to allocate all elements and attributes names
*/
#ifdef LIBXML_XINCLUDE_ENABLED
#endif
#ifdef LIBXML_PATTERN_ENABLED
ret->patternMax = 0;
#endif
return(ret);
}
/**
* xmlNewTextReaderFilename:
* @URI: the URI of the resource to process
*
* Create an xmlTextReader structure fed with the resource at @URI
*
* Returns the new xmlTextReaderPtr or NULL in case of error
*/
xmlNewTextReaderFilename(const char *URI) {
return(NULL);
return(NULL);
}
return(ret);
}
/**
* xmlFreeTextReader:
* @reader: the xmlTextReaderPtr
*
* Deallocate all the resources associated to the reader
*/
void
return;
#ifdef LIBXML_SCHEMAS_ENABLED
}
}
}
if (! reader->xsdPreserveCtxt)
}
}
#endif
#ifdef LIBXML_XINCLUDE_ENABLED
#endif
#ifdef LIBXML_PATTERN_ENABLED
int i;
}
}
#endif
}
}
}
}
}
/************************************************************************
* *
* Methods for XmlTextReader *
* *
************************************************************************/
/**
* xmlTextReaderClose:
* @reader: the xmlTextReaderPtr used
*
* This method releases any resources allocated by the current instance
* changes the state to Closed and close any underlying input.
*
* Returns 0 or -1 in case of error
*/
int
return(-1);
}
}
}
return(0);
}
/**
* xmlTextReaderGetAttributeNo:
* @reader: the xmlTextReaderPtr used
* @no: the zero-based index of the attribute relative to the containing element
*
* Provides the value of the attribute with the specified index relative
* to the containing element.
*
* Returns a string containing the value of the specified attribute, or NULL
* in case of error. The string must be deallocated by the caller.
*/
xmlChar *
int i;
return(NULL);
return(NULL);
return(NULL);
/* TODO: handle the xmlDecl */
return(NULL);
}
return(NULL);
for (;i < no;i++) {
return(NULL);
}
/* TODO walk the DTD if present */
return(ret);
}
/**
* xmlTextReaderGetAttribute:
* @reader: the xmlTextReaderPtr used
* @name: the qualified name of the attribute.
*
* Provides the value of the attribute with the specified qualified name.
*
* Returns a string containing the value of the specified attribute, or NULL
* in case of error. The string must be deallocated by the caller.
*/
xmlChar *
return(NULL);
return(NULL);
return(NULL);
/* TODO: handle the xmlDecl */
return(NULL);
/*
* Namespace default decl
*/
}
}
return NULL;
}
}
/*
* Namespace default decl
*/
break;
}
}
} else {
}
return(ret);
}
/**
* xmlTextReaderGetAttributeNs:
* @reader: the xmlTextReaderPtr used
* @localName: the local name of the attribute.
* @namespaceURI: the namespace URI of the attribute.
*
* Provides the value of the specified attribute
*
* Returns a string containing the value of the specified attribute, or NULL
* in case of error. The string must be deallocated by the caller.
*/
xmlChar *
const xmlChar *namespaceURI) {
return(NULL);
return(NULL);
return(NULL);
/* TODO: handle the xmlDecl */
return(NULL);
}
}
}
return NULL;
}
}
/**
* xmlTextReaderGetRemainder:
* @reader: the xmlTextReaderPtr used
*
* Method to get the remainder of the buffered XML. this method stops the
* parser, set its state to End Of File and return the input stream with
* what is left that the parser did not use.
*
* The implementation is not good, the parser certainly procgressed past
* what's left in reader->input, and there is an allocation problem. Best
* would be to rewrite it differently.
*
* Returns the xmlParserInputBufferPtr attached to the XML or NULL
* in case of error.
*/
return(NULL);
return(NULL);
}
}
} else {
/*
* Hum, one may need to duplicate the data structure because
* without reference counting the input may be freed twice:
* - by the layer which allocated it.
* - by the layer to which would have been returned to.
*/
return(NULL);
}
return(ret);
}
/**
* xmlTextReaderLookupNamespace:
* @reader: the xmlTextReaderPtr used
* @prefix: the prefix whose namespace URI is to be resolved. To return
* the default namespace, specify NULL
*
* Resolves a namespace prefix in the scope of the current element.
*
* Returns a string containing the namespace URI to which the prefix maps
* or NULL in case of error. The string must be deallocated by the caller.
*/
xmlChar *
return(NULL);
return(NULL);
return(NULL);
}
/**
* xmlTextReaderMoveToAttributeNo:
* @reader: the xmlTextReaderPtr used
* @no: the zero-based index of the attribute relative to the containing
* element.
*
* Moves the position of the current instance to the attribute with
* the specified index relative to the containing element.
*
* Returns 1 in case of success, -1 in case of error, 0 if not found
*/
int
int i;
return(-1);
return(-1);
/* TODO: handle the xmlDecl */
return(-1);
}
return(1);
}
return(0);
for (;i < no;i++) {
return(0);
}
/* TODO walk the DTD if present */
return(1);
}
/**
* xmlTextReaderMoveToAttribute:
* @reader: the xmlTextReaderPtr used
* @name: the qualified name of the attribute.
*
* Moves the position of the current instance to the attribute with
* the specified qualified name.
*
* Returns 1 in case of success, -1 in case of error, 0 if not found
*/
int
return(-1);
return(-1);
/* TODO: handle the xmlDecl */
return(0);
/*
* Namespace default decl
*/
return(1);
}
}
return(0);
}
/*
* One need to have
* - same attribute names
* - and the attribute carrying that namespace
*/
return(1);
}
}
return(0);
}
/*
* Namespace default decl
*/
goto found;
}
}
goto not_found;
}
/*
* One need to have
* - same attribute names
* - and the attribute carrying that namespace
*/
goto found;
}
}
return(0);
return(1);
}
/**
* xmlTextReaderMoveToAttributeNs:
* @reader: the xmlTextReaderPtr used
* @localName: the local name of the attribute.
* @namespaceURI: the namespace URI of the attribute.
*
* Moves the position of the current instance to the attribute with the
* specified local name and namespace URI.
*
* Returns 1 in case of success, -1 in case of error, 0 if not found
*/
int
return(-1);
return(-1);
return(0);
}
return(1);
}
}
return(0);
}
/*
* One need to have
* - same attribute names
* - and the attribute carrying that namespace
*/
return(1);
}
}
return(0);
}
/**
* xmlTextReaderMoveToFirstAttribute:
* @reader: the xmlTextReaderPtr used
*
* Moves the position of the current instance to the first attribute
* associated with the current node.
*
* Returns 1 in case of success, -1 in case of error, 0 if not found
*/
int
return(-1);
return(-1);
return(0);
return(1);
}
return(1);
}
return(0);
}
/**
* xmlTextReaderMoveToNextAttribute:
* @reader: the xmlTextReaderPtr used
*
* Moves the position of the current instance to the next attribute
* associated with the current node.
*
* Returns 1 in case of success, -1 in case of error, 0 if not found
*/
int
return(-1);
return(-1);
return(0);
return(xmlTextReaderMoveToFirstAttribute(reader));
return(1);
}
return(1);
}
return(0);
return(1);
}
return(0);
}
/**
* xmlTextReaderMoveToElement:
* @reader: the xmlTextReaderPtr used
*
* Moves the position of the current instance to the node that
* contains the current Attribute node.
*
* Returns 1 in case of success, -1 in case of error, 0 if not moved
*/
int
return(-1);
return(-1);
return(0);
return(1);
}
return(0);
}
/**
* xmlTextReaderReadAttributeValue:
* @reader: the xmlTextReaderPtr used
*
* Parses an attribute value into one or more Text and EntityReference nodes.
*
* Returns 1 in case of success, 0 if the reader was not positionned on an
* ttribute node or all the attribute values have been read, or -1
* in case of error.
*/
int
return(-1);
return(-1);
return(0);
return(0);
} else {
}
} else {
return(0);
}
return(1);
}
/**
* xmlTextReaderConstEncoding:
* @reader: the xmlTextReaderPtr used
*
* Determine the encoding of the document being read.
*
* Returns a string containing the encoding of the document or NULL in
* case of error. The string is deallocated with the reader.
*/
const xmlChar *
return(NULL);
return(NULL);
return(NULL);
else
}
/************************************************************************
* *
* Acces API to the current node *
* *
************************************************************************/
/**
* xmlTextReaderAttributeCount:
* @reader: the xmlTextReaderPtr used
*
* Provides the number of attributes of the current node
*
* Returns 0 i no attributes, -1 in case of error or the attribute count
*/
int
int ret;
return(-1);
return(0);
else
return(0);
return(0);
ret = 0;
ret++;
}
ret++;
}
return(ret);
}
/**
* xmlTextReaderNodeType:
* @reader: the xmlTextReaderPtr used
*
* Get the node type of the current node
* Reference:
*
* Returns the xmlNodeType of the current node or -1 in case of error
*/
int
return(-1);
return(XML_READER_TYPE_NONE);
else
case XML_ELEMENT_NODE:
return(XML_READER_TYPE_END_ELEMENT);
return(XML_READER_TYPE_ELEMENT);
case XML_NAMESPACE_DECL:
case XML_ATTRIBUTE_NODE:
return(XML_READER_TYPE_ATTRIBUTE);
case XML_TEXT_NODE:
else
return(XML_READER_TYPE_WHITESPACE);
} else {
return(XML_READER_TYPE_TEXT);
}
case XML_CDATA_SECTION_NODE:
return(XML_READER_TYPE_CDATA);
case XML_ENTITY_REF_NODE:
return(XML_READER_TYPE_ENTITY_REFERENCE);
case XML_ENTITY_NODE:
return(XML_READER_TYPE_ENTITY);
case XML_PI_NODE:
case XML_COMMENT_NODE:
return(XML_READER_TYPE_COMMENT);
case XML_DOCUMENT_NODE:
case XML_HTML_DOCUMENT_NODE:
#ifdef LIBXML_DOCB_ENABLED
case XML_DOCB_DOCUMENT_NODE:
#endif
return(XML_READER_TYPE_DOCUMENT);
case XML_DOCUMENT_FRAG_NODE:
return(XML_READER_TYPE_DOCUMENT_FRAGMENT);
case XML_NOTATION_NODE:
return(XML_READER_TYPE_NOTATION);
case XML_DOCUMENT_TYPE_NODE:
case XML_DTD_NODE:
return(XML_READER_TYPE_DOCUMENT_TYPE);
case XML_ELEMENT_DECL:
case XML_ATTRIBUTE_DECL:
case XML_ENTITY_DECL:
case XML_XINCLUDE_START:
case XML_XINCLUDE_END:
return(XML_READER_TYPE_NONE);
}
return(-1);
}
/**
* xmlTextReaderIsEmptyElement:
* @reader: the xmlTextReaderPtr used
*
* Check if the current node is empty
*
* Returns 1 if empty, 0 if not and -1 in case of error
*/
int
return(-1);
return(0);
return(0);
return(0);
return(0);
return(1);
#ifdef LIBXML_XINCLUDE_ENABLED
if (reader->in_xinclude > 0)
return(1);
#endif
}
/**
* xmlTextReaderLocalName:
* @reader: the xmlTextReaderPtr used
*
* The local name of the node.
*
* Returns the local name or NULL if not available
*/
xmlChar *
return(NULL);
else
else
}
return(xmlTextReaderName(reader));
}
/**
* xmlTextReaderConstLocalName:
* @reader: the xmlTextReaderPtr used
*
* The local name of the node.
*
* Returns the local name or NULL if not available, the
* string will be deallocated with the reader.
*/
const xmlChar *
return(NULL);
else
else
}
return(xmlTextReaderConstName(reader));
}
/**
* xmlTextReaderName:
* @reader: the xmlTextReaderPtr used
*
* The qualified name of the node, equal to Prefix :LocalName.
*
* Returns the local name or NULL if not available
*/
xmlChar *
return(NULL);
else
case XML_ELEMENT_NODE:
case XML_ATTRIBUTE_NODE:
return(ret);
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_ENTITY_NODE:
case XML_ENTITY_REF_NODE:
case XML_PI_NODE:
case XML_COMMENT_NODE:
case XML_DOCUMENT_NODE:
case XML_HTML_DOCUMENT_NODE:
#ifdef LIBXML_DOCB_ENABLED
case XML_DOCB_DOCUMENT_NODE:
#endif
case XML_DOCUMENT_FRAG_NODE:
case XML_NOTATION_NODE:
case XML_DOCUMENT_TYPE_NODE:
case XML_DTD_NODE:
case XML_NAMESPACE_DECL: {
return(ret);
return(ret);
}
case XML_ELEMENT_DECL:
case XML_ATTRIBUTE_DECL:
case XML_ENTITY_DECL:
case XML_XINCLUDE_START:
case XML_XINCLUDE_END:
return(NULL);
}
return(NULL);
}
/**
* xmlTextReaderConstName:
* @reader: the xmlTextReaderPtr used
*
* The qualified name of the node, equal to Prefix :LocalName.
*
* Returns the local name or NULL if not available, the string is
* deallocated with the reader.
*/
const xmlChar *
return(NULL);
else
case XML_ELEMENT_NODE:
case XML_ATTRIBUTE_NODE:
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_ENTITY_NODE:
case XML_ENTITY_REF_NODE:
case XML_PI_NODE:
case XML_COMMENT_NODE:
case XML_DOCUMENT_NODE:
case XML_HTML_DOCUMENT_NODE:
#ifdef LIBXML_DOCB_ENABLED
case XML_DOCB_DOCUMENT_NODE:
#endif
case XML_DOCUMENT_FRAG_NODE:
case XML_NOTATION_NODE:
case XML_DOCUMENT_TYPE_NODE:
case XML_DTD_NODE:
case XML_NAMESPACE_DECL: {
}
case XML_ELEMENT_DECL:
case XML_ATTRIBUTE_DECL:
case XML_ENTITY_DECL:
case XML_XINCLUDE_START:
case XML_XINCLUDE_END:
return(NULL);
}
return(NULL);
}
/**
* xmlTextReaderPrefix:
* @reader: the xmlTextReaderPtr used
*
* A shorthand reference to the namespace associated with the node.
*
* Returns the prefix or NULL if not available
*/
xmlChar *
return(NULL);
else
return(NULL);
}
return(NULL);
return(NULL);
}
/**
* xmlTextReaderConstPrefix:
* @reader: the xmlTextReaderPtr used
*
* A shorthand reference to the namespace associated with the node.
*
* Returns the prefix or NULL if not available, the string is deallocated
* with the reader.
*/
const xmlChar *
return(NULL);
else
return(NULL);
}
return(NULL);
return(NULL);
}
/**
* xmlTextReaderNamespaceUri:
* @reader: the xmlTextReaderPtr used
*
* The URI defining the namespace associated with the node.
*
* Returns the namespace URI or NULL if not available
*/
xmlChar *
return(NULL);
else
return(NULL);
return(NULL);
}
/**
* xmlTextReaderConstNamespaceUri:
* @reader: the xmlTextReaderPtr used
*
* The URI defining the namespace associated with the node.
*
* Returns the namespace URI or NULL if not available, the string
* will be deallocated with the reader
*/
const xmlChar *
return(NULL);
else
return(NULL);
return(NULL);
}
/**
* xmlTextReaderBaseUri:
* @reader: the xmlTextReaderPtr used
*
* The base URI of the node.
*
* Returns the base URI or NULL if not available
*/
xmlChar *
return(NULL);
}
/**
* xmlTextReaderConstBaseUri:
* @reader: the xmlTextReaderPtr used
*
* The base URI of the node.
*
* Returns the base URI or NULL if not available, the string
* will be deallocated with the reader
*/
const xmlChar *
return(NULL);
return(NULL);
return(ret);
}
/**
* xmlTextReaderDepth:
* @reader: the xmlTextReaderPtr used
*
* The depth of the node in the tree.
*
* Returns the depth or -1 in case of error
*/
int
return(-1);
return(0);
}
}
/**
* xmlTextReaderHasAttributes:
* @reader: the xmlTextReaderPtr used
*
* Whether the node has attributes.
*
* Returns 1 if true, 0 if false, and -1 in case or error
*/
int
return(-1);
return(0);
else
return(1);
/* TODO: handle the xmlDecl */
return(0);
}
/**
* xmlTextReaderHasValue:
* @reader: the xmlTextReaderPtr used
*
* Whether the node can have a text value.
*
* Returns 1 if true, 0 if false, and -1 in case or error
*/
int
return(-1);
return(0);
else
case XML_ATTRIBUTE_NODE:
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_PI_NODE:
case XML_COMMENT_NODE:
case XML_NAMESPACE_DECL:
return(1);
default:
break;
}
return(0);
}
/**
* xmlTextReaderValue:
* @reader: the xmlTextReaderPtr used
*
* Provides the text value of the node if present
*
* Returns the string or NULL if not available. The result must be deallocated
* with xmlFree()
*/
xmlChar *
return(NULL);
return(NULL);
else
case XML_NAMESPACE_DECL:
case XML_ATTRIBUTE_NODE:{
return (xmlNodeListGetString
else
break;
}
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_PI_NODE:
case XML_COMMENT_NODE:
default:
break;
}
return(NULL);
}
/**
* xmlTextReaderConstValue:
* @reader: the xmlTextReaderPtr used
*
* Provides the text value of the node if present
*
* Returns the string or NULL if not available. The result will be
* deallocated on the next Read() operation.
*/
const xmlChar *
return(NULL);
return(NULL);
else
case XML_NAMESPACE_DECL:
case XML_ATTRIBUTE_NODE:{
else {
"xmlTextReaderSetup : malloc failed\n");
return (NULL);
}
}
break;
}
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_PI_NODE:
case XML_COMMENT_NODE:
default:
break;
}
return(NULL);
}
/**
* xmlTextReaderIsDefault:
* @reader: the xmlTextReaderPtr used
*
* Whether an Attribute node was generated from the default value
* defined in the DTD or schema.
*
* Returns 0 if not defaulted, 1 if defaulted, and -1 in case of error
*/
int
return(-1);
return(0);
}
/**
* xmlTextReaderQuoteChar:
* @reader: the xmlTextReaderPtr used
*
* The quotation mark character used to enclose the value of an attribute.
*
* Returns " or ' and -1 in case of error
*/
int
return(-1);
/* TODO maybe lookup the attribute value for " first */
return((int) '"');
}
/**
* xmlTextReaderXmlLang:
* @reader: the xmlTextReaderPtr used
*
* The xml:lang scope within which the node resides.
*
* Returns the xml:lang value or NULL if none exists.
*/
xmlChar *
return(NULL);
return(NULL);
}
/**
* xmlTextReaderConstXmlLang:
* @reader: the xmlTextReaderPtr used
*
* The xml:lang scope within which the node resides.
*
* Returns the xml:lang value or NULL if none exists.
*/
const xmlChar *
return(NULL);
return(NULL);
return(NULL);
return(ret);
}
/**
* xmlTextReaderConstString:
* @reader: the xmlTextReaderPtr used
* @str: the string to intern.
*
* Get an interned string from the reader, allows for example to
* speedup string name comparisons
*
* Returns an interned copy of the string or NULL in case of error. The
* string will be deallocated with the reader.
*/
const xmlChar *
return(NULL);
}
/**
* xmlTextReaderNormalization:
* @reader: the xmlTextReaderPtr used
*
* The value indicating whether to normalize white space and attribute values.
* Since attribute value and end of line normalizations are a MUST in the XML
* specification only the value true is accepted. The broken bahaviour of
* accepting out of range character entities like � is of course not
* supported either.
*
* Returns 1 or -1 in case of error.
*/
int
return(-1);
return(1);
}
/************************************************************************
* *
* Extensions to the base APIs *
* *
************************************************************************/
/**
* xmlTextReaderSetParserProp:
* @reader: the xmlTextReaderPtr used
* @prop: the xmlParserProperties to set
* @value: usually 0 or 1 to (de)activate it
*
* Change the parser processing behaviour by changing some of its internal
* properties. Note that some properties can only be changed before any
* read has been done.
*
* Returns 0 if the call was successful, or -1 in case of error
*/
int
return(-1);
switch (p) {
case XML_PARSER_LOADDTD:
if (value != 0) {
if (ctxt->loadsubset == 0) {
return(-1);
}
} else {
ctxt->loadsubset = 0;
}
return(0);
case XML_PARSER_DEFAULTATTRS:
if (value != 0) {
} else {
}
return(0);
case XML_PARSER_VALIDATE:
if (value != 0) {
} else {
}
return(0);
if (value != 0) {
} else {
ctxt->replaceEntities = 0;
}
return(0);
}
return(-1);
}
/**
* xmlTextReaderGetParserProp:
* @reader: the xmlTextReaderPtr used
* @prop: the xmlParserProperties to get
*
* Read the parser internal property.
*
* Returns the value, usually 0 or 1, or -1 in case of error.
*/
int
return(-1);
switch (p) {
case XML_PARSER_LOADDTD:
return(1);
return(0);
case XML_PARSER_DEFAULTATTRS:
return(1);
return(0);
case XML_PARSER_VALIDATE:
return(ctxt->replaceEntities);
}
return(-1);
}
/**
* xmlTextReaderGetParserLineNumber:
* @reader: the user data (XML reader context)
*
* Provide the line number of the current parsing point.
*
* Returns an int or 0 if not available
*/
int
{
return (0);
}
}
/**
* xmlTextReaderGetParserColumnNumber:
* @reader: the user data (XML reader context)
*
* Provide the column number of the current parsing point.
*
* Returns an int or 0 if not available
*/
int
{
return (0);
}
}
/**
* xmlTextReaderCurrentNode:
* @reader: the xmlTextReaderPtr used
*
* Hacking interface allowing to get the xmlNodePtr correponding to the
* current node being accessed by the xmlTextReader. This is dangerous
* because the underlying node may be destroyed on the next Reads.
*
* Returns the xmlNodePtr or NULL in case of error.
*/
return(NULL);
}
/**
* xmlTextReaderPreserve:
* @reader: the xmlTextReaderPtr used
*
* This tells the XML Reader to preserve the current node.
* The caller must also use xmlTextReaderCurrentDoc() to
* keep an handle on the resulting document once parsing has finished
*
* Returns the xmlNodePtr or NULL in case of error.
*/
return(NULL);
else
return(NULL);
}
}
return(cur);
}
#ifdef LIBXML_PATTERN_ENABLED
/**
* xmlTextReaderPreservePattern:
* @reader: the xmlTextReaderPtr used
* @pattern: an XPath subset pattern
* @namespaces: the prefix definitions, array of [URI, prefix] or NULL
*
* This tells the XML Reader to preserve all nodes matched by the
* pattern. The caller must also use xmlTextReaderCurrentDoc() to
* keep an handle on the resulting document once parsing has finished
*
* Returns a positive number in case of success and -1 in case of error
*/
int
const xmlChar **namespaces)
{
return(-1);
return(-1);
if (reader->patternMax <= 0) {
sizeof(reader->patternTab[0]));
return (-1);
}
}
reader->patternMax *
sizeof(reader->patternTab[0]));
return (-1);
}
}
}
#endif
/**
* xmlTextReaderCurrentDoc:
* @reader: the xmlTextReaderPtr used
*
* Hacking interface allowing to get the xmlDocPtr correponding to the
* current document being accessed by the xmlTextReader.
* NOTE: as a result of this call, the reader will not destroy the
* associated XML document and calling xmlFreeDoc() on the result
* is needed once the reader parsing has finished.
*
* Returns the xmlDocPtr or NULL in case of error.
*/
return(NULL);
return(NULL);
}
#ifdef LIBXML_SCHEMAS_ENABLED
static char *
static void XMLCDECL
static void XMLCDECL
{
char * str;
} else {
reader->errorFunc(reader->errorFuncArg, str, XML_PARSER_SEVERITY_VALIDITY_ERROR, NULL /* locator */);
}
}
{
char * str;
} else {
reader->errorFunc(reader->errorFuncArg, str, XML_PARSER_SEVERITY_VALIDITY_WARNING, NULL /* locator */);
}
}
static void
{
if (reader->sErrorFunc) {
} else {
}
}
/**
* xmlTextReaderRelaxNGSetSchema:
* @reader: the xmlTextReaderPtr used
* @schema: a precompiled RelaxNG schema
*
* Use RelaxNG to validate the document as it is processed.
* Activation is only possible before the first Read().
* if @schema is NULL, then RelaxNG validation is desactivated.
@ The @schema should not be freed until the reader is deallocated
* or its use has been deactivated.
*
* Returns 0 in case the RelaxNG validation could be (des)activated and
* -1 in case of error.
*/
int
return(-1);
}
}
return(0);
}
return(-1);
}
}
return(-1);
reader);
}
reader);
}
reader->rngValidErrors = 0;
return(0);
}
/**
* xmlTextReaderSetSchema:
* @reader: the xmlTextReaderPtr used
* @schema: a precompiled Schema schema
*
* Use XSD Schema to validate the document as it is processed.
* Activation is only possible before the first Read().
* if @schema is NULL, then Schema validation is desactivated.
@ The @schema should not be freed until the reader is deallocated
* or its use has been deactivated.
*
* Returns 0 in case the Schema validation could be (des)activated and
* -1 in case of error.
*/
int
return(-1);
}
if (! reader->xsdPreserveCtxt)
}
reader->xsdPreserveCtxt = 0;
}
return(0);
}
return(-1);
}
if (! reader->xsdPreserveCtxt)
}
reader->xsdPreserveCtxt = 0;
}
return(-1);
}
return(-1);
}
reader);
}
reader);
}
reader->xsdValidErrors = 0;
return(0);
}
/**
* xmlTextReaderRelaxNGValidate:
* @reader: the xmlTextReaderPtr used
* @rng: the path to a RelaxNG schema or NULL
*
* Use RelaxNG to validate the document as it is processed.
* Activation is only possible before the first Read().
* if @rng is NULL, then RelaxNG validation is deactivated.
*
* Returns 0 in case the RelaxNG validation could be (de)activated and
* -1 in case of error.
*/
int
return(-1);
}
}
return(0);
}
return(-1);
}
}
reader);
}
reader);
}
return(-1);
return(-1);
}
reader);
}
reader);
}
reader->rngValidErrors = 0;
return(0);
}
/**
* xmlTextReaderSchemaValidateInternal:
* @reader: the xmlTextReaderPtr used
* @xsd: the path to a W3C XSD schema or NULL
* @ctxt: the XML Schema validation context or NULL
* @options: options (not used yet)
*
* Validate the document as it is processed using XML Schema.
* Activation is only possible before the first Read().
* If both @xsd and @ctxt are NULL then XML Schema validation is deactivated.
*
* Returns 0 in case the schemas validation could be (de)activated and
* -1 in case of error.
*/
static int
const char *xsd,
int options ATTRIBUTE_UNUSED)
{
return(-1);
return(-1);
return(-1);
/* Cleanup previous validation stuff. */
}
if (! reader->xsdPreserveCtxt)
}
reader->xsdPreserveCtxt = 0;
}
/* We just want to deactivate the validation, so get out. */
return(0);
}
/* Parse the schema and create validation environment. */
reader);
}
return(-1);
return(-1);
}
return(-1);
}
} else {
/* Use the given validation context. */
reader->xsdPreserveCtxt = 0;
return(-1);
}
}
/*
* Redirect the validation context's error channels to use
* the reader channels.
* TODO: In case the user provides the validation context we
* could make this redirection optional.
*/
reader);
}
reader);
}
reader->xsdValidErrors = 0;
return(0);
}
/**
* xmlTextReaderSchemaValidateCtxt:
* @reader: the xmlTextReaderPtr used
* @ctxt: the XML Schema validation context or NULL
* @options: options (not used yet)
*
* Use W3C XSD schema context to validate the document as it is processed.
* Activation is only possible before the first Read().
* If @ctxt is NULL, then XML Schema validation is deactivated.
*
* Returns 0 in case the schemas validation could be (de)activated and
* -1 in case of error.
*/
int
int options)
{
}
/**
* xmlTextReaderSchemaValidate:
* @reader: the xmlTextReaderPtr used
* @xsd: the path to a W3C XSD schema or NULL
*
* Use W3C XSD schema to validate the document as it is processed.
* Activation is only possible before the first Read().
* If @xsd is NULL, then XML Schema validation is deactivated.
*
* Returns 0 in case the schemas validation could be (de)activated and
* -1 in case of error.
*/
int
{
}
#endif
/**
* xmlTextReaderIsNamespaceDecl:
* @reader: the xmlTextReaderPtr used
*
* Determine whether the current node is a namespace declaration
* rather than a regular attribute.
*
* Returns 1 if the current node is a namespace declaration, 0 if it
* is a regular attribute or other type of node, or -1 in case of
* error.
*/
int
return(-1);
return(-1);
else
return(1);
else
return(0);
}
/**
* xmlTextReaderConstXmlVersion:
* @reader: the xmlTextReaderPtr used
*
* Determine the XML version of the document being read.
*
* Returns a string containing the XML version of the document or NULL
* in case of error. The string is deallocated with the reader.
*/
const xmlChar *
return(NULL);
return(NULL);
return(NULL);
else
}
/**
* xmlTextReaderStandalone:
* @reader: the xmlTextReaderPtr used
*
* Determine the standalone status of the document being read.
*
* Returns 1 if the document was declared to be standalone, 0 if it
* was declared to be not standalone, or -1 if the document did not
* specify its standalone status or in case of error.
*/
int
return(-1);
return(-1);
return(doc->standalone);
}
/************************************************************************
* *
* Error Handling Extensions *
* *
************************************************************************/
/* helper to build a xmlMalloc'ed string from a format and va_list */
static char *
int size;
int chars;
char *larger;
char *str;
return NULL;
}
size = 150;
while (1) {
break;
if (chars > -1)
else
size += 100;
return NULL;
}
}
return str;
}
/**
* xmlTextReaderLocatorLineNumber:
* @locator: the xmlTextReaderLocatorPtr used
*
* Obtain the line number for the given locator.
*
* Returns the line number or -1 in case of error.
*/
int
/* we know that locator is a xmlParserCtxtPtr */
int ret = -1;
return(-1);
}
else {
/* inspired from error.c */
}
else {
ret = -1;
}
}
return ret;
}
/**
* xmlTextReaderLocatorBaseURI:
* @locator: the xmlTextReaderLocatorPtr used
*
* Obtain the base URI for the given locator.
*
* Returns the base URI or NULL in case of error.
*/
xmlChar *
/* we know that locator is a xmlParserCtxtPtr */
return(NULL);
}
else {
/* inspired from error.c */
}
else {
}
}
return ret;
}
static void
str,
}
}
static void
(xmlErrorPtr) error);
}
}
static void XMLCDECL
}
static void XMLCDECL
}
static void XMLCDECL
/*
* some callbacks only report locator information:
* skip them (mimicking behaviour in error.c)
*/
}
}
static void XMLCDECL
/*
* some callbacks only report locator information:
* skip them (mimicking behaviour in error.c)
*/
}
}
/**
* xmlTextReaderSetErrorHandler:
* @reader: the xmlTextReaderPtr used
* @f: the callback function to call on error and warnings
* @arg: a user argument to pass to the callback function
*
* Register a callback function that will be called on error and warnings.
*
* If @f is NULL, the default error and warning handlers are restored.
*/
void
void *arg) {
if (f != NULL) {
#ifdef LIBXML_SCHEMAS_ENABLED
if (reader->rngValidCtxt) {
reader);
}
if (reader->xsdValidCtxt) {
reader);
}
#endif
}
else {
/* restore defaults */
#ifdef LIBXML_SCHEMAS_ENABLED
if (reader->rngValidCtxt) {
}
if (reader->xsdValidCtxt) {
}
#endif
}
}
/**
* xmlTextReaderSetStructuredErrorHandler:
* @reader: the xmlTextReaderPtr used
* @f: the callback function to call on error and warnings
* @arg: a user argument to pass to the callback function
*
* Register a callback function that will be called on error and warnings.
*
* If @f is NULL, the default error and warning handlers are restored.
*/
void
void *arg) {
if (f != NULL) {
reader->sErrorFunc = f;
#ifdef LIBXML_SCHEMAS_ENABLED
if (reader->rngValidCtxt) {
reader);
}
if (reader->xsdValidCtxt) {
reader);
}
#endif
}
else {
/* restore defaults */
#ifdef LIBXML_SCHEMAS_ENABLED
if (reader->rngValidCtxt) {
}
if (reader->xsdValidCtxt) {
}
#endif
}
}
/**
* xmlTextReaderIsValid:
* @reader: the xmlTextReaderPtr used
*
* Retrieve the validity status from the parser context
*
* Returns the flag value 1 if valid, 0 if no, and -1 in case of error
*/
int
#ifdef LIBXML_SCHEMAS_ENABLED
return(reader->rngValidErrors == 0);
return(reader->xsdValidErrors == 0);
#endif
return(0);
}
/**
* xmlTextReaderGetErrorHandler:
* @reader: the xmlTextReaderPtr used
* @f: the callback function or NULL is no callback has been registered
* @arg: a user argument
*
* Retrieve the error callback function and user argument.
*/
void
void **arg) {
}
/************************************************************************
* *
* New set (2.6.0) of simpler and more flexible APIs *
* *
************************************************************************/
/**
* xmlTextReaderSetup:
* @reader: an XML reader
* @input: xmlParserInputBufferPtr used to feed the reader, will
* be destroyed with it.
* @URL: the base URL to use for the document
* @encoding: the document encoding, or NULL
* @options: a combination of xmlParserOption
*
* Setup an XML reader with new options
*
* Returns 0 in case of success and -1 in case of error.
*/
int
{
return (-1);
}
/*
* we force the generation of compact text nodes on the reader
* since usr applications should never modify the tree
*/
}
}
"xmlTextReaderSetup : malloc failed\n");
return (-1);
}
"xmlTextReaderSetup : malloc failed\n");
return (-1);
}
#ifdef LIBXML_SAX1_ENABLED
#endif /* LIBXML_SAX1_ENABLED */
#ifdef LIBXML_SAX1_ENABLED
} else {
}
#endif /* LIBXML_SAX1_ENABLED */
}
} else {
}
} else {
if (inputStream == NULL) {
return(-1);
}
else
inputStream->filename = (char *)
inputStream->end =
}
"xmlTextReaderSetup : malloc failed\n");
return (-1);
}
}
}
} else {
}
} else {
}
/*
* use the parser dictionnary to allocate all elements and attributes names
*/
#ifdef LIBXML_XINCLUDE_ENABLED
}
if (options & XML_PARSE_XINCLUDE) {
} else
reader->in_xinclude = 0;
#endif
#ifdef LIBXML_PATTERN_ENABLED
reader->patternMax = 0;
}
}
}
#endif
if (options & XML_PARSE_DTDVALID)
}
return (0);
}
/**
* xmlTextReaderByteConsumed:
* @reader: an XML reader
*
* This function provides the current index of the parser used
* by the reader, relative to the start of the current entity.
* This function actually just wraps a call to xmlBytesConsumed()
* for the parser context associated with the reader.
* See xmlBytesConsumed() for more information.
*
* Returns the index in bytes from the beginning of the entity or -1
* in case the index could not be computed.
*/
long
return(-1);
}
/**
* xmlReaderWalker:
* @doc: a preparsed document
*
* Create an xmltextReader for a preparsed document.
*
* Returns the new reader or NULL in case of error.
*/
{
return(NULL);
"xmlNewTextReader : malloc failed\n");
return(NULL);
}
return(ret);
}
/**
* xmlReaderForDoc:
* @cur: a pointer to a zero terminated string
* @URL: the base URL to use for the document
* @encoding: the document encoding, or NULL
* @options: a combination of xmlParserOption
*
* Create an xmltextReader for an XML in-memory document.
* The parsing flags @options are a combination of xmlParserOption.
*
* Returns the new reader or NULL in case of error.
*/
int options)
{
int len;
return (NULL);
return (xmlReaderForMemory
}
/**
* xmlReaderForFile:
* @filename: a file or URL
* @encoding: the document encoding, or NULL
* @options: a combination of xmlParserOption
*
* parse an XML file from the filesystem or the network.
* The parsing flags @options are a combination of xmlParserOption.
*
* Returns the new reader or NULL in case of error.
*/
{
return (NULL);
return (reader);
}
/**
* xmlReaderForMemory:
* @buffer: a pointer to a char array
* @size: the size of the array
* @URL: the base URL to use for the document
* @encoding: the document encoding, or NULL
* @options: a combination of xmlParserOption
*
* Create an xmltextReader for an XML in-memory document.
* The parsing flags @options are a combination of xmlParserOption.
*
* Returns the new reader or NULL in case of error.
*/
{
return (NULL);
}
return (NULL);
}
return (reader);
}
/**
* xmlReaderForFd:
* @fd: an open file descriptor
* @URL: the base URL to use for the document
* @encoding: the document encoding, or NULL
* @options: a combination of xmlParserOption
*
* Create an xmltextReader for an XML from a file descriptor.
* The parsing flags @options are a combination of xmlParserOption.
* NOTE that the file descriptor will not be closed when the
* reader is closed or reset.
*
* Returns the new reader or NULL in case of error.
*/
{
if (fd < 0)
return (NULL);
return (NULL);
return (NULL);
}
return (reader);
}
/**
* xmlReaderForIO:
* @ioread: an I/O read function
* @ioclose: an I/O close function
* @ioctx: an I/O handler
* @URL: the base URL to use for the document
* @encoding: the document encoding, or NULL
* @options: a combination of xmlParserOption
*
* Create an xmltextReader for an XML document from I/O functions and source.
* The parsing flags @options are a combination of xmlParserOption.
*
* Returns the new reader or NULL in case of error.
*/
int options)
{
return (NULL);
return (NULL);
return (NULL);
}
return (reader);
}
/**
* xmlReaderNewWalker:
* @reader: an XML reader
* @doc: a preparsed document
*
* Setup an xmltextReader to parse a preparsed XML document.
* This reuses the existing @reader xmlTextReader.
*
* Returns 0 in case of success and -1 in case of error
*/
int
{
return (-1);
return (-1);
}
}
else
}
return(0);
}
/**
* xmlReaderNewDoc:
* @reader: an XML reader
* @cur: a pointer to a zero terminated string
* @URL: the base URL to use for the document
* @encoding: the document encoding, or NULL
* @options: a combination of xmlParserOption
*
* Setup an xmltextReader to parse an XML in-memory document.
* The parsing flags @options are a combination of xmlParserOption.
* This reuses the existing @reader xmlTextReader.
*
* Returns 0 in case of success and -1 in case of error
*/
int
{
int len;
return (-1);
return (-1);
}
/**
* xmlReaderNewFile:
* @reader: an XML reader
* @filename: a file or URL
* @encoding: the document encoding, or NULL
* @options: a combination of xmlParserOption
*
* parse an XML file from the filesystem or the network.
* The parsing flags @options are a combination of xmlParserOption.
* This reuses the existing @reader xmlTextReader.
*
* Returns 0 in case of success and -1 in case of error
*/
int
{
return (-1);
return (-1);
input =
return (-1);
}
/**
* xmlReaderNewMemory:
* @reader: an XML reader
* @buffer: a pointer to a char array
* @size: the size of the array
* @URL: the base URL to use for the document
* @encoding: the document encoding, or NULL
* @options: a combination of xmlParserOption
*
* Setup an xmltextReader to parse an XML in-memory document.
* The parsing flags @options are a combination of xmlParserOption.
* This reuses the existing @reader xmlTextReader.
*
* Returns 0 in case of success and -1 in case of error
*/
int
{
return (-1);
return (-1);
return (-1);
}
}
/**
* xmlReaderNewFd:
* @reader: an XML reader
* @fd: an open file descriptor
* @URL: the base URL to use for the document
* @encoding: the document encoding, or NULL
* @options: a combination of xmlParserOption
*
* Setup an xmltextReader to parse an XML from a file descriptor.
* NOTE that the file descriptor will not be closed when the
* reader is closed or reset.
* The parsing flags @options are a combination of xmlParserOption.
* This reuses the existing @reader xmlTextReader.
*
* Returns 0 in case of success and -1 in case of error
*/
int
{
if (fd < 0)
return (-1);
return (-1);
return (-1);
}
/**
* xmlReaderNewIO:
* @reader: an XML reader
* @ioread: an I/O read function
* @ioclose: an I/O close function
* @ioctx: an I/O handler
* @URL: the base URL to use for the document
* @encoding: the document encoding, or NULL
* @options: a combination of xmlParserOption
*
* Setup an xmltextReader to parse an XML document from I/O functions
* and source.
* The parsing flags @options are a combination of xmlParserOption.
* This reuses the existing @reader xmlTextReader.
*
* Returns 0 in case of success and -1 in case of error
*/
int
{
return (-1);
return (-1);
return (-1);
}
/************************************************************************
* *
* Utilities *
* *
************************************************************************/
#ifdef NOT_USED_YET
/**
* xmlBase64Decode:
* @in: the input buffer
* @inlen: the size of the input (in), the size read from it (out)
* @to: the output buffer
* @tolen: the size of the output (in), the size written to (out)
*
* Base64 decoder, reads from @in and save in @to
* TODO: tell jody when this is actually exported
*
* Returns 0 if all the input was consumer, 1 if the Base64 end was reached,
* 2 if there wasn't enough space on the output or -1 in case of error.
*/
static int
unsigned long incur; /* current index in in[] */
unsigned long inblk; /* last block index in in[] */
unsigned long outcur; /* current index in out[] */
unsigned long inmax; /* size of in[] */
unsigned long outmax; /* size of out[] */
unsigned char cur; /* the current value read from in[] */
int nbintmp; /* number of byte in intmp[] */
int is_ignore; /* cur should be ignored */
int is_end = 0; /* the end of the base64 was found */
int retval = 1;
int i;
return(-1);
incur = 0;
inblk = 0;
outcur = 0;
nbintmp = 0;
while (1) {
break;
is_ignore = 0;
else if (cur == '+')
cur = 62;
else if (cur == '/')
cur = 63;
else if (cur == '.')
cur = 0;
is_end = 1;
else {
is_ignore = 1;
if (nbintmp == 0)
}
if (!is_ignore) {
int nbouttmp = 3;
int is_break = 0;
if (is_end) {
if (nbintmp == 0)
break;
nbouttmp = 1;
else
nbouttmp = 2;
nbintmp = 3;
is_break = 1;
}
/*
* if intmp is full, push the 4byte sequence as a 3 byte
* sequence out
*/
if (nbintmp == 4) {
nbintmp = 0;
outtmp[1] =
retval = 2;
break;
}
for (i = 0; i < nbouttmp; i++)
}
if (is_break) {
retval = 0;
break;
}
}
}
return (retval);
}
/*
* Test routine for the xmlBase64Decode function
*/
#if 0
char *input = " VW4 gcGV0 \n aXQgdGVzdCAuCg== ";
char output[100];
char output2[100];
char output3[100];
unsigned long outlen = 100;
int ret;
/*
* Direct
*/
/*
* output chunking
*/
cons = 0;
prod = 0;
tmp = 5;
}
/*
* input chunking
*/
cons = 0;
prod = 0;
if (tmp2 > 5)
tmp2 = 5;
}
return(0);
}
#endif
#endif /* NOT_USED_YET */
#define bottom_xmlreader
#include "elfgcchack.h"
#endif /* LIBXML_READER_ENABLED */