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