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: * daniel@veillard.com
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: #define MAX_ERR_MSG_SIZE 64000
48:
49: /*
50: * The following VA_COPY was coded following an example in
51: * the Samba project. It may not be sufficient for some
52: * esoteric implementations of va_list (i.e. it may need
53: * something involving a memcpy) but (hopefully) will be
54: * sufficient for libxml2.
55: */
56: #ifndef VA_COPY
57: #ifdef HAVE_VA_COPY
58: #define VA_COPY(dest, src) va_copy(dest, src)
59: #else
60: #ifdef HAVE___VA_COPY
61: #define VA_COPY(dest,src) __va_copy(dest, src)
62: #else
63: #define VA_COPY(dest,src) (dest) = (src)
64: #endif
65: #endif
66: #endif
67:
68: /* #define DEBUG_CALLBACKS */
69: /* #define DEBUG_READER */
70:
71: /**
72: * TODO:
73: *
74: * macro to flag unimplemented blocks
75: */
76: #define TODO \
77: xmlGenericError(xmlGenericErrorContext, \
78: "Unimplemented block at %s:%d\n", \
79: __FILE__, __LINE__);
80:
81: #ifdef DEBUG_READER
82: #define DUMP_READER xmlTextReaderDebug(reader);
83: #else
84: #define DUMP_READER
85: #endif
86:
87: #define CHUNK_SIZE 512
88: /************************************************************************
89: * *
90: * The parser: maps the Text Reader API on top of the existing *
91: * parsing routines building a tree *
92: * *
93: ************************************************************************/
94:
95: #define XML_TEXTREADER_INPUT 1
96: #define XML_TEXTREADER_CTXT 2
97:
98: typedef enum {
99: XML_TEXTREADER_NONE = -1,
100: XML_TEXTREADER_START= 0,
101: XML_TEXTREADER_ELEMENT= 1,
102: XML_TEXTREADER_END= 2,
103: XML_TEXTREADER_EMPTY= 3,
104: XML_TEXTREADER_BACKTRACK= 4,
105: XML_TEXTREADER_DONE= 5,
106: XML_TEXTREADER_ERROR= 6
107: } xmlTextReaderState;
108:
109: typedef enum {
110: XML_TEXTREADER_NOT_VALIDATE = 0,
111: XML_TEXTREADER_VALIDATE_DTD = 1,
112: XML_TEXTREADER_VALIDATE_RNG = 2,
113: XML_TEXTREADER_VALIDATE_XSD = 4
114: } xmlTextReaderValidate;
115:
116: struct _xmlTextReader {
117: int mode; /* the parsing mode */
118: xmlDocPtr doc; /* when walking an existing doc */
119: xmlTextReaderValidate validate;/* is there any validation */
120: int allocs; /* what structure were deallocated */
121: xmlTextReaderState state;
122: xmlParserCtxtPtr ctxt; /* the parser context */
123: xmlSAXHandlerPtr sax; /* the parser SAX callbacks */
124: xmlParserInputBufferPtr input; /* the input */
125: startElementSAXFunc startElement;/* initial SAX callbacks */
126: endElementSAXFunc endElement; /* idem */
127: startElementNsSAX2Func startElementNs;/* idem */
128: endElementNsSAX2Func endElementNs; /* idem */
129: charactersSAXFunc characters;
130: cdataBlockSAXFunc cdataBlock;
131: unsigned int base; /* base of the segment in the input */
132: unsigned int cur; /* current position in the input */
133: xmlNodePtr node; /* current node */
134: xmlNodePtr curnode;/* current attribute node */
135: int depth; /* depth of the current node */
136: xmlNodePtr faketext;/* fake xmlNs chld */
137: int preserve;/* preserve the resulting document */
138: xmlBufferPtr buffer; /* used to return const xmlChar * */
139: xmlDictPtr dict; /* the context dictionnary */
140:
141: /* entity stack when traversing entities content */
142: xmlNodePtr ent; /* Current Entity Ref Node */
143: int entNr; /* Depth of the entities stack */
144: int entMax; /* Max depth of the entities stack */
145: xmlNodePtr *entTab; /* array of entities */
146:
147: /* error handling */
148: xmlTextReaderErrorFunc errorFunc; /* callback function */
149: void *errorFuncArg; /* callback function user argument */
150:
151: #ifdef LIBXML_SCHEMAS_ENABLED
152: /* Handling of RelaxNG validation */
153: xmlRelaxNGPtr rngSchemas; /* The Relax NG schemas */
154: xmlRelaxNGValidCtxtPtr rngValidCtxt;/* The Relax NG validation context */
155: int rngValidErrors;/* The number of errors detected */
156: xmlNodePtr rngFullNode; /* the node if RNG not progressive */
157: /* Handling of Schemas validation */
158: xmlSchemaPtr xsdSchemas; /* The Schemas schemas */
159: xmlSchemaValidCtxtPtr xsdValidCtxt;/* The Schemas validation context */
160: int xsdPreserveCtxt; /* 1 if the context was provided by the user */
161: int xsdValidErrors;/* The number of errors detected */
162: xmlSchemaSAXPlugPtr xsdPlug; /* the schemas plug in SAX pipeline */
163: #endif
164: #ifdef LIBXML_XINCLUDE_ENABLED
165: /* Handling of XInclude processing */
166: int xinclude; /* is xinclude asked for */
167: const xmlChar * xinclude_name; /* the xinclude name from dict */
168: xmlXIncludeCtxtPtr xincctxt; /* the xinclude context */
169: int in_xinclude; /* counts for xinclude */
170: #endif
171: #ifdef LIBXML_PATTERN_ENABLED
172: int patternNr; /* number of preserve patterns */
173: int patternMax; /* max preserve patterns */
174: xmlPatternPtr *patternTab; /* array of preserve patterns */
175: #endif
176: int preserves; /* level of preserves */
177: int parserFlags; /* the set of options set */
178: /* Structured error handling */
179: xmlStructuredErrorFunc sErrorFunc; /* callback function */
180: };
181:
182: #define NODE_IS_EMPTY 0x1
183: #define NODE_IS_PRESERVED 0x2
184: #define NODE_IS_SPRESERVED 0x4
185:
186: /**
187: * CONSTSTR:
188: *
189: * Macro used to return an interned string
190: */
191: #define CONSTSTR(str) xmlDictLookup(reader->dict, (str), -1)
192: #define CONSTQSTR(p, str) xmlDictQLookup(reader->dict, (p), (str))
193:
194: static int xmlTextReaderReadTree(xmlTextReaderPtr reader);
195: static int xmlTextReaderNextTree(xmlTextReaderPtr reader);
196:
197: /************************************************************************
198: * *
199: * Our own version of the freeing routines as we recycle nodes *
200: * *
201: ************************************************************************/
202: /**
203: * DICT_FREE:
204: * @str: a string
205: *
206: * Free a string if it is not owned by the "dict" dictionnary in the
207: * current scope
208: */
209: #define DICT_FREE(str) \
210: if ((str) && ((!dict) || \
211: (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
212: xmlFree((char *)(str));
213:
214: static void xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur);
215: static void xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur);
216:
217: /**
218: * xmlFreeID:
219: * @not: A id
220: *
221: * Deallocate the memory used by an id definition
222: */
223: static void
224: xmlFreeID(xmlIDPtr id) {
225: xmlDictPtr dict = NULL;
226:
227: if (id == NULL) return;
228:
229: if (id->doc != NULL)
230: dict = id->doc->dict;
231:
232: if (id->value != NULL)
233: DICT_FREE(id->value)
234: xmlFree(id);
235: }
236:
237: /**
238: * xmlTextReaderRemoveID:
239: * @doc: the document
240: * @attr: the attribute
241: *
242: * Remove the given attribute from the ID table maintained internally.
243: *
244: * Returns -1 if the lookup failed and 0 otherwise
245: */
246: static int
247: xmlTextReaderRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
248: xmlIDTablePtr table;
249: xmlIDPtr id;
250: xmlChar *ID;
251:
252: if (doc == NULL) return(-1);
253: if (attr == NULL) return(-1);
254: table = (xmlIDTablePtr) doc->ids;
255: if (table == NULL)
256: return(-1);
257:
258: ID = xmlNodeListGetString(doc, attr->children, 1);
259: if (ID == NULL)
260: return(-1);
261: id = xmlHashLookup(table, ID);
262: xmlFree(ID);
263: if (id == NULL || id->attr != attr) {
264: return(-1);
265: }
266: id->name = attr->name;
267: id->attr = NULL;
268: return(0);
269: }
270:
271: /**
272: * xmlTextReaderFreeProp:
273: * @reader: the xmlTextReaderPtr used
274: * @cur: the node
275: *
276: * Free a node.
277: */
278: static void
279: xmlTextReaderFreeProp(xmlTextReaderPtr reader, xmlAttrPtr cur) {
280: xmlDictPtr dict;
281:
282: dict = reader->ctxt->dict;
283: if (cur == NULL) return;
284:
285: if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
286: xmlDeregisterNodeDefaultValue((xmlNodePtr) cur);
287:
288: /* Check for ID removal -> leading to invalid references ! */
289: if ((cur->parent != NULL) && (cur->parent->doc != NULL) &&
290: ((cur->parent->doc->intSubset != NULL) ||
291: (cur->parent->doc->extSubset != NULL))) {
292: if (xmlIsID(cur->parent->doc, cur->parent, cur))
293: xmlTextReaderRemoveID(cur->parent->doc, cur);
294: }
295: if (cur->children != NULL)
296: xmlTextReaderFreeNodeList(reader, cur->children);
297:
298: DICT_FREE(cur->name);
299: if ((reader != NULL) && (reader->ctxt != NULL) &&
300: (reader->ctxt->freeAttrsNr < 100)) {
301: cur->next = reader->ctxt->freeAttrs;
302: reader->ctxt->freeAttrs = cur;
303: reader->ctxt->freeAttrsNr++;
304: } else {
305: xmlFree(cur);
306: }
307: }
308:
309: /**
310: * xmlTextReaderFreePropList:
311: * @reader: the xmlTextReaderPtr used
312: * @cur: the first property in the list
313: *
314: * Free a property and all its siblings, all the children are freed too.
315: */
316: static void
317: xmlTextReaderFreePropList(xmlTextReaderPtr reader, xmlAttrPtr cur) {
318: xmlAttrPtr next;
319: if (cur == NULL) return;
320: while (cur != NULL) {
321: next = cur->next;
322: xmlTextReaderFreeProp(reader, cur);
323: cur = next;
324: }
325: }
326:
327: /**
328: * xmlTextReaderFreeNodeList:
329: * @reader: the xmlTextReaderPtr used
330: * @cur: the first node in the list
331: *
332: * Free a node and all its siblings, this is a recursive behaviour, all
333: * the children are freed too.
334: */
335: static void
336: xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur) {
337: xmlNodePtr next;
338: xmlDictPtr dict;
339:
340: dict = reader->ctxt->dict;
341: if (cur == NULL) return;
342: if (cur->type == XML_NAMESPACE_DECL) {
343: xmlFreeNsList((xmlNsPtr) cur);
344: return;
345: }
346: if ((cur->type == XML_DOCUMENT_NODE) ||
347: (cur->type == XML_HTML_DOCUMENT_NODE)) {
348: xmlFreeDoc((xmlDocPtr) cur);
349: return;
350: }
351: while (cur != NULL) {
352: next = cur->next;
353: /* unroll to speed up freeing the document */
354: if (cur->type != XML_DTD_NODE) {
355:
356: if ((cur->children != NULL) &&
357: (cur->type != XML_ENTITY_REF_NODE)) {
358: if (cur->children->parent == cur)
359: xmlTextReaderFreeNodeList(reader, cur->children);
360: cur->children = NULL;
361: }
362:
363: if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
364: xmlDeregisterNodeDefaultValue(cur);
365:
366: if (((cur->type == XML_ELEMENT_NODE) ||
367: (cur->type == XML_XINCLUDE_START) ||
368: (cur->type == XML_XINCLUDE_END)) &&
369: (cur->properties != NULL))
370: xmlTextReaderFreePropList(reader, cur->properties);
371: if ((cur->content != (xmlChar *) &(cur->properties)) &&
372: (cur->type != XML_ELEMENT_NODE) &&
373: (cur->type != XML_XINCLUDE_START) &&
374: (cur->type != XML_XINCLUDE_END) &&
375: (cur->type != XML_ENTITY_REF_NODE)) {
376: DICT_FREE(cur->content);
377: }
378: if (((cur->type == XML_ELEMENT_NODE) ||
379: (cur->type == XML_XINCLUDE_START) ||
380: (cur->type == XML_XINCLUDE_END)) &&
381: (cur->nsDef != NULL))
382: xmlFreeNsList(cur->nsDef);
383:
384: /*
385: * we don't free element names here they are interned now
386: */
387: if ((cur->type != XML_TEXT_NODE) &&
388: (cur->type != XML_COMMENT_NODE))
389: DICT_FREE(cur->name);
390: if (((cur->type == XML_ELEMENT_NODE) ||
391: (cur->type == XML_TEXT_NODE)) &&
392: (reader != NULL) && (reader->ctxt != NULL) &&
393: (reader->ctxt->freeElemsNr < 100)) {
394: cur->next = reader->ctxt->freeElems;
395: reader->ctxt->freeElems = cur;
396: reader->ctxt->freeElemsNr++;
397: } else {
398: xmlFree(cur);
399: }
400: }
401: cur = next;
402: }
403: }
404:
405: /**
406: * xmlTextReaderFreeNode:
407: * @reader: the xmlTextReaderPtr used
408: * @cur: the node
409: *
410: * Free a node, this is a recursive behaviour, all the children are freed too.
411: * This doesn't unlink the child from the list, use xmlUnlinkNode() first.
412: */
413: static void
414: xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur) {
415: xmlDictPtr dict;
416:
417: dict = reader->ctxt->dict;
418: if (cur->type == XML_DTD_NODE) {
419: xmlFreeDtd((xmlDtdPtr) cur);
420: return;
421: }
422: if (cur->type == XML_NAMESPACE_DECL) {
423: xmlFreeNs((xmlNsPtr) cur);
424: return;
425: }
426: if (cur->type == XML_ATTRIBUTE_NODE) {
427: xmlTextReaderFreeProp(reader, (xmlAttrPtr) cur);
428: return;
429: }
430:
431: if ((cur->children != NULL) &&
432: (cur->type != XML_ENTITY_REF_NODE)) {
433: if (cur->children->parent == cur)
434: xmlTextReaderFreeNodeList(reader, cur->children);
435: cur->children = NULL;
436: }
437:
438: if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
439: xmlDeregisterNodeDefaultValue(cur);
440:
441: if (((cur->type == XML_ELEMENT_NODE) ||
442: (cur->type == XML_XINCLUDE_START) ||
443: (cur->type == XML_XINCLUDE_END)) &&
444: (cur->properties != NULL))
445: xmlTextReaderFreePropList(reader, cur->properties);
446: if ((cur->content != (xmlChar *) &(cur->properties)) &&
447: (cur->type != XML_ELEMENT_NODE) &&
448: (cur->type != XML_XINCLUDE_START) &&
449: (cur->type != XML_XINCLUDE_END) &&
450: (cur->type != XML_ENTITY_REF_NODE)) {
451: DICT_FREE(cur->content);
452: }
453: if (((cur->type == XML_ELEMENT_NODE) ||
454: (cur->type == XML_XINCLUDE_START) ||
455: (cur->type == XML_XINCLUDE_END)) &&
456: (cur->nsDef != NULL))
457: xmlFreeNsList(cur->nsDef);
458:
459: /*
460: * we don't free names here they are interned now
461: */
462: if ((cur->type != XML_TEXT_NODE) &&
463: (cur->type != XML_COMMENT_NODE))
464: DICT_FREE(cur->name);
465:
466: if (((cur->type == XML_ELEMENT_NODE) ||
467: (cur->type == XML_TEXT_NODE)) &&
468: (reader != NULL) && (reader->ctxt != NULL) &&
469: (reader->ctxt->freeElemsNr < 100)) {
470: cur->next = reader->ctxt->freeElems;
471: reader->ctxt->freeElems = cur;
472: reader->ctxt->freeElemsNr++;
473: } else {
474: xmlFree(cur);
475: }
476: }
477:
478: /**
479: * xmlTextReaderFreeIDTable:
480: * @table: An id table
481: *
482: * Deallocate the memory used by an ID hash table.
483: */
484: static void
485: xmlTextReaderFreeIDTable(xmlIDTablePtr table) {
486: xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
487: }
488:
489: /**
490: * xmlTextReaderFreeDoc:
491: * @reader: the xmlTextReaderPtr used
492: * @cur: pointer to the document
493: *
494: * Free up all the structures used by a document, tree included.
495: */
496: static void
497: xmlTextReaderFreeDoc(xmlTextReaderPtr reader, xmlDocPtr cur) {
498: xmlDtdPtr extSubset, intSubset;
499:
500: if (cur == NULL) return;
501:
502: if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
503: xmlDeregisterNodeDefaultValue((xmlNodePtr) cur);
504:
505: /*
506: * Do this before freeing the children list to avoid ID lookups
507: */
508: if (cur->ids != NULL) xmlTextReaderFreeIDTable((xmlIDTablePtr) cur->ids);
509: cur->ids = NULL;
510: if (cur->refs != NULL) xmlFreeRefTable((xmlRefTablePtr) cur->refs);
511: cur->refs = NULL;
512: extSubset = cur->extSubset;
513: intSubset = cur->intSubset;
514: if (intSubset == extSubset)
515: extSubset = NULL;
516: if (extSubset != NULL) {
517: xmlUnlinkNode((xmlNodePtr) cur->extSubset);
518: cur->extSubset = NULL;
519: xmlFreeDtd(extSubset);
520: }
521: if (intSubset != NULL) {
522: xmlUnlinkNode((xmlNodePtr) cur->intSubset);
523: cur->intSubset = NULL;
524: xmlFreeDtd(intSubset);
525: }
526:
527: if (cur->children != NULL) xmlTextReaderFreeNodeList(reader, cur->children);
528:
529: if (cur->version != NULL) xmlFree((char *) cur->version);
530: if (cur->name != NULL) xmlFree((char *) cur->name);
531: if (cur->encoding != NULL) xmlFree((char *) cur->encoding);
532: if (cur->oldNs != NULL) xmlFreeNsList(cur->oldNs);
533: if (cur->URL != NULL) xmlFree((char *) cur->URL);
534: if (cur->dict != NULL) xmlDictFree(cur->dict);
535:
536: xmlFree(cur);
537: }
538:
539: /************************************************************************
540: * *
541: * The reader core parser *
542: * *
543: ************************************************************************/
544: #ifdef DEBUG_READER
545: static void
546: xmlTextReaderDebug(xmlTextReaderPtr reader) {
547: if ((reader == NULL) || (reader->ctxt == NULL)) {
548: fprintf(stderr, "xmlTextReader NULL\n");
549: return;
550: }
551: fprintf(stderr, "xmlTextReader: state %d depth %d ",
552: reader->state, reader->depth);
553: if (reader->node == NULL) {
554: fprintf(stderr, "node = NULL\n");
555: } else {
556: fprintf(stderr, "node %s\n", reader->node->name);
557: }
558: fprintf(stderr, " input: base %d, cur %d, depth %d: ",
559: reader->base, reader->cur, reader->ctxt->nodeNr);
560: if (reader->input->buffer == NULL) {
561: fprintf(stderr, "buffer is NULL\n");
562: } else {
563: #ifdef LIBXML_DEBUG_ENABLED
564: xmlDebugDumpString(stderr,
565: &reader->input->buffer->content[reader->cur]);
566: #endif
567: fprintf(stderr, "\n");
568: }
569: }
570: #endif
571:
572: /**
573: * xmlTextReaderEntPush:
574: * @reader: the xmlTextReaderPtr used
575: * @value: the entity reference node
576: *
577: * Pushes a new entity reference node on top of the entities stack
578: *
579: * Returns 0 in case of error, the index in the stack otherwise
580: */
581: static int
582: xmlTextReaderEntPush(xmlTextReaderPtr reader, xmlNodePtr value)
583: {
584: if (reader->entMax <= 0) {
585: reader->entMax = 10;
586: reader->entTab = (xmlNodePtr *) xmlMalloc(reader->entMax *
587: sizeof(reader->entTab[0]));
588: if (reader->entTab == NULL) {
589: xmlGenericError(xmlGenericErrorContext, "xmlMalloc failed !\n");
590: return (0);
591: }
592: }
593: if (reader->entNr >= reader->entMax) {
594: reader->entMax *= 2;
595: reader->entTab =
596: (xmlNodePtr *) xmlRealloc(reader->entTab,
597: reader->entMax *
598: sizeof(reader->entTab[0]));
599: if (reader->entTab == NULL) {
600: xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
601: return (0);
602: }
603: }
604: reader->entTab[reader->entNr] = value;
605: reader->ent = value;
606: return (reader->entNr++);
607: }
608:
609: /**
610: * xmlTextReaderEntPop:
611: * @reader: the xmlTextReaderPtr used
612: *
613: * Pops the top element entity from the entities stack
614: *
615: * Returns the entity just removed
616: */
617: static xmlNodePtr
618: xmlTextReaderEntPop(xmlTextReaderPtr reader)
619: {
620: xmlNodePtr ret;
621:
622: if (reader->entNr <= 0)
623: return (NULL);
624: reader->entNr--;
625: if (reader->entNr > 0)
626: reader->ent = reader->entTab[reader->entNr - 1];
627: else
628: reader->ent = NULL;
629: ret = reader->entTab[reader->entNr];
630: reader->entTab[reader->entNr] = NULL;
631: return (ret);
632: }
633:
634: /**
635: * xmlTextReaderStartElement:
636: * @ctx: the user data (XML parser context)
637: * @fullname: The element name, including namespace prefix
638: * @atts: An array of name/value attributes pairs, NULL terminated
639: *
640: * called when an opening tag has been processed.
641: */
642: static void
643: xmlTextReaderStartElement(void *ctx, const xmlChar *fullname,
644: const xmlChar **atts) {
645: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
646: xmlTextReaderPtr reader = ctxt->_private;
647:
648: #ifdef DEBUG_CALLBACKS
649: printf("xmlTextReaderStartElement(%s)\n", fullname);
650: #endif
651: if ((reader != NULL) && (reader->startElement != NULL)) {
652: reader->startElement(ctx, fullname, atts);
653: if ((ctxt->node != NULL) && (ctxt->input != NULL) &&
654: (ctxt->input->cur != NULL) && (ctxt->input->cur[0] == '/') &&
655: (ctxt->input->cur[1] == '>'))
656: ctxt->node->extra = NODE_IS_EMPTY;
657: }
658: if (reader != NULL)
659: reader->state = XML_TEXTREADER_ELEMENT;
660: }
661:
662: /**
663: * xmlTextReaderEndElement:
664: * @ctx: the user data (XML parser context)
665: * @fullname: The element name, including namespace prefix
666: *
667: * called when an ending tag has been processed.
668: */
669: static void
670: xmlTextReaderEndElement(void *ctx, const xmlChar *fullname) {
671: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
672: xmlTextReaderPtr reader = ctxt->_private;
673:
674: #ifdef DEBUG_CALLBACKS
675: printf("xmlTextReaderEndElement(%s)\n", fullname);
676: #endif
677: if ((reader != NULL) && (reader->endElement != NULL)) {
678: reader->endElement(ctx, fullname);
679: }
680: }
681:
682: /**
683: * xmlTextReaderStartElementNs:
684: * @ctx: the user data (XML parser context)
685: * @localname: the local name of the element
686: * @prefix: the element namespace prefix if available
687: * @URI: the element namespace name if available
688: * @nb_namespaces: number of namespace definitions on that node
689: * @namespaces: pointer to the array of prefix/URI pairs namespace definitions
690: * @nb_attributes: the number of attributes on that node
691: * nb_defaulted: the number of defaulted attributes.
692: * @attributes: pointer to the array of (localname/prefix/URI/value/end)
693: * attribute values.
694: *
695: * called when an opening tag has been processed.
696: */
697: static void
698: xmlTextReaderStartElementNs(void *ctx,
699: const xmlChar *localname,
700: const xmlChar *prefix,
701: const xmlChar *URI,
702: int nb_namespaces,
703: const xmlChar **namespaces,
704: int nb_attributes,
705: int nb_defaulted,
706: const xmlChar **attributes)
707: {
708: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
709: xmlTextReaderPtr reader = ctxt->_private;
710:
711: #ifdef DEBUG_CALLBACKS
712: printf("xmlTextReaderStartElementNs(%s)\n", localname);
713: #endif
714: if ((reader != NULL) && (reader->startElementNs != NULL)) {
715: reader->startElementNs(ctx, localname, prefix, URI, nb_namespaces,
716: namespaces, nb_attributes, nb_defaulted,
717: attributes);
718: if ((ctxt->node != NULL) && (ctxt->input != NULL) &&
719: (ctxt->input->cur != NULL) && (ctxt->input->cur[0] == '/') &&
720: (ctxt->input->cur[1] == '>'))
721: ctxt->node->extra = NODE_IS_EMPTY;
722: }
723: if (reader != NULL)
724: reader->state = XML_TEXTREADER_ELEMENT;
725: }
726:
727: /**
728: * xmlTextReaderEndElementNs:
729: * @ctx: the user data (XML parser context)
730: * @localname: the local name of the element
731: * @prefix: the element namespace prefix if available
732: * @URI: the element namespace name if available
733: *
734: * called when an ending tag has been processed.
735: */
736: static void
737: xmlTextReaderEndElementNs(void *ctx,
738: const xmlChar * localname,
739: const xmlChar * prefix,
740: const xmlChar * URI)
741: {
742: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
743: xmlTextReaderPtr reader = ctxt->_private;
744:
745: #ifdef DEBUG_CALLBACKS
746: printf("xmlTextReaderEndElementNs(%s)\n", localname);
747: #endif
748: if ((reader != NULL) && (reader->endElementNs != NULL)) {
749: reader->endElementNs(ctx, localname, prefix, URI);
750: }
751: }
752:
753:
754: /**
755: * xmlTextReaderCharacters:
756: * @ctx: the user data (XML parser context)
757: * @ch: a xmlChar string
758: * @len: the number of xmlChar
759: *
760: * receiving some chars from the parser.
761: */
762: static void
763: xmlTextReaderCharacters(void *ctx, const xmlChar *ch, int len)
764: {
765: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
766: xmlTextReaderPtr reader = ctxt->_private;
767:
768: #ifdef DEBUG_CALLBACKS
769: printf("xmlTextReaderCharacters()\n");
770: #endif
771: if ((reader != NULL) && (reader->characters != NULL)) {
772: reader->characters(ctx, ch, len);
773: }
774: }
775:
776: /**
777: * xmlTextReaderCDataBlock:
778: * @ctx: the user data (XML parser context)
779: * @value: The pcdata content
780: * @len: the block length
781: *
782: * called when a pcdata block has been parsed
783: */
784: static void
785: xmlTextReaderCDataBlock(void *ctx, const xmlChar *ch, int len)
786: {
787: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
788: xmlTextReaderPtr reader = ctxt->_private;
789:
790: #ifdef DEBUG_CALLBACKS
791: printf("xmlTextReaderCDataBlock()\n");
792: #endif
793: if ((reader != NULL) && (reader->cdataBlock != NULL)) {
794: reader->cdataBlock(ctx, ch, len);
795: }
796: }
797:
798: /**
799: * xmlTextReaderPushData:
800: * @reader: the xmlTextReaderPtr used
801: *
802: * Push data down the progressive parser until a significant callback
803: * got raised.
804: *
805: * Returns -1 in case of failure, 0 otherwise
806: */
807: static int
808: xmlTextReaderPushData(xmlTextReaderPtr reader) {
809: xmlBufferPtr inbuf;
810: int val, s;
811: xmlTextReaderState oldstate;
812:
813: if ((reader->input == NULL) || (reader->input->buffer == NULL))
814: return(-1);
815:
816: oldstate = reader->state;
817: reader->state = XML_TEXTREADER_NONE;
818: inbuf = reader->input->buffer;
819:
820: while (reader->state == XML_TEXTREADER_NONE) {
821: if (inbuf->use < reader->cur + CHUNK_SIZE) {
822: /*
823: * Refill the buffer unless we are at the end of the stream
824: */
825: if (reader->mode != XML_TEXTREADER_MODE_EOF) {
826: val = xmlParserInputBufferRead(reader->input, 4096);
827: if ((val == 0) &&
828: (inbuf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)) {
829: if (inbuf->use == reader->cur) {
830: reader->mode = XML_TEXTREADER_MODE_EOF;
831: reader->state = oldstate;
832: }
833: } else if (val < 0) {
834: reader->mode = XML_TEXTREADER_MODE_EOF;
835: reader->state = oldstate;
836: if ((oldstate != XML_TEXTREADER_START) ||
837: (reader->ctxt->myDoc != NULL))
838: return(val);
839: } else if (val == 0) {
840: /* mark the end of the stream and process the remains */
841: reader->mode = XML_TEXTREADER_MODE_EOF;
842: break;
843: }
844:
845: } else
846: break;
847: }
848: /*
849: * parse by block of CHUNK_SIZE bytes, various tests show that
850: * it's the best tradeoff at least on a 1.2GH Duron
851: */
852: if (inbuf->use >= reader->cur + CHUNK_SIZE) {
853: val = xmlParseChunk(reader->ctxt,
854: (const char *) &inbuf->content[reader->cur],
855: CHUNK_SIZE, 0);
856: reader->cur += CHUNK_SIZE;
857: if ((val != 0) || (reader->ctxt->wellFormed == 0))
858: return(-1);
859: } else {
860: s = inbuf->use - reader->cur;
861: val = xmlParseChunk(reader->ctxt,
862: (const char *) &inbuf->content[reader->cur],
863: s, 0);
864: reader->cur += s;
865: if ((val != 0) || (reader->ctxt->wellFormed == 0))
866: return(-1);
867: break;
868: }
869: }
870:
871: /*
872: * Discard the consumed input when needed and possible
873: */
874: if (reader->mode == XML_TEXTREADER_MODE_INTERACTIVE) {
875: if (inbuf->alloc != XML_BUFFER_ALLOC_IMMUTABLE) {
876: if ((reader->cur >= 4096) &&
877: (inbuf->use - reader->cur <= CHUNK_SIZE)) {
878: val = xmlBufferShrink(inbuf, reader->cur);
879: if (val >= 0) {
880: reader->cur -= val;
881: }
882: }
883: }
884: }
885:
886: /*
887: * At the end of the stream signal that the work is done to the Push
888: * parser.
889: */
890: else if (reader->mode == XML_TEXTREADER_MODE_EOF) {
891: if (reader->state != XML_TEXTREADER_DONE) {
892: s = inbuf->use - reader->cur;
893: val = xmlParseChunk(reader->ctxt,
894: (const char *) &inbuf->content[reader->cur],
895: s, 1);
896: reader->cur = inbuf->use;
897: reader->state = XML_TEXTREADER_DONE;
898: if ((val != 0) || (reader->ctxt->wellFormed == 0))
899: return(-1);
900: }
901: }
902: reader->state = oldstate;
903: return(0);
904: }
905:
906: #ifdef LIBXML_REGEXP_ENABLED
907: /**
908: * xmlTextReaderValidatePush:
909: * @reader: the xmlTextReaderPtr used
910: *
911: * Push the current node for validation
912: */
913: static void
914: xmlTextReaderValidatePush(xmlTextReaderPtr reader ATTRIBUTE_UNUSED) {
915: xmlNodePtr node = reader->node;
916:
917: #ifdef LIBXML_VALID_ENABLED
918: if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
919: (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
920: if ((node->ns == NULL) || (node->ns->prefix == NULL)) {
921: reader->ctxt->valid &= xmlValidatePushElement(&reader->ctxt->vctxt,
922: reader->ctxt->myDoc, node, node->name);
923: } else {
924: /* TODO use the BuildQName interface */
925: xmlChar *qname;
926:
927: qname = xmlStrdup(node->ns->prefix);
928: qname = xmlStrcat(qname, BAD_CAST ":");
929: qname = xmlStrcat(qname, node->name);
930: reader->ctxt->valid &= xmlValidatePushElement(&reader->ctxt->vctxt,
931: reader->ctxt->myDoc, node, qname);
932: if (qname != NULL)
933: xmlFree(qname);
934: }
935: }
936: #endif /* LIBXML_VALID_ENABLED */
937: #ifdef LIBXML_SCHEMAS_ENABLED
938: if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
939: (reader->rngValidCtxt != NULL)) {
940: int ret;
941:
942: if (reader->rngFullNode != NULL) return;
943: ret = xmlRelaxNGValidatePushElement(reader->rngValidCtxt,
944: reader->ctxt->myDoc,
945: node);
946: if (ret == 0) {
947: /*
948: * this element requires a full tree
949: */
950: node = xmlTextReaderExpand(reader);
951: if (node == NULL) {
952: printf("Expand failed !\n");
953: ret = -1;
954: } else {
955: ret = xmlRelaxNGValidateFullElement(reader->rngValidCtxt,
956: reader->ctxt->myDoc,
957: node);
958: reader->rngFullNode = node;
959: }
960: }
961: if (ret != 1)
962: reader->rngValidErrors++;
963: }
964: #endif
965: }
966:
967: /**
968: * xmlTextReaderValidateCData:
969: * @reader: the xmlTextReaderPtr used
970: * @data: pointer to the CData
971: * @len: lenght of the CData block in bytes.
972: *
973: * Push some CData for validation
974: */
975: static void
976: xmlTextReaderValidateCData(xmlTextReaderPtr reader,
977: const xmlChar *data, int len) {
978: #ifdef LIBXML_VALID_ENABLED
979: if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
980: (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
981: reader->ctxt->valid &= xmlValidatePushCData(&reader->ctxt->vctxt,
982: data, len);
983: }
984: #endif /* LIBXML_VALID_ENABLED */
985: #ifdef LIBXML_SCHEMAS_ENABLED
986: if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
987: (reader->rngValidCtxt != NULL)) {
988: int ret;
989:
990: if (reader->rngFullNode != NULL) return;
991: ret = xmlRelaxNGValidatePushCData(reader->rngValidCtxt, data, len);
992: if (ret != 1)
993: reader->rngValidErrors++;
994: }
995: #endif
996: }
997:
998: /**
999: * xmlTextReaderValidatePop:
1000: * @reader: the xmlTextReaderPtr used
1001: *
1002: * Pop the current node from validation
1003: */
1004: static void
1005: xmlTextReaderValidatePop(xmlTextReaderPtr reader) {
1006: xmlNodePtr node = reader->node;
1007:
1008: #ifdef LIBXML_VALID_ENABLED
1009: if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
1010: (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
1011: if ((node->ns == NULL) || (node->ns->prefix == NULL)) {
1012: reader->ctxt->valid &= xmlValidatePopElement(&reader->ctxt->vctxt,
1013: reader->ctxt->myDoc, node, node->name);
1014: } else {
1015: /* TODO use the BuildQName interface */
1016: xmlChar *qname;
1017:
1018: qname = xmlStrdup(node->ns->prefix);
1019: qname = xmlStrcat(qname, BAD_CAST ":");
1020: qname = xmlStrcat(qname, node->name);
1021: reader->ctxt->valid &= xmlValidatePopElement(&reader->ctxt->vctxt,
1022: reader->ctxt->myDoc, node, qname);
1023: if (qname != NULL)
1024: xmlFree(qname);
1025: }
1026: }
1027: #endif /* LIBXML_VALID_ENABLED */
1028: #ifdef LIBXML_SCHEMAS_ENABLED
1029: if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
1030: (reader->rngValidCtxt != NULL)) {
1031: int ret;
1032:
1033: if (reader->rngFullNode != NULL) {
1034: if (node == reader->rngFullNode)
1035: reader->rngFullNode = NULL;
1036: return;
1037: }
1038: ret = xmlRelaxNGValidatePopElement(reader->rngValidCtxt,
1039: reader->ctxt->myDoc,
1040: node);
1041: if (ret != 1)
1042: reader->rngValidErrors++;
1043: }
1044: #endif
1045: }
1046:
1047: /**
1048: * xmlTextReaderValidateEntity:
1049: * @reader: the xmlTextReaderPtr used
1050: *
1051: * Handle the validation when an entity reference is encountered and
1052: * entity substitution is not activated. As a result the parser interface
1053: * must walk through the entity and do the validation calls
1054: */
1055: static void
1056: xmlTextReaderValidateEntity(xmlTextReaderPtr reader) {
1057: xmlNodePtr oldnode = reader->node;
1058: xmlNodePtr node = reader->node;
1059: xmlParserCtxtPtr ctxt = reader->ctxt;
1060:
1061: do {
1062: if (node->type == XML_ENTITY_REF_NODE) {
1063: /*
1064: * Case where the underlying tree is not availble, lookup the entity
1065: * and walk it.
1066: */
1067: if ((node->children == NULL) && (ctxt->sax != NULL) &&
1068: (ctxt->sax->getEntity != NULL)) {
1069: node->children = (xmlNodePtr)
1070: ctxt->sax->getEntity(ctxt, node->name);
1071: }
1072:
1073: if ((node->children != NULL) &&
1074: (node->children->type == XML_ENTITY_DECL) &&
1075: (node->children->children != NULL)) {
1076: xmlTextReaderEntPush(reader, node);
1077: node = node->children->children;
1078: continue;
1079: } else {
1080: /*
1081: * The error has probably be raised already.
1082: */
1083: if (node == oldnode)
1084: break;
1085: node = node->next;
1086: }
1087: #ifdef LIBXML_REGEXP_ENABLED
1088: } else if (node->type == XML_ELEMENT_NODE) {
1089: reader->node = node;
1090: xmlTextReaderValidatePush(reader);
1091: } else if ((node->type == XML_TEXT_NODE) ||
1092: (node->type == XML_CDATA_SECTION_NODE)) {
1093: xmlTextReaderValidateCData(reader, node->content,
1094: xmlStrlen(node->content));
1095: #endif
1096: }
1097:
1098: /*
1099: * go to next node
1100: */
1101: if (node->children != NULL) {
1102: node = node->children;
1103: continue;
1104: } else if (node->type == XML_ELEMENT_NODE) {
1105: xmlTextReaderValidatePop(reader);
1106: }
1107: if (node->next != NULL) {
1108: node = node->next;
1109: continue;
1110: }
1111: do {
1112: node = node->parent;
1113: if (node->type == XML_ELEMENT_NODE) {
1114: xmlNodePtr tmp;
1115: if (reader->entNr == 0) {
1116: while ((tmp = node->last) != NULL) {
1117: if ((tmp->extra & NODE_IS_PRESERVED) == 0) {
1118: xmlUnlinkNode(tmp);
1119: xmlTextReaderFreeNode(reader, tmp);
1120: } else
1121: break;
1122: }
1123: }
1124: reader->node = node;
1125: xmlTextReaderValidatePop(reader);
1126: }
1127: if ((node->type == XML_ENTITY_DECL) &&
1128: (reader->ent != NULL) && (reader->ent->children == node)) {
1129: node = xmlTextReaderEntPop(reader);
1130: }
1131: if (node == oldnode)
1132: break;
1133: if (node->next != NULL) {
1134: node = node->next;
1135: break;
1136: }
1137: } while ((node != NULL) && (node != oldnode));
1138: } while ((node != NULL) && (node != oldnode));
1139: reader->node = oldnode;
1140: }
1141: #endif /* LIBXML_REGEXP_ENABLED */
1142:
1143:
1144: /**
1145: * xmlTextReaderGetSuccessor:
1146: * @cur: the current node
1147: *
1148: * Get the successor of a node if available.
1149: *
1150: * Returns the successor node or NULL
1151: */
1152: static xmlNodePtr
1153: xmlTextReaderGetSuccessor(xmlNodePtr cur) {
1154: if (cur == NULL) return(NULL) ; /* ERROR */
1155: if (cur->next != NULL) return(cur->next) ;
1156: do {
1157: cur = cur->parent;
1158: if (cur == NULL) break;
1159: if (cur->next != NULL) return(cur->next);
1160: } while (cur != NULL);
1161: return(cur);
1162: }
1163:
1164: /**
1165: * xmlTextReaderDoExpand:
1166: * @reader: the xmlTextReaderPtr used
1167: *
1168: * Makes sure that the current node is fully read as well as all its
1169: * descendant. It means the full DOM subtree must be available at the
1170: * end of the call.
1171: *
1172: * Returns 1 if the node was expanded successfully, 0 if there is no more
1173: * nodes to read, or -1 in case of error
1174: */
1175: static int
1176: xmlTextReaderDoExpand(xmlTextReaderPtr reader) {
1177: int val;
1178:
1179: if ((reader == NULL) || (reader->node == NULL) || (reader->ctxt == NULL))
1180: return(-1);
1181: do {
1182: if (reader->ctxt->instate == XML_PARSER_EOF) return(1);
1183:
1184: if (xmlTextReaderGetSuccessor(reader->node) != NULL)
1185: return(1);
1186: if (reader->ctxt->nodeNr < reader->depth)
1187: return(1);
1188: if (reader->mode == XML_TEXTREADER_MODE_EOF)
1189: return(1);
1190: val = xmlTextReaderPushData(reader);
1191: if (val < 0){
1192: reader->mode = XML_TEXTREADER_MODE_ERROR;
1193: return(-1);
1194: }
1195: } while(reader->mode != XML_TEXTREADER_MODE_EOF);
1196: return(1);
1197: }
1198:
1199: /**
1200: * xmlTextReaderCollectSiblings:
1201: * @node: the first child
1202: *
1203: * Traverse depth-first through all sibling nodes and their children
1204: * nodes and concatenate their content. This is an auxiliary function
1205: * to xmlTextReaderReadString.
1206: *
1207: * Returns a string containing the content, or NULL in case of error.
1208: */
1209: static xmlChar *
1210: xmlTextReaderCollectSiblings(xmlNodePtr node)
1211: {
1212: xmlBufferPtr buffer;
1213: xmlChar *ret;
1214:
1215: buffer = xmlBufferCreate();
1216: if (buffer == NULL)
1217: return NULL;
1218:
1219: for ( ; node != NULL; node = node->next) {
1220: switch (node->type) {
1221: case XML_TEXT_NODE:
1222: case XML_CDATA_SECTION_NODE:
1223: xmlBufferCat(buffer, node->content);
1224: break;
1225: case XML_ELEMENT_NODE: {
1226: xmlChar *tmp;
1227:
1228: tmp = xmlTextReaderCollectSiblings(node->children);
1229: xmlBufferCat(buffer, tmp);
1230: xmlFree(tmp);
1231: break;
1232: }
1233: default:
1234: break;
1235: }
1236: }
1237: ret = buffer->content;
1238: buffer->content = NULL;
1239: xmlBufferFree(buffer);
1240: return(ret);
1241: }
1242:
1243: /**
1244: * xmlTextReaderRead:
1245: * @reader: the xmlTextReaderPtr used
1246: *
1247: * Moves the position of the current instance to the next node in
1248: * the stream, exposing its properties.
1249: *
1250: * Returns 1 if the node was read successfully, 0 if there is no more
1251: * nodes to read, or -1 in case of error
1252: */
1253: int
1254: xmlTextReaderRead(xmlTextReaderPtr reader) {
1255: int val, olddepth = 0;
1256: xmlTextReaderState oldstate = XML_TEXTREADER_START;
1257: xmlNodePtr oldnode = NULL;
1258:
1259:
1260: if (reader == NULL)
1261: return(-1);
1262: reader->curnode = NULL;
1263: if (reader->doc != NULL)
1264: return(xmlTextReaderReadTree(reader));
1265: if (reader->ctxt == NULL)
1266: return(-1);
1267: if (reader->ctxt->wellFormed != 1)
1268: return(-1);
1269:
1270: #ifdef DEBUG_READER
1271: fprintf(stderr, "\nREAD ");
1272: DUMP_READER
1273: #endif
1274: if (reader->mode == XML_TEXTREADER_MODE_INITIAL) {
1275: reader->mode = XML_TEXTREADER_MODE_INTERACTIVE;
1276: /*
1277: * Initial state
1278: */
1279: do {
1280: val = xmlTextReaderPushData(reader);
1281: if (val < 0){
1282: reader->mode = XML_TEXTREADER_MODE_ERROR;
1283: reader->state = XML_TEXTREADER_ERROR;
1284: return(-1);
1285: }
1286: } while ((reader->ctxt->node == NULL) &&
1287: ((reader->mode != XML_TEXTREADER_MODE_EOF) &&
1288: (reader->state != XML_TEXTREADER_DONE)));
1289: if (reader->ctxt->node == NULL) {
1290: if (reader->ctxt->myDoc != NULL) {
1291: reader->node = reader->ctxt->myDoc->children;
1292: }
1293: if (reader->node == NULL){
1294: reader->mode = XML_TEXTREADER_MODE_ERROR;
1295: reader->state = XML_TEXTREADER_ERROR;
1296: return(-1);
1297: }
1298: reader->state = XML_TEXTREADER_ELEMENT;
1299: } else {
1300: if (reader->ctxt->myDoc != NULL) {
1301: reader->node = reader->ctxt->myDoc->children;
1302: }
1303: if (reader->node == NULL)
1304: reader->node = reader->ctxt->nodeTab[0];
1305: reader->state = XML_TEXTREADER_ELEMENT;
1306: }
1307: reader->depth = 0;
1308: reader->ctxt->parseMode = XML_PARSE_READER;
1309: goto node_found;
1310: }
1311: oldstate = reader->state;
1312: olddepth = reader->ctxt->nodeNr;
1313: oldnode = reader->node;
1314:
1315: get_next_node:
1316: if (reader->node == NULL) {
1317: if (reader->mode == XML_TEXTREADER_MODE_EOF)
1318: return(0);
1319: else
1320: return(-1);
1321: }
1322:
1323: /*
1324: * If we are not backtracking on ancestors or examined nodes,
1325: * that the parser didn't finished or that we arent at the end
1326: * of stream, continue processing.
1327: */
1328: while ((reader->node != NULL) && (reader->node->next == NULL) &&
1329: (reader->ctxt->nodeNr == olddepth) &&
1330: ((oldstate == XML_TEXTREADER_BACKTRACK) ||
1331: (reader->node->children == NULL) ||
1332: (reader->node->type == XML_ENTITY_REF_NODE) ||
1333: ((reader->node->children != NULL) &&
1334: (reader->node->children->type == XML_TEXT_NODE) &&
1335: (reader->node->children->next == NULL)) ||
1336: (reader->node->type == XML_DTD_NODE) ||
1337: (reader->node->type == XML_DOCUMENT_NODE) ||
1338: (reader->node->type == XML_HTML_DOCUMENT_NODE)) &&
1339: ((reader->ctxt->node == NULL) ||
1340: (reader->ctxt->node == reader->node) ||
1341: (reader->ctxt->node == reader->node->parent)) &&
1342: (reader->ctxt->instate != XML_PARSER_EOF)) {
1343: val = xmlTextReaderPushData(reader);
1344: if (val < 0){
1345: reader->mode = XML_TEXTREADER_MODE_ERROR;
1346: reader->state = XML_TEXTREADER_ERROR;
1347: return(-1);
1348: }
1349: if (reader->node == NULL)
1350: goto node_end;
1351: }
1352: if (oldstate != XML_TEXTREADER_BACKTRACK) {
1353: if ((reader->node->children != NULL) &&
1354: (reader->node->type != XML_ENTITY_REF_NODE) &&
1355: (reader->node->type != XML_XINCLUDE_START) &&
1356: (reader->node->type != XML_DTD_NODE)) {
1357: reader->node = reader->node->children;
1358: reader->depth++;
1359: reader->state = XML_TEXTREADER_ELEMENT;
1360: goto node_found;
1361: }
1362: }
1363: if (reader->node->next != NULL) {
1364: if ((oldstate == XML_TEXTREADER_ELEMENT) &&
1365: (reader->node->type == XML_ELEMENT_NODE) &&
1366: (reader->node->children == NULL) &&
1367: ((reader->node->extra & NODE_IS_EMPTY) == 0)
1368: #ifdef LIBXML_XINCLUDE_ENABLED
1369: && (reader->in_xinclude <= 0)
1370: #endif
1371: ) {
1372: reader->state = XML_TEXTREADER_END;
1373: goto node_found;
1374: }
1375: #ifdef LIBXML_REGEXP_ENABLED
1376: if ((reader->validate) &&
1377: (reader->node->type == XML_ELEMENT_NODE))
1378: xmlTextReaderValidatePop(reader);
1379: #endif /* LIBXML_REGEXP_ENABLED */
1380: if ((reader->preserves > 0) &&
1381: (reader->node->extra & NODE_IS_SPRESERVED))
1382: reader->preserves--;
1383: reader->node = reader->node->next;
1384: reader->state = XML_TEXTREADER_ELEMENT;
1385:
1386: /*
1387: * Cleanup of the old node
1388: */
1389: if ((reader->preserves == 0) &&
1390: #ifdef LIBXML_XINCLUDE_ENABLED
1391: (reader->in_xinclude == 0) &&
1392: #endif
1393: (reader->entNr == 0) &&
1394: (reader->node->prev != NULL) &&
1395: (reader->node->prev->type != XML_DTD_NODE) &&
1396: (reader->entNr == 0)) {
1397: xmlNodePtr tmp = reader->node->prev;
1398: if ((tmp->extra & NODE_IS_PRESERVED) == 0) {
1399: xmlUnlinkNode(tmp);
1400: xmlTextReaderFreeNode(reader, tmp);
1401: }
1402: }
1403:
1404: goto node_found;
1405: }
1406: if ((oldstate == XML_TEXTREADER_ELEMENT) &&
1407: (reader->node->type == XML_ELEMENT_NODE) &&
1408: (reader->node->children == NULL) &&
1409: ((reader->node->extra & NODE_IS_EMPTY) == 0)) {;
1410: reader->state = XML_TEXTREADER_END;
1411: goto node_found;
1412: }
1413: #ifdef LIBXML_REGEXP_ENABLED
1414: if ((reader->validate) && (reader->node->type == XML_ELEMENT_NODE))
1415: xmlTextReaderValidatePop(reader);
1416: #endif /* LIBXML_REGEXP_ENABLED */
1417: if ((reader->preserves > 0) &&
1418: (reader->node->extra & NODE_IS_SPRESERVED))
1419: reader->preserves--;
1420: reader->node = reader->node->parent;
1421: if ((reader->node == NULL) ||
1422: (reader->node->type == XML_DOCUMENT_NODE) ||
1423: #ifdef LIBXML_DOCB_ENABLED
1424: (reader->node->type == XML_DOCB_DOCUMENT_NODE) ||
1425: #endif
1426: (reader->node->type == XML_HTML_DOCUMENT_NODE)) {
1427: if (reader->mode != XML_TEXTREADER_MODE_EOF) {
1428: val = xmlParseChunk(reader->ctxt, "", 0, 1);
1429: reader->state = XML_TEXTREADER_DONE;
1430: if (val != 0)
1431: return(-1);
1432: }
1433: reader->node = NULL;
1434: reader->depth = -1;
1435:
1436: /*
1437: * Cleanup of the old node
1438: */
1439: if ((oldnode != NULL) && (reader->preserves == 0) &&
1440: #ifdef LIBXML_XINCLUDE_ENABLED
1441: (reader->in_xinclude == 0) &&
1442: #endif
1443: (reader->entNr == 0) &&
1444: (oldnode->type != XML_DTD_NODE) &&
1445: ((oldnode->extra & NODE_IS_PRESERVED) == 0) &&
1446: (reader->entNr == 0)) {
1447: xmlUnlinkNode(oldnode);
1448: xmlTextReaderFreeNode(reader, oldnode);
1449: }
1450:
1451: goto node_end;
1452: }
1453: if ((reader->preserves == 0) &&
1454: #ifdef LIBXML_XINCLUDE_ENABLED
1455: (reader->in_xinclude == 0) &&
1456: #endif
1457: (reader->entNr == 0) &&
1458: (reader->node->last != NULL) &&
1459: ((reader->node->last->extra & NODE_IS_PRESERVED) == 0)) {
1460: xmlNodePtr tmp = reader->node->last;
1461: xmlUnlinkNode(tmp);
1462: xmlTextReaderFreeNode(reader, tmp);
1463: }
1464: reader->depth--;
1465: reader->state = XML_TEXTREADER_BACKTRACK;
1466:
1467: node_found:
1468: DUMP_READER
1469:
1470: /*
1471: * If we are in the middle of a piece of CDATA make sure it's finished
1472: */
1473: if ((reader->node != NULL) &&
1474: (reader->node->next == NULL) &&
1475: ((reader->node->type == XML_TEXT_NODE) ||
1476: (reader->node->type == XML_CDATA_SECTION_NODE))) {
1477: if (xmlTextReaderExpand(reader) == NULL)
1478: return -1;
1479: }
1480:
1481: #ifdef LIBXML_XINCLUDE_ENABLED
1482: /*
1483: * Handle XInclude if asked for
1484: */
1485: if ((reader->xinclude) && (reader->node != NULL) &&
1486: (reader->node->type == XML_ELEMENT_NODE) &&
1487: (reader->node->ns != NULL) &&
1488: ((xmlStrEqual(reader->node->ns->href, XINCLUDE_NS)) ||
1489: (xmlStrEqual(reader->node->ns->href, XINCLUDE_OLD_NS)))) {
1490: if (reader->xincctxt == NULL) {
1491: reader->xincctxt = xmlXIncludeNewContext(reader->ctxt->myDoc);
1492: xmlXIncludeSetFlags(reader->xincctxt,
1493: reader->parserFlags & (~XML_PARSE_NOXINCNODE));
1494: }
1495: /*
1496: * expand that node and process it
1497: */
1498: if (xmlTextReaderExpand(reader) == NULL)
1499: return -1;
1500: xmlXIncludeProcessNode(reader->xincctxt, reader->node);
1501: }
1502: if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_START)) {
1503: reader->in_xinclude++;
1504: goto get_next_node;
1505: }
1506: if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_END)) {
1507: reader->in_xinclude--;
1508: goto get_next_node;
1509: }
1510: #endif
1511: /*
1512: * Handle entities enter and exit when in entity replacement mode
1513: */
1514: if ((reader->node != NULL) &&
1515: (reader->node->type == XML_ENTITY_REF_NODE) &&
1516: (reader->ctxt != NULL) && (reader->ctxt->replaceEntities == 1)) {
1517: /*
1518: * Case where the underlying tree is not availble, lookup the entity
1519: * and walk it.
1520: */
1521: if ((reader->node->children == NULL) && (reader->ctxt->sax != NULL) &&
1522: (reader->ctxt->sax->getEntity != NULL)) {
1523: reader->node->children = (xmlNodePtr)
1524: reader->ctxt->sax->getEntity(reader->ctxt, reader->node->name);
1525: }
1526:
1527: if ((reader->node->children != NULL) &&
1528: (reader->node->children->type == XML_ENTITY_DECL) &&
1529: (reader->node->children->children != NULL)) {
1530: xmlTextReaderEntPush(reader, reader->node);
1531: reader->node = reader->node->children->children;
1532: }
1533: #ifdef LIBXML_REGEXP_ENABLED
1534: } else if ((reader->node != NULL) &&
1535: (reader->node->type == XML_ENTITY_REF_NODE) &&
1536: (reader->ctxt != NULL) && (reader->validate)) {
1537: xmlTextReaderValidateEntity(reader);
1538: #endif /* LIBXML_REGEXP_ENABLED */
1539: }
1540: if ((reader->node != NULL) &&
1541: (reader->node->type == XML_ENTITY_DECL) &&
1542: (reader->ent != NULL) && (reader->ent->children == reader->node)) {
1543: reader->node = xmlTextReaderEntPop(reader);
1544: reader->depth++;
1545: goto get_next_node;
1546: }
1547: #ifdef LIBXML_REGEXP_ENABLED
1548: if ((reader->validate) && (reader->node != NULL)) {
1549: xmlNodePtr node = reader->node;
1550:
1551: if ((node->type == XML_ELEMENT_NODE) &&
1552: ((reader->state != XML_TEXTREADER_END) &&
1553: (reader->state != XML_TEXTREADER_BACKTRACK))) {
1554: xmlTextReaderValidatePush(reader);
1555: } else if ((node->type == XML_TEXT_NODE) ||
1556: (node->type == XML_CDATA_SECTION_NODE)) {
1557: xmlTextReaderValidateCData(reader, node->content,
1558: xmlStrlen(node->content));
1559: }
1560: }
1561: #endif /* LIBXML_REGEXP_ENABLED */
1562: #ifdef LIBXML_PATTERN_ENABLED
1563: if ((reader->patternNr > 0) && (reader->state != XML_TEXTREADER_END) &&
1564: (reader->state != XML_TEXTREADER_BACKTRACK)) {
1565: int i;
1566: for (i = 0;i < reader->patternNr;i++) {
1567: if (xmlPatternMatch(reader->patternTab[i], reader->node) == 1) {
1568: xmlTextReaderPreserve(reader);
1569: break;
1570: }
1571: }
1572: }
1573: #endif /* LIBXML_PATTERN_ENABLED */
1574: #ifdef LIBXML_SCHEMAS_ENABLED
1575: if ((reader->validate == XML_TEXTREADER_VALIDATE_XSD) &&
1576: (reader->xsdValidErrors == 0) &&
1577: (reader->xsdValidCtxt != NULL)) {
1578: reader->xsdValidErrors = !xmlSchemaIsValid(reader->xsdValidCtxt);
1579: }
1580: #endif /* LIBXML_PATTERN_ENABLED */
1581: return(1);
1582: node_end:
1583: reader->state = XML_TEXTREADER_DONE;
1584: return(0);
1585: }
1586:
1587: /**
1588: * xmlTextReaderReadState:
1589: * @reader: the xmlTextReaderPtr used
1590: *
1591: * Gets the read state of the reader.
1592: *
1593: * Returns the state value, or -1 in case of error
1594: */
1595: int
1596: xmlTextReaderReadState(xmlTextReaderPtr reader) {
1597: if (reader == NULL)
1598: return(-1);
1599: return(reader->mode);
1600: }
1601:
1602: /**
1603: * xmlTextReaderExpand:
1604: * @reader: the xmlTextReaderPtr used
1605: *
1606: * Reads the contents of the current node and the full subtree. It then makes
1607: * the subtree available until the next xmlTextReaderRead() call
1608: *
1609: * Returns a node pointer valid until the next xmlTextReaderRead() call
1610: * or NULL in case of error.
1611: */
1612: xmlNodePtr
1613: xmlTextReaderExpand(xmlTextReaderPtr reader) {
1614: if ((reader == NULL) || (reader->node == NULL))
1615: return(NULL);
1616: if (reader->doc != NULL)
1617: return(reader->node);
1618: if (reader->ctxt == NULL)
1619: return(NULL);
1620: if (xmlTextReaderDoExpand(reader) < 0)
1621: return(NULL);
1622: return(reader->node);
1623: }
1624:
1625: /**
1626: * xmlTextReaderNext:
1627: * @reader: the xmlTextReaderPtr used
1628: *
1629: * Skip to the node following the current one in document order while
1630: * avoiding the subtree if any.
1631: *
1632: * Returns 1 if the node was read successfully, 0 if there is no more
1633: * nodes to read, or -1 in case of error
1634: */
1635: int
1636: xmlTextReaderNext(xmlTextReaderPtr reader) {
1637: int ret;
1638: xmlNodePtr cur;
1639:
1640: if (reader == NULL)
1641: return(-1);
1642: if (reader->doc != NULL)
1643: return(xmlTextReaderNextTree(reader));
1644: cur = reader->node;
1645: if ((cur == NULL) || (cur->type != XML_ELEMENT_NODE))
1646: return(xmlTextReaderRead(reader));
1647: if (reader->state == XML_TEXTREADER_END || reader->state == XML_TEXTREADER_BACKTRACK)
1648: return(xmlTextReaderRead(reader));
1649: if (cur->extra & NODE_IS_EMPTY)
1650: return(xmlTextReaderRead(reader));
1651: do {
1652: ret = xmlTextReaderRead(reader);
1653: if (ret != 1)
1654: return(ret);
1655: } while (reader->node != cur);
1656: return(xmlTextReaderRead(reader));
1657: }
1658:
1659: #ifdef LIBXML_WRITER_ENABLED
1660: /**
1661: * xmlTextReaderReadInnerXml:
1662: * @reader: the xmlTextReaderPtr used
1663: *
1664: * Reads the contents of the current node, including child nodes and markup.
1665: *
1666: * Returns a string containing the XML content, or NULL if the current node
1667: * is neither an element nor attribute, or has no child nodes. The
1668: * string must be deallocated by the caller.
1669: */
1670: xmlChar *
1671: xmlTextReaderReadInnerXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
1672: {
1673: xmlChar *resbuf;
1674: xmlNodePtr node, cur_node;
1675: xmlBufferPtr buff, buff2;
1676: xmlDocPtr doc;
1677:
1678: if (xmlTextReaderExpand(reader) == NULL) {
1679: return NULL;
1680: }
1681: doc = reader->doc;
1682: buff = xmlBufferCreate();
1683: for (cur_node = reader->node->children; cur_node != NULL;
1684: cur_node = cur_node->next) {
1685: node = xmlDocCopyNode(cur_node, doc, 1);
1686: buff2 = xmlBufferCreate();
1687: if (xmlNodeDump(buff2, doc, node, 0, 0) == -1) {
1688: xmlFreeNode(node);
1689: xmlBufferFree(buff2);
1690: xmlBufferFree(buff);
1691: return NULL;
1692: }
1693: xmlBufferCat(buff, buff2->content);
1694: xmlFreeNode(node);
1695: xmlBufferFree(buff2);
1696: }
1697: resbuf = buff->content;
1698: buff->content = NULL;
1699:
1700: xmlBufferFree(buff);
1701: return resbuf;
1702: }
1703: #endif
1704:
1705: #ifdef LIBXML_WRITER_ENABLED
1706: /**
1707: * xmlTextReaderReadOuterXml:
1708: * @reader: the xmlTextReaderPtr used
1709: *
1710: * Reads the contents of the current node, including child nodes and markup.
1711: *
1712: * Returns a string containing the node and any XML content, or NULL if the
1713: * current node cannot be serialized. The string must be deallocated
1714: * by the caller.
1715: */
1716: xmlChar *
1717: xmlTextReaderReadOuterXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
1718: {
1719: xmlChar *resbuf;
1720: xmlNodePtr node;
1721: xmlBufferPtr buff;
1722: xmlDocPtr doc;
1723:
1724: node = reader->node;
1725: doc = reader->doc;
1726: if (xmlTextReaderExpand(reader) == NULL) {
1727: return NULL;
1728: }
1729: if (node->type == XML_DTD_NODE) {
1730: node = (xmlNodePtr) xmlCopyDtd((xmlDtdPtr) node);
1731: } else {
1732: node = xmlDocCopyNode(node, doc, 1);
1733: }
1734: buff = xmlBufferCreate();
1735: if (xmlNodeDump(buff, doc, node, 0, 0) == -1) {
1736: xmlFreeNode(node);
1737: xmlBufferFree(buff);
1738: return NULL;
1739: }
1740:
1741: resbuf = buff->content;
1742: buff->content = NULL;
1743:
1744: xmlFreeNode(node);
1745: xmlBufferFree(buff);
1746: return resbuf;
1747: }
1748: #endif
1749:
1750: /**
1751: * xmlTextReaderReadString:
1752: * @reader: the xmlTextReaderPtr used
1753: *
1754: * Reads the contents of an element or a text node as a string.
1755: *
1756: * Returns a string containing the contents of the Element or Text node,
1757: * or NULL if the reader is positioned on any other type of node.
1758: * The string must be deallocated by the caller.
1759: */
1760: xmlChar *
1761: xmlTextReaderReadString(xmlTextReaderPtr reader)
1762: {
1763: xmlNodePtr node;
1764:
1765: if ((reader == NULL) || (reader->node == NULL))
1766: return(NULL);
1767:
1768: node = (reader->curnode != NULL) ? reader->curnode : reader->node;
1769: switch (node->type) {
1770: case XML_TEXT_NODE:
1771: if (node->content != NULL)
1772: return(xmlStrdup(node->content));
1773: break;
1774: case XML_ELEMENT_NODE:
1775: if (xmlTextReaderDoExpand(reader) != -1) {
1776: return xmlTextReaderCollectSiblings(node->children);
1777: }
1778: case XML_ATTRIBUTE_NODE:
1779: TODO
1780: break;
1781: default:
1782: break;
1783: }
1784: return(NULL);
1785: }
1786:
1787: #if 0
1788: /**
1789: * xmlTextReaderReadBase64:
1790: * @reader: the xmlTextReaderPtr used
1791: * @array: a byte array to store the content.
1792: * @offset: the zero-based index into array where the method should
1793: * begin to write.
1794: * @len: the number of bytes to write.
1795: *
1796: * Reads and decodes the Base64 encoded contents of an element and
1797: * stores the result in a byte buffer.
1798: *
1799: * Returns the number of bytes written to array, or zero if the current
1800: * instance is not positioned on an element or -1 in case of error.
1801: */
1802: int
1803: xmlTextReaderReadBase64(xmlTextReaderPtr reader,
1804: unsigned char *array ATTRIBUTE_UNUSED,
1805: int offset ATTRIBUTE_UNUSED,
1806: int len ATTRIBUTE_UNUSED) {
1807: if ((reader == NULL) || (reader->ctxt == NULL))
1808: return(-1);
1809: if (reader->ctxt->wellFormed != 1)
1810: return(-1);
1811:
1812: if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
1813: return(0);
1814: TODO
1815: return(0);
1816: }
1817:
1818: /**
1819: * xmlTextReaderReadBinHex:
1820: * @reader: the xmlTextReaderPtr used
1821: * @array: a byte array to store the content.
1822: * @offset: the zero-based index into array where the method should
1823: * begin to write.
1824: * @len: the number of bytes to write.
1825: *
1826: * Reads and decodes the BinHex encoded contents of an element and
1827: * stores the result in a byte buffer.
1828: *
1829: * Returns the number of bytes written to array, or zero if the current
1830: * instance is not positioned on an element or -1 in case of error.
1831: */
1832: int
1833: xmlTextReaderReadBinHex(xmlTextReaderPtr reader,
1834: unsigned char *array ATTRIBUTE_UNUSED,
1835: int offset ATTRIBUTE_UNUSED,
1836: int len ATTRIBUTE_UNUSED) {
1837: if ((reader == NULL) || (reader->ctxt == NULL))
1838: return(-1);
1839: if (reader->ctxt->wellFormed != 1)
1840: return(-1);
1841:
1842: if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
1843: return(0);
1844: TODO
1845: return(0);
1846: }
1847: #endif
1848:
1849: /************************************************************************
1850: * *
1851: * Operating on a preparsed tree *
1852: * *
1853: ************************************************************************/
1854: static int
1855: xmlTextReaderNextTree(xmlTextReaderPtr reader)
1856: {
1857: if (reader == NULL)
1858: return(-1);
1859:
1860: if (reader->state == XML_TEXTREADER_END)
1861: return(0);
1862:
1863: if (reader->node == NULL) {
1864: if (reader->doc->children == NULL) {
1865: reader->state = XML_TEXTREADER_END;
1866: return(0);
1867: }
1868:
1869: reader->node = reader->doc->children;
1870: reader->state = XML_TEXTREADER_START;
1871: return(1);
1872: }
1873:
1874: if (reader->state != XML_TEXTREADER_BACKTRACK) {
1875: /* Here removed traversal to child, because we want to skip the subtree,
1876: replace with traversal to sibling to skip subtree */
1877: if (reader->node->next != 0) {
1878: /* Move to sibling if present,skipping sub-tree */
1879: reader->node = reader->node->next;
1880: reader->state = XML_TEXTREADER_START;
1881: return(1);
1882: }
1883:
1884: /* if reader->node->next is NULL mean no subtree for current node,
1885: so need to move to sibling of parent node if present */
1886: if ((reader->node->type == XML_ELEMENT_NODE) ||
1887: (reader->node->type == XML_ATTRIBUTE_NODE)) {
1888: reader->state = XML_TEXTREADER_BACKTRACK;
1889: /* This will move to parent if present */
1890: xmlTextReaderRead(reader);
1891: }
1892: }
1893:
1894: if (reader->node->next != 0) {
1895: reader->node = reader->node->next;
1896: reader->state = XML_TEXTREADER_START;
1897: return(1);
1898: }
1899:
1900: if (reader->node->parent != 0) {
1901: if (reader->node->parent->type == XML_DOCUMENT_NODE) {
1902: reader->state = XML_TEXTREADER_END;
1903: return(0);
1904: }
1905:
1906: reader->node = reader->node->parent;
1907: reader->depth--;
1908: reader->state = XML_TEXTREADER_BACKTRACK;
1909: /* Repeat process to move to sibling of parent node if present */
1910: xmlTextReaderNextTree(reader);
1911: }
1912:
1913: reader->state = XML_TEXTREADER_END;
1914:
1915: return(1);
1916: }
1917:
1918: /**
1919: * xmlTextReaderReadTree:
1920: * @reader: the xmlTextReaderPtr used
1921: *
1922: * Moves the position of the current instance to the next node in
1923: * the stream, exposing its properties.
1924: *
1925: * Returns 1 if the node was read successfully, 0 if there is no more
1926: * nodes to read, or -1 in case of error
1927: */
1928: static int
1929: xmlTextReaderReadTree(xmlTextReaderPtr reader) {
1930: if (reader->state == XML_TEXTREADER_END)
1931: return(0);
1932:
1933: next_node:
1934: if (reader->node == NULL) {
1935: if (reader->doc->children == NULL) {
1936: reader->state = XML_TEXTREADER_END;
1937: return(0);
1938: }
1939:
1940: reader->node = reader->doc->children;
1941: reader->state = XML_TEXTREADER_START;
1942: goto found_node;
1943: }
1944:
1945: if ((reader->state != XML_TEXTREADER_BACKTRACK) &&
1946: (reader->node->type != XML_DTD_NODE) &&
1947: (reader->node->type != XML_XINCLUDE_START) &&
1948: (reader->node->type != XML_ENTITY_REF_NODE)) {
1949: if (reader->node->children != NULL) {
1950: reader->node = reader->node->children;
1951: reader->depth++;
1952: reader->state = XML_TEXTREADER_START;
1953: goto found_node;
1954: }
1955:
1956: if (reader->node->type == XML_ATTRIBUTE_NODE) {
1957: reader->state = XML_TEXTREADER_BACKTRACK;
1958: goto found_node;
1959: }
1960: }
1961:
1962: if (reader->node->next != NULL) {
1963: reader->node = reader->node->next;
1964: reader->state = XML_TEXTREADER_START;
1965: goto found_node;
1966: }
1967:
1968: if (reader->node->parent != NULL) {
1969: if ((reader->node->parent->type == XML_DOCUMENT_NODE) ||
1970: (reader->node->parent->type == XML_HTML_DOCUMENT_NODE)) {
1971: reader->state = XML_TEXTREADER_END;
1972: return(0);
1973: }
1974:
1975: reader->node = reader->node->parent;
1976: reader->depth--;
1977: reader->state = XML_TEXTREADER_BACKTRACK;
1978: goto found_node;
1979: }
1980:
1981: reader->state = XML_TEXTREADER_END;
1982:
1983: found_node:
1984: if ((reader->node->type == XML_XINCLUDE_START) ||
1985: (reader->node->type == XML_XINCLUDE_END))
1986: goto next_node;
1987:
1988: return(1);
1989: }
1990:
1991: /**
1992: * xmlTextReaderNextSibling:
1993: * @reader: the xmlTextReaderPtr used
1994: *
1995: * Skip to the node following the current one in document order while
1996: * avoiding the subtree if any.
1997: * Currently implemented only for Readers built on a document
1998: *
1999: * Returns 1 if the node was read successfully, 0 if there is no more
2000: * nodes to read, or -1 in case of error
2001: */
2002: int
2003: xmlTextReaderNextSibling(xmlTextReaderPtr reader) {
2004: if (reader == NULL)
2005: return(-1);
2006: if (reader->doc == NULL) {
2007: /* TODO */
2008: return(-1);
2009: }
2010:
2011: if (reader->state == XML_TEXTREADER_END)
2012: return(0);
2013:
2014: if (reader->node == NULL)
2015: return(xmlTextReaderNextTree(reader));
2016:
2017: if (reader->node->next != NULL) {
2018: reader->node = reader->node->next;
2019: reader->state = XML_TEXTREADER_START;
2020: return(1);
2021: }
2022:
2023: return(0);
2024: }
2025:
2026: /************************************************************************
2027: * *
2028: * Constructor and destructors *
2029: * *
2030: ************************************************************************/
2031: /**
2032: * xmlNewTextReader:
2033: * @input: the xmlParserInputBufferPtr used to read data
2034: * @URI: the URI information for the source if available
2035: *
2036: * Create an xmlTextReader structure fed with @input
2037: *
2038: * Returns the new xmlTextReaderPtr or NULL in case of error
2039: */
2040: xmlTextReaderPtr
2041: xmlNewTextReader(xmlParserInputBufferPtr input, const char *URI) {
2042: xmlTextReaderPtr ret;
2043:
2044: if (input == NULL)
2045: return(NULL);
2046: ret = xmlMalloc(sizeof(xmlTextReader));
2047: if (ret == NULL) {
2048: xmlGenericError(xmlGenericErrorContext,
2049: "xmlNewTextReader : malloc failed\n");
2050: return(NULL);
2051: }
2052: memset(ret, 0, sizeof(xmlTextReader));
2053: ret->doc = NULL;
2054: ret->entTab = NULL;
2055: ret->entMax = 0;
2056: ret->entNr = 0;
2057: ret->input = input;
2058: ret->buffer = xmlBufferCreateSize(100);
2059: if (ret->buffer == NULL) {
2060: xmlFree(ret);
2061: xmlGenericError(xmlGenericErrorContext,
2062: "xmlNewTextReader : malloc failed\n");
2063: return(NULL);
2064: }
2065: ret->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
2066: if (ret->sax == NULL) {
2067: xmlBufferFree(ret->buffer);
2068: xmlFree(ret);
2069: xmlGenericError(xmlGenericErrorContext,
2070: "xmlNewTextReader : malloc failed\n");
2071: return(NULL);
2072: }
2073: xmlSAXVersion(ret->sax, 2);
2074: ret->startElement = ret->sax->startElement;
2075: ret->sax->startElement = xmlTextReaderStartElement;
2076: ret->endElement = ret->sax->endElement;
2077: ret->sax->endElement = xmlTextReaderEndElement;
2078: #ifdef LIBXML_SAX1_ENABLED
2079: if (ret->sax->initialized == XML_SAX2_MAGIC) {
2080: #endif /* LIBXML_SAX1_ENABLED */
2081: ret->startElementNs = ret->sax->startElementNs;
2082: ret->sax->startElementNs = xmlTextReaderStartElementNs;
2083: ret->endElementNs = ret->sax->endElementNs;
2084: ret->sax->endElementNs = xmlTextReaderEndElementNs;
2085: #ifdef LIBXML_SAX1_ENABLED
2086: } else {
2087: ret->startElementNs = NULL;
2088: ret->endElementNs = NULL;
2089: }
2090: #endif /* LIBXML_SAX1_ENABLED */
2091: ret->characters = ret->sax->characters;
2092: ret->sax->characters = xmlTextReaderCharacters;
2093: ret->sax->ignorableWhitespace = xmlTextReaderCharacters;
2094: ret->cdataBlock = ret->sax->cdataBlock;
2095: ret->sax->cdataBlock = xmlTextReaderCDataBlock;
2096:
2097: ret->mode = XML_TEXTREADER_MODE_INITIAL;
2098: ret->node = NULL;
2099: ret->curnode = NULL;
2100: if (ret->input->buffer->use < 4) {
2101: xmlParserInputBufferRead(input, 4);
2102: }
2103: if (ret->input->buffer->use >= 4) {
2104: ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL,
2105: (const char *) ret->input->buffer->content, 4, URI);
2106: ret->base = 0;
2107: ret->cur = 4;
2108: } else {
2109: ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL, NULL, 0, URI);
2110: ret->base = 0;
2111: ret->cur = 0;
2112: }
2113:
2114: if (ret->ctxt == NULL) {
2115: xmlGenericError(xmlGenericErrorContext,
2116: "xmlNewTextReader : malloc failed\n");
2117: xmlBufferFree(ret->buffer);
2118: xmlFree(ret->sax);
2119: xmlFree(ret);
2120: return(NULL);
2121: }
2122: ret->ctxt->parseMode = XML_PARSE_READER;
2123: ret->ctxt->_private = ret;
2124: ret->ctxt->linenumbers = 1;
2125: ret->ctxt->dictNames = 1;
2126: ret->allocs = XML_TEXTREADER_CTXT;
2127: /*
2128: * use the parser dictionnary to allocate all elements and attributes names
2129: */
2130: ret->ctxt->docdict = 1;
2131: ret->dict = ret->ctxt->dict;
2132: #ifdef LIBXML_XINCLUDE_ENABLED
2133: ret->xinclude = 0;
2134: #endif
2135: #ifdef LIBXML_PATTERN_ENABLED
2136: ret->patternMax = 0;
2137: ret->patternTab = NULL;
2138: #endif
2139: return(ret);
2140: }
2141:
2142: /**
2143: * xmlNewTextReaderFilename:
2144: * @URI: the URI of the resource to process
2145: *
2146: * Create an xmlTextReader structure fed with the resource at @URI
2147: *
2148: * Returns the new xmlTextReaderPtr or NULL in case of error
2149: */
2150: xmlTextReaderPtr
2151: xmlNewTextReaderFilename(const char *URI) {
2152: xmlParserInputBufferPtr input;
2153: xmlTextReaderPtr ret;
2154: char *directory = NULL;
2155:
2156: input = xmlParserInputBufferCreateFilename(URI, XML_CHAR_ENCODING_NONE);
2157: if (input == NULL)
2158: return(NULL);
2159: ret = xmlNewTextReader(input, URI);
2160: if (ret == NULL) {
2161: xmlFreeParserInputBuffer(input);
2162: return(NULL);
2163: }
2164: ret->allocs |= XML_TEXTREADER_INPUT;
2165: if (ret->ctxt->directory == NULL)
2166: directory = xmlParserGetDirectory(URI);
2167: if ((ret->ctxt->directory == NULL) && (directory != NULL))
2168: ret->ctxt->directory = (char *) xmlStrdup((xmlChar *) directory);
2169: if (directory != NULL)
2170: xmlFree(directory);
2171: return(ret);
2172: }
2173:
2174: /**
2175: * xmlFreeTextReader:
2176: * @reader: the xmlTextReaderPtr
2177: *
2178: * Deallocate all the resources associated to the reader
2179: */
2180: void
2181: xmlFreeTextReader(xmlTextReaderPtr reader) {
2182: if (reader == NULL)
2183: return;
2184: #ifdef LIBXML_SCHEMAS_ENABLED
2185: if (reader->rngSchemas != NULL) {
2186: xmlRelaxNGFree(reader->rngSchemas);
2187: reader->rngSchemas = NULL;
2188: }
2189: if (reader->rngValidCtxt != NULL) {
2190: xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
2191: reader->rngValidCtxt = NULL;
2192: }
2193: if (reader->xsdPlug != NULL) {
2194: xmlSchemaSAXUnplug(reader->xsdPlug);
2195: reader->xsdPlug = NULL;
2196: }
2197: if (reader->xsdValidCtxt != NULL) {
2198: if (! reader->xsdPreserveCtxt)
2199: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
2200: reader->xsdValidCtxt = NULL;
2201: }
2202: if (reader->xsdSchemas != NULL) {
2203: xmlSchemaFree(reader->xsdSchemas);
2204: reader->xsdSchemas = NULL;
2205: }
2206: #endif
2207: #ifdef LIBXML_XINCLUDE_ENABLED
2208: if (reader->xincctxt != NULL)
2209: xmlXIncludeFreeContext(reader->xincctxt);
2210: #endif
2211: #ifdef LIBXML_PATTERN_ENABLED
2212: if (reader->patternTab != NULL) {
2213: int i;
2214: for (i = 0;i < reader->patternNr;i++) {
2215: if (reader->patternTab[i] != NULL)
2216: xmlFreePattern(reader->patternTab[i]);
2217: }
2218: xmlFree(reader->patternTab);
2219: }
2220: #endif
2221: if (reader->faketext != NULL) {
2222: xmlFreeNode(reader->faketext);
2223: }
2224: if (reader->ctxt != NULL) {
2225: if (reader->dict == reader->ctxt->dict)
2226: reader->dict = NULL;
2227: if (reader->ctxt->myDoc != NULL) {
2228: if (reader->preserve == 0)
2229: xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2230: reader->ctxt->myDoc = NULL;
2231: }
2232: if ((reader->ctxt->vctxt.vstateTab != NULL) &&
2233: (reader->ctxt->vctxt.vstateMax > 0)){
2234: xmlFree(reader->ctxt->vctxt.vstateTab);
2235: reader->ctxt->vctxt.vstateTab = NULL;
2236: reader->ctxt->vctxt.vstateMax = 0;
2237: }
2238: if (reader->allocs & XML_TEXTREADER_CTXT)
2239: xmlFreeParserCtxt(reader->ctxt);
2240: }
2241: if (reader->sax != NULL)
2242: xmlFree(reader->sax);
2243: if ((reader->input != NULL) && (reader->allocs & XML_TEXTREADER_INPUT))
2244: xmlFreeParserInputBuffer(reader->input);
2245: if (reader->buffer != NULL)
2246: xmlBufferFree(reader->buffer);
2247: if (reader->entTab != NULL)
2248: xmlFree(reader->entTab);
2249: if (reader->dict != NULL)
2250: xmlDictFree(reader->dict);
2251: xmlFree(reader);
2252: }
2253:
2254: /************************************************************************
2255: * *
2256: * Methods for XmlTextReader *
2257: * *
2258: ************************************************************************/
2259: /**
2260: * xmlTextReaderClose:
2261: * @reader: the xmlTextReaderPtr used
2262: *
2263: * This method releases any resources allocated by the current instance
2264: * changes the state to Closed and close any underlying input.
2265: *
2266: * Returns 0 or -1 in case of error
2267: */
2268: int
2269: xmlTextReaderClose(xmlTextReaderPtr reader) {
2270: if (reader == NULL)
2271: return(-1);
2272: reader->node = NULL;
2273: reader->curnode = NULL;
2274: reader->mode = XML_TEXTREADER_MODE_CLOSED;
2275: if (reader->ctxt != NULL) {
2276: xmlStopParser(reader->ctxt);
2277: if (reader->ctxt->myDoc != NULL) {
2278: if (reader->preserve == 0)
2279: xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2280: reader->ctxt->myDoc = NULL;
2281: }
2282: }
2283: if ((reader->input != NULL) && (reader->allocs & XML_TEXTREADER_INPUT)) {
2284: xmlFreeParserInputBuffer(reader->input);
2285: reader->allocs -= XML_TEXTREADER_INPUT;
2286: }
2287: return(0);
2288: }
2289:
2290: /**
2291: * xmlTextReaderGetAttributeNo:
2292: * @reader: the xmlTextReaderPtr used
2293: * @no: the zero-based index of the attribute relative to the containing element
2294: *
2295: * Provides the value of the attribute with the specified index relative
2296: * to the containing element.
2297: *
2298: * Returns a string containing the value of the specified attribute, or NULL
2299: * in case of error. The string must be deallocated by the caller.
2300: */
2301: xmlChar *
2302: xmlTextReaderGetAttributeNo(xmlTextReaderPtr reader, int no) {
2303: xmlChar *ret;
2304: int i;
2305: xmlAttrPtr cur;
2306: xmlNsPtr ns;
2307:
2308: if (reader == NULL)
2309: return(NULL);
2310: if (reader->node == NULL)
2311: return(NULL);
2312: if (reader->curnode != NULL)
2313: return(NULL);
2314: /* TODO: handle the xmlDecl */
2315: if (reader->node->type != XML_ELEMENT_NODE)
2316: return(NULL);
2317:
2318: ns = reader->node->nsDef;
2319: for (i = 0;(i < no) && (ns != NULL);i++) {
2320: ns = ns->next;
2321: }
2322: if (ns != NULL)
2323: return(xmlStrdup(ns->href));
2324:
2325: cur = reader->node->properties;
2326: if (cur == NULL)
2327: return(NULL);
2328: for (;i < no;i++) {
2329: cur = cur->next;
2330: if (cur == NULL)
2331: return(NULL);
2332: }
2333: /* TODO walk the DTD if present */
2334:
2335: ret = xmlNodeListGetString(reader->node->doc, cur->children, 1);
2336: if (ret == NULL) return(xmlStrdup((xmlChar *)""));
2337: return(ret);
2338: }
2339:
2340: /**
2341: * xmlTextReaderGetAttribute:
2342: * @reader: the xmlTextReaderPtr used
2343: * @name: the qualified name of the attribute.
2344: *
2345: * Provides the value of the attribute with the specified qualified name.
2346: *
2347: * Returns a string containing the value of the specified attribute, or NULL
2348: * in case of error. The string must be deallocated by the caller.
2349: */
2350: xmlChar *
2351: xmlTextReaderGetAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
2352: xmlChar *prefix = NULL;
2353: xmlChar *localname;
2354: xmlNsPtr ns;
2355: xmlChar *ret = NULL;
2356:
2357: if ((reader == NULL) || (name == NULL))
2358: return(NULL);
2359: if (reader->node == NULL)
2360: return(NULL);
2361: if (reader->curnode != NULL)
2362: return(NULL);
2363:
2364: /* TODO: handle the xmlDecl */
2365: if (reader->node->type != XML_ELEMENT_NODE)
2366: return(NULL);
2367:
2368: localname = xmlSplitQName2(name, &prefix);
2369: if (localname == NULL) {
2370: /*
2371: * Namespace default decl
2372: */
2373: if (xmlStrEqual(name, BAD_CAST "xmlns")) {
2374: ns = reader->node->nsDef;
2375: while (ns != NULL) {
2376: if (ns->prefix == NULL) {
2377: return(xmlStrdup(ns->href));
2378: }
2379: ns = ns->next;
2380: }
2381: return NULL;
2382: }
2383: return(xmlGetNoNsProp(reader->node, name));
2384: }
2385:
2386: /*
2387: * Namespace default decl
2388: */
2389: if (xmlStrEqual(prefix, BAD_CAST "xmlns")) {
2390: ns = reader->node->nsDef;
2391: while (ns != NULL) {
2392: if ((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localname))) {
2393: ret = xmlStrdup(ns->href);
2394: break;
2395: }
2396: ns = ns->next;
2397: }
2398: } else {
2399: ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
2400: if (ns != NULL)
2401: ret = xmlGetNsProp(reader->node, localname, ns->href);
2402: }
2403:
2404: xmlFree(localname);
2405: if (prefix != NULL)
2406: xmlFree(prefix);
2407: return(ret);
2408: }
2409:
2410:
2411: /**
2412: * xmlTextReaderGetAttributeNs:
2413: * @reader: the xmlTextReaderPtr used
2414: * @localName: the local name of the attribute.
2415: * @namespaceURI: the namespace URI of the attribute.
2416: *
2417: * Provides the value of the specified attribute
2418: *
2419: * Returns a string containing the value of the specified attribute, or NULL
2420: * in case of error. The string must be deallocated by the caller.
2421: */
2422: xmlChar *
2423: xmlTextReaderGetAttributeNs(xmlTextReaderPtr reader, const xmlChar *localName,
2424: const xmlChar *namespaceURI) {
2425: xmlChar *prefix = NULL;
2426: xmlNsPtr ns;
2427:
2428: if ((reader == NULL) || (localName == NULL))
2429: return(NULL);
2430: if (reader->node == NULL)
2431: return(NULL);
2432: if (reader->curnode != NULL)
2433: return(NULL);
2434:
2435: /* TODO: handle the xmlDecl */
2436: if (reader->node->type != XML_ELEMENT_NODE)
2437: return(NULL);
2438:
2439: if (xmlStrEqual(namespaceURI, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
2440: if (! xmlStrEqual(localName, BAD_CAST "xmlns")) {
2441: prefix = BAD_CAST localName;
2442: }
2443: ns = reader->node->nsDef;
2444: while (ns != NULL) {
2445: if ((prefix == NULL && ns->prefix == NULL) ||
2446: ((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localName)))) {
2447: return xmlStrdup(ns->href);
2448: }
2449: ns = ns->next;
2450: }
2451: return NULL;
2452: }
2453:
2454: return(xmlGetNsProp(reader->node, localName, namespaceURI));
2455: }
2456:
2457: /**
2458: * xmlTextReaderGetRemainder:
2459: * @reader: the xmlTextReaderPtr used
2460: *
2461: * Method to get the remainder of the buffered XML. this method stops the
2462: * parser, set its state to End Of File and return the input stream with
2463: * what is left that the parser did not use.
2464: *
2465: * The implementation is not good, the parser certainly procgressed past
2466: * what's left in reader->input, and there is an allocation problem. Best
2467: * would be to rewrite it differently.
2468: *
2469: * Returns the xmlParserInputBufferPtr attached to the XML or NULL
2470: * in case of error.
2471: */
2472: xmlParserInputBufferPtr
2473: xmlTextReaderGetRemainder(xmlTextReaderPtr reader) {
2474: xmlParserInputBufferPtr ret = NULL;
2475:
2476: if (reader == NULL)
2477: return(NULL);
2478: if (reader->node == NULL)
2479: return(NULL);
2480:
2481: reader->node = NULL;
2482: reader->curnode = NULL;
2483: reader->mode = XML_TEXTREADER_MODE_EOF;
2484: if (reader->ctxt != NULL) {
2485: xmlStopParser(reader->ctxt);
2486: if (reader->ctxt->myDoc != NULL) {
2487: if (reader->preserve == 0)
2488: xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2489: reader->ctxt->myDoc = NULL;
2490: }
2491: }
2492: if (reader->allocs & XML_TEXTREADER_INPUT) {
2493: ret = reader->input;
2494: reader->input = NULL;
2495: reader->allocs -= XML_TEXTREADER_INPUT;
2496: } else {
2497: /*
2498: * Hum, one may need to duplicate the data structure because
2499: * without reference counting the input may be freed twice:
2500: * - by the layer which allocated it.
2501: * - by the layer to which would have been returned to.
2502: */
2503: TODO
2504: return(NULL);
2505: }
2506: return(ret);
2507: }
2508:
2509: /**
2510: * xmlTextReaderLookupNamespace:
2511: * @reader: the xmlTextReaderPtr used
2512: * @prefix: the prefix whose namespace URI is to be resolved. To return
2513: * the default namespace, specify NULL
2514: *
2515: * Resolves a namespace prefix in the scope of the current element.
2516: *
2517: * Returns a string containing the namespace URI to which the prefix maps
2518: * or NULL in case of error. The string must be deallocated by the caller.
2519: */
2520: xmlChar *
2521: xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, const xmlChar *prefix) {
2522: xmlNsPtr ns;
2523:
2524: if (reader == NULL)
2525: return(NULL);
2526: if (reader->node == NULL)
2527: return(NULL);
2528:
2529: ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
2530: if (ns == NULL)
2531: return(NULL);
2532: return(xmlStrdup(ns->href));
2533: }
2534:
2535: /**
2536: * xmlTextReaderMoveToAttributeNo:
2537: * @reader: the xmlTextReaderPtr used
2538: * @no: the zero-based index of the attribute relative to the containing
2539: * element.
2540: *
2541: * Moves the position of the current instance to the attribute with
2542: * the specified index relative to the containing element.
2543: *
2544: * Returns 1 in case of success, -1 in case of error, 0 if not found
2545: */
2546: int
2547: xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, int no) {
2548: int i;
2549: xmlAttrPtr cur;
2550: xmlNsPtr ns;
2551:
2552: if (reader == NULL)
2553: return(-1);
2554: if (reader->node == NULL)
2555: return(-1);
2556: /* TODO: handle the xmlDecl */
2557: if (reader->node->type != XML_ELEMENT_NODE)
2558: return(-1);
2559:
2560: reader->curnode = NULL;
2561:
2562: ns = reader->node->nsDef;
2563: for (i = 0;(i < no) && (ns != NULL);i++) {
2564: ns = ns->next;
2565: }
2566: if (ns != NULL) {
2567: reader->curnode = (xmlNodePtr) ns;
2568: return(1);
2569: }
2570:
2571: cur = reader->node->properties;
2572: if (cur == NULL)
2573: return(0);
2574: for (;i < no;i++) {
2575: cur = cur->next;
2576: if (cur == NULL)
2577: return(0);
2578: }
2579: /* TODO walk the DTD if present */
2580:
2581: reader->curnode = (xmlNodePtr) cur;
2582: return(1);
2583: }
2584:
2585: /**
2586: * xmlTextReaderMoveToAttribute:
2587: * @reader: the xmlTextReaderPtr used
2588: * @name: the qualified name of the attribute.
2589: *
2590: * Moves the position of the current instance to the attribute with
2591: * the specified qualified name.
2592: *
2593: * Returns 1 in case of success, -1 in case of error, 0 if not found
2594: */
2595: int
2596: xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
2597: xmlChar *prefix = NULL;
2598: xmlChar *localname;
2599: xmlNsPtr ns;
2600: xmlAttrPtr prop;
2601:
2602: if ((reader == NULL) || (name == NULL))
2603: return(-1);
2604: if (reader->node == NULL)
2605: return(-1);
2606:
2607: /* TODO: handle the xmlDecl */
2608: if (reader->node->type != XML_ELEMENT_NODE)
2609: return(0);
2610:
2611: localname = xmlSplitQName2(name, &prefix);
2612: if (localname == NULL) {
2613: /*
2614: * Namespace default decl
2615: */
2616: if (xmlStrEqual(name, BAD_CAST "xmlns")) {
2617: ns = reader->node->nsDef;
2618: while (ns != NULL) {
2619: if (ns->prefix == NULL) {
2620: reader->curnode = (xmlNodePtr) ns;
2621: return(1);
2622: }
2623: ns = ns->next;
2624: }
2625: return(0);
2626: }
2627:
2628: prop = reader->node->properties;
2629: while (prop != NULL) {
2630: /*
2631: * One need to have
2632: * - same attribute names
2633: * - and the attribute carrying that namespace
2634: */
2635: if ((xmlStrEqual(prop->name, name)) &&
2636: ((prop->ns == NULL) || (prop->ns->prefix == NULL))) {
2637: reader->curnode = (xmlNodePtr) prop;
2638: return(1);
2639: }
2640: prop = prop->next;
2641: }
2642: return(0);
2643: }
2644:
2645: /*
2646: * Namespace default decl
2647: */
2648: if (xmlStrEqual(prefix, BAD_CAST "xmlns")) {
2649: ns = reader->node->nsDef;
2650: while (ns != NULL) {
2651: if ((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localname))) {
2652: reader->curnode = (xmlNodePtr) ns;
2653: goto found;
2654: }
2655: ns = ns->next;
2656: }
2657: goto not_found;
2658: }
2659: prop = reader->node->properties;
2660: while (prop != NULL) {
2661: /*
2662: * One need to have
2663: * - same attribute names
2664: * - and the attribute carrying that namespace
2665: */
2666: if ((xmlStrEqual(prop->name, localname)) &&
2667: (prop->ns != NULL) && (xmlStrEqual(prop->ns->prefix, prefix))) {
2668: reader->curnode = (xmlNodePtr) prop;
2669: goto found;
2670: }
2671: prop = prop->next;
2672: }
2673: not_found:
2674: if (localname != NULL)
2675: xmlFree(localname);
2676: if (prefix != NULL)
2677: xmlFree(prefix);
2678: return(0);
2679:
2680: found:
2681: if (localname != NULL)
2682: xmlFree(localname);
2683: if (prefix != NULL)
2684: xmlFree(prefix);
2685: return(1);
2686: }
2687:
2688: /**
2689: * xmlTextReaderMoveToAttributeNs:
2690: * @reader: the xmlTextReaderPtr used
2691: * @localName: the local name of the attribute.
2692: * @namespaceURI: the namespace URI of the attribute.
2693: *
2694: * Moves the position of the current instance to the attribute with the
2695: * specified local name and namespace URI.
2696: *
2697: * Returns 1 in case of success, -1 in case of error, 0 if not found
2698: */
2699: int
2700: xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
2701: const xmlChar *localName, const xmlChar *namespaceURI) {
2702: xmlAttrPtr prop;
2703: xmlNodePtr node;
2704: xmlNsPtr ns;
2705: xmlChar *prefix = NULL;
2706:
2707: if ((reader == NULL) || (localName == NULL) || (namespaceURI == NULL))
2708: return(-1);
2709: if (reader->node == NULL)
2710: return(-1);
2711: if (reader->node->type != XML_ELEMENT_NODE)
2712: return(0);
2713: node = reader->node;
2714:
2715: if (xmlStrEqual(namespaceURI, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
2716: if (! xmlStrEqual(localName, BAD_CAST "xmlns")) {
2717: prefix = BAD_CAST localName;
2718: }
2719: ns = reader->node->nsDef;
2720: while (ns != NULL) {
2721: if ((prefix == NULL && ns->prefix == NULL) ||
2722: ((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localName)))) {
2723: reader->curnode = (xmlNodePtr) ns;
2724: return(1);
2725: }
2726: ns = ns->next;
2727: }
2728: return(0);
2729: }
2730:
2731: prop = node->properties;
2732: while (prop != NULL) {
2733: /*
2734: * One need to have
2735: * - same attribute names
2736: * - and the attribute carrying that namespace
2737: */
2738: if (xmlStrEqual(prop->name, localName) &&
2739: ((prop->ns != NULL) &&
2740: (xmlStrEqual(prop->ns->href, namespaceURI)))) {
2741: reader->curnode = (xmlNodePtr) prop;
2742: return(1);
2743: }
2744: prop = prop->next;
2745: }
2746: return(0);
2747: }
2748:
2749: /**
2750: * xmlTextReaderMoveToFirstAttribute:
2751: * @reader: the xmlTextReaderPtr used
2752: *
2753: * Moves the position of the current instance to the first attribute
2754: * associated with the current node.
2755: *
2756: * Returns 1 in case of success, -1 in case of error, 0 if not found
2757: */
2758: int
2759: xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader) {
2760: if (reader == NULL)
2761: return(-1);
2762: if (reader->node == NULL)
2763: return(-1);
2764: if (reader->node->type != XML_ELEMENT_NODE)
2765: return(0);
2766:
2767: if (reader->node->nsDef != NULL) {
2768: reader->curnode = (xmlNodePtr) reader->node->nsDef;
2769: return(1);
2770: }
2771: if (reader->node->properties != NULL) {
2772: reader->curnode = (xmlNodePtr) reader->node->properties;
2773: return(1);
2774: }
2775: return(0);
2776: }
2777:
2778: /**
2779: * xmlTextReaderMoveToNextAttribute:
2780: * @reader: the xmlTextReaderPtr used
2781: *
2782: * Moves the position of the current instance to the next attribute
2783: * associated with the current node.
2784: *
2785: * Returns 1 in case of success, -1 in case of error, 0 if not found
2786: */
2787: int
2788: xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader) {
2789: if (reader == NULL)
2790: return(-1);
2791: if (reader->node == NULL)
2792: return(-1);
2793: if (reader->node->type != XML_ELEMENT_NODE)
2794: return(0);
2795: if (reader->curnode == NULL)
2796: return(xmlTextReaderMoveToFirstAttribute(reader));
2797:
2798: if (reader->curnode->type == XML_NAMESPACE_DECL) {
2799: xmlNsPtr ns = (xmlNsPtr) reader->curnode;
2800: if (ns->next != NULL) {
2801: reader->curnode = (xmlNodePtr) ns->next;
2802: return(1);
2803: }
2804: if (reader->node->properties != NULL) {
2805: reader->curnode = (xmlNodePtr) reader->node->properties;
2806: return(1);
2807: }
2808: return(0);
2809: } else if ((reader->curnode->type == XML_ATTRIBUTE_NODE) &&
2810: (reader->curnode->next != NULL)) {
2811: reader->curnode = reader->curnode->next;
2812: return(1);
2813: }
2814: return(0);
2815: }
2816:
2817: /**
2818: * xmlTextReaderMoveToElement:
2819: * @reader: the xmlTextReaderPtr used
2820: *
2821: * Moves the position of the current instance to the node that
2822: * contains the current Attribute node.
2823: *
2824: * Returns 1 in case of success, -1 in case of error, 0 if not moved
2825: */
2826: int
2827: xmlTextReaderMoveToElement(xmlTextReaderPtr reader) {
2828: if (reader == NULL)
2829: return(-1);
2830: if (reader->node == NULL)
2831: return(-1);
2832: if (reader->node->type != XML_ELEMENT_NODE)
2833: return(0);
2834: if (reader->curnode != NULL) {
2835: reader->curnode = NULL;
2836: return(1);
2837: }
2838: return(0);
2839: }
2840:
2841: /**
2842: * xmlTextReaderReadAttributeValue:
2843: * @reader: the xmlTextReaderPtr used
2844: *
2845: * Parses an attribute value into one or more Text and EntityReference nodes.
2846: *
2847: * Returns 1 in case of success, 0 if the reader was not positionned on an
2848: * ttribute node or all the attribute values have been read, or -1
2849: * in case of error.
2850: */
2851: int
2852: xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader) {
2853: if (reader == NULL)
2854: return(-1);
2855: if (reader->node == NULL)
2856: return(-1);
2857: if (reader->curnode == NULL)
2858: return(0);
2859: if (reader->curnode->type == XML_ATTRIBUTE_NODE) {
2860: if (reader->curnode->children == NULL)
2861: return(0);
2862: reader->curnode = reader->curnode->children;
2863: } else if (reader->curnode->type == XML_NAMESPACE_DECL) {
2864: xmlNsPtr ns = (xmlNsPtr) reader->curnode;
2865:
2866: if (reader->faketext == NULL) {
2867: reader->faketext = xmlNewDocText(reader->node->doc,
2868: ns->href);
2869: } else {
2870: if ((reader->faketext->content != NULL) &&
2871: (reader->faketext->content !=
2872: (xmlChar *) &(reader->faketext->properties)))
2873: xmlFree(reader->faketext->content);
2874: reader->faketext->content = xmlStrdup(ns->href);
2875: }
2876: reader->curnode = reader->faketext;
2877: } else {
2878: if (reader->curnode->next == NULL)
2879: return(0);
2880: reader->curnode = reader->curnode->next;
2881: }
2882: return(1);
2883: }
2884:
2885: /**
2886: * xmlTextReaderConstEncoding:
2887: * @reader: the xmlTextReaderPtr used
2888: *
2889: * Determine the encoding of the document being read.
2890: *
2891: * Returns a string containing the encoding of the document or NULL in
2892: * case of error. The string is deallocated with the reader.
2893: */
2894: const xmlChar *
2895: xmlTextReaderConstEncoding(xmlTextReaderPtr reader) {
2896: xmlDocPtr doc = NULL;
2897: if (reader == NULL)
2898: return(NULL);
2899: if (reader->doc != NULL)
2900: doc = reader->doc;
2901: else if (reader->ctxt != NULL)
2902: doc = reader->ctxt->myDoc;
2903: if (doc == NULL)
2904: return(NULL);
2905:
2906: if (doc->encoding == NULL)
2907: return(NULL);
2908: else
2909: return(CONSTSTR(doc->encoding));
2910: }
2911:
2912:
2913: /************************************************************************
2914: * *
2915: * Acces API to the current node *
2916: * *
2917: ************************************************************************/
2918: /**
2919: * xmlTextReaderAttributeCount:
2920: * @reader: the xmlTextReaderPtr used
2921: *
2922: * Provides the number of attributes of the current node
2923: *
2924: * Returns 0 i no attributes, -1 in case of error or the attribute count
2925: */
2926: int
2927: xmlTextReaderAttributeCount(xmlTextReaderPtr reader) {
2928: int ret;
2929: xmlAttrPtr attr;
2930: xmlNsPtr ns;
2931: xmlNodePtr node;
2932:
2933: if (reader == NULL)
2934: return(-1);
2935: if (reader->node == NULL)
2936: return(0);
2937:
2938: if (reader->curnode != NULL)
2939: node = reader->curnode;
2940: else
2941: node = reader->node;
2942:
2943: if (node->type != XML_ELEMENT_NODE)
2944: return(0);
2945: if ((reader->state == XML_TEXTREADER_END) ||
2946: (reader->state == XML_TEXTREADER_BACKTRACK))
2947: return(0);
2948: ret = 0;
2949: attr = node->properties;
2950: while (attr != NULL) {
2951: ret++;
2952: attr = attr->next;
2953: }
2954: ns = node->nsDef;
2955: while (ns != NULL) {
2956: ret++;
2957: ns = ns->next;
2958: }
2959: return(ret);
2960: }
2961:
2962: /**
2963: * xmlTextReaderNodeType:
2964: * @reader: the xmlTextReaderPtr used
2965: *
2966: * Get the node type of the current node
2967: * Reference:
2968: * http://www.gnu.org/software/dotgnu/pnetlib-doc/System/Xml/XmlNodeType.html
2969: *
2970: * Returns the xmlNodeType of the current node or -1 in case of error
2971: */
2972: int
2973: xmlTextReaderNodeType(xmlTextReaderPtr reader) {
2974: xmlNodePtr node;
2975:
2976: if (reader == NULL)
2977: return(-1);
2978: if (reader->node == NULL)
2979: return(XML_READER_TYPE_NONE);
2980: if (reader->curnode != NULL)
2981: node = reader->curnode;
2982: else
2983: node = reader->node;
2984: switch (node->type) {
2985: case XML_ELEMENT_NODE:
2986: if ((reader->state == XML_TEXTREADER_END) ||
2987: (reader->state == XML_TEXTREADER_BACKTRACK))
2988: return(XML_READER_TYPE_END_ELEMENT);
2989: return(XML_READER_TYPE_ELEMENT);
2990: case XML_NAMESPACE_DECL:
2991: case XML_ATTRIBUTE_NODE:
2992: return(XML_READER_TYPE_ATTRIBUTE);
2993: case XML_TEXT_NODE:
2994: if (xmlIsBlankNode(reader->node)) {
2995: if (xmlNodeGetSpacePreserve(reader->node))
2996: return(XML_READER_TYPE_SIGNIFICANT_WHITESPACE);
2997: else
2998: return(XML_READER_TYPE_WHITESPACE);
2999: } else {
3000: return(XML_READER_TYPE_TEXT);
3001: }
3002: case XML_CDATA_SECTION_NODE:
3003: return(XML_READER_TYPE_CDATA);
3004: case XML_ENTITY_REF_NODE:
3005: return(XML_READER_TYPE_ENTITY_REFERENCE);
3006: case XML_ENTITY_NODE:
3007: return(XML_READER_TYPE_ENTITY);
3008: case XML_PI_NODE:
3009: return(XML_READER_TYPE_PROCESSING_INSTRUCTION);
3010: case XML_COMMENT_NODE:
3011: return(XML_READER_TYPE_COMMENT);
3012: case XML_DOCUMENT_NODE:
3013: case XML_HTML_DOCUMENT_NODE:
3014: #ifdef LIBXML_DOCB_ENABLED
3015: case XML_DOCB_DOCUMENT_NODE:
3016: #endif
3017: return(XML_READER_TYPE_DOCUMENT);
3018: case XML_DOCUMENT_FRAG_NODE:
3019: return(XML_READER_TYPE_DOCUMENT_FRAGMENT);
3020: case XML_NOTATION_NODE:
3021: return(XML_READER_TYPE_NOTATION);
3022: case XML_DOCUMENT_TYPE_NODE:
3023: case XML_DTD_NODE:
3024: return(XML_READER_TYPE_DOCUMENT_TYPE);
3025:
3026: case XML_ELEMENT_DECL:
3027: case XML_ATTRIBUTE_DECL:
3028: case XML_ENTITY_DECL:
3029: case XML_XINCLUDE_START:
3030: case XML_XINCLUDE_END:
3031: return(XML_READER_TYPE_NONE);
3032: }
3033: return(-1);
3034: }
3035:
3036: /**
3037: * xmlTextReaderIsEmptyElement:
3038: * @reader: the xmlTextReaderPtr used
3039: *
3040: * Check if the current node is empty
3041: *
3042: * Returns 1 if empty, 0 if not and -1 in case of error
3043: */
3044: int
3045: xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader) {
3046: if ((reader == NULL) || (reader->node == NULL))
3047: return(-1);
3048: if (reader->node->type != XML_ELEMENT_NODE)
3049: return(0);
3050: if (reader->curnode != NULL)
3051: return(0);
3052: if (reader->node->children != NULL)
3053: return(0);
3054: if (reader->state == XML_TEXTREADER_END)
3055: return(0);
3056: if (reader->doc != NULL)
3057: return(1);
3058: #ifdef LIBXML_XINCLUDE_ENABLED
3059: if (reader->in_xinclude > 0)
3060: return(1);
3061: #endif
3062: return((reader->node->extra & NODE_IS_EMPTY) != 0);
3063: }
3064:
3065: /**
3066: * xmlTextReaderLocalName:
3067: * @reader: the xmlTextReaderPtr used
3068: *
3069: * The local name of the node.
3070: *
3071: * Returns the local name or NULL if not available,
3072: * if non NULL it need to be freed by the caller.
3073: */
3074: xmlChar *
3075: xmlTextReaderLocalName(xmlTextReaderPtr reader) {
3076: xmlNodePtr node;
3077: if ((reader == NULL) || (reader->node == NULL))
3078: return(NULL);
3079: if (reader->curnode != NULL)
3080: node = reader->curnode;
3081: else
3082: node = reader->node;
3083: if (node->type == XML_NAMESPACE_DECL) {
3084: xmlNsPtr ns = (xmlNsPtr) node;
3085: if (ns->prefix == NULL)
3086: return(xmlStrdup(BAD_CAST "xmlns"));
3087: else
3088: return(xmlStrdup(ns->prefix));
3089: }
3090: if ((node->type != XML_ELEMENT_NODE) &&
3091: (node->type != XML_ATTRIBUTE_NODE))
3092: return(xmlTextReaderName(reader));
3093: return(xmlStrdup(node->name));
3094: }
3095:
3096: /**
3097: * xmlTextReaderConstLocalName:
3098: * @reader: the xmlTextReaderPtr used
3099: *
3100: * The local name of the node.
3101: *
3102: * Returns the local name or NULL if not available, the
3103: * string will be deallocated with the reader.
3104: */
3105: const xmlChar *
3106: xmlTextReaderConstLocalName(xmlTextReaderPtr reader) {
3107: xmlNodePtr node;
3108: if ((reader == NULL) || (reader->node == NULL))
3109: return(NULL);
3110: if (reader->curnode != NULL)
3111: node = reader->curnode;
3112: else
3113: node = reader->node;
3114: if (node->type == XML_NAMESPACE_DECL) {
3115: xmlNsPtr ns = (xmlNsPtr) node;
3116: if (ns->prefix == NULL)
3117: return(CONSTSTR(BAD_CAST "xmlns"));
3118: else
3119: return(ns->prefix);
3120: }
3121: if ((node->type != XML_ELEMENT_NODE) &&
3122: (node->type != XML_ATTRIBUTE_NODE))
3123: return(xmlTextReaderConstName(reader));
3124: return(node->name);
3125: }
3126:
3127: /**
3128: * xmlTextReaderName:
3129: * @reader: the xmlTextReaderPtr used
3130: *
3131: * The qualified name of the node, equal to Prefix :LocalName.
3132: *
3133: * Returns the local name or NULL if not available,
3134: * if non NULL it need to be freed by the caller.
3135: */
3136: xmlChar *
3137: xmlTextReaderName(xmlTextReaderPtr reader) {
3138: xmlNodePtr node;
3139: xmlChar *ret;
3140:
3141: if ((reader == NULL) || (reader->node == NULL))
3142: return(NULL);
3143: if (reader->curnode != NULL)
3144: node = reader->curnode;
3145: else
3146: node = reader->node;
3147: switch (node->type) {
3148: case XML_ELEMENT_NODE:
3149: case XML_ATTRIBUTE_NODE:
3150: if ((node->ns == NULL) ||
3151: (node->ns->prefix == NULL))
3152: return(xmlStrdup(node->name));
3153:
3154: ret = xmlStrdup(node->ns->prefix);
3155: ret = xmlStrcat(ret, BAD_CAST ":");
3156: ret = xmlStrcat(ret, node->name);
3157: return(ret);
3158: case XML_TEXT_NODE:
3159: return(xmlStrdup(BAD_CAST "#text"));
3160: case XML_CDATA_SECTION_NODE:
3161: return(xmlStrdup(BAD_CAST "#cdata-section"));
3162: case XML_ENTITY_NODE:
3163: case XML_ENTITY_REF_NODE:
3164: return(xmlStrdup(node->name));
3165: case XML_PI_NODE:
3166: return(xmlStrdup(node->name));
3167: case XML_COMMENT_NODE:
3168: return(xmlStrdup(BAD_CAST "#comment"));
3169: case XML_DOCUMENT_NODE:
3170: case XML_HTML_DOCUMENT_NODE:
3171: #ifdef LIBXML_DOCB_ENABLED
3172: case XML_DOCB_DOCUMENT_NODE:
3173: #endif
3174: return(xmlStrdup(BAD_CAST "#document"));
3175: case XML_DOCUMENT_FRAG_NODE:
3176: return(xmlStrdup(BAD_CAST "#document-fragment"));
3177: case XML_NOTATION_NODE:
3178: return(xmlStrdup(node->name));
3179: case XML_DOCUMENT_TYPE_NODE:
3180: case XML_DTD_NODE:
3181: return(xmlStrdup(node->name));
3182: case XML_NAMESPACE_DECL: {
3183: xmlNsPtr ns = (xmlNsPtr) node;
3184:
3185: ret = xmlStrdup(BAD_CAST "xmlns");
3186: if (ns->prefix == NULL)
3187: return(ret);
3188: ret = xmlStrcat(ret, BAD_CAST ":");
3189: ret = xmlStrcat(ret, ns->prefix);
3190: return(ret);
3191: }
3192:
3193: case XML_ELEMENT_DECL:
3194: case XML_ATTRIBUTE_DECL:
3195: case XML_ENTITY_DECL:
3196: case XML_XINCLUDE_START:
3197: case XML_XINCLUDE_END:
3198: return(NULL);
3199: }
3200: return(NULL);
3201: }
3202:
3203: /**
3204: * xmlTextReaderConstName:
3205: * @reader: the xmlTextReaderPtr used
3206: *
3207: * The qualified name of the node, equal to Prefix :LocalName.
3208: *
3209: * Returns the local name or NULL if not available, the string is
3210: * deallocated with the reader.
3211: */
3212: const xmlChar *
3213: xmlTextReaderConstName(xmlTextReaderPtr reader) {
3214: xmlNodePtr node;
3215:
3216: if ((reader == NULL) || (reader->node == NULL))
3217: return(NULL);
3218: if (reader->curnode != NULL)
3219: node = reader->curnode;
3220: else
3221: node = reader->node;
3222: switch (node->type) {
3223: case XML_ELEMENT_NODE:
3224: case XML_ATTRIBUTE_NODE:
3225: if ((node->ns == NULL) ||
3226: (node->ns->prefix == NULL))
3227: return(node->name);
3228: return(CONSTQSTR(node->ns->prefix, node->name));
3229: case XML_TEXT_NODE:
3230: return(CONSTSTR(BAD_CAST "#text"));
3231: case XML_CDATA_SECTION_NODE:
3232: return(CONSTSTR(BAD_CAST "#cdata-section"));
3233: case XML_ENTITY_NODE:
3234: case XML_ENTITY_REF_NODE:
3235: return(CONSTSTR(node->name));
3236: case XML_PI_NODE:
3237: return(CONSTSTR(node->name));
3238: case XML_COMMENT_NODE:
3239: return(CONSTSTR(BAD_CAST "#comment"));
3240: case XML_DOCUMENT_NODE:
3241: case XML_HTML_DOCUMENT_NODE:
3242: #ifdef LIBXML_DOCB_ENABLED
3243: case XML_DOCB_DOCUMENT_NODE:
3244: #endif
3245: return(CONSTSTR(BAD_CAST "#document"));
3246: case XML_DOCUMENT_FRAG_NODE:
3247: return(CONSTSTR(BAD_CAST "#document-fragment"));
3248: case XML_NOTATION_NODE:
3249: return(CONSTSTR(node->name));
3250: case XML_DOCUMENT_TYPE_NODE:
3251: case XML_DTD_NODE:
3252: return(CONSTSTR(node->name));
3253: case XML_NAMESPACE_DECL: {
3254: xmlNsPtr ns = (xmlNsPtr) node;
3255:
3256: if (ns->prefix == NULL)
3257: return(CONSTSTR(BAD_CAST "xmlns"));
3258: return(CONSTQSTR(BAD_CAST "xmlns", ns->prefix));
3259: }
3260:
3261: case XML_ELEMENT_DECL:
3262: case XML_ATTRIBUTE_DECL:
3263: case XML_ENTITY_DECL:
3264: case XML_XINCLUDE_START:
3265: case XML_XINCLUDE_END:
3266: return(NULL);
3267: }
3268: return(NULL);
3269: }
3270:
3271: /**
3272: * xmlTextReaderPrefix:
3273: * @reader: the xmlTextReaderPtr used
3274: *
3275: * A shorthand reference to the namespace associated with the node.
3276: *
3277: * Returns the prefix or NULL if not available,
3278: * if non NULL it need to be freed by the caller.
3279: */
3280: xmlChar *
3281: xmlTextReaderPrefix(xmlTextReaderPtr reader) {
3282: xmlNodePtr node;
3283: if ((reader == NULL) || (reader->node == NULL))
3284: return(NULL);
3285: if (reader->curnode != NULL)
3286: node = reader->curnode;
3287: else
3288: node = reader->node;
3289: if (node->type == XML_NAMESPACE_DECL) {
3290: xmlNsPtr ns = (xmlNsPtr) node;
3291: if (ns->prefix == NULL)
3292: return(NULL);
3293: return(xmlStrdup(BAD_CAST "xmlns"));
3294: }
3295: if ((node->type != XML_ELEMENT_NODE) &&
3296: (node->type != XML_ATTRIBUTE_NODE))
3297: return(NULL);
3298: if ((node->ns != NULL) && (node->ns->prefix != NULL))
3299: return(xmlStrdup(node->ns->prefix));
3300: return(NULL);
3301: }
3302:
3303: /**
3304: * xmlTextReaderConstPrefix:
3305: * @reader: the xmlTextReaderPtr used
3306: *
3307: * A shorthand reference to the namespace associated with the node.
3308: *
3309: * Returns the prefix or NULL if not available, the string is deallocated
3310: * with the reader.
3311: */
3312: const xmlChar *
3313: xmlTextReaderConstPrefix(xmlTextReaderPtr reader) {
3314: xmlNodePtr node;
3315: if ((reader == NULL) || (reader->node == NULL))
3316: return(NULL);
3317: if (reader->curnode != NULL)
3318: node = reader->curnode;
3319: else
3320: node = reader->node;
3321: if (node->type == XML_NAMESPACE_DECL) {
3322: xmlNsPtr ns = (xmlNsPtr) node;
3323: if (ns->prefix == NULL)
3324: return(NULL);
3325: return(CONSTSTR(BAD_CAST "xmlns"));
3326: }
3327: if ((node->type != XML_ELEMENT_NODE) &&
3328: (node->type != XML_ATTRIBUTE_NODE))
3329: return(NULL);
3330: if ((node->ns != NULL) && (node->ns->prefix != NULL))
3331: return(CONSTSTR(node->ns->prefix));
3332: return(NULL);
3333: }
3334:
3335: /**
3336: * xmlTextReaderNamespaceUri:
3337: * @reader: the xmlTextReaderPtr used
3338: *
3339: * The URI defining the namespace associated with the node.
3340: *
3341: * Returns the namespace URI or NULL if not available,
3342: * if non NULL it need to be freed by the caller.
3343: */
3344: xmlChar *
3345: xmlTextReaderNamespaceUri(xmlTextReaderPtr reader) {
3346: xmlNodePtr node;
3347: if ((reader == NULL) || (reader->node == NULL))
3348: return(NULL);
3349: if (reader->curnode != NULL)
3350: node = reader->curnode;
3351: else
3352: node = reader->node;
3353: if (node->type == XML_NAMESPACE_DECL)
3354: return(xmlStrdup(BAD_CAST "http://www.w3.org/2000/xmlns/"));
3355: if ((node->type != XML_ELEMENT_NODE) &&
3356: (node->type != XML_ATTRIBUTE_NODE))
3357: return(NULL);
3358: if (node->ns != NULL)
3359: return(xmlStrdup(node->ns->href));
3360: return(NULL);
3361: }
3362:
3363: /**
3364: * xmlTextReaderConstNamespaceUri:
3365: * @reader: the xmlTextReaderPtr used
3366: *
3367: * The URI defining the namespace associated with the node.
3368: *
3369: * Returns the namespace URI or NULL if not available, the string
3370: * will be deallocated with the reader
3371: */
3372: const xmlChar *
3373: xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader) {
3374: xmlNodePtr node;
3375: if ((reader == NULL) || (reader->node == NULL))
3376: return(NULL);
3377: if (reader->curnode != NULL)
3378: node = reader->curnode;
3379: else
3380: node = reader->node;
3381: if (node->type == XML_NAMESPACE_DECL)
3382: return(CONSTSTR(BAD_CAST "http://www.w3.org/2000/xmlns/"));
3383: if ((node->type != XML_ELEMENT_NODE) &&
3384: (node->type != XML_ATTRIBUTE_NODE))
3385: return(NULL);
3386: if (node->ns != NULL)
3387: return(CONSTSTR(node->ns->href));
3388: return(NULL);
3389: }
3390:
3391: /**
3392: * xmlTextReaderBaseUri:
3393: * @reader: the xmlTextReaderPtr used
3394: *
3395: * The base URI of the node.
3396: *
3397: * Returns the base URI or NULL if not available,
3398: * if non NULL it need to be freed by the caller.
3399: */
3400: xmlChar *
3401: xmlTextReaderBaseUri(xmlTextReaderPtr reader) {
3402: if ((reader == NULL) || (reader->node == NULL))
3403: return(NULL);
3404: return(xmlNodeGetBase(NULL, reader->node));
3405: }
3406:
3407: /**
3408: * xmlTextReaderConstBaseUri:
3409: * @reader: the xmlTextReaderPtr used
3410: *
3411: * The base URI of the node.
3412: *
3413: * Returns the base URI or NULL if not available, the string
3414: * will be deallocated with the reader
3415: */
3416: const xmlChar *
3417: xmlTextReaderConstBaseUri(xmlTextReaderPtr reader) {
3418: xmlChar *tmp;
3419: const xmlChar *ret;
3420:
3421: if ((reader == NULL) || (reader->node == NULL))
3422: return(NULL);
3423: tmp = xmlNodeGetBase(NULL, reader->node);
3424: if (tmp == NULL)
3425: return(NULL);
3426: ret = CONSTSTR(tmp);
3427: xmlFree(tmp);
3428: return(ret);
3429: }
3430:
3431: /**
3432: * xmlTextReaderDepth:
3433: * @reader: the xmlTextReaderPtr used
3434: *
3435: * The depth of the node in the tree.
3436: *
3437: * Returns the depth or -1 in case of error
3438: */
3439: int
3440: xmlTextReaderDepth(xmlTextReaderPtr reader) {
3441: if (reader == NULL)
3442: return(-1);
3443: if (reader->node == NULL)
3444: return(0);
3445:
3446: if (reader->curnode != NULL) {
3447: if ((reader->curnode->type == XML_ATTRIBUTE_NODE) ||
3448: (reader->curnode->type == XML_NAMESPACE_DECL))
3449: return(reader->depth + 1);
3450: return(reader->depth + 2);
3451: }
3452: return(reader->depth);
3453: }
3454:
3455: /**
3456: * xmlTextReaderHasAttributes:
3457: * @reader: the xmlTextReaderPtr used
3458: *
3459: * Whether the node has attributes.
3460: *
3461: * Returns 1 if true, 0 if false, and -1 in case or error
3462: */
3463: int
3464: xmlTextReaderHasAttributes(xmlTextReaderPtr reader) {
3465: xmlNodePtr node;
3466: if (reader == NULL)
3467: return(-1);
3468: if (reader->node == NULL)
3469: return(0);
3470: if (reader->curnode != NULL)
3471: node = reader->curnode;
3472: else
3473: node = reader->node;
3474:
3475: if ((node->type == XML_ELEMENT_NODE) &&
3476: ((node->properties != NULL) || (node->nsDef != NULL)))
3477: return(1);
3478: /* TODO: handle the xmlDecl */
3479: return(0);
3480: }
3481:
3482: /**
3483: * xmlTextReaderHasValue:
3484: * @reader: the xmlTextReaderPtr used
3485: *
3486: * Whether the node can have a text value.
3487: *
3488: * Returns 1 if true, 0 if false, and -1 in case or error
3489: */
3490: int
3491: xmlTextReaderHasValue(xmlTextReaderPtr reader) {
3492: xmlNodePtr node;
3493: if (reader == NULL)
3494: return(-1);
3495: if (reader->node == NULL)
3496: return(0);
3497: if (reader->curnode != NULL)
3498: node = reader->curnode;
3499: else
3500: node = reader->node;
3501:
3502: switch (node->type) {
3503: case XML_ATTRIBUTE_NODE:
3504: case XML_TEXT_NODE:
3505: case XML_CDATA_SECTION_NODE:
3506: case XML_PI_NODE:
3507: case XML_COMMENT_NODE:
3508: case XML_NAMESPACE_DECL:
3509: return(1);
3510: default:
3511: break;
3512: }
3513: return(0);
3514: }
3515:
3516: /**
3517: * xmlTextReaderValue:
3518: * @reader: the xmlTextReaderPtr used
3519: *
3520: * Provides the text value of the node if present
3521: *
3522: * Returns the string or NULL if not available. The result must be deallocated
3523: * with xmlFree()
3524: */
3525: xmlChar *
3526: xmlTextReaderValue(xmlTextReaderPtr reader) {
3527: xmlNodePtr node;
3528: if (reader == NULL)
3529: return(NULL);
3530: if (reader->node == NULL)
3531: return(NULL);
3532: if (reader->curnode != NULL)
3533: node = reader->curnode;
3534: else
3535: node = reader->node;
3536:
3537: switch (node->type) {
3538: case XML_NAMESPACE_DECL:
3539: return(xmlStrdup(((xmlNsPtr) node)->href));
3540: case XML_ATTRIBUTE_NODE:{
3541: xmlAttrPtr attr = (xmlAttrPtr) node;
3542:
3543: if (attr->parent != NULL)
3544: return (xmlNodeListGetString
3545: (attr->parent->doc, attr->children, 1));
3546: else
3547: return (xmlNodeListGetString(NULL, attr->children, 1));
3548: break;
3549: }
3550: case XML_TEXT_NODE:
3551: case XML_CDATA_SECTION_NODE:
3552: case XML_PI_NODE:
3553: case XML_COMMENT_NODE:
3554: if (node->content != NULL)
3555: return (xmlStrdup(node->content));
3556: default:
3557: break;
3558: }
3559: return(NULL);
3560: }
3561:
3562: /**
3563: * xmlTextReaderConstValue:
3564: * @reader: the xmlTextReaderPtr used
3565: *
3566: * Provides the text value of the node if present
3567: *
3568: * Returns the string or NULL if not available. The result will be
3569: * deallocated on the next Read() operation.
3570: */
3571: const xmlChar *
3572: xmlTextReaderConstValue(xmlTextReaderPtr reader) {
3573: xmlNodePtr node;
3574: if (reader == NULL)
3575: return(NULL);
3576: if (reader->node == NULL)
3577: return(NULL);
3578: if (reader->curnode != NULL)
3579: node = reader->curnode;
3580: else
3581: node = reader->node;
3582:
3583: switch (node->type) {
3584: case XML_NAMESPACE_DECL:
3585: return(((xmlNsPtr) node)->href);
3586: case XML_ATTRIBUTE_NODE:{
3587: xmlAttrPtr attr = (xmlAttrPtr) node;
3588:
3589: if ((attr->children != NULL) &&
3590: (attr->children->type == XML_TEXT_NODE) &&
3591: (attr->children->next == NULL))
3592: return(attr->children->content);
3593: else {
3594: if (reader->buffer == NULL)
3595: reader->buffer = xmlBufferCreateSize(100);
3596: if (reader->buffer == NULL) {
3597: xmlGenericError(xmlGenericErrorContext,
3598: "xmlTextReaderSetup : malloc failed\n");
3599: return (NULL);
3600: }
3601: reader->buffer->use = 0;
3602: xmlNodeBufGetContent(reader->buffer, node);
3603: return(reader->buffer->content);
3604: }
3605: break;
3606: }
3607: case XML_TEXT_NODE:
3608: case XML_CDATA_SECTION_NODE:
3609: case XML_PI_NODE:
3610: case XML_COMMENT_NODE:
3611: return(node->content);
3612: default:
3613: break;
3614: }
3615: return(NULL);
3616: }
3617:
3618: /**
3619: * xmlTextReaderIsDefault:
3620: * @reader: the xmlTextReaderPtr used
3621: *
3622: * Whether an Attribute node was generated from the default value
3623: * defined in the DTD or schema.
3624: *
3625: * Returns 0 if not defaulted, 1 if defaulted, and -1 in case of error
3626: */
3627: int
3628: xmlTextReaderIsDefault(xmlTextReaderPtr reader) {
3629: if (reader == NULL)
3630: return(-1);
3631: return(0);
3632: }
3633:
3634: /**
3635: * xmlTextReaderQuoteChar:
3636: * @reader: the xmlTextReaderPtr used
3637: *
3638: * The quotation mark character used to enclose the value of an attribute.
3639: *
3640: * Returns " or ' and -1 in case of error
3641: */
3642: int
3643: xmlTextReaderQuoteChar(xmlTextReaderPtr reader) {
3644: if (reader == NULL)
3645: return(-1);
3646: /* TODO maybe lookup the attribute value for " first */
3647: return((int) '"');
3648: }
3649:
3650: /**
3651: * xmlTextReaderXmlLang:
3652: * @reader: the xmlTextReaderPtr used
3653: *
3654: * The xml:lang scope within which the node resides.
3655: *
3656: * Returns the xml:lang value or NULL if none exists.,
3657: * if non NULL it need to be freed by the caller.
3658: */
3659: xmlChar *
3660: xmlTextReaderXmlLang(xmlTextReaderPtr reader) {
3661: if (reader == NULL)
3662: return(NULL);
3663: if (reader->node == NULL)
3664: return(NULL);
3665: return(xmlNodeGetLang(reader->node));
3666: }
3667:
3668: /**
3669: * xmlTextReaderConstXmlLang:
3670: * @reader: the xmlTextReaderPtr used
3671: *
3672: * The xml:lang scope within which the node resides.
3673: *
3674: * Returns the xml:lang value or NULL if none exists.
3675: */
3676: const xmlChar *
3677: xmlTextReaderConstXmlLang(xmlTextReaderPtr reader) {
3678: xmlChar *tmp;
3679: const xmlChar *ret;
3680:
3681: if (reader == NULL)
3682: return(NULL);
3683: if (reader->node == NULL)
3684: return(NULL);
3685: tmp = xmlNodeGetLang(reader->node);
3686: if (tmp == NULL)
3687: return(NULL);
3688: ret = CONSTSTR(tmp);
3689: xmlFree(tmp);
3690: return(ret);
3691: }
3692:
3693: /**
3694: * xmlTextReaderConstString:
3695: * @reader: the xmlTextReaderPtr used
3696: * @str: the string to intern.
3697: *
3698: * Get an interned string from the reader, allows for example to
3699: * speedup string name comparisons
3700: *
3701: * Returns an interned copy of the string or NULL in case of error. The
3702: * string will be deallocated with the reader.
3703: */
3704: const xmlChar *
3705: xmlTextReaderConstString(xmlTextReaderPtr reader, const xmlChar *str) {
3706: if (reader == NULL)
3707: return(NULL);
3708: return(CONSTSTR(str));
3709: }
3710:
3711: /**
3712: * xmlTextReaderNormalization:
3713: * @reader: the xmlTextReaderPtr used
3714: *
3715: * The value indicating whether to normalize white space and attribute values.
3716: * Since attribute value and end of line normalizations are a MUST in the XML
3717: * specification only the value true is accepted. The broken bahaviour of
3718: * accepting out of range character entities like � is of course not
3719: * supported either.
3720: *
3721: * Returns 1 or -1 in case of error.
3722: */
3723: int
3724: xmlTextReaderNormalization(xmlTextReaderPtr reader) {
3725: if (reader == NULL)
3726: return(-1);
3727: return(1);
3728: }
3729:
3730: /************************************************************************
3731: * *
3732: * Extensions to the base APIs *
3733: * *
3734: ************************************************************************/
3735:
3736: /**
3737: * xmlTextReaderSetParserProp:
3738: * @reader: the xmlTextReaderPtr used
3739: * @prop: the xmlParserProperties to set
3740: * @value: usually 0 or 1 to (de)activate it
3741: *
3742: * Change the parser processing behaviour by changing some of its internal
3743: * properties. Note that some properties can only be changed before any
3744: * read has been done.
3745: *
3746: * Returns 0 if the call was successful, or -1 in case of error
3747: */
3748: int
3749: xmlTextReaderSetParserProp(xmlTextReaderPtr reader, int prop, int value) {
3750: xmlParserProperties p = (xmlParserProperties) prop;
3751: xmlParserCtxtPtr ctxt;
3752:
3753: if ((reader == NULL) || (reader->ctxt == NULL))
3754: return(-1);
3755: ctxt = reader->ctxt;
3756:
3757: switch (p) {
3758: case XML_PARSER_LOADDTD:
3759: if (value != 0) {
3760: if (ctxt->loadsubset == 0) {
3761: if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
3762: return(-1);
3763: ctxt->loadsubset = XML_DETECT_IDS;
3764: }
3765: } else {
3766: ctxt->loadsubset = 0;
3767: }
3768: return(0);
3769: case XML_PARSER_DEFAULTATTRS:
3770: if (value != 0) {
3771: ctxt->loadsubset |= XML_COMPLETE_ATTRS;
3772: } else {
3773: if (ctxt->loadsubset & XML_COMPLETE_ATTRS)
3774: ctxt->loadsubset -= XML_COMPLETE_ATTRS;
3775: }
3776: return(0);
3777: case XML_PARSER_VALIDATE:
3778: if (value != 0) {
3779: ctxt->validate = 1;
3780: reader->validate = XML_TEXTREADER_VALIDATE_DTD;
3781: } else {
3782: ctxt->validate = 0;
3783: }
3784: return(0);
3785: case XML_PARSER_SUBST_ENTITIES:
3786: if (value != 0) {
3787: ctxt->replaceEntities = 1;
3788: } else {
3789: ctxt->replaceEntities = 0;
3790: }
3791: return(0);
3792: }
3793: return(-1);
3794: }
3795:
3796: /**
3797: * xmlTextReaderGetParserProp:
3798: * @reader: the xmlTextReaderPtr used
3799: * @prop: the xmlParserProperties to get
3800: *
3801: * Read the parser internal property.
3802: *
3803: * Returns the value, usually 0 or 1, or -1 in case of error.
3804: */
3805: int
3806: xmlTextReaderGetParserProp(xmlTextReaderPtr reader, int prop) {
3807: xmlParserProperties p = (xmlParserProperties) prop;
3808: xmlParserCtxtPtr ctxt;
3809:
3810: if ((reader == NULL) || (reader->ctxt == NULL))
3811: return(-1);
3812: ctxt = reader->ctxt;
3813:
3814: switch (p) {
3815: case XML_PARSER_LOADDTD:
3816: if ((ctxt->loadsubset != 0) || (ctxt->validate != 0))
3817: return(1);
3818: return(0);
3819: case XML_PARSER_DEFAULTATTRS:
3820: if (ctxt->loadsubset & XML_COMPLETE_ATTRS)
3821: return(1);
3822: return(0);
3823: case XML_PARSER_VALIDATE:
3824: return(reader->validate);
3825: case XML_PARSER_SUBST_ENTITIES:
3826: return(ctxt->replaceEntities);
3827: }
3828: return(-1);
3829: }
3830:
3831:
3832: /**
3833: * xmlTextReaderGetParserLineNumber:
3834: * @reader: the user data (XML reader context)
3835: *
3836: * Provide the line number of the current parsing point.
3837: *
3838: * Returns an int or 0 if not available
3839: */
3840: int
3841: xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader)
3842: {
3843: if ((reader == NULL) || (reader->ctxt == NULL) ||
3844: (reader->ctxt->input == NULL)) {
3845: return (0);
3846: }
3847: return (reader->ctxt->input->line);
3848: }
3849:
3850: /**
3851: * xmlTextReaderGetParserColumnNumber:
3852: * @reader: the user data (XML reader context)
3853: *
3854: * Provide the column number of the current parsing point.
3855: *
3856: * Returns an int or 0 if not available
3857: */
3858: int
3859: xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader)
3860: {
3861: if ((reader == NULL) || (reader->ctxt == NULL) ||
3862: (reader->ctxt->input == NULL)) {
3863: return (0);
3864: }
3865: return (reader->ctxt->input->col);
3866: }
3867:
3868: /**
3869: * xmlTextReaderCurrentNode:
3870: * @reader: the xmlTextReaderPtr used
3871: *
3872: * Hacking interface allowing to get the xmlNodePtr correponding to the
3873: * current node being accessed by the xmlTextReader. This is dangerous
3874: * because the underlying node may be destroyed on the next Reads.
3875: *
3876: * Returns the xmlNodePtr or NULL in case of error.
3877: */
3878: xmlNodePtr
3879: xmlTextReaderCurrentNode(xmlTextReaderPtr reader) {
3880: if (reader == NULL)
3881: return(NULL);
3882:
3883: if (reader->curnode != NULL)
3884: return(reader->curnode);
3885: return(reader->node);
3886: }
3887:
3888: /**
3889: * xmlTextReaderPreserve:
3890: * @reader: the xmlTextReaderPtr used
3891: *
3892: * This tells the XML Reader to preserve the current node.
3893: * The caller must also use xmlTextReaderCurrentDoc() to
3894: * keep an handle on the resulting document once parsing has finished
3895: *
3896: * Returns the xmlNodePtr or NULL in case of error.
3897: */
3898: xmlNodePtr
3899: xmlTextReaderPreserve(xmlTextReaderPtr reader) {
3900: xmlNodePtr cur, parent;
3901:
3902: if (reader == NULL)
3903: return(NULL);
3904:
3905: if (reader->curnode != NULL)
3906: cur = reader->curnode;
3907: else
3908: cur = reader->node;
3909: if (cur == NULL)
3910: return(NULL);
3911:
3912: if ((cur->type != XML_DOCUMENT_NODE) && (cur->type != XML_DTD_NODE)) {
3913: cur->extra |= NODE_IS_PRESERVED;
3914: cur->extra |= NODE_IS_SPRESERVED;
3915: }
3916: reader->preserves++;
3917:
3918: parent = cur->parent;;
3919: while (parent != NULL) {
3920: if (parent->type == XML_ELEMENT_NODE)
3921: parent->extra |= NODE_IS_PRESERVED;
3922: parent = parent->parent;
3923: }
3924: return(cur);
3925: }
3926:
3927: #ifdef LIBXML_PATTERN_ENABLED
3928: /**
3929: * xmlTextReaderPreservePattern:
3930: * @reader: the xmlTextReaderPtr used
3931: * @pattern: an XPath subset pattern
3932: * @namespaces: the prefix definitions, array of [URI, prefix] or NULL
3933: *
3934: * This tells the XML Reader to preserve all nodes matched by the
3935: * pattern. The caller must also use xmlTextReaderCurrentDoc() to
3936: * keep an handle on the resulting document once parsing has finished
3937: *
3938: * Returns a positive number in case of success and -1 in case of error
3939: */
3940: int
3941: xmlTextReaderPreservePattern(xmlTextReaderPtr reader, const xmlChar *pattern,
3942: const xmlChar **namespaces)
3943: {
3944: xmlPatternPtr comp;
3945:
3946: if ((reader == NULL) || (pattern == NULL))
3947: return(-1);
3948:
3949: comp = xmlPatterncompile(pattern, reader->dict, 0, namespaces);
3950: if (comp == NULL)
3951: return(-1);
3952:
3953: if (reader->patternMax <= 0) {
3954: reader->patternMax = 4;
3955: reader->patternTab = (xmlPatternPtr *) xmlMalloc(reader->patternMax *
3956: sizeof(reader->patternTab[0]));
3957: if (reader->patternTab == NULL) {
3958: xmlGenericError(xmlGenericErrorContext, "xmlMalloc failed !\n");
3959: return (-1);
3960: }
3961: }
3962: if (reader->patternNr >= reader->patternMax) {
3963: xmlPatternPtr *tmp;
3964: reader->patternMax *= 2;
3965: tmp = (xmlPatternPtr *) xmlRealloc(reader->patternTab,
3966: reader->patternMax *
3967: sizeof(reader->patternTab[0]));
3968: if (tmp == NULL) {
3969: xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
3970: reader->patternMax /= 2;
3971: return (-1);
3972: }
3973: reader->patternTab = tmp;
3974: }
3975: reader->patternTab[reader->patternNr] = comp;
3976: return(reader->patternNr++);
3977: }
3978: #endif
3979:
3980: /**
3981: * xmlTextReaderCurrentDoc:
3982: * @reader: the xmlTextReaderPtr used
3983: *
3984: * Hacking interface allowing to get the xmlDocPtr correponding to the
3985: * current document being accessed by the xmlTextReader.
3986: * NOTE: as a result of this call, the reader will not destroy the
3987: * associated XML document and calling xmlFreeDoc() on the result
3988: * is needed once the reader parsing has finished.
3989: *
3990: * Returns the xmlDocPtr or NULL in case of error.
3991: */
3992: xmlDocPtr
3993: xmlTextReaderCurrentDoc(xmlTextReaderPtr reader) {
3994: if (reader == NULL)
3995: return(NULL);
3996: if (reader->doc != NULL)
3997: return(reader->doc);
3998: if ((reader->ctxt == NULL) || (reader->ctxt->myDoc == NULL))
3999: return(NULL);
4000:
4001: reader->preserve = 1;
4002: return(reader->ctxt->myDoc);
4003: }
4004:
4005: #ifdef LIBXML_SCHEMAS_ENABLED
4006: static char *xmlTextReaderBuildMessage(const char *msg, va_list ap);
4007:
4008: static void XMLCDECL
4009: xmlTextReaderValidityError(void *ctxt, const char *msg, ...);
4010:
4011: static void XMLCDECL
4012: xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...);
4013:
4014: static void XMLCDECL
4015: xmlTextReaderValidityErrorRelay(void *ctx, const char *msg, ...)
4016: {
4017: xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
4018:
4019: char *str;
4020:
4021: va_list ap;
4022:
4023: va_start(ap, msg);
4024: str = xmlTextReaderBuildMessage(msg, ap);
4025: if (!reader->errorFunc) {
4026: xmlTextReaderValidityError(ctx, "%s", str);
4027: } else {
4028: reader->errorFunc(reader->errorFuncArg, str,
4029: XML_PARSER_SEVERITY_VALIDITY_ERROR,
4030: NULL /* locator */ );
4031: }
4032: if (str != NULL)
4033: xmlFree(str);
4034: va_end(ap);
4035: }
4036:
4037: static void XMLCDECL
4038: xmlTextReaderValidityWarningRelay(void *ctx, const char *msg, ...)
4039: {
4040: xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
4041:
4042: char *str;
4043:
4044: va_list ap;
4045:
4046: va_start(ap, msg);
4047: str = xmlTextReaderBuildMessage(msg, ap);
4048: if (!reader->errorFunc) {
4049: xmlTextReaderValidityWarning(ctx, "%s", str);
4050: } else {
4051: reader->errorFunc(reader->errorFuncArg, str,
4052: XML_PARSER_SEVERITY_VALIDITY_WARNING,
4053: NULL /* locator */ );
4054: }
4055: if (str != NULL)
4056: xmlFree(str);
4057: va_end(ap);
4058: }
4059:
4060: static void
4061: xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error);
4062:
4063: static void
4064: xmlTextReaderValidityStructuredRelay(void *userData, xmlErrorPtr error)
4065: {
4066: xmlTextReaderPtr reader = (xmlTextReaderPtr) userData;
4067:
4068: if (reader->sErrorFunc) {
4069: reader->sErrorFunc(reader->errorFuncArg, error);
4070: } else {
4071: xmlTextReaderStructuredError(reader, error);
4072: }
4073: }
4074: /**
4075: * xmlTextReaderRelaxNGSetSchema:
4076: * @reader: the xmlTextReaderPtr used
4077: * @schema: a precompiled RelaxNG schema
4078: *
4079: * Use RelaxNG to validate the document as it is processed.
4080: * Activation is only possible before the first Read().
4081: * if @schema is NULL, then RelaxNG validation is desactivated.
4082: @ The @schema should not be freed until the reader is deallocated
4083: * or its use has been deactivated.
4084: *
4085: * Returns 0 in case the RelaxNG validation could be (des)activated and
4086: * -1 in case of error.
4087: */
4088: int
4089: xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, xmlRelaxNGPtr schema) {
4090: if (reader == NULL)
4091: return(-1);
4092: if (schema == NULL) {
4093: if (reader->rngSchemas != NULL) {
4094: xmlRelaxNGFree(reader->rngSchemas);
4095: reader->rngSchemas = NULL;
4096: }
4097: if (reader->rngValidCtxt != NULL) {
4098: xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4099: reader->rngValidCtxt = NULL;
4100: }
4101: return(0);
4102: }
4103: if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4104: return(-1);
4105: if (reader->rngSchemas != NULL) {
4106: xmlRelaxNGFree(reader->rngSchemas);
4107: reader->rngSchemas = NULL;
4108: }
4109: if (reader->rngValidCtxt != NULL) {
4110: xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4111: reader->rngValidCtxt = NULL;
4112: }
4113: reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(schema);
4114: if (reader->rngValidCtxt == NULL)
4115: return(-1);
4116: if (reader->errorFunc != NULL) {
4117: xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4118: xmlTextReaderValidityErrorRelay,
4119: xmlTextReaderValidityWarningRelay,
4120: reader);
4121: }
4122: if (reader->sErrorFunc != NULL) {
4123: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4124: xmlTextReaderValidityStructuredRelay,
4125: reader);
4126: }
4127: reader->rngValidErrors = 0;
4128: reader->rngFullNode = NULL;
4129: reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4130: return(0);
4131: }
4132:
4133: /**
4134: * xmlTextReaderSetSchema:
4135: * @reader: the xmlTextReaderPtr used
4136: * @schema: a precompiled Schema schema
4137: *
4138: * Use XSD Schema to validate the document as it is processed.
4139: * Activation is only possible before the first Read().
4140: * if @schema is NULL, then Schema validation is desactivated.
4141: @ The @schema should not be freed until the reader is deallocated
4142: * or its use has been deactivated.
4143: *
4144: * Returns 0 in case the Schema validation could be (des)activated and
4145: * -1 in case of error.
4146: */
4147: int
4148: xmlTextReaderSetSchema(xmlTextReaderPtr reader, xmlSchemaPtr schema) {
4149: if (reader == NULL)
4150: return(-1);
4151: if (schema == NULL) {
4152: if (reader->xsdPlug != NULL) {
4153: xmlSchemaSAXUnplug(reader->xsdPlug);
4154: reader->xsdPlug = NULL;
4155: }
4156: if (reader->xsdValidCtxt != NULL) {
4157: if (! reader->xsdPreserveCtxt)
4158: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4159: reader->xsdValidCtxt = NULL;
4160: }
4161: reader->xsdPreserveCtxt = 0;
4162: if (reader->xsdSchemas != NULL) {
4163: xmlSchemaFree(reader->xsdSchemas);
4164: reader->xsdSchemas = NULL;
4165: }
4166: return(0);
4167: }
4168: if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4169: return(-1);
4170: if (reader->xsdPlug != NULL) {
4171: xmlSchemaSAXUnplug(reader->xsdPlug);
4172: reader->xsdPlug = NULL;
4173: }
4174: if (reader->xsdValidCtxt != NULL) {
4175: if (! reader->xsdPreserveCtxt)
4176: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4177: reader->xsdValidCtxt = NULL;
4178: }
4179: reader->xsdPreserveCtxt = 0;
4180: if (reader->xsdSchemas != NULL) {
4181: xmlSchemaFree(reader->xsdSchemas);
4182: reader->xsdSchemas = NULL;
4183: }
4184: reader->xsdValidCtxt = xmlSchemaNewValidCtxt(schema);
4185: if (reader->xsdValidCtxt == NULL) {
4186: xmlSchemaFree(reader->xsdSchemas);
4187: reader->xsdSchemas = NULL;
4188: return(-1);
4189: }
4190: reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4191: &(reader->ctxt->sax),
4192: &(reader->ctxt->userData));
4193: if (reader->xsdPlug == NULL) {
4194: xmlSchemaFree(reader->xsdSchemas);
4195: reader->xsdSchemas = NULL;
4196: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4197: reader->xsdValidCtxt = NULL;
4198: return(-1);
4199: }
4200: if (reader->errorFunc != NULL) {
4201: xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4202: xmlTextReaderValidityErrorRelay,
4203: xmlTextReaderValidityWarningRelay,
4204: reader);
4205: }
4206: if (reader->sErrorFunc != NULL) {
4207: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4208: xmlTextReaderValidityStructuredRelay,
4209: reader);
4210: }
4211: reader->xsdValidErrors = 0;
4212: reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4213: return(0);
4214: }
4215:
4216: /**
4217: * xmlTextReaderRelaxNGValidate:
4218: * @reader: the xmlTextReaderPtr used
4219: * @rng: the path to a RelaxNG schema or NULL
4220: *
4221: * Use RelaxNG to validate the document as it is processed.
4222: * Activation is only possible before the first Read().
4223: * if @rng is NULL, then RelaxNG validation is deactivated.
4224: *
4225: * Returns 0 in case the RelaxNG validation could be (de)activated and
4226: * -1 in case of error.
4227: */
4228: int
4229: xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng) {
4230: xmlRelaxNGParserCtxtPtr ctxt;
4231:
4232: if (reader == NULL)
4233: return(-1);
4234:
4235: if (rng == NULL) {
4236: if (reader->rngValidCtxt != NULL) {
4237: xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4238: reader->rngValidCtxt = NULL;
4239: }
4240: if (reader->rngSchemas != NULL) {
4241: xmlRelaxNGFree(reader->rngSchemas);
4242: reader->rngSchemas = NULL;
4243: }
4244: return(0);
4245: }
4246: if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4247: return(-1);
4248: if (reader->rngSchemas != NULL) {
4249: xmlRelaxNGFree(reader->rngSchemas);
4250: reader->rngSchemas = NULL;
4251: }
4252: if (reader->rngValidCtxt != NULL) {
4253: xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4254: reader->rngValidCtxt = NULL;
4255: }
4256: ctxt = xmlRelaxNGNewParserCtxt(rng);
4257: if (reader->errorFunc != NULL) {
4258: xmlRelaxNGSetParserErrors(ctxt,
4259: xmlTextReaderValidityErrorRelay,
4260: xmlTextReaderValidityWarningRelay,
4261: reader);
4262: }
4263: if (reader->sErrorFunc != NULL) {
4264: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4265: xmlTextReaderValidityStructuredRelay,
4266: reader);
4267: }
4268: reader->rngSchemas = xmlRelaxNGParse(ctxt);
4269: xmlRelaxNGFreeParserCtxt(ctxt);
4270: if (reader->rngSchemas == NULL)
4271: return(-1);
4272: reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
4273: if (reader->rngValidCtxt == NULL) {
4274: xmlRelaxNGFree(reader->rngSchemas);
4275: reader->rngSchemas = NULL;
4276: return(-1);
4277: }
4278: if (reader->errorFunc != NULL) {
4279: xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4280: xmlTextReaderValidityErrorRelay,
4281: xmlTextReaderValidityWarningRelay,
4282: reader);
4283: }
4284: if (reader->sErrorFunc != NULL) {
4285: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4286: xmlTextReaderValidityStructuredRelay,
4287: reader);
4288: }
4289: reader->rngValidErrors = 0;
4290: reader->rngFullNode = NULL;
4291: reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4292: return(0);
4293: }
4294:
4295: /**
4296: * xmlTextReaderSchemaValidateInternal:
4297: * @reader: the xmlTextReaderPtr used
4298: * @xsd: the path to a W3C XSD schema or NULL
4299: * @ctxt: the XML Schema validation context or NULL
4300: * @options: options (not used yet)
4301: *
4302: * Validate the document as it is processed using XML Schema.
4303: * Activation is only possible before the first Read().
4304: * If both @xsd and @ctxt are NULL then XML Schema validation is deactivated.
4305: *
4306: * Returns 0 in case the schemas validation could be (de)activated and
4307: * -1 in case of error.
4308: */
4309: static int
4310: xmlTextReaderSchemaValidateInternal(xmlTextReaderPtr reader,
4311: const char *xsd,
4312: xmlSchemaValidCtxtPtr ctxt,
4313: int options ATTRIBUTE_UNUSED)
4314: {
4315: if (reader == NULL)
4316: return(-1);
4317:
4318: if ((xsd != NULL) && (ctxt != NULL))
4319: return(-1);
4320:
4321: if (((xsd != NULL) || (ctxt != NULL)) &&
4322: ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
4323: (reader->ctxt == NULL)))
4324: return(-1);
4325:
4326: /* Cleanup previous validation stuff. */
4327: if (reader->xsdPlug != NULL) {
4328: xmlSchemaSAXUnplug(reader->xsdPlug);
4329: reader->xsdPlug = NULL;
4330: }
4331: if (reader->xsdValidCtxt != NULL) {
4332: if (! reader->xsdPreserveCtxt)
4333: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4334: reader->xsdValidCtxt = NULL;
4335: }
4336: reader->xsdPreserveCtxt = 0;
4337: if (reader->xsdSchemas != NULL) {
4338: xmlSchemaFree(reader->xsdSchemas);
4339: reader->xsdSchemas = NULL;
4340: }
4341:
4342: if ((xsd == NULL) && (ctxt == NULL)) {
4343: /* We just want to deactivate the validation, so get out. */
4344: return(0);
4345: }
4346:
4347: if (xsd != NULL) {
4348: xmlSchemaParserCtxtPtr pctxt;
4349: /* Parse the schema and create validation environment. */
4350: pctxt = xmlSchemaNewParserCtxt(xsd);
4351: if (reader->errorFunc != NULL) {
4352: xmlSchemaSetParserErrors(pctxt,
4353: xmlTextReaderValidityErrorRelay,
4354: xmlTextReaderValidityWarningRelay,
4355: reader);
4356: }
4357: reader->xsdSchemas = xmlSchemaParse(pctxt);
4358: xmlSchemaFreeParserCtxt(pctxt);
4359: if (reader->xsdSchemas == NULL)
4360: return(-1);
4361: reader->xsdValidCtxt = xmlSchemaNewValidCtxt(reader->xsdSchemas);
4362: if (reader->xsdValidCtxt == NULL) {
4363: xmlSchemaFree(reader->xsdSchemas);
4364: reader->xsdSchemas = NULL;
4365: return(-1);
4366: }
4367: reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4368: &(reader->ctxt->sax),
4369: &(reader->ctxt->userData));
4370: if (reader->xsdPlug == NULL) {
4371: xmlSchemaFree(reader->xsdSchemas);
4372: reader->xsdSchemas = NULL;
4373: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4374: reader->xsdValidCtxt = NULL;
4375: return(-1);
4376: }
4377: } else {
4378: /* Use the given validation context. */
4379: reader->xsdValidCtxt = ctxt;
4380: reader->xsdPreserveCtxt = 1;
4381: reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4382: &(reader->ctxt->sax),
4383: &(reader->ctxt->userData));
4384: if (reader->xsdPlug == NULL) {
4385: reader->xsdValidCtxt = NULL;
4386: reader->xsdPreserveCtxt = 0;
4387: return(-1);
4388: }
4389: }
4390: /*
4391: * Redirect the validation context's error channels to use
4392: * the reader channels.
4393: * TODO: In case the user provides the validation context we
4394: * could make this redirection optional.
4395: */
4396: if (reader->errorFunc != NULL) {
4397: xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4398: xmlTextReaderValidityErrorRelay,
4399: xmlTextReaderValidityWarningRelay,
4400: reader);
4401: }
4402: if (reader->sErrorFunc != NULL) {
4403: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4404: xmlTextReaderValidityStructuredRelay,
4405: reader);
4406: }
4407: reader->xsdValidErrors = 0;
4408: reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4409: return(0);
4410: }
4411:
4412: /**
4413: * xmlTextReaderSchemaValidateCtxt:
4414: * @reader: the xmlTextReaderPtr used
4415: * @ctxt: the XML Schema validation context or NULL
4416: * @options: options (not used yet)
4417: *
4418: * Use W3C XSD schema context to validate the document as it is processed.
4419: * Activation is only possible before the first Read().
4420: * If @ctxt is NULL, then XML Schema validation is deactivated.
4421: *
4422: * Returns 0 in case the schemas validation could be (de)activated and
4423: * -1 in case of error.
4424: */
4425: int
4426: xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader,
4427: xmlSchemaValidCtxtPtr ctxt,
4428: int options)
4429: {
4430: return(xmlTextReaderSchemaValidateInternal(reader, NULL, ctxt, options));
4431: }
4432:
4433: /**
4434: * xmlTextReaderSchemaValidate:
4435: * @reader: the xmlTextReaderPtr used
4436: * @xsd: the path to a W3C XSD schema or NULL
4437: *
4438: * Use W3C XSD schema to validate the document as it is processed.
4439: * Activation is only possible before the first Read().
4440: * If @xsd is NULL, then XML Schema validation is deactivated.
4441: *
4442: * Returns 0 in case the schemas validation could be (de)activated and
4443: * -1 in case of error.
4444: */
4445: int
4446: xmlTextReaderSchemaValidate(xmlTextReaderPtr reader, const char *xsd)
4447: {
4448: return(xmlTextReaderSchemaValidateInternal(reader, xsd, NULL, 0));
4449: }
4450: #endif
4451:
4452: /**
4453: * xmlTextReaderIsNamespaceDecl:
4454: * @reader: the xmlTextReaderPtr used
4455: *
4456: * Determine whether the current node is a namespace declaration
4457: * rather than a regular attribute.
4458: *
4459: * Returns 1 if the current node is a namespace declaration, 0 if it
4460: * is a regular attribute or other type of node, or -1 in case of
4461: * error.
4462: */
4463: int
4464: xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader) {
4465: xmlNodePtr node;
4466: if (reader == NULL)
4467: return(-1);
4468: if (reader->node == NULL)
4469: return(-1);
4470: if (reader->curnode != NULL)
4471: node = reader->curnode;
4472: else
4473: node = reader->node;
4474:
4475: if (XML_NAMESPACE_DECL == node->type)
4476: return(1);
4477: else
4478: return(0);
4479: }
4480:
4481: /**
4482: * xmlTextReaderConstXmlVersion:
4483: * @reader: the xmlTextReaderPtr used
4484: *
4485: * Determine the XML version of the document being read.
4486: *
4487: * Returns a string containing the XML version of the document or NULL
4488: * in case of error. The string is deallocated with the reader.
4489: */
4490: const xmlChar *
4491: xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader) {
4492: xmlDocPtr doc = NULL;
4493: if (reader == NULL)
4494: return(NULL);
4495: if (reader->doc != NULL)
4496: doc = reader->doc;
4497: else if (reader->ctxt != NULL)
4498: doc = reader->ctxt->myDoc;
4499: if (doc == NULL)
4500: return(NULL);
4501:
4502: if (doc->version == NULL)
4503: return(NULL);
4504: else
4505: return(CONSTSTR(doc->version));
4506: }
4507:
4508: /**
4509: * xmlTextReaderStandalone:
4510: * @reader: the xmlTextReaderPtr used
4511: *
4512: * Determine the standalone status of the document being read.
4513: *
4514: * Returns 1 if the document was declared to be standalone, 0 if it
4515: * was declared to be not standalone, or -1 if the document did not
4516: * specify its standalone status or in case of error.
4517: */
4518: int
4519: xmlTextReaderStandalone(xmlTextReaderPtr reader) {
4520: xmlDocPtr doc = NULL;
4521: if (reader == NULL)
4522: return(-1);
4523: if (reader->doc != NULL)
4524: doc = reader->doc;
4525: else if (reader->ctxt != NULL)
4526: doc = reader->ctxt->myDoc;
4527: if (doc == NULL)
4528: return(-1);
4529:
4530: return(doc->standalone);
4531: }
4532:
4533: /************************************************************************
4534: * *
4535: * Error Handling Extensions *
4536: * *
4537: ************************************************************************/
4538:
4539: /* helper to build a xmlMalloc'ed string from a format and va_list */
4540: static char *
4541: xmlTextReaderBuildMessage(const char *msg, va_list ap) {
4542: int size = 0;
4543: int chars;
4544: char *larger;
4545: char *str = NULL;
4546: va_list aq;
4547:
4548: while (1) {
4549: VA_COPY(aq, ap);
4550: chars = vsnprintf(str, size, msg, aq);
4551: va_end(aq);
4552: if (chars < 0) {
4553: xmlGenericError(xmlGenericErrorContext, "vsnprintf failed !\n");
4554: if (str)
4555: xmlFree(str);
4556: return NULL;
4557: }
4558: if ((chars < size) || (size == MAX_ERR_MSG_SIZE))
4559: break;
4560: if (chars < MAX_ERR_MSG_SIZE)
4561: size = chars + 1;
4562: else
4563: size = MAX_ERR_MSG_SIZE;
4564: if ((larger = (char *) xmlRealloc(str, size)) == NULL) {
4565: xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
4566: if (str)
4567: xmlFree(str);
4568: return NULL;
4569: }
4570: str = larger;
4571: }
4572:
4573: return str;
4574: }
4575:
4576: /**
4577: * xmlTextReaderLocatorLineNumber:
4578: * @locator: the xmlTextReaderLocatorPtr used
4579: *
4580: * Obtain the line number for the given locator.
4581: *
4582: * Returns the line number or -1 in case of error.
4583: */
4584: int
4585: xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator) {
4586: /* we know that locator is a xmlParserCtxtPtr */
4587: xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
4588: int ret = -1;
4589:
4590: if (locator == NULL)
4591: return(-1);
4592: if (ctx->node != NULL) {
4593: ret = xmlGetLineNo(ctx->node);
4594: }
4595: else {
4596: /* inspired from error.c */
4597: xmlParserInputPtr input;
4598: input = ctx->input;
4599: if ((input->filename == NULL) && (ctx->inputNr > 1))
4600: input = ctx->inputTab[ctx->inputNr - 2];
4601: if (input != NULL) {
4602: ret = input->line;
4603: }
4604: else {
4605: ret = -1;
4606: }
4607: }
4608:
4609: return ret;
4610: }
4611:
4612: /**
4613: * xmlTextReaderLocatorBaseURI:
4614: * @locator: the xmlTextReaderLocatorPtr used
4615: *
4616: * Obtain the base URI for the given locator.
4617: *
4618: * Returns the base URI or NULL in case of error,
4619: * if non NULL it need to be freed by the caller.
4620: */
4621: xmlChar *
4622: xmlTextReaderLocatorBaseURI(xmlTextReaderLocatorPtr locator) {
4623: /* we know that locator is a xmlParserCtxtPtr */
4624: xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
4625: xmlChar *ret = NULL;
4626:
4627: if (locator == NULL)
4628: return(NULL);
4629: if (ctx->node != NULL) {
4630: ret = xmlNodeGetBase(NULL,ctx->node);
4631: }
4632: else {
4633: /* inspired from error.c */
4634: xmlParserInputPtr input;
4635: input = ctx->input;
4636: if ((input->filename == NULL) && (ctx->inputNr > 1))
4637: input = ctx->inputTab[ctx->inputNr - 2];
4638: if (input != NULL) {
4639: ret = xmlStrdup(BAD_CAST input->filename);
4640: }
4641: else {
4642: ret = NULL;
4643: }
4644: }
4645:
4646: return ret;
4647: }
4648:
4649: static void
4650: xmlTextReaderGenericError(void *ctxt, xmlParserSeverities severity,
4651: char *str)
4652: {
4653: xmlParserCtxtPtr ctx = (xmlParserCtxtPtr) ctxt;
4654:
4655: xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
4656:
4657: if (str != NULL) {
4658: if (reader->errorFunc)
4659: reader->errorFunc(reader->errorFuncArg, str, severity,
4660: (xmlTextReaderLocatorPtr) ctx);
4661: xmlFree(str);
4662: }
4663: }
4664:
4665: static void
4666: xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error)
4667: {
4668: xmlParserCtxtPtr ctx = (xmlParserCtxtPtr) ctxt;
4669:
4670: xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
4671:
4672: if (error && reader->sErrorFunc) {
4673: reader->sErrorFunc(reader->errorFuncArg, (xmlErrorPtr) error);
4674: }
4675: }
4676:
4677: static void XMLCDECL
4678: xmlTextReaderError(void *ctxt, const char *msg, ...)
4679: {
4680: va_list ap;
4681:
4682: va_start(ap, msg);
4683: xmlTextReaderGenericError(ctxt,
4684: XML_PARSER_SEVERITY_ERROR,
4685: xmlTextReaderBuildMessage(msg, ap));
4686: va_end(ap);
4687:
4688: }
4689:
4690: static void XMLCDECL
4691: xmlTextReaderWarning(void *ctxt, const char *msg, ...)
4692: {
4693: va_list ap;
4694:
4695: va_start(ap, msg);
4696: xmlTextReaderGenericError(ctxt,
4697: XML_PARSER_SEVERITY_WARNING,
4698: xmlTextReaderBuildMessage(msg, ap));
4699: va_end(ap);
4700: }
4701:
4702: static void XMLCDECL
4703: xmlTextReaderValidityError(void *ctxt, const char *msg, ...)
4704: {
4705: va_list ap;
4706:
4707: int len = xmlStrlen((const xmlChar *) msg);
4708:
4709: if ((len > 1) && (msg[len - 2] != ':')) {
4710: /*
4711: * some callbacks only report locator information:
4712: * skip them (mimicking behaviour in error.c)
4713: */
4714: va_start(ap, msg);
4715: xmlTextReaderGenericError(ctxt,
4716: XML_PARSER_SEVERITY_VALIDITY_ERROR,
4717: xmlTextReaderBuildMessage(msg, ap));
4718: va_end(ap);
4719: }
4720: }
4721:
4722: static void XMLCDECL
4723: xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...)
4724: {
4725: va_list ap;
4726:
4727: int len = xmlStrlen((const xmlChar *) msg);
4728:
4729: if ((len != 0) && (msg[len - 1] != ':')) {
4730: /*
4731: * some callbacks only report locator information:
4732: * skip them (mimicking behaviour in error.c)
4733: */
4734: va_start(ap, msg);
4735: xmlTextReaderGenericError(ctxt,
4736: XML_PARSER_SEVERITY_VALIDITY_WARNING,
4737: xmlTextReaderBuildMessage(msg, ap));
4738: va_end(ap);
4739: }
4740: }
4741:
4742: /**
4743: * xmlTextReaderSetErrorHandler:
4744: * @reader: the xmlTextReaderPtr used
4745: * @f: the callback function to call on error and warnings
4746: * @arg: a user argument to pass to the callback function
4747: *
4748: * Register a callback function that will be called on error and warnings.
4749: *
4750: * If @f is NULL, the default error and warning handlers are restored.
4751: */
4752: void
4753: xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
4754: xmlTextReaderErrorFunc f, void *arg)
4755: {
4756: if (f != NULL) {
4757: reader->ctxt->sax->error = xmlTextReaderError;
4758: reader->ctxt->sax->serror = NULL;
4759: reader->ctxt->vctxt.error = xmlTextReaderValidityError;
4760: reader->ctxt->sax->warning = xmlTextReaderWarning;
4761: reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
4762: reader->errorFunc = f;
4763: reader->sErrorFunc = NULL;
4764: reader->errorFuncArg = arg;
4765: #ifdef LIBXML_SCHEMAS_ENABLED
4766: if (reader->rngValidCtxt) {
4767: xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4768: xmlTextReaderValidityErrorRelay,
4769: xmlTextReaderValidityWarningRelay,
4770: reader);
4771: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
4772: reader);
4773: }
4774: if (reader->xsdValidCtxt) {
4775: xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4776: xmlTextReaderValidityErrorRelay,
4777: xmlTextReaderValidityWarningRelay,
4778: reader);
4779: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
4780: reader);
4781: }
4782: #endif
4783: } else {
4784: /* restore defaults */
4785: reader->ctxt->sax->error = xmlParserError;
4786: reader->ctxt->vctxt.error = xmlParserValidityError;
4787: reader->ctxt->sax->warning = xmlParserWarning;
4788: reader->ctxt->vctxt.warning = xmlParserValidityWarning;
4789: reader->errorFunc = NULL;
4790: reader->sErrorFunc = NULL;
4791: reader->errorFuncArg = NULL;
4792: #ifdef LIBXML_SCHEMAS_ENABLED
4793: if (reader->rngValidCtxt) {
4794: xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
4795: reader);
4796: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
4797: reader);
4798: }
4799: if (reader->xsdValidCtxt) {
4800: xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
4801: reader);
4802: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
4803: reader);
4804: }
4805: #endif
4806: }
4807: }
4808:
4809: /**
4810: * xmlTextReaderSetStructuredErrorHandler:
4811: * @reader: the xmlTextReaderPtr used
4812: * @f: the callback function to call on error and warnings
4813: * @arg: a user argument to pass to the callback function
4814: *
4815: * Register a callback function that will be called on error and warnings.
4816: *
4817: * If @f is NULL, the default error and warning handlers are restored.
4818: */
4819: void
4820: xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
4821: xmlStructuredErrorFunc f, void *arg)
4822: {
4823: if (f != NULL) {
4824: reader->ctxt->sax->error = NULL;
4825: reader->ctxt->sax->serror = xmlTextReaderStructuredError;
4826: reader->ctxt->vctxt.error = xmlTextReaderValidityError;
4827: reader->ctxt->sax->warning = xmlTextReaderWarning;
4828: reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
4829: reader->sErrorFunc = f;
4830: reader->errorFunc = NULL;
4831: reader->errorFuncArg = arg;
4832: #ifdef LIBXML_SCHEMAS_ENABLED
4833: if (reader->rngValidCtxt) {
4834: xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
4835: reader);
4836: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4837: xmlTextReaderValidityStructuredRelay,
4838: reader);
4839: }
4840: if (reader->xsdValidCtxt) {
4841: xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
4842: reader);
4843: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4844: xmlTextReaderValidityStructuredRelay,
4845: reader);
4846: }
4847: #endif
4848: } else {
4849: /* restore defaults */
4850: reader->ctxt->sax->error = xmlParserError;
4851: reader->ctxt->sax->serror = NULL;
4852: reader->ctxt->vctxt.error = xmlParserValidityError;
4853: reader->ctxt->sax->warning = xmlParserWarning;
4854: reader->ctxt->vctxt.warning = xmlParserValidityWarning;
4855: reader->errorFunc = NULL;
4856: reader->sErrorFunc = NULL;
4857: reader->errorFuncArg = NULL;
4858: #ifdef LIBXML_SCHEMAS_ENABLED
4859: if (reader->rngValidCtxt) {
4860: xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
4861: reader);
4862: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
4863: reader);
4864: }
4865: if (reader->xsdValidCtxt) {
4866: xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
4867: reader);
4868: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
4869: reader);
4870: }
4871: #endif
4872: }
4873: }
4874:
4875: /**
4876: * xmlTextReaderIsValid:
4877: * @reader: the xmlTextReaderPtr used
4878: *
4879: * Retrieve the validity status from the parser context
4880: *
4881: * Returns the flag value 1 if valid, 0 if no, and -1 in case of error
4882: */
4883: int
4884: xmlTextReaderIsValid(xmlTextReaderPtr reader)
4885: {
4886: if (reader == NULL)
4887: return (-1);
4888: #ifdef LIBXML_SCHEMAS_ENABLED
4889: if (reader->validate == XML_TEXTREADER_VALIDATE_RNG)
4890: return (reader->rngValidErrors == 0);
4891: if (reader->validate == XML_TEXTREADER_VALIDATE_XSD)
4892: return (reader->xsdValidErrors == 0);
4893: #endif
4894: if ((reader->ctxt != NULL) && (reader->ctxt->validate == 1))
4895: return (reader->ctxt->valid);
4896: return (0);
4897: }
4898:
4899: /**
4900: * xmlTextReaderGetErrorHandler:
4901: * @reader: the xmlTextReaderPtr used
4902: * @f: the callback function or NULL is no callback has been registered
4903: * @arg: a user argument
4904: *
4905: * Retrieve the error callback function and user argument.
4906: */
4907: void
4908: xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
4909: xmlTextReaderErrorFunc * f, void **arg)
4910: {
4911: if (f != NULL)
4912: *f = reader->errorFunc;
4913: if (arg != NULL)
4914: *arg = reader->errorFuncArg;
4915: }
4916: /************************************************************************
4917: * *
4918: * New set (2.6.0) of simpler and more flexible APIs *
4919: * *
4920: ************************************************************************/
4921:
4922: /**
4923: * xmlTextReaderSetup:
4924: * @reader: an XML reader
4925: * @input: xmlParserInputBufferPtr used to feed the reader, will
4926: * be destroyed with it.
4927: * @URL: the base URL to use for the document
4928: * @encoding: the document encoding, or NULL
4929: * @options: a combination of xmlParserOption
4930: *
4931: * Setup an XML reader with new options
4932: *
4933: * Returns 0 in case of success and -1 in case of error.
4934: */
4935: int
4936: xmlTextReaderSetup(xmlTextReaderPtr reader,
4937: xmlParserInputBufferPtr input, const char *URL,
4938: const char *encoding, int options)
4939: {
4940: if (reader == NULL) {
4941: if (input != NULL)
4942: xmlFreeParserInputBuffer(input);
4943: return (-1);
4944: }
4945:
4946: /*
4947: * we force the generation of compact text nodes on the reader
4948: * since usr applications should never modify the tree
4949: */
4950: options |= XML_PARSE_COMPACT;
4951:
4952: reader->doc = NULL;
4953: reader->entNr = 0;
4954: reader->parserFlags = options;
4955: reader->validate = XML_TEXTREADER_NOT_VALIDATE;
4956: if ((input != NULL) && (reader->input != NULL) &&
4957: (reader->allocs & XML_TEXTREADER_INPUT)) {
4958: xmlFreeParserInputBuffer(reader->input);
4959: reader->input = NULL;
4960: reader->allocs -= XML_TEXTREADER_INPUT;
4961: }
4962: if (input != NULL) {
4963: reader->input = input;
4964: reader->allocs |= XML_TEXTREADER_INPUT;
4965: }
4966: if (reader->buffer == NULL)
4967: reader->buffer = xmlBufferCreateSize(100);
4968: if (reader->buffer == NULL) {
4969: xmlGenericError(xmlGenericErrorContext,
4970: "xmlTextReaderSetup : malloc failed\n");
4971: return (-1);
4972: }
4973: if (reader->sax == NULL)
4974: reader->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
4975: if (reader->sax == NULL) {
4976: xmlGenericError(xmlGenericErrorContext,
4977: "xmlTextReaderSetup : malloc failed\n");
4978: return (-1);
4979: }
4980: xmlSAXVersion(reader->sax, 2);
4981: reader->startElement = reader->sax->startElement;
4982: reader->sax->startElement = xmlTextReaderStartElement;
4983: reader->endElement = reader->sax->endElement;
4984: reader->sax->endElement = xmlTextReaderEndElement;
4985: #ifdef LIBXML_SAX1_ENABLED
4986: if (reader->sax->initialized == XML_SAX2_MAGIC) {
4987: #endif /* LIBXML_SAX1_ENABLED */
4988: reader->startElementNs = reader->sax->startElementNs;
4989: reader->sax->startElementNs = xmlTextReaderStartElementNs;
4990: reader->endElementNs = reader->sax->endElementNs;
4991: reader->sax->endElementNs = xmlTextReaderEndElementNs;
4992: #ifdef LIBXML_SAX1_ENABLED
4993: } else {
4994: reader->startElementNs = NULL;
4995: reader->endElementNs = NULL;
4996: }
4997: #endif /* LIBXML_SAX1_ENABLED */
4998: reader->characters = reader->sax->characters;
4999: reader->sax->characters = xmlTextReaderCharacters;
5000: reader->sax->ignorableWhitespace = xmlTextReaderCharacters;
5001: reader->cdataBlock = reader->sax->cdataBlock;
5002: reader->sax->cdataBlock = xmlTextReaderCDataBlock;
5003:
5004: reader->mode = XML_TEXTREADER_MODE_INITIAL;
5005: reader->node = NULL;
5006: reader->curnode = NULL;
5007: if (input != NULL) {
5008: if (reader->input->buffer->use < 4) {
5009: xmlParserInputBufferRead(input, 4);
5010: }
5011: if (reader->ctxt == NULL) {
5012: if (reader->input->buffer->use >= 4) {
5013: reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL,
5014: (const char *) reader->input->buffer->content, 4, URL);
5015: reader->base = 0;
5016: reader->cur = 4;
5017: } else {
5018: reader->ctxt =
5019: xmlCreatePushParserCtxt(reader->sax, NULL, NULL, 0, URL);
5020: reader->base = 0;
5021: reader->cur = 0;
5022: }
5023: } else {
5024: xmlParserInputPtr inputStream;
5025: xmlParserInputBufferPtr buf;
5026: xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
5027:
5028: xmlCtxtReset(reader->ctxt);
5029: buf = xmlAllocParserInputBuffer(enc);
5030: if (buf == NULL) return(-1);
5031: inputStream = xmlNewInputStream(reader->ctxt);
5032: if (inputStream == NULL) {
5033: xmlFreeParserInputBuffer(buf);
5034: return(-1);
5035: }
5036:
5037: if (URL == NULL)
5038: inputStream->filename = NULL;
5039: else
5040: inputStream->filename = (char *)
5041: xmlCanonicPath((const xmlChar *) URL);
5042: inputStream->buf = buf;
5043: inputStream->base = inputStream->buf->buffer->content;
5044: inputStream->cur = inputStream->buf->buffer->content;
5045: inputStream->end =
5046: &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
5047:
5048: inputPush(reader->ctxt, inputStream);
5049: reader->cur = 0;
5050: }
5051: if (reader->ctxt == NULL) {
5052: xmlGenericError(xmlGenericErrorContext,
5053: "xmlTextReaderSetup : malloc failed\n");
5054: return (-1);
5055: }
5056: }
5057: if (reader->dict != NULL) {
5058: if (reader->ctxt->dict != NULL) {
5059: if (reader->dict != reader->ctxt->dict) {
5060: xmlDictFree(reader->dict);
5061: reader->dict = reader->ctxt->dict;
5062: }
5063: } else {
5064: reader->ctxt->dict = reader->dict;
5065: }
5066: } else {
5067: if (reader->ctxt->dict == NULL)
5068: reader->ctxt->dict = xmlDictCreate();
5069: reader->dict = reader->ctxt->dict;
5070: }
5071: reader->ctxt->_private = reader;
5072: reader->ctxt->linenumbers = 1;
5073: reader->ctxt->dictNames = 1;
5074: /*
5075: * use the parser dictionnary to allocate all elements and attributes names
5076: */
5077: reader->ctxt->docdict = 1;
5078: reader->ctxt->parseMode = XML_PARSE_READER;
5079:
5080: #ifdef LIBXML_XINCLUDE_ENABLED
5081: if (reader->xincctxt != NULL) {
5082: xmlXIncludeFreeContext(reader->xincctxt);
5083: reader->xincctxt = NULL;
5084: }
5085: if (options & XML_PARSE_XINCLUDE) {
5086: reader->xinclude = 1;
5087: reader->xinclude_name = xmlDictLookup(reader->dict, XINCLUDE_NODE, -1);
5088: options -= XML_PARSE_XINCLUDE;
5089: } else
5090: reader->xinclude = 0;
5091: reader->in_xinclude = 0;
5092: #endif
5093: #ifdef LIBXML_PATTERN_ENABLED
5094: if (reader->patternTab == NULL) {
5095: reader->patternNr = 0;
5096: reader->patternMax = 0;
5097: }
5098: while (reader->patternNr > 0) {
5099: reader->patternNr--;
5100: if (reader->patternTab[reader->patternNr] != NULL) {
5101: xmlFreePattern(reader->patternTab[reader->patternNr]);
5102: reader->patternTab[reader->patternNr] = NULL;
5103: }
5104: }
5105: #endif
5106:
5107: if (options & XML_PARSE_DTDVALID)
5108: reader->validate = XML_TEXTREADER_VALIDATE_DTD;
5109:
5110: xmlCtxtUseOptions(reader->ctxt, options);
5111: if (encoding != NULL) {
5112: xmlCharEncodingHandlerPtr hdlr;
5113:
5114: hdlr = xmlFindCharEncodingHandler(encoding);
5115: if (hdlr != NULL)
5116: xmlSwitchToEncoding(reader->ctxt, hdlr);
5117: }
5118: if ((URL != NULL) && (reader->ctxt->input != NULL) &&
5119: (reader->ctxt->input->filename == NULL))
5120: reader->ctxt->input->filename = (char *)
5121: xmlStrdup((const xmlChar *) URL);
5122:
5123: reader->doc = NULL;
5124:
5125: return (0);
5126: }
5127:
5128: /**
5129: * xmlTextReaderByteConsumed:
5130: * @reader: an XML reader
5131: *
5132: * This function provides the current index of the parser used
5133: * by the reader, relative to the start of the current entity.
5134: * This function actually just wraps a call to xmlBytesConsumed()
5135: * for the parser context associated with the reader.
5136: * See xmlBytesConsumed() for more information.
5137: *
5138: * Returns the index in bytes from the beginning of the entity or -1
5139: * in case the index could not be computed.
5140: */
5141: long
5142: xmlTextReaderByteConsumed(xmlTextReaderPtr reader) {
5143: if ((reader == NULL) || (reader->ctxt == NULL))
5144: return(-1);
5145: return(xmlByteConsumed(reader->ctxt));
5146: }
5147:
5148:
5149: /**
5150: * xmlReaderWalker:
5151: * @doc: a preparsed document
5152: *
5153: * Create an xmltextReader for a preparsed document.
5154: *
5155: * Returns the new reader or NULL in case of error.
5156: */
5157: xmlTextReaderPtr
5158: xmlReaderWalker(xmlDocPtr doc)
5159: {
5160: xmlTextReaderPtr ret;
5161:
5162: if (doc == NULL)
5163: return(NULL);
5164:
5165: ret = xmlMalloc(sizeof(xmlTextReader));
5166: if (ret == NULL) {
5167: xmlGenericError(xmlGenericErrorContext,
5168: "xmlNewTextReader : malloc failed\n");
5169: return(NULL);
5170: }
5171: memset(ret, 0, sizeof(xmlTextReader));
5172: ret->entNr = 0;
5173: ret->input = NULL;
5174: ret->mode = XML_TEXTREADER_MODE_INITIAL;
5175: ret->node = NULL;
5176: ret->curnode = NULL;
5177: ret->base = 0;
5178: ret->cur = 0;
5179: ret->allocs = XML_TEXTREADER_CTXT;
5180: ret->doc = doc;
5181: ret->state = XML_TEXTREADER_START;
5182: ret->dict = xmlDictCreate();
5183: return(ret);
5184: }
5185:
5186: /**
5187: * xmlReaderForDoc:
5188: * @cur: a pointer to a zero terminated string
5189: * @URL: the base URL to use for the document
5190: * @encoding: the document encoding, or NULL
5191: * @options: a combination of xmlParserOption
5192: *
5193: * Create an xmltextReader for an XML in-memory document.
5194: * The parsing flags @options are a combination of xmlParserOption.
5195: *
5196: * Returns the new reader or NULL in case of error.
5197: */
5198: xmlTextReaderPtr
5199: xmlReaderForDoc(const xmlChar * cur, const char *URL, const char *encoding,
5200: int options)
5201: {
5202: int len;
5203:
5204: if (cur == NULL)
5205: return (NULL);
5206: len = xmlStrlen(cur);
5207:
5208: return (xmlReaderForMemory
5209: ((const char *) cur, len, URL, encoding, options));
5210: }
5211:
5212: /**
5213: * xmlReaderForFile:
5214: * @filename: a file or URL
5215: * @encoding: the document encoding, or NULL
5216: * @options: a combination of xmlParserOption
5217: *
5218: * parse an XML file from the filesystem or the network.
5219: * The parsing flags @options are a combination of xmlParserOption.
5220: *
5221: * Returns the new reader or NULL in case of error.
5222: */
5223: xmlTextReaderPtr
5224: xmlReaderForFile(const char *filename, const char *encoding, int options)
5225: {
5226: xmlTextReaderPtr reader;
5227:
5228: reader = xmlNewTextReaderFilename(filename);
5229: if (reader == NULL)
5230: return (NULL);
5231: xmlTextReaderSetup(reader, NULL, NULL, encoding, options);
5232: return (reader);
5233: }
5234:
5235: /**
5236: * xmlReaderForMemory:
5237: * @buffer: a pointer to a char array
5238: * @size: the size of the array
5239: * @URL: the base URL to use for the document
5240: * @encoding: the document encoding, or NULL
5241: * @options: a combination of xmlParserOption
5242: *
5243: * Create an xmltextReader for an XML in-memory document.
5244: * The parsing flags @options are a combination of xmlParserOption.
5245: *
5246: * Returns the new reader or NULL in case of error.
5247: */
5248: xmlTextReaderPtr
5249: xmlReaderForMemory(const char *buffer, int size, const char *URL,
5250: const char *encoding, int options)
5251: {
5252: xmlTextReaderPtr reader;
5253: xmlParserInputBufferPtr buf;
5254:
5255: buf = xmlParserInputBufferCreateStatic(buffer, size,
5256: XML_CHAR_ENCODING_NONE);
5257: if (buf == NULL) {
5258: return (NULL);
5259: }
5260: reader = xmlNewTextReader(buf, URL);
5261: if (reader == NULL) {
5262: xmlFreeParserInputBuffer(buf);
5263: return (NULL);
5264: }
5265: reader->allocs |= XML_TEXTREADER_INPUT;
5266: xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5267: return (reader);
5268: }
5269:
5270: /**
5271: * xmlReaderForFd:
5272: * @fd: an open file descriptor
5273: * @URL: the base URL to use for the document
5274: * @encoding: the document encoding, or NULL
5275: * @options: a combination of xmlParserOption
5276: *
5277: * Create an xmltextReader for an XML from a file descriptor.
5278: * The parsing flags @options are a combination of xmlParserOption.
5279: * NOTE that the file descriptor will not be closed when the
5280: * reader is closed or reset.
5281: *
5282: * Returns the new reader or NULL in case of error.
5283: */
5284: xmlTextReaderPtr
5285: xmlReaderForFd(int fd, const char *URL, const char *encoding, int options)
5286: {
5287: xmlTextReaderPtr reader;
5288: xmlParserInputBufferPtr input;
5289:
5290: if (fd < 0)
5291: return (NULL);
5292:
5293: input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
5294: if (input == NULL)
5295: return (NULL);
5296: input->closecallback = NULL;
5297: reader = xmlNewTextReader(input, URL);
5298: if (reader == NULL) {
5299: xmlFreeParserInputBuffer(input);
5300: return (NULL);
5301: }
5302: reader->allocs |= XML_TEXTREADER_INPUT;
5303: xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5304: return (reader);
5305: }
5306:
5307: /**
5308: * xmlReaderForIO:
5309: * @ioread: an I/O read function
5310: * @ioclose: an I/O close function
5311: * @ioctx: an I/O handler
5312: * @URL: the base URL to use for the document
5313: * @encoding: the document encoding, or NULL
5314: * @options: a combination of xmlParserOption
5315: *
5316: * Create an xmltextReader for an XML document from I/O functions and source.
5317: * The parsing flags @options are a combination of xmlParserOption.
5318: *
5319: * Returns the new reader or NULL in case of error.
5320: */
5321: xmlTextReaderPtr
5322: xmlReaderForIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
5323: void *ioctx, const char *URL, const char *encoding,
5324: int options)
5325: {
5326: xmlTextReaderPtr reader;
5327: xmlParserInputBufferPtr input;
5328:
5329: if (ioread == NULL)
5330: return (NULL);
5331:
5332: input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
5333: XML_CHAR_ENCODING_NONE);
5334: if (input == NULL)
5335: return (NULL);
5336: reader = xmlNewTextReader(input, URL);
5337: if (reader == NULL) {
5338: xmlFreeParserInputBuffer(input);
5339: return (NULL);
5340: }
5341: reader->allocs |= XML_TEXTREADER_INPUT;
5342: xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5343: return (reader);
5344: }
5345:
5346: /**
5347: * xmlReaderNewWalker:
5348: * @reader: an XML reader
5349: * @doc: a preparsed document
5350: *
5351: * Setup an xmltextReader to parse a preparsed XML document.
5352: * This reuses the existing @reader xmlTextReader.
5353: *
5354: * Returns 0 in case of success and -1 in case of error
5355: */
5356: int
5357: xmlReaderNewWalker(xmlTextReaderPtr reader, xmlDocPtr doc)
5358: {
5359: if (doc == NULL)
5360: return (-1);
5361: if (reader == NULL)
5362: return (-1);
5363:
5364: if (reader->input != NULL) {
5365: xmlFreeParserInputBuffer(reader->input);
5366: }
5367: if (reader->ctxt != NULL) {
5368: xmlCtxtReset(reader->ctxt);
5369: }
5370:
5371: reader->entNr = 0;
5372: reader->input = NULL;
5373: reader->mode = XML_TEXTREADER_MODE_INITIAL;
5374: reader->node = NULL;
5375: reader->curnode = NULL;
5376: reader->base = 0;
5377: reader->cur = 0;
5378: reader->allocs = XML_TEXTREADER_CTXT;
5379: reader->doc = doc;
5380: reader->state = XML_TEXTREADER_START;
5381: if (reader->dict == NULL) {
5382: if ((reader->ctxt != NULL) && (reader->ctxt->dict != NULL))
5383: reader->dict = reader->ctxt->dict;
5384: else
5385: reader->dict = xmlDictCreate();
5386: }
5387: return(0);
5388: }
5389:
5390: /**
5391: * xmlReaderNewDoc:
5392: * @reader: an XML reader
5393: * @cur: a pointer to a zero terminated string
5394: * @URL: the base URL to use for the document
5395: * @encoding: the document encoding, or NULL
5396: * @options: a combination of xmlParserOption
5397: *
5398: * Setup an xmltextReader to parse an XML in-memory document.
5399: * The parsing flags @options are a combination of xmlParserOption.
5400: * This reuses the existing @reader xmlTextReader.
5401: *
5402: * Returns 0 in case of success and -1 in case of error
5403: */
5404: int
5405: xmlReaderNewDoc(xmlTextReaderPtr reader, const xmlChar * cur,
5406: const char *URL, const char *encoding, int options)
5407: {
5408:
5409: int len;
5410:
5411: if (cur == NULL)
5412: return (-1);
5413: if (reader == NULL)
5414: return (-1);
5415:
5416: len = xmlStrlen(cur);
5417: return (xmlReaderNewMemory(reader, (const char *)cur, len,
5418: URL, encoding, options));
5419: }
5420:
5421: /**
5422: * xmlReaderNewFile:
5423: * @reader: an XML reader
5424: * @filename: a file or URL
5425: * @encoding: the document encoding, or NULL
5426: * @options: a combination of xmlParserOption
5427: *
5428: * parse an XML file from the filesystem or the network.
5429: * The parsing flags @options are a combination of xmlParserOption.
5430: * This reuses the existing @reader xmlTextReader.
5431: *
5432: * Returns 0 in case of success and -1 in case of error
5433: */
5434: int
5435: xmlReaderNewFile(xmlTextReaderPtr reader, const char *filename,
5436: const char *encoding, int options)
5437: {
5438: xmlParserInputBufferPtr input;
5439:
5440: if (filename == NULL)
5441: return (-1);
5442: if (reader == NULL)
5443: return (-1);
5444:
5445: input =
5446: xmlParserInputBufferCreateFilename(filename,
5447: XML_CHAR_ENCODING_NONE);
5448: if (input == NULL)
5449: return (-1);
5450: return (xmlTextReaderSetup(reader, input, filename, encoding, options));
5451: }
5452:
5453: /**
5454: * xmlReaderNewMemory:
5455: * @reader: an XML reader
5456: * @buffer: a pointer to a char array
5457: * @size: the size of the array
5458: * @URL: the base URL to use for the document
5459: * @encoding: the document encoding, or NULL
5460: * @options: a combination of xmlParserOption
5461: *
5462: * Setup an xmltextReader to parse an XML in-memory document.
5463: * The parsing flags @options are a combination of xmlParserOption.
5464: * This reuses the existing @reader xmlTextReader.
5465: *
5466: * Returns 0 in case of success and -1 in case of error
5467: */
5468: int
5469: xmlReaderNewMemory(xmlTextReaderPtr reader, const char *buffer, int size,
5470: const char *URL, const char *encoding, int options)
5471: {
5472: xmlParserInputBufferPtr input;
5473:
5474: if (reader == NULL)
5475: return (-1);
5476: if (buffer == NULL)
5477: return (-1);
5478:
5479: input = xmlParserInputBufferCreateStatic(buffer, size,
5480: XML_CHAR_ENCODING_NONE);
5481: if (input == NULL) {
5482: return (-1);
5483: }
5484: return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5485: }
5486:
5487: /**
5488: * xmlReaderNewFd:
5489: * @reader: an XML reader
5490: * @fd: an open file descriptor
5491: * @URL: the base URL to use for the document
5492: * @encoding: the document encoding, or NULL
5493: * @options: a combination of xmlParserOption
5494: *
5495: * Setup an xmltextReader to parse an XML from a file descriptor.
5496: * NOTE that the file descriptor will not be closed when the
5497: * reader is closed or reset.
5498: * The parsing flags @options are a combination of xmlParserOption.
5499: * This reuses the existing @reader xmlTextReader.
5500: *
5501: * Returns 0 in case of success and -1 in case of error
5502: */
5503: int
5504: xmlReaderNewFd(xmlTextReaderPtr reader, int fd,
5505: const char *URL, const char *encoding, int options)
5506: {
5507: xmlParserInputBufferPtr input;
5508:
5509: if (fd < 0)
5510: return (-1);
5511: if (reader == NULL)
5512: return (-1);
5513:
5514: input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
5515: if (input == NULL)
5516: return (-1);
5517: input->closecallback = NULL;
5518: return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5519: }
5520:
5521: /**
5522: * xmlReaderNewIO:
5523: * @reader: an XML reader
5524: * @ioread: an I/O read function
5525: * @ioclose: an I/O close function
5526: * @ioctx: an I/O handler
5527: * @URL: the base URL to use for the document
5528: * @encoding: the document encoding, or NULL
5529: * @options: a combination of xmlParserOption
5530: *
5531: * Setup an xmltextReader to parse an XML document from I/O functions
5532: * and source.
5533: * The parsing flags @options are a combination of xmlParserOption.
5534: * This reuses the existing @reader xmlTextReader.
5535: *
5536: * Returns 0 in case of success and -1 in case of error
5537: */
5538: int
5539: xmlReaderNewIO(xmlTextReaderPtr reader, xmlInputReadCallback ioread,
5540: xmlInputCloseCallback ioclose, void *ioctx,
5541: const char *URL, const char *encoding, int options)
5542: {
5543: xmlParserInputBufferPtr input;
5544:
5545: if (ioread == NULL)
5546: return (-1);
5547: if (reader == NULL)
5548: return (-1);
5549:
5550: input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
5551: XML_CHAR_ENCODING_NONE);
5552: if (input == NULL)
5553: return (-1);
5554: return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5555: }
5556: /************************************************************************
5557: * *
5558: * Utilities *
5559: * *
5560: ************************************************************************/
5561: #ifdef NOT_USED_YET
5562:
5563: /**
5564: * xmlBase64Decode:
5565: * @in: the input buffer
5566: * @inlen: the size of the input (in), the size read from it (out)
5567: * @to: the output buffer
5568: * @tolen: the size of the output (in), the size written to (out)
5569: *
5570: * Base64 decoder, reads from @in and save in @to
5571: * TODO: tell jody when this is actually exported
5572: *
5573: * Returns 0 if all the input was consumer, 1 if the Base64 end was reached,
5574: * 2 if there wasn't enough space on the output or -1 in case of error.
5575: */
5576: static int
5577: xmlBase64Decode(const unsigned char *in, unsigned long *inlen,
5578: unsigned char *to, unsigned long *tolen)
5579: {
5580: unsigned long incur; /* current index in in[] */
5581:
5582: unsigned long inblk; /* last block index in in[] */
5583:
5584: unsigned long outcur; /* current index in out[] */
5585:
5586: unsigned long inmax; /* size of in[] */
5587:
5588: unsigned long outmax; /* size of out[] */
5589:
5590: unsigned char cur; /* the current value read from in[] */
5591:
5592: unsigned char intmp[4], outtmp[4]; /* temporary buffers for the convert */
5593:
5594: int nbintmp; /* number of byte in intmp[] */
5595:
5596: int is_ignore; /* cur should be ignored */
5597:
5598: int is_end = 0; /* the end of the base64 was found */
5599:
5600: int retval = 1;
5601:
5602: int i;
5603:
5604: if ((in == NULL) || (inlen == NULL) || (to == NULL) || (tolen == NULL))
5605: return (-1);
5606:
5607: incur = 0;
5608: inblk = 0;
5609: outcur = 0;
5610: inmax = *inlen;
5611: outmax = *tolen;
5612: nbintmp = 0;
5613:
5614: while (1) {
5615: if (incur >= inmax)
5616: break;
5617: cur = in[incur++];
5618: is_ignore = 0;
5619: if ((cur >= 'A') && (cur <= 'Z'))
5620: cur = cur - 'A';
5621: else if ((cur >= 'a') && (cur <= 'z'))
5622: cur = cur - 'a' + 26;
5623: else if ((cur >= '0') && (cur <= '9'))
5624: cur = cur - '0' + 52;
5625: else if (cur == '+')
5626: cur = 62;
5627: else if (cur == '/')
5628: cur = 63;
5629: else if (cur == '.')
5630: cur = 0;
5631: else if (cur == '=') /*no op , end of the base64 stream */
5632: is_end = 1;
5633: else {
5634: is_ignore = 1;
5635: if (nbintmp == 0)
5636: inblk = incur;
5637: }
5638:
5639: if (!is_ignore) {
5640: int nbouttmp = 3;
5641:
5642: int is_break = 0;
5643:
5644: if (is_end) {
5645: if (nbintmp == 0)
5646: break;
5647: if ((nbintmp == 1) || (nbintmp == 2))
5648: nbouttmp = 1;
5649: else
5650: nbouttmp = 2;
5651: nbintmp = 3;
5652: is_break = 1;
5653: }
5654: intmp[nbintmp++] = cur;
5655: /*
5656: * if intmp is full, push the 4byte sequence as a 3 byte
5657: * sequence out
5658: */
5659: if (nbintmp == 4) {
5660: nbintmp = 0;
5661: outtmp[0] = (intmp[0] << 2) | ((intmp[1] & 0x30) >> 4);
5662: outtmp[1] =
5663: ((intmp[1] & 0x0F) << 4) | ((intmp[2] & 0x3C) >> 2);
5664: outtmp[2] = ((intmp[2] & 0x03) << 6) | (intmp[3] & 0x3F);
5665: if (outcur + 3 >= outmax) {
5666: retval = 2;
5667: break;
5668: }
5669:
5670: for (i = 0; i < nbouttmp; i++)
5671: to[outcur++] = outtmp[i];
5672: inblk = incur;
5673: }
5674:
5675: if (is_break) {
5676: retval = 0;
5677: break;
5678: }
5679: }
5680: }
5681:
5682: *tolen = outcur;
5683: *inlen = inblk;
5684: return (retval);
5685: }
5686:
5687: /*
5688: * Test routine for the xmlBase64Decode function
5689: */
5690: #if 0
5691: int
5692: main(int argc, char **argv)
5693: {
5694: char *input = " VW4 gcGV0 \n aXQgdGVzdCAuCg== ";
5695:
5696: char output[100];
5697:
5698: char output2[100];
5699:
5700: char output3[100];
5701:
5702: unsigned long inlen = strlen(input);
5703:
5704: unsigned long outlen = 100;
5705:
5706: int ret;
5707:
5708: unsigned long cons, tmp, tmp2, prod;
5709:
5710: /*
5711: * Direct
5712: */
5713: ret = xmlBase64Decode(input, &inlen, output, &outlen);
5714:
5715: output[outlen] = 0;
5716: printf("ret: %d, inlen: %ld , outlen: %ld, output: '%s'\n", ret, inlen,
5717: outlen, output)indent: Standard input:179: Error:Unmatched #endif
5718: ;
5719:
5720: /*
5721: * output chunking
5722: */
5723: cons = 0;
5724: prod = 0;
5725: while (cons < inlen) {
5726: tmp = 5;
5727: tmp2 = inlen - cons;
5728:
5729: printf("%ld %ld\n", cons, prod);
5730: ret = xmlBase64Decode(&input[cons], &tmp2, &output2[prod], &tmp);
5731: cons += tmp2;
5732: prod += tmp;
5733: printf("%ld %ld\n", cons, prod);
5734: }
5735: output2[outlen] = 0;
5736: printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons,
5737: prod, output2);
5738:
5739: /*
5740: * input chunking
5741: */
5742: cons = 0;
5743: prod = 0;
5744: while (cons < inlen) {
5745: tmp = 100 - prod;
5746: tmp2 = inlen - cons;
5747: if (tmp2 > 5)
5748: tmp2 = 5;
5749:
5750: printf("%ld %ld\n", cons, prod);
5751: ret = xmlBase64Decode(&input[cons], &tmp2, &output3[prod], &tmp);
5752: cons += tmp2;
5753: prod += tmp;
5754: printf("%ld %ld\n", cons, prod);
5755: }
5756: output3[outlen] = 0;
5757: printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons,
5758: prod, output3);
5759: return (0);
5760:
5761: }
5762: #endif
5763: #endif /* NOT_USED_YET */
5764: #define bottom_xmlreader
5765: #include "elfgcchack.h"
5766: #endif /* LIBXML_READER_ENABLED */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmlreader.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2