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