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