2 * xmlreader.c: implements the xmlTextReader streaming node API
5 * XmlTextReader.Normalization Property won't be supported, since
6 * it makes the parser non compliant to the XML recommendation
8 * See Copyright for the status of this software.
15 * - XML Schemas validation
20 #ifdef LIBXML_READER_ENABLED
21 #include <string.h> /* for memset() only ! */
31 #include <libxml/xmlmemory.h>
32 #include <libxml/xmlIO.h>
33 #include <libxml/xmlreader.h>
34 #include <libxml/parserInternals.h>
35 #ifdef LIBXML_SCHEMAS_ENABLED
36 #include <libxml/relaxng.h>
37 #include <libxml/xmlschemas.h>
39 #include <libxml/uri.h>
40 #ifdef LIBXML_XINCLUDE_ENABLED
41 #include <libxml/xinclude.h>
43 #ifdef LIBXML_PATTERN_ENABLED
44 #include <libxml/pattern.h>
49 #define MAX_ERR_MSG_SIZE 64000
52 * The following VA_COPY was coded following an example in
53 * the Samba project. It may not be sufficient for some
54 * esoteric implementations of va_list but (hopefully) will
55 * be sufficient for libxml2.
59 #define VA_COPY(dest, src) va_copy(dest, src)
62 #define VA_COPY(dest,src) __va_copy(dest, src)
64 #ifndef VA_LIST_IS_ARRAY
65 #define VA_COPY(dest,src) (dest) = (src)
68 #define VA_COPY(dest,src) memcpy((char *)(dest),(char *)(src),sizeof(va_list))
74 /* #define DEBUG_CALLBACKS */
75 /* #define DEBUG_READER */
80 * macro to flag unimplemented blocks
83 xmlGenericError(xmlGenericErrorContext, \
84 "Unimplemented block at %s:%d\n", \
88 #define DUMP_READER xmlTextReaderDebug(reader);
93 #define CHUNK_SIZE 512
94 /************************************************************************
96 * The parser: maps the Text Reader API on top of the existing *
97 * parsing routines building a tree *
99 ************************************************************************/
101 #define XML_TEXTREADER_INPUT 1
102 #define XML_TEXTREADER_CTXT 2
105 XML_TEXTREADER_NONE
= -1,
106 XML_TEXTREADER_START
= 0,
107 XML_TEXTREADER_ELEMENT
= 1,
108 XML_TEXTREADER_END
= 2,
109 XML_TEXTREADER_EMPTY
= 3,
110 XML_TEXTREADER_BACKTRACK
= 4,
111 XML_TEXTREADER_DONE
= 5,
112 XML_TEXTREADER_ERROR
= 6
113 } xmlTextReaderState
;
116 XML_TEXTREADER_NOT_VALIDATE
= 0,
117 XML_TEXTREADER_VALIDATE_DTD
= 1,
118 XML_TEXTREADER_VALIDATE_RNG
= 2,
119 XML_TEXTREADER_VALIDATE_XSD
= 4
120 } xmlTextReaderValidate
;
122 struct _xmlTextReader
{
123 int mode
; /* the parsing mode */
124 xmlDocPtr doc
; /* when walking an existing doc */
125 xmlTextReaderValidate validate
;/* is there any validation */
126 int allocs
; /* what structure were deallocated */
127 xmlTextReaderState state
;
128 xmlParserCtxtPtr ctxt
; /* the parser context */
129 xmlSAXHandlerPtr sax
; /* the parser SAX callbacks */
130 xmlParserInputBufferPtr input
; /* the input */
131 startElementSAXFunc startElement
;/* initial SAX callbacks */
132 endElementSAXFunc endElement
; /* idem */
133 startElementNsSAX2Func startElementNs
;/* idem */
134 endElementNsSAX2Func endElementNs
; /* idem */
135 charactersSAXFunc characters
;
136 cdataBlockSAXFunc cdataBlock
;
137 unsigned int base
; /* base of the segment in the input */
138 unsigned int cur
; /* current position in the input */
139 xmlNodePtr node
; /* current node */
140 xmlNodePtr curnode
;/* current attribute node */
141 int depth
; /* depth of the current node */
142 xmlNodePtr faketext
;/* fake xmlNs chld */
143 int preserve
;/* preserve the resulting document */
144 xmlBufPtr buffer
; /* used to return const xmlChar * */
145 xmlDictPtr dict
; /* the context dictionary */
147 /* entity stack when traversing entities content */
148 xmlNodePtr ent
; /* Current Entity Ref Node */
149 int entNr
; /* Depth of the entities stack */
150 int entMax
; /* Max depth of the entities stack */
151 xmlNodePtr
*entTab
; /* array of entities */
154 xmlTextReaderErrorFunc errorFunc
; /* callback function */
155 void *errorFuncArg
; /* callback function user argument */
157 #ifdef LIBXML_SCHEMAS_ENABLED
158 /* Handling of RelaxNG validation */
159 xmlRelaxNGPtr rngSchemas
; /* The Relax NG schemas */
160 xmlRelaxNGValidCtxtPtr rngValidCtxt
;/* The Relax NG validation context */
161 int rngPreserveCtxt
; /* 1 if the context was provided by the user */
162 int rngValidErrors
;/* The number of errors detected */
163 xmlNodePtr rngFullNode
; /* the node if RNG not progressive */
164 /* Handling of Schemas validation */
165 xmlSchemaPtr xsdSchemas
; /* The Schemas schemas */
166 xmlSchemaValidCtxtPtr xsdValidCtxt
;/* The Schemas validation context */
167 int xsdPreserveCtxt
; /* 1 if the context was provided by the user */
168 int xsdValidErrors
;/* The number of errors detected */
169 xmlSchemaSAXPlugPtr xsdPlug
; /* the schemas plug in SAX pipeline */
171 #ifdef LIBXML_XINCLUDE_ENABLED
172 /* Handling of XInclude processing */
173 int xinclude
; /* is xinclude asked for */
174 const xmlChar
* xinclude_name
; /* the xinclude name from dict */
175 xmlXIncludeCtxtPtr xincctxt
; /* the xinclude context */
176 int in_xinclude
; /* counts for xinclude */
178 #ifdef LIBXML_PATTERN_ENABLED
179 int patternNr
; /* number of preserve patterns */
180 int patternMax
; /* max preserve patterns */
181 xmlPatternPtr
*patternTab
; /* array of preserve patterns */
183 int preserves
; /* level of preserves */
184 int parserFlags
; /* the set of options set */
185 /* Structured error handling */
186 xmlStructuredErrorFunc sErrorFunc
; /* callback function */
189 #define NODE_IS_EMPTY 0x1
190 #define NODE_IS_PRESERVED 0x2
191 #define NODE_IS_SPRESERVED 0x4
196 * Macro used to return an interned string
198 #define CONSTSTR(str) xmlDictLookup(reader->dict, (str), -1)
199 #define CONSTQSTR(p, str) xmlDictQLookup(reader->dict, (p), (str))
201 static int xmlTextReaderReadTree(xmlTextReaderPtr reader
);
202 static int xmlTextReaderNextTree(xmlTextReaderPtr reader
);
204 /************************************************************************
206 * Our own version of the freeing routines as we recycle nodes *
208 ************************************************************************/
213 * Free a string if it is not owned by the "dict" dictionary in the
216 #define DICT_FREE(str) \
217 if ((str) && ((!dict) || \
218 (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
219 xmlFree((char *)(str));
221 static void xmlTextReaderFreeNode(xmlTextReaderPtr reader
, xmlNodePtr cur
);
222 static void xmlTextReaderFreeNodeList(xmlTextReaderPtr reader
, xmlNodePtr cur
);
228 * Deallocate the memory used by an id definition
231 xmlFreeID(xmlIDPtr id
) {
232 xmlDictPtr dict
= NULL
;
234 if (id
== NULL
) return;
237 dict
= id
->doc
->dict
;
239 if (id
->value
!= NULL
)
245 * xmlTextReaderRemoveID:
247 * @attr: the attribute
249 * Remove the given attribute from the ID table maintained internally.
251 * Returns -1 if the lookup failed and 0 otherwise
254 xmlTextReaderRemoveID(xmlDocPtr doc
, xmlAttrPtr attr
) {
259 if (doc
== NULL
) return(-1);
260 if (attr
== NULL
) return(-1);
261 table
= (xmlIDTablePtr
) doc
->ids
;
265 ID
= xmlNodeListGetString(doc
, attr
->children
, 1);
268 id
= xmlHashLookup(table
, ID
);
270 if (id
== NULL
|| id
->attr
!= attr
) {
273 id
->name
= attr
->name
;
279 * xmlTextReaderFreeProp:
280 * @reader: the xmlTextReaderPtr used
286 xmlTextReaderFreeProp(xmlTextReaderPtr reader
, xmlAttrPtr cur
) {
289 if ((reader
!= NULL
) && (reader
->ctxt
!= NULL
))
290 dict
= reader
->ctxt
->dict
;
293 if (cur
== NULL
) return;
295 if ((__xmlRegisterCallbacks
) && (xmlDeregisterNodeDefaultValue
))
296 xmlDeregisterNodeDefaultValue((xmlNodePtr
) cur
);
298 /* Check for ID removal -> leading to invalid references ! */
299 if ((cur
->parent
!= NULL
) && (cur
->parent
->doc
!= NULL
) &&
300 ((cur
->parent
->doc
->intSubset
!= NULL
) ||
301 (cur
->parent
->doc
->extSubset
!= NULL
))) {
302 if (xmlIsID(cur
->parent
->doc
, cur
->parent
, cur
))
303 xmlTextReaderRemoveID(cur
->parent
->doc
, cur
);
305 if (cur
->children
!= NULL
)
306 xmlTextReaderFreeNodeList(reader
, cur
->children
);
308 DICT_FREE(cur
->name
);
309 if ((reader
!= NULL
) && (reader
->ctxt
!= NULL
) &&
310 (reader
->ctxt
->freeAttrsNr
< 100)) {
311 cur
->next
= reader
->ctxt
->freeAttrs
;
312 reader
->ctxt
->freeAttrs
= cur
;
313 reader
->ctxt
->freeAttrsNr
++;
320 * xmlTextReaderFreePropList:
321 * @reader: the xmlTextReaderPtr used
322 * @cur: the first property in the list
324 * Free a property and all its siblings, all the children are freed too.
327 xmlTextReaderFreePropList(xmlTextReaderPtr reader
, xmlAttrPtr cur
) {
330 while (cur
!= NULL
) {
332 xmlTextReaderFreeProp(reader
, cur
);
338 * xmlTextReaderFreeNodeList:
339 * @reader: the xmlTextReaderPtr used
340 * @cur: the first node in the list
342 * Free a node and all its siblings, this is a recursive behaviour, all
343 * the children are freed too.
346 xmlTextReaderFreeNodeList(xmlTextReaderPtr reader
, xmlNodePtr cur
) {
350 if ((reader
!= NULL
) && (reader
->ctxt
!= NULL
))
351 dict
= reader
->ctxt
->dict
;
354 if (cur
== NULL
) return;
355 if (cur
->type
== XML_NAMESPACE_DECL
) {
356 xmlFreeNsList((xmlNsPtr
) cur
);
359 if ((cur
->type
== XML_DOCUMENT_NODE
) ||
360 (cur
->type
== XML_HTML_DOCUMENT_NODE
)) {
361 xmlFreeDoc((xmlDocPtr
) cur
);
364 while (cur
!= NULL
) {
366 /* unroll to speed up freeing the document */
367 if (cur
->type
!= XML_DTD_NODE
) {
369 if ((cur
->children
!= NULL
) &&
370 (cur
->type
!= XML_ENTITY_REF_NODE
)) {
371 if (cur
->children
->parent
== cur
)
372 xmlTextReaderFreeNodeList(reader
, cur
->children
);
373 cur
->children
= NULL
;
376 if ((__xmlRegisterCallbacks
) && (xmlDeregisterNodeDefaultValue
))
377 xmlDeregisterNodeDefaultValue(cur
);
379 if (((cur
->type
== XML_ELEMENT_NODE
) ||
380 (cur
->type
== XML_XINCLUDE_START
) ||
381 (cur
->type
== XML_XINCLUDE_END
)) &&
382 (cur
->properties
!= NULL
))
383 xmlTextReaderFreePropList(reader
, cur
->properties
);
384 if ((cur
->content
!= (xmlChar
*) &(cur
->properties
)) &&
385 (cur
->type
!= XML_ELEMENT_NODE
) &&
386 (cur
->type
!= XML_XINCLUDE_START
) &&
387 (cur
->type
!= XML_XINCLUDE_END
) &&
388 (cur
->type
!= XML_ENTITY_REF_NODE
)) {
389 DICT_FREE(cur
->content
);
391 if (((cur
->type
== XML_ELEMENT_NODE
) ||
392 (cur
->type
== XML_XINCLUDE_START
) ||
393 (cur
->type
== XML_XINCLUDE_END
)) &&
394 (cur
->nsDef
!= NULL
))
395 xmlFreeNsList(cur
->nsDef
);
398 * we don't free element names here they are interned now
400 if ((cur
->type
!= XML_TEXT_NODE
) &&
401 (cur
->type
!= XML_COMMENT_NODE
))
402 DICT_FREE(cur
->name
);
403 if (((cur
->type
== XML_ELEMENT_NODE
) ||
404 (cur
->type
== XML_TEXT_NODE
)) &&
405 (reader
!= NULL
) && (reader
->ctxt
!= NULL
) &&
406 (reader
->ctxt
->freeElemsNr
< 100)) {
407 cur
->next
= reader
->ctxt
->freeElems
;
408 reader
->ctxt
->freeElems
= cur
;
409 reader
->ctxt
->freeElemsNr
++;
419 * xmlTextReaderFreeNode:
420 * @reader: the xmlTextReaderPtr used
423 * Free a node, this is a recursive behaviour, all the children are freed too.
424 * This doesn't unlink the child from the list, use xmlUnlinkNode() first.
427 xmlTextReaderFreeNode(xmlTextReaderPtr reader
, xmlNodePtr cur
) {
430 if ((reader
!= NULL
) && (reader
->ctxt
!= NULL
))
431 dict
= reader
->ctxt
->dict
;
434 if (cur
->type
== XML_DTD_NODE
) {
435 xmlFreeDtd((xmlDtdPtr
) cur
);
438 if (cur
->type
== XML_NAMESPACE_DECL
) {
439 xmlFreeNs((xmlNsPtr
) cur
);
442 if (cur
->type
== XML_ATTRIBUTE_NODE
) {
443 xmlTextReaderFreeProp(reader
, (xmlAttrPtr
) cur
);
447 if ((cur
->children
!= NULL
) &&
448 (cur
->type
!= XML_ENTITY_REF_NODE
)) {
449 if (cur
->children
->parent
== cur
)
450 xmlTextReaderFreeNodeList(reader
, cur
->children
);
451 cur
->children
= NULL
;
454 if ((__xmlRegisterCallbacks
) && (xmlDeregisterNodeDefaultValue
))
455 xmlDeregisterNodeDefaultValue(cur
);
457 if (((cur
->type
== XML_ELEMENT_NODE
) ||
458 (cur
->type
== XML_XINCLUDE_START
) ||
459 (cur
->type
== XML_XINCLUDE_END
)) &&
460 (cur
->properties
!= NULL
))
461 xmlTextReaderFreePropList(reader
, cur
->properties
);
462 if ((cur
->content
!= (xmlChar
*) &(cur
->properties
)) &&
463 (cur
->type
!= XML_ELEMENT_NODE
) &&
464 (cur
->type
!= XML_XINCLUDE_START
) &&
465 (cur
->type
!= XML_XINCLUDE_END
) &&
466 (cur
->type
!= XML_ENTITY_REF_NODE
)) {
467 DICT_FREE(cur
->content
);
469 if (((cur
->type
== XML_ELEMENT_NODE
) ||
470 (cur
->type
== XML_XINCLUDE_START
) ||
471 (cur
->type
== XML_XINCLUDE_END
)) &&
472 (cur
->nsDef
!= NULL
))
473 xmlFreeNsList(cur
->nsDef
);
476 * we don't free names here they are interned now
478 if ((cur
->type
!= XML_TEXT_NODE
) &&
479 (cur
->type
!= XML_COMMENT_NODE
))
480 DICT_FREE(cur
->name
);
482 if (((cur
->type
== XML_ELEMENT_NODE
) ||
483 (cur
->type
== XML_TEXT_NODE
)) &&
484 (reader
!= NULL
) && (reader
->ctxt
!= NULL
) &&
485 (reader
->ctxt
->freeElemsNr
< 100)) {
486 cur
->next
= reader
->ctxt
->freeElems
;
487 reader
->ctxt
->freeElems
= cur
;
488 reader
->ctxt
->freeElemsNr
++;
495 * xmlTextReaderFreeIDTable:
496 * @table: An id table
498 * Deallocate the memory used by an ID hash table.
501 xmlTextReaderFreeIDTable(xmlIDTablePtr table
) {
502 xmlHashFree(table
, (xmlHashDeallocator
) xmlFreeID
);
506 * xmlTextReaderFreeDoc:
507 * @reader: the xmlTextReaderPtr used
508 * @cur: pointer to the document
510 * Free up all the structures used by a document, tree included.
513 xmlTextReaderFreeDoc(xmlTextReaderPtr reader
, xmlDocPtr cur
) {
514 xmlDtdPtr extSubset
, intSubset
;
516 if (cur
== NULL
) return;
518 if ((__xmlRegisterCallbacks
) && (xmlDeregisterNodeDefaultValue
))
519 xmlDeregisterNodeDefaultValue((xmlNodePtr
) cur
);
522 * Do this before freeing the children list to avoid ID lookups
524 if (cur
->ids
!= NULL
) xmlTextReaderFreeIDTable((xmlIDTablePtr
) cur
->ids
);
526 if (cur
->refs
!= NULL
) xmlFreeRefTable((xmlRefTablePtr
) cur
->refs
);
528 extSubset
= cur
->extSubset
;
529 intSubset
= cur
->intSubset
;
530 if (intSubset
== extSubset
)
532 if (extSubset
!= NULL
) {
533 xmlUnlinkNode((xmlNodePtr
) cur
->extSubset
);
534 cur
->extSubset
= NULL
;
535 xmlFreeDtd(extSubset
);
537 if (intSubset
!= NULL
) {
538 xmlUnlinkNode((xmlNodePtr
) cur
->intSubset
);
539 cur
->intSubset
= NULL
;
540 xmlFreeDtd(intSubset
);
543 if (cur
->children
!= NULL
) xmlTextReaderFreeNodeList(reader
, cur
->children
);
545 if (cur
->version
!= NULL
) xmlFree((char *) cur
->version
);
546 if (cur
->name
!= NULL
) xmlFree((char *) cur
->name
);
547 if (cur
->encoding
!= NULL
) xmlFree((char *) cur
->encoding
);
548 if (cur
->oldNs
!= NULL
) xmlFreeNsList(cur
->oldNs
);
549 if (cur
->URL
!= NULL
) xmlFree((char *) cur
->URL
);
550 if (cur
->dict
!= NULL
) xmlDictFree(cur
->dict
);
555 /************************************************************************
557 * The reader core parser *
559 ************************************************************************/
562 xmlTextReaderDebug(xmlTextReaderPtr reader
) {
563 if ((reader
== NULL
) || (reader
->ctxt
== NULL
)) {
564 fprintf(stderr
, "xmlTextReader NULL\n");
567 fprintf(stderr
, "xmlTextReader: state %d depth %d ",
568 reader
->state
, reader
->depth
);
569 if (reader
->node
== NULL
) {
570 fprintf(stderr
, "node = NULL\n");
572 fprintf(stderr
, "node %s\n", reader
->node
->name
);
574 fprintf(stderr
, " input: base %d, cur %d, depth %d: ",
575 reader
->base
, reader
->cur
, reader
->ctxt
->nodeNr
);
576 if (reader
->input
->buffer
== NULL
) {
577 fprintf(stderr
, "buffer is NULL\n");
579 #ifdef LIBXML_DEBUG_ENABLED
580 xmlDebugDumpString(stderr
,
581 &reader
->input
->buffer
->content
[reader
->cur
]);
583 fprintf(stderr
, "\n");
589 * xmlTextReaderEntPush:
590 * @reader: the xmlTextReaderPtr used
591 * @value: the entity reference node
593 * Pushes a new entity reference node on top of the entities stack
595 * Returns 0 in case of error, the index in the stack otherwise
598 xmlTextReaderEntPush(xmlTextReaderPtr reader
, xmlNodePtr value
)
600 if (reader
->entMax
<= 0) {
602 reader
->entTab
= (xmlNodePtr
*) xmlMalloc(reader
->entMax
*
603 sizeof(reader
->entTab
[0]));
604 if (reader
->entTab
== NULL
) {
605 xmlGenericError(xmlGenericErrorContext
, "xmlMalloc failed !\n");
609 if (reader
->entNr
>= reader
->entMax
) {
612 (xmlNodePtr
*) xmlRealloc(reader
->entTab
,
614 sizeof(reader
->entTab
[0]));
615 if (reader
->entTab
== NULL
) {
616 xmlGenericError(xmlGenericErrorContext
, "xmlRealloc failed !\n");
620 reader
->entTab
[reader
->entNr
] = value
;
622 return (reader
->entNr
++);
626 * xmlTextReaderEntPop:
627 * @reader: the xmlTextReaderPtr used
629 * Pops the top element entity from the entities stack
631 * Returns the entity just removed
634 xmlTextReaderEntPop(xmlTextReaderPtr reader
)
638 if (reader
->entNr
<= 0)
641 if (reader
->entNr
> 0)
642 reader
->ent
= reader
->entTab
[reader
->entNr
- 1];
645 ret
= reader
->entTab
[reader
->entNr
];
646 reader
->entTab
[reader
->entNr
] = NULL
;
651 * xmlTextReaderStartElement:
652 * @ctx: the user data (XML parser context)
653 * @fullname: The element name, including namespace prefix
654 * @atts: An array of name/value attributes pairs, NULL terminated
656 * called when an opening tag has been processed.
659 xmlTextReaderStartElement(void *ctx
, const xmlChar
*fullname
,
660 const xmlChar
**atts
) {
661 xmlParserCtxtPtr ctxt
= (xmlParserCtxtPtr
) ctx
;
662 xmlTextReaderPtr reader
= ctxt
->_private
;
664 #ifdef DEBUG_CALLBACKS
665 printf("xmlTextReaderStartElement(%s)\n", fullname
);
667 if ((reader
!= NULL
) && (reader
->startElement
!= NULL
)) {
668 reader
->startElement(ctx
, fullname
, atts
);
669 if ((ctxt
->node
!= NULL
) && (ctxt
->input
!= NULL
) &&
670 (ctxt
->input
->cur
!= NULL
) && (ctxt
->input
->cur
[0] == '/') &&
671 (ctxt
->input
->cur
[1] == '>'))
672 ctxt
->node
->extra
= NODE_IS_EMPTY
;
675 reader
->state
= XML_TEXTREADER_ELEMENT
;
679 * xmlTextReaderEndElement:
680 * @ctx: the user data (XML parser context)
681 * @fullname: The element name, including namespace prefix
683 * called when an ending tag has been processed.
686 xmlTextReaderEndElement(void *ctx
, const xmlChar
*fullname
) {
687 xmlParserCtxtPtr ctxt
= (xmlParserCtxtPtr
) ctx
;
688 xmlTextReaderPtr reader
= ctxt
->_private
;
690 #ifdef DEBUG_CALLBACKS
691 printf("xmlTextReaderEndElement(%s)\n", fullname
);
693 if ((reader
!= NULL
) && (reader
->endElement
!= NULL
)) {
694 reader
->endElement(ctx
, fullname
);
699 * xmlTextReaderStartElementNs:
700 * @ctx: the user data (XML parser context)
701 * @localname: the local name of the element
702 * @prefix: the element namespace prefix if available
703 * @URI: the element namespace name if available
704 * @nb_namespaces: number of namespace definitions on that node
705 * @namespaces: pointer to the array of prefix/URI pairs namespace definitions
706 * @nb_attributes: the number of attributes on that node
707 * nb_defaulted: the number of defaulted attributes.
708 * @attributes: pointer to the array of (localname/prefix/URI/value/end)
711 * called when an opening tag has been processed.
714 xmlTextReaderStartElementNs(void *ctx
,
715 const xmlChar
*localname
,
716 const xmlChar
*prefix
,
719 const xmlChar
**namespaces
,
722 const xmlChar
**attributes
)
724 xmlParserCtxtPtr ctxt
= (xmlParserCtxtPtr
) ctx
;
725 xmlTextReaderPtr reader
= ctxt
->_private
;
727 #ifdef DEBUG_CALLBACKS
728 printf("xmlTextReaderStartElementNs(%s)\n", localname
);
730 if ((reader
!= NULL
) && (reader
->startElementNs
!= NULL
)) {
731 reader
->startElementNs(ctx
, localname
, prefix
, URI
, nb_namespaces
,
732 namespaces
, nb_attributes
, nb_defaulted
,
734 if ((ctxt
->node
!= NULL
) && (ctxt
->input
!= NULL
) &&
735 (ctxt
->input
->cur
!= NULL
) && (ctxt
->input
->cur
[0] == '/') &&
736 (ctxt
->input
->cur
[1] == '>'))
737 ctxt
->node
->extra
= NODE_IS_EMPTY
;
740 reader
->state
= XML_TEXTREADER_ELEMENT
;
744 * xmlTextReaderEndElementNs:
745 * @ctx: the user data (XML parser context)
746 * @localname: the local name of the element
747 * @prefix: the element namespace prefix if available
748 * @URI: the element namespace name if available
750 * called when an ending tag has been processed.
753 xmlTextReaderEndElementNs(void *ctx
,
754 const xmlChar
* localname
,
755 const xmlChar
* prefix
,
758 xmlParserCtxtPtr ctxt
= (xmlParserCtxtPtr
) ctx
;
759 xmlTextReaderPtr reader
= ctxt
->_private
;
761 #ifdef DEBUG_CALLBACKS
762 printf("xmlTextReaderEndElementNs(%s)\n", localname
);
764 if ((reader
!= NULL
) && (reader
->endElementNs
!= NULL
)) {
765 reader
->endElementNs(ctx
, localname
, prefix
, URI
);
771 * xmlTextReaderCharacters:
772 * @ctx: the user data (XML parser context)
773 * @ch: a xmlChar string
774 * @len: the number of xmlChar
776 * receiving some chars from the parser.
779 xmlTextReaderCharacters(void *ctx
, const xmlChar
*ch
, int len
)
781 xmlParserCtxtPtr ctxt
= (xmlParserCtxtPtr
) ctx
;
782 xmlTextReaderPtr reader
= ctxt
->_private
;
784 #ifdef DEBUG_CALLBACKS
785 printf("xmlTextReaderCharacters()\n");
787 if ((reader
!= NULL
) && (reader
->characters
!= NULL
)) {
788 reader
->characters(ctx
, ch
, len
);
793 * xmlTextReaderCDataBlock:
794 * @ctx: the user data (XML parser context)
795 * @value: The pcdata content
796 * @len: the block length
798 * called when a pcdata block has been parsed
801 xmlTextReaderCDataBlock(void *ctx
, const xmlChar
*ch
, int len
)
803 xmlParserCtxtPtr ctxt
= (xmlParserCtxtPtr
) ctx
;
804 xmlTextReaderPtr reader
= ctxt
->_private
;
806 #ifdef DEBUG_CALLBACKS
807 printf("xmlTextReaderCDataBlock()\n");
809 if ((reader
!= NULL
) && (reader
->cdataBlock
!= NULL
)) {
810 reader
->cdataBlock(ctx
, ch
, len
);
815 * xmlTextReaderPushData:
816 * @reader: the xmlTextReaderPtr used
818 * Push data down the progressive parser until a significant callback
821 * Returns -1 in case of failure, 0 otherwise
824 xmlTextReaderPushData(xmlTextReaderPtr reader
) {
827 xmlTextReaderState oldstate
;
830 if ((reader
->input
== NULL
) || (reader
->input
->buffer
== NULL
))
833 oldstate
= reader
->state
;
834 reader
->state
= XML_TEXTREADER_NONE
;
835 inbuf
= reader
->input
->buffer
;
836 alloc
= xmlBufGetAllocationScheme(inbuf
);
838 while (reader
->state
== XML_TEXTREADER_NONE
) {
839 if (xmlBufUse(inbuf
) < reader
->cur
+ CHUNK_SIZE
) {
841 * Refill the buffer unless we are at the end of the stream
843 if (reader
->mode
!= XML_TEXTREADER_MODE_EOF
) {
844 val
= xmlParserInputBufferRead(reader
->input
, 4096);
846 (alloc
== XML_BUFFER_ALLOC_IMMUTABLE
)) {
847 if (xmlBufUse(inbuf
) == reader
->cur
) {
848 reader
->mode
= XML_TEXTREADER_MODE_EOF
;
849 reader
->state
= oldstate
;
851 } else if (val
< 0) {
852 reader
->mode
= XML_TEXTREADER_MODE_EOF
;
853 reader
->state
= oldstate
;
854 if ((oldstate
!= XML_TEXTREADER_START
) ||
855 (reader
->ctxt
->myDoc
!= NULL
))
857 } else if (val
== 0) {
858 /* mark the end of the stream and process the remains */
859 reader
->mode
= XML_TEXTREADER_MODE_EOF
;
867 * parse by block of CHUNK_SIZE bytes, various tests show that
868 * it's the best tradeoff at least on a 1.2GH Duron
870 if (xmlBufUse(inbuf
) >= reader
->cur
+ CHUNK_SIZE
) {
871 val
= xmlParseChunk(reader
->ctxt
,
872 (const char *) xmlBufContent(inbuf
) + reader
->cur
,
874 reader
->cur
+= CHUNK_SIZE
;
876 reader
->ctxt
->wellFormed
= 0;
877 if (reader
->ctxt
->wellFormed
== 0)
880 s
= xmlBufUse(inbuf
) - reader
->cur
;
881 val
= xmlParseChunk(reader
->ctxt
,
882 (const char *) xmlBufContent(inbuf
) + reader
->cur
,
886 reader
->ctxt
->wellFormed
= 0;
892 * Discard the consumed input when needed and possible
894 if (reader
->mode
== XML_TEXTREADER_MODE_INTERACTIVE
) {
895 if (alloc
!= XML_BUFFER_ALLOC_IMMUTABLE
) {
896 if ((reader
->cur
>= 4096) &&
897 (xmlBufUse(inbuf
) - reader
->cur
<= CHUNK_SIZE
)) {
898 val
= xmlBufShrink(inbuf
, reader
->cur
);
907 * At the end of the stream signal that the work is done to the Push
910 else if (reader
->mode
== XML_TEXTREADER_MODE_EOF
) {
911 if (reader
->state
!= XML_TEXTREADER_DONE
) {
912 s
= xmlBufUse(inbuf
) - reader
->cur
;
913 val
= xmlParseChunk(reader
->ctxt
,
914 (const char *) xmlBufContent(inbuf
) + reader
->cur
,
916 reader
->cur
= xmlBufUse(inbuf
);
917 reader
->state
= XML_TEXTREADER_DONE
;
919 if (reader
->ctxt
->wellFormed
)
920 reader
->ctxt
->wellFormed
= 0;
926 reader
->state
= oldstate
;
927 if (reader
->ctxt
->wellFormed
== 0) {
928 reader
->mode
= XML_TEXTREADER_MODE_EOF
;
935 #ifdef LIBXML_REGEXP_ENABLED
937 * xmlTextReaderValidatePush:
938 * @reader: the xmlTextReaderPtr used
940 * Push the current node for validation
943 xmlTextReaderValidatePush(xmlTextReaderPtr reader ATTRIBUTE_UNUSED
) {
944 xmlNodePtr node
= reader
->node
;
946 #ifdef LIBXML_VALID_ENABLED
947 if ((reader
->validate
== XML_TEXTREADER_VALIDATE_DTD
) &&
948 (reader
->ctxt
!= NULL
) && (reader
->ctxt
->validate
== 1)) {
949 if ((node
->ns
== NULL
) || (node
->ns
->prefix
== NULL
)) {
950 reader
->ctxt
->valid
&= xmlValidatePushElement(&reader
->ctxt
->vctxt
,
951 reader
->ctxt
->myDoc
, node
, node
->name
);
953 /* TODO use the BuildQName interface */
956 qname
= xmlStrdup(node
->ns
->prefix
);
957 qname
= xmlStrcat(qname
, BAD_CAST
":");
958 qname
= xmlStrcat(qname
, node
->name
);
959 reader
->ctxt
->valid
&= xmlValidatePushElement(&reader
->ctxt
->vctxt
,
960 reader
->ctxt
->myDoc
, node
, qname
);
965 #endif /* LIBXML_VALID_ENABLED */
966 #ifdef LIBXML_SCHEMAS_ENABLED
967 if ((reader
->validate
== XML_TEXTREADER_VALIDATE_RNG
) &&
968 (reader
->rngValidCtxt
!= NULL
)) {
971 if (reader
->rngFullNode
!= NULL
) return;
972 ret
= xmlRelaxNGValidatePushElement(reader
->rngValidCtxt
,
977 * this element requires a full tree
979 node
= xmlTextReaderExpand(reader
);
981 printf("Expand failed !\n");
984 ret
= xmlRelaxNGValidateFullElement(reader
->rngValidCtxt
,
987 reader
->rngFullNode
= node
;
991 reader
->rngValidErrors
++;
997 * xmlTextReaderValidateCData:
998 * @reader: the xmlTextReaderPtr used
999 * @data: pointer to the CData
1000 * @len: length of the CData block in bytes.
1002 * Push some CData for validation
1005 xmlTextReaderValidateCData(xmlTextReaderPtr reader
,
1006 const xmlChar
*data
, int len
) {
1007 #ifdef LIBXML_VALID_ENABLED
1008 if ((reader
->validate
== XML_TEXTREADER_VALIDATE_DTD
) &&
1009 (reader
->ctxt
!= NULL
) && (reader
->ctxt
->validate
== 1)) {
1010 reader
->ctxt
->valid
&= xmlValidatePushCData(&reader
->ctxt
->vctxt
,
1013 #endif /* LIBXML_VALID_ENABLED */
1014 #ifdef LIBXML_SCHEMAS_ENABLED
1015 if ((reader
->validate
== XML_TEXTREADER_VALIDATE_RNG
) &&
1016 (reader
->rngValidCtxt
!= NULL
)) {
1019 if (reader
->rngFullNode
!= NULL
) return;
1020 ret
= xmlRelaxNGValidatePushCData(reader
->rngValidCtxt
, data
, len
);
1022 reader
->rngValidErrors
++;
1028 * xmlTextReaderValidatePop:
1029 * @reader: the xmlTextReaderPtr used
1031 * Pop the current node from validation
1034 xmlTextReaderValidatePop(xmlTextReaderPtr reader
) {
1035 xmlNodePtr node
= reader
->node
;
1037 #ifdef LIBXML_VALID_ENABLED
1038 if ((reader
->validate
== XML_TEXTREADER_VALIDATE_DTD
) &&
1039 (reader
->ctxt
!= NULL
) && (reader
->ctxt
->validate
== 1)) {
1040 if ((node
->ns
== NULL
) || (node
->ns
->prefix
== NULL
)) {
1041 reader
->ctxt
->valid
&= xmlValidatePopElement(&reader
->ctxt
->vctxt
,
1042 reader
->ctxt
->myDoc
, node
, node
->name
);
1044 /* TODO use the BuildQName interface */
1047 qname
= xmlStrdup(node
->ns
->prefix
);
1048 qname
= xmlStrcat(qname
, BAD_CAST
":");
1049 qname
= xmlStrcat(qname
, node
->name
);
1050 reader
->ctxt
->valid
&= xmlValidatePopElement(&reader
->ctxt
->vctxt
,
1051 reader
->ctxt
->myDoc
, node
, qname
);
1056 #endif /* LIBXML_VALID_ENABLED */
1057 #ifdef LIBXML_SCHEMAS_ENABLED
1058 if ((reader
->validate
== XML_TEXTREADER_VALIDATE_RNG
) &&
1059 (reader
->rngValidCtxt
!= NULL
)) {
1062 if (reader
->rngFullNode
!= NULL
) {
1063 if (node
== reader
->rngFullNode
)
1064 reader
->rngFullNode
= NULL
;
1067 ret
= xmlRelaxNGValidatePopElement(reader
->rngValidCtxt
,
1068 reader
->ctxt
->myDoc
,
1071 reader
->rngValidErrors
++;
1077 * xmlTextReaderValidateEntity:
1078 * @reader: the xmlTextReaderPtr used
1080 * Handle the validation when an entity reference is encountered and
1081 * entity substitution is not activated. As a result the parser interface
1082 * must walk through the entity and do the validation calls
1085 xmlTextReaderValidateEntity(xmlTextReaderPtr reader
) {
1086 xmlNodePtr oldnode
= reader
->node
;
1087 xmlNodePtr node
= reader
->node
;
1088 xmlParserCtxtPtr ctxt
= reader
->ctxt
;
1091 if (node
->type
== XML_ENTITY_REF_NODE
) {
1093 * Case where the underlying tree is not availble, lookup the entity
1096 if ((node
->children
== NULL
) && (ctxt
->sax
!= NULL
) &&
1097 (ctxt
->sax
->getEntity
!= NULL
)) {
1098 node
->children
= (xmlNodePtr
)
1099 ctxt
->sax
->getEntity(ctxt
, node
->name
);
1102 if ((node
->children
!= NULL
) &&
1103 (node
->children
->type
== XML_ENTITY_DECL
) &&
1104 (node
->children
->children
!= NULL
)) {
1105 xmlTextReaderEntPush(reader
, node
);
1106 node
= node
->children
->children
;
1110 * The error has probably be raised already.
1112 if (node
== oldnode
)
1116 #ifdef LIBXML_REGEXP_ENABLED
1117 } else if (node
->type
== XML_ELEMENT_NODE
) {
1118 reader
->node
= node
;
1119 xmlTextReaderValidatePush(reader
);
1120 } else if ((node
->type
== XML_TEXT_NODE
) ||
1121 (node
->type
== XML_CDATA_SECTION_NODE
)) {
1122 xmlTextReaderValidateCData(reader
, node
->content
,
1123 xmlStrlen(node
->content
));
1130 if (node
->children
!= NULL
) {
1131 node
= node
->children
;
1133 } else if (node
->type
== XML_ELEMENT_NODE
) {
1134 xmlTextReaderValidatePop(reader
);
1136 if (node
->next
!= NULL
) {
1141 node
= node
->parent
;
1142 if (node
->type
== XML_ELEMENT_NODE
) {
1144 if (reader
->entNr
== 0) {
1145 while ((tmp
= node
->last
) != NULL
) {
1146 if ((tmp
->extra
& NODE_IS_PRESERVED
) == 0) {
1148 xmlTextReaderFreeNode(reader
, tmp
);
1153 reader
->node
= node
;
1154 xmlTextReaderValidatePop(reader
);
1156 if ((node
->type
== XML_ENTITY_DECL
) &&
1157 (reader
->ent
!= NULL
) && (reader
->ent
->children
== node
)) {
1158 node
= xmlTextReaderEntPop(reader
);
1160 if (node
== oldnode
)
1162 if (node
->next
!= NULL
) {
1166 } while ((node
!= NULL
) && (node
!= oldnode
));
1167 } while ((node
!= NULL
) && (node
!= oldnode
));
1168 reader
->node
= oldnode
;
1170 #endif /* LIBXML_REGEXP_ENABLED */
1174 * xmlTextReaderGetSuccessor:
1175 * @cur: the current node
1177 * Get the successor of a node if available.
1179 * Returns the successor node or NULL
1182 xmlTextReaderGetSuccessor(xmlNodePtr cur
) {
1183 if (cur
== NULL
) return(NULL
) ; /* ERROR */
1184 if (cur
->next
!= NULL
) return(cur
->next
) ;
1187 if (cur
== NULL
) break;
1188 if (cur
->next
!= NULL
) return(cur
->next
);
1189 } while (cur
!= NULL
);
1194 * xmlTextReaderDoExpand:
1195 * @reader: the xmlTextReaderPtr used
1197 * Makes sure that the current node is fully read as well as all its
1198 * descendant. It means the full DOM subtree must be available at the
1201 * Returns 1 if the node was expanded successfully, 0 if there is no more
1202 * nodes to read, or -1 in case of error
1205 xmlTextReaderDoExpand(xmlTextReaderPtr reader
) {
1208 if ((reader
== NULL
) || (reader
->node
== NULL
) || (reader
->ctxt
== NULL
))
1211 if (reader
->ctxt
->instate
== XML_PARSER_EOF
) return(1);
1213 if (xmlTextReaderGetSuccessor(reader
->node
) != NULL
)
1215 if (reader
->ctxt
->nodeNr
< reader
->depth
)
1217 if (reader
->mode
== XML_TEXTREADER_MODE_EOF
)
1219 val
= xmlTextReaderPushData(reader
);
1221 reader
->mode
= XML_TEXTREADER_MODE_ERROR
;
1224 } while(reader
->mode
!= XML_TEXTREADER_MODE_EOF
);
1229 * xmlTextReaderCollectSiblings:
1230 * @node: the first child
1232 * Traverse depth-first through all sibling nodes and their children
1233 * nodes and concatenate their content. This is an auxiliary function
1234 * to xmlTextReaderReadString.
1236 * Returns a string containing the content, or NULL in case of error.
1239 xmlTextReaderCollectSiblings(xmlNodePtr node
)
1241 xmlBufferPtr buffer
;
1244 if ((node
== NULL
) || (node
->type
== XML_NAMESPACE_DECL
))
1247 buffer
= xmlBufferCreate();
1251 for ( ; node
!= NULL
; node
= node
->next
) {
1252 switch (node
->type
) {
1254 case XML_CDATA_SECTION_NODE
:
1255 xmlBufferCat(buffer
, node
->content
);
1257 case XML_ELEMENT_NODE
: {
1260 tmp
= xmlTextReaderCollectSiblings(node
->children
);
1261 xmlBufferCat(buffer
, tmp
);
1269 ret
= buffer
->content
;
1270 buffer
->content
= NULL
;
1271 xmlBufferFree(buffer
);
1276 * xmlTextReaderRead:
1277 * @reader: the xmlTextReaderPtr used
1279 * Moves the position of the current instance to the next node in
1280 * the stream, exposing its properties.
1282 * Returns 1 if the node was read successfully, 0 if there is no more
1283 * nodes to read, or -1 in case of error
1286 xmlTextReaderRead(xmlTextReaderPtr reader
) {
1287 int val
, olddepth
= 0;
1288 xmlTextReaderState oldstate
= XML_TEXTREADER_START
;
1289 xmlNodePtr oldnode
= NULL
;
1294 reader
->curnode
= NULL
;
1295 if (reader
->doc
!= NULL
)
1296 return(xmlTextReaderReadTree(reader
));
1297 if (reader
->ctxt
== NULL
)
1301 fprintf(stderr
, "\nREAD ");
1304 if (reader
->mode
== XML_TEXTREADER_MODE_INITIAL
) {
1305 reader
->mode
= XML_TEXTREADER_MODE_INTERACTIVE
;
1310 val
= xmlTextReaderPushData(reader
);
1312 reader
->mode
= XML_TEXTREADER_MODE_ERROR
;
1313 reader
->state
= XML_TEXTREADER_ERROR
;
1316 } while ((reader
->ctxt
->node
== NULL
) &&
1317 ((reader
->mode
!= XML_TEXTREADER_MODE_EOF
) &&
1318 (reader
->state
!= XML_TEXTREADER_DONE
)));
1319 if (reader
->ctxt
->node
== NULL
) {
1320 if (reader
->ctxt
->myDoc
!= NULL
) {
1321 reader
->node
= reader
->ctxt
->myDoc
->children
;
1323 if (reader
->node
== NULL
){
1324 reader
->mode
= XML_TEXTREADER_MODE_ERROR
;
1325 reader
->state
= XML_TEXTREADER_ERROR
;
1328 reader
->state
= XML_TEXTREADER_ELEMENT
;
1330 if (reader
->ctxt
->myDoc
!= NULL
) {
1331 reader
->node
= reader
->ctxt
->myDoc
->children
;
1333 if (reader
->node
== NULL
)
1334 reader
->node
= reader
->ctxt
->nodeTab
[0];
1335 reader
->state
= XML_TEXTREADER_ELEMENT
;
1338 reader
->ctxt
->parseMode
= XML_PARSE_READER
;
1341 oldstate
= reader
->state
;
1342 olddepth
= reader
->ctxt
->nodeNr
;
1343 oldnode
= reader
->node
;
1346 if (reader
->node
== NULL
) {
1347 if (reader
->mode
== XML_TEXTREADER_MODE_EOF
)
1354 * If we are not backtracking on ancestors or examined nodes,
1355 * that the parser didn't finished or that we arent at the end
1356 * of stream, continue processing.
1358 while ((reader
->node
!= NULL
) && (reader
->node
->next
== NULL
) &&
1359 (reader
->ctxt
->nodeNr
== olddepth
) &&
1360 ((oldstate
== XML_TEXTREADER_BACKTRACK
) ||
1361 (reader
->node
->children
== NULL
) ||
1362 (reader
->node
->type
== XML_ENTITY_REF_NODE
) ||
1363 ((reader
->node
->children
!= NULL
) &&
1364 (reader
->node
->children
->type
== XML_TEXT_NODE
) &&
1365 (reader
->node
->children
->next
== NULL
)) ||
1366 (reader
->node
->type
== XML_DTD_NODE
) ||
1367 (reader
->node
->type
== XML_DOCUMENT_NODE
) ||
1368 (reader
->node
->type
== XML_HTML_DOCUMENT_NODE
)) &&
1369 ((reader
->ctxt
->node
== NULL
) ||
1370 (reader
->ctxt
->node
== reader
->node
) ||
1371 (reader
->ctxt
->node
== reader
->node
->parent
)) &&
1372 (reader
->ctxt
->instate
!= XML_PARSER_EOF
)) {
1373 val
= xmlTextReaderPushData(reader
);
1375 reader
->mode
= XML_TEXTREADER_MODE_ERROR
;
1376 reader
->state
= XML_TEXTREADER_ERROR
;
1379 if (reader
->node
== NULL
)
1382 if (oldstate
!= XML_TEXTREADER_BACKTRACK
) {
1383 if ((reader
->node
->children
!= NULL
) &&
1384 (reader
->node
->type
!= XML_ENTITY_REF_NODE
) &&
1385 (reader
->node
->type
!= XML_XINCLUDE_START
) &&
1386 (reader
->node
->type
!= XML_DTD_NODE
)) {
1387 reader
->node
= reader
->node
->children
;
1389 reader
->state
= XML_TEXTREADER_ELEMENT
;
1393 if (reader
->node
->next
!= NULL
) {
1394 if ((oldstate
== XML_TEXTREADER_ELEMENT
) &&
1395 (reader
->node
->type
== XML_ELEMENT_NODE
) &&
1396 (reader
->node
->children
== NULL
) &&
1397 ((reader
->node
->extra
& NODE_IS_EMPTY
) == 0)
1398 #ifdef LIBXML_XINCLUDE_ENABLED
1399 && (reader
->in_xinclude
<= 0)
1402 reader
->state
= XML_TEXTREADER_END
;
1405 #ifdef LIBXML_REGEXP_ENABLED
1406 if ((reader
->validate
) &&
1407 (reader
->node
->type
== XML_ELEMENT_NODE
))
1408 xmlTextReaderValidatePop(reader
);
1409 #endif /* LIBXML_REGEXP_ENABLED */
1410 if ((reader
->preserves
> 0) &&
1411 (reader
->node
->extra
& NODE_IS_SPRESERVED
))
1412 reader
->preserves
--;
1413 reader
->node
= reader
->node
->next
;
1414 reader
->state
= XML_TEXTREADER_ELEMENT
;
1417 * Cleanup of the old node
1419 if ((reader
->preserves
== 0) &&
1420 #ifdef LIBXML_XINCLUDE_ENABLED
1421 (reader
->in_xinclude
== 0) &&
1423 (reader
->entNr
== 0) &&
1424 (reader
->node
->prev
!= NULL
) &&
1425 (reader
->node
->prev
->type
!= XML_DTD_NODE
)) {
1426 xmlNodePtr tmp
= reader
->node
->prev
;
1427 if ((tmp
->extra
& NODE_IS_PRESERVED
) == 0) {
1429 xmlTextReaderFreeNode(reader
, tmp
);
1435 if ((oldstate
== XML_TEXTREADER_ELEMENT
) &&
1436 (reader
->node
->type
== XML_ELEMENT_NODE
) &&
1437 (reader
->node
->children
== NULL
) &&
1438 ((reader
->node
->extra
& NODE_IS_EMPTY
) == 0)) {;
1439 reader
->state
= XML_TEXTREADER_END
;
1442 #ifdef LIBXML_REGEXP_ENABLED
1443 if ((reader
->validate
!= XML_TEXTREADER_NOT_VALIDATE
) && (reader
->node
->type
== XML_ELEMENT_NODE
))
1444 xmlTextReaderValidatePop(reader
);
1445 #endif /* LIBXML_REGEXP_ENABLED */
1446 if ((reader
->preserves
> 0) &&
1447 (reader
->node
->extra
& NODE_IS_SPRESERVED
))
1448 reader
->preserves
--;
1449 reader
->node
= reader
->node
->parent
;
1450 if ((reader
->node
== NULL
) ||
1451 (reader
->node
->type
== XML_DOCUMENT_NODE
) ||
1452 #ifdef LIBXML_DOCB_ENABLED
1453 (reader
->node
->type
== XML_DOCB_DOCUMENT_NODE
) ||
1455 (reader
->node
->type
== XML_HTML_DOCUMENT_NODE
)) {
1456 if (reader
->mode
!= XML_TEXTREADER_MODE_EOF
) {
1457 val
= xmlParseChunk(reader
->ctxt
, "", 0, 1);
1458 reader
->state
= XML_TEXTREADER_DONE
;
1462 reader
->node
= NULL
;
1466 * Cleanup of the old node
1468 if ((oldnode
!= NULL
) && (reader
->preserves
== 0) &&
1469 #ifdef LIBXML_XINCLUDE_ENABLED
1470 (reader
->in_xinclude
== 0) &&
1472 (reader
->entNr
== 0) &&
1473 (oldnode
->type
!= XML_DTD_NODE
) &&
1474 ((oldnode
->extra
& NODE_IS_PRESERVED
) == 0)) {
1475 xmlUnlinkNode(oldnode
);
1476 xmlTextReaderFreeNode(reader
, oldnode
);
1481 if ((reader
->preserves
== 0) &&
1482 #ifdef LIBXML_XINCLUDE_ENABLED
1483 (reader
->in_xinclude
== 0) &&
1485 (reader
->entNr
== 0) &&
1486 (reader
->node
->last
!= NULL
) &&
1487 ((reader
->node
->last
->extra
& NODE_IS_PRESERVED
) == 0)) {
1488 xmlNodePtr tmp
= reader
->node
->last
;
1490 xmlTextReaderFreeNode(reader
, tmp
);
1493 reader
->state
= XML_TEXTREADER_BACKTRACK
;
1499 * If we are in the middle of a piece of CDATA make sure it's finished
1501 if ((reader
->node
!= NULL
) &&
1502 (reader
->node
->next
== NULL
) &&
1503 ((reader
->node
->type
== XML_TEXT_NODE
) ||
1504 (reader
->node
->type
== XML_CDATA_SECTION_NODE
))) {
1505 if (xmlTextReaderExpand(reader
) == NULL
)
1509 #ifdef LIBXML_XINCLUDE_ENABLED
1511 * Handle XInclude if asked for
1513 if ((reader
->xinclude
) && (reader
->node
!= NULL
) &&
1514 (reader
->node
->type
== XML_ELEMENT_NODE
) &&
1515 (reader
->node
->ns
!= NULL
) &&
1516 ((xmlStrEqual(reader
->node
->ns
->href
, XINCLUDE_NS
)) ||
1517 (xmlStrEqual(reader
->node
->ns
->href
, XINCLUDE_OLD_NS
)))) {
1518 if (reader
->xincctxt
== NULL
) {
1519 reader
->xincctxt
= xmlXIncludeNewContext(reader
->ctxt
->myDoc
);
1520 xmlXIncludeSetFlags(reader
->xincctxt
,
1521 reader
->parserFlags
& (~XML_PARSE_NOXINCNODE
));
1524 * expand that node and process it
1526 if (xmlTextReaderExpand(reader
) == NULL
)
1528 xmlXIncludeProcessNode(reader
->xincctxt
, reader
->node
);
1530 if ((reader
->node
!= NULL
) && (reader
->node
->type
== XML_XINCLUDE_START
)) {
1531 reader
->in_xinclude
++;
1534 if ((reader
->node
!= NULL
) && (reader
->node
->type
== XML_XINCLUDE_END
)) {
1535 reader
->in_xinclude
--;
1540 * Handle entities enter and exit when in entity replacement mode
1542 if ((reader
->node
!= NULL
) &&
1543 (reader
->node
->type
== XML_ENTITY_REF_NODE
) &&
1544 (reader
->ctxt
!= NULL
) && (reader
->ctxt
->replaceEntities
== 1)) {
1546 * Case where the underlying tree is not availble, lookup the entity
1549 if ((reader
->node
->children
== NULL
) && (reader
->ctxt
->sax
!= NULL
) &&
1550 (reader
->ctxt
->sax
->getEntity
!= NULL
)) {
1551 reader
->node
->children
= (xmlNodePtr
)
1552 reader
->ctxt
->sax
->getEntity(reader
->ctxt
, reader
->node
->name
);
1555 if ((reader
->node
->children
!= NULL
) &&
1556 (reader
->node
->children
->type
== XML_ENTITY_DECL
) &&
1557 (reader
->node
->children
->children
!= NULL
)) {
1558 xmlTextReaderEntPush(reader
, reader
->node
);
1559 reader
->node
= reader
->node
->children
->children
;
1561 #ifdef LIBXML_REGEXP_ENABLED
1562 } else if ((reader
->node
!= NULL
) &&
1563 (reader
->node
->type
== XML_ENTITY_REF_NODE
) &&
1564 (reader
->ctxt
!= NULL
) && (reader
->validate
)) {
1565 xmlTextReaderValidateEntity(reader
);
1566 #endif /* LIBXML_REGEXP_ENABLED */
1568 if ((reader
->node
!= NULL
) &&
1569 (reader
->node
->type
== XML_ENTITY_DECL
) &&
1570 (reader
->ent
!= NULL
) && (reader
->ent
->children
== reader
->node
)) {
1571 reader
->node
= xmlTextReaderEntPop(reader
);
1575 #ifdef LIBXML_REGEXP_ENABLED
1576 if ((reader
->validate
!= XML_TEXTREADER_NOT_VALIDATE
) && (reader
->node
!= NULL
)) {
1577 xmlNodePtr node
= reader
->node
;
1579 if ((node
->type
== XML_ELEMENT_NODE
) &&
1580 ((reader
->state
!= XML_TEXTREADER_END
) &&
1581 (reader
->state
!= XML_TEXTREADER_BACKTRACK
))) {
1582 xmlTextReaderValidatePush(reader
);
1583 } else if ((node
->type
== XML_TEXT_NODE
) ||
1584 (node
->type
== XML_CDATA_SECTION_NODE
)) {
1585 xmlTextReaderValidateCData(reader
, node
->content
,
1586 xmlStrlen(node
->content
));
1589 #endif /* LIBXML_REGEXP_ENABLED */
1590 #ifdef LIBXML_PATTERN_ENABLED
1591 if ((reader
->patternNr
> 0) && (reader
->state
!= XML_TEXTREADER_END
) &&
1592 (reader
->state
!= XML_TEXTREADER_BACKTRACK
)) {
1594 for (i
= 0;i
< reader
->patternNr
;i
++) {
1595 if (xmlPatternMatch(reader
->patternTab
[i
], reader
->node
) == 1) {
1596 xmlTextReaderPreserve(reader
);
1601 #endif /* LIBXML_PATTERN_ENABLED */
1602 #ifdef LIBXML_SCHEMAS_ENABLED
1603 if ((reader
->validate
== XML_TEXTREADER_VALIDATE_XSD
) &&
1604 (reader
->xsdValidErrors
== 0) &&
1605 (reader
->xsdValidCtxt
!= NULL
)) {
1606 reader
->xsdValidErrors
= !xmlSchemaIsValid(reader
->xsdValidCtxt
);
1608 #endif /* LIBXML_PATTERN_ENABLED */
1611 reader
->state
= XML_TEXTREADER_DONE
;
1616 * xmlTextReaderReadState:
1617 * @reader: the xmlTextReaderPtr used
1619 * Gets the read state of the reader.
1621 * Returns the state value, or -1 in case of error
1624 xmlTextReaderReadState(xmlTextReaderPtr reader
) {
1627 return(reader
->mode
);
1631 * xmlTextReaderExpand:
1632 * @reader: the xmlTextReaderPtr used
1634 * Reads the contents of the current node and the full subtree. It then makes
1635 * the subtree available until the next xmlTextReaderRead() call
1637 * Returns a node pointer valid until the next xmlTextReaderRead() call
1638 * or NULL in case of error.
1641 xmlTextReaderExpand(xmlTextReaderPtr reader
) {
1642 if ((reader
== NULL
) || (reader
->node
== NULL
))
1644 if (reader
->doc
!= NULL
)
1645 return(reader
->node
);
1646 if (reader
->ctxt
== NULL
)
1648 if (xmlTextReaderDoExpand(reader
) < 0)
1650 return(reader
->node
);
1654 * xmlTextReaderNext:
1655 * @reader: the xmlTextReaderPtr used
1657 * Skip to the node following the current one in document order while
1658 * avoiding the subtree if any.
1660 * Returns 1 if the node was read successfully, 0 if there is no more
1661 * nodes to read, or -1 in case of error
1664 xmlTextReaderNext(xmlTextReaderPtr reader
) {
1670 if (reader
->doc
!= NULL
)
1671 return(xmlTextReaderNextTree(reader
));
1673 if ((cur
== NULL
) || (cur
->type
!= XML_ELEMENT_NODE
))
1674 return(xmlTextReaderRead(reader
));
1675 if (reader
->state
== XML_TEXTREADER_END
|| reader
->state
== XML_TEXTREADER_BACKTRACK
)
1676 return(xmlTextReaderRead(reader
));
1677 if (cur
->extra
& NODE_IS_EMPTY
)
1678 return(xmlTextReaderRead(reader
));
1680 ret
= xmlTextReaderRead(reader
);
1683 } while (reader
->node
!= cur
);
1684 return(xmlTextReaderRead(reader
));
1687 #ifdef LIBXML_WRITER_ENABLED
1689 * xmlTextReaderReadInnerXml:
1690 * @reader: the xmlTextReaderPtr used
1692 * Reads the contents of the current node, including child nodes and markup.
1694 * Returns a string containing the XML content, or NULL if the current node
1695 * is neither an element nor attribute, or has no child nodes. The
1696 * string must be deallocated by the caller.
1699 xmlTextReaderReadInnerXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED
)
1702 xmlNodePtr node
, cur_node
;
1703 xmlBufferPtr buff
, buff2
;
1706 if (xmlTextReaderExpand(reader
) == NULL
) {
1710 buff
= xmlBufferCreate();
1711 for (cur_node
= reader
->node
->children
; cur_node
!= NULL
;
1712 cur_node
= cur_node
->next
) {
1713 node
= xmlDocCopyNode(cur_node
, doc
, 1);
1714 buff2
= xmlBufferCreate();
1715 if (xmlNodeDump(buff2
, doc
, node
, 0, 0) == -1) {
1717 xmlBufferFree(buff2
);
1718 xmlBufferFree(buff
);
1721 xmlBufferCat(buff
, buff2
->content
);
1723 xmlBufferFree(buff2
);
1725 resbuf
= buff
->content
;
1726 buff
->content
= NULL
;
1728 xmlBufferFree(buff
);
1733 #ifdef LIBXML_WRITER_ENABLED
1735 * xmlTextReaderReadOuterXml:
1736 * @reader: the xmlTextReaderPtr used
1738 * Reads the contents of the current node, including child nodes and markup.
1740 * Returns a string containing the node and any XML content, or NULL if the
1741 * current node cannot be serialized. The string must be deallocated
1745 xmlTextReaderReadOuterXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED
)
1752 node
= reader
->node
;
1754 if (xmlTextReaderExpand(reader
) == NULL
) {
1757 if (node
->type
== XML_DTD_NODE
) {
1758 node
= (xmlNodePtr
) xmlCopyDtd((xmlDtdPtr
) node
);
1760 node
= xmlDocCopyNode(node
, doc
, 1);
1762 buff
= xmlBufferCreate();
1763 if (xmlNodeDump(buff
, doc
, node
, 0, 0) == -1) {
1765 xmlBufferFree(buff
);
1769 resbuf
= buff
->content
;
1770 buff
->content
= NULL
;
1773 xmlBufferFree(buff
);
1779 * xmlTextReaderReadString:
1780 * @reader: the xmlTextReaderPtr used
1782 * Reads the contents of an element or a text node as a string.
1784 * Returns a string containing the contents of the Element or Text node,
1785 * or NULL if the reader is positioned on any other type of node.
1786 * The string must be deallocated by the caller.
1789 xmlTextReaderReadString(xmlTextReaderPtr reader
)
1793 if ((reader
== NULL
) || (reader
->node
== NULL
))
1796 node
= (reader
->curnode
!= NULL
) ? reader
->curnode
: reader
->node
;
1797 switch (node
->type
) {
1799 if (node
->content
!= NULL
)
1800 return(xmlStrdup(node
->content
));
1802 case XML_ELEMENT_NODE
:
1803 if (xmlTextReaderDoExpand(reader
) != -1) {
1804 return xmlTextReaderCollectSiblings(node
->children
);
1807 case XML_ATTRIBUTE_NODE
:
1818 * xmlTextReaderReadBase64:
1819 * @reader: the xmlTextReaderPtr used
1820 * @array: a byte array to store the content.
1821 * @offset: the zero-based index into array where the method should
1823 * @len: the number of bytes to write.
1825 * Reads and decodes the Base64 encoded contents of an element and
1826 * stores the result in a byte buffer.
1828 * Returns the number of bytes written to array, or zero if the current
1829 * instance is not positioned on an element or -1 in case of error.
1832 xmlTextReaderReadBase64(xmlTextReaderPtr reader
,
1833 unsigned char *array ATTRIBUTE_UNUSED
,
1834 int offset ATTRIBUTE_UNUSED
,
1835 int len ATTRIBUTE_UNUSED
) {
1836 if ((reader
== NULL
) || (reader
->ctxt
== NULL
))
1838 if (reader
->ctxt
->wellFormed
!= 1)
1841 if ((reader
->node
== NULL
) || (reader
->node
->type
== XML_ELEMENT_NODE
))
1848 * xmlTextReaderReadBinHex:
1849 * @reader: the xmlTextReaderPtr used
1850 * @array: a byte array to store the content.
1851 * @offset: the zero-based index into array where the method should
1853 * @len: the number of bytes to write.
1855 * Reads and decodes the BinHex encoded contents of an element and
1856 * stores the result in a byte buffer.
1858 * Returns the number of bytes written to array, or zero if the current
1859 * instance is not positioned on an element or -1 in case of error.
1862 xmlTextReaderReadBinHex(xmlTextReaderPtr reader
,
1863 unsigned char *array ATTRIBUTE_UNUSED
,
1864 int offset ATTRIBUTE_UNUSED
,
1865 int len ATTRIBUTE_UNUSED
) {
1866 if ((reader
== NULL
) || (reader
->ctxt
== NULL
))
1868 if (reader
->ctxt
->wellFormed
!= 1)
1871 if ((reader
->node
== NULL
) || (reader
->node
->type
== XML_ELEMENT_NODE
))
1878 /************************************************************************
1880 * Operating on a preparsed tree *
1882 ************************************************************************/
1884 xmlTextReaderNextTree(xmlTextReaderPtr reader
)
1889 if (reader
->state
== XML_TEXTREADER_END
)
1892 if (reader
->node
== NULL
) {
1893 if (reader
->doc
->children
== NULL
) {
1894 reader
->state
= XML_TEXTREADER_END
;
1898 reader
->node
= reader
->doc
->children
;
1899 reader
->state
= XML_TEXTREADER_START
;
1903 if (reader
->state
!= XML_TEXTREADER_BACKTRACK
) {
1904 /* Here removed traversal to child, because we want to skip the subtree,
1905 replace with traversal to sibling to skip subtree */
1906 if (reader
->node
->next
!= 0) {
1907 /* Move to sibling if present,skipping sub-tree */
1908 reader
->node
= reader
->node
->next
;
1909 reader
->state
= XML_TEXTREADER_START
;
1913 /* if reader->node->next is NULL mean no subtree for current node,
1914 so need to move to sibling of parent node if present */
1915 if ((reader
->node
->type
== XML_ELEMENT_NODE
) ||
1916 (reader
->node
->type
== XML_ATTRIBUTE_NODE
)) {
1917 reader
->state
= XML_TEXTREADER_BACKTRACK
;
1918 /* This will move to parent if present */
1919 xmlTextReaderRead(reader
);
1923 if (reader
->node
->next
!= 0) {
1924 reader
->node
= reader
->node
->next
;
1925 reader
->state
= XML_TEXTREADER_START
;
1929 if (reader
->node
->parent
!= 0) {
1930 if (reader
->node
->parent
->type
== XML_DOCUMENT_NODE
) {
1931 reader
->state
= XML_TEXTREADER_END
;
1935 reader
->node
= reader
->node
->parent
;
1937 reader
->state
= XML_TEXTREADER_BACKTRACK
;
1938 /* Repeat process to move to sibling of parent node if present */
1939 xmlTextReaderNextTree(reader
);
1942 reader
->state
= XML_TEXTREADER_END
;
1948 * xmlTextReaderReadTree:
1949 * @reader: the xmlTextReaderPtr used
1951 * Moves the position of the current instance to the next node in
1952 * the stream, exposing its properties.
1954 * Returns 1 if the node was read successfully, 0 if there is no more
1955 * nodes to read, or -1 in case of error
1958 xmlTextReaderReadTree(xmlTextReaderPtr reader
) {
1959 if (reader
->state
== XML_TEXTREADER_END
)
1963 if (reader
->node
== NULL
) {
1964 if (reader
->doc
->children
== NULL
) {
1965 reader
->state
= XML_TEXTREADER_END
;
1969 reader
->node
= reader
->doc
->children
;
1970 reader
->state
= XML_TEXTREADER_START
;
1974 if ((reader
->state
!= XML_TEXTREADER_BACKTRACK
) &&
1975 (reader
->node
->type
!= XML_DTD_NODE
) &&
1976 (reader
->node
->type
!= XML_XINCLUDE_START
) &&
1977 (reader
->node
->type
!= XML_ENTITY_REF_NODE
)) {
1978 if (reader
->node
->children
!= NULL
) {
1979 reader
->node
= reader
->node
->children
;
1981 reader
->state
= XML_TEXTREADER_START
;
1985 if (reader
->node
->type
== XML_ATTRIBUTE_NODE
) {
1986 reader
->state
= XML_TEXTREADER_BACKTRACK
;
1991 if (reader
->node
->next
!= NULL
) {
1992 reader
->node
= reader
->node
->next
;
1993 reader
->state
= XML_TEXTREADER_START
;
1997 if (reader
->node
->parent
!= NULL
) {
1998 if ((reader
->node
->parent
->type
== XML_DOCUMENT_NODE
) ||
1999 (reader
->node
->parent
->type
== XML_HTML_DOCUMENT_NODE
)) {
2000 reader
->state
= XML_TEXTREADER_END
;
2004 reader
->node
= reader
->node
->parent
;
2006 reader
->state
= XML_TEXTREADER_BACKTRACK
;
2010 reader
->state
= XML_TEXTREADER_END
;
2013 if ((reader
->node
->type
== XML_XINCLUDE_START
) ||
2014 (reader
->node
->type
== XML_XINCLUDE_END
))
2021 * xmlTextReaderNextSibling:
2022 * @reader: the xmlTextReaderPtr used
2024 * Skip to the node following the current one in document order while
2025 * avoiding the subtree if any.
2026 * Currently implemented only for Readers built on a document
2028 * Returns 1 if the node was read successfully, 0 if there is no more
2029 * nodes to read, or -1 in case of error
2032 xmlTextReaderNextSibling(xmlTextReaderPtr reader
) {
2035 if (reader
->doc
== NULL
) {
2040 if (reader
->state
== XML_TEXTREADER_END
)
2043 if (reader
->node
== NULL
)
2044 return(xmlTextReaderNextTree(reader
));
2046 if (reader
->node
->next
!= NULL
) {
2047 reader
->node
= reader
->node
->next
;
2048 reader
->state
= XML_TEXTREADER_START
;
2055 /************************************************************************
2057 * Constructor and destructors *
2059 ************************************************************************/
2062 * @input: the xmlParserInputBufferPtr used to read data
2063 * @URI: the URI information for the source if available
2065 * Create an xmlTextReader structure fed with @input
2067 * Returns the new xmlTextReaderPtr or NULL in case of error
2070 xmlNewTextReader(xmlParserInputBufferPtr input
, const char *URI
) {
2071 xmlTextReaderPtr ret
;
2075 ret
= xmlMalloc(sizeof(xmlTextReader
));
2077 xmlGenericError(xmlGenericErrorContext
,
2078 "xmlNewTextReader : malloc failed\n");
2081 memset(ret
, 0, sizeof(xmlTextReader
));
2087 ret
->buffer
= xmlBufCreateSize(100);
2088 if (ret
->buffer
== NULL
) {
2090 xmlGenericError(xmlGenericErrorContext
,
2091 "xmlNewTextReader : malloc failed\n");
2094 /* no operation on a reader should require a huge buffer */
2095 xmlBufSetAllocationScheme(ret
->buffer
,
2096 XML_BUFFER_ALLOC_BOUNDED
);
2097 ret
->sax
= (xmlSAXHandler
*) xmlMalloc(sizeof(xmlSAXHandler
));
2098 if (ret
->sax
== NULL
) {
2099 xmlBufFree(ret
->buffer
);
2101 xmlGenericError(xmlGenericErrorContext
,
2102 "xmlNewTextReader : malloc failed\n");
2105 xmlSAXVersion(ret
->sax
, 2);
2106 ret
->startElement
= ret
->sax
->startElement
;
2107 ret
->sax
->startElement
= xmlTextReaderStartElement
;
2108 ret
->endElement
= ret
->sax
->endElement
;
2109 ret
->sax
->endElement
= xmlTextReaderEndElement
;
2110 #ifdef LIBXML_SAX1_ENABLED
2111 if (ret
->sax
->initialized
== XML_SAX2_MAGIC
) {
2112 #endif /* LIBXML_SAX1_ENABLED */
2113 ret
->startElementNs
= ret
->sax
->startElementNs
;
2114 ret
->sax
->startElementNs
= xmlTextReaderStartElementNs
;
2115 ret
->endElementNs
= ret
->sax
->endElementNs
;
2116 ret
->sax
->endElementNs
= xmlTextReaderEndElementNs
;
2117 #ifdef LIBXML_SAX1_ENABLED
2119 ret
->startElementNs
= NULL
;
2120 ret
->endElementNs
= NULL
;
2122 #endif /* LIBXML_SAX1_ENABLED */
2123 ret
->characters
= ret
->sax
->characters
;
2124 ret
->sax
->characters
= xmlTextReaderCharacters
;
2125 ret
->sax
->ignorableWhitespace
= xmlTextReaderCharacters
;
2126 ret
->cdataBlock
= ret
->sax
->cdataBlock
;
2127 ret
->sax
->cdataBlock
= xmlTextReaderCDataBlock
;
2129 ret
->mode
= XML_TEXTREADER_MODE_INITIAL
;
2131 ret
->curnode
= NULL
;
2132 if (xmlBufUse(ret
->input
->buffer
) < 4) {
2133 xmlParserInputBufferRead(input
, 4);
2135 if (xmlBufUse(ret
->input
->buffer
) >= 4) {
2136 ret
->ctxt
= xmlCreatePushParserCtxt(ret
->sax
, NULL
,
2137 (const char *) xmlBufContent(ret
->input
->buffer
),
2142 ret
->ctxt
= xmlCreatePushParserCtxt(ret
->sax
, NULL
, NULL
, 0, URI
);
2147 if (ret
->ctxt
== NULL
) {
2148 xmlGenericError(xmlGenericErrorContext
,
2149 "xmlNewTextReader : malloc failed\n");
2150 xmlBufFree(ret
->buffer
);
2155 ret
->ctxt
->parseMode
= XML_PARSE_READER
;
2156 ret
->ctxt
->_private
= ret
;
2157 ret
->ctxt
->linenumbers
= 1;
2158 ret
->ctxt
->dictNames
= 1;
2159 ret
->allocs
= XML_TEXTREADER_CTXT
;
2161 * use the parser dictionary to allocate all elements and attributes names
2163 ret
->ctxt
->docdict
= 1;
2164 ret
->dict
= ret
->ctxt
->dict
;
2165 #ifdef LIBXML_XINCLUDE_ENABLED
2168 #ifdef LIBXML_PATTERN_ENABLED
2169 ret
->patternMax
= 0;
2170 ret
->patternTab
= NULL
;
2176 * xmlNewTextReaderFilename:
2177 * @URI: the URI of the resource to process
2179 * Create an xmlTextReader structure fed with the resource at @URI
2181 * Returns the new xmlTextReaderPtr or NULL in case of error
2184 xmlNewTextReaderFilename(const char *URI
) {
2185 xmlParserInputBufferPtr input
;
2186 xmlTextReaderPtr ret
;
2187 char *directory
= NULL
;
2189 input
= xmlParserInputBufferCreateFilename(URI
, XML_CHAR_ENCODING_NONE
);
2192 ret
= xmlNewTextReader(input
, URI
);
2194 xmlFreeParserInputBuffer(input
);
2197 ret
->allocs
|= XML_TEXTREADER_INPUT
;
2198 if (ret
->ctxt
->directory
== NULL
)
2199 directory
= xmlParserGetDirectory(URI
);
2200 if ((ret
->ctxt
->directory
== NULL
) && (directory
!= NULL
))
2201 ret
->ctxt
->directory
= (char *) xmlStrdup((xmlChar
*) directory
);
2202 if (directory
!= NULL
)
2208 * xmlFreeTextReader:
2209 * @reader: the xmlTextReaderPtr
2211 * Deallocate all the resources associated to the reader
2214 xmlFreeTextReader(xmlTextReaderPtr reader
) {
2217 #ifdef LIBXML_SCHEMAS_ENABLED
2218 if (reader
->rngSchemas
!= NULL
) {
2219 xmlRelaxNGFree(reader
->rngSchemas
);
2220 reader
->rngSchemas
= NULL
;
2222 if (reader
->rngValidCtxt
!= NULL
) {
2223 if (! reader
->rngPreserveCtxt
)
2224 xmlRelaxNGFreeValidCtxt(reader
->rngValidCtxt
);
2225 reader
->rngValidCtxt
= NULL
;
2227 if (reader
->xsdPlug
!= NULL
) {
2228 xmlSchemaSAXUnplug(reader
->xsdPlug
);
2229 reader
->xsdPlug
= NULL
;
2231 if (reader
->xsdValidCtxt
!= NULL
) {
2232 if (! reader
->xsdPreserveCtxt
)
2233 xmlSchemaFreeValidCtxt(reader
->xsdValidCtxt
);
2234 reader
->xsdValidCtxt
= NULL
;
2236 if (reader
->xsdSchemas
!= NULL
) {
2237 xmlSchemaFree(reader
->xsdSchemas
);
2238 reader
->xsdSchemas
= NULL
;
2241 #ifdef LIBXML_XINCLUDE_ENABLED
2242 if (reader
->xincctxt
!= NULL
)
2243 xmlXIncludeFreeContext(reader
->xincctxt
);
2245 #ifdef LIBXML_PATTERN_ENABLED
2246 if (reader
->patternTab
!= NULL
) {
2248 for (i
= 0;i
< reader
->patternNr
;i
++) {
2249 if (reader
->patternTab
[i
] != NULL
)
2250 xmlFreePattern(reader
->patternTab
[i
]);
2252 xmlFree(reader
->patternTab
);
2255 if (reader
->faketext
!= NULL
) {
2256 xmlFreeNode(reader
->faketext
);
2258 if (reader
->ctxt
!= NULL
) {
2259 if (reader
->dict
== reader
->ctxt
->dict
)
2260 reader
->dict
= NULL
;
2261 if (reader
->ctxt
->myDoc
!= NULL
) {
2262 if (reader
->preserve
== 0)
2263 xmlTextReaderFreeDoc(reader
, reader
->ctxt
->myDoc
);
2264 reader
->ctxt
->myDoc
= NULL
;
2266 if ((reader
->ctxt
->vctxt
.vstateTab
!= NULL
) &&
2267 (reader
->ctxt
->vctxt
.vstateMax
> 0)){
2268 xmlFree(reader
->ctxt
->vctxt
.vstateTab
);
2269 reader
->ctxt
->vctxt
.vstateTab
= NULL
;
2270 reader
->ctxt
->vctxt
.vstateMax
= 0;
2272 if (reader
->allocs
& XML_TEXTREADER_CTXT
)
2273 xmlFreeParserCtxt(reader
->ctxt
);
2275 if (reader
->sax
!= NULL
)
2276 xmlFree(reader
->sax
);
2277 if ((reader
->input
!= NULL
) && (reader
->allocs
& XML_TEXTREADER_INPUT
))
2278 xmlFreeParserInputBuffer(reader
->input
);
2279 if (reader
->buffer
!= NULL
)
2280 xmlBufFree(reader
->buffer
);
2281 if (reader
->entTab
!= NULL
)
2282 xmlFree(reader
->entTab
);
2283 if (reader
->dict
!= NULL
)
2284 xmlDictFree(reader
->dict
);
2288 /************************************************************************
2290 * Methods for XmlTextReader *
2292 ************************************************************************/
2294 * xmlTextReaderClose:
2295 * @reader: the xmlTextReaderPtr used
2297 * This method releases any resources allocated by the current instance
2298 * changes the state to Closed and close any underlying input.
2300 * Returns 0 or -1 in case of error
2303 xmlTextReaderClose(xmlTextReaderPtr reader
) {
2306 reader
->node
= NULL
;
2307 reader
->curnode
= NULL
;
2308 reader
->mode
= XML_TEXTREADER_MODE_CLOSED
;
2309 if (reader
->ctxt
!= NULL
) {
2310 xmlStopParser(reader
->ctxt
);
2311 if (reader
->ctxt
->myDoc
!= NULL
) {
2312 if (reader
->preserve
== 0)
2313 xmlTextReaderFreeDoc(reader
, reader
->ctxt
->myDoc
);
2314 reader
->ctxt
->myDoc
= NULL
;
2317 if ((reader
->input
!= NULL
) && (reader
->allocs
& XML_TEXTREADER_INPUT
)) {
2318 xmlFreeParserInputBuffer(reader
->input
);
2319 reader
->allocs
-= XML_TEXTREADER_INPUT
;
2325 * xmlTextReaderGetAttributeNo:
2326 * @reader: the xmlTextReaderPtr used
2327 * @no: the zero-based index of the attribute relative to the containing element
2329 * Provides the value of the attribute with the specified index relative
2330 * to the containing element.
2332 * Returns a string containing the value of the specified attribute, or NULL
2333 * in case of error. The string must be deallocated by the caller.
2336 xmlTextReaderGetAttributeNo(xmlTextReaderPtr reader
, int no
) {
2344 if (reader
->node
== NULL
)
2346 if (reader
->curnode
!= NULL
)
2348 /* TODO: handle the xmlDecl */
2349 if (reader
->node
->type
!= XML_ELEMENT_NODE
)
2352 ns
= reader
->node
->nsDef
;
2353 for (i
= 0;(i
< no
) && (ns
!= NULL
);i
++) {
2357 return(xmlStrdup(ns
->href
));
2359 cur
= reader
->node
->properties
;
2367 /* TODO walk the DTD if present */
2369 ret
= xmlNodeListGetString(reader
->node
->doc
, cur
->children
, 1);
2370 if (ret
== NULL
) return(xmlStrdup((xmlChar
*)""));
2375 * xmlTextReaderGetAttribute:
2376 * @reader: the xmlTextReaderPtr used
2377 * @name: the qualified name of the attribute.
2379 * Provides the value of the attribute with the specified qualified name.
2381 * Returns a string containing the value of the specified attribute, or NULL
2382 * in case of error. The string must be deallocated by the caller.
2385 xmlTextReaderGetAttribute(xmlTextReaderPtr reader
, const xmlChar
*name
) {
2386 xmlChar
*prefix
= NULL
;
2389 xmlChar
*ret
= NULL
;
2391 if ((reader
== NULL
) || (name
== NULL
))
2393 if (reader
->node
== NULL
)
2395 if (reader
->curnode
!= NULL
)
2398 /* TODO: handle the xmlDecl */
2399 if (reader
->node
->type
!= XML_ELEMENT_NODE
)
2402 localname
= xmlSplitQName2(name
, &prefix
);
2403 if (localname
== NULL
) {
2405 * Namespace default decl
2407 if (xmlStrEqual(name
, BAD_CAST
"xmlns")) {
2408 ns
= reader
->node
->nsDef
;
2409 while (ns
!= NULL
) {
2410 if (ns
->prefix
== NULL
) {
2411 return(xmlStrdup(ns
->href
));
2417 return(xmlGetNoNsProp(reader
->node
, name
));
2421 * Namespace default decl
2423 if (xmlStrEqual(prefix
, BAD_CAST
"xmlns")) {
2424 ns
= reader
->node
->nsDef
;
2425 while (ns
!= NULL
) {
2426 if ((ns
->prefix
!= NULL
) && (xmlStrEqual(ns
->prefix
, localname
))) {
2427 ret
= xmlStrdup(ns
->href
);
2433 ns
= xmlSearchNs(reader
->node
->doc
, reader
->node
, prefix
);
2435 ret
= xmlGetNsProp(reader
->node
, localname
, ns
->href
);
2446 * xmlTextReaderGetAttributeNs:
2447 * @reader: the xmlTextReaderPtr used
2448 * @localName: the local name of the attribute.
2449 * @namespaceURI: the namespace URI of the attribute.
2451 * Provides the value of the specified attribute
2453 * Returns a string containing the value of the specified attribute, or NULL
2454 * in case of error. The string must be deallocated by the caller.
2457 xmlTextReaderGetAttributeNs(xmlTextReaderPtr reader
, const xmlChar
*localName
,
2458 const xmlChar
*namespaceURI
) {
2459 xmlChar
*prefix
= NULL
;
2462 if ((reader
== NULL
) || (localName
== NULL
))
2464 if (reader
->node
== NULL
)
2466 if (reader
->curnode
!= NULL
)
2469 /* TODO: handle the xmlDecl */
2470 if (reader
->node
->type
!= XML_ELEMENT_NODE
)
2473 if (xmlStrEqual(namespaceURI
, BAD_CAST
"http://www.w3.org/2000/xmlns/")) {
2474 if (! xmlStrEqual(localName
, BAD_CAST
"xmlns")) {
2475 prefix
= BAD_CAST localName
;
2477 ns
= reader
->node
->nsDef
;
2478 while (ns
!= NULL
) {
2479 if ((prefix
== NULL
&& ns
->prefix
== NULL
) ||
2480 ((ns
->prefix
!= NULL
) && (xmlStrEqual(ns
->prefix
, localName
)))) {
2481 return xmlStrdup(ns
->href
);
2488 return(xmlGetNsProp(reader
->node
, localName
, namespaceURI
));
2492 * xmlTextReaderGetRemainder:
2493 * @reader: the xmlTextReaderPtr used
2495 * Method to get the remainder of the buffered XML. this method stops the
2496 * parser, set its state to End Of File and return the input stream with
2497 * what is left that the parser did not use.
2499 * The implementation is not good, the parser certainly procgressed past
2500 * what's left in reader->input, and there is an allocation problem. Best
2501 * would be to rewrite it differently.
2503 * Returns the xmlParserInputBufferPtr attached to the XML or NULL
2506 xmlParserInputBufferPtr
2507 xmlTextReaderGetRemainder(xmlTextReaderPtr reader
) {
2508 xmlParserInputBufferPtr ret
= NULL
;
2512 if (reader
->node
== NULL
)
2515 reader
->node
= NULL
;
2516 reader
->curnode
= NULL
;
2517 reader
->mode
= XML_TEXTREADER_MODE_EOF
;
2518 if (reader
->ctxt
!= NULL
) {
2519 xmlStopParser(reader
->ctxt
);
2520 if (reader
->ctxt
->myDoc
!= NULL
) {
2521 if (reader
->preserve
== 0)
2522 xmlTextReaderFreeDoc(reader
, reader
->ctxt
->myDoc
);
2523 reader
->ctxt
->myDoc
= NULL
;
2526 if (reader
->allocs
& XML_TEXTREADER_INPUT
) {
2527 ret
= reader
->input
;
2528 reader
->input
= NULL
;
2529 reader
->allocs
-= XML_TEXTREADER_INPUT
;
2532 * Hum, one may need to duplicate the data structure because
2533 * without reference counting the input may be freed twice:
2534 * - by the layer which allocated it.
2535 * - by the layer to which would have been returned to.
2544 * xmlTextReaderLookupNamespace:
2545 * @reader: the xmlTextReaderPtr used
2546 * @prefix: the prefix whose namespace URI is to be resolved. To return
2547 * the default namespace, specify NULL
2549 * Resolves a namespace prefix in the scope of the current element.
2551 * Returns a string containing the namespace URI to which the prefix maps
2552 * or NULL in case of error. The string must be deallocated by the caller.
2555 xmlTextReaderLookupNamespace(xmlTextReaderPtr reader
, const xmlChar
*prefix
) {
2560 if (reader
->node
== NULL
)
2563 ns
= xmlSearchNs(reader
->node
->doc
, reader
->node
, prefix
);
2566 return(xmlStrdup(ns
->href
));
2570 * xmlTextReaderMoveToAttributeNo:
2571 * @reader: the xmlTextReaderPtr used
2572 * @no: the zero-based index of the attribute relative to the containing
2575 * Moves the position of the current instance to the attribute with
2576 * the specified index relative to the containing element.
2578 * Returns 1 in case of success, -1 in case of error, 0 if not found
2581 xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader
, int no
) {
2588 if (reader
->node
== NULL
)
2590 /* TODO: handle the xmlDecl */
2591 if (reader
->node
->type
!= XML_ELEMENT_NODE
)
2594 reader
->curnode
= NULL
;
2596 ns
= reader
->node
->nsDef
;
2597 for (i
= 0;(i
< no
) && (ns
!= NULL
);i
++) {
2601 reader
->curnode
= (xmlNodePtr
) ns
;
2605 cur
= reader
->node
->properties
;
2613 /* TODO walk the DTD if present */
2615 reader
->curnode
= (xmlNodePtr
) cur
;
2620 * xmlTextReaderMoveToAttribute:
2621 * @reader: the xmlTextReaderPtr used
2622 * @name: the qualified name of the attribute.
2624 * Moves the position of the current instance to the attribute with
2625 * the specified qualified name.
2627 * Returns 1 in case of success, -1 in case of error, 0 if not found
2630 xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader
, const xmlChar
*name
) {
2631 xmlChar
*prefix
= NULL
;
2636 if ((reader
== NULL
) || (name
== NULL
))
2638 if (reader
->node
== NULL
)
2641 /* TODO: handle the xmlDecl */
2642 if (reader
->node
->type
!= XML_ELEMENT_NODE
)
2645 localname
= xmlSplitQName2(name
, &prefix
);
2646 if (localname
== NULL
) {
2648 * Namespace default decl
2650 if (xmlStrEqual(name
, BAD_CAST
"xmlns")) {
2651 ns
= reader
->node
->nsDef
;
2652 while (ns
!= NULL
) {
2653 if (ns
->prefix
== NULL
) {
2654 reader
->curnode
= (xmlNodePtr
) ns
;
2662 prop
= reader
->node
->properties
;
2663 while (prop
!= NULL
) {
2666 * - same attribute names
2667 * - and the attribute carrying that namespace
2669 if ((xmlStrEqual(prop
->name
, name
)) &&
2670 ((prop
->ns
== NULL
) || (prop
->ns
->prefix
== NULL
))) {
2671 reader
->curnode
= (xmlNodePtr
) prop
;
2680 * Namespace default decl
2682 if (xmlStrEqual(prefix
, BAD_CAST
"xmlns")) {
2683 ns
= reader
->node
->nsDef
;
2684 while (ns
!= NULL
) {
2685 if ((ns
->prefix
!= NULL
) && (xmlStrEqual(ns
->prefix
, localname
))) {
2686 reader
->curnode
= (xmlNodePtr
) ns
;
2693 prop
= reader
->node
->properties
;
2694 while (prop
!= NULL
) {
2697 * - same attribute names
2698 * - and the attribute carrying that namespace
2700 if ((xmlStrEqual(prop
->name
, localname
)) &&
2701 (prop
->ns
!= NULL
) && (xmlStrEqual(prop
->ns
->prefix
, prefix
))) {
2702 reader
->curnode
= (xmlNodePtr
) prop
;
2708 if (localname
!= NULL
)
2715 if (localname
!= NULL
)
2723 * xmlTextReaderMoveToAttributeNs:
2724 * @reader: the xmlTextReaderPtr used
2725 * @localName: the local name of the attribute.
2726 * @namespaceURI: the namespace URI of the attribute.
2728 * Moves the position of the current instance to the attribute with the
2729 * specified local name and namespace URI.
2731 * Returns 1 in case of success, -1 in case of error, 0 if not found
2734 xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader
,
2735 const xmlChar
*localName
, const xmlChar
*namespaceURI
) {
2739 xmlChar
*prefix
= NULL
;
2741 if ((reader
== NULL
) || (localName
== NULL
) || (namespaceURI
== NULL
))
2743 if (reader
->node
== NULL
)
2745 if (reader
->node
->type
!= XML_ELEMENT_NODE
)
2747 node
= reader
->node
;
2749 if (xmlStrEqual(namespaceURI
, BAD_CAST
"http://www.w3.org/2000/xmlns/")) {
2750 if (! xmlStrEqual(localName
, BAD_CAST
"xmlns")) {
2751 prefix
= BAD_CAST localName
;
2753 ns
= reader
->node
->nsDef
;
2754 while (ns
!= NULL
) {
2755 if ((prefix
== NULL
&& ns
->prefix
== NULL
) ||
2756 ((ns
->prefix
!= NULL
) && (xmlStrEqual(ns
->prefix
, localName
)))) {
2757 reader
->curnode
= (xmlNodePtr
) ns
;
2765 prop
= node
->properties
;
2766 while (prop
!= NULL
) {
2769 * - same attribute names
2770 * - and the attribute carrying that namespace
2772 if (xmlStrEqual(prop
->name
, localName
) &&
2773 ((prop
->ns
!= NULL
) &&
2774 (xmlStrEqual(prop
->ns
->href
, namespaceURI
)))) {
2775 reader
->curnode
= (xmlNodePtr
) prop
;
2784 * xmlTextReaderMoveToFirstAttribute:
2785 * @reader: the xmlTextReaderPtr used
2787 * Moves the position of the current instance to the first attribute
2788 * associated with the current node.
2790 * Returns 1 in case of success, -1 in case of error, 0 if not found
2793 xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader
) {
2796 if (reader
->node
== NULL
)
2798 if (reader
->node
->type
!= XML_ELEMENT_NODE
)
2801 if (reader
->node
->nsDef
!= NULL
) {
2802 reader
->curnode
= (xmlNodePtr
) reader
->node
->nsDef
;
2805 if (reader
->node
->properties
!= NULL
) {
2806 reader
->curnode
= (xmlNodePtr
) reader
->node
->properties
;
2813 * xmlTextReaderMoveToNextAttribute:
2814 * @reader: the xmlTextReaderPtr used
2816 * Moves the position of the current instance to the next attribute
2817 * associated with the current node.
2819 * Returns 1 in case of success, -1 in case of error, 0 if not found
2822 xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader
) {
2825 if (reader
->node
== NULL
)
2827 if (reader
->node
->type
!= XML_ELEMENT_NODE
)
2829 if (reader
->curnode
== NULL
)
2830 return(xmlTextReaderMoveToFirstAttribute(reader
));
2832 if (reader
->curnode
->type
== XML_NAMESPACE_DECL
) {
2833 xmlNsPtr ns
= (xmlNsPtr
) reader
->curnode
;
2834 if (ns
->next
!= NULL
) {
2835 reader
->curnode
= (xmlNodePtr
) ns
->next
;
2838 if (reader
->node
->properties
!= NULL
) {
2839 reader
->curnode
= (xmlNodePtr
) reader
->node
->properties
;
2843 } else if ((reader
->curnode
->type
== XML_ATTRIBUTE_NODE
) &&
2844 (reader
->curnode
->next
!= NULL
)) {
2845 reader
->curnode
= reader
->curnode
->next
;
2852 * xmlTextReaderMoveToElement:
2853 * @reader: the xmlTextReaderPtr used
2855 * Moves the position of the current instance to the node that
2856 * contains the current Attribute node.
2858 * Returns 1 in case of success, -1 in case of error, 0 if not moved
2861 xmlTextReaderMoveToElement(xmlTextReaderPtr reader
) {
2864 if (reader
->node
== NULL
)
2866 if (reader
->node
->type
!= XML_ELEMENT_NODE
)
2868 if (reader
->curnode
!= NULL
) {
2869 reader
->curnode
= NULL
;
2876 * xmlTextReaderReadAttributeValue:
2877 * @reader: the xmlTextReaderPtr used
2879 * Parses an attribute value into one or more Text and EntityReference nodes.
2881 * Returns 1 in case of success, 0 if the reader was not positionned on an
2882 * ttribute node or all the attribute values have been read, or -1
2886 xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader
) {
2889 if (reader
->node
== NULL
)
2891 if (reader
->curnode
== NULL
)
2893 if (reader
->curnode
->type
== XML_ATTRIBUTE_NODE
) {
2894 if (reader
->curnode
->children
== NULL
)
2896 reader
->curnode
= reader
->curnode
->children
;
2897 } else if (reader
->curnode
->type
== XML_NAMESPACE_DECL
) {
2898 xmlNsPtr ns
= (xmlNsPtr
) reader
->curnode
;
2900 if (reader
->faketext
== NULL
) {
2901 reader
->faketext
= xmlNewDocText(reader
->node
->doc
,
2904 if ((reader
->faketext
->content
!= NULL
) &&
2905 (reader
->faketext
->content
!=
2906 (xmlChar
*) &(reader
->faketext
->properties
)))
2907 xmlFree(reader
->faketext
->content
);
2908 reader
->faketext
->content
= xmlStrdup(ns
->href
);
2910 reader
->curnode
= reader
->faketext
;
2912 if (reader
->curnode
->next
== NULL
)
2914 reader
->curnode
= reader
->curnode
->next
;
2920 * xmlTextReaderConstEncoding:
2921 * @reader: the xmlTextReaderPtr used
2923 * Determine the encoding of the document being read.
2925 * Returns a string containing the encoding of the document or NULL in
2926 * case of error. The string is deallocated with the reader.
2929 xmlTextReaderConstEncoding(xmlTextReaderPtr reader
) {
2930 xmlDocPtr doc
= NULL
;
2933 if (reader
->doc
!= NULL
)
2935 else if (reader
->ctxt
!= NULL
)
2936 doc
= reader
->ctxt
->myDoc
;
2940 if (doc
->encoding
== NULL
)
2943 return(CONSTSTR(doc
->encoding
));
2947 /************************************************************************
2949 * Acces API to the current node *
2951 ************************************************************************/
2953 * xmlTextReaderAttributeCount:
2954 * @reader: the xmlTextReaderPtr used
2956 * Provides the number of attributes of the current node
2958 * Returns 0 i no attributes, -1 in case of error or the attribute count
2961 xmlTextReaderAttributeCount(xmlTextReaderPtr reader
) {
2969 if (reader
->node
== NULL
)
2972 if (reader
->curnode
!= NULL
)
2973 node
= reader
->curnode
;
2975 node
= reader
->node
;
2977 if (node
->type
!= XML_ELEMENT_NODE
)
2979 if ((reader
->state
== XML_TEXTREADER_END
) ||
2980 (reader
->state
== XML_TEXTREADER_BACKTRACK
))
2983 attr
= node
->properties
;
2984 while (attr
!= NULL
) {
2989 while (ns
!= NULL
) {
2997 * xmlTextReaderNodeType:
2998 * @reader: the xmlTextReaderPtr used
3000 * Get the node type of the current node
3002 * http://www.gnu.org/software/dotgnu/pnetlib-doc/System/Xml/XmlNodeType.html
3004 * Returns the xmlNodeType of the current node or -1 in case of error
3007 xmlTextReaderNodeType(xmlTextReaderPtr reader
) {
3012 if (reader
->node
== NULL
)
3013 return(XML_READER_TYPE_NONE
);
3014 if (reader
->curnode
!= NULL
)
3015 node
= reader
->curnode
;
3017 node
= reader
->node
;
3018 switch (node
->type
) {
3019 case XML_ELEMENT_NODE
:
3020 if ((reader
->state
== XML_TEXTREADER_END
) ||
3021 (reader
->state
== XML_TEXTREADER_BACKTRACK
))
3022 return(XML_READER_TYPE_END_ELEMENT
);
3023 return(XML_READER_TYPE_ELEMENT
);
3024 case XML_NAMESPACE_DECL
:
3025 case XML_ATTRIBUTE_NODE
:
3026 return(XML_READER_TYPE_ATTRIBUTE
);
3028 if (xmlIsBlankNode(reader
->node
)) {
3029 if (xmlNodeGetSpacePreserve(reader
->node
))
3030 return(XML_READER_TYPE_SIGNIFICANT_WHITESPACE
);
3032 return(XML_READER_TYPE_WHITESPACE
);
3034 return(XML_READER_TYPE_TEXT
);
3036 case XML_CDATA_SECTION_NODE
:
3037 return(XML_READER_TYPE_CDATA
);
3038 case XML_ENTITY_REF_NODE
:
3039 return(XML_READER_TYPE_ENTITY_REFERENCE
);
3040 case XML_ENTITY_NODE
:
3041 return(XML_READER_TYPE_ENTITY
);
3043 return(XML_READER_TYPE_PROCESSING_INSTRUCTION
);
3044 case XML_COMMENT_NODE
:
3045 return(XML_READER_TYPE_COMMENT
);
3046 case XML_DOCUMENT_NODE
:
3047 case XML_HTML_DOCUMENT_NODE
:
3048 #ifdef LIBXML_DOCB_ENABLED
3049 case XML_DOCB_DOCUMENT_NODE
:
3051 return(XML_READER_TYPE_DOCUMENT
);
3052 case XML_DOCUMENT_FRAG_NODE
:
3053 return(XML_READER_TYPE_DOCUMENT_FRAGMENT
);
3054 case XML_NOTATION_NODE
:
3055 return(XML_READER_TYPE_NOTATION
);
3056 case XML_DOCUMENT_TYPE_NODE
:
3058 return(XML_READER_TYPE_DOCUMENT_TYPE
);
3060 case XML_ELEMENT_DECL
:
3061 case XML_ATTRIBUTE_DECL
:
3062 case XML_ENTITY_DECL
:
3063 case XML_XINCLUDE_START
:
3064 case XML_XINCLUDE_END
:
3065 return(XML_READER_TYPE_NONE
);
3071 * xmlTextReaderIsEmptyElement:
3072 * @reader: the xmlTextReaderPtr used
3074 * Check if the current node is empty
3076 * Returns 1 if empty, 0 if not and -1 in case of error
3079 xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader
) {
3080 if ((reader
== NULL
) || (reader
->node
== NULL
))
3082 if (reader
->node
->type
!= XML_ELEMENT_NODE
)
3084 if (reader
->curnode
!= NULL
)
3086 if (reader
->node
->children
!= NULL
)
3088 if (reader
->state
== XML_TEXTREADER_END
)
3090 if (reader
->doc
!= NULL
)
3092 #ifdef LIBXML_XINCLUDE_ENABLED
3093 if (reader
->in_xinclude
> 0)
3096 return((reader
->node
->extra
& NODE_IS_EMPTY
) != 0);
3100 * xmlTextReaderLocalName:
3101 * @reader: the xmlTextReaderPtr used
3103 * The local name of the node.
3105 * Returns the local name or NULL if not available,
3106 * if non NULL it need to be freed by the caller.
3109 xmlTextReaderLocalName(xmlTextReaderPtr reader
) {
3111 if ((reader
== NULL
) || (reader
->node
== NULL
))
3113 if (reader
->curnode
!= NULL
)
3114 node
= reader
->curnode
;
3116 node
= reader
->node
;
3117 if (node
->type
== XML_NAMESPACE_DECL
) {
3118 xmlNsPtr ns
= (xmlNsPtr
) node
;
3119 if (ns
->prefix
== NULL
)
3120 return(xmlStrdup(BAD_CAST
"xmlns"));
3122 return(xmlStrdup(ns
->prefix
));
3124 if ((node
->type
!= XML_ELEMENT_NODE
) &&
3125 (node
->type
!= XML_ATTRIBUTE_NODE
))
3126 return(xmlTextReaderName(reader
));
3127 return(xmlStrdup(node
->name
));
3131 * xmlTextReaderConstLocalName:
3132 * @reader: the xmlTextReaderPtr used
3134 * The local name of the node.
3136 * Returns the local name or NULL if not available, the
3137 * string will be deallocated with the reader.
3140 xmlTextReaderConstLocalName(xmlTextReaderPtr reader
) {
3142 if ((reader
== NULL
) || (reader
->node
== NULL
))
3144 if (reader
->curnode
!= NULL
)
3145 node
= reader
->curnode
;
3147 node
= reader
->node
;
3148 if (node
->type
== XML_NAMESPACE_DECL
) {
3149 xmlNsPtr ns
= (xmlNsPtr
) node
;
3150 if (ns
->prefix
== NULL
)
3151 return(CONSTSTR(BAD_CAST
"xmlns"));
3155 if ((node
->type
!= XML_ELEMENT_NODE
) &&
3156 (node
->type
!= XML_ATTRIBUTE_NODE
))
3157 return(xmlTextReaderConstName(reader
));
3162 * xmlTextReaderName:
3163 * @reader: the xmlTextReaderPtr used
3165 * The qualified name of the node, equal to Prefix :LocalName.
3167 * Returns the local name or NULL if not available,
3168 * if non NULL it need to be freed by the caller.
3171 xmlTextReaderName(xmlTextReaderPtr reader
) {
3175 if ((reader
== NULL
) || (reader
->node
== NULL
))
3177 if (reader
->curnode
!= NULL
)
3178 node
= reader
->curnode
;
3180 node
= reader
->node
;
3181 switch (node
->type
) {
3182 case XML_ELEMENT_NODE
:
3183 case XML_ATTRIBUTE_NODE
:
3184 if ((node
->ns
== NULL
) ||
3185 (node
->ns
->prefix
== NULL
))
3186 return(xmlStrdup(node
->name
));
3188 ret
= xmlStrdup(node
->ns
->prefix
);
3189 ret
= xmlStrcat(ret
, BAD_CAST
":");
3190 ret
= xmlStrcat(ret
, node
->name
);
3193 return(xmlStrdup(BAD_CAST
"#text"));
3194 case XML_CDATA_SECTION_NODE
:
3195 return(xmlStrdup(BAD_CAST
"#cdata-section"));
3196 case XML_ENTITY_NODE
:
3197 case XML_ENTITY_REF_NODE
:
3198 return(xmlStrdup(node
->name
));
3200 return(xmlStrdup(node
->name
));
3201 case XML_COMMENT_NODE
:
3202 return(xmlStrdup(BAD_CAST
"#comment"));
3203 case XML_DOCUMENT_NODE
:
3204 case XML_HTML_DOCUMENT_NODE
:
3205 #ifdef LIBXML_DOCB_ENABLED
3206 case XML_DOCB_DOCUMENT_NODE
:
3208 return(xmlStrdup(BAD_CAST
"#document"));
3209 case XML_DOCUMENT_FRAG_NODE
:
3210 return(xmlStrdup(BAD_CAST
"#document-fragment"));
3211 case XML_NOTATION_NODE
:
3212 return(xmlStrdup(node
->name
));
3213 case XML_DOCUMENT_TYPE_NODE
:
3215 return(xmlStrdup(node
->name
));
3216 case XML_NAMESPACE_DECL
: {
3217 xmlNsPtr ns
= (xmlNsPtr
) node
;
3219 ret
= xmlStrdup(BAD_CAST
"xmlns");
3220 if (ns
->prefix
== NULL
)
3222 ret
= xmlStrcat(ret
, BAD_CAST
":");
3223 ret
= xmlStrcat(ret
, ns
->prefix
);
3227 case XML_ELEMENT_DECL
:
3228 case XML_ATTRIBUTE_DECL
:
3229 case XML_ENTITY_DECL
:
3230 case XML_XINCLUDE_START
:
3231 case XML_XINCLUDE_END
:
3238 * xmlTextReaderConstName:
3239 * @reader: the xmlTextReaderPtr used
3241 * The qualified name of the node, equal to Prefix :LocalName.
3243 * Returns the local name or NULL if not available, the string is
3244 * deallocated with the reader.
3247 xmlTextReaderConstName(xmlTextReaderPtr reader
) {
3250 if ((reader
== NULL
) || (reader
->node
== NULL
))
3252 if (reader
->curnode
!= NULL
)
3253 node
= reader
->curnode
;
3255 node
= reader
->node
;
3256 switch (node
->type
) {
3257 case XML_ELEMENT_NODE
:
3258 case XML_ATTRIBUTE_NODE
:
3259 if ((node
->ns
== NULL
) ||
3260 (node
->ns
->prefix
== NULL
))
3262 return(CONSTQSTR(node
->ns
->prefix
, node
->name
));
3264 return(CONSTSTR(BAD_CAST
"#text"));
3265 case XML_CDATA_SECTION_NODE
:
3266 return(CONSTSTR(BAD_CAST
"#cdata-section"));
3267 case XML_ENTITY_NODE
:
3268 case XML_ENTITY_REF_NODE
:
3269 return(CONSTSTR(node
->name
));
3271 return(CONSTSTR(node
->name
));
3272 case XML_COMMENT_NODE
:
3273 return(CONSTSTR(BAD_CAST
"#comment"));
3274 case XML_DOCUMENT_NODE
:
3275 case XML_HTML_DOCUMENT_NODE
:
3276 #ifdef LIBXML_DOCB_ENABLED
3277 case XML_DOCB_DOCUMENT_NODE
:
3279 return(CONSTSTR(BAD_CAST
"#document"));
3280 case XML_DOCUMENT_FRAG_NODE
:
3281 return(CONSTSTR(BAD_CAST
"#document-fragment"));
3282 case XML_NOTATION_NODE
:
3283 return(CONSTSTR(node
->name
));
3284 case XML_DOCUMENT_TYPE_NODE
:
3286 return(CONSTSTR(node
->name
));
3287 case XML_NAMESPACE_DECL
: {
3288 xmlNsPtr ns
= (xmlNsPtr
) node
;
3290 if (ns
->prefix
== NULL
)
3291 return(CONSTSTR(BAD_CAST
"xmlns"));
3292 return(CONSTQSTR(BAD_CAST
"xmlns", ns
->prefix
));
3295 case XML_ELEMENT_DECL
:
3296 case XML_ATTRIBUTE_DECL
:
3297 case XML_ENTITY_DECL
:
3298 case XML_XINCLUDE_START
:
3299 case XML_XINCLUDE_END
:
3306 * xmlTextReaderPrefix:
3307 * @reader: the xmlTextReaderPtr used
3309 * A shorthand reference to the namespace associated with the node.
3311 * Returns the prefix or NULL if not available,
3312 * if non NULL it need to be freed by the caller.
3315 xmlTextReaderPrefix(xmlTextReaderPtr reader
) {
3317 if ((reader
== NULL
) || (reader
->node
== NULL
))
3319 if (reader
->curnode
!= NULL
)
3320 node
= reader
->curnode
;
3322 node
= reader
->node
;
3323 if (node
->type
== XML_NAMESPACE_DECL
) {
3324 xmlNsPtr ns
= (xmlNsPtr
) node
;
3325 if (ns
->prefix
== NULL
)
3327 return(xmlStrdup(BAD_CAST
"xmlns"));
3329 if ((node
->type
!= XML_ELEMENT_NODE
) &&
3330 (node
->type
!= XML_ATTRIBUTE_NODE
))
3332 if ((node
->ns
!= NULL
) && (node
->ns
->prefix
!= NULL
))
3333 return(xmlStrdup(node
->ns
->prefix
));
3338 * xmlTextReaderConstPrefix:
3339 * @reader: the xmlTextReaderPtr used
3341 * A shorthand reference to the namespace associated with the node.
3343 * Returns the prefix or NULL if not available, the string is deallocated
3347 xmlTextReaderConstPrefix(xmlTextReaderPtr reader
) {
3349 if ((reader
== NULL
) || (reader
->node
== NULL
))
3351 if (reader
->curnode
!= NULL
)
3352 node
= reader
->curnode
;
3354 node
= reader
->node
;
3355 if (node
->type
== XML_NAMESPACE_DECL
) {
3356 xmlNsPtr ns
= (xmlNsPtr
) node
;
3357 if (ns
->prefix
== NULL
)
3359 return(CONSTSTR(BAD_CAST
"xmlns"));
3361 if ((node
->type
!= XML_ELEMENT_NODE
) &&
3362 (node
->type
!= XML_ATTRIBUTE_NODE
))
3364 if ((node
->ns
!= NULL
) && (node
->ns
->prefix
!= NULL
))
3365 return(CONSTSTR(node
->ns
->prefix
));
3370 * xmlTextReaderNamespaceUri:
3371 * @reader: the xmlTextReaderPtr used
3373 * The URI defining the namespace associated with the node.
3375 * Returns the namespace URI or NULL if not available,
3376 * if non NULL it need to be freed by the caller.
3379 xmlTextReaderNamespaceUri(xmlTextReaderPtr reader
) {
3381 if ((reader
== NULL
) || (reader
->node
== NULL
))
3383 if (reader
->curnode
!= NULL
)
3384 node
= reader
->curnode
;
3386 node
= reader
->node
;
3387 if (node
->type
== XML_NAMESPACE_DECL
)
3388 return(xmlStrdup(BAD_CAST
"http://www.w3.org/2000/xmlns/"));
3389 if ((node
->type
!= XML_ELEMENT_NODE
) &&
3390 (node
->type
!= XML_ATTRIBUTE_NODE
))
3392 if (node
->ns
!= NULL
)
3393 return(xmlStrdup(node
->ns
->href
));
3398 * xmlTextReaderConstNamespaceUri:
3399 * @reader: the xmlTextReaderPtr used
3401 * The URI defining the namespace associated with the node.
3403 * Returns the namespace URI or NULL if not available, the string
3404 * will be deallocated with the reader
3407 xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader
) {
3409 if ((reader
== NULL
) || (reader
->node
== NULL
))
3411 if (reader
->curnode
!= NULL
)
3412 node
= reader
->curnode
;
3414 node
= reader
->node
;
3415 if (node
->type
== XML_NAMESPACE_DECL
)
3416 return(CONSTSTR(BAD_CAST
"http://www.w3.org/2000/xmlns/"));
3417 if ((node
->type
!= XML_ELEMENT_NODE
) &&
3418 (node
->type
!= XML_ATTRIBUTE_NODE
))
3420 if (node
->ns
!= NULL
)
3421 return(CONSTSTR(node
->ns
->href
));
3426 * xmlTextReaderBaseUri:
3427 * @reader: the xmlTextReaderPtr used
3429 * The base URI of the node.
3431 * Returns the base URI or NULL if not available,
3432 * if non NULL it need to be freed by the caller.
3435 xmlTextReaderBaseUri(xmlTextReaderPtr reader
) {
3436 if ((reader
== NULL
) || (reader
->node
== NULL
))
3438 return(xmlNodeGetBase(NULL
, reader
->node
));
3442 * xmlTextReaderConstBaseUri:
3443 * @reader: the xmlTextReaderPtr used
3445 * The base URI of the node.
3447 * Returns the base URI or NULL if not available, the string
3448 * will be deallocated with the reader
3451 xmlTextReaderConstBaseUri(xmlTextReaderPtr reader
) {
3455 if ((reader
== NULL
) || (reader
->node
== NULL
))
3457 tmp
= xmlNodeGetBase(NULL
, reader
->node
);
3460 ret
= CONSTSTR(tmp
);
3466 * xmlTextReaderDepth:
3467 * @reader: the xmlTextReaderPtr used
3469 * The depth of the node in the tree.
3471 * Returns the depth or -1 in case of error
3474 xmlTextReaderDepth(xmlTextReaderPtr reader
) {
3477 if (reader
->node
== NULL
)
3480 if (reader
->curnode
!= NULL
) {
3481 if ((reader
->curnode
->type
== XML_ATTRIBUTE_NODE
) ||
3482 (reader
->curnode
->type
== XML_NAMESPACE_DECL
))
3483 return(reader
->depth
+ 1);
3484 return(reader
->depth
+ 2);
3486 return(reader
->depth
);
3490 * xmlTextReaderHasAttributes:
3491 * @reader: the xmlTextReaderPtr used
3493 * Whether the node has attributes.
3495 * Returns 1 if true, 0 if false, and -1 in case or error
3498 xmlTextReaderHasAttributes(xmlTextReaderPtr reader
) {
3502 if (reader
->node
== NULL
)
3504 if (reader
->curnode
!= NULL
)
3505 node
= reader
->curnode
;
3507 node
= reader
->node
;
3509 if ((node
->type
== XML_ELEMENT_NODE
) &&
3510 ((node
->properties
!= NULL
) || (node
->nsDef
!= NULL
)))
3512 /* TODO: handle the xmlDecl */
3517 * xmlTextReaderHasValue:
3518 * @reader: the xmlTextReaderPtr used
3520 * Whether the node can have a text value.
3522 * Returns 1 if true, 0 if false, and -1 in case or error
3525 xmlTextReaderHasValue(xmlTextReaderPtr reader
) {
3529 if (reader
->node
== NULL
)
3531 if (reader
->curnode
!= NULL
)
3532 node
= reader
->curnode
;
3534 node
= reader
->node
;
3536 switch (node
->type
) {
3537 case XML_ATTRIBUTE_NODE
:
3539 case XML_CDATA_SECTION_NODE
:
3541 case XML_COMMENT_NODE
:
3542 case XML_NAMESPACE_DECL
:
3551 * xmlTextReaderValue:
3552 * @reader: the xmlTextReaderPtr used
3554 * Provides the text value of the node if present
3556 * Returns the string or NULL if not available. The result must be deallocated
3560 xmlTextReaderValue(xmlTextReaderPtr reader
) {
3564 if (reader
->node
== NULL
)
3566 if (reader
->curnode
!= NULL
)
3567 node
= reader
->curnode
;
3569 node
= reader
->node
;
3571 switch (node
->type
) {
3572 case XML_NAMESPACE_DECL
:
3573 return(xmlStrdup(((xmlNsPtr
) node
)->href
));
3574 case XML_ATTRIBUTE_NODE
:{
3575 xmlAttrPtr attr
= (xmlAttrPtr
) node
;
3577 if (attr
->parent
!= NULL
)
3578 return (xmlNodeListGetString
3579 (attr
->parent
->doc
, attr
->children
, 1));
3581 return (xmlNodeListGetString(NULL
, attr
->children
, 1));
3585 case XML_CDATA_SECTION_NODE
:
3587 case XML_COMMENT_NODE
:
3588 if (node
->content
!= NULL
)
3589 return (xmlStrdup(node
->content
));
3597 * xmlTextReaderConstValue:
3598 * @reader: the xmlTextReaderPtr used
3600 * Provides the text value of the node if present
3602 * Returns the string or NULL if not available. The result will be
3603 * deallocated on the next Read() operation.
3606 xmlTextReaderConstValue(xmlTextReaderPtr reader
) {
3610 if (reader
->node
== NULL
)
3612 if (reader
->curnode
!= NULL
)
3613 node
= reader
->curnode
;
3615 node
= reader
->node
;
3617 switch (node
->type
) {
3618 case XML_NAMESPACE_DECL
:
3619 return(((xmlNsPtr
) node
)->href
);
3620 case XML_ATTRIBUTE_NODE
:{
3621 xmlAttrPtr attr
= (xmlAttrPtr
) node
;
3624 if ((attr
->children
!= NULL
) &&
3625 (attr
->children
->type
== XML_TEXT_NODE
) &&
3626 (attr
->children
->next
== NULL
))
3627 return(attr
->children
->content
);
3629 if (reader
->buffer
== NULL
) {
3630 reader
->buffer
= xmlBufCreateSize(100);
3631 if (reader
->buffer
== NULL
) {
3632 xmlGenericError(xmlGenericErrorContext
,
3633 "xmlTextReaderSetup : malloc failed\n");
3636 xmlBufSetAllocationScheme(reader
->buffer
,
3637 XML_BUFFER_ALLOC_BOUNDED
);
3639 xmlBufEmpty(reader
->buffer
);
3640 xmlBufGetNodeContent(reader
->buffer
, node
);
3641 ret
= xmlBufContent(reader
->buffer
);
3643 /* error on the buffer best to reallocate */
3644 xmlBufFree(reader
->buffer
);
3645 reader
->buffer
= xmlBufCreateSize(100);
3646 xmlBufSetAllocationScheme(reader
->buffer
,
3647 XML_BUFFER_ALLOC_BOUNDED
);
3655 case XML_CDATA_SECTION_NODE
:
3657 case XML_COMMENT_NODE
:
3658 return(node
->content
);
3666 * xmlTextReaderIsDefault:
3667 * @reader: the xmlTextReaderPtr used
3669 * Whether an Attribute node was generated from the default value
3670 * defined in the DTD or schema.
3672 * Returns 0 if not defaulted, 1 if defaulted, and -1 in case of error
3675 xmlTextReaderIsDefault(xmlTextReaderPtr reader
) {
3682 * xmlTextReaderQuoteChar:
3683 * @reader: the xmlTextReaderPtr used
3685 * The quotation mark character used to enclose the value of an attribute.
3687 * Returns " or ' and -1 in case of error
3690 xmlTextReaderQuoteChar(xmlTextReaderPtr reader
) {
3693 /* TODO maybe lookup the attribute value for " first */
3698 * xmlTextReaderXmlLang:
3699 * @reader: the xmlTextReaderPtr used
3701 * The xml:lang scope within which the node resides.
3703 * Returns the xml:lang value or NULL if none exists.,
3704 * if non NULL it need to be freed by the caller.
3707 xmlTextReaderXmlLang(xmlTextReaderPtr reader
) {
3710 if (reader
->node
== NULL
)
3712 return(xmlNodeGetLang(reader
->node
));
3716 * xmlTextReaderConstXmlLang:
3717 * @reader: the xmlTextReaderPtr used
3719 * The xml:lang scope within which the node resides.
3721 * Returns the xml:lang value or NULL if none exists.
3724 xmlTextReaderConstXmlLang(xmlTextReaderPtr reader
) {
3730 if (reader
->node
== NULL
)
3732 tmp
= xmlNodeGetLang(reader
->node
);
3735 ret
= CONSTSTR(tmp
);
3741 * xmlTextReaderConstString:
3742 * @reader: the xmlTextReaderPtr used
3743 * @str: the string to intern.
3745 * Get an interned string from the reader, allows for example to
3746 * speedup string name comparisons
3748 * Returns an interned copy of the string or NULL in case of error. The
3749 * string will be deallocated with the reader.
3752 xmlTextReaderConstString(xmlTextReaderPtr reader
, const xmlChar
*str
) {
3755 return(CONSTSTR(str
));
3759 * xmlTextReaderNormalization:
3760 * @reader: the xmlTextReaderPtr used
3762 * The value indicating whether to normalize white space and attribute values.
3763 * Since attribute value and end of line normalizations are a MUST in the XML
3764 * specification only the value true is accepted. The broken bahaviour of
3765 * accepting out of range character entities like � is of course not
3768 * Returns 1 or -1 in case of error.
3771 xmlTextReaderNormalization(xmlTextReaderPtr reader
) {
3777 /************************************************************************
3779 * Extensions to the base APIs *
3781 ************************************************************************/
3784 * xmlTextReaderSetParserProp:
3785 * @reader: the xmlTextReaderPtr used
3786 * @prop: the xmlParserProperties to set
3787 * @value: usually 0 or 1 to (de)activate it
3789 * Change the parser processing behaviour by changing some of its internal
3790 * properties. Note that some properties can only be changed before any
3791 * read has been done.
3793 * Returns 0 if the call was successful, or -1 in case of error
3796 xmlTextReaderSetParserProp(xmlTextReaderPtr reader
, int prop
, int value
) {
3797 xmlParserProperties p
= (xmlParserProperties
) prop
;
3798 xmlParserCtxtPtr ctxt
;
3800 if ((reader
== NULL
) || (reader
->ctxt
== NULL
))
3802 ctxt
= reader
->ctxt
;
3805 case XML_PARSER_LOADDTD
:
3807 if (ctxt
->loadsubset
== 0) {
3808 if (reader
->mode
!= XML_TEXTREADER_MODE_INITIAL
)
3810 ctxt
->loadsubset
= XML_DETECT_IDS
;
3813 ctxt
->loadsubset
= 0;
3816 case XML_PARSER_DEFAULTATTRS
:
3818 ctxt
->loadsubset
|= XML_COMPLETE_ATTRS
;
3820 if (ctxt
->loadsubset
& XML_COMPLETE_ATTRS
)
3821 ctxt
->loadsubset
-= XML_COMPLETE_ATTRS
;
3824 case XML_PARSER_VALIDATE
:
3827 reader
->validate
= XML_TEXTREADER_VALIDATE_DTD
;
3832 case XML_PARSER_SUBST_ENTITIES
:
3834 ctxt
->replaceEntities
= 1;
3836 ctxt
->replaceEntities
= 0;
3844 * xmlTextReaderGetParserProp:
3845 * @reader: the xmlTextReaderPtr used
3846 * @prop: the xmlParserProperties to get
3848 * Read the parser internal property.
3850 * Returns the value, usually 0 or 1, or -1 in case of error.
3853 xmlTextReaderGetParserProp(xmlTextReaderPtr reader
, int prop
) {
3854 xmlParserProperties p
= (xmlParserProperties
) prop
;
3855 xmlParserCtxtPtr ctxt
;
3857 if ((reader
== NULL
) || (reader
->ctxt
== NULL
))
3859 ctxt
= reader
->ctxt
;
3862 case XML_PARSER_LOADDTD
:
3863 if ((ctxt
->loadsubset
!= 0) || (ctxt
->validate
!= 0))
3866 case XML_PARSER_DEFAULTATTRS
:
3867 if (ctxt
->loadsubset
& XML_COMPLETE_ATTRS
)
3870 case XML_PARSER_VALIDATE
:
3871 return(reader
->validate
);
3872 case XML_PARSER_SUBST_ENTITIES
:
3873 return(ctxt
->replaceEntities
);
3880 * xmlTextReaderGetParserLineNumber:
3881 * @reader: the user data (XML reader context)
3883 * Provide the line number of the current parsing point.
3885 * Returns an int or 0 if not available
3888 xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader
)
3890 if ((reader
== NULL
) || (reader
->ctxt
== NULL
) ||
3891 (reader
->ctxt
->input
== NULL
)) {
3894 return (reader
->ctxt
->input
->line
);
3898 * xmlTextReaderGetParserColumnNumber:
3899 * @reader: the user data (XML reader context)
3901 * Provide the column number of the current parsing point.
3903 * Returns an int or 0 if not available
3906 xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader
)
3908 if ((reader
== NULL
) || (reader
->ctxt
== NULL
) ||
3909 (reader
->ctxt
->input
== NULL
)) {
3912 return (reader
->ctxt
->input
->col
);
3916 * xmlTextReaderCurrentNode:
3917 * @reader: the xmlTextReaderPtr used
3919 * Hacking interface allowing to get the xmlNodePtr correponding to the
3920 * current node being accessed by the xmlTextReader. This is dangerous
3921 * because the underlying node may be destroyed on the next Reads.
3923 * Returns the xmlNodePtr or NULL in case of error.
3926 xmlTextReaderCurrentNode(xmlTextReaderPtr reader
) {
3930 if (reader
->curnode
!= NULL
)
3931 return(reader
->curnode
);
3932 return(reader
->node
);
3936 * xmlTextReaderPreserve:
3937 * @reader: the xmlTextReaderPtr used
3939 * This tells the XML Reader to preserve the current node.
3940 * The caller must also use xmlTextReaderCurrentDoc() to
3941 * keep an handle on the resulting document once parsing has finished
3943 * Returns the xmlNodePtr or NULL in case of error.
3946 xmlTextReaderPreserve(xmlTextReaderPtr reader
) {
3947 xmlNodePtr cur
, parent
;
3952 if (reader
->curnode
!= NULL
)
3953 cur
= reader
->curnode
;
3959 if ((cur
->type
!= XML_DOCUMENT_NODE
) && (cur
->type
!= XML_DTD_NODE
)) {
3960 cur
->extra
|= NODE_IS_PRESERVED
;
3961 cur
->extra
|= NODE_IS_SPRESERVED
;
3963 reader
->preserves
++;
3965 parent
= cur
->parent
;;
3966 while (parent
!= NULL
) {
3967 if (parent
->type
== XML_ELEMENT_NODE
)
3968 parent
->extra
|= NODE_IS_PRESERVED
;
3969 parent
= parent
->parent
;
3974 #ifdef LIBXML_PATTERN_ENABLED
3976 * xmlTextReaderPreservePattern:
3977 * @reader: the xmlTextReaderPtr used
3978 * @pattern: an XPath subset pattern
3979 * @namespaces: the prefix definitions, array of [URI, prefix] or NULL
3981 * This tells the XML Reader to preserve all nodes matched by the
3982 * pattern. The caller must also use xmlTextReaderCurrentDoc() to
3983 * keep an handle on the resulting document once parsing has finished
3985 * Returns a positive number in case of success and -1 in case of error
3988 xmlTextReaderPreservePattern(xmlTextReaderPtr reader
, const xmlChar
*pattern
,
3989 const xmlChar
**namespaces
)
3993 if ((reader
== NULL
) || (pattern
== NULL
))
3996 comp
= xmlPatterncompile(pattern
, reader
->dict
, 0, namespaces
);
4000 if (reader
->patternMax
<= 0) {
4001 reader
->patternMax
= 4;
4002 reader
->patternTab
= (xmlPatternPtr
*) xmlMalloc(reader
->patternMax
*
4003 sizeof(reader
->patternTab
[0]));
4004 if (reader
->patternTab
== NULL
) {
4005 xmlGenericError(xmlGenericErrorContext
, "xmlMalloc failed !\n");
4009 if (reader
->patternNr
>= reader
->patternMax
) {
4011 reader
->patternMax
*= 2;
4012 tmp
= (xmlPatternPtr
*) xmlRealloc(reader
->patternTab
,
4013 reader
->patternMax
*
4014 sizeof(reader
->patternTab
[0]));
4016 xmlGenericError(xmlGenericErrorContext
, "xmlRealloc failed !\n");
4017 reader
->patternMax
/= 2;
4020 reader
->patternTab
= tmp
;
4022 reader
->patternTab
[reader
->patternNr
] = comp
;
4023 return(reader
->patternNr
++);
4028 * xmlTextReaderCurrentDoc:
4029 * @reader: the xmlTextReaderPtr used
4031 * Hacking interface allowing to get the xmlDocPtr correponding to the
4032 * current document being accessed by the xmlTextReader.
4033 * NOTE: as a result of this call, the reader will not destroy the
4034 * associated XML document and calling xmlFreeDoc() on the result
4035 * is needed once the reader parsing has finished.
4037 * Returns the xmlDocPtr or NULL in case of error.
4040 xmlTextReaderCurrentDoc(xmlTextReaderPtr reader
) {
4043 if (reader
->doc
!= NULL
)
4044 return(reader
->doc
);
4045 if ((reader
->ctxt
== NULL
) || (reader
->ctxt
->myDoc
== NULL
))
4048 reader
->preserve
= 1;
4049 return(reader
->ctxt
->myDoc
);
4052 #ifdef LIBXML_SCHEMAS_ENABLED
4053 static char *xmlTextReaderBuildMessage(const char *msg
, va_list ap
) LIBXML_ATTR_FORMAT(1,0);
4055 static void XMLCDECL
4056 xmlTextReaderValidityError(void *ctxt
, const char *msg
, ...) LIBXML_ATTR_FORMAT(2,3);
4058 static void XMLCDECL
4059 xmlTextReaderValidityWarning(void *ctxt
, const char *msg
, ...) LIBXML_ATTR_FORMAT(2,3);
4061 static void XMLCDECL
4062 xmlTextReaderValidityErrorRelay(void *ctx
, const char *msg
, ...) LIBXML_ATTR_FORMAT(2,3);
4064 static void XMLCDECL
4065 xmlTextReaderValidityWarningRelay(void *ctx
, const char *msg
, ...) LIBXML_ATTR_FORMAT(2,3);
4067 static void XMLCDECL
4068 xmlTextReaderValidityErrorRelay(void *ctx
, const char *msg
, ...)
4070 xmlTextReaderPtr reader
= (xmlTextReaderPtr
) ctx
;
4077 str
= xmlTextReaderBuildMessage(msg
, ap
);
4078 if (!reader
->errorFunc
) {
4079 xmlTextReaderValidityError(ctx
, "%s", str
);
4081 reader
->errorFunc(reader
->errorFuncArg
, str
,
4082 XML_PARSER_SEVERITY_VALIDITY_ERROR
,
4083 NULL
/* locator */ );
4090 static void XMLCDECL
4091 xmlTextReaderValidityWarningRelay(void *ctx
, const char *msg
, ...)
4093 xmlTextReaderPtr reader
= (xmlTextReaderPtr
) ctx
;
4100 str
= xmlTextReaderBuildMessage(msg
, ap
);
4101 if (!reader
->errorFunc
) {
4102 xmlTextReaderValidityWarning(ctx
, "%s", str
);
4104 reader
->errorFunc(reader
->errorFuncArg
, str
,
4105 XML_PARSER_SEVERITY_VALIDITY_WARNING
,
4106 NULL
/* locator */ );
4114 xmlTextReaderStructuredError(void *ctxt
, xmlErrorPtr error
);
4117 xmlTextReaderValidityStructuredRelay(void *userData
, xmlErrorPtr error
)
4119 xmlTextReaderPtr reader
= (xmlTextReaderPtr
) userData
;
4121 if (reader
->sErrorFunc
) {
4122 reader
->sErrorFunc(reader
->errorFuncArg
, error
);
4124 xmlTextReaderStructuredError(reader
, error
);
4128 * xmlTextReaderRelaxNGSetSchema:
4129 * @reader: the xmlTextReaderPtr used
4130 * @schema: a precompiled RelaxNG schema
4132 * Use RelaxNG to validate the document as it is processed.
4133 * Activation is only possible before the first Read().
4134 * if @schema is NULL, then RelaxNG validation is desactivated.
4135 @ The @schema should not be freed until the reader is deallocated
4136 * or its use has been deactivated.
4138 * Returns 0 in case the RelaxNG validation could be (des)activated and
4139 * -1 in case of error.
4142 xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader
, xmlRelaxNGPtr schema
) {
4145 if (schema
== NULL
) {
4146 if (reader
->rngSchemas
!= NULL
) {
4147 xmlRelaxNGFree(reader
->rngSchemas
);
4148 reader
->rngSchemas
= NULL
;
4150 if (reader
->rngValidCtxt
!= NULL
) {
4151 if (! reader
->rngPreserveCtxt
)
4152 xmlRelaxNGFreeValidCtxt(reader
->rngValidCtxt
);
4153 reader
->rngValidCtxt
= NULL
;
4155 reader
->rngPreserveCtxt
= 0;
4158 if (reader
->mode
!= XML_TEXTREADER_MODE_INITIAL
)
4160 if (reader
->rngSchemas
!= NULL
) {
4161 xmlRelaxNGFree(reader
->rngSchemas
);
4162 reader
->rngSchemas
= NULL
;
4164 if (reader
->rngValidCtxt
!= NULL
) {
4165 if (! reader
->rngPreserveCtxt
)
4166 xmlRelaxNGFreeValidCtxt(reader
->rngValidCtxt
);
4167 reader
->rngValidCtxt
= NULL
;
4169 reader
->rngPreserveCtxt
= 0;
4170 reader
->rngValidCtxt
= xmlRelaxNGNewValidCtxt(schema
);
4171 if (reader
->rngValidCtxt
== NULL
)
4173 if (reader
->errorFunc
!= NULL
) {
4174 xmlRelaxNGSetValidErrors(reader
->rngValidCtxt
,
4175 xmlTextReaderValidityErrorRelay
,
4176 xmlTextReaderValidityWarningRelay
,
4179 if (reader
->sErrorFunc
!= NULL
) {
4180 xmlRelaxNGSetValidStructuredErrors(reader
->rngValidCtxt
,
4181 xmlTextReaderValidityStructuredRelay
,
4184 reader
->rngValidErrors
= 0;
4185 reader
->rngFullNode
= NULL
;
4186 reader
->validate
= XML_TEXTREADER_VALIDATE_RNG
;
4191 * xmlTextReaderLocator:
4192 * @ctx: the xmlTextReaderPtr used
4193 * @file: returned file information
4194 * @line: returned line information
4196 * Internal locator function for the readers
4198 * Returns 0 in case the Schema validation could be (des)activated and
4199 * -1 in case of error.
4202 xmlTextReaderLocator(void *ctx
, const char **file
, unsigned long *line
) {
4203 xmlTextReaderPtr reader
;
4205 if ((ctx
== NULL
) || ((file
== NULL
) && (line
== NULL
)))
4213 reader
= (xmlTextReaderPtr
) ctx
;
4214 if ((reader
->ctxt
!= NULL
) && (reader
->ctxt
->input
!= NULL
)) {
4216 *file
= reader
->ctxt
->input
->filename
;
4218 *line
= reader
->ctxt
->input
->line
;
4221 if (reader
->node
!= NULL
) {
4226 res
= xmlGetLineNo(reader
->node
);
4228 *line
= (unsigned long) res
;
4233 xmlDocPtr doc
= reader
->node
->doc
;
4234 if ((doc
!= NULL
) && (doc
->URL
!= NULL
))
4235 *file
= (const char *) doc
->URL
;
4245 * xmlTextReaderSetSchema:
4246 * @reader: the xmlTextReaderPtr used
4247 * @schema: a precompiled Schema schema
4249 * Use XSD Schema to validate the document as it is processed.
4250 * Activation is only possible before the first Read().
4251 * if @schema is NULL, then Schema validation is desactivated.
4252 @ The @schema should not be freed until the reader is deallocated
4253 * or its use has been deactivated.
4255 * Returns 0 in case the Schema validation could be (des)activated and
4256 * -1 in case of error.
4259 xmlTextReaderSetSchema(xmlTextReaderPtr reader
, xmlSchemaPtr schema
) {
4262 if (schema
== NULL
) {
4263 if (reader
->xsdPlug
!= NULL
) {
4264 xmlSchemaSAXUnplug(reader
->xsdPlug
);
4265 reader
->xsdPlug
= NULL
;
4267 if (reader
->xsdValidCtxt
!= NULL
) {
4268 if (! reader
->xsdPreserveCtxt
)
4269 xmlSchemaFreeValidCtxt(reader
->xsdValidCtxt
);
4270 reader
->xsdValidCtxt
= NULL
;
4272 reader
->xsdPreserveCtxt
= 0;
4273 if (reader
->xsdSchemas
!= NULL
) {
4274 xmlSchemaFree(reader
->xsdSchemas
);
4275 reader
->xsdSchemas
= NULL
;
4279 if (reader
->mode
!= XML_TEXTREADER_MODE_INITIAL
)
4281 if (reader
->xsdPlug
!= NULL
) {
4282 xmlSchemaSAXUnplug(reader
->xsdPlug
);
4283 reader
->xsdPlug
= NULL
;
4285 if (reader
->xsdValidCtxt
!= NULL
) {
4286 if (! reader
->xsdPreserveCtxt
)
4287 xmlSchemaFreeValidCtxt(reader
->xsdValidCtxt
);
4288 reader
->xsdValidCtxt
= NULL
;
4290 reader
->xsdPreserveCtxt
= 0;
4291 if (reader
->xsdSchemas
!= NULL
) {
4292 xmlSchemaFree(reader
->xsdSchemas
);
4293 reader
->xsdSchemas
= NULL
;
4295 reader
->xsdValidCtxt
= xmlSchemaNewValidCtxt(schema
);
4296 if (reader
->xsdValidCtxt
== NULL
) {
4297 xmlSchemaFree(reader
->xsdSchemas
);
4298 reader
->xsdSchemas
= NULL
;
4301 reader
->xsdPlug
= xmlSchemaSAXPlug(reader
->xsdValidCtxt
,
4302 &(reader
->ctxt
->sax
),
4303 &(reader
->ctxt
->userData
));
4304 if (reader
->xsdPlug
== NULL
) {
4305 xmlSchemaFree(reader
->xsdSchemas
);
4306 reader
->xsdSchemas
= NULL
;
4307 xmlSchemaFreeValidCtxt(reader
->xsdValidCtxt
);
4308 reader
->xsdValidCtxt
= NULL
;
4311 xmlSchemaValidateSetLocator(reader
->xsdValidCtxt
,
4312 xmlTextReaderLocator
,
4315 if (reader
->errorFunc
!= NULL
) {
4316 xmlSchemaSetValidErrors(reader
->xsdValidCtxt
,
4317 xmlTextReaderValidityErrorRelay
,
4318 xmlTextReaderValidityWarningRelay
,
4321 if (reader
->sErrorFunc
!= NULL
) {
4322 xmlSchemaSetValidStructuredErrors(reader
->xsdValidCtxt
,
4323 xmlTextReaderValidityStructuredRelay
,
4326 reader
->xsdValidErrors
= 0;
4327 reader
->validate
= XML_TEXTREADER_VALIDATE_XSD
;
4332 * xmlTextReaderRelaxNGValidateInternal:
4333 * @reader: the xmlTextReaderPtr used
4334 * @rng: the path to a RelaxNG schema or NULL
4335 * @ctxt: the RelaxNG schema validation context or NULL
4336 * @options: options (not yet used)
4338 * Use RelaxNG to validate the document as it is processed.
4339 * Activation is only possible before the first Read().
4340 * If both @rng and @ctxt are NULL, then RelaxNG validation is deactivated.
4342 * Returns 0 in case the RelaxNG validation could be (de)activated and
4343 * -1 in case of error.
4346 xmlTextReaderRelaxNGValidateInternal(xmlTextReaderPtr reader
,
4348 xmlRelaxNGValidCtxtPtr ctxt
,
4349 int options ATTRIBUTE_UNUSED
)
4354 if ((rng
!= NULL
) && (ctxt
!= NULL
))
4357 if (((rng
!= NULL
) || (ctxt
!= NULL
)) &&
4358 ((reader
->mode
!= XML_TEXTREADER_MODE_INITIAL
) ||
4359 (reader
->ctxt
== NULL
)))
4362 /* Cleanup previous validation stuff. */
4363 if (reader
->rngValidCtxt
!= NULL
) {
4364 if ( !reader
->rngPreserveCtxt
)
4365 xmlRelaxNGFreeValidCtxt(reader
->rngValidCtxt
);
4366 reader
->rngValidCtxt
= NULL
;
4368 reader
->rngPreserveCtxt
= 0;
4369 if (reader
->rngSchemas
!= NULL
) {
4370 xmlRelaxNGFree(reader
->rngSchemas
);
4371 reader
->rngSchemas
= NULL
;
4374 if ((rng
== NULL
) && (ctxt
== NULL
)) {
4375 /* We just want to deactivate the validation, so get out. */
4381 xmlRelaxNGParserCtxtPtr pctxt
;
4382 /* Parse the schema and create validation environment. */
4384 pctxt
= xmlRelaxNGNewParserCtxt(rng
);
4385 if (reader
->errorFunc
!= NULL
) {
4386 xmlRelaxNGSetParserErrors(pctxt
,
4387 xmlTextReaderValidityErrorRelay
,
4388 xmlTextReaderValidityWarningRelay
,
4391 if (reader
->sErrorFunc
!= NULL
) {
4392 xmlRelaxNGSetValidStructuredErrors(reader
->rngValidCtxt
,
4393 xmlTextReaderValidityStructuredRelay
,
4396 reader
->rngSchemas
= xmlRelaxNGParse(pctxt
);
4397 xmlRelaxNGFreeParserCtxt(pctxt
);
4398 if (reader
->rngSchemas
== NULL
)
4400 reader
->rngValidCtxt
= xmlRelaxNGNewValidCtxt(reader
->rngSchemas
);
4401 if (reader
->rngValidCtxt
== NULL
) {
4402 xmlRelaxNGFree(reader
->rngSchemas
);
4403 reader
->rngSchemas
= NULL
;
4407 /* Use the given validation context. */
4408 reader
->rngValidCtxt
= ctxt
;
4409 reader
->rngPreserveCtxt
= 1;
4412 * Redirect the validation context's error channels to use
4413 * the reader channels.
4414 * TODO: In case the user provides the validation context we
4415 * could make this redirection optional.
4417 if (reader
->errorFunc
!= NULL
) {
4418 xmlRelaxNGSetValidErrors(reader
->rngValidCtxt
,
4419 xmlTextReaderValidityErrorRelay
,
4420 xmlTextReaderValidityWarningRelay
,
4423 if (reader
->sErrorFunc
!= NULL
) {
4424 xmlRelaxNGSetValidStructuredErrors(reader
->rngValidCtxt
,
4425 xmlTextReaderValidityStructuredRelay
,
4428 reader
->rngValidErrors
= 0;
4429 reader
->rngFullNode
= NULL
;
4430 reader
->validate
= XML_TEXTREADER_VALIDATE_RNG
;
4435 * xmlTextReaderSchemaValidateInternal:
4436 * @reader: the xmlTextReaderPtr used
4437 * @xsd: the path to a W3C XSD schema or NULL
4438 * @ctxt: the XML Schema validation context or NULL
4439 * @options: options (not used yet)
4441 * Validate the document as it is processed using XML Schema.
4442 * Activation is only possible before the first Read().
4443 * If both @xsd and @ctxt are NULL then XML Schema validation is deactivated.
4445 * Returns 0 in case the schemas validation could be (de)activated and
4446 * -1 in case of error.
4449 xmlTextReaderSchemaValidateInternal(xmlTextReaderPtr reader
,
4451 xmlSchemaValidCtxtPtr ctxt
,
4452 int options ATTRIBUTE_UNUSED
)
4457 if ((xsd
!= NULL
) && (ctxt
!= NULL
))
4460 if (((xsd
!= NULL
) || (ctxt
!= NULL
)) &&
4461 ((reader
->mode
!= XML_TEXTREADER_MODE_INITIAL
) ||
4462 (reader
->ctxt
== NULL
)))
4465 /* Cleanup previous validation stuff. */
4466 if (reader
->xsdPlug
!= NULL
) {
4467 xmlSchemaSAXUnplug(reader
->xsdPlug
);
4468 reader
->xsdPlug
= NULL
;
4470 if (reader
->xsdValidCtxt
!= NULL
) {
4471 if (! reader
->xsdPreserveCtxt
)
4472 xmlSchemaFreeValidCtxt(reader
->xsdValidCtxt
);
4473 reader
->xsdValidCtxt
= NULL
;
4475 reader
->xsdPreserveCtxt
= 0;
4476 if (reader
->xsdSchemas
!= NULL
) {
4477 xmlSchemaFree(reader
->xsdSchemas
);
4478 reader
->xsdSchemas
= NULL
;
4481 if ((xsd
== NULL
) && (ctxt
== NULL
)) {
4482 /* We just want to deactivate the validation, so get out. */
4487 xmlSchemaParserCtxtPtr pctxt
;
4488 /* Parse the schema and create validation environment. */
4489 pctxt
= xmlSchemaNewParserCtxt(xsd
);
4490 if (reader
->errorFunc
!= NULL
) {
4491 xmlSchemaSetParserErrors(pctxt
,
4492 xmlTextReaderValidityErrorRelay
,
4493 xmlTextReaderValidityWarningRelay
,
4496 reader
->xsdSchemas
= xmlSchemaParse(pctxt
);
4497 xmlSchemaFreeParserCtxt(pctxt
);
4498 if (reader
->xsdSchemas
== NULL
)
4500 reader
->xsdValidCtxt
= xmlSchemaNewValidCtxt(reader
->xsdSchemas
);
4501 if (reader
->xsdValidCtxt
== NULL
) {
4502 xmlSchemaFree(reader
->xsdSchemas
);
4503 reader
->xsdSchemas
= NULL
;
4506 reader
->xsdPlug
= xmlSchemaSAXPlug(reader
->xsdValidCtxt
,
4507 &(reader
->ctxt
->sax
),
4508 &(reader
->ctxt
->userData
));
4509 if (reader
->xsdPlug
== NULL
) {
4510 xmlSchemaFree(reader
->xsdSchemas
);
4511 reader
->xsdSchemas
= NULL
;
4512 xmlSchemaFreeValidCtxt(reader
->xsdValidCtxt
);
4513 reader
->xsdValidCtxt
= NULL
;
4517 /* Use the given validation context. */
4518 reader
->xsdValidCtxt
= ctxt
;
4519 reader
->xsdPreserveCtxt
= 1;
4520 reader
->xsdPlug
= xmlSchemaSAXPlug(reader
->xsdValidCtxt
,
4521 &(reader
->ctxt
->sax
),
4522 &(reader
->ctxt
->userData
));
4523 if (reader
->xsdPlug
== NULL
) {
4524 reader
->xsdValidCtxt
= NULL
;
4525 reader
->xsdPreserveCtxt
= 0;
4529 xmlSchemaValidateSetLocator(reader
->xsdValidCtxt
,
4530 xmlTextReaderLocator
,
4533 * Redirect the validation context's error channels to use
4534 * the reader channels.
4535 * TODO: In case the user provides the validation context we
4536 * could make this redirection optional.
4538 if (reader
->errorFunc
!= NULL
) {
4539 xmlSchemaSetValidErrors(reader
->xsdValidCtxt
,
4540 xmlTextReaderValidityErrorRelay
,
4541 xmlTextReaderValidityWarningRelay
,
4544 if (reader
->sErrorFunc
!= NULL
) {
4545 xmlSchemaSetValidStructuredErrors(reader
->xsdValidCtxt
,
4546 xmlTextReaderValidityStructuredRelay
,
4549 reader
->xsdValidErrors
= 0;
4550 reader
->validate
= XML_TEXTREADER_VALIDATE_XSD
;
4555 * xmlTextReaderSchemaValidateCtxt:
4556 * @reader: the xmlTextReaderPtr used
4557 * @ctxt: the XML Schema validation context or NULL
4558 * @options: options (not used yet)
4560 * Use W3C XSD schema context to validate the document as it is processed.
4561 * Activation is only possible before the first Read().
4562 * If @ctxt is NULL, then XML Schema validation is deactivated.
4564 * Returns 0 in case the schemas validation could be (de)activated and
4565 * -1 in case of error.
4568 xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader
,
4569 xmlSchemaValidCtxtPtr ctxt
,
4572 return(xmlTextReaderSchemaValidateInternal(reader
, NULL
, ctxt
, options
));
4576 * xmlTextReaderSchemaValidate:
4577 * @reader: the xmlTextReaderPtr used
4578 * @xsd: the path to a W3C XSD schema or NULL
4580 * Use W3C XSD schema to validate the document as it is processed.
4581 * Activation is only possible before the first Read().
4582 * If @xsd is NULL, then XML Schema validation is deactivated.
4584 * Returns 0 in case the schemas validation could be (de)activated and
4585 * -1 in case of error.
4588 xmlTextReaderSchemaValidate(xmlTextReaderPtr reader
, const char *xsd
)
4590 return(xmlTextReaderSchemaValidateInternal(reader
, xsd
, NULL
, 0));
4594 * xmlTextReaderRelaxNGValidateCtxt:
4595 * @reader: the xmlTextReaderPtr used
4596 * @ctxt: the RelaxNG schema validation context or NULL
4597 * @options: options (not used yet)
4599 * Use RelaxNG schema context to validate the document as it is processed.
4600 * Activation is only possible before the first Read().
4601 * If @ctxt is NULL, then RelaxNG schema validation is deactivated.
4603 * Returns 0 in case the schemas validation could be (de)activated and
4604 * -1 in case of error.
4607 xmlTextReaderRelaxNGValidateCtxt(xmlTextReaderPtr reader
,
4608 xmlRelaxNGValidCtxtPtr ctxt
,
4611 return(xmlTextReaderRelaxNGValidateInternal(reader
, NULL
, ctxt
, options
));
4615 * xmlTextReaderRelaxNGValidate:
4616 * @reader: the xmlTextReaderPtr used
4617 * @rng: the path to a RelaxNG schema or NULL
4619 * Use RelaxNG schema to validate the document as it is processed.
4620 * Activation is only possible before the first Read().
4621 * If @rng is NULL, then RelaxNG schema validation is deactivated.
4623 * Returns 0 in case the schemas validation could be (de)activated and
4624 * -1 in case of error.
4627 xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader
, const char *rng
)
4629 return(xmlTextReaderRelaxNGValidateInternal(reader
, rng
, NULL
, 0));
4635 * xmlTextReaderIsNamespaceDecl:
4636 * @reader: the xmlTextReaderPtr used
4638 * Determine whether the current node is a namespace declaration
4639 * rather than a regular attribute.
4641 * Returns 1 if the current node is a namespace declaration, 0 if it
4642 * is a regular attribute or other type of node, or -1 in case of
4646 xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader
) {
4650 if (reader
->node
== NULL
)
4652 if (reader
->curnode
!= NULL
)
4653 node
= reader
->curnode
;
4655 node
= reader
->node
;
4657 if (XML_NAMESPACE_DECL
== node
->type
)
4664 * xmlTextReaderConstXmlVersion:
4665 * @reader: the xmlTextReaderPtr used
4667 * Determine the XML version of the document being read.
4669 * Returns a string containing the XML version of the document or NULL
4670 * in case of error. The string is deallocated with the reader.
4673 xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader
) {
4674 xmlDocPtr doc
= NULL
;
4677 if (reader
->doc
!= NULL
)
4679 else if (reader
->ctxt
!= NULL
)
4680 doc
= reader
->ctxt
->myDoc
;
4684 if (doc
->version
== NULL
)
4687 return(CONSTSTR(doc
->version
));
4691 * xmlTextReaderStandalone:
4692 * @reader: the xmlTextReaderPtr used
4694 * Determine the standalone status of the document being read.
4696 * Returns 1 if the document was declared to be standalone, 0 if it
4697 * was declared to be not standalone, or -1 if the document did not
4698 * specify its standalone status or in case of error.
4701 xmlTextReaderStandalone(xmlTextReaderPtr reader
) {
4702 xmlDocPtr doc
= NULL
;
4705 if (reader
->doc
!= NULL
)
4707 else if (reader
->ctxt
!= NULL
)
4708 doc
= reader
->ctxt
->myDoc
;
4712 return(doc
->standalone
);
4715 /************************************************************************
4717 * Error Handling Extensions *
4719 ************************************************************************/
4721 /* helper to build a xmlMalloc'ed string from a format and va_list */
4723 xmlTextReaderBuildMessage(const char *msg
, va_list ap
) {
4732 chars
= vsnprintf(str
, size
, msg
, aq
);
4735 xmlGenericError(xmlGenericErrorContext
, "vsnprintf failed !\n");
4740 if ((chars
< size
) || (size
== MAX_ERR_MSG_SIZE
))
4742 if (chars
< MAX_ERR_MSG_SIZE
)
4745 size
= MAX_ERR_MSG_SIZE
;
4746 if ((larger
= (char *) xmlRealloc(str
, size
)) == NULL
) {
4747 xmlGenericError(xmlGenericErrorContext
, "xmlRealloc failed !\n");
4759 * xmlTextReaderLocatorLineNumber:
4760 * @locator: the xmlTextReaderLocatorPtr used
4762 * Obtain the line number for the given locator.
4764 * Returns the line number or -1 in case of error.
4767 xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator
) {
4768 /* we know that locator is a xmlParserCtxtPtr */
4769 xmlParserCtxtPtr ctx
= (xmlParserCtxtPtr
)locator
;
4772 if (locator
== NULL
)
4774 if (ctx
->node
!= NULL
) {
4775 ret
= xmlGetLineNo(ctx
->node
);
4778 /* inspired from error.c */
4779 xmlParserInputPtr input
;
4781 if ((input
->filename
== NULL
) && (ctx
->inputNr
> 1))
4782 input
= ctx
->inputTab
[ctx
->inputNr
- 2];
4783 if (input
!= NULL
) {
4795 * xmlTextReaderLocatorBaseURI:
4796 * @locator: the xmlTextReaderLocatorPtr used
4798 * Obtain the base URI for the given locator.
4800 * Returns the base URI or NULL in case of error,
4801 * if non NULL it need to be freed by the caller.
4804 xmlTextReaderLocatorBaseURI(xmlTextReaderLocatorPtr locator
) {
4805 /* we know that locator is a xmlParserCtxtPtr */
4806 xmlParserCtxtPtr ctx
= (xmlParserCtxtPtr
)locator
;
4807 xmlChar
*ret
= NULL
;
4809 if (locator
== NULL
)
4811 if (ctx
->node
!= NULL
) {
4812 ret
= xmlNodeGetBase(NULL
,ctx
->node
);
4815 /* inspired from error.c */
4816 xmlParserInputPtr input
;
4818 if ((input
->filename
== NULL
) && (ctx
->inputNr
> 1))
4819 input
= ctx
->inputTab
[ctx
->inputNr
- 2];
4820 if (input
!= NULL
) {
4821 ret
= xmlStrdup(BAD_CAST input
->filename
);
4832 xmlTextReaderGenericError(void *ctxt
, xmlParserSeverities severity
,
4835 xmlParserCtxtPtr ctx
= (xmlParserCtxtPtr
) ctxt
;
4837 xmlTextReaderPtr reader
= (xmlTextReaderPtr
) ctx
->_private
;
4840 if (reader
->errorFunc
)
4841 reader
->errorFunc(reader
->errorFuncArg
, str
, severity
,
4842 (xmlTextReaderLocatorPtr
) ctx
);
4848 xmlTextReaderStructuredError(void *ctxt
, xmlErrorPtr error
)
4850 xmlParserCtxtPtr ctx
= (xmlParserCtxtPtr
) ctxt
;
4852 xmlTextReaderPtr reader
= (xmlTextReaderPtr
) ctx
->_private
;
4854 if (error
&& reader
->sErrorFunc
) {
4855 reader
->sErrorFunc(reader
->errorFuncArg
, (xmlErrorPtr
) error
);
4859 static void XMLCDECL
LIBXML_ATTR_FORMAT(2,3)
4860 xmlTextReaderError(void *ctxt
, const char *msg
, ...)
4865 xmlTextReaderGenericError(ctxt
,
4866 XML_PARSER_SEVERITY_ERROR
,
4867 xmlTextReaderBuildMessage(msg
, ap
));
4872 static void XMLCDECL
LIBXML_ATTR_FORMAT(2,3)
4873 xmlTextReaderWarning(void *ctxt
, const char *msg
, ...)
4878 xmlTextReaderGenericError(ctxt
,
4879 XML_PARSER_SEVERITY_WARNING
,
4880 xmlTextReaderBuildMessage(msg
, ap
));
4884 static void XMLCDECL
4885 xmlTextReaderValidityError(void *ctxt
, const char *msg
, ...)
4889 int len
= xmlStrlen((const xmlChar
*) msg
);
4891 if ((len
> 1) && (msg
[len
- 2] != ':')) {
4893 * some callbacks only report locator information:
4894 * skip them (mimicking behaviour in error.c)
4897 xmlTextReaderGenericError(ctxt
,
4898 XML_PARSER_SEVERITY_VALIDITY_ERROR
,
4899 xmlTextReaderBuildMessage(msg
, ap
));
4904 static void XMLCDECL
4905 xmlTextReaderValidityWarning(void *ctxt
, const char *msg
, ...)
4909 int len
= xmlStrlen((const xmlChar
*) msg
);
4911 if ((len
!= 0) && (msg
[len
- 1] != ':')) {
4913 * some callbacks only report locator information:
4914 * skip them (mimicking behaviour in error.c)
4917 xmlTextReaderGenericError(ctxt
,
4918 XML_PARSER_SEVERITY_VALIDITY_WARNING
,
4919 xmlTextReaderBuildMessage(msg
, ap
));
4925 * xmlTextReaderSetErrorHandler:
4926 * @reader: the xmlTextReaderPtr used
4927 * @f: the callback function to call on error and warnings
4928 * @arg: a user argument to pass to the callback function
4930 * Register a callback function that will be called on error and warnings.
4932 * If @f is NULL, the default error and warning handlers are restored.
4935 xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader
,
4936 xmlTextReaderErrorFunc f
, void *arg
)
4939 reader
->ctxt
->sax
->error
= xmlTextReaderError
;
4940 reader
->ctxt
->sax
->serror
= NULL
;
4941 reader
->ctxt
->vctxt
.error
= xmlTextReaderValidityError
;
4942 reader
->ctxt
->sax
->warning
= xmlTextReaderWarning
;
4943 reader
->ctxt
->vctxt
.warning
= xmlTextReaderValidityWarning
;
4944 reader
->errorFunc
= f
;
4945 reader
->sErrorFunc
= NULL
;
4946 reader
->errorFuncArg
= arg
;
4947 #ifdef LIBXML_SCHEMAS_ENABLED
4948 if (reader
->rngValidCtxt
) {
4949 xmlRelaxNGSetValidErrors(reader
->rngValidCtxt
,
4950 xmlTextReaderValidityErrorRelay
,
4951 xmlTextReaderValidityWarningRelay
,
4953 xmlRelaxNGSetValidStructuredErrors(reader
->rngValidCtxt
, NULL
,
4956 if (reader
->xsdValidCtxt
) {
4957 xmlSchemaSetValidErrors(reader
->xsdValidCtxt
,
4958 xmlTextReaderValidityErrorRelay
,
4959 xmlTextReaderValidityWarningRelay
,
4961 xmlSchemaSetValidStructuredErrors(reader
->xsdValidCtxt
, NULL
,
4966 /* restore defaults */
4967 reader
->ctxt
->sax
->error
= xmlParserError
;
4968 reader
->ctxt
->vctxt
.error
= xmlParserValidityError
;
4969 reader
->ctxt
->sax
->warning
= xmlParserWarning
;
4970 reader
->ctxt
->vctxt
.warning
= xmlParserValidityWarning
;
4971 reader
->errorFunc
= NULL
;
4972 reader
->sErrorFunc
= NULL
;
4973 reader
->errorFuncArg
= NULL
;
4974 #ifdef LIBXML_SCHEMAS_ENABLED
4975 if (reader
->rngValidCtxt
) {
4976 xmlRelaxNGSetValidErrors(reader
->rngValidCtxt
, NULL
, NULL
,
4978 xmlRelaxNGSetValidStructuredErrors(reader
->rngValidCtxt
, NULL
,
4981 if (reader
->xsdValidCtxt
) {
4982 xmlSchemaSetValidErrors(reader
->xsdValidCtxt
, NULL
, NULL
,
4984 xmlSchemaSetValidStructuredErrors(reader
->xsdValidCtxt
, NULL
,
4992 * xmlTextReaderSetStructuredErrorHandler:
4993 * @reader: the xmlTextReaderPtr used
4994 * @f: the callback function to call on error and warnings
4995 * @arg: a user argument to pass to the callback function
4997 * Register a callback function that will be called on error and warnings.
4999 * If @f is NULL, the default error and warning handlers are restored.
5002 xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader
,
5003 xmlStructuredErrorFunc f
, void *arg
)
5006 reader
->ctxt
->sax
->error
= NULL
;
5007 reader
->ctxt
->sax
->serror
= xmlTextReaderStructuredError
;
5008 reader
->ctxt
->vctxt
.error
= xmlTextReaderValidityError
;
5009 reader
->ctxt
->sax
->warning
= xmlTextReaderWarning
;
5010 reader
->ctxt
->vctxt
.warning
= xmlTextReaderValidityWarning
;
5011 reader
->sErrorFunc
= f
;
5012 reader
->errorFunc
= NULL
;
5013 reader
->errorFuncArg
= arg
;
5014 #ifdef LIBXML_SCHEMAS_ENABLED
5015 if (reader
->rngValidCtxt
) {
5016 xmlRelaxNGSetValidErrors(reader
->rngValidCtxt
, NULL
, NULL
,
5018 xmlRelaxNGSetValidStructuredErrors(reader
->rngValidCtxt
,
5019 xmlTextReaderValidityStructuredRelay
,
5022 if (reader
->xsdValidCtxt
) {
5023 xmlSchemaSetValidErrors(reader
->xsdValidCtxt
, NULL
, NULL
,
5025 xmlSchemaSetValidStructuredErrors(reader
->xsdValidCtxt
,
5026 xmlTextReaderValidityStructuredRelay
,
5031 /* restore defaults */
5032 reader
->ctxt
->sax
->error
= xmlParserError
;
5033 reader
->ctxt
->sax
->serror
= NULL
;
5034 reader
->ctxt
->vctxt
.error
= xmlParserValidityError
;
5035 reader
->ctxt
->sax
->warning
= xmlParserWarning
;
5036 reader
->ctxt
->vctxt
.warning
= xmlParserValidityWarning
;
5037 reader
->errorFunc
= NULL
;
5038 reader
->sErrorFunc
= NULL
;
5039 reader
->errorFuncArg
= NULL
;
5040 #ifdef LIBXML_SCHEMAS_ENABLED
5041 if (reader
->rngValidCtxt
) {
5042 xmlRelaxNGSetValidErrors(reader
->rngValidCtxt
, NULL
, NULL
,
5044 xmlRelaxNGSetValidStructuredErrors(reader
->rngValidCtxt
, NULL
,
5047 if (reader
->xsdValidCtxt
) {
5048 xmlSchemaSetValidErrors(reader
->xsdValidCtxt
, NULL
, NULL
,
5050 xmlSchemaSetValidStructuredErrors(reader
->xsdValidCtxt
, NULL
,
5058 * xmlTextReaderIsValid:
5059 * @reader: the xmlTextReaderPtr used
5061 * Retrieve the validity status from the parser context
5063 * Returns the flag value 1 if valid, 0 if no, and -1 in case of error
5066 xmlTextReaderIsValid(xmlTextReaderPtr reader
)
5070 #ifdef LIBXML_SCHEMAS_ENABLED
5071 if (reader
->validate
== XML_TEXTREADER_VALIDATE_RNG
)
5072 return (reader
->rngValidErrors
== 0);
5073 if (reader
->validate
== XML_TEXTREADER_VALIDATE_XSD
)
5074 return (reader
->xsdValidErrors
== 0);
5076 if ((reader
->ctxt
!= NULL
) && (reader
->ctxt
->validate
== 1))
5077 return (reader
->ctxt
->valid
);
5082 * xmlTextReaderGetErrorHandler:
5083 * @reader: the xmlTextReaderPtr used
5084 * @f: the callback function or NULL is no callback has been registered
5085 * @arg: a user argument
5087 * Retrieve the error callback function and user argument.
5090 xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader
,
5091 xmlTextReaderErrorFunc
* f
, void **arg
)
5094 *f
= reader
->errorFunc
;
5096 *arg
= reader
->errorFuncArg
;
5098 /************************************************************************
5100 * New set (2.6.0) of simpler and more flexible APIs *
5102 ************************************************************************/
5105 * xmlTextReaderSetup:
5106 * @reader: an XML reader
5107 * @input: xmlParserInputBufferPtr used to feed the reader, will
5108 * be destroyed with it.
5109 * @URL: the base URL to use for the document
5110 * @encoding: the document encoding, or NULL
5111 * @options: a combination of xmlParserOption
5113 * Setup an XML reader with new options
5115 * Returns 0 in case of success and -1 in case of error.
5118 xmlTextReaderSetup(xmlTextReaderPtr reader
,
5119 xmlParserInputBufferPtr input
, const char *URL
,
5120 const char *encoding
, int options
)
5122 if (reader
== NULL
) {
5124 xmlFreeParserInputBuffer(input
);
5129 * we force the generation of compact text nodes on the reader
5130 * since usr applications should never modify the tree
5132 options
|= XML_PARSE_COMPACT
;
5136 reader
->parserFlags
= options
;
5137 reader
->validate
= XML_TEXTREADER_NOT_VALIDATE
;
5138 if ((input
!= NULL
) && (reader
->input
!= NULL
) &&
5139 (reader
->allocs
& XML_TEXTREADER_INPUT
)) {
5140 xmlFreeParserInputBuffer(reader
->input
);
5141 reader
->input
= NULL
;
5142 reader
->allocs
-= XML_TEXTREADER_INPUT
;
5144 if (input
!= NULL
) {
5145 reader
->input
= input
;
5146 reader
->allocs
|= XML_TEXTREADER_INPUT
;
5148 if (reader
->buffer
== NULL
)
5149 reader
->buffer
= xmlBufCreateSize(100);
5150 if (reader
->buffer
== NULL
) {
5151 xmlGenericError(xmlGenericErrorContext
,
5152 "xmlTextReaderSetup : malloc failed\n");
5155 /* no operation on a reader should require a huge buffer */
5156 xmlBufSetAllocationScheme(reader
->buffer
,
5157 XML_BUFFER_ALLOC_BOUNDED
);
5158 if (reader
->sax
== NULL
)
5159 reader
->sax
= (xmlSAXHandler
*) xmlMalloc(sizeof(xmlSAXHandler
));
5160 if (reader
->sax
== NULL
) {
5161 xmlGenericError(xmlGenericErrorContext
,
5162 "xmlTextReaderSetup : malloc failed\n");
5165 xmlSAXVersion(reader
->sax
, 2);
5166 reader
->startElement
= reader
->sax
->startElement
;
5167 reader
->sax
->startElement
= xmlTextReaderStartElement
;
5168 reader
->endElement
= reader
->sax
->endElement
;
5169 reader
->sax
->endElement
= xmlTextReaderEndElement
;
5170 #ifdef LIBXML_SAX1_ENABLED
5171 if (reader
->sax
->initialized
== XML_SAX2_MAGIC
) {
5172 #endif /* LIBXML_SAX1_ENABLED */
5173 reader
->startElementNs
= reader
->sax
->startElementNs
;
5174 reader
->sax
->startElementNs
= xmlTextReaderStartElementNs
;
5175 reader
->endElementNs
= reader
->sax
->endElementNs
;
5176 reader
->sax
->endElementNs
= xmlTextReaderEndElementNs
;
5177 #ifdef LIBXML_SAX1_ENABLED
5179 reader
->startElementNs
= NULL
;
5180 reader
->endElementNs
= NULL
;
5182 #endif /* LIBXML_SAX1_ENABLED */
5183 reader
->characters
= reader
->sax
->characters
;
5184 reader
->sax
->characters
= xmlTextReaderCharacters
;
5185 reader
->sax
->ignorableWhitespace
= xmlTextReaderCharacters
;
5186 reader
->cdataBlock
= reader
->sax
->cdataBlock
;
5187 reader
->sax
->cdataBlock
= xmlTextReaderCDataBlock
;
5189 reader
->mode
= XML_TEXTREADER_MODE_INITIAL
;
5190 reader
->node
= NULL
;
5191 reader
->curnode
= NULL
;
5192 if (input
!= NULL
) {
5193 if (xmlBufUse(reader
->input
->buffer
) < 4) {
5194 xmlParserInputBufferRead(input
, 4);
5196 if (reader
->ctxt
== NULL
) {
5197 if (xmlBufUse(reader
->input
->buffer
) >= 4) {
5198 reader
->ctxt
= xmlCreatePushParserCtxt(reader
->sax
, NULL
,
5199 (const char *) xmlBufContent(reader
->input
->buffer
),
5205 xmlCreatePushParserCtxt(reader
->sax
, NULL
, NULL
, 0, URL
);
5210 xmlParserInputPtr inputStream
;
5211 xmlParserInputBufferPtr buf
;
5212 xmlCharEncoding enc
= XML_CHAR_ENCODING_NONE
;
5214 xmlCtxtReset(reader
->ctxt
);
5215 buf
= xmlAllocParserInputBuffer(enc
);
5216 if (buf
== NULL
) return(-1);
5217 inputStream
= xmlNewInputStream(reader
->ctxt
);
5218 if (inputStream
== NULL
) {
5219 xmlFreeParserInputBuffer(buf
);
5224 inputStream
->filename
= NULL
;
5226 inputStream
->filename
= (char *)
5227 xmlCanonicPath((const xmlChar
*) URL
);
5228 inputStream
->buf
= buf
;
5229 xmlBufResetInput(buf
->buffer
, inputStream
);
5231 inputPush(reader
->ctxt
, inputStream
);
5234 if (reader
->ctxt
== NULL
) {
5235 xmlGenericError(xmlGenericErrorContext
,
5236 "xmlTextReaderSetup : malloc failed\n");
5240 if (reader
->dict
!= NULL
) {
5241 if (reader
->ctxt
->dict
!= NULL
) {
5242 if (reader
->dict
!= reader
->ctxt
->dict
) {
5243 xmlDictFree(reader
->dict
);
5244 reader
->dict
= reader
->ctxt
->dict
;
5247 reader
->ctxt
->dict
= reader
->dict
;
5250 if (reader
->ctxt
->dict
== NULL
)
5251 reader
->ctxt
->dict
= xmlDictCreate();
5252 reader
->dict
= reader
->ctxt
->dict
;
5254 reader
->ctxt
->_private
= reader
;
5255 reader
->ctxt
->linenumbers
= 1;
5256 reader
->ctxt
->dictNames
= 1;
5258 * use the parser dictionary to allocate all elements and attributes names
5260 reader
->ctxt
->docdict
= 1;
5261 reader
->ctxt
->parseMode
= XML_PARSE_READER
;
5263 #ifdef LIBXML_XINCLUDE_ENABLED
5264 if (reader
->xincctxt
!= NULL
) {
5265 xmlXIncludeFreeContext(reader
->xincctxt
);
5266 reader
->xincctxt
= NULL
;
5268 if (options
& XML_PARSE_XINCLUDE
) {
5269 reader
->xinclude
= 1;
5270 reader
->xinclude_name
= xmlDictLookup(reader
->dict
, XINCLUDE_NODE
, -1);
5271 options
-= XML_PARSE_XINCLUDE
;
5273 reader
->xinclude
= 0;
5274 reader
->in_xinclude
= 0;
5276 #ifdef LIBXML_PATTERN_ENABLED
5277 if (reader
->patternTab
== NULL
) {
5278 reader
->patternNr
= 0;
5279 reader
->patternMax
= 0;
5281 while (reader
->patternNr
> 0) {
5282 reader
->patternNr
--;
5283 if (reader
->patternTab
[reader
->patternNr
] != NULL
) {
5284 xmlFreePattern(reader
->patternTab
[reader
->patternNr
]);
5285 reader
->patternTab
[reader
->patternNr
] = NULL
;
5290 if (options
& XML_PARSE_DTDVALID
)
5291 reader
->validate
= XML_TEXTREADER_VALIDATE_DTD
;
5293 xmlCtxtUseOptions(reader
->ctxt
, options
);
5294 if (encoding
!= NULL
) {
5295 xmlCharEncodingHandlerPtr hdlr
;
5297 hdlr
= xmlFindCharEncodingHandler(encoding
);
5299 xmlSwitchToEncoding(reader
->ctxt
, hdlr
);
5301 if ((URL
!= NULL
) && (reader
->ctxt
->input
!= NULL
) &&
5302 (reader
->ctxt
->input
->filename
== NULL
))
5303 reader
->ctxt
->input
->filename
= (char *)
5304 xmlStrdup((const xmlChar
*) URL
);
5312 * xmlTextReaderByteConsumed:
5313 * @reader: an XML reader
5315 * This function provides the current index of the parser used
5316 * by the reader, relative to the start of the current entity.
5317 * This function actually just wraps a call to xmlBytesConsumed()
5318 * for the parser context associated with the reader.
5319 * See xmlBytesConsumed() for more information.
5321 * Returns the index in bytes from the beginning of the entity or -1
5322 * in case the index could not be computed.
5325 xmlTextReaderByteConsumed(xmlTextReaderPtr reader
) {
5326 if ((reader
== NULL
) || (reader
->ctxt
== NULL
))
5328 return(xmlByteConsumed(reader
->ctxt
));
5334 * @doc: a preparsed document
5336 * Create an xmltextReader for a preparsed document.
5338 * Returns the new reader or NULL in case of error.
5341 xmlReaderWalker(xmlDocPtr doc
)
5343 xmlTextReaderPtr ret
;
5348 ret
= xmlMalloc(sizeof(xmlTextReader
));
5350 xmlGenericError(xmlGenericErrorContext
,
5351 "xmlNewTextReader : malloc failed\n");
5354 memset(ret
, 0, sizeof(xmlTextReader
));
5357 ret
->mode
= XML_TEXTREADER_MODE_INITIAL
;
5359 ret
->curnode
= NULL
;
5362 ret
->allocs
= XML_TEXTREADER_CTXT
;
5364 ret
->state
= XML_TEXTREADER_START
;
5365 ret
->dict
= xmlDictCreate();
5371 * @cur: a pointer to a zero terminated string
5372 * @URL: the base URL to use for the document
5373 * @encoding: the document encoding, or NULL
5374 * @options: a combination of xmlParserOption
5376 * Create an xmltextReader for an XML in-memory document.
5377 * The parsing flags @options are a combination of xmlParserOption.
5379 * Returns the new reader or NULL in case of error.
5382 xmlReaderForDoc(const xmlChar
* cur
, const char *URL
, const char *encoding
,
5389 len
= xmlStrlen(cur
);
5391 return (xmlReaderForMemory
5392 ((const char *) cur
, len
, URL
, encoding
, options
));
5397 * @filename: a file or URL
5398 * @encoding: the document encoding, or NULL
5399 * @options: a combination of xmlParserOption
5401 * parse an XML file from the filesystem or the network.
5402 * The parsing flags @options are a combination of xmlParserOption.
5404 * Returns the new reader or NULL in case of error.
5407 xmlReaderForFile(const char *filename
, const char *encoding
, int options
)
5409 xmlTextReaderPtr reader
;
5411 reader
= xmlNewTextReaderFilename(filename
);
5414 xmlTextReaderSetup(reader
, NULL
, NULL
, encoding
, options
);
5419 * xmlReaderForMemory:
5420 * @buffer: a pointer to a char array
5421 * @size: the size of the array
5422 * @URL: the base URL to use for the document
5423 * @encoding: the document encoding, or NULL
5424 * @options: a combination of xmlParserOption
5426 * Create an xmltextReader for an XML in-memory document.
5427 * The parsing flags @options are a combination of xmlParserOption.
5429 * Returns the new reader or NULL in case of error.
5432 xmlReaderForMemory(const char *buffer
, int size
, const char *URL
,
5433 const char *encoding
, int options
)
5435 xmlTextReaderPtr reader
;
5436 xmlParserInputBufferPtr buf
;
5438 buf
= xmlParserInputBufferCreateStatic(buffer
, size
,
5439 XML_CHAR_ENCODING_NONE
);
5443 reader
= xmlNewTextReader(buf
, URL
);
5444 if (reader
== NULL
) {
5445 xmlFreeParserInputBuffer(buf
);
5448 reader
->allocs
|= XML_TEXTREADER_INPUT
;
5449 xmlTextReaderSetup(reader
, NULL
, URL
, encoding
, options
);
5455 * @fd: an open file descriptor
5456 * @URL: the base URL to use for the document
5457 * @encoding: the document encoding, or NULL
5458 * @options: a combination of xmlParserOption
5460 * Create an xmltextReader for an XML from a file descriptor.
5461 * The parsing flags @options are a combination of xmlParserOption.
5462 * NOTE that the file descriptor will not be closed when the
5463 * reader is closed or reset.
5465 * Returns the new reader or NULL in case of error.
5468 xmlReaderForFd(int fd
, const char *URL
, const char *encoding
, int options
)
5470 xmlTextReaderPtr reader
;
5471 xmlParserInputBufferPtr input
;
5476 input
= xmlParserInputBufferCreateFd(fd
, XML_CHAR_ENCODING_NONE
);
5479 input
->closecallback
= NULL
;
5480 reader
= xmlNewTextReader(input
, URL
);
5481 if (reader
== NULL
) {
5482 xmlFreeParserInputBuffer(input
);
5485 reader
->allocs
|= XML_TEXTREADER_INPUT
;
5486 xmlTextReaderSetup(reader
, NULL
, URL
, encoding
, options
);
5492 * @ioread: an I/O read function
5493 * @ioclose: an I/O close function
5494 * @ioctx: an I/O handler
5495 * @URL: the base URL to use for the document
5496 * @encoding: the document encoding, or NULL
5497 * @options: a combination of xmlParserOption
5499 * Create an xmltextReader for an XML document from I/O functions and source.
5500 * The parsing flags @options are a combination of xmlParserOption.
5502 * Returns the new reader or NULL in case of error.
5505 xmlReaderForIO(xmlInputReadCallback ioread
, xmlInputCloseCallback ioclose
,
5506 void *ioctx
, const char *URL
, const char *encoding
,
5509 xmlTextReaderPtr reader
;
5510 xmlParserInputBufferPtr input
;
5515 input
= xmlParserInputBufferCreateIO(ioread
, ioclose
, ioctx
,
5516 XML_CHAR_ENCODING_NONE
);
5517 if (input
== NULL
) {
5518 if (ioclose
!= NULL
)
5522 reader
= xmlNewTextReader(input
, URL
);
5523 if (reader
== NULL
) {
5524 xmlFreeParserInputBuffer(input
);
5527 reader
->allocs
|= XML_TEXTREADER_INPUT
;
5528 xmlTextReaderSetup(reader
, NULL
, URL
, encoding
, options
);
5533 * xmlReaderNewWalker:
5534 * @reader: an XML reader
5535 * @doc: a preparsed document
5537 * Setup an xmltextReader to parse a preparsed XML document.
5538 * This reuses the existing @reader xmlTextReader.
5540 * Returns 0 in case of success and -1 in case of error
5543 xmlReaderNewWalker(xmlTextReaderPtr reader
, xmlDocPtr doc
)
5550 if (reader
->input
!= NULL
) {
5551 xmlFreeParserInputBuffer(reader
->input
);
5553 if (reader
->ctxt
!= NULL
) {
5554 xmlCtxtReset(reader
->ctxt
);
5558 reader
->input
= NULL
;
5559 reader
->mode
= XML_TEXTREADER_MODE_INITIAL
;
5560 reader
->node
= NULL
;
5561 reader
->curnode
= NULL
;
5564 reader
->allocs
= XML_TEXTREADER_CTXT
;
5566 reader
->state
= XML_TEXTREADER_START
;
5567 if (reader
->dict
== NULL
) {
5568 if ((reader
->ctxt
!= NULL
) && (reader
->ctxt
->dict
!= NULL
))
5569 reader
->dict
= reader
->ctxt
->dict
;
5571 reader
->dict
= xmlDictCreate();
5578 * @reader: an XML reader
5579 * @cur: a pointer to a zero terminated string
5580 * @URL: the base URL to use for the document
5581 * @encoding: the document encoding, or NULL
5582 * @options: a combination of xmlParserOption
5584 * Setup an xmltextReader to parse an XML in-memory document.
5585 * The parsing flags @options are a combination of xmlParserOption.
5586 * This reuses the existing @reader xmlTextReader.
5588 * Returns 0 in case of success and -1 in case of error
5591 xmlReaderNewDoc(xmlTextReaderPtr reader
, const xmlChar
* cur
,
5592 const char *URL
, const char *encoding
, int options
)
5602 len
= xmlStrlen(cur
);
5603 return (xmlReaderNewMemory(reader
, (const char *)cur
, len
,
5604 URL
, encoding
, options
));
5609 * @reader: an XML reader
5610 * @filename: a file or URL
5611 * @encoding: the document encoding, or NULL
5612 * @options: a combination of xmlParserOption
5614 * parse an XML file from the filesystem or the network.
5615 * The parsing flags @options are a combination of xmlParserOption.
5616 * This reuses the existing @reader xmlTextReader.
5618 * Returns 0 in case of success and -1 in case of error
5621 xmlReaderNewFile(xmlTextReaderPtr reader
, const char *filename
,
5622 const char *encoding
, int options
)
5624 xmlParserInputBufferPtr input
;
5626 if (filename
== NULL
)
5632 xmlParserInputBufferCreateFilename(filename
,
5633 XML_CHAR_ENCODING_NONE
);
5636 return (xmlTextReaderSetup(reader
, input
, filename
, encoding
, options
));
5640 * xmlReaderNewMemory:
5641 * @reader: an XML reader
5642 * @buffer: a pointer to a char array
5643 * @size: the size of the array
5644 * @URL: the base URL to use for the document
5645 * @encoding: the document encoding, or NULL
5646 * @options: a combination of xmlParserOption
5648 * Setup an xmltextReader to parse an XML in-memory document.
5649 * The parsing flags @options are a combination of xmlParserOption.
5650 * This reuses the existing @reader xmlTextReader.
5652 * Returns 0 in case of success and -1 in case of error
5655 xmlReaderNewMemory(xmlTextReaderPtr reader
, const char *buffer
, int size
,
5656 const char *URL
, const char *encoding
, int options
)
5658 xmlParserInputBufferPtr input
;
5665 input
= xmlParserInputBufferCreateStatic(buffer
, size
,
5666 XML_CHAR_ENCODING_NONE
);
5667 if (input
== NULL
) {
5670 return (xmlTextReaderSetup(reader
, input
, URL
, encoding
, options
));
5675 * @reader: an XML reader
5676 * @fd: an open file descriptor
5677 * @URL: the base URL to use for the document
5678 * @encoding: the document encoding, or NULL
5679 * @options: a combination of xmlParserOption
5681 * Setup an xmltextReader to parse an XML from a file descriptor.
5682 * NOTE that the file descriptor will not be closed when the
5683 * reader is closed or reset.
5684 * The parsing flags @options are a combination of xmlParserOption.
5685 * This reuses the existing @reader xmlTextReader.
5687 * Returns 0 in case of success and -1 in case of error
5690 xmlReaderNewFd(xmlTextReaderPtr reader
, int fd
,
5691 const char *URL
, const char *encoding
, int options
)
5693 xmlParserInputBufferPtr input
;
5700 input
= xmlParserInputBufferCreateFd(fd
, XML_CHAR_ENCODING_NONE
);
5703 input
->closecallback
= NULL
;
5704 return (xmlTextReaderSetup(reader
, input
, URL
, encoding
, options
));
5709 * @reader: an XML reader
5710 * @ioread: an I/O read function
5711 * @ioclose: an I/O close function
5712 * @ioctx: an I/O handler
5713 * @URL: the base URL to use for the document
5714 * @encoding: the document encoding, or NULL
5715 * @options: a combination of xmlParserOption
5717 * Setup an xmltextReader to parse an XML document from I/O functions
5719 * The parsing flags @options are a combination of xmlParserOption.
5720 * This reuses the existing @reader xmlTextReader.
5722 * Returns 0 in case of success and -1 in case of error
5725 xmlReaderNewIO(xmlTextReaderPtr reader
, xmlInputReadCallback ioread
,
5726 xmlInputCloseCallback ioclose
, void *ioctx
,
5727 const char *URL
, const char *encoding
, int options
)
5729 xmlParserInputBufferPtr input
;
5736 input
= xmlParserInputBufferCreateIO(ioread
, ioclose
, ioctx
,
5737 XML_CHAR_ENCODING_NONE
);
5738 if (input
== NULL
) {
5739 if (ioclose
!= NULL
)
5743 return (xmlTextReaderSetup(reader
, input
, URL
, encoding
, options
));
5746 /************************************************************************
5750 ************************************************************************/
5755 * @in: the input buffer
5756 * @inlen: the size of the input (in), the size read from it (out)
5757 * @to: the output buffer
5758 * @tolen: the size of the output (in), the size written to (out)
5760 * Base64 decoder, reads from @in and save in @to
5761 * TODO: tell jody when this is actually exported
5763 * Returns 0 if all the input was consumer, 1 if the Base64 end was reached,
5764 * 2 if there wasn't enough space on the output or -1 in case of error.
5767 xmlBase64Decode(const unsigned char *in
, unsigned long *inlen
,
5768 unsigned char *to
, unsigned long *tolen
)
5770 unsigned long incur
; /* current index in in[] */
5772 unsigned long inblk
; /* last block index in in[] */
5774 unsigned long outcur
; /* current index in out[] */
5776 unsigned long inmax
; /* size of in[] */
5778 unsigned long outmax
; /* size of out[] */
5780 unsigned char cur
; /* the current value read from in[] */
5782 unsigned char intmp
[4], outtmp
[4]; /* temporary buffers for the convert */
5784 int nbintmp
; /* number of byte in intmp[] */
5786 int is_ignore
; /* cur should be ignored */
5788 int is_end
= 0; /* the end of the base64 was found */
5794 if ((in
== NULL
) || (inlen
== NULL
) || (to
== NULL
) || (tolen
== NULL
))
5809 if ((cur
>= 'A') && (cur
<= 'Z'))
5811 else if ((cur
>= 'a') && (cur
<= 'z'))
5812 cur
= cur
- 'a' + 26;
5813 else if ((cur
>= '0') && (cur
<= '9'))
5814 cur
= cur
- '0' + 52;
5815 else if (cur
== '+')
5817 else if (cur
== '/')
5819 else if (cur
== '.')
5821 else if (cur
== '=') /*no op , end of the base64 stream */
5837 if ((nbintmp
== 1) || (nbintmp
== 2))
5844 intmp
[nbintmp
++] = cur
;
5846 * if intmp is full, push the 4byte sequence as a 3 byte
5851 outtmp
[0] = (intmp
[0] << 2) | ((intmp
[1] & 0x30) >> 4);
5853 ((intmp
[1] & 0x0F) << 4) | ((intmp
[2] & 0x3C) >> 2);
5854 outtmp
[2] = ((intmp
[2] & 0x03) << 6) | (intmp
[3] & 0x3F);
5855 if (outcur
+ 3 >= outmax
) {
5860 for (i
= 0; i
< nbouttmp
; i
++)
5861 to
[outcur
++] = outtmp
[i
];
5878 * Test routine for the xmlBase64Decode function
5882 main(int argc
, char **argv
)
5884 char *input
= " VW4 gcGV0 \n aXQgdGVzdCAuCg== ";
5892 unsigned long inlen
= strlen(input
);
5894 unsigned long outlen
= 100;
5898 unsigned long cons
, tmp
, tmp2
, prod
;
5903 ret
= xmlBase64Decode(input
, &inlen
, output
, &outlen
);
5906 printf("ret: %d, inlen: %ld , outlen: %ld, output: '%s'\n", ret
, inlen
,
5907 outlen
, output
)indent
: Standard input
:179: Error
:Unmatched
#endif
5915 while (cons
< inlen
) {
5917 tmp2
= inlen
- cons
;
5919 printf("%ld %ld\n", cons
, prod
);
5920 ret
= xmlBase64Decode(&input
[cons
], &tmp2
, &output2
[prod
], &tmp
);
5923 printf("%ld %ld\n", cons
, prod
);
5925 output2
[outlen
] = 0;
5926 printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret
, cons
,
5934 while (cons
< inlen
) {
5936 tmp2
= inlen
- cons
;
5940 printf("%ld %ld\n", cons
, prod
);
5941 ret
= xmlBase64Decode(&input
[cons
], &tmp2
, &output3
[prod
], &tmp
);
5944 printf("%ld %ld\n", cons
, prod
);
5946 output3
[outlen
] = 0;
5947 printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret
, cons
,
5953 #endif /* NOT_USED_YET */
5954 #define bottom_xmlreader
5955 #include "elfgcchack.h"
5956 #endif /* LIBXML_READER_ENABLED */