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