Commit | Line | Data |
---|---|---|
d44e3c4f | 1 | /****************************************************************************** |
2 | * Copyright (c) 2000-2016 Ericsson Telecom AB | |
3 | * All rights reserved. This program and the accompanying materials | |
4 | * are made available under the terms of the Eclipse Public License v1.0 | |
5 | * which accompanies this distribution, and is available at | |
6 | * http://www.eclipse.org/legal/epl-v10.html | |
7 | * | |
8 | * Contributors: | |
9 | * Balasko, Jeno | |
10 | * Raduly, Csaba | |
11 | * | |
12 | ******************************************************************************/ | |
970ed795 EL |
13 | /* |
14 | * XmlReader.cc | |
15 | * | |
16 | * Created on: 19-Nov-2008 | |
17 | * Author: ecsardu | |
18 | */ | |
19 | ||
20 | #include <libxml/xmlreader.h> | |
21 | #include "XmlReader.hh" | |
22 | #include "static_check.h" | |
23 | ||
24 | #include "Encdec.hh" | |
25 | ||
26 | XmlReaderWrap::XmlReaderWrap(TTCN_Buffer& buf) | |
27 | : my_reader(0) | |
28 | { | |
29 | // compile-time safety checks | |
30 | ENSURE_EQUAL( XML_PARSER_SEVERITY_VALIDITY_WARNING, \ | |
31 | xmlreader_lite::XML_PARSER_SEVERITY_VALIDITY_WARNING); | |
32 | ENSURE_EQUAL( XML_PARSER_SEVERITY_VALIDITY_ERROR , \ | |
33 | xmlreader_lite::XML_PARSER_SEVERITY_VALIDITY_ERROR); | |
34 | ENSURE_EQUAL( XML_PARSER_SEVERITY_WARNING, \ | |
35 | xmlreader_lite::XML_PARSER_SEVERITY_WARNING); | |
36 | ENSURE_EQUAL( XML_PARSER_SEVERITY_ERROR , \ | |
37 | xmlreader_lite::XML_PARSER_SEVERITY_ERROR); | |
38 | ||
39 | ENSURE_EQUAL( XML_READER_TYPE_NONE, \ | |
40 | xmlreader_lite::XML_READER_TYPE_NONE); | |
41 | ENSURE_EQUAL( XML_READER_TYPE_ELEMENT, \ | |
42 | xmlreader_lite::XML_READER_TYPE_ELEMENT); | |
43 | ENSURE_EQUAL( XML_READER_TYPE_ATTRIBUTE, \ | |
44 | xmlreader_lite::XML_READER_TYPE_ATTRIBUTE); | |
45 | ENSURE_EQUAL( XML_READER_TYPE_TEXT, \ | |
46 | xmlreader_lite::XML_READER_TYPE_TEXT); | |
47 | ENSURE_EQUAL( XML_READER_TYPE_CDATA, \ | |
48 | xmlreader_lite::XML_READER_TYPE_CDATA); | |
49 | ENSURE_EQUAL( XML_READER_TYPE_ENTITY_REFERENCE, \ | |
50 | xmlreader_lite::XML_READER_TYPE_ENTITY_REFERENCE); | |
51 | ENSURE_EQUAL( XML_READER_TYPE_ENTITY, \ | |
52 | xmlreader_lite::XML_READER_TYPE_ENTITY); | |
53 | ENSURE_EQUAL( XML_READER_TYPE_PROCESSING_INSTRUCTION, \ | |
54 | xmlreader_lite::XML_READER_TYPE_PROCESSING_INSTRUCTION); | |
55 | ENSURE_EQUAL( XML_READER_TYPE_COMMENT, \ | |
56 | xmlreader_lite::XML_READER_TYPE_COMMENT); | |
57 | ENSURE_EQUAL( XML_READER_TYPE_DOCUMENT, \ | |
58 | xmlreader_lite::XML_READER_TYPE_DOCUMENT); | |
59 | ENSURE_EQUAL( XML_READER_TYPE_DOCUMENT_TYPE, \ | |
60 | xmlreader_lite::XML_READER_TYPE_DOCUMENT_TYPE); | |
61 | ENSURE_EQUAL( XML_READER_TYPE_DOCUMENT_FRAGMENT, \ | |
62 | xmlreader_lite::XML_READER_TYPE_DOCUMENT_FRAGMENT); | |
63 | ENSURE_EQUAL( XML_READER_TYPE_NOTATION, \ | |
64 | xmlreader_lite::XML_READER_TYPE_NOTATION); | |
65 | ENSURE_EQUAL( XML_READER_TYPE_WHITESPACE, \ | |
66 | xmlreader_lite::XML_READER_TYPE_WHITESPACE); | |
67 | ENSURE_EQUAL( XML_READER_TYPE_SIGNIFICANT_WHITESPACE, \ | |
68 | xmlreader_lite::XML_READER_TYPE_SIGNIFICANT_WHITESPACE); | |
69 | ENSURE_EQUAL( XML_READER_TYPE_END_ELEMENT, \ | |
70 | xmlreader_lite::XML_READER_TYPE_END_ELEMENT); | |
71 | ENSURE_EQUAL( XML_READER_TYPE_END_ENTITY, \ | |
72 | xmlreader_lite::XML_READER_TYPE_END_ENTITY); | |
73 | ENSURE_EQUAL( XML_READER_TYPE_XML_DECLARATION, \ | |
74 | xmlreader_lite::XML_READER_TYPE_XML_DECLARATION); | |
75 | ||
76 | LIBXML_TEST_VERSION; | |
77 | const char * encoding = 0; | |
78 | if (0 == buf.get_len()) { | |
79 | TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_INCOMPL_MSG, | |
80 | "Cannot decode empty XML"); | |
81 | } | |
82 | else { | |
83 | my_reader = xmlReaderForMemory((const char*)buf.get_data(), buf.get_len(), | |
84 | "uri:geller", encoding, 0); | |
85 | if (0 == my_reader) { | |
86 | TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_INVAL_MSG, | |
87 | "Failed to create XML reader"); // no further information available | |
88 | } | |
89 | else xmlTextReaderSetErrorHandler(my_reader, errorhandler, this); | |
90 | } | |
91 | } | |
92 | ||
93 | void | |
94 | XmlReaderWrap::errorhandler(void * arg, const char * msg, | |
95 | xmlParserSeverities severity, xmlTextReaderLocatorPtr locator) | |
96 | { | |
97 | //XmlReaderWrap *self = (XmlReaderWrap*)arg; | |
98 | (void)arg; | |
99 | (void)severity; | |
100 | TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_UNDEF, // TODO create a new ET_ | |
101 | "XML error: %s at line %d", msg, xmlTextReaderLocatorLineNumber(locator)); | |
102 | } | |
103 | ||
104 | XmlReaderWrap::~XmlReaderWrap() | |
105 | { | |
106 | xmlFreeTextReader(my_reader); | |
107 | my_reader = 0; | |
108 | } | |
109 | ||
110 | ||
111 | #undef Read | |
112 | int XmlReaderWrap::Read() | |
113 | { | |
114 | return last_status = xmlTextReaderRead(my_reader); // assign and return | |
115 | } | |
116 | ||
117 | // Debug version of Read(). Both are present to support linking | |
118 | // non-debug clients to the debug library. | |
119 | int XmlReaderWrap::ReadDbg(const char *where) | |
120 | { | |
121 | #ifdef NDEBUG | |
122 | (void)where; | |
123 | #else | |
124 | static bool d = !!getenv("DEBUG_XMLREADER"); | |
125 | if(d){ | |
126 | last_status = xmlTextReaderRead(my_reader); | |
127 | if (last_status==1) { | |
128 | int type = NodeType(); | |
129 | const char * name = (const char * )Name(); | |
130 | const char * uri = (const char * )NamespaceUri(); | |
131 | int empty = IsEmptyElement(); | |
132 | char closer = type == XML_READER_TYPE_DOCUMENT_TYPE ? '[' : (empty ? '/' : ' '); | |
133 | printf("X%dX type=%2d, @%2d <%c{%s}%s%c>", | |
134 | xmlTextReaderReadState(my_reader), type, xmlTextReaderDepth(my_reader), | |
135 | ((type!=XML_READER_TYPE_END_ELEMENT) ? ' ' : '/'), | |
136 | uri ? uri : "", name, closer); | |
137 | } | |
138 | else if (last_status==0) { | |
139 | fputs("XXX eof ", stdout); | |
140 | } | |
141 | else { | |
142 | fputs("XXX error", stdout); | |
143 | } | |
144 | printf("\t%s\n", where); | |
145 | fflush(stdout); | |
146 | return last_status; | |
147 | } else | |
148 | #endif | |
149 | { | |
150 | return last_status = xmlTextReaderRead(my_reader); // assign and return | |
151 | } | |
152 | } | |
153 | ||
154 | #if 0 | |
155 | xmlChar * XmlReaderWrap::ReadInnerXml() | |
156 | { return xmlTextReaderReadInnerXml(my_reader); } | |
157 | #endif | |
158 | ||
159 | xmlChar * XmlReaderWrap::ReadOuterXml() // used by Charstring.cc | |
160 | { return xmlTextReaderReadOuterXml(my_reader); } | |
161 | ||
162 | xmlChar * XmlReaderWrap::ReadString() // used by Objid.cc | |
163 | { return xmlTextReaderReadString(my_reader); } | |
164 | ||
165 | int XmlReaderWrap::Depth() // used everywhere | |
166 | { return xmlTextReaderDepth(my_reader); } | |
167 | ||
168 | #if 0 | |
169 | int XmlReaderWrap::ReadAttributeValue() | |
170 | { return xmlTextReaderReadAttributeValue(my_reader); } | |
171 | ||
172 | int XmlReaderWrap::AttributeCount() | |
173 | { return xmlTextReaderAttributeCount(my_reader); } | |
174 | ||
175 | int XmlReaderWrap::HasAttributes() | |
176 | { return xmlTextReaderHasAttributes(my_reader); } | |
177 | ||
178 | int XmlReaderWrap::HasValue() | |
179 | { return xmlTextReaderHasValue(my_reader); } | |
180 | ||
181 | int XmlReaderWrap::IsDefault() | |
182 | { return xmlTextReaderIsDefault(my_reader); } | |
183 | #endif | |
184 | ||
185 | int XmlReaderWrap::IsEmptyElement() // used often | |
186 | { return xmlTextReaderIsEmptyElement(my_reader); } | |
187 | ||
188 | int XmlReaderWrap::NodeType() | |
189 | { return xmlTextReaderNodeType(my_reader); } | |
190 | ||
191 | #if 0 | |
192 | int XmlReaderWrap::QuoteChar() | |
193 | { return xmlTextReaderQuoteChar(my_reader); } | |
194 | ||
195 | int XmlReaderWrap::ReadState() | |
196 | { return xmlTextReaderReadState(my_reader); } | |
197 | #endif | |
198 | ||
199 | int XmlReaderWrap::IsNamespaceDecl() // used while processing attributes | |
200 | { return xmlTextReaderIsNamespaceDecl(my_reader); } | |
201 | ||
202 | #if 0 | |
203 | const xmlChar * XmlReaderWrap::BaseUri() | |
204 | { return xmlTextReaderConstBaseUri(my_reader); } | |
205 | #endif | |
206 | ||
207 | const xmlChar * XmlReaderWrap::LocalName() | |
208 | { return xmlTextReaderConstLocalName(my_reader); } | |
209 | ||
210 | const xmlChar * XmlReaderWrap::Name() | |
211 | { return xmlTextReaderConstName(my_reader); } | |
212 | ||
213 | const xmlChar * XmlReaderWrap::NamespaceUri() | |
214 | { return xmlTextReaderConstNamespaceUri(my_reader); } | |
215 | ||
216 | const xmlChar * XmlReaderWrap::Prefix() | |
217 | { return xmlTextReaderConstPrefix(my_reader); } | |
218 | ||
219 | #if 0 | |
220 | const xmlChar * XmlReaderWrap::XmlLang() | |
221 | { return xmlTextReaderConstXmlLang(my_reader); } | |
222 | #endif | |
223 | ||
224 | const xmlChar * XmlReaderWrap::Value() | |
225 | { return xmlTextReaderConstValue(my_reader); } | |
226 | ||
227 | xmlChar * XmlReaderWrap::NewValue() | |
228 | { return xmlTextReaderValue(my_reader); } | |
229 | ||
230 | xmlChar * XmlReaderWrap::LookupNamespace( const xmlChar *prefix) | |
231 | { return xmlTextReaderLookupNamespace(my_reader,prefix); } | |
232 | ||
233 | #if 0 | |
234 | int XmlReaderWrap::Close() | |
235 | { return xmlTextReaderClose(my_reader); } | |
236 | ||
237 | xmlChar * XmlReaderWrap::GetAttributeNo( int no) | |
238 | { return xmlTextReaderGetAttributeNo(my_reader,no); } | |
239 | ||
240 | xmlChar * XmlReaderWrap::GetAttribute( const xmlChar *name) | |
241 | { return xmlTextReaderGetAttribute(my_reader,name); } | |
242 | ||
243 | xmlChar * XmlReaderWrap::GetAttributeNs( const xmlChar *localName, const xmlChar *namespaceURI) | |
244 | { return xmlTextReaderGetAttributeNs(my_reader,localName,namespaceURI); } | |
245 | ||
246 | int XmlReaderWrap::MoveToAttributeNo( int no) | |
247 | { return xmlTextReaderMoveToAttributeNo(my_reader,no); } | |
248 | #endif | |
249 | ||
250 | int XmlReaderWrap::MoveToAttribute( const xmlChar *name) | |
251 | { return xmlTextReaderMoveToAttribute(my_reader,name); } | |
252 | ||
253 | //int XmlReaderWrap::MoveToAttributeNs( const xmlChar *localName, const xmlChar *namespaceURI) | |
254 | //{ return xmlTextReaderMoveToAttributeNs(my_reader,localName,namespaceURI); } | |
255 | ||
256 | #undef AdvanceAttribute | |
257 | int XmlReaderWrap::AdvanceAttribute() | |
258 | { | |
259 | int rez; | |
260 | for (rez = MoveToNextAttribute(); rez==1; rez = MoveToNextAttribute()) { | |
261 | if (!xmlTextReaderIsNamespaceDecl(my_reader)) break; | |
262 | } | |
263 | if (rez != 0) // success(1) or failure (-1) | |
264 | return rez; | |
265 | // 0 means no more attributes. Back to the element. | |
266 | rez = xmlTextReaderMoveToElement(my_reader); | |
267 | return -(rez == -1); // if -1, return -1 else return 0 | |
268 | } | |
269 | ||
270 | int XmlReaderWrap::AdvanceAttributeDbg(const char *where) | |
271 | { | |
272 | int rez; | |
273 | for (rez = MoveToNextAttributeDbg(where); rez==1; rez = MoveToNextAttributeDbg(where)) { | |
274 | if (!xmlTextReaderIsNamespaceDecl(my_reader)) break; | |
275 | } | |
276 | if (rez != 0) // success(1) or failure (-1) | |
277 | return rez; | |
278 | // 0 means no more attributes. Back to the element. | |
279 | rez = xmlTextReaderMoveToElement(my_reader); | |
280 | return -(rez == -1); // if -1, return -1 else return 0 | |
281 | } | |
282 | ||
283 | ||
284 | #undef MoveToFirstAttribute | |
285 | int XmlReaderWrap::MoveToFirstAttribute() | |
286 | { return xmlTextReaderMoveToFirstAttribute(my_reader); } | |
287 | ||
288 | int XmlReaderWrap::MoveToFirstAttributeDbg(const char *where) | |
289 | { | |
290 | int ret = xmlTextReaderMoveToFirstAttribute(my_reader); | |
291 | #ifdef NDEBUG | |
292 | (void)where; | |
293 | #else | |
294 | static bool d = !!getenv("DEBUG_XMLREADER"); | |
295 | if (d) { | |
296 | switch (ret) { | |
297 | case 1: {//OK | |
298 | const xmlChar * name = xmlTextReaderConstLocalName(my_reader); | |
299 | const xmlChar * val = xmlTextReaderConstValue(my_reader); | |
300 | printf("#%dX %s='%s'", xmlTextReaderReadState(my_reader), name, val); | |
301 | break;} | |
302 | case 0: {// not found | |
303 | const xmlChar * name = xmlTextReaderConstLocalName(my_reader); | |
304 | printf("#%dX no attribute found in <%s>", xmlTextReaderReadState(my_reader), name); | |
305 | break;} | |
306 | default: | |
307 | break; | |
308 | } | |
309 | ||
310 | printf("\t%s\n", where); | |
311 | fflush(stdout); | |
312 | } | |
313 | //return xmlTextReaderMoveToFirstAttribute(my_reader); | |
314 | #endif | |
315 | return ret; | |
316 | } | |
317 | ||
318 | #undef MoveToNextAttribute | |
319 | int XmlReaderWrap::MoveToNextAttribute() | |
320 | { return xmlTextReaderMoveToNextAttribute(my_reader); } | |
321 | ||
322 | int XmlReaderWrap::MoveToNextAttributeDbg(const char *where) | |
323 | { | |
324 | int ret = xmlTextReaderMoveToNextAttribute(my_reader); | |
325 | #ifdef NDEBUG | |
326 | (void)where; | |
327 | #else | |
328 | static bool d = !!getenv("DEBUG_XMLREADER"); | |
329 | if (d) { | |
330 | switch (ret) { | |
331 | case 1: {//OK | |
332 | const xmlChar * name = xmlTextReaderConstLocalName(my_reader); | |
333 | const xmlChar * val = xmlTextReaderConstValue(my_reader); | |
334 | printf("X%dX %s='%s'", xmlTextReaderReadState(my_reader), name, val); | |
335 | break;} | |
336 | case 0: {// not found | |
337 | const xmlChar * name = xmlTextReaderConstLocalName(my_reader); | |
338 | printf("X%dX no more attributes found after '%s'", xmlTextReaderReadState(my_reader), name); | |
339 | break;} | |
340 | default: | |
341 | break; | |
342 | } | |
343 | ||
344 | printf("\t%s\n", where); | |
345 | fflush(stdout); | |
346 | } | |
347 | //return xmlTextReaderMoveToNextAttribute(my_reader); | |
348 | #endif | |
349 | return ret; | |
350 | } | |
351 | ||
352 | #undef MoveToElement | |
353 | int XmlReaderWrap::MoveToElement() | |
354 | { return xmlTextReaderMoveToElement(my_reader); } | |
355 | ||
356 | int XmlReaderWrap::MoveToElementDbg(const char *where) | |
357 | { | |
358 | int ret = xmlTextReaderMoveToElement(my_reader); | |
359 | #ifdef NDEBUG | |
360 | (void)where; | |
361 | #else | |
362 | static bool d = !!getenv("DEBUG_XMLREADER"); | |
363 | if (d) { | |
364 | const xmlChar * name = xmlTextReaderConstLocalName(my_reader); | |
365 | const xmlChar * val = xmlTextReaderConstValue(my_reader); | |
366 | printf("X%dX <%s='%s'>\n", xmlTextReaderReadState(my_reader), name, val); | |
367 | } | |
368 | ||
369 | printf("\t%s\n", where); | |
370 | fflush(stdout); | |
371 | #endif | |
372 | return ret; | |
373 | } | |
374 | ||
375 | //int XmlReaderWrap::GetParserLineNumber() | |
376 | //{ return xmlTextReaderGetParserLineNumber(my_reader); } | |
377 | ||
378 | //int XmlReaderWrap::GetParserColumnNumber() | |
379 | //{ return xmlTextReaderGetParserColumnNumber(my_reader); } | |
380 | ||
381 | #if 0 | |
382 | int XmlReaderWrap::Next() | |
383 | { return xmlTextReaderNext(my_reader); } | |
384 | ||
385 | int XmlReaderWrap::NextSibling() | |
386 | { return xmlTextReaderNextSibling(my_reader); } | |
387 | ||
388 | int XmlReaderWrap::Normalization() | |
389 | { return xmlTextReaderNormalization(my_reader); } | |
390 | ||
391 | int XmlReaderWrap::SetParserProp( int prop, int value) | |
392 | { return xmlTextReaderSetParserProp(my_reader,prop,value); } | |
393 | ||
394 | int XmlReaderWrap::GetParserProp( int prop) | |
395 | { return xmlTextReaderGetParserProp(my_reader,prop); } | |
396 | ||
397 | xmlParserInputBufferPtr XmlReaderWrap::GetRemainder() | |
398 | { return xmlTextReaderGetRemainder(my_reader); } | |
399 | ||
400 | xmlNodePtr XmlReaderWrap::CurrentNode() | |
401 | { return xmlTextReaderCurrentNode(my_reader); } | |
402 | ||
403 | xmlNodePtr XmlReaderWrap::Preserve() | |
404 | { return xmlTextReaderPreserve(my_reader); } | |
405 | ||
406 | int XmlReaderWrap::PreservePattern( const xmlChar *pattern, const xmlChar **namespaces) | |
407 | { return xmlTextReaderPreservePattern(my_reader,pattern,namespaces); } | |
408 | ||
409 | xmlDocPtr XmlReaderWrap::CurrentDoc() | |
410 | { return xmlTextReaderCurrentDoc(my_reader); } | |
411 | ||
412 | xmlNodePtr XmlReaderWrap::Expand() | |
413 | { return xmlTextReaderExpand(my_reader); } | |
414 | ||
415 | int XmlReaderWrap::IsValid() | |
416 | { return xmlTextReaderIsValid(my_reader); } | |
417 | ||
418 | int XmlReaderWrap::RelaxNGValidate( const char *rng) | |
419 | { return xmlTextReaderRelaxNGValidate(my_reader,rng); } | |
420 | ||
421 | int XmlReaderWrap::RelaxNGSetSchema( xmlRelaxNGPtr schema) | |
422 | { return xmlTextReaderRelaxNGSetSchema(my_reader,schema); } | |
423 | ||
424 | int XmlReaderWrap::SchemaValidate( const char *xsd) | |
425 | { return xmlTextReaderSchemaValidate(my_reader,xsd); } | |
426 | ||
427 | int XmlReaderWrap::SchemaValidateCtxt( xmlSchemaValidCtxtPtr ctxt, int options) | |
428 | { return xmlTextReaderSchemaValidateCtxt(my_reader,ctxt,options); } | |
429 | ||
430 | int XmlReaderWrap::SetSchema( xmlSchemaPtr schema) | |
431 | { return xmlTextReaderSetSchema(my_reader,schema); } | |
432 | ||
433 | int XmlReaderWrap::Standalone() | |
434 | { return xmlTextReaderStandalone(my_reader); } | |
435 | #endif | |
436 | ||
437 | long XmlReaderWrap::ByteConsumed() | |
438 | { return xmlTextReaderByteConsumed(my_reader); } | |
439 | ||
440 | //int XmlReaderWrap::LocatorLineNumber(xmlTextReaderLocatorPtr locator) | |
441 | //{ return xmlTextReaderLocatorLineNumber(locator); } | |
442 | ||
443 | //xmlChar * XmlReaderWrap::LocatorBaseURI(xmlTextReaderLocatorPtr locator) | |
444 | //{ return xmlTextReaderLocatorBaseURI(locator); } | |
445 | ||
446 | #if 0 | |
447 | void XmlReaderWrap::SetErrorHandler( xmlTextReaderErrorFunc f, void *arg) | |
448 | { return xmlTextReaderSetErrorHandler(my_reader,f,arg); } | |
449 | ||
450 | void XmlReaderWrap::SetStructuredErrorHandler( xmlStructuredErrorFunc f, void *arg) | |
451 | { return xmlTextReaderSetStructuredErrorHandler(my_reader,f,arg); } | |
452 | ||
453 | void XmlReaderWrap::GetErrorHandler( xmlTextReaderErrorFunc *f, void **arg) | |
454 | { return xmlTextReaderGetErrorHandler(my_reader,f,arg); } | |
455 | #endif | |
456 | ||
457 | #ifndef NDEBUG | |
458 | void XmlReaderWrap::Status() | |
459 | { | |
460 | //const xmlChar *string = xmlTextReaderConstString (my_reader); | |
461 | const xmlChar *baseuri = xmlTextReaderConstBaseUri (my_reader); | |
462 | const xmlChar *localname= xmlTextReaderConstLocalName (my_reader); | |
463 | const xmlChar *name = xmlTextReaderConstName (my_reader); | |
464 | const xmlChar *ns_uri = xmlTextReaderConstNamespaceUri(my_reader); | |
465 | const xmlChar *prefix = xmlTextReaderConstPrefix (my_reader); | |
466 | const xmlChar *lang = xmlTextReaderConstXmlLang (my_reader); | |
467 | const xmlChar *value = xmlTextReaderConstValue (my_reader); | |
468 | const xmlChar *encoding = xmlTextReaderConstEncoding (my_reader); | |
469 | const xmlChar *version = xmlTextReaderConstXmlVersion(my_reader); | |
470 | ||
471 | printf ("XML reader %d deep:\n" | |
472 | "\tbaseUri = '%s'\n" | |
473 | "\tprefix = '%s'\n" | |
474 | "\tlocalname = '%s'\n" | |
475 | "\tname = '%s%s'\n" | |
476 | "\tns-Uri = '%s'\n" | |
477 | "\txml lang = '%s'\n" | |
478 | "\tvalue = '%s'\n" | |
479 | "\tencoding = '%s'\n" | |
480 | "\txml ver = '%s'\n" | |
481 | , xmlTextReaderDepth(my_reader) | |
482 | , baseuri | |
483 | , prefix | |
484 | , localname | |
485 | , name, (xmlTextReaderIsEmptyElement(my_reader) ? "/" : "") | |
486 | , ns_uri | |
487 | , lang | |
488 | , value | |
489 | , encoding | |
490 | , version); | |
491 | } | |
492 | #endif | |
493 | ||
494 | ||
495 |