VirtualBox

source: vbox/trunk/src/libs/libxml2-2.9.4/xmlreader.c@ 76686

Last change on this file since 76686 was 65950, checked in by vboxsync, 8 years ago

libxml 2.9.4: fix export
  • Property svn:eol-style set to native
File size: 164.5 KB
Line 
1/*
2 * xmlreader.c: implements the xmlTextReader streaming node API
3 *
4 * NOTE:
5 * XmlTextReader.Normalization Property won't be supported, since
6 * it makes the parser non compliant to the XML recommendation
7 *
8 * See Copyright for the status of this software.
9 *
10 * [email protected]
11 */
12
13/*
14 * TODOs:
15 * - XML Schemas validation
16 */
17#define IN_LIBXML
18#include "libxml.h"
19
20#ifdef LIBXML_READER_ENABLED
21#include <string.h> /* for memset() only ! */
22#include <stdarg.h>
23
24#ifdef HAVE_CTYPE_H
25#include <ctype.h>
26#endif
27#ifdef HAVE_STDLIB_H
28#include <stdlib.h>
29#endif
30
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>
38#endif
39#include <libxml/uri.h>
40#ifdef LIBXML_XINCLUDE_ENABLED
41#include <libxml/xinclude.h>
42#endif
43#ifdef LIBXML_PATTERN_ENABLED
44#include <libxml/pattern.h>
45#endif
46
47#include "buf.h"
48
49#define MAX_ERR_MSG_SIZE 64000
50
51/*
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.
56 */
57#ifndef VA_COPY
58 #ifdef HAVE_VA_COPY
59 #define VA_COPY(dest, src) va_copy(dest, src)
60 #else
61 #ifdef HAVE___VA_COPY
62 #define VA_COPY(dest,src) __va_copy(dest, src)
63 #else
64 #ifndef VA_LIST_IS_ARRAY
65 #define VA_COPY(dest,src) (dest) = (src)
66 #else
67 #include <string.h>
68 #define VA_COPY(dest,src) memcpy((char *)(dest),(char *)(src),sizeof(va_list))
69 #endif
70 #endif
71 #endif
72#endif
73
74/* #define DEBUG_CALLBACKS */
75/* #define DEBUG_READER */
76
77/**
78 * TODO:
79 *
80 * macro to flag unimplemented blocks
81 */
82#define TODO \
83 xmlGenericError(xmlGenericErrorContext, \
84 "Unimplemented block at %s:%d\n", \
85 __FILE__, __LINE__);
86
87#ifdef DEBUG_READER
88#define DUMP_READER xmlTextReaderDebug(reader);
89#else
90#define DUMP_READER
91#endif
92
93#define CHUNK_SIZE 512
94/************************************************************************
95 * *
96 * The parser: maps the Text Reader API on top of the existing *
97 * parsing routines building a tree *
98 * *
99 ************************************************************************/
100
101#define XML_TEXTREADER_INPUT 1
102#define XML_TEXTREADER_CTXT 2
103
104typedef enum {
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;
114
115typedef enum {
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;
121
122struct _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 */
146
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 */
152
153 /* error handling */
154 xmlTextReaderErrorFunc errorFunc; /* callback function */
155 void *errorFuncArg; /* callback function user argument */
156
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 */
170#endif
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 */
177#endif
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 */
182#endif
183 int preserves; /* level of preserves */
184 int parserFlags; /* the set of options set */
185 /* Structured error handling */
186 xmlStructuredErrorFunc sErrorFunc; /* callback function */
187};
188
189#define NODE_IS_EMPTY 0x1
190#define NODE_IS_PRESERVED 0x2
191#define NODE_IS_SPRESERVED 0x4
192
193/**
194 * CONSTSTR:
195 *
196 * Macro used to return an interned string
197 */
198#define CONSTSTR(str) xmlDictLookup(reader->dict, (str), -1)
199#define CONSTQSTR(p, str) xmlDictQLookup(reader->dict, (p), (str))
200
201static int xmlTextReaderReadTree(xmlTextReaderPtr reader);
202static int xmlTextReaderNextTree(xmlTextReaderPtr reader);
203
204/************************************************************************
205 * *
206 * Our own version of the freeing routines as we recycle nodes *
207 * *
208 ************************************************************************/
209/**
210 * DICT_FREE:
211 * @str: a string
212 *
213 * Free a string if it is not owned by the "dict" dictionary in the
214 * current scope
215 */
216#define DICT_FREE(str) \
217 if ((str) && ((!dict) || \
218 (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
219 xmlFree((char *)(str));
220
221static void xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur);
222static void xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur);
223
224/**
225 * xmlFreeID:
226 * @not: A id
227 *
228 * Deallocate the memory used by an id definition
229 */
230static void
231xmlFreeID(xmlIDPtr id) {
232 xmlDictPtr dict = NULL;
233
234 if (id == NULL) return;
235
236 if (id->doc != NULL)
237 dict = id->doc->dict;
238
239 if (id->value != NULL)
240 DICT_FREE(id->value)
241 xmlFree(id);
242}
243
244/**
245 * xmlTextReaderRemoveID:
246 * @doc: the document
247 * @attr: the attribute
248 *
249 * Remove the given attribute from the ID table maintained internally.
250 *
251 * Returns -1 if the lookup failed and 0 otherwise
252 */
253static int
254xmlTextReaderRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
255 xmlIDTablePtr table;
256 xmlIDPtr id;
257 xmlChar *ID;
258
259 if (doc == NULL) return(-1);
260 if (attr == NULL) return(-1);
261 table = (xmlIDTablePtr) doc->ids;
262 if (table == NULL)
263 return(-1);
264
265 ID = xmlNodeListGetString(doc, attr->children, 1);
266 if (ID == NULL)
267 return(-1);
268 id = xmlHashLookup(table, ID);
269 xmlFree(ID);
270 if (id == NULL || id->attr != attr) {
271 return(-1);
272 }
273 id->name = attr->name;
274 id->attr = NULL;
275 return(0);
276}
277
278/**
279 * xmlTextReaderFreeProp:
280 * @reader: the xmlTextReaderPtr used
281 * @cur: the node
282 *
283 * Free a node.
284 */
285static void
286xmlTextReaderFreeProp(xmlTextReaderPtr reader, xmlAttrPtr cur) {
287 xmlDictPtr dict;
288
289 if ((reader != NULL) && (reader->ctxt != NULL))
290 dict = reader->ctxt->dict;
291 else
292 dict = NULL;
293 if (cur == NULL) return;
294
295 if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
296 xmlDeregisterNodeDefaultValue((xmlNodePtr) cur);
297
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);
304 }
305 if (cur->children != NULL)
306 xmlTextReaderFreeNodeList(reader, cur->children);
307
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++;
314 } else {
315 xmlFree(cur);
316 }
317}
318
319/**
320 * xmlTextReaderFreePropList:
321 * @reader: the xmlTextReaderPtr used
322 * @cur: the first property in the list
323 *
324 * Free a property and all its siblings, all the children are freed too.
325 */
326static void
327xmlTextReaderFreePropList(xmlTextReaderPtr reader, xmlAttrPtr cur) {
328 xmlAttrPtr next;
329
330 while (cur != NULL) {
331 next = cur->next;
332 xmlTextReaderFreeProp(reader, cur);
333 cur = next;
334 }
335}
336
337/**
338 * xmlTextReaderFreeNodeList:
339 * @reader: the xmlTextReaderPtr used
340 * @cur: the first node in the list
341 *
342 * Free a node and all its siblings, this is a recursive behaviour, all
343 * the children are freed too.
344 */
345static void
346xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur) {
347 xmlNodePtr next;
348 xmlDictPtr dict;
349
350 if ((reader != NULL) && (reader->ctxt != NULL))
351 dict = reader->ctxt->dict;
352 else
353 dict = NULL;
354 if (cur == NULL) return;
355 if (cur->type == XML_NAMESPACE_DECL) {
356 xmlFreeNsList((xmlNsPtr) cur);
357 return;
358 }
359 if ((cur->type == XML_DOCUMENT_NODE) ||
360 (cur->type == XML_HTML_DOCUMENT_NODE)) {
361 xmlFreeDoc((xmlDocPtr) cur);
362 return;
363 }
364 while (cur != NULL) {
365 next = cur->next;
366 /* unroll to speed up freeing the document */
367 if (cur->type != XML_DTD_NODE) {
368
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;
374 }
375
376 if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
377 xmlDeregisterNodeDefaultValue(cur);
378
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);
390 }
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);
396
397 /*
398 * we don't free element names here they are interned now
399 */
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++;
410 } else {
411 xmlFree(cur);
412 }
413 }
414 cur = next;
415 }
416}
417
418/**
419 * xmlTextReaderFreeNode:
420 * @reader: the xmlTextReaderPtr used
421 * @cur: the node
422 *
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.
425 */
426static void
427xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur) {
428 xmlDictPtr dict;
429
430 if ((reader != NULL) && (reader->ctxt != NULL))
431 dict = reader->ctxt->dict;
432 else
433 dict = NULL;
434 if (cur->type == XML_DTD_NODE) {
435 xmlFreeDtd((xmlDtdPtr) cur);
436 return;
437 }
438 if (cur->type == XML_NAMESPACE_DECL) {
439 xmlFreeNs((xmlNsPtr) cur);
440 return;
441 }
442 if (cur->type == XML_ATTRIBUTE_NODE) {
443 xmlTextReaderFreeProp(reader, (xmlAttrPtr) cur);
444 return;
445 }
446
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;
452 }
453
454 if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
455 xmlDeregisterNodeDefaultValue(cur);
456
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);
468 }
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);
474
475 /*
476 * we don't free names here they are interned now
477 */
478 if ((cur->type != XML_TEXT_NODE) &&
479 (cur->type != XML_COMMENT_NODE))
480 DICT_FREE(cur->name);
481
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++;
489 } else {
490 xmlFree(cur);
491 }
492}
493
494/**
495 * xmlTextReaderFreeIDTable:
496 * @table: An id table
497 *
498 * Deallocate the memory used by an ID hash table.
499 */
500static void
501xmlTextReaderFreeIDTable(xmlIDTablePtr table) {
502 xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
503}
504
505/**
506 * xmlTextReaderFreeDoc:
507 * @reader: the xmlTextReaderPtr used
508 * @cur: pointer to the document
509 *
510 * Free up all the structures used by a document, tree included.
511 */
512static void
513xmlTextReaderFreeDoc(xmlTextReaderPtr reader, xmlDocPtr cur) {
514 xmlDtdPtr extSubset, intSubset;
515
516 if (cur == NULL) return;
517
518 if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
519 xmlDeregisterNodeDefaultValue((xmlNodePtr) cur);
520
521 /*
522 * Do this before freeing the children list to avoid ID lookups
523 */
524 if (cur->ids != NULL) xmlTextReaderFreeIDTable((xmlIDTablePtr) cur->ids);
525 cur->ids = NULL;
526 if (cur->refs != NULL) xmlFreeRefTable((xmlRefTablePtr) cur->refs);
527 cur->refs = NULL;
528 extSubset = cur->extSubset;
529 intSubset = cur->intSubset;
530 if (intSubset == extSubset)
531 extSubset = NULL;
532 if (extSubset != NULL) {
533 xmlUnlinkNode((xmlNodePtr) cur->extSubset);
534 cur->extSubset = NULL;
535 xmlFreeDtd(extSubset);
536 }
537 if (intSubset != NULL) {
538 xmlUnlinkNode((xmlNodePtr) cur->intSubset);
539 cur->intSubset = NULL;
540 xmlFreeDtd(intSubset);
541 }
542
543 if (cur->children != NULL) xmlTextReaderFreeNodeList(reader, cur->children);
544
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);
551
552 xmlFree(cur);
553}
554
555/************************************************************************
556 * *
557 * The reader core parser *
558 * *
559 ************************************************************************/
560#ifdef DEBUG_READER
561static void
562xmlTextReaderDebug(xmlTextReaderPtr reader) {
563 if ((reader == NULL) || (reader->ctxt == NULL)) {
564 fprintf(stderr, "xmlTextReader NULL\n");
565 return;
566 }
567 fprintf(stderr, "xmlTextReader: state %d depth %d ",
568 reader->state, reader->depth);
569 if (reader->node == NULL) {
570 fprintf(stderr, "node = NULL\n");
571 } else {
572 fprintf(stderr, "node %s\n", reader->node->name);
573 }
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");
578 } else {
579#ifdef LIBXML_DEBUG_ENABLED
580 xmlDebugDumpString(stderr,
581 &reader->input->buffer->content[reader->cur]);
582#endif
583 fprintf(stderr, "\n");
584 }
585}
586#endif
587
588/**
589 * xmlTextReaderEntPush:
590 * @reader: the xmlTextReaderPtr used
591 * @value: the entity reference node
592 *
593 * Pushes a new entity reference node on top of the entities stack
594 *
595 * Returns 0 in case of error, the index in the stack otherwise
596 */
597static int
598xmlTextReaderEntPush(xmlTextReaderPtr reader, xmlNodePtr value)
599{
600 if (reader->entMax <= 0) {
601 reader->entMax = 10;
602 reader->entTab = (xmlNodePtr *) xmlMalloc(reader->entMax *
603 sizeof(reader->entTab[0]));
604 if (reader->entTab == NULL) {
605 xmlGenericError(xmlGenericErrorContext, "xmlMalloc failed !\n");
606 return (0);
607 }
608 }
609 if (reader->entNr >= reader->entMax) {
610 reader->entMax *= 2;
611 reader->entTab =
612 (xmlNodePtr *) xmlRealloc(reader->entTab,
613 reader->entMax *
614 sizeof(reader->entTab[0]));
615 if (reader->entTab == NULL) {
616 xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
617 return (0);
618 }
619 }
620 reader->entTab[reader->entNr] = value;
621 reader->ent = value;
622 return (reader->entNr++);
623}
624
625/**
626 * xmlTextReaderEntPop:
627 * @reader: the xmlTextReaderPtr used
628 *
629 * Pops the top element entity from the entities stack
630 *
631 * Returns the entity just removed
632 */
633static xmlNodePtr
634xmlTextReaderEntPop(xmlTextReaderPtr reader)
635{
636 xmlNodePtr ret;
637
638 if (reader->entNr <= 0)
639 return (NULL);
640 reader->entNr--;
641 if (reader->entNr > 0)
642 reader->ent = reader->entTab[reader->entNr - 1];
643 else
644 reader->ent = NULL;
645 ret = reader->entTab[reader->entNr];
646 reader->entTab[reader->entNr] = NULL;
647 return (ret);
648}
649
650/**
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
655 *
656 * called when an opening tag has been processed.
657 */
658static void
659xmlTextReaderStartElement(void *ctx, const xmlChar *fullname,
660 const xmlChar **atts) {
661 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
662 xmlTextReaderPtr reader = ctxt->_private;
663
664#ifdef DEBUG_CALLBACKS
665 printf("xmlTextReaderStartElement(%s)\n", fullname);
666#endif
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;
673 }
674 if (reader != NULL)
675 reader->state = XML_TEXTREADER_ELEMENT;
676}
677
678/**
679 * xmlTextReaderEndElement:
680 * @ctx: the user data (XML parser context)
681 * @fullname: The element name, including namespace prefix
682 *
683 * called when an ending tag has been processed.
684 */
685static void
686xmlTextReaderEndElement(void *ctx, const xmlChar *fullname) {
687 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
688 xmlTextReaderPtr reader = ctxt->_private;
689
690#ifdef DEBUG_CALLBACKS
691 printf("xmlTextReaderEndElement(%s)\n", fullname);
692#endif
693 if ((reader != NULL) && (reader->endElement != NULL)) {
694 reader->endElement(ctx, fullname);
695 }
696}
697
698/**
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)
709 * attribute values.
710 *
711 * called when an opening tag has been processed.
712 */
713static void
714xmlTextReaderStartElementNs(void *ctx,
715 const xmlChar *localname,
716 const xmlChar *prefix,
717 const xmlChar *URI,
718 int nb_namespaces,
719 const xmlChar **namespaces,
720 int nb_attributes,
721 int nb_defaulted,
722 const xmlChar **attributes)
723{
724 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
725 xmlTextReaderPtr reader = ctxt->_private;
726
727#ifdef DEBUG_CALLBACKS
728 printf("xmlTextReaderStartElementNs(%s)\n", localname);
729#endif
730 if ((reader != NULL) && (reader->startElementNs != NULL)) {
731 reader->startElementNs(ctx, localname, prefix, URI, nb_namespaces,
732 namespaces, nb_attributes, nb_defaulted,
733 attributes);
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;
738 }
739 if (reader != NULL)
740 reader->state = XML_TEXTREADER_ELEMENT;
741}
742
743/**
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
749 *
750 * called when an ending tag has been processed.
751 */
752static void
753xmlTextReaderEndElementNs(void *ctx,
754 const xmlChar * localname,
755 const xmlChar * prefix,
756 const xmlChar * URI)
757{
758 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
759 xmlTextReaderPtr reader = ctxt->_private;
760
761#ifdef DEBUG_CALLBACKS
762 printf("xmlTextReaderEndElementNs(%s)\n", localname);
763#endif
764 if ((reader != NULL) && (reader->endElementNs != NULL)) {
765 reader->endElementNs(ctx, localname, prefix, URI);
766 }
767}
768
769
770/**
771 * xmlTextReaderCharacters:
772 * @ctx: the user data (XML parser context)
773 * @ch: a xmlChar string
774 * @len: the number of xmlChar
775 *
776 * receiving some chars from the parser.
777 */
778static void
779xmlTextReaderCharacters(void *ctx, const xmlChar *ch, int len)
780{
781 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
782 xmlTextReaderPtr reader = ctxt->_private;
783
784#ifdef DEBUG_CALLBACKS
785 printf("xmlTextReaderCharacters()\n");
786#endif
787 if ((reader != NULL) && (reader->characters != NULL)) {
788 reader->characters(ctx, ch, len);
789 }
790}
791
792/**
793 * xmlTextReaderCDataBlock:
794 * @ctx: the user data (XML parser context)
795 * @value: The pcdata content
796 * @len: the block length
797 *
798 * called when a pcdata block has been parsed
799 */
800static void
801xmlTextReaderCDataBlock(void *ctx, const xmlChar *ch, int len)
802{
803 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
804 xmlTextReaderPtr reader = ctxt->_private;
805
806#ifdef DEBUG_CALLBACKS
807 printf("xmlTextReaderCDataBlock()\n");
808#endif
809 if ((reader != NULL) && (reader->cdataBlock != NULL)) {
810 reader->cdataBlock(ctx, ch, len);
811 }
812}
813
814/**
815 * xmlTextReaderPushData:
816 * @reader: the xmlTextReaderPtr used
817 *
818 * Push data down the progressive parser until a significant callback
819 * got raised.
820 *
821 * Returns -1 in case of failure, 0 otherwise
822 */
823static int
824xmlTextReaderPushData(xmlTextReaderPtr reader) {
825 xmlBufPtr inbuf;
826 int val, s;
827 xmlTextReaderState oldstate;
828 int alloc;
829
830 if ((reader->input == NULL) || (reader->input->buffer == NULL))
831 return(-1);
832
833 oldstate = reader->state;
834 reader->state = XML_TEXTREADER_NONE;
835 inbuf = reader->input->buffer;
836 alloc = xmlBufGetAllocationScheme(inbuf);
837
838 while (reader->state == XML_TEXTREADER_NONE) {
839 if (xmlBufUse(inbuf) < reader->cur + CHUNK_SIZE) {
840 /*
841 * Refill the buffer unless we are at the end of the stream
842 */
843 if (reader->mode != XML_TEXTREADER_MODE_EOF) {
844 val = xmlParserInputBufferRead(reader->input, 4096);
845 if ((val == 0) &&
846 (alloc == XML_BUFFER_ALLOC_IMMUTABLE)) {
847 if (xmlBufUse(inbuf) == reader->cur) {
848 reader->mode = XML_TEXTREADER_MODE_EOF;
849 reader->state = oldstate;
850 }
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))
856 return(val);
857 } else if (val == 0) {
858 /* mark the end of the stream and process the remains */
859 reader->mode = XML_TEXTREADER_MODE_EOF;
860 break;
861 }
862
863 } else
864 break;
865 }
866 /*
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
869 */
870 if (xmlBufUse(inbuf) >= reader->cur + CHUNK_SIZE) {
871 val = xmlParseChunk(reader->ctxt,
872 (const char *) xmlBufContent(inbuf) + reader->cur,
873 CHUNK_SIZE, 0);
874 reader->cur += CHUNK_SIZE;
875 if (val != 0)
876 reader->ctxt->wellFormed = 0;
877 if (reader->ctxt->wellFormed == 0)
878 break;
879 } else {
880 s = xmlBufUse(inbuf) - reader->cur;
881 val = xmlParseChunk(reader->ctxt,
882 (const char *) xmlBufContent(inbuf) + reader->cur,
883 s, 0);
884 reader->cur += s;
885 if (val != 0)
886 reader->ctxt->wellFormed = 0;
887 break;
888 }
889 }
890
891 /*
892 * Discard the consumed input when needed and possible
893 */
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);
899 if (val >= 0) {
900 reader->cur -= val;
901 }
902 }
903 }
904 }
905
906 /*
907 * At the end of the stream signal that the work is done to the Push
908 * parser.
909 */
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,
915 s, 1);
916 reader->cur = xmlBufUse(inbuf);
917 reader->state = XML_TEXTREADER_DONE;
918 if (val != 0) {
919 if (reader->ctxt->wellFormed)
920 reader->ctxt->wellFormed = 0;
921 else
922 return(-1);
923 }
924 }
925 }
926 reader->state = oldstate;
927 if (reader->ctxt->wellFormed == 0) {
928 reader->mode = XML_TEXTREADER_MODE_EOF;
929 return(-1);
930 }
931
932 return(0);
933}
934
935#ifdef LIBXML_REGEXP_ENABLED
936/**
937 * xmlTextReaderValidatePush:
938 * @reader: the xmlTextReaderPtr used
939 *
940 * Push the current node for validation
941 */
942static void
943xmlTextReaderValidatePush(xmlTextReaderPtr reader ATTRIBUTE_UNUSED) {
944 xmlNodePtr node = reader->node;
945
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);
952 } else {
953 /* TODO use the BuildQName interface */
954 xmlChar *qname;
955
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);
961 if (qname != NULL)
962 xmlFree(qname);
963 }
964 }
965#endif /* LIBXML_VALID_ENABLED */
966#ifdef LIBXML_SCHEMAS_ENABLED
967 if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
968 (reader->rngValidCtxt != NULL)) {
969 int ret;
970
971 if (reader->rngFullNode != NULL) return;
972 ret = xmlRelaxNGValidatePushElement(reader->rngValidCtxt,
973 reader->ctxt->myDoc,
974 node);
975 if (ret == 0) {
976 /*
977 * this element requires a full tree
978 */
979 node = xmlTextReaderExpand(reader);
980 if (node == NULL) {
981printf("Expand failed !\n");
982 ret = -1;
983 } else {
984 ret = xmlRelaxNGValidateFullElement(reader->rngValidCtxt,
985 reader->ctxt->myDoc,
986 node);
987 reader->rngFullNode = node;
988 }
989 }
990 if (ret != 1)
991 reader->rngValidErrors++;
992 }
993#endif
994}
995
996/**
997 * xmlTextReaderValidateCData:
998 * @reader: the xmlTextReaderPtr used
999 * @data: pointer to the CData
1000 * @len: length of the CData block in bytes.
1001 *
1002 * Push some CData for validation
1003 */
1004static void
1005xmlTextReaderValidateCData(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,
1011 data, len);
1012 }
1013#endif /* LIBXML_VALID_ENABLED */
1014#ifdef LIBXML_SCHEMAS_ENABLED
1015 if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
1016 (reader->rngValidCtxt != NULL)) {
1017 int ret;
1018
1019 if (reader->rngFullNode != NULL) return;
1020 ret = xmlRelaxNGValidatePushCData(reader->rngValidCtxt, data, len);
1021 if (ret != 1)
1022 reader->rngValidErrors++;
1023 }
1024#endif
1025}
1026
1027/**
1028 * xmlTextReaderValidatePop:
1029 * @reader: the xmlTextReaderPtr used
1030 *
1031 * Pop the current node from validation
1032 */
1033static void
1034xmlTextReaderValidatePop(xmlTextReaderPtr reader) {
1035 xmlNodePtr node = reader->node;
1036
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);
1043 } else {
1044 /* TODO use the BuildQName interface */
1045 xmlChar *qname;
1046
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);
1052 if (qname != NULL)
1053 xmlFree(qname);
1054 }
1055 }
1056#endif /* LIBXML_VALID_ENABLED */
1057#ifdef LIBXML_SCHEMAS_ENABLED
1058 if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
1059 (reader->rngValidCtxt != NULL)) {
1060 int ret;
1061
1062 if (reader->rngFullNode != NULL) {
1063 if (node == reader->rngFullNode)
1064 reader->rngFullNode = NULL;
1065 return;
1066 }
1067 ret = xmlRelaxNGValidatePopElement(reader->rngValidCtxt,
1068 reader->ctxt->myDoc,
1069 node);
1070 if (ret != 1)
1071 reader->rngValidErrors++;
1072 }
1073#endif
1074}
1075
1076/**
1077 * xmlTextReaderValidateEntity:
1078 * @reader: the xmlTextReaderPtr used
1079 *
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
1083 */
1084static void
1085xmlTextReaderValidateEntity(xmlTextReaderPtr reader) {
1086 xmlNodePtr oldnode = reader->node;
1087 xmlNodePtr node = reader->node;
1088 xmlParserCtxtPtr ctxt = reader->ctxt;
1089
1090 do {
1091 if (node->type == XML_ENTITY_REF_NODE) {
1092 /*
1093 * Case where the underlying tree is not availble, lookup the entity
1094 * and walk it.
1095 */
1096 if ((node->children == NULL) && (ctxt->sax != NULL) &&
1097 (ctxt->sax->getEntity != NULL)) {
1098 node->children = (xmlNodePtr)
1099 ctxt->sax->getEntity(ctxt, node->name);
1100 }
1101
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;
1107 continue;
1108 } else {
1109 /*
1110 * The error has probably be raised already.
1111 */
1112 if (node == oldnode)
1113 break;
1114 node = node->next;
1115 }
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));
1124#endif
1125 }
1126
1127 /*
1128 * go to next node
1129 */
1130 if (node->children != NULL) {
1131 node = node->children;
1132 continue;
1133 } else if (node->type == XML_ELEMENT_NODE) {
1134 xmlTextReaderValidatePop(reader);
1135 }
1136 if (node->next != NULL) {
1137 node = node->next;
1138 continue;
1139 }
1140 do {
1141 node = node->parent;
1142 if (node->type == XML_ELEMENT_NODE) {
1143 xmlNodePtr tmp;
1144 if (reader->entNr == 0) {
1145 while ((tmp = node->last) != NULL) {
1146 if ((tmp->extra & NODE_IS_PRESERVED) == 0) {
1147 xmlUnlinkNode(tmp);
1148 xmlTextReaderFreeNode(reader, tmp);
1149 } else
1150 break;
1151 }
1152 }
1153 reader->node = node;
1154 xmlTextReaderValidatePop(reader);
1155 }
1156 if ((node->type == XML_ENTITY_DECL) &&
1157 (reader->ent != NULL) && (reader->ent->children == node)) {
1158 node = xmlTextReaderEntPop(reader);
1159 }
1160 if (node == oldnode)
1161 break;
1162 if (node->next != NULL) {
1163 node = node->next;
1164 break;
1165 }
1166 } while ((node != NULL) && (node != oldnode));
1167 } while ((node != NULL) && (node != oldnode));
1168 reader->node = oldnode;
1169}
1170#endif /* LIBXML_REGEXP_ENABLED */
1171
1172
1173/**
1174 * xmlTextReaderGetSuccessor:
1175 * @cur: the current node
1176 *
1177 * Get the successor of a node if available.
1178 *
1179 * Returns the successor node or NULL
1180 */
1181static xmlNodePtr
1182xmlTextReaderGetSuccessor(xmlNodePtr cur) {
1183 if (cur == NULL) return(NULL) ; /* ERROR */
1184 if (cur->next != NULL) return(cur->next) ;
1185 do {
1186 cur = cur->parent;
1187 if (cur == NULL) break;
1188 if (cur->next != NULL) return(cur->next);
1189 } while (cur != NULL);
1190 return(cur);
1191}
1192
1193/**
1194 * xmlTextReaderDoExpand:
1195 * @reader: the xmlTextReaderPtr used
1196 *
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
1199 * end of the call.
1200 *
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
1203 */
1204static int
1205xmlTextReaderDoExpand(xmlTextReaderPtr reader) {
1206 int val;
1207
1208 if ((reader == NULL) || (reader->node == NULL) || (reader->ctxt == NULL))
1209 return(-1);
1210 do {
1211 if (reader->ctxt->instate == XML_PARSER_EOF) return(1);
1212
1213 if (xmlTextReaderGetSuccessor(reader->node) != NULL)
1214 return(1);
1215 if (reader->ctxt->nodeNr < reader->depth)
1216 return(1);
1217 if (reader->mode == XML_TEXTREADER_MODE_EOF)
1218 return(1);
1219 val = xmlTextReaderPushData(reader);
1220 if (val < 0){
1221 reader->mode = XML_TEXTREADER_MODE_ERROR;
1222 return(-1);
1223 }
1224 } while(reader->mode != XML_TEXTREADER_MODE_EOF);
1225 return(1);
1226}
1227
1228/**
1229 * xmlTextReaderCollectSiblings:
1230 * @node: the first child
1231 *
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.
1235 *
1236 * Returns a string containing the content, or NULL in case of error.
1237 */
1238static xmlChar *
1239xmlTextReaderCollectSiblings(xmlNodePtr node)
1240{
1241 xmlBufferPtr buffer;
1242 xmlChar *ret;
1243
1244 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
1245 return(NULL);
1246
1247 buffer = xmlBufferCreate();
1248 if (buffer == NULL)
1249 return NULL;
1250
1251 for ( ; node != NULL; node = node->next) {
1252 switch (node->type) {
1253 case XML_TEXT_NODE:
1254 case XML_CDATA_SECTION_NODE:
1255 xmlBufferCat(buffer, node->content);
1256 break;
1257 case XML_ELEMENT_NODE: {
1258 xmlChar *tmp;
1259
1260 tmp = xmlTextReaderCollectSiblings(node->children);
1261 xmlBufferCat(buffer, tmp);
1262 xmlFree(tmp);
1263 break;
1264 }
1265 default:
1266 break;
1267 }
1268 }
1269 ret = buffer->content;
1270 buffer->content = NULL;
1271 xmlBufferFree(buffer);
1272 return(ret);
1273}
1274
1275/**
1276 * xmlTextReaderRead:
1277 * @reader: the xmlTextReaderPtr used
1278 *
1279 * Moves the position of the current instance to the next node in
1280 * the stream, exposing its properties.
1281 *
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
1284 */
1285int
1286xmlTextReaderRead(xmlTextReaderPtr reader) {
1287 int val, olddepth = 0;
1288 xmlTextReaderState oldstate = XML_TEXTREADER_START;
1289 xmlNodePtr oldnode = NULL;
1290
1291
1292 if (reader == NULL)
1293 return(-1);
1294 reader->curnode = NULL;
1295 if (reader->doc != NULL)
1296 return(xmlTextReaderReadTree(reader));
1297 if (reader->ctxt == NULL)
1298 return(-1);
1299
1300#ifdef DEBUG_READER
1301 fprintf(stderr, "\nREAD ");
1302 DUMP_READER
1303#endif
1304 if (reader->mode == XML_TEXTREADER_MODE_INITIAL) {
1305 reader->mode = XML_TEXTREADER_MODE_INTERACTIVE;
1306 /*
1307 * Initial state
1308 */
1309 do {
1310 val = xmlTextReaderPushData(reader);
1311 if (val < 0){
1312 reader->mode = XML_TEXTREADER_MODE_ERROR;
1313 reader->state = XML_TEXTREADER_ERROR;
1314 return(-1);
1315 }
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;
1322 }
1323 if (reader->node == NULL){
1324 reader->mode = XML_TEXTREADER_MODE_ERROR;
1325 reader->state = XML_TEXTREADER_ERROR;
1326 return(-1);
1327 }
1328 reader->state = XML_TEXTREADER_ELEMENT;
1329 } else {
1330 if (reader->ctxt->myDoc != NULL) {
1331 reader->node = reader->ctxt->myDoc->children;
1332 }
1333 if (reader->node == NULL)
1334 reader->node = reader->ctxt->nodeTab[0];
1335 reader->state = XML_TEXTREADER_ELEMENT;
1336 }
1337 reader->depth = 0;
1338 reader->ctxt->parseMode = XML_PARSE_READER;
1339 goto node_found;
1340 }
1341 oldstate = reader->state;
1342 olddepth = reader->ctxt->nodeNr;
1343 oldnode = reader->node;
1344
1345get_next_node:
1346 if (reader->node == NULL) {
1347 if (reader->mode == XML_TEXTREADER_MODE_EOF)
1348 return(0);
1349 else
1350 return(-1);
1351 }
1352
1353 /*
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.
1357 */
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);
1374 if (val < 0){
1375 reader->mode = XML_TEXTREADER_MODE_ERROR;
1376 reader->state = XML_TEXTREADER_ERROR;
1377 return(-1);
1378 }
1379 if (reader->node == NULL)
1380 goto node_end;
1381 }
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;
1388 reader->depth++;
1389 reader->state = XML_TEXTREADER_ELEMENT;
1390 goto node_found;
1391 }
1392 }
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)
1400#endif
1401 ) {
1402 reader->state = XML_TEXTREADER_END;
1403 goto node_found;
1404 }
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;
1415
1416 /*
1417 * Cleanup of the old node
1418 */
1419 if ((reader->preserves == 0) &&
1420#ifdef LIBXML_XINCLUDE_ENABLED
1421 (reader->in_xinclude == 0) &&
1422#endif
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) {
1428 xmlUnlinkNode(tmp);
1429 xmlTextReaderFreeNode(reader, tmp);
1430 }
1431 }
1432
1433 goto node_found;
1434 }
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;
1440 goto node_found;
1441 }
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) ||
1454#endif
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;
1459 if (val != 0)
1460 return(-1);
1461 }
1462 reader->node = NULL;
1463 reader->depth = -1;
1464
1465 /*
1466 * Cleanup of the old node
1467 */
1468 if ((oldnode != NULL) && (reader->preserves == 0) &&
1469#ifdef LIBXML_XINCLUDE_ENABLED
1470 (reader->in_xinclude == 0) &&
1471#endif
1472 (reader->entNr == 0) &&
1473 (oldnode->type != XML_DTD_NODE) &&
1474 ((oldnode->extra & NODE_IS_PRESERVED) == 0)) {
1475 xmlUnlinkNode(oldnode);
1476 xmlTextReaderFreeNode(reader, oldnode);
1477 }
1478
1479 goto node_end;
1480 }
1481 if ((reader->preserves == 0) &&
1482#ifdef LIBXML_XINCLUDE_ENABLED
1483 (reader->in_xinclude == 0) &&
1484#endif
1485 (reader->entNr == 0) &&
1486 (reader->node->last != NULL) &&
1487 ((reader->node->last->extra & NODE_IS_PRESERVED) == 0)) {
1488 xmlNodePtr tmp = reader->node->last;
1489 xmlUnlinkNode(tmp);
1490 xmlTextReaderFreeNode(reader, tmp);
1491 }
1492 reader->depth--;
1493 reader->state = XML_TEXTREADER_BACKTRACK;
1494
1495node_found:
1496 DUMP_READER
1497
1498 /*
1499 * If we are in the middle of a piece of CDATA make sure it's finished
1500 */
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)
1506 return -1;
1507 }
1508
1509#ifdef LIBXML_XINCLUDE_ENABLED
1510 /*
1511 * Handle XInclude if asked for
1512 */
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));
1522 }
1523 /*
1524 * expand that node and process it
1525 */
1526 if (xmlTextReaderExpand(reader) == NULL)
1527 return -1;
1528 xmlXIncludeProcessNode(reader->xincctxt, reader->node);
1529 }
1530 if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_START)) {
1531 reader->in_xinclude++;
1532 goto get_next_node;
1533 }
1534 if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_END)) {
1535 reader->in_xinclude--;
1536 goto get_next_node;
1537 }
1538#endif
1539 /*
1540 * Handle entities enter and exit when in entity replacement mode
1541 */
1542 if ((reader->node != NULL) &&
1543 (reader->node->type == XML_ENTITY_REF_NODE) &&
1544 (reader->ctxt != NULL) && (reader->ctxt->replaceEntities == 1)) {
1545 /*
1546 * Case where the underlying tree is not availble, lookup the entity
1547 * and walk it.
1548 */
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);
1553 }
1554
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;
1560 }
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 */
1567 }
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);
1572 reader->depth++;
1573 goto get_next_node;
1574 }
1575#ifdef LIBXML_REGEXP_ENABLED
1576 if ((reader->validate != XML_TEXTREADER_NOT_VALIDATE) && (reader->node != NULL)) {
1577 xmlNodePtr node = reader->node;
1578
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));
1587 }
1588 }
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)) {
1593 int i;
1594 for (i = 0;i < reader->patternNr;i++) {
1595 if (xmlPatternMatch(reader->patternTab[i], reader->node) == 1) {
1596 xmlTextReaderPreserve(reader);
1597 break;
1598 }
1599 }
1600 }
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);
1607 }
1608#endif /* LIBXML_PATTERN_ENABLED */
1609 return(1);
1610node_end:
1611 reader->state = XML_TEXTREADER_DONE;
1612 return(0);
1613}
1614
1615/**
1616 * xmlTextReaderReadState:
1617 * @reader: the xmlTextReaderPtr used
1618 *
1619 * Gets the read state of the reader.
1620 *
1621 * Returns the state value, or -1 in case of error
1622 */
1623int
1624xmlTextReaderReadState(xmlTextReaderPtr reader) {
1625 if (reader == NULL)
1626 return(-1);
1627 return(reader->mode);
1628}
1629
1630/**
1631 * xmlTextReaderExpand:
1632 * @reader: the xmlTextReaderPtr used
1633 *
1634 * Reads the contents of the current node and the full subtree. It then makes
1635 * the subtree available until the next xmlTextReaderRead() call
1636 *
1637 * Returns a node pointer valid until the next xmlTextReaderRead() call
1638 * or NULL in case of error.
1639 */
1640xmlNodePtr
1641xmlTextReaderExpand(xmlTextReaderPtr reader) {
1642 if ((reader == NULL) || (reader->node == NULL))
1643 return(NULL);
1644 if (reader->doc != NULL)
1645 return(reader->node);
1646 if (reader->ctxt == NULL)
1647 return(NULL);
1648 if (xmlTextReaderDoExpand(reader) < 0)
1649 return(NULL);
1650 return(reader->node);
1651}
1652
1653/**
1654 * xmlTextReaderNext:
1655 * @reader: the xmlTextReaderPtr used
1656 *
1657 * Skip to the node following the current one in document order while
1658 * avoiding the subtree if any.
1659 *
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
1662 */
1663int
1664xmlTextReaderNext(xmlTextReaderPtr reader) {
1665 int ret;
1666 xmlNodePtr cur;
1667
1668 if (reader == NULL)
1669 return(-1);
1670 if (reader->doc != NULL)
1671 return(xmlTextReaderNextTree(reader));
1672 cur = reader->node;
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));
1679 do {
1680 ret = xmlTextReaderRead(reader);
1681 if (ret != 1)
1682 return(ret);
1683 } while (reader->node != cur);
1684 return(xmlTextReaderRead(reader));
1685}
1686
1687#ifdef LIBXML_WRITER_ENABLED
1688/**
1689 * xmlTextReaderReadInnerXml:
1690 * @reader: the xmlTextReaderPtr used
1691 *
1692 * Reads the contents of the current node, including child nodes and markup.
1693 *
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.
1697 */
1698xmlChar *
1699xmlTextReaderReadInnerXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
1700{
1701 xmlChar *resbuf;
1702 xmlNodePtr node, cur_node;
1703 xmlBufferPtr buff, buff2;
1704 xmlDocPtr doc;
1705
1706 if (xmlTextReaderExpand(reader) == NULL) {
1707 return NULL;
1708 }
1709 doc = reader->doc;
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) {
1716 xmlFreeNode(node);
1717 xmlBufferFree(buff2);
1718 xmlBufferFree(buff);
1719 return NULL;
1720 }
1721 xmlBufferCat(buff, buff2->content);
1722 xmlFreeNode(node);
1723 xmlBufferFree(buff2);
1724 }
1725 resbuf = buff->content;
1726 buff->content = NULL;
1727
1728 xmlBufferFree(buff);
1729 return resbuf;
1730}
1731#endif
1732
1733#ifdef LIBXML_WRITER_ENABLED
1734/**
1735 * xmlTextReaderReadOuterXml:
1736 * @reader: the xmlTextReaderPtr used
1737 *
1738 * Reads the contents of the current node, including child nodes and markup.
1739 *
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
1742 * by the caller.
1743 */
1744xmlChar *
1745xmlTextReaderReadOuterXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
1746{
1747 xmlChar *resbuf;
1748 xmlNodePtr node;
1749 xmlBufferPtr buff;
1750 xmlDocPtr doc;
1751
1752 node = reader->node;
1753 doc = reader->doc;
1754 if (xmlTextReaderExpand(reader) == NULL) {
1755 return NULL;
1756 }
1757 if (node->type == XML_DTD_NODE) {
1758 node = (xmlNodePtr) xmlCopyDtd((xmlDtdPtr) node);
1759 } else {
1760 node = xmlDocCopyNode(node, doc, 1);
1761 }
1762 buff = xmlBufferCreate();
1763 if (xmlNodeDump(buff, doc, node, 0, 0) == -1) {
1764 xmlFreeNode(node);
1765 xmlBufferFree(buff);
1766 return NULL;
1767 }
1768
1769 resbuf = buff->content;
1770 buff->content = NULL;
1771
1772 xmlFreeNode(node);
1773 xmlBufferFree(buff);
1774 return resbuf;
1775}
1776#endif
1777
1778/**
1779 * xmlTextReaderReadString:
1780 * @reader: the xmlTextReaderPtr used
1781 *
1782 * Reads the contents of an element or a text node as a string.
1783 *
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.
1787 */
1788xmlChar *
1789xmlTextReaderReadString(xmlTextReaderPtr reader)
1790{
1791 xmlNodePtr node;
1792
1793 if ((reader == NULL) || (reader->node == NULL))
1794 return(NULL);
1795
1796 node = (reader->curnode != NULL) ? reader->curnode : reader->node;
1797 switch (node->type) {
1798 case XML_TEXT_NODE:
1799 if (node->content != NULL)
1800 return(xmlStrdup(node->content));
1801 break;
1802 case XML_ELEMENT_NODE:
1803 if (xmlTextReaderDoExpand(reader) != -1) {
1804 return xmlTextReaderCollectSiblings(node->children);
1805 }
1806 break;
1807 case XML_ATTRIBUTE_NODE:
1808 TODO
1809 break;
1810 default:
1811 break;
1812 }
1813 return(NULL);
1814}
1815
1816#if 0
1817/**
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
1822 * begin to write.
1823 * @len: the number of bytes to write.
1824 *
1825 * Reads and decodes the Base64 encoded contents of an element and
1826 * stores the result in a byte buffer.
1827 *
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.
1830 */
1831int
1832xmlTextReaderReadBase64(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))
1837 return(-1);
1838 if (reader->ctxt->wellFormed != 1)
1839 return(-1);
1840
1841 if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
1842 return(0);
1843 TODO
1844 return(0);
1845}
1846
1847/**
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
1852 * begin to write.
1853 * @len: the number of bytes to write.
1854 *
1855 * Reads and decodes the BinHex encoded contents of an element and
1856 * stores the result in a byte buffer.
1857 *
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.
1860 */
1861int
1862xmlTextReaderReadBinHex(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))
1867 return(-1);
1868 if (reader->ctxt->wellFormed != 1)
1869 return(-1);
1870
1871 if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
1872 return(0);
1873 TODO
1874 return(0);
1875}
1876#endif
1877
1878/************************************************************************
1879 * *
1880 * Operating on a preparsed tree *
1881 * *
1882 ************************************************************************/
1883static int
1884xmlTextReaderNextTree(xmlTextReaderPtr reader)
1885{
1886 if (reader == NULL)
1887 return(-1);
1888
1889 if (reader->state == XML_TEXTREADER_END)
1890 return(0);
1891
1892 if (reader->node == NULL) {
1893 if (reader->doc->children == NULL) {
1894 reader->state = XML_TEXTREADER_END;
1895 return(0);
1896 }
1897
1898 reader->node = reader->doc->children;
1899 reader->state = XML_TEXTREADER_START;
1900 return(1);
1901 }
1902
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;
1910 return(1);
1911 }
1912
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);
1920 }
1921 }
1922
1923 if (reader->node->next != 0) {
1924 reader->node = reader->node->next;
1925 reader->state = XML_TEXTREADER_START;
1926 return(1);
1927 }
1928
1929 if (reader->node->parent != 0) {
1930 if (reader->node->parent->type == XML_DOCUMENT_NODE) {
1931 reader->state = XML_TEXTREADER_END;
1932 return(0);
1933 }
1934
1935 reader->node = reader->node->parent;
1936 reader->depth--;
1937 reader->state = XML_TEXTREADER_BACKTRACK;
1938 /* Repeat process to move to sibling of parent node if present */
1939 xmlTextReaderNextTree(reader);
1940 }
1941
1942 reader->state = XML_TEXTREADER_END;
1943
1944 return(1);
1945}
1946
1947/**
1948 * xmlTextReaderReadTree:
1949 * @reader: the xmlTextReaderPtr used
1950 *
1951 * Moves the position of the current instance to the next node in
1952 * the stream, exposing its properties.
1953 *
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
1956 */
1957static int
1958xmlTextReaderReadTree(xmlTextReaderPtr reader) {
1959 if (reader->state == XML_TEXTREADER_END)
1960 return(0);
1961
1962next_node:
1963 if (reader->node == NULL) {
1964 if (reader->doc->children == NULL) {
1965 reader->state = XML_TEXTREADER_END;
1966 return(0);
1967 }
1968
1969 reader->node = reader->doc->children;
1970 reader->state = XML_TEXTREADER_START;
1971 goto found_node;
1972 }
1973
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;
1980 reader->depth++;
1981 reader->state = XML_TEXTREADER_START;
1982 goto found_node;
1983 }
1984
1985 if (reader->node->type == XML_ATTRIBUTE_NODE) {
1986 reader->state = XML_TEXTREADER_BACKTRACK;
1987 goto found_node;
1988 }
1989 }
1990
1991 if (reader->node->next != NULL) {
1992 reader->node = reader->node->next;
1993 reader->state = XML_TEXTREADER_START;
1994 goto found_node;
1995 }
1996
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;
2001 return(0);
2002 }
2003
2004 reader->node = reader->node->parent;
2005 reader->depth--;
2006 reader->state = XML_TEXTREADER_BACKTRACK;
2007 goto found_node;
2008 }
2009
2010 reader->state = XML_TEXTREADER_END;
2011
2012found_node:
2013 if ((reader->node->type == XML_XINCLUDE_START) ||
2014 (reader->node->type == XML_XINCLUDE_END))
2015 goto next_node;
2016
2017 return(1);
2018}
2019
2020/**
2021 * xmlTextReaderNextSibling:
2022 * @reader: the xmlTextReaderPtr used
2023 *
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
2027 *
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
2030 */
2031int
2032xmlTextReaderNextSibling(xmlTextReaderPtr reader) {
2033 if (reader == NULL)
2034 return(-1);
2035 if (reader->doc == NULL) {
2036 /* TODO */
2037 return(-1);
2038 }
2039
2040 if (reader->state == XML_TEXTREADER_END)
2041 return(0);
2042
2043 if (reader->node == NULL)
2044 return(xmlTextReaderNextTree(reader));
2045
2046 if (reader->node->next != NULL) {
2047 reader->node = reader->node->next;
2048 reader->state = XML_TEXTREADER_START;
2049 return(1);
2050 }
2051
2052 return(0);
2053}
2054
2055/************************************************************************
2056 * *
2057 * Constructor and destructors *
2058 * *
2059 ************************************************************************/
2060/**
2061 * xmlNewTextReader:
2062 * @input: the xmlParserInputBufferPtr used to read data
2063 * @URI: the URI information for the source if available
2064 *
2065 * Create an xmlTextReader structure fed with @input
2066 *
2067 * Returns the new xmlTextReaderPtr or NULL in case of error
2068 */
2069xmlTextReaderPtr
2070xmlNewTextReader(xmlParserInputBufferPtr input, const char *URI) {
2071 xmlTextReaderPtr ret;
2072
2073 if (input == NULL)
2074 return(NULL);
2075 ret = xmlMalloc(sizeof(xmlTextReader));
2076 if (ret == NULL) {
2077 xmlGenericError(xmlGenericErrorContext,
2078 "xmlNewTextReader : malloc failed\n");
2079 return(NULL);
2080 }
2081 memset(ret, 0, sizeof(xmlTextReader));
2082 ret->doc = NULL;
2083 ret->entTab = NULL;
2084 ret->entMax = 0;
2085 ret->entNr = 0;
2086 ret->input = input;
2087 ret->buffer = xmlBufCreateSize(100);
2088 if (ret->buffer == NULL) {
2089 xmlFree(ret);
2090 xmlGenericError(xmlGenericErrorContext,
2091 "xmlNewTextReader : malloc failed\n");
2092 return(NULL);
2093 }
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);
2100 xmlFree(ret);
2101 xmlGenericError(xmlGenericErrorContext,
2102 "xmlNewTextReader : malloc failed\n");
2103 return(NULL);
2104 }
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
2118 } else {
2119 ret->startElementNs = NULL;
2120 ret->endElementNs = NULL;
2121 }
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;
2128
2129 ret->mode = XML_TEXTREADER_MODE_INITIAL;
2130 ret->node = NULL;
2131 ret->curnode = NULL;
2132 if (xmlBufUse(ret->input->buffer) < 4) {
2133 xmlParserInputBufferRead(input, 4);
2134 }
2135 if (xmlBufUse(ret->input->buffer) >= 4) {
2136 ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL,
2137 (const char *) xmlBufContent(ret->input->buffer),
2138 4, URI);
2139 ret->base = 0;
2140 ret->cur = 4;
2141 } else {
2142 ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL, NULL, 0, URI);
2143 ret->base = 0;
2144 ret->cur = 0;
2145 }
2146
2147 if (ret->ctxt == NULL) {
2148 xmlGenericError(xmlGenericErrorContext,
2149 "xmlNewTextReader : malloc failed\n");
2150 xmlBufFree(ret->buffer);
2151 xmlFree(ret->sax);
2152 xmlFree(ret);
2153 return(NULL);
2154 }
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;
2160 /*
2161 * use the parser dictionary to allocate all elements and attributes names
2162 */
2163 ret->ctxt->docdict = 1;
2164 ret->dict = ret->ctxt->dict;
2165#ifdef LIBXML_XINCLUDE_ENABLED
2166 ret->xinclude = 0;
2167#endif
2168#ifdef LIBXML_PATTERN_ENABLED
2169 ret->patternMax = 0;
2170 ret->patternTab = NULL;
2171#endif
2172 return(ret);
2173}
2174
2175/**
2176 * xmlNewTextReaderFilename:
2177 * @URI: the URI of the resource to process
2178 *
2179 * Create an xmlTextReader structure fed with the resource at @URI
2180 *
2181 * Returns the new xmlTextReaderPtr or NULL in case of error
2182 */
2183xmlTextReaderPtr
2184xmlNewTextReaderFilename(const char *URI) {
2185 xmlParserInputBufferPtr input;
2186 xmlTextReaderPtr ret;
2187 char *directory = NULL;
2188
2189 input = xmlParserInputBufferCreateFilename(URI, XML_CHAR_ENCODING_NONE);
2190 if (input == NULL)
2191 return(NULL);
2192 ret = xmlNewTextReader(input, URI);
2193 if (ret == NULL) {
2194 xmlFreeParserInputBuffer(input);
2195 return(NULL);
2196 }
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)
2203 xmlFree(directory);
2204 return(ret);
2205}
2206
2207/**
2208 * xmlFreeTextReader:
2209 * @reader: the xmlTextReaderPtr
2210 *
2211 * Deallocate all the resources associated to the reader
2212 */
2213void
2214xmlFreeTextReader(xmlTextReaderPtr reader) {
2215 if (reader == NULL)
2216 return;
2217#ifdef LIBXML_SCHEMAS_ENABLED
2218 if (reader->rngSchemas != NULL) {
2219 xmlRelaxNGFree(reader->rngSchemas);
2220 reader->rngSchemas = NULL;
2221 }
2222 if (reader->rngValidCtxt != NULL) {
2223 if (! reader->rngPreserveCtxt)
2224 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
2225 reader->rngValidCtxt = NULL;
2226 }
2227 if (reader->xsdPlug != NULL) {
2228 xmlSchemaSAXUnplug(reader->xsdPlug);
2229 reader->xsdPlug = NULL;
2230 }
2231 if (reader->xsdValidCtxt != NULL) {
2232 if (! reader->xsdPreserveCtxt)
2233 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
2234 reader->xsdValidCtxt = NULL;
2235 }
2236 if (reader->xsdSchemas != NULL) {
2237 xmlSchemaFree(reader->xsdSchemas);
2238 reader->xsdSchemas = NULL;
2239 }
2240#endif
2241#ifdef LIBXML_XINCLUDE_ENABLED
2242 if (reader->xincctxt != NULL)
2243 xmlXIncludeFreeContext(reader->xincctxt);
2244#endif
2245#ifdef LIBXML_PATTERN_ENABLED
2246 if (reader->patternTab != NULL) {
2247 int i;
2248 for (i = 0;i < reader->patternNr;i++) {
2249 if (reader->patternTab[i] != NULL)
2250 xmlFreePattern(reader->patternTab[i]);
2251 }
2252 xmlFree(reader->patternTab);
2253 }
2254#endif
2255 if (reader->faketext != NULL) {
2256 xmlFreeNode(reader->faketext);
2257 }
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;
2265 }
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;
2271 }
2272 if (reader->allocs & XML_TEXTREADER_CTXT)
2273 xmlFreeParserCtxt(reader->ctxt);
2274 }
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);
2285 xmlFree(reader);
2286}
2287
2288/************************************************************************
2289 * *
2290 * Methods for XmlTextReader *
2291 * *
2292 ************************************************************************/
2293/**
2294 * xmlTextReaderClose:
2295 * @reader: the xmlTextReaderPtr used
2296 *
2297 * This method releases any resources allocated by the current instance
2298 * changes the state to Closed and close any underlying input.
2299 *
2300 * Returns 0 or -1 in case of error
2301 */
2302int
2303xmlTextReaderClose(xmlTextReaderPtr reader) {
2304 if (reader == NULL)
2305 return(-1);
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;
2315 }
2316 }
2317 if ((reader->input != NULL) && (reader->allocs & XML_TEXTREADER_INPUT)) {
2318 xmlFreeParserInputBuffer(reader->input);
2319 reader->allocs -= XML_TEXTREADER_INPUT;
2320 }
2321 return(0);
2322}
2323
2324/**
2325 * xmlTextReaderGetAttributeNo:
2326 * @reader: the xmlTextReaderPtr used
2327 * @no: the zero-based index of the attribute relative to the containing element
2328 *
2329 * Provides the value of the attribute with the specified index relative
2330 * to the containing element.
2331 *
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.
2334 */
2335xmlChar *
2336xmlTextReaderGetAttributeNo(xmlTextReaderPtr reader, int no) {
2337 xmlChar *ret;
2338 int i;
2339 xmlAttrPtr cur;
2340 xmlNsPtr ns;
2341
2342 if (reader == NULL)
2343 return(NULL);
2344 if (reader->node == NULL)
2345 return(NULL);
2346 if (reader->curnode != NULL)
2347 return(NULL);
2348 /* TODO: handle the xmlDecl */
2349 if (reader->node->type != XML_ELEMENT_NODE)
2350 return(NULL);
2351
2352 ns = reader->node->nsDef;
2353 for (i = 0;(i < no) && (ns != NULL);i++) {
2354 ns = ns->next;
2355 }
2356 if (ns != NULL)
2357 return(xmlStrdup(ns->href));
2358
2359 cur = reader->node->properties;
2360 if (cur == NULL)
2361 return(NULL);
2362 for (;i < no;i++) {
2363 cur = cur->next;
2364 if (cur == NULL)
2365 return(NULL);
2366 }
2367 /* TODO walk the DTD if present */
2368
2369 ret = xmlNodeListGetString(reader->node->doc, cur->children, 1);
2370 if (ret == NULL) return(xmlStrdup((xmlChar *)""));
2371 return(ret);
2372}
2373
2374/**
2375 * xmlTextReaderGetAttribute:
2376 * @reader: the xmlTextReaderPtr used
2377 * @name: the qualified name of the attribute.
2378 *
2379 * Provides the value of the attribute with the specified qualified name.
2380 *
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.
2383 */
2384xmlChar *
2385xmlTextReaderGetAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
2386 xmlChar *prefix = NULL;
2387 xmlChar *localname;
2388 xmlNsPtr ns;
2389 xmlChar *ret = NULL;
2390
2391 if ((reader == NULL) || (name == NULL))
2392 return(NULL);
2393 if (reader->node == NULL)
2394 return(NULL);
2395 if (reader->curnode != NULL)
2396 return(NULL);
2397
2398 /* TODO: handle the xmlDecl */
2399 if (reader->node->type != XML_ELEMENT_NODE)
2400 return(NULL);
2401
2402 localname = xmlSplitQName2(name, &prefix);
2403 if (localname == NULL) {
2404 /*
2405 * Namespace default decl
2406 */
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));
2412 }
2413 ns = ns->next;
2414 }
2415 return NULL;
2416 }
2417 return(xmlGetNoNsProp(reader->node, name));
2418 }
2419
2420 /*
2421 * Namespace default decl
2422 */
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);
2428 break;
2429 }
2430 ns = ns->next;
2431 }
2432 } else {
2433 ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
2434 if (ns != NULL)
2435 ret = xmlGetNsProp(reader->node, localname, ns->href);
2436 }
2437
2438 xmlFree(localname);
2439 if (prefix != NULL)
2440 xmlFree(prefix);
2441 return(ret);
2442}
2443
2444
2445/**
2446 * xmlTextReaderGetAttributeNs:
2447 * @reader: the xmlTextReaderPtr used
2448 * @localName: the local name of the attribute.
2449 * @namespaceURI: the namespace URI of the attribute.
2450 *
2451 * Provides the value of the specified attribute
2452 *
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.
2455 */
2456xmlChar *
2457xmlTextReaderGetAttributeNs(xmlTextReaderPtr reader, const xmlChar *localName,
2458 const xmlChar *namespaceURI) {
2459 xmlChar *prefix = NULL;
2460 xmlNsPtr ns;
2461
2462 if ((reader == NULL) || (localName == NULL))
2463 return(NULL);
2464 if (reader->node == NULL)
2465 return(NULL);
2466 if (reader->curnode != NULL)
2467 return(NULL);
2468
2469 /* TODO: handle the xmlDecl */
2470 if (reader->node->type != XML_ELEMENT_NODE)
2471 return(NULL);
2472
2473 if (xmlStrEqual(namespaceURI, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
2474 if (! xmlStrEqual(localName, BAD_CAST "xmlns")) {
2475 prefix = BAD_CAST localName;
2476 }
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);
2482 }
2483 ns = ns->next;
2484 }
2485 return NULL;
2486 }
2487
2488 return(xmlGetNsProp(reader->node, localName, namespaceURI));
2489}
2490
2491/**
2492 * xmlTextReaderGetRemainder:
2493 * @reader: the xmlTextReaderPtr used
2494 *
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.
2498 *
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.
2502 *
2503 * Returns the xmlParserInputBufferPtr attached to the XML or NULL
2504 * in case of error.
2505 */
2506xmlParserInputBufferPtr
2507xmlTextReaderGetRemainder(xmlTextReaderPtr reader) {
2508 xmlParserInputBufferPtr ret = NULL;
2509
2510 if (reader == NULL)
2511 return(NULL);
2512 if (reader->node == NULL)
2513 return(NULL);
2514
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;
2524 }
2525 }
2526 if (reader->allocs & XML_TEXTREADER_INPUT) {
2527 ret = reader->input;
2528 reader->input = NULL;
2529 reader->allocs -= XML_TEXTREADER_INPUT;
2530 } else {
2531 /*
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.
2536 */
2537 TODO
2538 return(NULL);
2539 }
2540 return(ret);
2541}
2542
2543/**
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
2548 *
2549 * Resolves a namespace prefix in the scope of the current element.
2550 *
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.
2553 */
2554xmlChar *
2555xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, const xmlChar *prefix) {
2556 xmlNsPtr ns;
2557
2558 if (reader == NULL)
2559 return(NULL);
2560 if (reader->node == NULL)
2561 return(NULL);
2562
2563 ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
2564 if (ns == NULL)
2565 return(NULL);
2566 return(xmlStrdup(ns->href));
2567}
2568
2569/**
2570 * xmlTextReaderMoveToAttributeNo:
2571 * @reader: the xmlTextReaderPtr used
2572 * @no: the zero-based index of the attribute relative to the containing
2573 * element.
2574 *
2575 * Moves the position of the current instance to the attribute with
2576 * the specified index relative to the containing element.
2577 *
2578 * Returns 1 in case of success, -1 in case of error, 0 if not found
2579 */
2580int
2581xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, int no) {
2582 int i;
2583 xmlAttrPtr cur;
2584 xmlNsPtr ns;
2585
2586 if (reader == NULL)
2587 return(-1);
2588 if (reader->node == NULL)
2589 return(-1);
2590 /* TODO: handle the xmlDecl */
2591 if (reader->node->type != XML_ELEMENT_NODE)
2592 return(-1);
2593
2594 reader->curnode = NULL;
2595
2596 ns = reader->node->nsDef;
2597 for (i = 0;(i < no) && (ns != NULL);i++) {
2598 ns = ns->next;
2599 }
2600 if (ns != NULL) {
2601 reader->curnode = (xmlNodePtr) ns;
2602 return(1);
2603 }
2604
2605 cur = reader->node->properties;
2606 if (cur == NULL)
2607 return(0);
2608 for (;i < no;i++) {
2609 cur = cur->next;
2610 if (cur == NULL)
2611 return(0);
2612 }
2613 /* TODO walk the DTD if present */
2614
2615 reader->curnode = (xmlNodePtr) cur;
2616 return(1);
2617}
2618
2619/**
2620 * xmlTextReaderMoveToAttribute:
2621 * @reader: the xmlTextReaderPtr used
2622 * @name: the qualified name of the attribute.
2623 *
2624 * Moves the position of the current instance to the attribute with
2625 * the specified qualified name.
2626 *
2627 * Returns 1 in case of success, -1 in case of error, 0 if not found
2628 */
2629int
2630xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
2631 xmlChar *prefix = NULL;
2632 xmlChar *localname;
2633 xmlNsPtr ns;
2634 xmlAttrPtr prop;
2635
2636 if ((reader == NULL) || (name == NULL))
2637 return(-1);
2638 if (reader->node == NULL)
2639 return(-1);
2640
2641 /* TODO: handle the xmlDecl */
2642 if (reader->node->type != XML_ELEMENT_NODE)
2643 return(0);
2644
2645 localname = xmlSplitQName2(name, &prefix);
2646 if (localname == NULL) {
2647 /*
2648 * Namespace default decl
2649 */
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;
2655 return(1);
2656 }
2657 ns = ns->next;
2658 }
2659 return(0);
2660 }
2661
2662 prop = reader->node->properties;
2663 while (prop != NULL) {
2664 /*
2665 * One need to have
2666 * - same attribute names
2667 * - and the attribute carrying that namespace
2668 */
2669 if ((xmlStrEqual(prop->name, name)) &&
2670 ((prop->ns == NULL) || (prop->ns->prefix == NULL))) {
2671 reader->curnode = (xmlNodePtr) prop;
2672 return(1);
2673 }
2674 prop = prop->next;
2675 }
2676 return(0);
2677 }
2678
2679 /*
2680 * Namespace default decl
2681 */
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;
2687 goto found;
2688 }
2689 ns = ns->next;
2690 }
2691 goto not_found;
2692 }
2693 prop = reader->node->properties;
2694 while (prop != NULL) {
2695 /*
2696 * One need to have
2697 * - same attribute names
2698 * - and the attribute carrying that namespace
2699 */
2700 if ((xmlStrEqual(prop->name, localname)) &&
2701 (prop->ns != NULL) && (xmlStrEqual(prop->ns->prefix, prefix))) {
2702 reader->curnode = (xmlNodePtr) prop;
2703 goto found;
2704 }
2705 prop = prop->next;
2706 }
2707not_found:
2708 if (localname != NULL)
2709 xmlFree(localname);
2710 if (prefix != NULL)
2711 xmlFree(prefix);
2712 return(0);
2713
2714found:
2715 if (localname != NULL)
2716 xmlFree(localname);
2717 if (prefix != NULL)
2718 xmlFree(prefix);
2719 return(1);
2720}
2721
2722/**
2723 * xmlTextReaderMoveToAttributeNs:
2724 * @reader: the xmlTextReaderPtr used
2725 * @localName: the local name of the attribute.
2726 * @namespaceURI: the namespace URI of the attribute.
2727 *
2728 * Moves the position of the current instance to the attribute with the
2729 * specified local name and namespace URI.
2730 *
2731 * Returns 1 in case of success, -1 in case of error, 0 if not found
2732 */
2733int
2734xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
2735 const xmlChar *localName, const xmlChar *namespaceURI) {
2736 xmlAttrPtr prop;
2737 xmlNodePtr node;
2738 xmlNsPtr ns;
2739 xmlChar *prefix = NULL;
2740
2741 if ((reader == NULL) || (localName == NULL) || (namespaceURI == NULL))
2742 return(-1);
2743 if (reader->node == NULL)
2744 return(-1);
2745 if (reader->node->type != XML_ELEMENT_NODE)
2746 return(0);
2747 node = reader->node;
2748
2749 if (xmlStrEqual(namespaceURI, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
2750 if (! xmlStrEqual(localName, BAD_CAST "xmlns")) {
2751 prefix = BAD_CAST localName;
2752 }
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;
2758 return(1);
2759 }
2760 ns = ns->next;
2761 }
2762 return(0);
2763 }
2764
2765 prop = node->properties;
2766 while (prop != NULL) {
2767 /*
2768 * One need to have
2769 * - same attribute names
2770 * - and the attribute carrying that namespace
2771 */
2772 if (xmlStrEqual(prop->name, localName) &&
2773 ((prop->ns != NULL) &&
2774 (xmlStrEqual(prop->ns->href, namespaceURI)))) {
2775 reader->curnode = (xmlNodePtr) prop;
2776 return(1);
2777 }
2778 prop = prop->next;
2779 }
2780 return(0);
2781}
2782
2783/**
2784 * xmlTextReaderMoveToFirstAttribute:
2785 * @reader: the xmlTextReaderPtr used
2786 *
2787 * Moves the position of the current instance to the first attribute
2788 * associated with the current node.
2789 *
2790 * Returns 1 in case of success, -1 in case of error, 0 if not found
2791 */
2792int
2793xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader) {
2794 if (reader == NULL)
2795 return(-1);
2796 if (reader->node == NULL)
2797 return(-1);
2798 if (reader->node->type != XML_ELEMENT_NODE)
2799 return(0);
2800
2801 if (reader->node->nsDef != NULL) {
2802 reader->curnode = (xmlNodePtr) reader->node->nsDef;
2803 return(1);
2804 }
2805 if (reader->node->properties != NULL) {
2806 reader->curnode = (xmlNodePtr) reader->node->properties;
2807 return(1);
2808 }
2809 return(0);
2810}
2811
2812/**
2813 * xmlTextReaderMoveToNextAttribute:
2814 * @reader: the xmlTextReaderPtr used
2815 *
2816 * Moves the position of the current instance to the next attribute
2817 * associated with the current node.
2818 *
2819 * Returns 1 in case of success, -1 in case of error, 0 if not found
2820 */
2821int
2822xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader) {
2823 if (reader == NULL)
2824 return(-1);
2825 if (reader->node == NULL)
2826 return(-1);
2827 if (reader->node->type != XML_ELEMENT_NODE)
2828 return(0);
2829 if (reader->curnode == NULL)
2830 return(xmlTextReaderMoveToFirstAttribute(reader));
2831
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;
2836 return(1);
2837 }
2838 if (reader->node->properties != NULL) {
2839 reader->curnode = (xmlNodePtr) reader->node->properties;
2840 return(1);
2841 }
2842 return(0);
2843 } else if ((reader->curnode->type == XML_ATTRIBUTE_NODE) &&
2844 (reader->curnode->next != NULL)) {
2845 reader->curnode = reader->curnode->next;
2846 return(1);
2847 }
2848 return(0);
2849}
2850
2851/**
2852 * xmlTextReaderMoveToElement:
2853 * @reader: the xmlTextReaderPtr used
2854 *
2855 * Moves the position of the current instance to the node that
2856 * contains the current Attribute node.
2857 *
2858 * Returns 1 in case of success, -1 in case of error, 0 if not moved
2859 */
2860int
2861xmlTextReaderMoveToElement(xmlTextReaderPtr reader) {
2862 if (reader == NULL)
2863 return(-1);
2864 if (reader->node == NULL)
2865 return(-1);
2866 if (reader->node->type != XML_ELEMENT_NODE)
2867 return(0);
2868 if (reader->curnode != NULL) {
2869 reader->curnode = NULL;
2870 return(1);
2871 }
2872 return(0);
2873}
2874
2875/**
2876 * xmlTextReaderReadAttributeValue:
2877 * @reader: the xmlTextReaderPtr used
2878 *
2879 * Parses an attribute value into one or more Text and EntityReference nodes.
2880 *
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
2883 * in case of error.
2884 */
2885int
2886xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader) {
2887 if (reader == NULL)
2888 return(-1);
2889 if (reader->node == NULL)
2890 return(-1);
2891 if (reader->curnode == NULL)
2892 return(0);
2893 if (reader->curnode->type == XML_ATTRIBUTE_NODE) {
2894 if (reader->curnode->children == NULL)
2895 return(0);
2896 reader->curnode = reader->curnode->children;
2897 } else if (reader->curnode->type == XML_NAMESPACE_DECL) {
2898 xmlNsPtr ns = (xmlNsPtr) reader->curnode;
2899
2900 if (reader->faketext == NULL) {
2901 reader->faketext = xmlNewDocText(reader->node->doc,
2902 ns->href);
2903 } else {
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);
2909 }
2910 reader->curnode = reader->faketext;
2911 } else {
2912 if (reader->curnode->next == NULL)
2913 return(0);
2914 reader->curnode = reader->curnode->next;
2915 }
2916 return(1);
2917}
2918
2919/**
2920 * xmlTextReaderConstEncoding:
2921 * @reader: the xmlTextReaderPtr used
2922 *
2923 * Determine the encoding of the document being read.
2924 *
2925 * Returns a string containing the encoding of the document or NULL in
2926 * case of error. The string is deallocated with the reader.
2927 */
2928const xmlChar *
2929xmlTextReaderConstEncoding(xmlTextReaderPtr reader) {
2930 xmlDocPtr doc = NULL;
2931 if (reader == NULL)
2932 return(NULL);
2933 if (reader->doc != NULL)
2934 doc = reader->doc;
2935 else if (reader->ctxt != NULL)
2936 doc = reader->ctxt->myDoc;
2937 if (doc == NULL)
2938 return(NULL);
2939
2940 if (doc->encoding == NULL)
2941 return(NULL);
2942 else
2943 return(CONSTSTR(doc->encoding));
2944}
2945
2946
2947/************************************************************************
2948 * *
2949 * Acces API to the current node *
2950 * *
2951 ************************************************************************/
2952/**
2953 * xmlTextReaderAttributeCount:
2954 * @reader: the xmlTextReaderPtr used
2955 *
2956 * Provides the number of attributes of the current node
2957 *
2958 * Returns 0 i no attributes, -1 in case of error or the attribute count
2959 */
2960int
2961xmlTextReaderAttributeCount(xmlTextReaderPtr reader) {
2962 int ret;
2963 xmlAttrPtr attr;
2964 xmlNsPtr ns;
2965 xmlNodePtr node;
2966
2967 if (reader == NULL)
2968 return(-1);
2969 if (reader->node == NULL)
2970 return(0);
2971
2972 if (reader->curnode != NULL)
2973 node = reader->curnode;
2974 else
2975 node = reader->node;
2976
2977 if (node->type != XML_ELEMENT_NODE)
2978 return(0);
2979 if ((reader->state == XML_TEXTREADER_END) ||
2980 (reader->state == XML_TEXTREADER_BACKTRACK))
2981 return(0);
2982 ret = 0;
2983 attr = node->properties;
2984 while (attr != NULL) {
2985 ret++;
2986 attr = attr->next;
2987 }
2988 ns = node->nsDef;
2989 while (ns != NULL) {
2990 ret++;
2991 ns = ns->next;
2992 }
2993 return(ret);
2994}
2995
2996/**
2997 * xmlTextReaderNodeType:
2998 * @reader: the xmlTextReaderPtr used
2999 *
3000 * Get the node type of the current node
3001 * Reference:
3002 * http://www.gnu.org/software/dotgnu/pnetlib-doc/System/Xml/XmlNodeType.html
3003 *
3004 * Returns the xmlNodeType of the current node or -1 in case of error
3005 */
3006int
3007xmlTextReaderNodeType(xmlTextReaderPtr reader) {
3008 xmlNodePtr node;
3009
3010 if (reader == NULL)
3011 return(-1);
3012 if (reader->node == NULL)
3013 return(XML_READER_TYPE_NONE);
3014 if (reader->curnode != NULL)
3015 node = reader->curnode;
3016 else
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);
3027 case XML_TEXT_NODE:
3028 if (xmlIsBlankNode(reader->node)) {
3029 if (xmlNodeGetSpacePreserve(reader->node))
3030 return(XML_READER_TYPE_SIGNIFICANT_WHITESPACE);
3031 else
3032 return(XML_READER_TYPE_WHITESPACE);
3033 } else {
3034 return(XML_READER_TYPE_TEXT);
3035 }
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);
3042 case XML_PI_NODE:
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:
3050#endif
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:
3057 case XML_DTD_NODE:
3058 return(XML_READER_TYPE_DOCUMENT_TYPE);
3059
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);
3066 }
3067 return(-1);
3068}
3069
3070/**
3071 * xmlTextReaderIsEmptyElement:
3072 * @reader: the xmlTextReaderPtr used
3073 *
3074 * Check if the current node is empty
3075 *
3076 * Returns 1 if empty, 0 if not and -1 in case of error
3077 */
3078int
3079xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader) {
3080 if ((reader == NULL) || (reader->node == NULL))
3081 return(-1);
3082 if (reader->node->type != XML_ELEMENT_NODE)
3083 return(0);
3084 if (reader->curnode != NULL)
3085 return(0);
3086 if (reader->node->children != NULL)
3087 return(0);
3088 if (reader->state == XML_TEXTREADER_END)
3089 return(0);
3090 if (reader->doc != NULL)
3091 return(1);
3092#ifdef LIBXML_XINCLUDE_ENABLED
3093 if (reader->in_xinclude > 0)
3094 return(1);
3095#endif
3096 return((reader->node->extra & NODE_IS_EMPTY) != 0);
3097}
3098
3099/**
3100 * xmlTextReaderLocalName:
3101 * @reader: the xmlTextReaderPtr used
3102 *
3103 * The local name of the node.
3104 *
3105 * Returns the local name or NULL if not available,
3106 * if non NULL it need to be freed by the caller.
3107 */
3108xmlChar *
3109xmlTextReaderLocalName(xmlTextReaderPtr reader) {
3110 xmlNodePtr node;
3111 if ((reader == NULL) || (reader->node == NULL))
3112 return(NULL);
3113 if (reader->curnode != NULL)
3114 node = reader->curnode;
3115 else
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"));
3121 else
3122 return(xmlStrdup(ns->prefix));
3123 }
3124 if ((node->type != XML_ELEMENT_NODE) &&
3125 (node->type != XML_ATTRIBUTE_NODE))
3126 return(xmlTextReaderName(reader));
3127 return(xmlStrdup(node->name));
3128}
3129
3130/**
3131 * xmlTextReaderConstLocalName:
3132 * @reader: the xmlTextReaderPtr used
3133 *
3134 * The local name of the node.
3135 *
3136 * Returns the local name or NULL if not available, the
3137 * string will be deallocated with the reader.
3138 */
3139const xmlChar *
3140xmlTextReaderConstLocalName(xmlTextReaderPtr reader) {
3141 xmlNodePtr node;
3142 if ((reader == NULL) || (reader->node == NULL))
3143 return(NULL);
3144 if (reader->curnode != NULL)
3145 node = reader->curnode;
3146 else
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"));
3152 else
3153 return(ns->prefix);
3154 }
3155 if ((node->type != XML_ELEMENT_NODE) &&
3156 (node->type != XML_ATTRIBUTE_NODE))
3157 return(xmlTextReaderConstName(reader));
3158 return(node->name);
3159}
3160
3161/**
3162 * xmlTextReaderName:
3163 * @reader: the xmlTextReaderPtr used
3164 *
3165 * The qualified name of the node, equal to Prefix :LocalName.
3166 *
3167 * Returns the local name or NULL if not available,
3168 * if non NULL it need to be freed by the caller.
3169 */
3170xmlChar *
3171xmlTextReaderName(xmlTextReaderPtr reader) {
3172 xmlNodePtr node;
3173 xmlChar *ret;
3174
3175 if ((reader == NULL) || (reader->node == NULL))
3176 return(NULL);
3177 if (reader->curnode != NULL)
3178 node = reader->curnode;
3179 else
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));
3187
3188 ret = xmlStrdup(node->ns->prefix);
3189 ret = xmlStrcat(ret, BAD_CAST ":");
3190 ret = xmlStrcat(ret, node->name);
3191 return(ret);
3192 case XML_TEXT_NODE:
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));
3199 case XML_PI_NODE:
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:
3207#endif
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:
3214 case XML_DTD_NODE:
3215 return(xmlStrdup(node->name));
3216 case XML_NAMESPACE_DECL: {
3217 xmlNsPtr ns = (xmlNsPtr) node;
3218
3219 ret = xmlStrdup(BAD_CAST "xmlns");
3220 if (ns->prefix == NULL)
3221 return(ret);
3222 ret = xmlStrcat(ret, BAD_CAST ":");
3223 ret = xmlStrcat(ret, ns->prefix);
3224 return(ret);
3225 }
3226
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:
3232 return(NULL);
3233 }
3234 return(NULL);
3235}
3236
3237/**
3238 * xmlTextReaderConstName:
3239 * @reader: the xmlTextReaderPtr used
3240 *
3241 * The qualified name of the node, equal to Prefix :LocalName.
3242 *
3243 * Returns the local name or NULL if not available, the string is
3244 * deallocated with the reader.
3245 */
3246const xmlChar *
3247xmlTextReaderConstName(xmlTextReaderPtr reader) {
3248 xmlNodePtr node;
3249
3250 if ((reader == NULL) || (reader->node == NULL))
3251 return(NULL);
3252 if (reader->curnode != NULL)
3253 node = reader->curnode;
3254 else
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))
3261 return(node->name);
3262 return(CONSTQSTR(node->ns->prefix, node->name));
3263 case XML_TEXT_NODE:
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));
3270 case XML_PI_NODE:
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:
3278#endif
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:
3285 case XML_DTD_NODE:
3286 return(CONSTSTR(node->name));
3287 case XML_NAMESPACE_DECL: {
3288 xmlNsPtr ns = (xmlNsPtr) node;
3289
3290 if (ns->prefix == NULL)
3291 return(CONSTSTR(BAD_CAST "xmlns"));
3292 return(CONSTQSTR(BAD_CAST "xmlns", ns->prefix));
3293 }
3294
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:
3300 return(NULL);
3301 }
3302 return(NULL);
3303}
3304
3305/**
3306 * xmlTextReaderPrefix:
3307 * @reader: the xmlTextReaderPtr used
3308 *
3309 * A shorthand reference to the namespace associated with the node.
3310 *
3311 * Returns the prefix or NULL if not available,
3312 * if non NULL it need to be freed by the caller.
3313 */
3314xmlChar *
3315xmlTextReaderPrefix(xmlTextReaderPtr reader) {
3316 xmlNodePtr node;
3317 if ((reader == NULL) || (reader->node == NULL))
3318 return(NULL);
3319 if (reader->curnode != NULL)
3320 node = reader->curnode;
3321 else
3322 node = reader->node;
3323 if (node->type == XML_NAMESPACE_DECL) {
3324 xmlNsPtr ns = (xmlNsPtr) node;
3325 if (ns->prefix == NULL)
3326 return(NULL);
3327 return(xmlStrdup(BAD_CAST "xmlns"));
3328 }
3329 if ((node->type != XML_ELEMENT_NODE) &&
3330 (node->type != XML_ATTRIBUTE_NODE))
3331 return(NULL);
3332 if ((node->ns != NULL) && (node->ns->prefix != NULL))
3333 return(xmlStrdup(node->ns->prefix));
3334 return(NULL);
3335}
3336
3337/**
3338 * xmlTextReaderConstPrefix:
3339 * @reader: the xmlTextReaderPtr used
3340 *
3341 * A shorthand reference to the namespace associated with the node.
3342 *
3343 * Returns the prefix or NULL if not available, the string is deallocated
3344 * with the reader.
3345 */
3346const xmlChar *
3347xmlTextReaderConstPrefix(xmlTextReaderPtr reader) {
3348 xmlNodePtr node;
3349 if ((reader == NULL) || (reader->node == NULL))
3350 return(NULL);
3351 if (reader->curnode != NULL)
3352 node = reader->curnode;
3353 else
3354 node = reader->node;
3355 if (node->type == XML_NAMESPACE_DECL) {
3356 xmlNsPtr ns = (xmlNsPtr) node;
3357 if (ns->prefix == NULL)
3358 return(NULL);
3359 return(CONSTSTR(BAD_CAST "xmlns"));
3360 }
3361 if ((node->type != XML_ELEMENT_NODE) &&
3362 (node->type != XML_ATTRIBUTE_NODE))
3363 return(NULL);
3364 if ((node->ns != NULL) && (node->ns->prefix != NULL))
3365 return(CONSTSTR(node->ns->prefix));
3366 return(NULL);
3367}
3368
3369/**
3370 * xmlTextReaderNamespaceUri:
3371 * @reader: the xmlTextReaderPtr used
3372 *
3373 * The URI defining the namespace associated with the node.
3374 *
3375 * Returns the namespace URI or NULL if not available,
3376 * if non NULL it need to be freed by the caller.
3377 */
3378xmlChar *
3379xmlTextReaderNamespaceUri(xmlTextReaderPtr reader) {
3380 xmlNodePtr node;
3381 if ((reader == NULL) || (reader->node == NULL))
3382 return(NULL);
3383 if (reader->curnode != NULL)
3384 node = reader->curnode;
3385 else
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))
3391 return(NULL);
3392 if (node->ns != NULL)
3393 return(xmlStrdup(node->ns->href));
3394 return(NULL);
3395}
3396
3397/**
3398 * xmlTextReaderConstNamespaceUri:
3399 * @reader: the xmlTextReaderPtr used
3400 *
3401 * The URI defining the namespace associated with the node.
3402 *
3403 * Returns the namespace URI or NULL if not available, the string
3404 * will be deallocated with the reader
3405 */
3406const xmlChar *
3407xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader) {
3408 xmlNodePtr node;
3409 if ((reader == NULL) || (reader->node == NULL))
3410 return(NULL);
3411 if (reader->curnode != NULL)
3412 node = reader->curnode;
3413 else
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))
3419 return(NULL);
3420 if (node->ns != NULL)
3421 return(CONSTSTR(node->ns->href));
3422 return(NULL);
3423}
3424
3425/**
3426 * xmlTextReaderBaseUri:
3427 * @reader: the xmlTextReaderPtr used
3428 *
3429 * The base URI of the node.
3430 *
3431 * Returns the base URI or NULL if not available,
3432 * if non NULL it need to be freed by the caller.
3433 */
3434xmlChar *
3435xmlTextReaderBaseUri(xmlTextReaderPtr reader) {
3436 if ((reader == NULL) || (reader->node == NULL))
3437 return(NULL);
3438 return(xmlNodeGetBase(NULL, reader->node));
3439}
3440
3441/**
3442 * xmlTextReaderConstBaseUri:
3443 * @reader: the xmlTextReaderPtr used
3444 *
3445 * The base URI of the node.
3446 *
3447 * Returns the base URI or NULL if not available, the string
3448 * will be deallocated with the reader
3449 */
3450const xmlChar *
3451xmlTextReaderConstBaseUri(xmlTextReaderPtr reader) {
3452 xmlChar *tmp;
3453 const xmlChar *ret;
3454
3455 if ((reader == NULL) || (reader->node == NULL))
3456 return(NULL);
3457 tmp = xmlNodeGetBase(NULL, reader->node);
3458 if (tmp == NULL)
3459 return(NULL);
3460 ret = CONSTSTR(tmp);
3461 xmlFree(tmp);
3462 return(ret);
3463}
3464
3465/**
3466 * xmlTextReaderDepth:
3467 * @reader: the xmlTextReaderPtr used
3468 *
3469 * The depth of the node in the tree.
3470 *
3471 * Returns the depth or -1 in case of error
3472 */
3473int
3474xmlTextReaderDepth(xmlTextReaderPtr reader) {
3475 if (reader == NULL)
3476 return(-1);
3477 if (reader->node == NULL)
3478 return(0);
3479
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);
3485 }
3486 return(reader->depth);
3487}
3488
3489/**
3490 * xmlTextReaderHasAttributes:
3491 * @reader: the xmlTextReaderPtr used
3492 *
3493 * Whether the node has attributes.
3494 *
3495 * Returns 1 if true, 0 if false, and -1 in case or error
3496 */
3497int
3498xmlTextReaderHasAttributes(xmlTextReaderPtr reader) {
3499 xmlNodePtr node;
3500 if (reader == NULL)
3501 return(-1);
3502 if (reader->node == NULL)
3503 return(0);
3504 if (reader->curnode != NULL)
3505 node = reader->curnode;
3506 else
3507 node = reader->node;
3508
3509 if ((node->type == XML_ELEMENT_NODE) &&
3510 ((node->properties != NULL) || (node->nsDef != NULL)))
3511 return(1);
3512 /* TODO: handle the xmlDecl */
3513 return(0);
3514}
3515
3516/**
3517 * xmlTextReaderHasValue:
3518 * @reader: the xmlTextReaderPtr used
3519 *
3520 * Whether the node can have a text value.
3521 *
3522 * Returns 1 if true, 0 if false, and -1 in case or error
3523 */
3524int
3525xmlTextReaderHasValue(xmlTextReaderPtr reader) {
3526 xmlNodePtr node;
3527 if (reader == NULL)
3528 return(-1);
3529 if (reader->node == NULL)
3530 return(0);
3531 if (reader->curnode != NULL)
3532 node = reader->curnode;
3533 else
3534 node = reader->node;
3535
3536 switch (node->type) {
3537 case XML_ATTRIBUTE_NODE:
3538 case XML_TEXT_NODE:
3539 case XML_CDATA_SECTION_NODE:
3540 case XML_PI_NODE:
3541 case XML_COMMENT_NODE:
3542 case XML_NAMESPACE_DECL:
3543 return(1);
3544 default:
3545 break;
3546 }
3547 return(0);
3548}
3549
3550/**
3551 * xmlTextReaderValue:
3552 * @reader: the xmlTextReaderPtr used
3553 *
3554 * Provides the text value of the node if present
3555 *
3556 * Returns the string or NULL if not available. The result must be deallocated
3557 * with xmlFree()
3558 */
3559xmlChar *
3560xmlTextReaderValue(xmlTextReaderPtr reader) {
3561 xmlNodePtr node;
3562 if (reader == NULL)
3563 return(NULL);
3564 if (reader->node == NULL)
3565 return(NULL);
3566 if (reader->curnode != NULL)
3567 node = reader->curnode;
3568 else
3569 node = reader->node;
3570
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;
3576
3577 if (attr->parent != NULL)
3578 return (xmlNodeListGetString
3579 (attr->parent->doc, attr->children, 1));
3580 else
3581 return (xmlNodeListGetString(NULL, attr->children, 1));
3582 break;
3583 }
3584 case XML_TEXT_NODE:
3585 case XML_CDATA_SECTION_NODE:
3586 case XML_PI_NODE:
3587 case XML_COMMENT_NODE:
3588 if (node->content != NULL)
3589 return (xmlStrdup(node->content));
3590 default:
3591 break;
3592 }
3593 return(NULL);
3594}
3595
3596/**
3597 * xmlTextReaderConstValue:
3598 * @reader: the xmlTextReaderPtr used
3599 *
3600 * Provides the text value of the node if present
3601 *
3602 * Returns the string or NULL if not available. The result will be
3603 * deallocated on the next Read() operation.
3604 */
3605const xmlChar *
3606xmlTextReaderConstValue(xmlTextReaderPtr reader) {
3607 xmlNodePtr node;
3608 if (reader == NULL)
3609 return(NULL);
3610 if (reader->node == NULL)
3611 return(NULL);
3612 if (reader->curnode != NULL)
3613 node = reader->curnode;
3614 else
3615 node = reader->node;
3616
3617 switch (node->type) {
3618 case XML_NAMESPACE_DECL:
3619 return(((xmlNsPtr) node)->href);
3620 case XML_ATTRIBUTE_NODE:{
3621 xmlAttrPtr attr = (xmlAttrPtr) node;
3622 const xmlChar *ret;
3623
3624 if ((attr->children != NULL) &&
3625 (attr->children->type == XML_TEXT_NODE) &&
3626 (attr->children->next == NULL))
3627 return(attr->children->content);
3628 else {
3629 if (reader->buffer == NULL) {
3630 reader->buffer = xmlBufCreateSize(100);
3631 if (reader->buffer == NULL) {
3632 xmlGenericError(xmlGenericErrorContext,
3633 "xmlTextReaderSetup : malloc failed\n");
3634 return (NULL);
3635 }
3636 xmlBufSetAllocationScheme(reader->buffer,
3637 XML_BUFFER_ALLOC_BOUNDED);
3638 } else
3639 xmlBufEmpty(reader->buffer);
3640 xmlBufGetNodeContent(reader->buffer, node);
3641 ret = xmlBufContent(reader->buffer);
3642 if (ret == NULL) {
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);
3648 ret = BAD_CAST "";
3649 }
3650 return(ret);
3651 }
3652 break;
3653 }
3654 case XML_TEXT_NODE:
3655 case XML_CDATA_SECTION_NODE:
3656 case XML_PI_NODE:
3657 case XML_COMMENT_NODE:
3658 return(node->content);
3659 default:
3660 break;
3661 }
3662 return(NULL);
3663}
3664
3665/**
3666 * xmlTextReaderIsDefault:
3667 * @reader: the xmlTextReaderPtr used
3668 *
3669 * Whether an Attribute node was generated from the default value
3670 * defined in the DTD or schema.
3671 *
3672 * Returns 0 if not defaulted, 1 if defaulted, and -1 in case of error
3673 */
3674int
3675xmlTextReaderIsDefault(xmlTextReaderPtr reader) {
3676 if (reader == NULL)
3677 return(-1);
3678 return(0);
3679}
3680
3681/**
3682 * xmlTextReaderQuoteChar:
3683 * @reader: the xmlTextReaderPtr used
3684 *
3685 * The quotation mark character used to enclose the value of an attribute.
3686 *
3687 * Returns " or ' and -1 in case of error
3688 */
3689int
3690xmlTextReaderQuoteChar(xmlTextReaderPtr reader) {
3691 if (reader == NULL)
3692 return(-1);
3693 /* TODO maybe lookup the attribute value for " first */
3694 return((int) '"');
3695}
3696
3697/**
3698 * xmlTextReaderXmlLang:
3699 * @reader: the xmlTextReaderPtr used
3700 *
3701 * The xml:lang scope within which the node resides.
3702 *
3703 * Returns the xml:lang value or NULL if none exists.,
3704 * if non NULL it need to be freed by the caller.
3705 */
3706xmlChar *
3707xmlTextReaderXmlLang(xmlTextReaderPtr reader) {
3708 if (reader == NULL)
3709 return(NULL);
3710 if (reader->node == NULL)
3711 return(NULL);
3712 return(xmlNodeGetLang(reader->node));
3713}
3714
3715/**
3716 * xmlTextReaderConstXmlLang:
3717 * @reader: the xmlTextReaderPtr used
3718 *
3719 * The xml:lang scope within which the node resides.
3720 *
3721 * Returns the xml:lang value or NULL if none exists.
3722 */
3723const xmlChar *
3724xmlTextReaderConstXmlLang(xmlTextReaderPtr reader) {
3725 xmlChar *tmp;
3726 const xmlChar *ret;
3727
3728 if (reader == NULL)
3729 return(NULL);
3730 if (reader->node == NULL)
3731 return(NULL);
3732 tmp = xmlNodeGetLang(reader->node);
3733 if (tmp == NULL)
3734 return(NULL);
3735 ret = CONSTSTR(tmp);
3736 xmlFree(tmp);
3737 return(ret);
3738}
3739
3740/**
3741 * xmlTextReaderConstString:
3742 * @reader: the xmlTextReaderPtr used
3743 * @str: the string to intern.
3744 *
3745 * Get an interned string from the reader, allows for example to
3746 * speedup string name comparisons
3747 *
3748 * Returns an interned copy of the string or NULL in case of error. The
3749 * string will be deallocated with the reader.
3750 */
3751const xmlChar *
3752xmlTextReaderConstString(xmlTextReaderPtr reader, const xmlChar *str) {
3753 if (reader == NULL)
3754 return(NULL);
3755 return(CONSTSTR(str));
3756}
3757
3758/**
3759 * xmlTextReaderNormalization:
3760 * @reader: the xmlTextReaderPtr used
3761 *
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 &#0; is of course not
3766 * supported either.
3767 *
3768 * Returns 1 or -1 in case of error.
3769 */
3770int
3771xmlTextReaderNormalization(xmlTextReaderPtr reader) {
3772 if (reader == NULL)
3773 return(-1);
3774 return(1);
3775}
3776
3777/************************************************************************
3778 * *
3779 * Extensions to the base APIs *
3780 * *
3781 ************************************************************************/
3782
3783/**
3784 * xmlTextReaderSetParserProp:
3785 * @reader: the xmlTextReaderPtr used
3786 * @prop: the xmlParserProperties to set
3787 * @value: usually 0 or 1 to (de)activate it
3788 *
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.
3792 *
3793 * Returns 0 if the call was successful, or -1 in case of error
3794 */
3795int
3796xmlTextReaderSetParserProp(xmlTextReaderPtr reader, int prop, int value) {
3797 xmlParserProperties p = (xmlParserProperties) prop;
3798 xmlParserCtxtPtr ctxt;
3799
3800 if ((reader == NULL) || (reader->ctxt == NULL))
3801 return(-1);
3802 ctxt = reader->ctxt;
3803
3804 switch (p) {
3805 case XML_PARSER_LOADDTD:
3806 if (value != 0) {
3807 if (ctxt->loadsubset == 0) {
3808 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
3809 return(-1);
3810 ctxt->loadsubset = XML_DETECT_IDS;
3811 }
3812 } else {
3813 ctxt->loadsubset = 0;
3814 }
3815 return(0);
3816 case XML_PARSER_DEFAULTATTRS:
3817 if (value != 0) {
3818 ctxt->loadsubset |= XML_COMPLETE_ATTRS;
3819 } else {
3820 if (ctxt->loadsubset & XML_COMPLETE_ATTRS)
3821 ctxt->loadsubset -= XML_COMPLETE_ATTRS;
3822 }
3823 return(0);
3824 case XML_PARSER_VALIDATE:
3825 if (value != 0) {
3826 ctxt->validate = 1;
3827 reader->validate = XML_TEXTREADER_VALIDATE_DTD;
3828 } else {
3829 ctxt->validate = 0;
3830 }
3831 return(0);
3832 case XML_PARSER_SUBST_ENTITIES:
3833 if (value != 0) {
3834 ctxt->replaceEntities = 1;
3835 } else {
3836 ctxt->replaceEntities = 0;
3837 }
3838 return(0);
3839 }
3840 return(-1);
3841}
3842
3843/**
3844 * xmlTextReaderGetParserProp:
3845 * @reader: the xmlTextReaderPtr used
3846 * @prop: the xmlParserProperties to get
3847 *
3848 * Read the parser internal property.
3849 *
3850 * Returns the value, usually 0 or 1, or -1 in case of error.
3851 */
3852int
3853xmlTextReaderGetParserProp(xmlTextReaderPtr reader, int prop) {
3854 xmlParserProperties p = (xmlParserProperties) prop;
3855 xmlParserCtxtPtr ctxt;
3856
3857 if ((reader == NULL) || (reader->ctxt == NULL))
3858 return(-1);
3859 ctxt = reader->ctxt;
3860
3861 switch (p) {
3862 case XML_PARSER_LOADDTD:
3863 if ((ctxt->loadsubset != 0) || (ctxt->validate != 0))
3864 return(1);
3865 return(0);
3866 case XML_PARSER_DEFAULTATTRS:
3867 if (ctxt->loadsubset & XML_COMPLETE_ATTRS)
3868 return(1);
3869 return(0);
3870 case XML_PARSER_VALIDATE:
3871 return(reader->validate);
3872 case XML_PARSER_SUBST_ENTITIES:
3873 return(ctxt->replaceEntities);
3874 }
3875 return(-1);
3876}
3877
3878
3879/**
3880 * xmlTextReaderGetParserLineNumber:
3881 * @reader: the user data (XML reader context)
3882 *
3883 * Provide the line number of the current parsing point.
3884 *
3885 * Returns an int or 0 if not available
3886 */
3887int
3888xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader)
3889{
3890 if ((reader == NULL) || (reader->ctxt == NULL) ||
3891 (reader->ctxt->input == NULL)) {
3892 return (0);
3893 }
3894 return (reader->ctxt->input->line);
3895}
3896
3897/**
3898 * xmlTextReaderGetParserColumnNumber:
3899 * @reader: the user data (XML reader context)
3900 *
3901 * Provide the column number of the current parsing point.
3902 *
3903 * Returns an int or 0 if not available
3904 */
3905int
3906xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader)
3907{
3908 if ((reader == NULL) || (reader->ctxt == NULL) ||
3909 (reader->ctxt->input == NULL)) {
3910 return (0);
3911 }
3912 return (reader->ctxt->input->col);
3913}
3914
3915/**
3916 * xmlTextReaderCurrentNode:
3917 * @reader: the xmlTextReaderPtr used
3918 *
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.
3922 *
3923 * Returns the xmlNodePtr or NULL in case of error.
3924 */
3925xmlNodePtr
3926xmlTextReaderCurrentNode(xmlTextReaderPtr reader) {
3927 if (reader == NULL)
3928 return(NULL);
3929
3930 if (reader->curnode != NULL)
3931 return(reader->curnode);
3932 return(reader->node);
3933}
3934
3935/**
3936 * xmlTextReaderPreserve:
3937 * @reader: the xmlTextReaderPtr used
3938 *
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
3942 *
3943 * Returns the xmlNodePtr or NULL in case of error.
3944 */
3945xmlNodePtr
3946xmlTextReaderPreserve(xmlTextReaderPtr reader) {
3947 xmlNodePtr cur, parent;
3948
3949 if (reader == NULL)
3950 return(NULL);
3951
3952 if (reader->curnode != NULL)
3953 cur = reader->curnode;
3954 else
3955 cur = reader->node;
3956 if (cur == NULL)
3957 return(NULL);
3958
3959 if ((cur->type != XML_DOCUMENT_NODE) && (cur->type != XML_DTD_NODE)) {
3960 cur->extra |= NODE_IS_PRESERVED;
3961 cur->extra |= NODE_IS_SPRESERVED;
3962 }
3963 reader->preserves++;
3964
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;
3970 }
3971 return(cur);
3972}
3973
3974#ifdef LIBXML_PATTERN_ENABLED
3975/**
3976 * xmlTextReaderPreservePattern:
3977 * @reader: the xmlTextReaderPtr used
3978 * @pattern: an XPath subset pattern
3979 * @namespaces: the prefix definitions, array of [URI, prefix] or NULL
3980 *
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
3984 *
3985 * Returns a positive number in case of success and -1 in case of error
3986 */
3987int
3988xmlTextReaderPreservePattern(xmlTextReaderPtr reader, const xmlChar *pattern,
3989 const xmlChar **namespaces)
3990{
3991 xmlPatternPtr comp;
3992
3993 if ((reader == NULL) || (pattern == NULL))
3994 return(-1);
3995
3996 comp = xmlPatterncompile(pattern, reader->dict, 0, namespaces);
3997 if (comp == NULL)
3998 return(-1);
3999
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");
4006 return (-1);
4007 }
4008 }
4009 if (reader->patternNr >= reader->patternMax) {
4010 xmlPatternPtr *tmp;
4011 reader->patternMax *= 2;
4012 tmp = (xmlPatternPtr *) xmlRealloc(reader->patternTab,
4013 reader->patternMax *
4014 sizeof(reader->patternTab[0]));
4015 if (tmp == NULL) {
4016 xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
4017 reader->patternMax /= 2;
4018 return (-1);
4019 }
4020 reader->patternTab = tmp;
4021 }
4022 reader->patternTab[reader->patternNr] = comp;
4023 return(reader->patternNr++);
4024}
4025#endif
4026
4027/**
4028 * xmlTextReaderCurrentDoc:
4029 * @reader: the xmlTextReaderPtr used
4030 *
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.
4036 *
4037 * Returns the xmlDocPtr or NULL in case of error.
4038 */
4039xmlDocPtr
4040xmlTextReaderCurrentDoc(xmlTextReaderPtr reader) {
4041 if (reader == NULL)
4042 return(NULL);
4043 if (reader->doc != NULL)
4044 return(reader->doc);
4045 if ((reader->ctxt == NULL) || (reader->ctxt->myDoc == NULL))
4046 return(NULL);
4047
4048 reader->preserve = 1;
4049 return(reader->ctxt->myDoc);
4050}
4051
4052#ifdef LIBXML_SCHEMAS_ENABLED
4053static char *xmlTextReaderBuildMessage(const char *msg, va_list ap) LIBXML_ATTR_FORMAT(1,0);
4054
4055static void XMLCDECL
4056xmlTextReaderValidityError(void *ctxt, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
4057
4058static void XMLCDECL
4059xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
4060
4061static void XMLCDECL
4062xmlTextReaderValidityErrorRelay(void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
4063
4064static void XMLCDECL
4065xmlTextReaderValidityWarningRelay(void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
4066
4067static void XMLCDECL
4068xmlTextReaderValidityErrorRelay(void *ctx, const char *msg, ...)
4069{
4070 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
4071
4072 char *str;
4073
4074 va_list ap;
4075
4076 va_start(ap, msg);
4077 str = xmlTextReaderBuildMessage(msg, ap);
4078 if (!reader->errorFunc) {
4079 xmlTextReaderValidityError(ctx, "%s", str);
4080 } else {
4081 reader->errorFunc(reader->errorFuncArg, str,
4082 XML_PARSER_SEVERITY_VALIDITY_ERROR,
4083 NULL /* locator */ );
4084 }
4085 if (str != NULL)
4086 xmlFree(str);
4087 va_end(ap);
4088}
4089
4090static void XMLCDECL
4091xmlTextReaderValidityWarningRelay(void *ctx, const char *msg, ...)
4092{
4093 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
4094
4095 char *str;
4096
4097 va_list ap;
4098
4099 va_start(ap, msg);
4100 str = xmlTextReaderBuildMessage(msg, ap);
4101 if (!reader->errorFunc) {
4102 xmlTextReaderValidityWarning(ctx, "%s", str);
4103 } else {
4104 reader->errorFunc(reader->errorFuncArg, str,
4105 XML_PARSER_SEVERITY_VALIDITY_WARNING,
4106 NULL /* locator */ );
4107 }
4108 if (str != NULL)
4109 xmlFree(str);
4110 va_end(ap);
4111}
4112
4113static void
4114 xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error);
4115
4116static void
4117xmlTextReaderValidityStructuredRelay(void *userData, xmlErrorPtr error)
4118{
4119 xmlTextReaderPtr reader = (xmlTextReaderPtr) userData;
4120
4121 if (reader->sErrorFunc) {
4122 reader->sErrorFunc(reader->errorFuncArg, error);
4123 } else {
4124 xmlTextReaderStructuredError(reader, error);
4125 }
4126}
4127/**
4128 * xmlTextReaderRelaxNGSetSchema:
4129 * @reader: the xmlTextReaderPtr used
4130 * @schema: a precompiled RelaxNG schema
4131 *
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.
4137 *
4138 * Returns 0 in case the RelaxNG validation could be (des)activated and
4139 * -1 in case of error.
4140 */
4141int
4142xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, xmlRelaxNGPtr schema) {
4143 if (reader == NULL)
4144 return(-1);
4145 if (schema == NULL) {
4146 if (reader->rngSchemas != NULL) {
4147 xmlRelaxNGFree(reader->rngSchemas);
4148 reader->rngSchemas = NULL;
4149 }
4150 if (reader->rngValidCtxt != NULL) {
4151 if (! reader->rngPreserveCtxt)
4152 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4153 reader->rngValidCtxt = NULL;
4154 }
4155 reader->rngPreserveCtxt = 0;
4156 return(0);
4157 }
4158 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4159 return(-1);
4160 if (reader->rngSchemas != NULL) {
4161 xmlRelaxNGFree(reader->rngSchemas);
4162 reader->rngSchemas = NULL;
4163 }
4164 if (reader->rngValidCtxt != NULL) {
4165 if (! reader->rngPreserveCtxt)
4166 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4167 reader->rngValidCtxt = NULL;
4168 }
4169 reader->rngPreserveCtxt = 0;
4170 reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(schema);
4171 if (reader->rngValidCtxt == NULL)
4172 return(-1);
4173 if (reader->errorFunc != NULL) {
4174 xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4175 xmlTextReaderValidityErrorRelay,
4176 xmlTextReaderValidityWarningRelay,
4177 reader);
4178 }
4179 if (reader->sErrorFunc != NULL) {
4180 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4181 xmlTextReaderValidityStructuredRelay,
4182 reader);
4183 }
4184 reader->rngValidErrors = 0;
4185 reader->rngFullNode = NULL;
4186 reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4187 return(0);
4188}
4189
4190/**
4191 * xmlTextReaderLocator:
4192 * @ctx: the xmlTextReaderPtr used
4193 * @file: returned file information
4194 * @line: returned line information
4195 *
4196 * Internal locator function for the readers
4197 *
4198 * Returns 0 in case the Schema validation could be (des)activated and
4199 * -1 in case of error.
4200 */
4201static int
4202xmlTextReaderLocator(void *ctx, const char **file, unsigned long *line) {
4203 xmlTextReaderPtr reader;
4204
4205 if ((ctx == NULL) || ((file == NULL) && (line == NULL)))
4206 return(-1);
4207
4208 if (file != NULL)
4209 *file = NULL;
4210 if (line != NULL)
4211 *line = 0;
4212
4213 reader = (xmlTextReaderPtr) ctx;
4214 if ((reader->ctxt != NULL) && (reader->ctxt->input != NULL)) {
4215 if (file != NULL)
4216 *file = reader->ctxt->input->filename;
4217 if (line != NULL)
4218 *line = reader->ctxt->input->line;
4219 return(0);
4220 }
4221 if (reader->node != NULL) {
4222 long res;
4223 int ret = 0;
4224
4225 if (line != NULL) {
4226 res = xmlGetLineNo(reader->node);
4227 if (res > 0)
4228 *line = (unsigned long) res;
4229 else
4230 ret = -1;
4231 }
4232 if (file != NULL) {
4233 xmlDocPtr doc = reader->node->doc;
4234 if ((doc != NULL) && (doc->URL != NULL))
4235 *file = (const char *) doc->URL;
4236 else
4237 ret = -1;
4238 }
4239 return(ret);
4240 }
4241 return(-1);
4242}
4243
4244/**
4245 * xmlTextReaderSetSchema:
4246 * @reader: the xmlTextReaderPtr used
4247 * @schema: a precompiled Schema schema
4248 *
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.
4254 *
4255 * Returns 0 in case the Schema validation could be (des)activated and
4256 * -1 in case of error.
4257 */
4258int
4259xmlTextReaderSetSchema(xmlTextReaderPtr reader, xmlSchemaPtr schema) {
4260 if (reader == NULL)
4261 return(-1);
4262 if (schema == NULL) {
4263 if (reader->xsdPlug != NULL) {
4264 xmlSchemaSAXUnplug(reader->xsdPlug);
4265 reader->xsdPlug = NULL;
4266 }
4267 if (reader->xsdValidCtxt != NULL) {
4268 if (! reader->xsdPreserveCtxt)
4269 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4270 reader->xsdValidCtxt = NULL;
4271 }
4272 reader->xsdPreserveCtxt = 0;
4273 if (reader->xsdSchemas != NULL) {
4274 xmlSchemaFree(reader->xsdSchemas);
4275 reader->xsdSchemas = NULL;
4276 }
4277 return(0);
4278 }
4279 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4280 return(-1);
4281 if (reader->xsdPlug != NULL) {
4282 xmlSchemaSAXUnplug(reader->xsdPlug);
4283 reader->xsdPlug = NULL;
4284 }
4285 if (reader->xsdValidCtxt != NULL) {
4286 if (! reader->xsdPreserveCtxt)
4287 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4288 reader->xsdValidCtxt = NULL;
4289 }
4290 reader->xsdPreserveCtxt = 0;
4291 if (reader->xsdSchemas != NULL) {
4292 xmlSchemaFree(reader->xsdSchemas);
4293 reader->xsdSchemas = NULL;
4294 }
4295 reader->xsdValidCtxt = xmlSchemaNewValidCtxt(schema);
4296 if (reader->xsdValidCtxt == NULL) {
4297 xmlSchemaFree(reader->xsdSchemas);
4298 reader->xsdSchemas = NULL;
4299 return(-1);
4300 }
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;
4309 return(-1);
4310 }
4311 xmlSchemaValidateSetLocator(reader->xsdValidCtxt,
4312 xmlTextReaderLocator,
4313 (void *) reader);
4314
4315 if (reader->errorFunc != NULL) {
4316 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4317 xmlTextReaderValidityErrorRelay,
4318 xmlTextReaderValidityWarningRelay,
4319 reader);
4320 }
4321 if (reader->sErrorFunc != NULL) {
4322 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4323 xmlTextReaderValidityStructuredRelay,
4324 reader);
4325 }
4326 reader->xsdValidErrors = 0;
4327 reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4328 return(0);
4329}
4330
4331/**
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)
4337 *
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.
4341 *
4342 * Returns 0 in case the RelaxNG validation could be (de)activated and
4343 * -1 in case of error.
4344 */
4345static int
4346xmlTextReaderRelaxNGValidateInternal(xmlTextReaderPtr reader,
4347 const char *rng,
4348 xmlRelaxNGValidCtxtPtr ctxt,
4349 int options ATTRIBUTE_UNUSED)
4350{
4351 if (reader == NULL)
4352 return(-1);
4353
4354 if ((rng != NULL) && (ctxt != NULL))
4355 return (-1);
4356
4357 if (((rng != NULL) || (ctxt != NULL)) &&
4358 ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
4359 (reader->ctxt == NULL)))
4360 return(-1);
4361
4362 /* Cleanup previous validation stuff. */
4363 if (reader->rngValidCtxt != NULL) {
4364 if ( !reader->rngPreserveCtxt)
4365 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4366 reader->rngValidCtxt = NULL;
4367 }
4368 reader->rngPreserveCtxt = 0;
4369 if (reader->rngSchemas != NULL) {
4370 xmlRelaxNGFree(reader->rngSchemas);
4371 reader->rngSchemas = NULL;
4372 }
4373
4374 if ((rng == NULL) && (ctxt == NULL)) {
4375 /* We just want to deactivate the validation, so get out. */
4376 return(0);
4377 }
4378
4379
4380 if (rng != NULL) {
4381 xmlRelaxNGParserCtxtPtr pctxt;
4382 /* Parse the schema and create validation environment. */
4383
4384 pctxt = xmlRelaxNGNewParserCtxt(rng);
4385 if (reader->errorFunc != NULL) {
4386 xmlRelaxNGSetParserErrors(pctxt,
4387 xmlTextReaderValidityErrorRelay,
4388 xmlTextReaderValidityWarningRelay,
4389 reader);
4390 }
4391 if (reader->sErrorFunc != NULL) {
4392 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4393 xmlTextReaderValidityStructuredRelay,
4394 reader);
4395 }
4396 reader->rngSchemas = xmlRelaxNGParse(pctxt);
4397 xmlRelaxNGFreeParserCtxt(pctxt);
4398 if (reader->rngSchemas == NULL)
4399 return(-1);
4400 reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
4401 if (reader->rngValidCtxt == NULL) {
4402 xmlRelaxNGFree(reader->rngSchemas);
4403 reader->rngSchemas = NULL;
4404 return(-1);
4405 }
4406 } else {
4407 /* Use the given validation context. */
4408 reader->rngValidCtxt = ctxt;
4409 reader->rngPreserveCtxt = 1;
4410 }
4411 /*
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.
4416 */
4417 if (reader->errorFunc != NULL) {
4418 xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4419 xmlTextReaderValidityErrorRelay,
4420 xmlTextReaderValidityWarningRelay,
4421 reader);
4422 }
4423 if (reader->sErrorFunc != NULL) {
4424 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4425 xmlTextReaderValidityStructuredRelay,
4426 reader);
4427 }
4428 reader->rngValidErrors = 0;
4429 reader->rngFullNode = NULL;
4430 reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4431 return(0);
4432}
4433
4434/**
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)
4440 *
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.
4444 *
4445 * Returns 0 in case the schemas validation could be (de)activated and
4446 * -1 in case of error.
4447 */
4448static int
4449xmlTextReaderSchemaValidateInternal(xmlTextReaderPtr reader,
4450 const char *xsd,
4451 xmlSchemaValidCtxtPtr ctxt,
4452 int options ATTRIBUTE_UNUSED)
4453{
4454 if (reader == NULL)
4455 return(-1);
4456
4457 if ((xsd != NULL) && (ctxt != NULL))
4458 return(-1);
4459
4460 if (((xsd != NULL) || (ctxt != NULL)) &&
4461 ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
4462 (reader->ctxt == NULL)))
4463 return(-1);
4464
4465 /* Cleanup previous validation stuff. */
4466 if (reader->xsdPlug != NULL) {
4467 xmlSchemaSAXUnplug(reader->xsdPlug);
4468 reader->xsdPlug = NULL;
4469 }
4470 if (reader->xsdValidCtxt != NULL) {
4471 if (! reader->xsdPreserveCtxt)
4472 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4473 reader->xsdValidCtxt = NULL;
4474 }
4475 reader->xsdPreserveCtxt = 0;
4476 if (reader->xsdSchemas != NULL) {
4477 xmlSchemaFree(reader->xsdSchemas);
4478 reader->xsdSchemas = NULL;
4479 }
4480
4481 if ((xsd == NULL) && (ctxt == NULL)) {
4482 /* We just want to deactivate the validation, so get out. */
4483 return(0);
4484 }
4485
4486 if (xsd != NULL) {
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,
4494 reader);
4495 }
4496 reader->xsdSchemas = xmlSchemaParse(pctxt);
4497 xmlSchemaFreeParserCtxt(pctxt);
4498 if (reader->xsdSchemas == NULL)
4499 return(-1);
4500 reader->xsdValidCtxt = xmlSchemaNewValidCtxt(reader->xsdSchemas);
4501 if (reader->xsdValidCtxt == NULL) {
4502 xmlSchemaFree(reader->xsdSchemas);
4503 reader->xsdSchemas = NULL;
4504 return(-1);
4505 }
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;
4514 return(-1);
4515 }
4516 } else {
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;
4526 return(-1);
4527 }
4528 }
4529 xmlSchemaValidateSetLocator(reader->xsdValidCtxt,
4530 xmlTextReaderLocator,
4531 (void *) reader);
4532 /*
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.
4537 */
4538 if (reader->errorFunc != NULL) {
4539 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4540 xmlTextReaderValidityErrorRelay,
4541 xmlTextReaderValidityWarningRelay,
4542 reader);
4543 }
4544 if (reader->sErrorFunc != NULL) {
4545 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4546 xmlTextReaderValidityStructuredRelay,
4547 reader);
4548 }
4549 reader->xsdValidErrors = 0;
4550 reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4551 return(0);
4552}
4553
4554/**
4555 * xmlTextReaderSchemaValidateCtxt:
4556 * @reader: the xmlTextReaderPtr used
4557 * @ctxt: the XML Schema validation context or NULL
4558 * @options: options (not used yet)
4559 *
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.
4563 *
4564 * Returns 0 in case the schemas validation could be (de)activated and
4565 * -1 in case of error.
4566 */
4567int
4568xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader,
4569 xmlSchemaValidCtxtPtr ctxt,
4570 int options)
4571{
4572 return(xmlTextReaderSchemaValidateInternal(reader, NULL, ctxt, options));
4573}
4574
4575/**
4576 * xmlTextReaderSchemaValidate:
4577 * @reader: the xmlTextReaderPtr used
4578 * @xsd: the path to a W3C XSD schema or NULL
4579 *
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.
4583 *
4584 * Returns 0 in case the schemas validation could be (de)activated and
4585 * -1 in case of error.
4586 */
4587int
4588xmlTextReaderSchemaValidate(xmlTextReaderPtr reader, const char *xsd)
4589{
4590 return(xmlTextReaderSchemaValidateInternal(reader, xsd, NULL, 0));
4591}
4592
4593/**
4594 * xmlTextReaderRelaxNGValidateCtxt:
4595 * @reader: the xmlTextReaderPtr used
4596 * @ctxt: the RelaxNG schema validation context or NULL
4597 * @options: options (not used yet)
4598 *
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.
4602 *
4603 * Returns 0 in case the schemas validation could be (de)activated and
4604 * -1 in case of error.
4605 */
4606int
4607xmlTextReaderRelaxNGValidateCtxt(xmlTextReaderPtr reader,
4608 xmlRelaxNGValidCtxtPtr ctxt,
4609 int options)
4610{
4611 return(xmlTextReaderRelaxNGValidateInternal(reader, NULL, ctxt, options));
4612}
4613
4614/**
4615 * xmlTextReaderRelaxNGValidate:
4616 * @reader: the xmlTextReaderPtr used
4617 * @rng: the path to a RelaxNG schema or NULL
4618 *
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.
4622 *
4623 * Returns 0 in case the schemas validation could be (de)activated and
4624 * -1 in case of error.
4625 */
4626int
4627xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng)
4628{
4629 return(xmlTextReaderRelaxNGValidateInternal(reader, rng, NULL, 0));
4630}
4631
4632#endif
4633
4634/**
4635 * xmlTextReaderIsNamespaceDecl:
4636 * @reader: the xmlTextReaderPtr used
4637 *
4638 * Determine whether the current node is a namespace declaration
4639 * rather than a regular attribute.
4640 *
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
4643 * error.
4644 */
4645int
4646xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader) {
4647 xmlNodePtr node;
4648 if (reader == NULL)
4649 return(-1);
4650 if (reader->node == NULL)
4651 return(-1);
4652 if (reader->curnode != NULL)
4653 node = reader->curnode;
4654 else
4655 node = reader->node;
4656
4657 if (XML_NAMESPACE_DECL == node->type)
4658 return(1);
4659 else
4660 return(0);
4661}
4662
4663/**
4664 * xmlTextReaderConstXmlVersion:
4665 * @reader: the xmlTextReaderPtr used
4666 *
4667 * Determine the XML version of the document being read.
4668 *
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.
4671 */
4672const xmlChar *
4673xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader) {
4674 xmlDocPtr doc = NULL;
4675 if (reader == NULL)
4676 return(NULL);
4677 if (reader->doc != NULL)
4678 doc = reader->doc;
4679 else if (reader->ctxt != NULL)
4680 doc = reader->ctxt->myDoc;
4681 if (doc == NULL)
4682 return(NULL);
4683
4684 if (doc->version == NULL)
4685 return(NULL);
4686 else
4687 return(CONSTSTR(doc->version));
4688}
4689
4690/**
4691 * xmlTextReaderStandalone:
4692 * @reader: the xmlTextReaderPtr used
4693 *
4694 * Determine the standalone status of the document being read.
4695 *
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.
4699 */
4700int
4701xmlTextReaderStandalone(xmlTextReaderPtr reader) {
4702 xmlDocPtr doc = NULL;
4703 if (reader == NULL)
4704 return(-1);
4705 if (reader->doc != NULL)
4706 doc = reader->doc;
4707 else if (reader->ctxt != NULL)
4708 doc = reader->ctxt->myDoc;
4709 if (doc == NULL)
4710 return(-1);
4711
4712 return(doc->standalone);
4713}
4714
4715/************************************************************************
4716 * *
4717 * Error Handling Extensions *
4718 * *
4719 ************************************************************************/
4720
4721/* helper to build a xmlMalloc'ed string from a format and va_list */
4722static char *
4723xmlTextReaderBuildMessage(const char *msg, va_list ap) {
4724 int size = 0;
4725 int chars;
4726 char *larger;
4727 char *str = NULL;
4728 va_list aq;
4729
4730 while (1) {
4731 VA_COPY(aq, ap);
4732 chars = vsnprintf(str, size, msg, aq);
4733 va_end(aq);
4734 if (chars < 0) {
4735 xmlGenericError(xmlGenericErrorContext, "vsnprintf failed !\n");
4736 if (str)
4737 xmlFree(str);
4738 return NULL;
4739 }
4740 if ((chars < size) || (size == MAX_ERR_MSG_SIZE))
4741 break;
4742 if (chars < MAX_ERR_MSG_SIZE)
4743 size = chars + 1;
4744 else
4745 size = MAX_ERR_MSG_SIZE;
4746 if ((larger = (char *) xmlRealloc(str, size)) == NULL) {
4747 xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
4748 if (str)
4749 xmlFree(str);
4750 return NULL;
4751 }
4752 str = larger;
4753 }
4754
4755 return str;
4756}
4757
4758/**
4759 * xmlTextReaderLocatorLineNumber:
4760 * @locator: the xmlTextReaderLocatorPtr used
4761 *
4762 * Obtain the line number for the given locator.
4763 *
4764 * Returns the line number or -1 in case of error.
4765 */
4766int
4767xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator) {
4768 /* we know that locator is a xmlParserCtxtPtr */
4769 xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
4770 int ret = -1;
4771
4772 if (locator == NULL)
4773 return(-1);
4774 if (ctx->node != NULL) {
4775 ret = xmlGetLineNo(ctx->node);
4776 }
4777 else {
4778 /* inspired from error.c */
4779 xmlParserInputPtr input;
4780 input = ctx->input;
4781 if ((input->filename == NULL) && (ctx->inputNr > 1))
4782 input = ctx->inputTab[ctx->inputNr - 2];
4783 if (input != NULL) {
4784 ret = input->line;
4785 }
4786 else {
4787 ret = -1;
4788 }
4789 }
4790
4791 return ret;
4792}
4793
4794/**
4795 * xmlTextReaderLocatorBaseURI:
4796 * @locator: the xmlTextReaderLocatorPtr used
4797 *
4798 * Obtain the base URI for the given locator.
4799 *
4800 * Returns the base URI or NULL in case of error,
4801 * if non NULL it need to be freed by the caller.
4802 */
4803xmlChar *
4804xmlTextReaderLocatorBaseURI(xmlTextReaderLocatorPtr locator) {
4805 /* we know that locator is a xmlParserCtxtPtr */
4806 xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
4807 xmlChar *ret = NULL;
4808
4809 if (locator == NULL)
4810 return(NULL);
4811 if (ctx->node != NULL) {
4812 ret = xmlNodeGetBase(NULL,ctx->node);
4813 }
4814 else {
4815 /* inspired from error.c */
4816 xmlParserInputPtr input;
4817 input = ctx->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);
4822 }
4823 else {
4824 ret = NULL;
4825 }
4826 }
4827
4828 return ret;
4829}
4830
4831static void
4832xmlTextReaderGenericError(void *ctxt, xmlParserSeverities severity,
4833 char *str)
4834{
4835 xmlParserCtxtPtr ctx = (xmlParserCtxtPtr) ctxt;
4836
4837 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
4838
4839 if (str != NULL) {
4840 if (reader->errorFunc)
4841 reader->errorFunc(reader->errorFuncArg, str, severity,
4842 (xmlTextReaderLocatorPtr) ctx);
4843 xmlFree(str);
4844 }
4845}
4846
4847static void
4848xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error)
4849{
4850 xmlParserCtxtPtr ctx = (xmlParserCtxtPtr) ctxt;
4851
4852 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
4853
4854 if (error && reader->sErrorFunc) {
4855 reader->sErrorFunc(reader->errorFuncArg, (xmlErrorPtr) error);
4856 }
4857}
4858
4859static void XMLCDECL LIBXML_ATTR_FORMAT(2,3)
4860xmlTextReaderError(void *ctxt, const char *msg, ...)
4861{
4862 va_list ap;
4863
4864 va_start(ap, msg);
4865 xmlTextReaderGenericError(ctxt,
4866 XML_PARSER_SEVERITY_ERROR,
4867 xmlTextReaderBuildMessage(msg, ap));
4868 va_end(ap);
4869
4870}
4871
4872static void XMLCDECL LIBXML_ATTR_FORMAT(2,3)
4873xmlTextReaderWarning(void *ctxt, const char *msg, ...)
4874{
4875 va_list ap;
4876
4877 va_start(ap, msg);
4878 xmlTextReaderGenericError(ctxt,
4879 XML_PARSER_SEVERITY_WARNING,
4880 xmlTextReaderBuildMessage(msg, ap));
4881 va_end(ap);
4882}
4883
4884static void XMLCDECL
4885xmlTextReaderValidityError(void *ctxt, const char *msg, ...)
4886{
4887 va_list ap;
4888
4889 int len = xmlStrlen((const xmlChar *) msg);
4890
4891 if ((len > 1) && (msg[len - 2] != ':')) {
4892 /*
4893 * some callbacks only report locator information:
4894 * skip them (mimicking behaviour in error.c)
4895 */
4896 va_start(ap, msg);
4897 xmlTextReaderGenericError(ctxt,
4898 XML_PARSER_SEVERITY_VALIDITY_ERROR,
4899 xmlTextReaderBuildMessage(msg, ap));
4900 va_end(ap);
4901 }
4902}
4903
4904static void XMLCDECL
4905xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...)
4906{
4907 va_list ap;
4908
4909 int len = xmlStrlen((const xmlChar *) msg);
4910
4911 if ((len != 0) && (msg[len - 1] != ':')) {
4912 /*
4913 * some callbacks only report locator information:
4914 * skip them (mimicking behaviour in error.c)
4915 */
4916 va_start(ap, msg);
4917 xmlTextReaderGenericError(ctxt,
4918 XML_PARSER_SEVERITY_VALIDITY_WARNING,
4919 xmlTextReaderBuildMessage(msg, ap));
4920 va_end(ap);
4921 }
4922}
4923
4924/**
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
4929 *
4930 * Register a callback function that will be called on error and warnings.
4931 *
4932 * If @f is NULL, the default error and warning handlers are restored.
4933 */
4934void
4935xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
4936 xmlTextReaderErrorFunc f, void *arg)
4937{
4938 if (f != NULL) {
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,
4952 reader);
4953 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
4954 reader);
4955 }
4956 if (reader->xsdValidCtxt) {
4957 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4958 xmlTextReaderValidityErrorRelay,
4959 xmlTextReaderValidityWarningRelay,
4960 reader);
4961 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
4962 reader);
4963 }
4964#endif
4965 } else {
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,
4977 reader);
4978 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
4979 reader);
4980 }
4981 if (reader->xsdValidCtxt) {
4982 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
4983 reader);
4984 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
4985 reader);
4986 }
4987#endif
4988 }
4989}
4990
4991/**
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
4996 *
4997 * Register a callback function that will be called on error and warnings.
4998 *
4999 * If @f is NULL, the default error and warning handlers are restored.
5000 */
5001void
5002xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
5003 xmlStructuredErrorFunc f, void *arg)
5004{
5005 if (f != NULL) {
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,
5017 reader);
5018 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
5019 xmlTextReaderValidityStructuredRelay,
5020 reader);
5021 }
5022 if (reader->xsdValidCtxt) {
5023 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
5024 reader);
5025 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
5026 xmlTextReaderValidityStructuredRelay,
5027 reader);
5028 }
5029#endif
5030 } else {
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,
5043 reader);
5044 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
5045 reader);
5046 }
5047 if (reader->xsdValidCtxt) {
5048 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
5049 reader);
5050 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
5051 reader);
5052 }
5053#endif
5054 }
5055}
5056
5057/**
5058 * xmlTextReaderIsValid:
5059 * @reader: the xmlTextReaderPtr used
5060 *
5061 * Retrieve the validity status from the parser context
5062 *
5063 * Returns the flag value 1 if valid, 0 if no, and -1 in case of error
5064 */
5065int
5066xmlTextReaderIsValid(xmlTextReaderPtr reader)
5067{
5068 if (reader == NULL)
5069 return (-1);
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);
5075#endif
5076 if ((reader->ctxt != NULL) && (reader->ctxt->validate == 1))
5077 return (reader->ctxt->valid);
5078 return (0);
5079}
5080
5081/**
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
5086 *
5087 * Retrieve the error callback function and user argument.
5088 */
5089void
5090xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
5091 xmlTextReaderErrorFunc * f, void **arg)
5092{
5093 if (f != NULL)
5094 *f = reader->errorFunc;
5095 if (arg != NULL)
5096 *arg = reader->errorFuncArg;
5097}
5098/************************************************************************
5099 * *
5100 * New set (2.6.0) of simpler and more flexible APIs *
5101 * *
5102 ************************************************************************/
5103
5104/**
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
5112 *
5113 * Setup an XML reader with new options
5114 *
5115 * Returns 0 in case of success and -1 in case of error.
5116 */
5117int
5118xmlTextReaderSetup(xmlTextReaderPtr reader,
5119 xmlParserInputBufferPtr input, const char *URL,
5120 const char *encoding, int options)
5121{
5122 if (reader == NULL) {
5123 if (input != NULL)
5124 xmlFreeParserInputBuffer(input);
5125 return (-1);
5126 }
5127
5128 /*
5129 * we force the generation of compact text nodes on the reader
5130 * since usr applications should never modify the tree
5131 */
5132 options |= XML_PARSE_COMPACT;
5133
5134 reader->doc = NULL;
5135 reader->entNr = 0;
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;
5143 }
5144 if (input != NULL) {
5145 reader->input = input;
5146 reader->allocs |= XML_TEXTREADER_INPUT;
5147 }
5148 if (reader->buffer == NULL)
5149 reader->buffer = xmlBufCreateSize(100);
5150 if (reader->buffer == NULL) {
5151 xmlGenericError(xmlGenericErrorContext,
5152 "xmlTextReaderSetup : malloc failed\n");
5153 return (-1);
5154 }
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");
5163 return (-1);
5164 }
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
5178 } else {
5179 reader->startElementNs = NULL;
5180 reader->endElementNs = NULL;
5181 }
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;
5188
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);
5195 }
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),
5200 4, URL);
5201 reader->base = 0;
5202 reader->cur = 4;
5203 } else {
5204 reader->ctxt =
5205 xmlCreatePushParserCtxt(reader->sax, NULL, NULL, 0, URL);
5206 reader->base = 0;
5207 reader->cur = 0;
5208 }
5209 } else {
5210 xmlParserInputPtr inputStream;
5211 xmlParserInputBufferPtr buf;
5212 xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
5213
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);
5220 return(-1);
5221 }
5222
5223 if (URL == NULL)
5224 inputStream->filename = NULL;
5225 else
5226 inputStream->filename = (char *)
5227 xmlCanonicPath((const xmlChar *) URL);
5228 inputStream->buf = buf;
5229 xmlBufResetInput(buf->buffer, inputStream);
5230
5231 inputPush(reader->ctxt, inputStream);
5232 reader->cur = 0;
5233 }
5234 if (reader->ctxt == NULL) {
5235 xmlGenericError(xmlGenericErrorContext,
5236 "xmlTextReaderSetup : malloc failed\n");
5237 return (-1);
5238 }
5239 }
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;
5245 }
5246 } else {
5247 reader->ctxt->dict = reader->dict;
5248 }
5249 } else {
5250 if (reader->ctxt->dict == NULL)
5251 reader->ctxt->dict = xmlDictCreate();
5252 reader->dict = reader->ctxt->dict;
5253 }
5254 reader->ctxt->_private = reader;
5255 reader->ctxt->linenumbers = 1;
5256 reader->ctxt->dictNames = 1;
5257 /*
5258 * use the parser dictionary to allocate all elements and attributes names
5259 */
5260 reader->ctxt->docdict = 1;
5261 reader->ctxt->parseMode = XML_PARSE_READER;
5262
5263#ifdef LIBXML_XINCLUDE_ENABLED
5264 if (reader->xincctxt != NULL) {
5265 xmlXIncludeFreeContext(reader->xincctxt);
5266 reader->xincctxt = NULL;
5267 }
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;
5272 } else
5273 reader->xinclude = 0;
5274 reader->in_xinclude = 0;
5275#endif
5276#ifdef LIBXML_PATTERN_ENABLED
5277 if (reader->patternTab == NULL) {
5278 reader->patternNr = 0;
5279 reader->patternMax = 0;
5280 }
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;
5286 }
5287 }
5288#endif
5289
5290 if (options & XML_PARSE_DTDVALID)
5291 reader->validate = XML_TEXTREADER_VALIDATE_DTD;
5292
5293 xmlCtxtUseOptions(reader->ctxt, options);
5294 if (encoding != NULL) {
5295 xmlCharEncodingHandlerPtr hdlr;
5296
5297 hdlr = xmlFindCharEncodingHandler(encoding);
5298 if (hdlr != NULL)
5299 xmlSwitchToEncoding(reader->ctxt, hdlr);
5300 }
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);
5305
5306 reader->doc = NULL;
5307
5308 return (0);
5309}
5310
5311/**
5312 * xmlTextReaderByteConsumed:
5313 * @reader: an XML reader
5314 *
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.
5320 *
5321 * Returns the index in bytes from the beginning of the entity or -1
5322 * in case the index could not be computed.
5323 */
5324long
5325xmlTextReaderByteConsumed(xmlTextReaderPtr reader) {
5326 if ((reader == NULL) || (reader->ctxt == NULL))
5327 return(-1);
5328 return(xmlByteConsumed(reader->ctxt));
5329}
5330
5331
5332/**
5333 * xmlReaderWalker:
5334 * @doc: a preparsed document
5335 *
5336 * Create an xmltextReader for a preparsed document.
5337 *
5338 * Returns the new reader or NULL in case of error.
5339 */
5340xmlTextReaderPtr
5341xmlReaderWalker(xmlDocPtr doc)
5342{
5343 xmlTextReaderPtr ret;
5344
5345 if (doc == NULL)
5346 return(NULL);
5347
5348 ret = xmlMalloc(sizeof(xmlTextReader));
5349 if (ret == NULL) {
5350 xmlGenericError(xmlGenericErrorContext,
5351 "xmlNewTextReader : malloc failed\n");
5352 return(NULL);
5353 }
5354 memset(ret, 0, sizeof(xmlTextReader));
5355 ret->entNr = 0;
5356 ret->input = NULL;
5357 ret->mode = XML_TEXTREADER_MODE_INITIAL;
5358 ret->node = NULL;
5359 ret->curnode = NULL;
5360 ret->base = 0;
5361 ret->cur = 0;
5362 ret->allocs = XML_TEXTREADER_CTXT;
5363 ret->doc = doc;
5364 ret->state = XML_TEXTREADER_START;
5365 ret->dict = xmlDictCreate();
5366 return(ret);
5367}
5368
5369/**
5370 * xmlReaderForDoc:
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
5375 *
5376 * Create an xmltextReader for an XML in-memory document.
5377 * The parsing flags @options are a combination of xmlParserOption.
5378 *
5379 * Returns the new reader or NULL in case of error.
5380 */
5381xmlTextReaderPtr
5382xmlReaderForDoc(const xmlChar * cur, const char *URL, const char *encoding,
5383 int options)
5384{
5385 int len;
5386
5387 if (cur == NULL)
5388 return (NULL);
5389 len = xmlStrlen(cur);
5390
5391 return (xmlReaderForMemory
5392 ((const char *) cur, len, URL, encoding, options));
5393}
5394
5395/**
5396 * xmlReaderForFile:
5397 * @filename: a file or URL
5398 * @encoding: the document encoding, or NULL
5399 * @options: a combination of xmlParserOption
5400 *
5401 * parse an XML file from the filesystem or the network.
5402 * The parsing flags @options are a combination of xmlParserOption.
5403 *
5404 * Returns the new reader or NULL in case of error.
5405 */
5406xmlTextReaderPtr
5407xmlReaderForFile(const char *filename, const char *encoding, int options)
5408{
5409 xmlTextReaderPtr reader;
5410
5411 reader = xmlNewTextReaderFilename(filename);
5412 if (reader == NULL)
5413 return (NULL);
5414 xmlTextReaderSetup(reader, NULL, NULL, encoding, options);
5415 return (reader);
5416}
5417
5418/**
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
5425 *
5426 * Create an xmltextReader for an XML in-memory document.
5427 * The parsing flags @options are a combination of xmlParserOption.
5428 *
5429 * Returns the new reader or NULL in case of error.
5430 */
5431xmlTextReaderPtr
5432xmlReaderForMemory(const char *buffer, int size, const char *URL,
5433 const char *encoding, int options)
5434{
5435 xmlTextReaderPtr reader;
5436 xmlParserInputBufferPtr buf;
5437
5438 buf = xmlParserInputBufferCreateStatic(buffer, size,
5439 XML_CHAR_ENCODING_NONE);
5440 if (buf == NULL) {
5441 return (NULL);
5442 }
5443 reader = xmlNewTextReader(buf, URL);
5444 if (reader == NULL) {
5445 xmlFreeParserInputBuffer(buf);
5446 return (NULL);
5447 }
5448 reader->allocs |= XML_TEXTREADER_INPUT;
5449 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5450 return (reader);
5451}
5452
5453/**
5454 * xmlReaderForFd:
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
5459 *
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.
5464 *
5465 * Returns the new reader or NULL in case of error.
5466 */
5467xmlTextReaderPtr
5468xmlReaderForFd(int fd, const char *URL, const char *encoding, int options)
5469{
5470 xmlTextReaderPtr reader;
5471 xmlParserInputBufferPtr input;
5472
5473 if (fd < 0)
5474 return (NULL);
5475
5476 input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
5477 if (input == NULL)
5478 return (NULL);
5479 input->closecallback = NULL;
5480 reader = xmlNewTextReader(input, URL);
5481 if (reader == NULL) {
5482 xmlFreeParserInputBuffer(input);
5483 return (NULL);
5484 }
5485 reader->allocs |= XML_TEXTREADER_INPUT;
5486 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5487 return (reader);
5488}
5489
5490/**
5491 * xmlReaderForIO:
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
5498 *
5499 * Create an xmltextReader for an XML document from I/O functions and source.
5500 * The parsing flags @options are a combination of xmlParserOption.
5501 *
5502 * Returns the new reader or NULL in case of error.
5503 */
5504xmlTextReaderPtr
5505xmlReaderForIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
5506 void *ioctx, const char *URL, const char *encoding,
5507 int options)
5508{
5509 xmlTextReaderPtr reader;
5510 xmlParserInputBufferPtr input;
5511
5512 if (ioread == NULL)
5513 return (NULL);
5514
5515 input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
5516 XML_CHAR_ENCODING_NONE);
5517 if (input == NULL) {
5518 if (ioclose != NULL)
5519 ioclose(ioctx);
5520 return (NULL);
5521 }
5522 reader = xmlNewTextReader(input, URL);
5523 if (reader == NULL) {
5524 xmlFreeParserInputBuffer(input);
5525 return (NULL);
5526 }
5527 reader->allocs |= XML_TEXTREADER_INPUT;
5528 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5529 return (reader);
5530}
5531
5532/**
5533 * xmlReaderNewWalker:
5534 * @reader: an XML reader
5535 * @doc: a preparsed document
5536 *
5537 * Setup an xmltextReader to parse a preparsed XML document.
5538 * This reuses the existing @reader xmlTextReader.
5539 *
5540 * Returns 0 in case of success and -1 in case of error
5541 */
5542int
5543xmlReaderNewWalker(xmlTextReaderPtr reader, xmlDocPtr doc)
5544{
5545 if (doc == NULL)
5546 return (-1);
5547 if (reader == NULL)
5548 return (-1);
5549
5550 if (reader->input != NULL) {
5551 xmlFreeParserInputBuffer(reader->input);
5552 }
5553 if (reader->ctxt != NULL) {
5554 xmlCtxtReset(reader->ctxt);
5555 }
5556
5557 reader->entNr = 0;
5558 reader->input = NULL;
5559 reader->mode = XML_TEXTREADER_MODE_INITIAL;
5560 reader->node = NULL;
5561 reader->curnode = NULL;
5562 reader->base = 0;
5563 reader->cur = 0;
5564 reader->allocs = XML_TEXTREADER_CTXT;
5565 reader->doc = doc;
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;
5570 else
5571 reader->dict = xmlDictCreate();
5572 }
5573 return(0);
5574}
5575
5576/**
5577 * xmlReaderNewDoc:
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
5583 *
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.
5587 *
5588 * Returns 0 in case of success and -1 in case of error
5589 */
5590int
5591xmlReaderNewDoc(xmlTextReaderPtr reader, const xmlChar * cur,
5592 const char *URL, const char *encoding, int options)
5593{
5594
5595 int len;
5596
5597 if (cur == NULL)
5598 return (-1);
5599 if (reader == NULL)
5600 return (-1);
5601
5602 len = xmlStrlen(cur);
5603 return (xmlReaderNewMemory(reader, (const char *)cur, len,
5604 URL, encoding, options));
5605}
5606
5607/**
5608 * xmlReaderNewFile:
5609 * @reader: an XML reader
5610 * @filename: a file or URL
5611 * @encoding: the document encoding, or NULL
5612 * @options: a combination of xmlParserOption
5613 *
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.
5617 *
5618 * Returns 0 in case of success and -1 in case of error
5619 */
5620int
5621xmlReaderNewFile(xmlTextReaderPtr reader, const char *filename,
5622 const char *encoding, int options)
5623{
5624 xmlParserInputBufferPtr input;
5625
5626 if (filename == NULL)
5627 return (-1);
5628 if (reader == NULL)
5629 return (-1);
5630
5631 input =
5632 xmlParserInputBufferCreateFilename(filename,
5633 XML_CHAR_ENCODING_NONE);
5634 if (input == NULL)
5635 return (-1);
5636 return (xmlTextReaderSetup(reader, input, filename, encoding, options));
5637}
5638
5639/**
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
5647 *
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.
5651 *
5652 * Returns 0 in case of success and -1 in case of error
5653 */
5654int
5655xmlReaderNewMemory(xmlTextReaderPtr reader, const char *buffer, int size,
5656 const char *URL, const char *encoding, int options)
5657{
5658 xmlParserInputBufferPtr input;
5659
5660 if (reader == NULL)
5661 return (-1);
5662 if (buffer == NULL)
5663 return (-1);
5664
5665 input = xmlParserInputBufferCreateStatic(buffer, size,
5666 XML_CHAR_ENCODING_NONE);
5667 if (input == NULL) {
5668 return (-1);
5669 }
5670 return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5671}
5672
5673/**
5674 * xmlReaderNewFd:
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
5680 *
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.
5686 *
5687 * Returns 0 in case of success and -1 in case of error
5688 */
5689int
5690xmlReaderNewFd(xmlTextReaderPtr reader, int fd,
5691 const char *URL, const char *encoding, int options)
5692{
5693 xmlParserInputBufferPtr input;
5694
5695 if (fd < 0)
5696 return (-1);
5697 if (reader == NULL)
5698 return (-1);
5699
5700 input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
5701 if (input == NULL)
5702 return (-1);
5703 input->closecallback = NULL;
5704 return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5705}
5706
5707/**
5708 * xmlReaderNewIO:
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
5716 *
5717 * Setup an xmltextReader to parse an XML document from I/O functions
5718 * and source.
5719 * The parsing flags @options are a combination of xmlParserOption.
5720 * This reuses the existing @reader xmlTextReader.
5721 *
5722 * Returns 0 in case of success and -1 in case of error
5723 */
5724int
5725xmlReaderNewIO(xmlTextReaderPtr reader, xmlInputReadCallback ioread,
5726 xmlInputCloseCallback ioclose, void *ioctx,
5727 const char *URL, const char *encoding, int options)
5728{
5729 xmlParserInputBufferPtr input;
5730
5731 if (ioread == NULL)
5732 return (-1);
5733 if (reader == NULL)
5734 return (-1);
5735
5736 input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
5737 XML_CHAR_ENCODING_NONE);
5738 if (input == NULL) {
5739 if (ioclose != NULL)
5740 ioclose(ioctx);
5741 return (-1);
5742 }
5743 return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5744}
5745
5746/************************************************************************
5747 * *
5748 * Utilities *
5749 * *
5750 ************************************************************************/
5751#ifdef NOT_USED_YET
5752
5753/**
5754 * xmlBase64Decode:
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)
5759 *
5760 * Base64 decoder, reads from @in and save in @to
5761 * TODO: tell jody when this is actually exported
5762 *
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.
5765 */
5766static int
5767xmlBase64Decode(const unsigned char *in, unsigned long *inlen,
5768 unsigned char *to, unsigned long *tolen)
5769{
5770 unsigned long incur; /* current index in in[] */
5771
5772 unsigned long inblk; /* last block index in in[] */
5773
5774 unsigned long outcur; /* current index in out[] */
5775
5776 unsigned long inmax; /* size of in[] */
5777
5778 unsigned long outmax; /* size of out[] */
5779
5780 unsigned char cur; /* the current value read from in[] */
5781
5782 unsigned char intmp[4], outtmp[4]; /* temporary buffers for the convert */
5783
5784 int nbintmp; /* number of byte in intmp[] */
5785
5786 int is_ignore; /* cur should be ignored */
5787
5788 int is_end = 0; /* the end of the base64 was found */
5789
5790 int retval = 1;
5791
5792 int i;
5793
5794 if ((in == NULL) || (inlen == NULL) || (to == NULL) || (tolen == NULL))
5795 return (-1);
5796
5797 incur = 0;
5798 inblk = 0;
5799 outcur = 0;
5800 inmax = *inlen;
5801 outmax = *tolen;
5802 nbintmp = 0;
5803
5804 while (1) {
5805 if (incur >= inmax)
5806 break;
5807 cur = in[incur++];
5808 is_ignore = 0;
5809 if ((cur >= 'A') && (cur <= 'Z'))
5810 cur = cur - 'A';
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 == '+')
5816 cur = 62;
5817 else if (cur == '/')
5818 cur = 63;
5819 else if (cur == '.')
5820 cur = 0;
5821 else if (cur == '=') /*no op , end of the base64 stream */
5822 is_end = 1;
5823 else {
5824 is_ignore = 1;
5825 if (nbintmp == 0)
5826 inblk = incur;
5827 }
5828
5829 if (!is_ignore) {
5830 int nbouttmp = 3;
5831
5832 int is_break = 0;
5833
5834 if (is_end) {
5835 if (nbintmp == 0)
5836 break;
5837 if ((nbintmp == 1) || (nbintmp == 2))
5838 nbouttmp = 1;
5839 else
5840 nbouttmp = 2;
5841 nbintmp = 3;
5842 is_break = 1;
5843 }
5844 intmp[nbintmp++] = cur;
5845 /*
5846 * if intmp is full, push the 4byte sequence as a 3 byte
5847 * sequence out
5848 */
5849 if (nbintmp == 4) {
5850 nbintmp = 0;
5851 outtmp[0] = (intmp[0] << 2) | ((intmp[1] & 0x30) >> 4);
5852 outtmp[1] =
5853 ((intmp[1] & 0x0F) << 4) | ((intmp[2] & 0x3C) >> 2);
5854 outtmp[2] = ((intmp[2] & 0x03) << 6) | (intmp[3] & 0x3F);
5855 if (outcur + 3 >= outmax) {
5856 retval = 2;
5857 break;
5858 }
5859
5860 for (i = 0; i < nbouttmp; i++)
5861 to[outcur++] = outtmp[i];
5862 inblk = incur;
5863 }
5864
5865 if (is_break) {
5866 retval = 0;
5867 break;
5868 }
5869 }
5870 }
5871
5872 *tolen = outcur;
5873 *inlen = inblk;
5874 return (retval);
5875}
5876
5877/*
5878 * Test routine for the xmlBase64Decode function
5879 */
5880#if 0
5881int
5882main(int argc, char **argv)
5883{
5884 char *input = " VW4 gcGV0 \n aXQgdGVzdCAuCg== ";
5885
5886 char output[100];
5887
5888 char output2[100];
5889
5890 char output3[100];
5891
5892 unsigned long inlen = strlen(input);
5893
5894 unsigned long outlen = 100;
5895
5896 int ret;
5897
5898 unsigned long cons, tmp, tmp2, prod;
5899
5900 /*
5901 * Direct
5902 */
5903 ret = xmlBase64Decode(input, &inlen, output, &outlen);
5904
5905 output[outlen] = 0;
5906 printf("ret: %d, inlen: %ld , outlen: %ld, output: '%s'\n", ret, inlen,
5907 outlen, output)indent: Standard input:179: Error:Unmatched #endif
5908;
5909
5910 /*
5911 * output chunking
5912 */
5913 cons = 0;
5914 prod = 0;
5915 while (cons < inlen) {
5916 tmp = 5;
5917 tmp2 = inlen - cons;
5918
5919 printf("%ld %ld\n", cons, prod);
5920 ret = xmlBase64Decode(&input[cons], &tmp2, &output2[prod], &tmp);
5921 cons += tmp2;
5922 prod += tmp;
5923 printf("%ld %ld\n", cons, prod);
5924 }
5925 output2[outlen] = 0;
5926 printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons,
5927 prod, output2);
5928
5929 /*
5930 * input chunking
5931 */
5932 cons = 0;
5933 prod = 0;
5934 while (cons < inlen) {
5935 tmp = 100 - prod;
5936 tmp2 = inlen - cons;
5937 if (tmp2 > 5)
5938 tmp2 = 5;
5939
5940 printf("%ld %ld\n", cons, prod);
5941 ret = xmlBase64Decode(&input[cons], &tmp2, &output3[prod], &tmp);
5942 cons += tmp2;
5943 prod += tmp;
5944 printf("%ld %ld\n", cons, prod);
5945 }
5946 output3[outlen] = 0;
5947 printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons,
5948 prod, output3);
5949 return (0);
5950
5951}
5952#endif
5953#endif /* NOT_USED_YET */
5954#define bottom_xmlreader
5955#include "elfgcchack.h"
5956#endif /* LIBXML_READER_ENABLED */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette