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