Annotation of embedaddon/libxml2/xmlreader.c, revision 1.1
1.1 ! misho 1: /*
! 2: * xmlreader.c: implements the xmlTextReader streaming node API
! 3: *
! 4: * NOTE:
! 5: * XmlTextReader.Normalization Property won't be supported, since
! 6: * it makes the parser non compliant to the XML recommendation
! 7: *
! 8: * See Copyright for the status of this software.
! 9: *
! 10: * daniel@veillard.com
! 11: */
! 12:
! 13: /*
! 14: * TODOs:
! 15: * - XML Schemas validation
! 16: */
! 17: #define IN_LIBXML
! 18: #include "libxml.h"
! 19:
! 20: #ifdef LIBXML_READER_ENABLED
! 21: #include <string.h> /* for memset() only ! */
! 22: #include <stdarg.h>
! 23:
! 24: #ifdef HAVE_CTYPE_H
! 25: #include <ctype.h>
! 26: #endif
! 27: #ifdef HAVE_STDLIB_H
! 28: #include <stdlib.h>
! 29: #endif
! 30:
! 31: #include <libxml/xmlmemory.h>
! 32: #include <libxml/xmlIO.h>
! 33: #include <libxml/xmlreader.h>
! 34: #include <libxml/parserInternals.h>
! 35: #ifdef LIBXML_SCHEMAS_ENABLED
! 36: #include <libxml/relaxng.h>
! 37: #include <libxml/xmlschemas.h>
! 38: #endif
! 39: #include <libxml/uri.h>
! 40: #ifdef LIBXML_XINCLUDE_ENABLED
! 41: #include <libxml/xinclude.h>
! 42: #endif
! 43: #ifdef LIBXML_PATTERN_ENABLED
! 44: #include <libxml/pattern.h>
! 45: #endif
! 46:
! 47: #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: (reader->entNr == 0)) {
! 1397: xmlNodePtr tmp = reader->node->prev;
! 1398: if ((tmp->extra & NODE_IS_PRESERVED) == 0) {
! 1399: xmlUnlinkNode(tmp);
! 1400: xmlTextReaderFreeNode(reader, tmp);
! 1401: }
! 1402: }
! 1403:
! 1404: goto node_found;
! 1405: }
! 1406: if ((oldstate == XML_TEXTREADER_ELEMENT) &&
! 1407: (reader->node->type == XML_ELEMENT_NODE) &&
! 1408: (reader->node->children == NULL) &&
! 1409: ((reader->node->extra & NODE_IS_EMPTY) == 0)) {;
! 1410: reader->state = XML_TEXTREADER_END;
! 1411: goto node_found;
! 1412: }
! 1413: #ifdef LIBXML_REGEXP_ENABLED
! 1414: if ((reader->validate) && (reader->node->type == XML_ELEMENT_NODE))
! 1415: xmlTextReaderValidatePop(reader);
! 1416: #endif /* LIBXML_REGEXP_ENABLED */
! 1417: if ((reader->preserves > 0) &&
! 1418: (reader->node->extra & NODE_IS_SPRESERVED))
! 1419: reader->preserves--;
! 1420: reader->node = reader->node->parent;
! 1421: if ((reader->node == NULL) ||
! 1422: (reader->node->type == XML_DOCUMENT_NODE) ||
! 1423: #ifdef LIBXML_DOCB_ENABLED
! 1424: (reader->node->type == XML_DOCB_DOCUMENT_NODE) ||
! 1425: #endif
! 1426: (reader->node->type == XML_HTML_DOCUMENT_NODE)) {
! 1427: if (reader->mode != XML_TEXTREADER_MODE_EOF) {
! 1428: val = xmlParseChunk(reader->ctxt, "", 0, 1);
! 1429: reader->state = XML_TEXTREADER_DONE;
! 1430: if (val != 0)
! 1431: return(-1);
! 1432: }
! 1433: reader->node = NULL;
! 1434: reader->depth = -1;
! 1435:
! 1436: /*
! 1437: * Cleanup of the old node
! 1438: */
! 1439: if ((oldnode != NULL) && (reader->preserves == 0) &&
! 1440: #ifdef LIBXML_XINCLUDE_ENABLED
! 1441: (reader->in_xinclude == 0) &&
! 1442: #endif
! 1443: (reader->entNr == 0) &&
! 1444: (oldnode->type != XML_DTD_NODE) &&
! 1445: ((oldnode->extra & NODE_IS_PRESERVED) == 0) &&
! 1446: (reader->entNr == 0)) {
! 1447: xmlUnlinkNode(oldnode);
! 1448: xmlTextReaderFreeNode(reader, oldnode);
! 1449: }
! 1450:
! 1451: goto node_end;
! 1452: }
! 1453: if ((reader->preserves == 0) &&
! 1454: #ifdef LIBXML_XINCLUDE_ENABLED
! 1455: (reader->in_xinclude == 0) &&
! 1456: #endif
! 1457: (reader->entNr == 0) &&
! 1458: (reader->node->last != NULL) &&
! 1459: ((reader->node->last->extra & NODE_IS_PRESERVED) == 0)) {
! 1460: xmlNodePtr tmp = reader->node->last;
! 1461: xmlUnlinkNode(tmp);
! 1462: xmlTextReaderFreeNode(reader, tmp);
! 1463: }
! 1464: reader->depth--;
! 1465: reader->state = XML_TEXTREADER_BACKTRACK;
! 1466:
! 1467: node_found:
! 1468: DUMP_READER
! 1469:
! 1470: /*
! 1471: * If we are in the middle of a piece of CDATA make sure it's finished
! 1472: */
! 1473: if ((reader->node != NULL) &&
! 1474: (reader->node->next == NULL) &&
! 1475: ((reader->node->type == XML_TEXT_NODE) ||
! 1476: (reader->node->type == XML_CDATA_SECTION_NODE))) {
! 1477: if (xmlTextReaderExpand(reader) == NULL)
! 1478: return -1;
! 1479: }
! 1480:
! 1481: #ifdef LIBXML_XINCLUDE_ENABLED
! 1482: /*
! 1483: * Handle XInclude if asked for
! 1484: */
! 1485: if ((reader->xinclude) && (reader->node != NULL) &&
! 1486: (reader->node->type == XML_ELEMENT_NODE) &&
! 1487: (reader->node->ns != NULL) &&
! 1488: ((xmlStrEqual(reader->node->ns->href, XINCLUDE_NS)) ||
! 1489: (xmlStrEqual(reader->node->ns->href, XINCLUDE_OLD_NS)))) {
! 1490: if (reader->xincctxt == NULL) {
! 1491: reader->xincctxt = xmlXIncludeNewContext(reader->ctxt->myDoc);
! 1492: xmlXIncludeSetFlags(reader->xincctxt,
! 1493: reader->parserFlags & (~XML_PARSE_NOXINCNODE));
! 1494: }
! 1495: /*
! 1496: * expand that node and process it
! 1497: */
! 1498: if (xmlTextReaderExpand(reader) == NULL)
! 1499: return -1;
! 1500: xmlXIncludeProcessNode(reader->xincctxt, reader->node);
! 1501: }
! 1502: if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_START)) {
! 1503: reader->in_xinclude++;
! 1504: goto get_next_node;
! 1505: }
! 1506: if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_END)) {
! 1507: reader->in_xinclude--;
! 1508: goto get_next_node;
! 1509: }
! 1510: #endif
! 1511: /*
! 1512: * Handle entities enter and exit when in entity replacement mode
! 1513: */
! 1514: if ((reader->node != NULL) &&
! 1515: (reader->node->type == XML_ENTITY_REF_NODE) &&
! 1516: (reader->ctxt != NULL) && (reader->ctxt->replaceEntities == 1)) {
! 1517: /*
! 1518: * Case where the underlying tree is not availble, lookup the entity
! 1519: * and walk it.
! 1520: */
! 1521: if ((reader->node->children == NULL) && (reader->ctxt->sax != NULL) &&
! 1522: (reader->ctxt->sax->getEntity != NULL)) {
! 1523: reader->node->children = (xmlNodePtr)
! 1524: reader->ctxt->sax->getEntity(reader->ctxt, reader->node->name);
! 1525: }
! 1526:
! 1527: if ((reader->node->children != NULL) &&
! 1528: (reader->node->children->type == XML_ENTITY_DECL) &&
! 1529: (reader->node->children->children != NULL)) {
! 1530: xmlTextReaderEntPush(reader, reader->node);
! 1531: reader->node = reader->node->children->children;
! 1532: }
! 1533: #ifdef LIBXML_REGEXP_ENABLED
! 1534: } else if ((reader->node != NULL) &&
! 1535: (reader->node->type == XML_ENTITY_REF_NODE) &&
! 1536: (reader->ctxt != NULL) && (reader->validate)) {
! 1537: xmlTextReaderValidateEntity(reader);
! 1538: #endif /* LIBXML_REGEXP_ENABLED */
! 1539: }
! 1540: if ((reader->node != NULL) &&
! 1541: (reader->node->type == XML_ENTITY_DECL) &&
! 1542: (reader->ent != NULL) && (reader->ent->children == reader->node)) {
! 1543: reader->node = xmlTextReaderEntPop(reader);
! 1544: reader->depth++;
! 1545: goto get_next_node;
! 1546: }
! 1547: #ifdef LIBXML_REGEXP_ENABLED
! 1548: if ((reader->validate) && (reader->node != NULL)) {
! 1549: xmlNodePtr node = reader->node;
! 1550:
! 1551: if ((node->type == XML_ELEMENT_NODE) &&
! 1552: ((reader->state != XML_TEXTREADER_END) &&
! 1553: (reader->state != XML_TEXTREADER_BACKTRACK))) {
! 1554: xmlTextReaderValidatePush(reader);
! 1555: } else if ((node->type == XML_TEXT_NODE) ||
! 1556: (node->type == XML_CDATA_SECTION_NODE)) {
! 1557: xmlTextReaderValidateCData(reader, node->content,
! 1558: xmlStrlen(node->content));
! 1559: }
! 1560: }
! 1561: #endif /* LIBXML_REGEXP_ENABLED */
! 1562: #ifdef LIBXML_PATTERN_ENABLED
! 1563: if ((reader->patternNr > 0) && (reader->state != XML_TEXTREADER_END) &&
! 1564: (reader->state != XML_TEXTREADER_BACKTRACK)) {
! 1565: int i;
! 1566: for (i = 0;i < reader->patternNr;i++) {
! 1567: if (xmlPatternMatch(reader->patternTab[i], reader->node) == 1) {
! 1568: xmlTextReaderPreserve(reader);
! 1569: break;
! 1570: }
! 1571: }
! 1572: }
! 1573: #endif /* LIBXML_PATTERN_ENABLED */
! 1574: #ifdef LIBXML_SCHEMAS_ENABLED
! 1575: if ((reader->validate == XML_TEXTREADER_VALIDATE_XSD) &&
! 1576: (reader->xsdValidErrors == 0) &&
! 1577: (reader->xsdValidCtxt != NULL)) {
! 1578: reader->xsdValidErrors = !xmlSchemaIsValid(reader->xsdValidCtxt);
! 1579: }
! 1580: #endif /* LIBXML_PATTERN_ENABLED */
! 1581: return(1);
! 1582: node_end:
! 1583: reader->state = XML_TEXTREADER_DONE;
! 1584: return(0);
! 1585: }
! 1586:
! 1587: /**
! 1588: * xmlTextReaderReadState:
! 1589: * @reader: the xmlTextReaderPtr used
! 1590: *
! 1591: * Gets the read state of the reader.
! 1592: *
! 1593: * Returns the state value, or -1 in case of error
! 1594: */
! 1595: int
! 1596: xmlTextReaderReadState(xmlTextReaderPtr reader) {
! 1597: if (reader == NULL)
! 1598: return(-1);
! 1599: return(reader->mode);
! 1600: }
! 1601:
! 1602: /**
! 1603: * xmlTextReaderExpand:
! 1604: * @reader: the xmlTextReaderPtr used
! 1605: *
! 1606: * Reads the contents of the current node and the full subtree. It then makes
! 1607: * the subtree available until the next xmlTextReaderRead() call
! 1608: *
! 1609: * Returns a node pointer valid until the next xmlTextReaderRead() call
! 1610: * or NULL in case of error.
! 1611: */
! 1612: xmlNodePtr
! 1613: xmlTextReaderExpand(xmlTextReaderPtr reader) {
! 1614: if ((reader == NULL) || (reader->node == NULL))
! 1615: return(NULL);
! 1616: if (reader->doc != NULL)
! 1617: return(reader->node);
! 1618: if (reader->ctxt == NULL)
! 1619: return(NULL);
! 1620: if (xmlTextReaderDoExpand(reader) < 0)
! 1621: return(NULL);
! 1622: return(reader->node);
! 1623: }
! 1624:
! 1625: /**
! 1626: * xmlTextReaderNext:
! 1627: * @reader: the xmlTextReaderPtr used
! 1628: *
! 1629: * Skip to the node following the current one in document order while
! 1630: * avoiding the subtree if any.
! 1631: *
! 1632: * Returns 1 if the node was read successfully, 0 if there is no more
! 1633: * nodes to read, or -1 in case of error
! 1634: */
! 1635: int
! 1636: xmlTextReaderNext(xmlTextReaderPtr reader) {
! 1637: int ret;
! 1638: xmlNodePtr cur;
! 1639:
! 1640: if (reader == NULL)
! 1641: return(-1);
! 1642: if (reader->doc != NULL)
! 1643: return(xmlTextReaderNextTree(reader));
! 1644: cur = reader->node;
! 1645: if ((cur == NULL) || (cur->type != XML_ELEMENT_NODE))
! 1646: return(xmlTextReaderRead(reader));
! 1647: if (reader->state == XML_TEXTREADER_END || reader->state == XML_TEXTREADER_BACKTRACK)
! 1648: return(xmlTextReaderRead(reader));
! 1649: if (cur->extra & NODE_IS_EMPTY)
! 1650: return(xmlTextReaderRead(reader));
! 1651: do {
! 1652: ret = xmlTextReaderRead(reader);
! 1653: if (ret != 1)
! 1654: return(ret);
! 1655: } while (reader->node != cur);
! 1656: return(xmlTextReaderRead(reader));
! 1657: }
! 1658:
! 1659: #ifdef LIBXML_WRITER_ENABLED
! 1660: /**
! 1661: * xmlTextReaderReadInnerXml:
! 1662: * @reader: the xmlTextReaderPtr used
! 1663: *
! 1664: * Reads the contents of the current node, including child nodes and markup.
! 1665: *
! 1666: * Returns a string containing the XML content, or NULL if the current node
! 1667: * is neither an element nor attribute, or has no child nodes. The
! 1668: * string must be deallocated by the caller.
! 1669: */
! 1670: xmlChar *
! 1671: xmlTextReaderReadInnerXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
! 1672: {
! 1673: xmlChar *resbuf;
! 1674: xmlNodePtr node, cur_node;
! 1675: xmlBufferPtr buff, buff2;
! 1676: xmlDocPtr doc;
! 1677:
! 1678: if (xmlTextReaderExpand(reader) == NULL) {
! 1679: return NULL;
! 1680: }
! 1681: doc = reader->doc;
! 1682: buff = xmlBufferCreate();
! 1683: for (cur_node = reader->node->children; cur_node != NULL;
! 1684: cur_node = cur_node->next) {
! 1685: node = xmlDocCopyNode(cur_node, doc, 1);
! 1686: buff2 = xmlBufferCreate();
! 1687: if (xmlNodeDump(buff2, doc, node, 0, 0) == -1) {
! 1688: xmlFreeNode(node);
! 1689: xmlBufferFree(buff2);
! 1690: xmlBufferFree(buff);
! 1691: return NULL;
! 1692: }
! 1693: xmlBufferCat(buff, buff2->content);
! 1694: xmlFreeNode(node);
! 1695: xmlBufferFree(buff2);
! 1696: }
! 1697: resbuf = buff->content;
! 1698: buff->content = NULL;
! 1699:
! 1700: xmlBufferFree(buff);
! 1701: return resbuf;
! 1702: }
! 1703: #endif
! 1704:
! 1705: #ifdef LIBXML_WRITER_ENABLED
! 1706: /**
! 1707: * xmlTextReaderReadOuterXml:
! 1708: * @reader: the xmlTextReaderPtr used
! 1709: *
! 1710: * Reads the contents of the current node, including child nodes and markup.
! 1711: *
! 1712: * Returns a string containing the node and any XML content, or NULL if the
! 1713: * current node cannot be serialized. The string must be deallocated
! 1714: * by the caller.
! 1715: */
! 1716: xmlChar *
! 1717: xmlTextReaderReadOuterXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
! 1718: {
! 1719: xmlChar *resbuf;
! 1720: xmlNodePtr node;
! 1721: xmlBufferPtr buff;
! 1722: xmlDocPtr doc;
! 1723:
! 1724: node = reader->node;
! 1725: doc = reader->doc;
! 1726: if (xmlTextReaderExpand(reader) == NULL) {
! 1727: return NULL;
! 1728: }
! 1729: if (node->type == XML_DTD_NODE) {
! 1730: node = (xmlNodePtr) xmlCopyDtd((xmlDtdPtr) node);
! 1731: } else {
! 1732: node = xmlDocCopyNode(node, doc, 1);
! 1733: }
! 1734: buff = xmlBufferCreate();
! 1735: if (xmlNodeDump(buff, doc, node, 0, 0) == -1) {
! 1736: xmlFreeNode(node);
! 1737: xmlBufferFree(buff);
! 1738: return NULL;
! 1739: }
! 1740:
! 1741: resbuf = buff->content;
! 1742: buff->content = NULL;
! 1743:
! 1744: xmlFreeNode(node);
! 1745: xmlBufferFree(buff);
! 1746: return resbuf;
! 1747: }
! 1748: #endif
! 1749:
! 1750: /**
! 1751: * xmlTextReaderReadString:
! 1752: * @reader: the xmlTextReaderPtr used
! 1753: *
! 1754: * Reads the contents of an element or a text node as a string.
! 1755: *
! 1756: * Returns a string containing the contents of the Element or Text node,
! 1757: * or NULL if the reader is positioned on any other type of node.
! 1758: * The string must be deallocated by the caller.
! 1759: */
! 1760: xmlChar *
! 1761: xmlTextReaderReadString(xmlTextReaderPtr reader)
! 1762: {
! 1763: xmlNodePtr node;
! 1764:
! 1765: if ((reader == NULL) || (reader->node == NULL))
! 1766: return(NULL);
! 1767:
! 1768: node = (reader->curnode != NULL) ? reader->curnode : reader->node;
! 1769: switch (node->type) {
! 1770: case XML_TEXT_NODE:
! 1771: if (node->content != NULL)
! 1772: return(xmlStrdup(node->content));
! 1773: break;
! 1774: case XML_ELEMENT_NODE:
! 1775: if (xmlTextReaderDoExpand(reader) != -1) {
! 1776: return xmlTextReaderCollectSiblings(node->children);
! 1777: }
! 1778: case XML_ATTRIBUTE_NODE:
! 1779: TODO
! 1780: break;
! 1781: default:
! 1782: break;
! 1783: }
! 1784: return(NULL);
! 1785: }
! 1786:
! 1787: #if 0
! 1788: /**
! 1789: * xmlTextReaderReadBase64:
! 1790: * @reader: the xmlTextReaderPtr used
! 1791: * @array: a byte array to store the content.
! 1792: * @offset: the zero-based index into array where the method should
! 1793: * begin to write.
! 1794: * @len: the number of bytes to write.
! 1795: *
! 1796: * Reads and decodes the Base64 encoded contents of an element and
! 1797: * stores the result in a byte buffer.
! 1798: *
! 1799: * Returns the number of bytes written to array, or zero if the current
! 1800: * instance is not positioned on an element or -1 in case of error.
! 1801: */
! 1802: int
! 1803: xmlTextReaderReadBase64(xmlTextReaderPtr reader,
! 1804: unsigned char *array ATTRIBUTE_UNUSED,
! 1805: int offset ATTRIBUTE_UNUSED,
! 1806: int len ATTRIBUTE_UNUSED) {
! 1807: if ((reader == NULL) || (reader->ctxt == NULL))
! 1808: return(-1);
! 1809: if (reader->ctxt->wellFormed != 1)
! 1810: return(-1);
! 1811:
! 1812: if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
! 1813: return(0);
! 1814: TODO
! 1815: return(0);
! 1816: }
! 1817:
! 1818: /**
! 1819: * xmlTextReaderReadBinHex:
! 1820: * @reader: the xmlTextReaderPtr used
! 1821: * @array: a byte array to store the content.
! 1822: * @offset: the zero-based index into array where the method should
! 1823: * begin to write.
! 1824: * @len: the number of bytes to write.
! 1825: *
! 1826: * Reads and decodes the BinHex encoded contents of an element and
! 1827: * stores the result in a byte buffer.
! 1828: *
! 1829: * Returns the number of bytes written to array, or zero if the current
! 1830: * instance is not positioned on an element or -1 in case of error.
! 1831: */
! 1832: int
! 1833: xmlTextReaderReadBinHex(xmlTextReaderPtr reader,
! 1834: unsigned char *array ATTRIBUTE_UNUSED,
! 1835: int offset ATTRIBUTE_UNUSED,
! 1836: int len ATTRIBUTE_UNUSED) {
! 1837: if ((reader == NULL) || (reader->ctxt == NULL))
! 1838: return(-1);
! 1839: if (reader->ctxt->wellFormed != 1)
! 1840: return(-1);
! 1841:
! 1842: if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
! 1843: return(0);
! 1844: TODO
! 1845: return(0);
! 1846: }
! 1847: #endif
! 1848:
! 1849: /************************************************************************
! 1850: * *
! 1851: * Operating on a preparsed tree *
! 1852: * *
! 1853: ************************************************************************/
! 1854: static int
! 1855: xmlTextReaderNextTree(xmlTextReaderPtr reader)
! 1856: {
! 1857: if (reader == NULL)
! 1858: return(-1);
! 1859:
! 1860: if (reader->state == XML_TEXTREADER_END)
! 1861: return(0);
! 1862:
! 1863: if (reader->node == NULL) {
! 1864: if (reader->doc->children == NULL) {
! 1865: reader->state = XML_TEXTREADER_END;
! 1866: return(0);
! 1867: }
! 1868:
! 1869: reader->node = reader->doc->children;
! 1870: reader->state = XML_TEXTREADER_START;
! 1871: return(1);
! 1872: }
! 1873:
! 1874: if (reader->state != XML_TEXTREADER_BACKTRACK) {
! 1875: /* Here removed traversal to child, because we want to skip the subtree,
! 1876: replace with traversal to sibling to skip subtree */
! 1877: if (reader->node->next != 0) {
! 1878: /* Move to sibling if present,skipping sub-tree */
! 1879: reader->node = reader->node->next;
! 1880: reader->state = XML_TEXTREADER_START;
! 1881: return(1);
! 1882: }
! 1883:
! 1884: /* if reader->node->next is NULL mean no subtree for current node,
! 1885: so need to move to sibling of parent node if present */
! 1886: if ((reader->node->type == XML_ELEMENT_NODE) ||
! 1887: (reader->node->type == XML_ATTRIBUTE_NODE)) {
! 1888: reader->state = XML_TEXTREADER_BACKTRACK;
! 1889: /* This will move to parent if present */
! 1890: xmlTextReaderRead(reader);
! 1891: }
! 1892: }
! 1893:
! 1894: if (reader->node->next != 0) {
! 1895: reader->node = reader->node->next;
! 1896: reader->state = XML_TEXTREADER_START;
! 1897: return(1);
! 1898: }
! 1899:
! 1900: if (reader->node->parent != 0) {
! 1901: if (reader->node->parent->type == XML_DOCUMENT_NODE) {
! 1902: reader->state = XML_TEXTREADER_END;
! 1903: return(0);
! 1904: }
! 1905:
! 1906: reader->node = reader->node->parent;
! 1907: reader->depth--;
! 1908: reader->state = XML_TEXTREADER_BACKTRACK;
! 1909: /* Repeat process to move to sibling of parent node if present */
! 1910: xmlTextReaderNextTree(reader);
! 1911: }
! 1912:
! 1913: reader->state = XML_TEXTREADER_END;
! 1914:
! 1915: return(1);
! 1916: }
! 1917:
! 1918: /**
! 1919: * xmlTextReaderReadTree:
! 1920: * @reader: the xmlTextReaderPtr used
! 1921: *
! 1922: * Moves the position of the current instance to the next node in
! 1923: * the stream, exposing its properties.
! 1924: *
! 1925: * Returns 1 if the node was read successfully, 0 if there is no more
! 1926: * nodes to read, or -1 in case of error
! 1927: */
! 1928: static int
! 1929: xmlTextReaderReadTree(xmlTextReaderPtr reader) {
! 1930: if (reader->state == XML_TEXTREADER_END)
! 1931: return(0);
! 1932:
! 1933: next_node:
! 1934: if (reader->node == NULL) {
! 1935: if (reader->doc->children == NULL) {
! 1936: reader->state = XML_TEXTREADER_END;
! 1937: return(0);
! 1938: }
! 1939:
! 1940: reader->node = reader->doc->children;
! 1941: reader->state = XML_TEXTREADER_START;
! 1942: goto found_node;
! 1943: }
! 1944:
! 1945: if ((reader->state != XML_TEXTREADER_BACKTRACK) &&
! 1946: (reader->node->type != XML_DTD_NODE) &&
! 1947: (reader->node->type != XML_XINCLUDE_START) &&
! 1948: (reader->node->type != XML_ENTITY_REF_NODE)) {
! 1949: if (reader->node->children != NULL) {
! 1950: reader->node = reader->node->children;
! 1951: reader->depth++;
! 1952: reader->state = XML_TEXTREADER_START;
! 1953: goto found_node;
! 1954: }
! 1955:
! 1956: if (reader->node->type == XML_ATTRIBUTE_NODE) {
! 1957: reader->state = XML_TEXTREADER_BACKTRACK;
! 1958: goto found_node;
! 1959: }
! 1960: }
! 1961:
! 1962: if (reader->node->next != NULL) {
! 1963: reader->node = reader->node->next;
! 1964: reader->state = XML_TEXTREADER_START;
! 1965: goto found_node;
! 1966: }
! 1967:
! 1968: if (reader->node->parent != NULL) {
! 1969: if ((reader->node->parent->type == XML_DOCUMENT_NODE) ||
! 1970: (reader->node->parent->type == XML_HTML_DOCUMENT_NODE)) {
! 1971: reader->state = XML_TEXTREADER_END;
! 1972: return(0);
! 1973: }
! 1974:
! 1975: reader->node = reader->node->parent;
! 1976: reader->depth--;
! 1977: reader->state = XML_TEXTREADER_BACKTRACK;
! 1978: goto found_node;
! 1979: }
! 1980:
! 1981: reader->state = XML_TEXTREADER_END;
! 1982:
! 1983: found_node:
! 1984: if ((reader->node->type == XML_XINCLUDE_START) ||
! 1985: (reader->node->type == XML_XINCLUDE_END))
! 1986: goto next_node;
! 1987:
! 1988: return(1);
! 1989: }
! 1990:
! 1991: /**
! 1992: * xmlTextReaderNextSibling:
! 1993: * @reader: the xmlTextReaderPtr used
! 1994: *
! 1995: * Skip to the node following the current one in document order while
! 1996: * avoiding the subtree if any.
! 1997: * Currently implemented only for Readers built on a document
! 1998: *
! 1999: * Returns 1 if the node was read successfully, 0 if there is no more
! 2000: * nodes to read, or -1 in case of error
! 2001: */
! 2002: int
! 2003: xmlTextReaderNextSibling(xmlTextReaderPtr reader) {
! 2004: if (reader == NULL)
! 2005: return(-1);
! 2006: if (reader->doc == NULL) {
! 2007: /* TODO */
! 2008: return(-1);
! 2009: }
! 2010:
! 2011: if (reader->state == XML_TEXTREADER_END)
! 2012: return(0);
! 2013:
! 2014: if (reader->node == NULL)
! 2015: return(xmlTextReaderNextTree(reader));
! 2016:
! 2017: if (reader->node->next != NULL) {
! 2018: reader->node = reader->node->next;
! 2019: reader->state = XML_TEXTREADER_START;
! 2020: return(1);
! 2021: }
! 2022:
! 2023: return(0);
! 2024: }
! 2025:
! 2026: /************************************************************************
! 2027: * *
! 2028: * Constructor and destructors *
! 2029: * *
! 2030: ************************************************************************/
! 2031: /**
! 2032: * xmlNewTextReader:
! 2033: * @input: the xmlParserInputBufferPtr used to read data
! 2034: * @URI: the URI information for the source if available
! 2035: *
! 2036: * Create an xmlTextReader structure fed with @input
! 2037: *
! 2038: * Returns the new xmlTextReaderPtr or NULL in case of error
! 2039: */
! 2040: xmlTextReaderPtr
! 2041: xmlNewTextReader(xmlParserInputBufferPtr input, const char *URI) {
! 2042: xmlTextReaderPtr ret;
! 2043:
! 2044: if (input == NULL)
! 2045: return(NULL);
! 2046: ret = xmlMalloc(sizeof(xmlTextReader));
! 2047: if (ret == NULL) {
! 2048: xmlGenericError(xmlGenericErrorContext,
! 2049: "xmlNewTextReader : malloc failed\n");
! 2050: return(NULL);
! 2051: }
! 2052: memset(ret, 0, sizeof(xmlTextReader));
! 2053: ret->doc = NULL;
! 2054: ret->entTab = NULL;
! 2055: ret->entMax = 0;
! 2056: ret->entNr = 0;
! 2057: ret->input = input;
! 2058: ret->buffer = xmlBufferCreateSize(100);
! 2059: if (ret->buffer == NULL) {
! 2060: xmlFree(ret);
! 2061: xmlGenericError(xmlGenericErrorContext,
! 2062: "xmlNewTextReader : malloc failed\n");
! 2063: return(NULL);
! 2064: }
! 2065: ret->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
! 2066: if (ret->sax == NULL) {
! 2067: xmlBufferFree(ret->buffer);
! 2068: xmlFree(ret);
! 2069: xmlGenericError(xmlGenericErrorContext,
! 2070: "xmlNewTextReader : malloc failed\n");
! 2071: return(NULL);
! 2072: }
! 2073: xmlSAXVersion(ret->sax, 2);
! 2074: ret->startElement = ret->sax->startElement;
! 2075: ret->sax->startElement = xmlTextReaderStartElement;
! 2076: ret->endElement = ret->sax->endElement;
! 2077: ret->sax->endElement = xmlTextReaderEndElement;
! 2078: #ifdef LIBXML_SAX1_ENABLED
! 2079: if (ret->sax->initialized == XML_SAX2_MAGIC) {
! 2080: #endif /* LIBXML_SAX1_ENABLED */
! 2081: ret->startElementNs = ret->sax->startElementNs;
! 2082: ret->sax->startElementNs = xmlTextReaderStartElementNs;
! 2083: ret->endElementNs = ret->sax->endElementNs;
! 2084: ret->sax->endElementNs = xmlTextReaderEndElementNs;
! 2085: #ifdef LIBXML_SAX1_ENABLED
! 2086: } else {
! 2087: ret->startElementNs = NULL;
! 2088: ret->endElementNs = NULL;
! 2089: }
! 2090: #endif /* LIBXML_SAX1_ENABLED */
! 2091: ret->characters = ret->sax->characters;
! 2092: ret->sax->characters = xmlTextReaderCharacters;
! 2093: ret->sax->ignorableWhitespace = xmlTextReaderCharacters;
! 2094: ret->cdataBlock = ret->sax->cdataBlock;
! 2095: ret->sax->cdataBlock = xmlTextReaderCDataBlock;
! 2096:
! 2097: ret->mode = XML_TEXTREADER_MODE_INITIAL;
! 2098: ret->node = NULL;
! 2099: ret->curnode = NULL;
! 2100: if (ret->input->buffer->use < 4) {
! 2101: xmlParserInputBufferRead(input, 4);
! 2102: }
! 2103: if (ret->input->buffer->use >= 4) {
! 2104: ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL,
! 2105: (const char *) ret->input->buffer->content, 4, URI);
! 2106: ret->base = 0;
! 2107: ret->cur = 4;
! 2108: } else {
! 2109: ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL, NULL, 0, URI);
! 2110: ret->base = 0;
! 2111: ret->cur = 0;
! 2112: }
! 2113:
! 2114: if (ret->ctxt == NULL) {
! 2115: xmlGenericError(xmlGenericErrorContext,
! 2116: "xmlNewTextReader : malloc failed\n");
! 2117: xmlBufferFree(ret->buffer);
! 2118: xmlFree(ret->sax);
! 2119: xmlFree(ret);
! 2120: return(NULL);
! 2121: }
! 2122: ret->ctxt->parseMode = XML_PARSE_READER;
! 2123: ret->ctxt->_private = ret;
! 2124: ret->ctxt->linenumbers = 1;
! 2125: ret->ctxt->dictNames = 1;
! 2126: ret->allocs = XML_TEXTREADER_CTXT;
! 2127: /*
! 2128: * use the parser dictionnary to allocate all elements and attributes names
! 2129: */
! 2130: ret->ctxt->docdict = 1;
! 2131: ret->dict = ret->ctxt->dict;
! 2132: #ifdef LIBXML_XINCLUDE_ENABLED
! 2133: ret->xinclude = 0;
! 2134: #endif
! 2135: #ifdef LIBXML_PATTERN_ENABLED
! 2136: ret->patternMax = 0;
! 2137: ret->patternTab = NULL;
! 2138: #endif
! 2139: return(ret);
! 2140: }
! 2141:
! 2142: /**
! 2143: * xmlNewTextReaderFilename:
! 2144: * @URI: the URI of the resource to process
! 2145: *
! 2146: * Create an xmlTextReader structure fed with the resource at @URI
! 2147: *
! 2148: * Returns the new xmlTextReaderPtr or NULL in case of error
! 2149: */
! 2150: xmlTextReaderPtr
! 2151: xmlNewTextReaderFilename(const char *URI) {
! 2152: xmlParserInputBufferPtr input;
! 2153: xmlTextReaderPtr ret;
! 2154: char *directory = NULL;
! 2155:
! 2156: input = xmlParserInputBufferCreateFilename(URI, XML_CHAR_ENCODING_NONE);
! 2157: if (input == NULL)
! 2158: return(NULL);
! 2159: ret = xmlNewTextReader(input, URI);
! 2160: if (ret == NULL) {
! 2161: xmlFreeParserInputBuffer(input);
! 2162: return(NULL);
! 2163: }
! 2164: ret->allocs |= XML_TEXTREADER_INPUT;
! 2165: if (ret->ctxt->directory == NULL)
! 2166: directory = xmlParserGetDirectory(URI);
! 2167: if ((ret->ctxt->directory == NULL) && (directory != NULL))
! 2168: ret->ctxt->directory = (char *) xmlStrdup((xmlChar *) directory);
! 2169: if (directory != NULL)
! 2170: xmlFree(directory);
! 2171: return(ret);
! 2172: }
! 2173:
! 2174: /**
! 2175: * xmlFreeTextReader:
! 2176: * @reader: the xmlTextReaderPtr
! 2177: *
! 2178: * Deallocate all the resources associated to the reader
! 2179: */
! 2180: void
! 2181: xmlFreeTextReader(xmlTextReaderPtr reader) {
! 2182: if (reader == NULL)
! 2183: return;
! 2184: #ifdef LIBXML_SCHEMAS_ENABLED
! 2185: if (reader->rngSchemas != NULL) {
! 2186: xmlRelaxNGFree(reader->rngSchemas);
! 2187: reader->rngSchemas = NULL;
! 2188: }
! 2189: if (reader->rngValidCtxt != NULL) {
! 2190: xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
! 2191: reader->rngValidCtxt = NULL;
! 2192: }
! 2193: if (reader->xsdPlug != NULL) {
! 2194: xmlSchemaSAXUnplug(reader->xsdPlug);
! 2195: reader->xsdPlug = NULL;
! 2196: }
! 2197: if (reader->xsdValidCtxt != NULL) {
! 2198: if (! reader->xsdPreserveCtxt)
! 2199: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
! 2200: reader->xsdValidCtxt = NULL;
! 2201: }
! 2202: if (reader->xsdSchemas != NULL) {
! 2203: xmlSchemaFree(reader->xsdSchemas);
! 2204: reader->xsdSchemas = NULL;
! 2205: }
! 2206: #endif
! 2207: #ifdef LIBXML_XINCLUDE_ENABLED
! 2208: if (reader->xincctxt != NULL)
! 2209: xmlXIncludeFreeContext(reader->xincctxt);
! 2210: #endif
! 2211: #ifdef LIBXML_PATTERN_ENABLED
! 2212: if (reader->patternTab != NULL) {
! 2213: int i;
! 2214: for (i = 0;i < reader->patternNr;i++) {
! 2215: if (reader->patternTab[i] != NULL)
! 2216: xmlFreePattern(reader->patternTab[i]);
! 2217: }
! 2218: xmlFree(reader->patternTab);
! 2219: }
! 2220: #endif
! 2221: if (reader->faketext != NULL) {
! 2222: xmlFreeNode(reader->faketext);
! 2223: }
! 2224: if (reader->ctxt != NULL) {
! 2225: if (reader->dict == reader->ctxt->dict)
! 2226: reader->dict = NULL;
! 2227: if (reader->ctxt->myDoc != NULL) {
! 2228: if (reader->preserve == 0)
! 2229: xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
! 2230: reader->ctxt->myDoc = NULL;
! 2231: }
! 2232: if ((reader->ctxt->vctxt.vstateTab != NULL) &&
! 2233: (reader->ctxt->vctxt.vstateMax > 0)){
! 2234: xmlFree(reader->ctxt->vctxt.vstateTab);
! 2235: reader->ctxt->vctxt.vstateTab = NULL;
! 2236: reader->ctxt->vctxt.vstateMax = 0;
! 2237: }
! 2238: if (reader->allocs & XML_TEXTREADER_CTXT)
! 2239: xmlFreeParserCtxt(reader->ctxt);
! 2240: }
! 2241: if (reader->sax != NULL)
! 2242: xmlFree(reader->sax);
! 2243: if ((reader->input != NULL) && (reader->allocs & XML_TEXTREADER_INPUT))
! 2244: xmlFreeParserInputBuffer(reader->input);
! 2245: if (reader->buffer != NULL)
! 2246: xmlBufferFree(reader->buffer);
! 2247: if (reader->entTab != NULL)
! 2248: xmlFree(reader->entTab);
! 2249: if (reader->dict != NULL)
! 2250: xmlDictFree(reader->dict);
! 2251: xmlFree(reader);
! 2252: }
! 2253:
! 2254: /************************************************************************
! 2255: * *
! 2256: * Methods for XmlTextReader *
! 2257: * *
! 2258: ************************************************************************/
! 2259: /**
! 2260: * xmlTextReaderClose:
! 2261: * @reader: the xmlTextReaderPtr used
! 2262: *
! 2263: * This method releases any resources allocated by the current instance
! 2264: * changes the state to Closed and close any underlying input.
! 2265: *
! 2266: * Returns 0 or -1 in case of error
! 2267: */
! 2268: int
! 2269: xmlTextReaderClose(xmlTextReaderPtr reader) {
! 2270: if (reader == NULL)
! 2271: return(-1);
! 2272: reader->node = NULL;
! 2273: reader->curnode = NULL;
! 2274: reader->mode = XML_TEXTREADER_MODE_CLOSED;
! 2275: if (reader->ctxt != NULL) {
! 2276: xmlStopParser(reader->ctxt);
! 2277: if (reader->ctxt->myDoc != NULL) {
! 2278: if (reader->preserve == 0)
! 2279: xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
! 2280: reader->ctxt->myDoc = NULL;
! 2281: }
! 2282: }
! 2283: if ((reader->input != NULL) && (reader->allocs & XML_TEXTREADER_INPUT)) {
! 2284: xmlFreeParserInputBuffer(reader->input);
! 2285: reader->allocs -= XML_TEXTREADER_INPUT;
! 2286: }
! 2287: return(0);
! 2288: }
! 2289:
! 2290: /**
! 2291: * xmlTextReaderGetAttributeNo:
! 2292: * @reader: the xmlTextReaderPtr used
! 2293: * @no: the zero-based index of the attribute relative to the containing element
! 2294: *
! 2295: * Provides the value of the attribute with the specified index relative
! 2296: * to the containing element.
! 2297: *
! 2298: * Returns a string containing the value of the specified attribute, or NULL
! 2299: * in case of error. The string must be deallocated by the caller.
! 2300: */
! 2301: xmlChar *
! 2302: xmlTextReaderGetAttributeNo(xmlTextReaderPtr reader, int no) {
! 2303: xmlChar *ret;
! 2304: int i;
! 2305: xmlAttrPtr cur;
! 2306: xmlNsPtr ns;
! 2307:
! 2308: if (reader == NULL)
! 2309: return(NULL);
! 2310: if (reader->node == NULL)
! 2311: return(NULL);
! 2312: if (reader->curnode != NULL)
! 2313: return(NULL);
! 2314: /* TODO: handle the xmlDecl */
! 2315: if (reader->node->type != XML_ELEMENT_NODE)
! 2316: return(NULL);
! 2317:
! 2318: ns = reader->node->nsDef;
! 2319: for (i = 0;(i < no) && (ns != NULL);i++) {
! 2320: ns = ns->next;
! 2321: }
! 2322: if (ns != NULL)
! 2323: return(xmlStrdup(ns->href));
! 2324:
! 2325: cur = reader->node->properties;
! 2326: if (cur == NULL)
! 2327: return(NULL);
! 2328: for (;i < no;i++) {
! 2329: cur = cur->next;
! 2330: if (cur == NULL)
! 2331: return(NULL);
! 2332: }
! 2333: /* TODO walk the DTD if present */
! 2334:
! 2335: ret = xmlNodeListGetString(reader->node->doc, cur->children, 1);
! 2336: if (ret == NULL) return(xmlStrdup((xmlChar *)""));
! 2337: return(ret);
! 2338: }
! 2339:
! 2340: /**
! 2341: * xmlTextReaderGetAttribute:
! 2342: * @reader: the xmlTextReaderPtr used
! 2343: * @name: the qualified name of the attribute.
! 2344: *
! 2345: * Provides the value of the attribute with the specified qualified name.
! 2346: *
! 2347: * Returns a string containing the value of the specified attribute, or NULL
! 2348: * in case of error. The string must be deallocated by the caller.
! 2349: */
! 2350: xmlChar *
! 2351: xmlTextReaderGetAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
! 2352: xmlChar *prefix = NULL;
! 2353: xmlChar *localname;
! 2354: xmlNsPtr ns;
! 2355: xmlChar *ret = NULL;
! 2356:
! 2357: if ((reader == NULL) || (name == NULL))
! 2358: return(NULL);
! 2359: if (reader->node == NULL)
! 2360: return(NULL);
! 2361: if (reader->curnode != NULL)
! 2362: return(NULL);
! 2363:
! 2364: /* TODO: handle the xmlDecl */
! 2365: if (reader->node->type != XML_ELEMENT_NODE)
! 2366: return(NULL);
! 2367:
! 2368: localname = xmlSplitQName2(name, &prefix);
! 2369: if (localname == NULL) {
! 2370: /*
! 2371: * Namespace default decl
! 2372: */
! 2373: if (xmlStrEqual(name, BAD_CAST "xmlns")) {
! 2374: ns = reader->node->nsDef;
! 2375: while (ns != NULL) {
! 2376: if (ns->prefix == NULL) {
! 2377: return(xmlStrdup(ns->href));
! 2378: }
! 2379: ns = ns->next;
! 2380: }
! 2381: return NULL;
! 2382: }
! 2383: return(xmlGetNoNsProp(reader->node, name));
! 2384: }
! 2385:
! 2386: /*
! 2387: * Namespace default decl
! 2388: */
! 2389: if (xmlStrEqual(prefix, BAD_CAST "xmlns")) {
! 2390: ns = reader->node->nsDef;
! 2391: while (ns != NULL) {
! 2392: if ((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localname))) {
! 2393: ret = xmlStrdup(ns->href);
! 2394: break;
! 2395: }
! 2396: ns = ns->next;
! 2397: }
! 2398: } else {
! 2399: ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
! 2400: if (ns != NULL)
! 2401: ret = xmlGetNsProp(reader->node, localname, ns->href);
! 2402: }
! 2403:
! 2404: xmlFree(localname);
! 2405: if (prefix != NULL)
! 2406: xmlFree(prefix);
! 2407: return(ret);
! 2408: }
! 2409:
! 2410:
! 2411: /**
! 2412: * xmlTextReaderGetAttributeNs:
! 2413: * @reader: the xmlTextReaderPtr used
! 2414: * @localName: the local name of the attribute.
! 2415: * @namespaceURI: the namespace URI of the attribute.
! 2416: *
! 2417: * Provides the value of the specified attribute
! 2418: *
! 2419: * Returns a string containing the value of the specified attribute, or NULL
! 2420: * in case of error. The string must be deallocated by the caller.
! 2421: */
! 2422: xmlChar *
! 2423: xmlTextReaderGetAttributeNs(xmlTextReaderPtr reader, const xmlChar *localName,
! 2424: const xmlChar *namespaceURI) {
! 2425: xmlChar *prefix = NULL;
! 2426: xmlNsPtr ns;
! 2427:
! 2428: if ((reader == NULL) || (localName == NULL))
! 2429: return(NULL);
! 2430: if (reader->node == NULL)
! 2431: return(NULL);
! 2432: if (reader->curnode != NULL)
! 2433: return(NULL);
! 2434:
! 2435: /* TODO: handle the xmlDecl */
! 2436: if (reader->node->type != XML_ELEMENT_NODE)
! 2437: return(NULL);
! 2438:
! 2439: if (xmlStrEqual(namespaceURI, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
! 2440: if (! xmlStrEqual(localName, BAD_CAST "xmlns")) {
! 2441: prefix = BAD_CAST localName;
! 2442: }
! 2443: ns = reader->node->nsDef;
! 2444: while (ns != NULL) {
! 2445: if ((prefix == NULL && ns->prefix == NULL) ||
! 2446: ((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localName)))) {
! 2447: return xmlStrdup(ns->href);
! 2448: }
! 2449: ns = ns->next;
! 2450: }
! 2451: return NULL;
! 2452: }
! 2453:
! 2454: return(xmlGetNsProp(reader->node, localName, namespaceURI));
! 2455: }
! 2456:
! 2457: /**
! 2458: * xmlTextReaderGetRemainder:
! 2459: * @reader: the xmlTextReaderPtr used
! 2460: *
! 2461: * Method to get the remainder of the buffered XML. this method stops the
! 2462: * parser, set its state to End Of File and return the input stream with
! 2463: * what is left that the parser did not use.
! 2464: *
! 2465: * The implementation is not good, the parser certainly procgressed past
! 2466: * what's left in reader->input, and there is an allocation problem. Best
! 2467: * would be to rewrite it differently.
! 2468: *
! 2469: * Returns the xmlParserInputBufferPtr attached to the XML or NULL
! 2470: * in case of error.
! 2471: */
! 2472: xmlParserInputBufferPtr
! 2473: xmlTextReaderGetRemainder(xmlTextReaderPtr reader) {
! 2474: xmlParserInputBufferPtr ret = NULL;
! 2475:
! 2476: if (reader == NULL)
! 2477: return(NULL);
! 2478: if (reader->node == NULL)
! 2479: return(NULL);
! 2480:
! 2481: reader->node = NULL;
! 2482: reader->curnode = NULL;
! 2483: reader->mode = XML_TEXTREADER_MODE_EOF;
! 2484: if (reader->ctxt != NULL) {
! 2485: xmlStopParser(reader->ctxt);
! 2486: if (reader->ctxt->myDoc != NULL) {
! 2487: if (reader->preserve == 0)
! 2488: xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
! 2489: reader->ctxt->myDoc = NULL;
! 2490: }
! 2491: }
! 2492: if (reader->allocs & XML_TEXTREADER_INPUT) {
! 2493: ret = reader->input;
! 2494: reader->input = NULL;
! 2495: reader->allocs -= XML_TEXTREADER_INPUT;
! 2496: } else {
! 2497: /*
! 2498: * Hum, one may need to duplicate the data structure because
! 2499: * without reference counting the input may be freed twice:
! 2500: * - by the layer which allocated it.
! 2501: * - by the layer to which would have been returned to.
! 2502: */
! 2503: TODO
! 2504: return(NULL);
! 2505: }
! 2506: return(ret);
! 2507: }
! 2508:
! 2509: /**
! 2510: * xmlTextReaderLookupNamespace:
! 2511: * @reader: the xmlTextReaderPtr used
! 2512: * @prefix: the prefix whose namespace URI is to be resolved. To return
! 2513: * the default namespace, specify NULL
! 2514: *
! 2515: * Resolves a namespace prefix in the scope of the current element.
! 2516: *
! 2517: * Returns a string containing the namespace URI to which the prefix maps
! 2518: * or NULL in case of error. The string must be deallocated by the caller.
! 2519: */
! 2520: xmlChar *
! 2521: xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, const xmlChar *prefix) {
! 2522: xmlNsPtr ns;
! 2523:
! 2524: if (reader == NULL)
! 2525: return(NULL);
! 2526: if (reader->node == NULL)
! 2527: return(NULL);
! 2528:
! 2529: ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
! 2530: if (ns == NULL)
! 2531: return(NULL);
! 2532: return(xmlStrdup(ns->href));
! 2533: }
! 2534:
! 2535: /**
! 2536: * xmlTextReaderMoveToAttributeNo:
! 2537: * @reader: the xmlTextReaderPtr used
! 2538: * @no: the zero-based index of the attribute relative to the containing
! 2539: * element.
! 2540: *
! 2541: * Moves the position of the current instance to the attribute with
! 2542: * the specified index relative to the containing element.
! 2543: *
! 2544: * Returns 1 in case of success, -1 in case of error, 0 if not found
! 2545: */
! 2546: int
! 2547: xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, int no) {
! 2548: int i;
! 2549: xmlAttrPtr cur;
! 2550: xmlNsPtr ns;
! 2551:
! 2552: if (reader == NULL)
! 2553: return(-1);
! 2554: if (reader->node == NULL)
! 2555: return(-1);
! 2556: /* TODO: handle the xmlDecl */
! 2557: if (reader->node->type != XML_ELEMENT_NODE)
! 2558: return(-1);
! 2559:
! 2560: reader->curnode = NULL;
! 2561:
! 2562: ns = reader->node->nsDef;
! 2563: for (i = 0;(i < no) && (ns != NULL);i++) {
! 2564: ns = ns->next;
! 2565: }
! 2566: if (ns != NULL) {
! 2567: reader->curnode = (xmlNodePtr) ns;
! 2568: return(1);
! 2569: }
! 2570:
! 2571: cur = reader->node->properties;
! 2572: if (cur == NULL)
! 2573: return(0);
! 2574: for (;i < no;i++) {
! 2575: cur = cur->next;
! 2576: if (cur == NULL)
! 2577: return(0);
! 2578: }
! 2579: /* TODO walk the DTD if present */
! 2580:
! 2581: reader->curnode = (xmlNodePtr) cur;
! 2582: return(1);
! 2583: }
! 2584:
! 2585: /**
! 2586: * xmlTextReaderMoveToAttribute:
! 2587: * @reader: the xmlTextReaderPtr used
! 2588: * @name: the qualified name of the attribute.
! 2589: *
! 2590: * Moves the position of the current instance to the attribute with
! 2591: * the specified qualified name.
! 2592: *
! 2593: * Returns 1 in case of success, -1 in case of error, 0 if not found
! 2594: */
! 2595: int
! 2596: xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
! 2597: xmlChar *prefix = NULL;
! 2598: xmlChar *localname;
! 2599: xmlNsPtr ns;
! 2600: xmlAttrPtr prop;
! 2601:
! 2602: if ((reader == NULL) || (name == NULL))
! 2603: return(-1);
! 2604: if (reader->node == NULL)
! 2605: return(-1);
! 2606:
! 2607: /* TODO: handle the xmlDecl */
! 2608: if (reader->node->type != XML_ELEMENT_NODE)
! 2609: return(0);
! 2610:
! 2611: localname = xmlSplitQName2(name, &prefix);
! 2612: if (localname == NULL) {
! 2613: /*
! 2614: * Namespace default decl
! 2615: */
! 2616: if (xmlStrEqual(name, BAD_CAST "xmlns")) {
! 2617: ns = reader->node->nsDef;
! 2618: while (ns != NULL) {
! 2619: if (ns->prefix == NULL) {
! 2620: reader->curnode = (xmlNodePtr) ns;
! 2621: return(1);
! 2622: }
! 2623: ns = ns->next;
! 2624: }
! 2625: return(0);
! 2626: }
! 2627:
! 2628: prop = reader->node->properties;
! 2629: while (prop != NULL) {
! 2630: /*
! 2631: * One need to have
! 2632: * - same attribute names
! 2633: * - and the attribute carrying that namespace
! 2634: */
! 2635: if ((xmlStrEqual(prop->name, name)) &&
! 2636: ((prop->ns == NULL) || (prop->ns->prefix == NULL))) {
! 2637: reader->curnode = (xmlNodePtr) prop;
! 2638: return(1);
! 2639: }
! 2640: prop = prop->next;
! 2641: }
! 2642: return(0);
! 2643: }
! 2644:
! 2645: /*
! 2646: * Namespace default decl
! 2647: */
! 2648: if (xmlStrEqual(prefix, BAD_CAST "xmlns")) {
! 2649: ns = reader->node->nsDef;
! 2650: while (ns != NULL) {
! 2651: if ((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localname))) {
! 2652: reader->curnode = (xmlNodePtr) ns;
! 2653: goto found;
! 2654: }
! 2655: ns = ns->next;
! 2656: }
! 2657: goto not_found;
! 2658: }
! 2659: prop = reader->node->properties;
! 2660: while (prop != NULL) {
! 2661: /*
! 2662: * One need to have
! 2663: * - same attribute names
! 2664: * - and the attribute carrying that namespace
! 2665: */
! 2666: if ((xmlStrEqual(prop->name, localname)) &&
! 2667: (prop->ns != NULL) && (xmlStrEqual(prop->ns->prefix, prefix))) {
! 2668: reader->curnode = (xmlNodePtr) prop;
! 2669: goto found;
! 2670: }
! 2671: prop = prop->next;
! 2672: }
! 2673: not_found:
! 2674: if (localname != NULL)
! 2675: xmlFree(localname);
! 2676: if (prefix != NULL)
! 2677: xmlFree(prefix);
! 2678: return(0);
! 2679:
! 2680: found:
! 2681: if (localname != NULL)
! 2682: xmlFree(localname);
! 2683: if (prefix != NULL)
! 2684: xmlFree(prefix);
! 2685: return(1);
! 2686: }
! 2687:
! 2688: /**
! 2689: * xmlTextReaderMoveToAttributeNs:
! 2690: * @reader: the xmlTextReaderPtr used
! 2691: * @localName: the local name of the attribute.
! 2692: * @namespaceURI: the namespace URI of the attribute.
! 2693: *
! 2694: * Moves the position of the current instance to the attribute with the
! 2695: * specified local name and namespace URI.
! 2696: *
! 2697: * Returns 1 in case of success, -1 in case of error, 0 if not found
! 2698: */
! 2699: int
! 2700: xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
! 2701: const xmlChar *localName, const xmlChar *namespaceURI) {
! 2702: xmlAttrPtr prop;
! 2703: xmlNodePtr node;
! 2704: xmlNsPtr ns;
! 2705: xmlChar *prefix = NULL;
! 2706:
! 2707: if ((reader == NULL) || (localName == NULL) || (namespaceURI == NULL))
! 2708: return(-1);
! 2709: if (reader->node == NULL)
! 2710: return(-1);
! 2711: if (reader->node->type != XML_ELEMENT_NODE)
! 2712: return(0);
! 2713: node = reader->node;
! 2714:
! 2715: if (xmlStrEqual(namespaceURI, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
! 2716: if (! xmlStrEqual(localName, BAD_CAST "xmlns")) {
! 2717: prefix = BAD_CAST localName;
! 2718: }
! 2719: ns = reader->node->nsDef;
! 2720: while (ns != NULL) {
! 2721: if ((prefix == NULL && ns->prefix == NULL) ||
! 2722: ((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localName)))) {
! 2723: reader->curnode = (xmlNodePtr) ns;
! 2724: return(1);
! 2725: }
! 2726: ns = ns->next;
! 2727: }
! 2728: return(0);
! 2729: }
! 2730:
! 2731: prop = node->properties;
! 2732: while (prop != NULL) {
! 2733: /*
! 2734: * One need to have
! 2735: * - same attribute names
! 2736: * - and the attribute carrying that namespace
! 2737: */
! 2738: if (xmlStrEqual(prop->name, localName) &&
! 2739: ((prop->ns != NULL) &&
! 2740: (xmlStrEqual(prop->ns->href, namespaceURI)))) {
! 2741: reader->curnode = (xmlNodePtr) prop;
! 2742: return(1);
! 2743: }
! 2744: prop = prop->next;
! 2745: }
! 2746: return(0);
! 2747: }
! 2748:
! 2749: /**
! 2750: * xmlTextReaderMoveToFirstAttribute:
! 2751: * @reader: the xmlTextReaderPtr used
! 2752: *
! 2753: * Moves the position of the current instance to the first attribute
! 2754: * associated with the current node.
! 2755: *
! 2756: * Returns 1 in case of success, -1 in case of error, 0 if not found
! 2757: */
! 2758: int
! 2759: xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader) {
! 2760: if (reader == NULL)
! 2761: return(-1);
! 2762: if (reader->node == NULL)
! 2763: return(-1);
! 2764: if (reader->node->type != XML_ELEMENT_NODE)
! 2765: return(0);
! 2766:
! 2767: if (reader->node->nsDef != NULL) {
! 2768: reader->curnode = (xmlNodePtr) reader->node->nsDef;
! 2769: return(1);
! 2770: }
! 2771: if (reader->node->properties != NULL) {
! 2772: reader->curnode = (xmlNodePtr) reader->node->properties;
! 2773: return(1);
! 2774: }
! 2775: return(0);
! 2776: }
! 2777:
! 2778: /**
! 2779: * xmlTextReaderMoveToNextAttribute:
! 2780: * @reader: the xmlTextReaderPtr used
! 2781: *
! 2782: * Moves the position of the current instance to the next attribute
! 2783: * associated with the current node.
! 2784: *
! 2785: * Returns 1 in case of success, -1 in case of error, 0 if not found
! 2786: */
! 2787: int
! 2788: xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader) {
! 2789: if (reader == NULL)
! 2790: return(-1);
! 2791: if (reader->node == NULL)
! 2792: return(-1);
! 2793: if (reader->node->type != XML_ELEMENT_NODE)
! 2794: return(0);
! 2795: if (reader->curnode == NULL)
! 2796: return(xmlTextReaderMoveToFirstAttribute(reader));
! 2797:
! 2798: if (reader->curnode->type == XML_NAMESPACE_DECL) {
! 2799: xmlNsPtr ns = (xmlNsPtr) reader->curnode;
! 2800: if (ns->next != NULL) {
! 2801: reader->curnode = (xmlNodePtr) ns->next;
! 2802: return(1);
! 2803: }
! 2804: if (reader->node->properties != NULL) {
! 2805: reader->curnode = (xmlNodePtr) reader->node->properties;
! 2806: return(1);
! 2807: }
! 2808: return(0);
! 2809: } else if ((reader->curnode->type == XML_ATTRIBUTE_NODE) &&
! 2810: (reader->curnode->next != NULL)) {
! 2811: reader->curnode = reader->curnode->next;
! 2812: return(1);
! 2813: }
! 2814: return(0);
! 2815: }
! 2816:
! 2817: /**
! 2818: * xmlTextReaderMoveToElement:
! 2819: * @reader: the xmlTextReaderPtr used
! 2820: *
! 2821: * Moves the position of the current instance to the node that
! 2822: * contains the current Attribute node.
! 2823: *
! 2824: * Returns 1 in case of success, -1 in case of error, 0 if not moved
! 2825: */
! 2826: int
! 2827: xmlTextReaderMoveToElement(xmlTextReaderPtr reader) {
! 2828: if (reader == NULL)
! 2829: return(-1);
! 2830: if (reader->node == NULL)
! 2831: return(-1);
! 2832: if (reader->node->type != XML_ELEMENT_NODE)
! 2833: return(0);
! 2834: if (reader->curnode != NULL) {
! 2835: reader->curnode = NULL;
! 2836: return(1);
! 2837: }
! 2838: return(0);
! 2839: }
! 2840:
! 2841: /**
! 2842: * xmlTextReaderReadAttributeValue:
! 2843: * @reader: the xmlTextReaderPtr used
! 2844: *
! 2845: * Parses an attribute value into one or more Text and EntityReference nodes.
! 2846: *
! 2847: * Returns 1 in case of success, 0 if the reader was not positionned on an
! 2848: * ttribute node or all the attribute values have been read, or -1
! 2849: * in case of error.
! 2850: */
! 2851: int
! 2852: xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader) {
! 2853: if (reader == NULL)
! 2854: return(-1);
! 2855: if (reader->node == NULL)
! 2856: return(-1);
! 2857: if (reader->curnode == NULL)
! 2858: return(0);
! 2859: if (reader->curnode->type == XML_ATTRIBUTE_NODE) {
! 2860: if (reader->curnode->children == NULL)
! 2861: return(0);
! 2862: reader->curnode = reader->curnode->children;
! 2863: } else if (reader->curnode->type == XML_NAMESPACE_DECL) {
! 2864: xmlNsPtr ns = (xmlNsPtr) reader->curnode;
! 2865:
! 2866: if (reader->faketext == NULL) {
! 2867: reader->faketext = xmlNewDocText(reader->node->doc,
! 2868: ns->href);
! 2869: } else {
! 2870: if ((reader->faketext->content != NULL) &&
! 2871: (reader->faketext->content !=
! 2872: (xmlChar *) &(reader->faketext->properties)))
! 2873: xmlFree(reader->faketext->content);
! 2874: reader->faketext->content = xmlStrdup(ns->href);
! 2875: }
! 2876: reader->curnode = reader->faketext;
! 2877: } else {
! 2878: if (reader->curnode->next == NULL)
! 2879: return(0);
! 2880: reader->curnode = reader->curnode->next;
! 2881: }
! 2882: return(1);
! 2883: }
! 2884:
! 2885: /**
! 2886: * xmlTextReaderConstEncoding:
! 2887: * @reader: the xmlTextReaderPtr used
! 2888: *
! 2889: * Determine the encoding of the document being read.
! 2890: *
! 2891: * Returns a string containing the encoding of the document or NULL in
! 2892: * case of error. The string is deallocated with the reader.
! 2893: */
! 2894: const xmlChar *
! 2895: xmlTextReaderConstEncoding(xmlTextReaderPtr reader) {
! 2896: xmlDocPtr doc = NULL;
! 2897: if (reader == NULL)
! 2898: return(NULL);
! 2899: if (reader->doc != NULL)
! 2900: doc = reader->doc;
! 2901: else if (reader->ctxt != NULL)
! 2902: doc = reader->ctxt->myDoc;
! 2903: if (doc == NULL)
! 2904: return(NULL);
! 2905:
! 2906: if (doc->encoding == NULL)
! 2907: return(NULL);
! 2908: else
! 2909: return(CONSTSTR(doc->encoding));
! 2910: }
! 2911:
! 2912:
! 2913: /************************************************************************
! 2914: * *
! 2915: * Acces API to the current node *
! 2916: * *
! 2917: ************************************************************************/
! 2918: /**
! 2919: * xmlTextReaderAttributeCount:
! 2920: * @reader: the xmlTextReaderPtr used
! 2921: *
! 2922: * Provides the number of attributes of the current node
! 2923: *
! 2924: * Returns 0 i no attributes, -1 in case of error or the attribute count
! 2925: */
! 2926: int
! 2927: xmlTextReaderAttributeCount(xmlTextReaderPtr reader) {
! 2928: int ret;
! 2929: xmlAttrPtr attr;
! 2930: xmlNsPtr ns;
! 2931: xmlNodePtr node;
! 2932:
! 2933: if (reader == NULL)
! 2934: return(-1);
! 2935: if (reader->node == NULL)
! 2936: return(0);
! 2937:
! 2938: if (reader->curnode != NULL)
! 2939: node = reader->curnode;
! 2940: else
! 2941: node = reader->node;
! 2942:
! 2943: if (node->type != XML_ELEMENT_NODE)
! 2944: return(0);
! 2945: if ((reader->state == XML_TEXTREADER_END) ||
! 2946: (reader->state == XML_TEXTREADER_BACKTRACK))
! 2947: return(0);
! 2948: ret = 0;
! 2949: attr = node->properties;
! 2950: while (attr != NULL) {
! 2951: ret++;
! 2952: attr = attr->next;
! 2953: }
! 2954: ns = node->nsDef;
! 2955: while (ns != NULL) {
! 2956: ret++;
! 2957: ns = ns->next;
! 2958: }
! 2959: return(ret);
! 2960: }
! 2961:
! 2962: /**
! 2963: * xmlTextReaderNodeType:
! 2964: * @reader: the xmlTextReaderPtr used
! 2965: *
! 2966: * Get the node type of the current node
! 2967: * Reference:
! 2968: * http://www.gnu.org/software/dotgnu/pnetlib-doc/System/Xml/XmlNodeType.html
! 2969: *
! 2970: * Returns the xmlNodeType of the current node or -1 in case of error
! 2971: */
! 2972: int
! 2973: xmlTextReaderNodeType(xmlTextReaderPtr reader) {
! 2974: xmlNodePtr node;
! 2975:
! 2976: if (reader == NULL)
! 2977: return(-1);
! 2978: if (reader->node == NULL)
! 2979: return(XML_READER_TYPE_NONE);
! 2980: if (reader->curnode != NULL)
! 2981: node = reader->curnode;
! 2982: else
! 2983: node = reader->node;
! 2984: switch (node->type) {
! 2985: case XML_ELEMENT_NODE:
! 2986: if ((reader->state == XML_TEXTREADER_END) ||
! 2987: (reader->state == XML_TEXTREADER_BACKTRACK))
! 2988: return(XML_READER_TYPE_END_ELEMENT);
! 2989: return(XML_READER_TYPE_ELEMENT);
! 2990: case XML_NAMESPACE_DECL:
! 2991: case XML_ATTRIBUTE_NODE:
! 2992: return(XML_READER_TYPE_ATTRIBUTE);
! 2993: case XML_TEXT_NODE:
! 2994: if (xmlIsBlankNode(reader->node)) {
! 2995: if (xmlNodeGetSpacePreserve(reader->node))
! 2996: return(XML_READER_TYPE_SIGNIFICANT_WHITESPACE);
! 2997: else
! 2998: return(XML_READER_TYPE_WHITESPACE);
! 2999: } else {
! 3000: return(XML_READER_TYPE_TEXT);
! 3001: }
! 3002: case XML_CDATA_SECTION_NODE:
! 3003: return(XML_READER_TYPE_CDATA);
! 3004: case XML_ENTITY_REF_NODE:
! 3005: return(XML_READER_TYPE_ENTITY_REFERENCE);
! 3006: case XML_ENTITY_NODE:
! 3007: return(XML_READER_TYPE_ENTITY);
! 3008: case XML_PI_NODE:
! 3009: return(XML_READER_TYPE_PROCESSING_INSTRUCTION);
! 3010: case XML_COMMENT_NODE:
! 3011: return(XML_READER_TYPE_COMMENT);
! 3012: case XML_DOCUMENT_NODE:
! 3013: case XML_HTML_DOCUMENT_NODE:
! 3014: #ifdef LIBXML_DOCB_ENABLED
! 3015: case XML_DOCB_DOCUMENT_NODE:
! 3016: #endif
! 3017: return(XML_READER_TYPE_DOCUMENT);
! 3018: case XML_DOCUMENT_FRAG_NODE:
! 3019: return(XML_READER_TYPE_DOCUMENT_FRAGMENT);
! 3020: case XML_NOTATION_NODE:
! 3021: return(XML_READER_TYPE_NOTATION);
! 3022: case XML_DOCUMENT_TYPE_NODE:
! 3023: case XML_DTD_NODE:
! 3024: return(XML_READER_TYPE_DOCUMENT_TYPE);
! 3025:
! 3026: case XML_ELEMENT_DECL:
! 3027: case XML_ATTRIBUTE_DECL:
! 3028: case XML_ENTITY_DECL:
! 3029: case XML_XINCLUDE_START:
! 3030: case XML_XINCLUDE_END:
! 3031: return(XML_READER_TYPE_NONE);
! 3032: }
! 3033: return(-1);
! 3034: }
! 3035:
! 3036: /**
! 3037: * xmlTextReaderIsEmptyElement:
! 3038: * @reader: the xmlTextReaderPtr used
! 3039: *
! 3040: * Check if the current node is empty
! 3041: *
! 3042: * Returns 1 if empty, 0 if not and -1 in case of error
! 3043: */
! 3044: int
! 3045: xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader) {
! 3046: if ((reader == NULL) || (reader->node == NULL))
! 3047: return(-1);
! 3048: if (reader->node->type != XML_ELEMENT_NODE)
! 3049: return(0);
! 3050: if (reader->curnode != NULL)
! 3051: return(0);
! 3052: if (reader->node->children != NULL)
! 3053: return(0);
! 3054: if (reader->state == XML_TEXTREADER_END)
! 3055: return(0);
! 3056: if (reader->doc != NULL)
! 3057: return(1);
! 3058: #ifdef LIBXML_XINCLUDE_ENABLED
! 3059: if (reader->in_xinclude > 0)
! 3060: return(1);
! 3061: #endif
! 3062: return((reader->node->extra & NODE_IS_EMPTY) != 0);
! 3063: }
! 3064:
! 3065: /**
! 3066: * xmlTextReaderLocalName:
! 3067: * @reader: the xmlTextReaderPtr used
! 3068: *
! 3069: * The local name of the node.
! 3070: *
! 3071: * Returns the local name or NULL if not available,
! 3072: * if non NULL it need to be freed by the caller.
! 3073: */
! 3074: xmlChar *
! 3075: xmlTextReaderLocalName(xmlTextReaderPtr reader) {
! 3076: xmlNodePtr node;
! 3077: if ((reader == NULL) || (reader->node == NULL))
! 3078: return(NULL);
! 3079: if (reader->curnode != NULL)
! 3080: node = reader->curnode;
! 3081: else
! 3082: node = reader->node;
! 3083: if (node->type == XML_NAMESPACE_DECL) {
! 3084: xmlNsPtr ns = (xmlNsPtr) node;
! 3085: if (ns->prefix == NULL)
! 3086: return(xmlStrdup(BAD_CAST "xmlns"));
! 3087: else
! 3088: return(xmlStrdup(ns->prefix));
! 3089: }
! 3090: if ((node->type != XML_ELEMENT_NODE) &&
! 3091: (node->type != XML_ATTRIBUTE_NODE))
! 3092: return(xmlTextReaderName(reader));
! 3093: return(xmlStrdup(node->name));
! 3094: }
! 3095:
! 3096: /**
! 3097: * xmlTextReaderConstLocalName:
! 3098: * @reader: the xmlTextReaderPtr used
! 3099: *
! 3100: * The local name of the node.
! 3101: *
! 3102: * Returns the local name or NULL if not available, the
! 3103: * string will be deallocated with the reader.
! 3104: */
! 3105: const xmlChar *
! 3106: xmlTextReaderConstLocalName(xmlTextReaderPtr reader) {
! 3107: xmlNodePtr node;
! 3108: if ((reader == NULL) || (reader->node == NULL))
! 3109: return(NULL);
! 3110: if (reader->curnode != NULL)
! 3111: node = reader->curnode;
! 3112: else
! 3113: node = reader->node;
! 3114: if (node->type == XML_NAMESPACE_DECL) {
! 3115: xmlNsPtr ns = (xmlNsPtr) node;
! 3116: if (ns->prefix == NULL)
! 3117: return(CONSTSTR(BAD_CAST "xmlns"));
! 3118: else
! 3119: return(ns->prefix);
! 3120: }
! 3121: if ((node->type != XML_ELEMENT_NODE) &&
! 3122: (node->type != XML_ATTRIBUTE_NODE))
! 3123: return(xmlTextReaderConstName(reader));
! 3124: return(node->name);
! 3125: }
! 3126:
! 3127: /**
! 3128: * xmlTextReaderName:
! 3129: * @reader: the xmlTextReaderPtr used
! 3130: *
! 3131: * The qualified name of the node, equal to Prefix :LocalName.
! 3132: *
! 3133: * Returns the local name or NULL if not available,
! 3134: * if non NULL it need to be freed by the caller.
! 3135: */
! 3136: xmlChar *
! 3137: xmlTextReaderName(xmlTextReaderPtr reader) {
! 3138: xmlNodePtr node;
! 3139: xmlChar *ret;
! 3140:
! 3141: if ((reader == NULL) || (reader->node == NULL))
! 3142: return(NULL);
! 3143: if (reader->curnode != NULL)
! 3144: node = reader->curnode;
! 3145: else
! 3146: node = reader->node;
! 3147: switch (node->type) {
! 3148: case XML_ELEMENT_NODE:
! 3149: case XML_ATTRIBUTE_NODE:
! 3150: if ((node->ns == NULL) ||
! 3151: (node->ns->prefix == NULL))
! 3152: return(xmlStrdup(node->name));
! 3153:
! 3154: ret = xmlStrdup(node->ns->prefix);
! 3155: ret = xmlStrcat(ret, BAD_CAST ":");
! 3156: ret = xmlStrcat(ret, node->name);
! 3157: return(ret);
! 3158: case XML_TEXT_NODE:
! 3159: return(xmlStrdup(BAD_CAST "#text"));
! 3160: case XML_CDATA_SECTION_NODE:
! 3161: return(xmlStrdup(BAD_CAST "#cdata-section"));
! 3162: case XML_ENTITY_NODE:
! 3163: case XML_ENTITY_REF_NODE:
! 3164: return(xmlStrdup(node->name));
! 3165: case XML_PI_NODE:
! 3166: return(xmlStrdup(node->name));
! 3167: case XML_COMMENT_NODE:
! 3168: return(xmlStrdup(BAD_CAST "#comment"));
! 3169: case XML_DOCUMENT_NODE:
! 3170: case XML_HTML_DOCUMENT_NODE:
! 3171: #ifdef LIBXML_DOCB_ENABLED
! 3172: case XML_DOCB_DOCUMENT_NODE:
! 3173: #endif
! 3174: return(xmlStrdup(BAD_CAST "#document"));
! 3175: case XML_DOCUMENT_FRAG_NODE:
! 3176: return(xmlStrdup(BAD_CAST "#document-fragment"));
! 3177: case XML_NOTATION_NODE:
! 3178: return(xmlStrdup(node->name));
! 3179: case XML_DOCUMENT_TYPE_NODE:
! 3180: case XML_DTD_NODE:
! 3181: return(xmlStrdup(node->name));
! 3182: case XML_NAMESPACE_DECL: {
! 3183: xmlNsPtr ns = (xmlNsPtr) node;
! 3184:
! 3185: ret = xmlStrdup(BAD_CAST "xmlns");
! 3186: if (ns->prefix == NULL)
! 3187: return(ret);
! 3188: ret = xmlStrcat(ret, BAD_CAST ":");
! 3189: ret = xmlStrcat(ret, ns->prefix);
! 3190: return(ret);
! 3191: }
! 3192:
! 3193: case XML_ELEMENT_DECL:
! 3194: case XML_ATTRIBUTE_DECL:
! 3195: case XML_ENTITY_DECL:
! 3196: case XML_XINCLUDE_START:
! 3197: case XML_XINCLUDE_END:
! 3198: return(NULL);
! 3199: }
! 3200: return(NULL);
! 3201: }
! 3202:
! 3203: /**
! 3204: * xmlTextReaderConstName:
! 3205: * @reader: the xmlTextReaderPtr used
! 3206: *
! 3207: * The qualified name of the node, equal to Prefix :LocalName.
! 3208: *
! 3209: * Returns the local name or NULL if not available, the string is
! 3210: * deallocated with the reader.
! 3211: */
! 3212: const xmlChar *
! 3213: xmlTextReaderConstName(xmlTextReaderPtr reader) {
! 3214: xmlNodePtr node;
! 3215:
! 3216: if ((reader == NULL) || (reader->node == NULL))
! 3217: return(NULL);
! 3218: if (reader->curnode != NULL)
! 3219: node = reader->curnode;
! 3220: else
! 3221: node = reader->node;
! 3222: switch (node->type) {
! 3223: case XML_ELEMENT_NODE:
! 3224: case XML_ATTRIBUTE_NODE:
! 3225: if ((node->ns == NULL) ||
! 3226: (node->ns->prefix == NULL))
! 3227: return(node->name);
! 3228: return(CONSTQSTR(node->ns->prefix, node->name));
! 3229: case XML_TEXT_NODE:
! 3230: return(CONSTSTR(BAD_CAST "#text"));
! 3231: case XML_CDATA_SECTION_NODE:
! 3232: return(CONSTSTR(BAD_CAST "#cdata-section"));
! 3233: case XML_ENTITY_NODE:
! 3234: case XML_ENTITY_REF_NODE:
! 3235: return(CONSTSTR(node->name));
! 3236: case XML_PI_NODE:
! 3237: return(CONSTSTR(node->name));
! 3238: case XML_COMMENT_NODE:
! 3239: return(CONSTSTR(BAD_CAST "#comment"));
! 3240: case XML_DOCUMENT_NODE:
! 3241: case XML_HTML_DOCUMENT_NODE:
! 3242: #ifdef LIBXML_DOCB_ENABLED
! 3243: case XML_DOCB_DOCUMENT_NODE:
! 3244: #endif
! 3245: return(CONSTSTR(BAD_CAST "#document"));
! 3246: case XML_DOCUMENT_FRAG_NODE:
! 3247: return(CONSTSTR(BAD_CAST "#document-fragment"));
! 3248: case XML_NOTATION_NODE:
! 3249: return(CONSTSTR(node->name));
! 3250: case XML_DOCUMENT_TYPE_NODE:
! 3251: case XML_DTD_NODE:
! 3252: return(CONSTSTR(node->name));
! 3253: case XML_NAMESPACE_DECL: {
! 3254: xmlNsPtr ns = (xmlNsPtr) node;
! 3255:
! 3256: if (ns->prefix == NULL)
! 3257: return(CONSTSTR(BAD_CAST "xmlns"));
! 3258: return(CONSTQSTR(BAD_CAST "xmlns", ns->prefix));
! 3259: }
! 3260:
! 3261: case XML_ELEMENT_DECL:
! 3262: case XML_ATTRIBUTE_DECL:
! 3263: case XML_ENTITY_DECL:
! 3264: case XML_XINCLUDE_START:
! 3265: case XML_XINCLUDE_END:
! 3266: return(NULL);
! 3267: }
! 3268: return(NULL);
! 3269: }
! 3270:
! 3271: /**
! 3272: * xmlTextReaderPrefix:
! 3273: * @reader: the xmlTextReaderPtr used
! 3274: *
! 3275: * A shorthand reference to the namespace associated with the node.
! 3276: *
! 3277: * Returns the prefix or NULL if not available,
! 3278: * if non NULL it need to be freed by the caller.
! 3279: */
! 3280: xmlChar *
! 3281: xmlTextReaderPrefix(xmlTextReaderPtr reader) {
! 3282: xmlNodePtr node;
! 3283: if ((reader == NULL) || (reader->node == NULL))
! 3284: return(NULL);
! 3285: if (reader->curnode != NULL)
! 3286: node = reader->curnode;
! 3287: else
! 3288: node = reader->node;
! 3289: if (node->type == XML_NAMESPACE_DECL) {
! 3290: xmlNsPtr ns = (xmlNsPtr) node;
! 3291: if (ns->prefix == NULL)
! 3292: return(NULL);
! 3293: return(xmlStrdup(BAD_CAST "xmlns"));
! 3294: }
! 3295: if ((node->type != XML_ELEMENT_NODE) &&
! 3296: (node->type != XML_ATTRIBUTE_NODE))
! 3297: return(NULL);
! 3298: if ((node->ns != NULL) && (node->ns->prefix != NULL))
! 3299: return(xmlStrdup(node->ns->prefix));
! 3300: return(NULL);
! 3301: }
! 3302:
! 3303: /**
! 3304: * xmlTextReaderConstPrefix:
! 3305: * @reader: the xmlTextReaderPtr used
! 3306: *
! 3307: * A shorthand reference to the namespace associated with the node.
! 3308: *
! 3309: * Returns the prefix or NULL if not available, the string is deallocated
! 3310: * with the reader.
! 3311: */
! 3312: const xmlChar *
! 3313: xmlTextReaderConstPrefix(xmlTextReaderPtr reader) {
! 3314: xmlNodePtr node;
! 3315: if ((reader == NULL) || (reader->node == NULL))
! 3316: return(NULL);
! 3317: if (reader->curnode != NULL)
! 3318: node = reader->curnode;
! 3319: else
! 3320: node = reader->node;
! 3321: if (node->type == XML_NAMESPACE_DECL) {
! 3322: xmlNsPtr ns = (xmlNsPtr) node;
! 3323: if (ns->prefix == NULL)
! 3324: return(NULL);
! 3325: return(CONSTSTR(BAD_CAST "xmlns"));
! 3326: }
! 3327: if ((node->type != XML_ELEMENT_NODE) &&
! 3328: (node->type != XML_ATTRIBUTE_NODE))
! 3329: return(NULL);
! 3330: if ((node->ns != NULL) && (node->ns->prefix != NULL))
! 3331: return(CONSTSTR(node->ns->prefix));
! 3332: return(NULL);
! 3333: }
! 3334:
! 3335: /**
! 3336: * xmlTextReaderNamespaceUri:
! 3337: * @reader: the xmlTextReaderPtr used
! 3338: *
! 3339: * The URI defining the namespace associated with the node.
! 3340: *
! 3341: * Returns the namespace URI or NULL if not available,
! 3342: * if non NULL it need to be freed by the caller.
! 3343: */
! 3344: xmlChar *
! 3345: xmlTextReaderNamespaceUri(xmlTextReaderPtr reader) {
! 3346: xmlNodePtr node;
! 3347: if ((reader == NULL) || (reader->node == NULL))
! 3348: return(NULL);
! 3349: if (reader->curnode != NULL)
! 3350: node = reader->curnode;
! 3351: else
! 3352: node = reader->node;
! 3353: if (node->type == XML_NAMESPACE_DECL)
! 3354: return(xmlStrdup(BAD_CAST "http://www.w3.org/2000/xmlns/"));
! 3355: if ((node->type != XML_ELEMENT_NODE) &&
! 3356: (node->type != XML_ATTRIBUTE_NODE))
! 3357: return(NULL);
! 3358: if (node->ns != NULL)
! 3359: return(xmlStrdup(node->ns->href));
! 3360: return(NULL);
! 3361: }
! 3362:
! 3363: /**
! 3364: * xmlTextReaderConstNamespaceUri:
! 3365: * @reader: the xmlTextReaderPtr used
! 3366: *
! 3367: * The URI defining the namespace associated with the node.
! 3368: *
! 3369: * Returns the namespace URI or NULL if not available, the string
! 3370: * will be deallocated with the reader
! 3371: */
! 3372: const xmlChar *
! 3373: xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader) {
! 3374: xmlNodePtr node;
! 3375: if ((reader == NULL) || (reader->node == NULL))
! 3376: return(NULL);
! 3377: if (reader->curnode != NULL)
! 3378: node = reader->curnode;
! 3379: else
! 3380: node = reader->node;
! 3381: if (node->type == XML_NAMESPACE_DECL)
! 3382: return(CONSTSTR(BAD_CAST "http://www.w3.org/2000/xmlns/"));
! 3383: if ((node->type != XML_ELEMENT_NODE) &&
! 3384: (node->type != XML_ATTRIBUTE_NODE))
! 3385: return(NULL);
! 3386: if (node->ns != NULL)
! 3387: return(CONSTSTR(node->ns->href));
! 3388: return(NULL);
! 3389: }
! 3390:
! 3391: /**
! 3392: * xmlTextReaderBaseUri:
! 3393: * @reader: the xmlTextReaderPtr used
! 3394: *
! 3395: * The base URI of the node.
! 3396: *
! 3397: * Returns the base URI or NULL if not available,
! 3398: * if non NULL it need to be freed by the caller.
! 3399: */
! 3400: xmlChar *
! 3401: xmlTextReaderBaseUri(xmlTextReaderPtr reader) {
! 3402: if ((reader == NULL) || (reader->node == NULL))
! 3403: return(NULL);
! 3404: return(xmlNodeGetBase(NULL, reader->node));
! 3405: }
! 3406:
! 3407: /**
! 3408: * xmlTextReaderConstBaseUri:
! 3409: * @reader: the xmlTextReaderPtr used
! 3410: *
! 3411: * The base URI of the node.
! 3412: *
! 3413: * Returns the base URI or NULL if not available, the string
! 3414: * will be deallocated with the reader
! 3415: */
! 3416: const xmlChar *
! 3417: xmlTextReaderConstBaseUri(xmlTextReaderPtr reader) {
! 3418: xmlChar *tmp;
! 3419: const xmlChar *ret;
! 3420:
! 3421: if ((reader == NULL) || (reader->node == NULL))
! 3422: return(NULL);
! 3423: tmp = xmlNodeGetBase(NULL, reader->node);
! 3424: if (tmp == NULL)
! 3425: return(NULL);
! 3426: ret = CONSTSTR(tmp);
! 3427: xmlFree(tmp);
! 3428: return(ret);
! 3429: }
! 3430:
! 3431: /**
! 3432: * xmlTextReaderDepth:
! 3433: * @reader: the xmlTextReaderPtr used
! 3434: *
! 3435: * The depth of the node in the tree.
! 3436: *
! 3437: * Returns the depth or -1 in case of error
! 3438: */
! 3439: int
! 3440: xmlTextReaderDepth(xmlTextReaderPtr reader) {
! 3441: if (reader == NULL)
! 3442: return(-1);
! 3443: if (reader->node == NULL)
! 3444: return(0);
! 3445:
! 3446: if (reader->curnode != NULL) {
! 3447: if ((reader->curnode->type == XML_ATTRIBUTE_NODE) ||
! 3448: (reader->curnode->type == XML_NAMESPACE_DECL))
! 3449: return(reader->depth + 1);
! 3450: return(reader->depth + 2);
! 3451: }
! 3452: return(reader->depth);
! 3453: }
! 3454:
! 3455: /**
! 3456: * xmlTextReaderHasAttributes:
! 3457: * @reader: the xmlTextReaderPtr used
! 3458: *
! 3459: * Whether the node has attributes.
! 3460: *
! 3461: * Returns 1 if true, 0 if false, and -1 in case or error
! 3462: */
! 3463: int
! 3464: xmlTextReaderHasAttributes(xmlTextReaderPtr reader) {
! 3465: xmlNodePtr node;
! 3466: if (reader == NULL)
! 3467: return(-1);
! 3468: if (reader->node == NULL)
! 3469: return(0);
! 3470: if (reader->curnode != NULL)
! 3471: node = reader->curnode;
! 3472: else
! 3473: node = reader->node;
! 3474:
! 3475: if ((node->type == XML_ELEMENT_NODE) &&
! 3476: ((node->properties != NULL) || (node->nsDef != NULL)))
! 3477: return(1);
! 3478: /* TODO: handle the xmlDecl */
! 3479: return(0);
! 3480: }
! 3481:
! 3482: /**
! 3483: * xmlTextReaderHasValue:
! 3484: * @reader: the xmlTextReaderPtr used
! 3485: *
! 3486: * Whether the node can have a text value.
! 3487: *
! 3488: * Returns 1 if true, 0 if false, and -1 in case or error
! 3489: */
! 3490: int
! 3491: xmlTextReaderHasValue(xmlTextReaderPtr reader) {
! 3492: xmlNodePtr node;
! 3493: if (reader == NULL)
! 3494: return(-1);
! 3495: if (reader->node == NULL)
! 3496: return(0);
! 3497: if (reader->curnode != NULL)
! 3498: node = reader->curnode;
! 3499: else
! 3500: node = reader->node;
! 3501:
! 3502: switch (node->type) {
! 3503: case XML_ATTRIBUTE_NODE:
! 3504: case XML_TEXT_NODE:
! 3505: case XML_CDATA_SECTION_NODE:
! 3506: case XML_PI_NODE:
! 3507: case XML_COMMENT_NODE:
! 3508: case XML_NAMESPACE_DECL:
! 3509: return(1);
! 3510: default:
! 3511: break;
! 3512: }
! 3513: return(0);
! 3514: }
! 3515:
! 3516: /**
! 3517: * xmlTextReaderValue:
! 3518: * @reader: the xmlTextReaderPtr used
! 3519: *
! 3520: * Provides the text value of the node if present
! 3521: *
! 3522: * Returns the string or NULL if not available. The result must be deallocated
! 3523: * with xmlFree()
! 3524: */
! 3525: xmlChar *
! 3526: xmlTextReaderValue(xmlTextReaderPtr reader) {
! 3527: xmlNodePtr node;
! 3528: if (reader == NULL)
! 3529: return(NULL);
! 3530: if (reader->node == NULL)
! 3531: return(NULL);
! 3532: if (reader->curnode != NULL)
! 3533: node = reader->curnode;
! 3534: else
! 3535: node = reader->node;
! 3536:
! 3537: switch (node->type) {
! 3538: case XML_NAMESPACE_DECL:
! 3539: return(xmlStrdup(((xmlNsPtr) node)->href));
! 3540: case XML_ATTRIBUTE_NODE:{
! 3541: xmlAttrPtr attr = (xmlAttrPtr) node;
! 3542:
! 3543: if (attr->parent != NULL)
! 3544: return (xmlNodeListGetString
! 3545: (attr->parent->doc, attr->children, 1));
! 3546: else
! 3547: return (xmlNodeListGetString(NULL, attr->children, 1));
! 3548: break;
! 3549: }
! 3550: case XML_TEXT_NODE:
! 3551: case XML_CDATA_SECTION_NODE:
! 3552: case XML_PI_NODE:
! 3553: case XML_COMMENT_NODE:
! 3554: if (node->content != NULL)
! 3555: return (xmlStrdup(node->content));
! 3556: default:
! 3557: break;
! 3558: }
! 3559: return(NULL);
! 3560: }
! 3561:
! 3562: /**
! 3563: * xmlTextReaderConstValue:
! 3564: * @reader: the xmlTextReaderPtr used
! 3565: *
! 3566: * Provides the text value of the node if present
! 3567: *
! 3568: * Returns the string or NULL if not available. The result will be
! 3569: * deallocated on the next Read() operation.
! 3570: */
! 3571: const xmlChar *
! 3572: xmlTextReaderConstValue(xmlTextReaderPtr reader) {
! 3573: xmlNodePtr node;
! 3574: if (reader == NULL)
! 3575: return(NULL);
! 3576: if (reader->node == NULL)
! 3577: return(NULL);
! 3578: if (reader->curnode != NULL)
! 3579: node = reader->curnode;
! 3580: else
! 3581: node = reader->node;
! 3582:
! 3583: switch (node->type) {
! 3584: case XML_NAMESPACE_DECL:
! 3585: return(((xmlNsPtr) node)->href);
! 3586: case XML_ATTRIBUTE_NODE:{
! 3587: xmlAttrPtr attr = (xmlAttrPtr) node;
! 3588:
! 3589: if ((attr->children != NULL) &&
! 3590: (attr->children->type == XML_TEXT_NODE) &&
! 3591: (attr->children->next == NULL))
! 3592: return(attr->children->content);
! 3593: else {
! 3594: if (reader->buffer == NULL)
! 3595: reader->buffer = xmlBufferCreateSize(100);
! 3596: if (reader->buffer == NULL) {
! 3597: xmlGenericError(xmlGenericErrorContext,
! 3598: "xmlTextReaderSetup : malloc failed\n");
! 3599: return (NULL);
! 3600: }
! 3601: reader->buffer->use = 0;
! 3602: xmlNodeBufGetContent(reader->buffer, node);
! 3603: return(reader->buffer->content);
! 3604: }
! 3605: break;
! 3606: }
! 3607: case XML_TEXT_NODE:
! 3608: case XML_CDATA_SECTION_NODE:
! 3609: case XML_PI_NODE:
! 3610: case XML_COMMENT_NODE:
! 3611: return(node->content);
! 3612: default:
! 3613: break;
! 3614: }
! 3615: return(NULL);
! 3616: }
! 3617:
! 3618: /**
! 3619: * xmlTextReaderIsDefault:
! 3620: * @reader: the xmlTextReaderPtr used
! 3621: *
! 3622: * Whether an Attribute node was generated from the default value
! 3623: * defined in the DTD or schema.
! 3624: *
! 3625: * Returns 0 if not defaulted, 1 if defaulted, and -1 in case of error
! 3626: */
! 3627: int
! 3628: xmlTextReaderIsDefault(xmlTextReaderPtr reader) {
! 3629: if (reader == NULL)
! 3630: return(-1);
! 3631: return(0);
! 3632: }
! 3633:
! 3634: /**
! 3635: * xmlTextReaderQuoteChar:
! 3636: * @reader: the xmlTextReaderPtr used
! 3637: *
! 3638: * The quotation mark character used to enclose the value of an attribute.
! 3639: *
! 3640: * Returns " or ' and -1 in case of error
! 3641: */
! 3642: int
! 3643: xmlTextReaderQuoteChar(xmlTextReaderPtr reader) {
! 3644: if (reader == NULL)
! 3645: return(-1);
! 3646: /* TODO maybe lookup the attribute value for " first */
! 3647: return((int) '"');
! 3648: }
! 3649:
! 3650: /**
! 3651: * xmlTextReaderXmlLang:
! 3652: * @reader: the xmlTextReaderPtr used
! 3653: *
! 3654: * The xml:lang scope within which the node resides.
! 3655: *
! 3656: * Returns the xml:lang value or NULL if none exists.,
! 3657: * if non NULL it need to be freed by the caller.
! 3658: */
! 3659: xmlChar *
! 3660: xmlTextReaderXmlLang(xmlTextReaderPtr reader) {
! 3661: if (reader == NULL)
! 3662: return(NULL);
! 3663: if (reader->node == NULL)
! 3664: return(NULL);
! 3665: return(xmlNodeGetLang(reader->node));
! 3666: }
! 3667:
! 3668: /**
! 3669: * xmlTextReaderConstXmlLang:
! 3670: * @reader: the xmlTextReaderPtr used
! 3671: *
! 3672: * The xml:lang scope within which the node resides.
! 3673: *
! 3674: * Returns the xml:lang value or NULL if none exists.
! 3675: */
! 3676: const xmlChar *
! 3677: xmlTextReaderConstXmlLang(xmlTextReaderPtr reader) {
! 3678: xmlChar *tmp;
! 3679: const xmlChar *ret;
! 3680:
! 3681: if (reader == NULL)
! 3682: return(NULL);
! 3683: if (reader->node == NULL)
! 3684: return(NULL);
! 3685: tmp = xmlNodeGetLang(reader->node);
! 3686: if (tmp == NULL)
! 3687: return(NULL);
! 3688: ret = CONSTSTR(tmp);
! 3689: xmlFree(tmp);
! 3690: return(ret);
! 3691: }
! 3692:
! 3693: /**
! 3694: * xmlTextReaderConstString:
! 3695: * @reader: the xmlTextReaderPtr used
! 3696: * @str: the string to intern.
! 3697: *
! 3698: * Get an interned string from the reader, allows for example to
! 3699: * speedup string name comparisons
! 3700: *
! 3701: * Returns an interned copy of the string or NULL in case of error. The
! 3702: * string will be deallocated with the reader.
! 3703: */
! 3704: const xmlChar *
! 3705: xmlTextReaderConstString(xmlTextReaderPtr reader, const xmlChar *str) {
! 3706: if (reader == NULL)
! 3707: return(NULL);
! 3708: return(CONSTSTR(str));
! 3709: }
! 3710:
! 3711: /**
! 3712: * xmlTextReaderNormalization:
! 3713: * @reader: the xmlTextReaderPtr used
! 3714: *
! 3715: * The value indicating whether to normalize white space and attribute values.
! 3716: * Since attribute value and end of line normalizations are a MUST in the XML
! 3717: * specification only the value true is accepted. The broken bahaviour of
! 3718: * accepting out of range character entities like � is of course not
! 3719: * supported either.
! 3720: *
! 3721: * Returns 1 or -1 in case of error.
! 3722: */
! 3723: int
! 3724: xmlTextReaderNormalization(xmlTextReaderPtr reader) {
! 3725: if (reader == NULL)
! 3726: return(-1);
! 3727: return(1);
! 3728: }
! 3729:
! 3730: /************************************************************************
! 3731: * *
! 3732: * Extensions to the base APIs *
! 3733: * *
! 3734: ************************************************************************/
! 3735:
! 3736: /**
! 3737: * xmlTextReaderSetParserProp:
! 3738: * @reader: the xmlTextReaderPtr used
! 3739: * @prop: the xmlParserProperties to set
! 3740: * @value: usually 0 or 1 to (de)activate it
! 3741: *
! 3742: * Change the parser processing behaviour by changing some of its internal
! 3743: * properties. Note that some properties can only be changed before any
! 3744: * read has been done.
! 3745: *
! 3746: * Returns 0 if the call was successful, or -1 in case of error
! 3747: */
! 3748: int
! 3749: xmlTextReaderSetParserProp(xmlTextReaderPtr reader, int prop, int value) {
! 3750: xmlParserProperties p = (xmlParserProperties) prop;
! 3751: xmlParserCtxtPtr ctxt;
! 3752:
! 3753: if ((reader == NULL) || (reader->ctxt == NULL))
! 3754: return(-1);
! 3755: ctxt = reader->ctxt;
! 3756:
! 3757: switch (p) {
! 3758: case XML_PARSER_LOADDTD:
! 3759: if (value != 0) {
! 3760: if (ctxt->loadsubset == 0) {
! 3761: if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
! 3762: return(-1);
! 3763: ctxt->loadsubset = XML_DETECT_IDS;
! 3764: }
! 3765: } else {
! 3766: ctxt->loadsubset = 0;
! 3767: }
! 3768: return(0);
! 3769: case XML_PARSER_DEFAULTATTRS:
! 3770: if (value != 0) {
! 3771: ctxt->loadsubset |= XML_COMPLETE_ATTRS;
! 3772: } else {
! 3773: if (ctxt->loadsubset & XML_COMPLETE_ATTRS)
! 3774: ctxt->loadsubset -= XML_COMPLETE_ATTRS;
! 3775: }
! 3776: return(0);
! 3777: case XML_PARSER_VALIDATE:
! 3778: if (value != 0) {
! 3779: ctxt->validate = 1;
! 3780: reader->validate = XML_TEXTREADER_VALIDATE_DTD;
! 3781: } else {
! 3782: ctxt->validate = 0;
! 3783: }
! 3784: return(0);
! 3785: case XML_PARSER_SUBST_ENTITIES:
! 3786: if (value != 0) {
! 3787: ctxt->replaceEntities = 1;
! 3788: } else {
! 3789: ctxt->replaceEntities = 0;
! 3790: }
! 3791: return(0);
! 3792: }
! 3793: return(-1);
! 3794: }
! 3795:
! 3796: /**
! 3797: * xmlTextReaderGetParserProp:
! 3798: * @reader: the xmlTextReaderPtr used
! 3799: * @prop: the xmlParserProperties to get
! 3800: *
! 3801: * Read the parser internal property.
! 3802: *
! 3803: * Returns the value, usually 0 or 1, or -1 in case of error.
! 3804: */
! 3805: int
! 3806: xmlTextReaderGetParserProp(xmlTextReaderPtr reader, int prop) {
! 3807: xmlParserProperties p = (xmlParserProperties) prop;
! 3808: xmlParserCtxtPtr ctxt;
! 3809:
! 3810: if ((reader == NULL) || (reader->ctxt == NULL))
! 3811: return(-1);
! 3812: ctxt = reader->ctxt;
! 3813:
! 3814: switch (p) {
! 3815: case XML_PARSER_LOADDTD:
! 3816: if ((ctxt->loadsubset != 0) || (ctxt->validate != 0))
! 3817: return(1);
! 3818: return(0);
! 3819: case XML_PARSER_DEFAULTATTRS:
! 3820: if (ctxt->loadsubset & XML_COMPLETE_ATTRS)
! 3821: return(1);
! 3822: return(0);
! 3823: case XML_PARSER_VALIDATE:
! 3824: return(reader->validate);
! 3825: case XML_PARSER_SUBST_ENTITIES:
! 3826: return(ctxt->replaceEntities);
! 3827: }
! 3828: return(-1);
! 3829: }
! 3830:
! 3831:
! 3832: /**
! 3833: * xmlTextReaderGetParserLineNumber:
! 3834: * @reader: the user data (XML reader context)
! 3835: *
! 3836: * Provide the line number of the current parsing point.
! 3837: *
! 3838: * Returns an int or 0 if not available
! 3839: */
! 3840: int
! 3841: xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader)
! 3842: {
! 3843: if ((reader == NULL) || (reader->ctxt == NULL) ||
! 3844: (reader->ctxt->input == NULL)) {
! 3845: return (0);
! 3846: }
! 3847: return (reader->ctxt->input->line);
! 3848: }
! 3849:
! 3850: /**
! 3851: * xmlTextReaderGetParserColumnNumber:
! 3852: * @reader: the user data (XML reader context)
! 3853: *
! 3854: * Provide the column number of the current parsing point.
! 3855: *
! 3856: * Returns an int or 0 if not available
! 3857: */
! 3858: int
! 3859: xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader)
! 3860: {
! 3861: if ((reader == NULL) || (reader->ctxt == NULL) ||
! 3862: (reader->ctxt->input == NULL)) {
! 3863: return (0);
! 3864: }
! 3865: return (reader->ctxt->input->col);
! 3866: }
! 3867:
! 3868: /**
! 3869: * xmlTextReaderCurrentNode:
! 3870: * @reader: the xmlTextReaderPtr used
! 3871: *
! 3872: * Hacking interface allowing to get the xmlNodePtr correponding to the
! 3873: * current node being accessed by the xmlTextReader. This is dangerous
! 3874: * because the underlying node may be destroyed on the next Reads.
! 3875: *
! 3876: * Returns the xmlNodePtr or NULL in case of error.
! 3877: */
! 3878: xmlNodePtr
! 3879: xmlTextReaderCurrentNode(xmlTextReaderPtr reader) {
! 3880: if (reader == NULL)
! 3881: return(NULL);
! 3882:
! 3883: if (reader->curnode != NULL)
! 3884: return(reader->curnode);
! 3885: return(reader->node);
! 3886: }
! 3887:
! 3888: /**
! 3889: * xmlTextReaderPreserve:
! 3890: * @reader: the xmlTextReaderPtr used
! 3891: *
! 3892: * This tells the XML Reader to preserve the current node.
! 3893: * The caller must also use xmlTextReaderCurrentDoc() to
! 3894: * keep an handle on the resulting document once parsing has finished
! 3895: *
! 3896: * Returns the xmlNodePtr or NULL in case of error.
! 3897: */
! 3898: xmlNodePtr
! 3899: xmlTextReaderPreserve(xmlTextReaderPtr reader) {
! 3900: xmlNodePtr cur, parent;
! 3901:
! 3902: if (reader == NULL)
! 3903: return(NULL);
! 3904:
! 3905: if (reader->curnode != NULL)
! 3906: cur = reader->curnode;
! 3907: else
! 3908: cur = reader->node;
! 3909: if (cur == NULL)
! 3910: return(NULL);
! 3911:
! 3912: if ((cur->type != XML_DOCUMENT_NODE) && (cur->type != XML_DTD_NODE)) {
! 3913: cur->extra |= NODE_IS_PRESERVED;
! 3914: cur->extra |= NODE_IS_SPRESERVED;
! 3915: }
! 3916: reader->preserves++;
! 3917:
! 3918: parent = cur->parent;;
! 3919: while (parent != NULL) {
! 3920: if (parent->type == XML_ELEMENT_NODE)
! 3921: parent->extra |= NODE_IS_PRESERVED;
! 3922: parent = parent->parent;
! 3923: }
! 3924: return(cur);
! 3925: }
! 3926:
! 3927: #ifdef LIBXML_PATTERN_ENABLED
! 3928: /**
! 3929: * xmlTextReaderPreservePattern:
! 3930: * @reader: the xmlTextReaderPtr used
! 3931: * @pattern: an XPath subset pattern
! 3932: * @namespaces: the prefix definitions, array of [URI, prefix] or NULL
! 3933: *
! 3934: * This tells the XML Reader to preserve all nodes matched by the
! 3935: * pattern. The caller must also use xmlTextReaderCurrentDoc() to
! 3936: * keep an handle on the resulting document once parsing has finished
! 3937: *
! 3938: * Returns a positive number in case of success and -1 in case of error
! 3939: */
! 3940: int
! 3941: xmlTextReaderPreservePattern(xmlTextReaderPtr reader, const xmlChar *pattern,
! 3942: const xmlChar **namespaces)
! 3943: {
! 3944: xmlPatternPtr comp;
! 3945:
! 3946: if ((reader == NULL) || (pattern == NULL))
! 3947: return(-1);
! 3948:
! 3949: comp = xmlPatterncompile(pattern, reader->dict, 0, namespaces);
! 3950: if (comp == NULL)
! 3951: return(-1);
! 3952:
! 3953: if (reader->patternMax <= 0) {
! 3954: reader->patternMax = 4;
! 3955: reader->patternTab = (xmlPatternPtr *) xmlMalloc(reader->patternMax *
! 3956: sizeof(reader->patternTab[0]));
! 3957: if (reader->patternTab == NULL) {
! 3958: xmlGenericError(xmlGenericErrorContext, "xmlMalloc failed !\n");
! 3959: return (-1);
! 3960: }
! 3961: }
! 3962: if (reader->patternNr >= reader->patternMax) {
! 3963: xmlPatternPtr *tmp;
! 3964: reader->patternMax *= 2;
! 3965: tmp = (xmlPatternPtr *) xmlRealloc(reader->patternTab,
! 3966: reader->patternMax *
! 3967: sizeof(reader->patternTab[0]));
! 3968: if (tmp == NULL) {
! 3969: xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
! 3970: reader->patternMax /= 2;
! 3971: return (-1);
! 3972: }
! 3973: reader->patternTab = tmp;
! 3974: }
! 3975: reader->patternTab[reader->patternNr] = comp;
! 3976: return(reader->patternNr++);
! 3977: }
! 3978: #endif
! 3979:
! 3980: /**
! 3981: * xmlTextReaderCurrentDoc:
! 3982: * @reader: the xmlTextReaderPtr used
! 3983: *
! 3984: * Hacking interface allowing to get the xmlDocPtr correponding to the
! 3985: * current document being accessed by the xmlTextReader.
! 3986: * NOTE: as a result of this call, the reader will not destroy the
! 3987: * associated XML document and calling xmlFreeDoc() on the result
! 3988: * is needed once the reader parsing has finished.
! 3989: *
! 3990: * Returns the xmlDocPtr or NULL in case of error.
! 3991: */
! 3992: xmlDocPtr
! 3993: xmlTextReaderCurrentDoc(xmlTextReaderPtr reader) {
! 3994: if (reader == NULL)
! 3995: return(NULL);
! 3996: if (reader->doc != NULL)
! 3997: return(reader->doc);
! 3998: if ((reader->ctxt == NULL) || (reader->ctxt->myDoc == NULL))
! 3999: return(NULL);
! 4000:
! 4001: reader->preserve = 1;
! 4002: return(reader->ctxt->myDoc);
! 4003: }
! 4004:
! 4005: #ifdef LIBXML_SCHEMAS_ENABLED
! 4006: static char *xmlTextReaderBuildMessage(const char *msg, va_list ap);
! 4007:
! 4008: static void XMLCDECL
! 4009: xmlTextReaderValidityError(void *ctxt, const char *msg, ...);
! 4010:
! 4011: static void XMLCDECL
! 4012: xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...);
! 4013:
! 4014: static void XMLCDECL
! 4015: xmlTextReaderValidityErrorRelay(void *ctx, const char *msg, ...)
! 4016: {
! 4017: xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
! 4018:
! 4019: char *str;
! 4020:
! 4021: va_list ap;
! 4022:
! 4023: va_start(ap, msg);
! 4024: str = xmlTextReaderBuildMessage(msg, ap);
! 4025: if (!reader->errorFunc) {
! 4026: xmlTextReaderValidityError(ctx, "%s", str);
! 4027: } else {
! 4028: reader->errorFunc(reader->errorFuncArg, str,
! 4029: XML_PARSER_SEVERITY_VALIDITY_ERROR,
! 4030: NULL /* locator */ );
! 4031: }
! 4032: if (str != NULL)
! 4033: xmlFree(str);
! 4034: va_end(ap);
! 4035: }
! 4036:
! 4037: static void XMLCDECL
! 4038: xmlTextReaderValidityWarningRelay(void *ctx, const char *msg, ...)
! 4039: {
! 4040: xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
! 4041:
! 4042: char *str;
! 4043:
! 4044: va_list ap;
! 4045:
! 4046: va_start(ap, msg);
! 4047: str = xmlTextReaderBuildMessage(msg, ap);
! 4048: if (!reader->errorFunc) {
! 4049: xmlTextReaderValidityWarning(ctx, "%s", str);
! 4050: } else {
! 4051: reader->errorFunc(reader->errorFuncArg, str,
! 4052: XML_PARSER_SEVERITY_VALIDITY_WARNING,
! 4053: NULL /* locator */ );
! 4054: }
! 4055: if (str != NULL)
! 4056: xmlFree(str);
! 4057: va_end(ap);
! 4058: }
! 4059:
! 4060: static void
! 4061: xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error);
! 4062:
! 4063: static void
! 4064: xmlTextReaderValidityStructuredRelay(void *userData, xmlErrorPtr error)
! 4065: {
! 4066: xmlTextReaderPtr reader = (xmlTextReaderPtr) userData;
! 4067:
! 4068: if (reader->sErrorFunc) {
! 4069: reader->sErrorFunc(reader->errorFuncArg, error);
! 4070: } else {
! 4071: xmlTextReaderStructuredError(reader, error);
! 4072: }
! 4073: }
! 4074: /**
! 4075: * xmlTextReaderRelaxNGSetSchema:
! 4076: * @reader: the xmlTextReaderPtr used
! 4077: * @schema: a precompiled RelaxNG schema
! 4078: *
! 4079: * Use RelaxNG to validate the document as it is processed.
! 4080: * Activation is only possible before the first Read().
! 4081: * if @schema is NULL, then RelaxNG validation is desactivated.
! 4082: @ The @schema should not be freed until the reader is deallocated
! 4083: * or its use has been deactivated.
! 4084: *
! 4085: * Returns 0 in case the RelaxNG validation could be (des)activated and
! 4086: * -1 in case of error.
! 4087: */
! 4088: int
! 4089: xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, xmlRelaxNGPtr schema) {
! 4090: if (reader == NULL)
! 4091: return(-1);
! 4092: if (schema == NULL) {
! 4093: if (reader->rngSchemas != NULL) {
! 4094: xmlRelaxNGFree(reader->rngSchemas);
! 4095: reader->rngSchemas = NULL;
! 4096: }
! 4097: if (reader->rngValidCtxt != NULL) {
! 4098: xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
! 4099: reader->rngValidCtxt = NULL;
! 4100: }
! 4101: return(0);
! 4102: }
! 4103: if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
! 4104: return(-1);
! 4105: if (reader->rngSchemas != NULL) {
! 4106: xmlRelaxNGFree(reader->rngSchemas);
! 4107: reader->rngSchemas = NULL;
! 4108: }
! 4109: if (reader->rngValidCtxt != NULL) {
! 4110: xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
! 4111: reader->rngValidCtxt = NULL;
! 4112: }
! 4113: reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(schema);
! 4114: if (reader->rngValidCtxt == NULL)
! 4115: return(-1);
! 4116: if (reader->errorFunc != NULL) {
! 4117: xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
! 4118: xmlTextReaderValidityErrorRelay,
! 4119: xmlTextReaderValidityWarningRelay,
! 4120: reader);
! 4121: }
! 4122: if (reader->sErrorFunc != NULL) {
! 4123: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
! 4124: xmlTextReaderValidityStructuredRelay,
! 4125: reader);
! 4126: }
! 4127: reader->rngValidErrors = 0;
! 4128: reader->rngFullNode = NULL;
! 4129: reader->validate = XML_TEXTREADER_VALIDATE_RNG;
! 4130: return(0);
! 4131: }
! 4132:
! 4133: /**
! 4134: * xmlTextReaderSetSchema:
! 4135: * @reader: the xmlTextReaderPtr used
! 4136: * @schema: a precompiled Schema schema
! 4137: *
! 4138: * Use XSD Schema to validate the document as it is processed.
! 4139: * Activation is only possible before the first Read().
! 4140: * if @schema is NULL, then Schema validation is desactivated.
! 4141: @ The @schema should not be freed until the reader is deallocated
! 4142: * or its use has been deactivated.
! 4143: *
! 4144: * Returns 0 in case the Schema validation could be (des)activated and
! 4145: * -1 in case of error.
! 4146: */
! 4147: int
! 4148: xmlTextReaderSetSchema(xmlTextReaderPtr reader, xmlSchemaPtr schema) {
! 4149: if (reader == NULL)
! 4150: return(-1);
! 4151: if (schema == NULL) {
! 4152: if (reader->xsdPlug != NULL) {
! 4153: xmlSchemaSAXUnplug(reader->xsdPlug);
! 4154: reader->xsdPlug = NULL;
! 4155: }
! 4156: if (reader->xsdValidCtxt != NULL) {
! 4157: if (! reader->xsdPreserveCtxt)
! 4158: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
! 4159: reader->xsdValidCtxt = NULL;
! 4160: }
! 4161: reader->xsdPreserveCtxt = 0;
! 4162: if (reader->xsdSchemas != NULL) {
! 4163: xmlSchemaFree(reader->xsdSchemas);
! 4164: reader->xsdSchemas = NULL;
! 4165: }
! 4166: return(0);
! 4167: }
! 4168: if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
! 4169: return(-1);
! 4170: if (reader->xsdPlug != NULL) {
! 4171: xmlSchemaSAXUnplug(reader->xsdPlug);
! 4172: reader->xsdPlug = NULL;
! 4173: }
! 4174: if (reader->xsdValidCtxt != NULL) {
! 4175: if (! reader->xsdPreserveCtxt)
! 4176: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
! 4177: reader->xsdValidCtxt = NULL;
! 4178: }
! 4179: reader->xsdPreserveCtxt = 0;
! 4180: if (reader->xsdSchemas != NULL) {
! 4181: xmlSchemaFree(reader->xsdSchemas);
! 4182: reader->xsdSchemas = NULL;
! 4183: }
! 4184: reader->xsdValidCtxt = xmlSchemaNewValidCtxt(schema);
! 4185: if (reader->xsdValidCtxt == NULL) {
! 4186: xmlSchemaFree(reader->xsdSchemas);
! 4187: reader->xsdSchemas = NULL;
! 4188: return(-1);
! 4189: }
! 4190: reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
! 4191: &(reader->ctxt->sax),
! 4192: &(reader->ctxt->userData));
! 4193: if (reader->xsdPlug == NULL) {
! 4194: xmlSchemaFree(reader->xsdSchemas);
! 4195: reader->xsdSchemas = NULL;
! 4196: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
! 4197: reader->xsdValidCtxt = NULL;
! 4198: return(-1);
! 4199: }
! 4200: if (reader->errorFunc != NULL) {
! 4201: xmlSchemaSetValidErrors(reader->xsdValidCtxt,
! 4202: xmlTextReaderValidityErrorRelay,
! 4203: xmlTextReaderValidityWarningRelay,
! 4204: reader);
! 4205: }
! 4206: if (reader->sErrorFunc != NULL) {
! 4207: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
! 4208: xmlTextReaderValidityStructuredRelay,
! 4209: reader);
! 4210: }
! 4211: reader->xsdValidErrors = 0;
! 4212: reader->validate = XML_TEXTREADER_VALIDATE_XSD;
! 4213: return(0);
! 4214: }
! 4215:
! 4216: /**
! 4217: * xmlTextReaderRelaxNGValidate:
! 4218: * @reader: the xmlTextReaderPtr used
! 4219: * @rng: the path to a RelaxNG schema or NULL
! 4220: *
! 4221: * Use RelaxNG to validate the document as it is processed.
! 4222: * Activation is only possible before the first Read().
! 4223: * if @rng is NULL, then RelaxNG validation is deactivated.
! 4224: *
! 4225: * Returns 0 in case the RelaxNG validation could be (de)activated and
! 4226: * -1 in case of error.
! 4227: */
! 4228: int
! 4229: xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng) {
! 4230: xmlRelaxNGParserCtxtPtr ctxt;
! 4231:
! 4232: if (reader == NULL)
! 4233: return(-1);
! 4234:
! 4235: if (rng == NULL) {
! 4236: if (reader->rngValidCtxt != NULL) {
! 4237: xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
! 4238: reader->rngValidCtxt = NULL;
! 4239: }
! 4240: if (reader->rngSchemas != NULL) {
! 4241: xmlRelaxNGFree(reader->rngSchemas);
! 4242: reader->rngSchemas = NULL;
! 4243: }
! 4244: return(0);
! 4245: }
! 4246: if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
! 4247: return(-1);
! 4248: if (reader->rngSchemas != NULL) {
! 4249: xmlRelaxNGFree(reader->rngSchemas);
! 4250: reader->rngSchemas = NULL;
! 4251: }
! 4252: if (reader->rngValidCtxt != NULL) {
! 4253: xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
! 4254: reader->rngValidCtxt = NULL;
! 4255: }
! 4256: ctxt = xmlRelaxNGNewParserCtxt(rng);
! 4257: if (reader->errorFunc != NULL) {
! 4258: xmlRelaxNGSetParserErrors(ctxt,
! 4259: xmlTextReaderValidityErrorRelay,
! 4260: xmlTextReaderValidityWarningRelay,
! 4261: reader);
! 4262: }
! 4263: if (reader->sErrorFunc != NULL) {
! 4264: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
! 4265: xmlTextReaderValidityStructuredRelay,
! 4266: reader);
! 4267: }
! 4268: reader->rngSchemas = xmlRelaxNGParse(ctxt);
! 4269: xmlRelaxNGFreeParserCtxt(ctxt);
! 4270: if (reader->rngSchemas == NULL)
! 4271: return(-1);
! 4272: reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
! 4273: if (reader->rngValidCtxt == NULL) {
! 4274: xmlRelaxNGFree(reader->rngSchemas);
! 4275: reader->rngSchemas = NULL;
! 4276: return(-1);
! 4277: }
! 4278: if (reader->errorFunc != NULL) {
! 4279: xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
! 4280: xmlTextReaderValidityErrorRelay,
! 4281: xmlTextReaderValidityWarningRelay,
! 4282: reader);
! 4283: }
! 4284: if (reader->sErrorFunc != NULL) {
! 4285: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
! 4286: xmlTextReaderValidityStructuredRelay,
! 4287: reader);
! 4288: }
! 4289: reader->rngValidErrors = 0;
! 4290: reader->rngFullNode = NULL;
! 4291: reader->validate = XML_TEXTREADER_VALIDATE_RNG;
! 4292: return(0);
! 4293: }
! 4294:
! 4295: /**
! 4296: * xmlTextReaderSchemaValidateInternal:
! 4297: * @reader: the xmlTextReaderPtr used
! 4298: * @xsd: the path to a W3C XSD schema or NULL
! 4299: * @ctxt: the XML Schema validation context or NULL
! 4300: * @options: options (not used yet)
! 4301: *
! 4302: * Validate the document as it is processed using XML Schema.
! 4303: * Activation is only possible before the first Read().
! 4304: * If both @xsd and @ctxt are NULL then XML Schema validation is deactivated.
! 4305: *
! 4306: * Returns 0 in case the schemas validation could be (de)activated and
! 4307: * -1 in case of error.
! 4308: */
! 4309: static int
! 4310: xmlTextReaderSchemaValidateInternal(xmlTextReaderPtr reader,
! 4311: const char *xsd,
! 4312: xmlSchemaValidCtxtPtr ctxt,
! 4313: int options ATTRIBUTE_UNUSED)
! 4314: {
! 4315: if (reader == NULL)
! 4316: return(-1);
! 4317:
! 4318: if ((xsd != NULL) && (ctxt != NULL))
! 4319: return(-1);
! 4320:
! 4321: if (((xsd != NULL) || (ctxt != NULL)) &&
! 4322: ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
! 4323: (reader->ctxt == NULL)))
! 4324: return(-1);
! 4325:
! 4326: /* Cleanup previous validation stuff. */
! 4327: if (reader->xsdPlug != NULL) {
! 4328: xmlSchemaSAXUnplug(reader->xsdPlug);
! 4329: reader->xsdPlug = NULL;
! 4330: }
! 4331: if (reader->xsdValidCtxt != NULL) {
! 4332: if (! reader->xsdPreserveCtxt)
! 4333: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
! 4334: reader->xsdValidCtxt = NULL;
! 4335: }
! 4336: reader->xsdPreserveCtxt = 0;
! 4337: if (reader->xsdSchemas != NULL) {
! 4338: xmlSchemaFree(reader->xsdSchemas);
! 4339: reader->xsdSchemas = NULL;
! 4340: }
! 4341:
! 4342: if ((xsd == NULL) && (ctxt == NULL)) {
! 4343: /* We just want to deactivate the validation, so get out. */
! 4344: return(0);
! 4345: }
! 4346:
! 4347: if (xsd != NULL) {
! 4348: xmlSchemaParserCtxtPtr pctxt;
! 4349: /* Parse the schema and create validation environment. */
! 4350: pctxt = xmlSchemaNewParserCtxt(xsd);
! 4351: if (reader->errorFunc != NULL) {
! 4352: xmlSchemaSetParserErrors(pctxt,
! 4353: xmlTextReaderValidityErrorRelay,
! 4354: xmlTextReaderValidityWarningRelay,
! 4355: reader);
! 4356: }
! 4357: reader->xsdSchemas = xmlSchemaParse(pctxt);
! 4358: xmlSchemaFreeParserCtxt(pctxt);
! 4359: if (reader->xsdSchemas == NULL)
! 4360: return(-1);
! 4361: reader->xsdValidCtxt = xmlSchemaNewValidCtxt(reader->xsdSchemas);
! 4362: if (reader->xsdValidCtxt == NULL) {
! 4363: xmlSchemaFree(reader->xsdSchemas);
! 4364: reader->xsdSchemas = NULL;
! 4365: return(-1);
! 4366: }
! 4367: reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
! 4368: &(reader->ctxt->sax),
! 4369: &(reader->ctxt->userData));
! 4370: if (reader->xsdPlug == NULL) {
! 4371: xmlSchemaFree(reader->xsdSchemas);
! 4372: reader->xsdSchemas = NULL;
! 4373: xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
! 4374: reader->xsdValidCtxt = NULL;
! 4375: return(-1);
! 4376: }
! 4377: } else {
! 4378: /* Use the given validation context. */
! 4379: reader->xsdValidCtxt = ctxt;
! 4380: reader->xsdPreserveCtxt = 1;
! 4381: reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
! 4382: &(reader->ctxt->sax),
! 4383: &(reader->ctxt->userData));
! 4384: if (reader->xsdPlug == NULL) {
! 4385: reader->xsdValidCtxt = NULL;
! 4386: reader->xsdPreserveCtxt = 0;
! 4387: return(-1);
! 4388: }
! 4389: }
! 4390: /*
! 4391: * Redirect the validation context's error channels to use
! 4392: * the reader channels.
! 4393: * TODO: In case the user provides the validation context we
! 4394: * could make this redirection optional.
! 4395: */
! 4396: if (reader->errorFunc != NULL) {
! 4397: xmlSchemaSetValidErrors(reader->xsdValidCtxt,
! 4398: xmlTextReaderValidityErrorRelay,
! 4399: xmlTextReaderValidityWarningRelay,
! 4400: reader);
! 4401: }
! 4402: if (reader->sErrorFunc != NULL) {
! 4403: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
! 4404: xmlTextReaderValidityStructuredRelay,
! 4405: reader);
! 4406: }
! 4407: reader->xsdValidErrors = 0;
! 4408: reader->validate = XML_TEXTREADER_VALIDATE_XSD;
! 4409: return(0);
! 4410: }
! 4411:
! 4412: /**
! 4413: * xmlTextReaderSchemaValidateCtxt:
! 4414: * @reader: the xmlTextReaderPtr used
! 4415: * @ctxt: the XML Schema validation context or NULL
! 4416: * @options: options (not used yet)
! 4417: *
! 4418: * Use W3C XSD schema context to validate the document as it is processed.
! 4419: * Activation is only possible before the first Read().
! 4420: * If @ctxt is NULL, then XML Schema validation is deactivated.
! 4421: *
! 4422: * Returns 0 in case the schemas validation could be (de)activated and
! 4423: * -1 in case of error.
! 4424: */
! 4425: int
! 4426: xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader,
! 4427: xmlSchemaValidCtxtPtr ctxt,
! 4428: int options)
! 4429: {
! 4430: return(xmlTextReaderSchemaValidateInternal(reader, NULL, ctxt, options));
! 4431: }
! 4432:
! 4433: /**
! 4434: * xmlTextReaderSchemaValidate:
! 4435: * @reader: the xmlTextReaderPtr used
! 4436: * @xsd: the path to a W3C XSD schema or NULL
! 4437: *
! 4438: * Use W3C XSD schema to validate the document as it is processed.
! 4439: * Activation is only possible before the first Read().
! 4440: * If @xsd is NULL, then XML Schema validation is deactivated.
! 4441: *
! 4442: * Returns 0 in case the schemas validation could be (de)activated and
! 4443: * -1 in case of error.
! 4444: */
! 4445: int
! 4446: xmlTextReaderSchemaValidate(xmlTextReaderPtr reader, const char *xsd)
! 4447: {
! 4448: return(xmlTextReaderSchemaValidateInternal(reader, xsd, NULL, 0));
! 4449: }
! 4450: #endif
! 4451:
! 4452: /**
! 4453: * xmlTextReaderIsNamespaceDecl:
! 4454: * @reader: the xmlTextReaderPtr used
! 4455: *
! 4456: * Determine whether the current node is a namespace declaration
! 4457: * rather than a regular attribute.
! 4458: *
! 4459: * Returns 1 if the current node is a namespace declaration, 0 if it
! 4460: * is a regular attribute or other type of node, or -1 in case of
! 4461: * error.
! 4462: */
! 4463: int
! 4464: xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader) {
! 4465: xmlNodePtr node;
! 4466: if (reader == NULL)
! 4467: return(-1);
! 4468: if (reader->node == NULL)
! 4469: return(-1);
! 4470: if (reader->curnode != NULL)
! 4471: node = reader->curnode;
! 4472: else
! 4473: node = reader->node;
! 4474:
! 4475: if (XML_NAMESPACE_DECL == node->type)
! 4476: return(1);
! 4477: else
! 4478: return(0);
! 4479: }
! 4480:
! 4481: /**
! 4482: * xmlTextReaderConstXmlVersion:
! 4483: * @reader: the xmlTextReaderPtr used
! 4484: *
! 4485: * Determine the XML version of the document being read.
! 4486: *
! 4487: * Returns a string containing the XML version of the document or NULL
! 4488: * in case of error. The string is deallocated with the reader.
! 4489: */
! 4490: const xmlChar *
! 4491: xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader) {
! 4492: xmlDocPtr doc = NULL;
! 4493: if (reader == NULL)
! 4494: return(NULL);
! 4495: if (reader->doc != NULL)
! 4496: doc = reader->doc;
! 4497: else if (reader->ctxt != NULL)
! 4498: doc = reader->ctxt->myDoc;
! 4499: if (doc == NULL)
! 4500: return(NULL);
! 4501:
! 4502: if (doc->version == NULL)
! 4503: return(NULL);
! 4504: else
! 4505: return(CONSTSTR(doc->version));
! 4506: }
! 4507:
! 4508: /**
! 4509: * xmlTextReaderStandalone:
! 4510: * @reader: the xmlTextReaderPtr used
! 4511: *
! 4512: * Determine the standalone status of the document being read.
! 4513: *
! 4514: * Returns 1 if the document was declared to be standalone, 0 if it
! 4515: * was declared to be not standalone, or -1 if the document did not
! 4516: * specify its standalone status or in case of error.
! 4517: */
! 4518: int
! 4519: xmlTextReaderStandalone(xmlTextReaderPtr reader) {
! 4520: xmlDocPtr doc = NULL;
! 4521: if (reader == NULL)
! 4522: return(-1);
! 4523: if (reader->doc != NULL)
! 4524: doc = reader->doc;
! 4525: else if (reader->ctxt != NULL)
! 4526: doc = reader->ctxt->myDoc;
! 4527: if (doc == NULL)
! 4528: return(-1);
! 4529:
! 4530: return(doc->standalone);
! 4531: }
! 4532:
! 4533: /************************************************************************
! 4534: * *
! 4535: * Error Handling Extensions *
! 4536: * *
! 4537: ************************************************************************/
! 4538:
! 4539: /* helper to build a xmlMalloc'ed string from a format and va_list */
! 4540: static char *
! 4541: xmlTextReaderBuildMessage(const char *msg, va_list ap) {
! 4542: int size = 0;
! 4543: int chars;
! 4544: char *larger;
! 4545: char *str = NULL;
! 4546: va_list aq;
! 4547:
! 4548: while (1) {
! 4549: VA_COPY(aq, ap);
! 4550: chars = vsnprintf(str, size, msg, aq);
! 4551: va_end(aq);
! 4552: if (chars < 0) {
! 4553: xmlGenericError(xmlGenericErrorContext, "vsnprintf failed !\n");
! 4554: if (str)
! 4555: xmlFree(str);
! 4556: return NULL;
! 4557: }
! 4558: if ((chars < size) || (size == MAX_ERR_MSG_SIZE))
! 4559: break;
! 4560: if (chars < MAX_ERR_MSG_SIZE)
! 4561: size = chars + 1;
! 4562: else
! 4563: size = MAX_ERR_MSG_SIZE;
! 4564: if ((larger = (char *) xmlRealloc(str, size)) == NULL) {
! 4565: xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
! 4566: if (str)
! 4567: xmlFree(str);
! 4568: return NULL;
! 4569: }
! 4570: str = larger;
! 4571: }
! 4572:
! 4573: return str;
! 4574: }
! 4575:
! 4576: /**
! 4577: * xmlTextReaderLocatorLineNumber:
! 4578: * @locator: the xmlTextReaderLocatorPtr used
! 4579: *
! 4580: * Obtain the line number for the given locator.
! 4581: *
! 4582: * Returns the line number or -1 in case of error.
! 4583: */
! 4584: int
! 4585: xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator) {
! 4586: /* we know that locator is a xmlParserCtxtPtr */
! 4587: xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
! 4588: int ret = -1;
! 4589:
! 4590: if (locator == NULL)
! 4591: return(-1);
! 4592: if (ctx->node != NULL) {
! 4593: ret = xmlGetLineNo(ctx->node);
! 4594: }
! 4595: else {
! 4596: /* inspired from error.c */
! 4597: xmlParserInputPtr input;
! 4598: input = ctx->input;
! 4599: if ((input->filename == NULL) && (ctx->inputNr > 1))
! 4600: input = ctx->inputTab[ctx->inputNr - 2];
! 4601: if (input != NULL) {
! 4602: ret = input->line;
! 4603: }
! 4604: else {
! 4605: ret = -1;
! 4606: }
! 4607: }
! 4608:
! 4609: return ret;
! 4610: }
! 4611:
! 4612: /**
! 4613: * xmlTextReaderLocatorBaseURI:
! 4614: * @locator: the xmlTextReaderLocatorPtr used
! 4615: *
! 4616: * Obtain the base URI for the given locator.
! 4617: *
! 4618: * Returns the base URI or NULL in case of error,
! 4619: * if non NULL it need to be freed by the caller.
! 4620: */
! 4621: xmlChar *
! 4622: xmlTextReaderLocatorBaseURI(xmlTextReaderLocatorPtr locator) {
! 4623: /* we know that locator is a xmlParserCtxtPtr */
! 4624: xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
! 4625: xmlChar *ret = NULL;
! 4626:
! 4627: if (locator == NULL)
! 4628: return(NULL);
! 4629: if (ctx->node != NULL) {
! 4630: ret = xmlNodeGetBase(NULL,ctx->node);
! 4631: }
! 4632: else {
! 4633: /* inspired from error.c */
! 4634: xmlParserInputPtr input;
! 4635: input = ctx->input;
! 4636: if ((input->filename == NULL) && (ctx->inputNr > 1))
! 4637: input = ctx->inputTab[ctx->inputNr - 2];
! 4638: if (input != NULL) {
! 4639: ret = xmlStrdup(BAD_CAST input->filename);
! 4640: }
! 4641: else {
! 4642: ret = NULL;
! 4643: }
! 4644: }
! 4645:
! 4646: return ret;
! 4647: }
! 4648:
! 4649: static void
! 4650: xmlTextReaderGenericError(void *ctxt, xmlParserSeverities severity,
! 4651: char *str)
! 4652: {
! 4653: xmlParserCtxtPtr ctx = (xmlParserCtxtPtr) ctxt;
! 4654:
! 4655: xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
! 4656:
! 4657: if (str != NULL) {
! 4658: if (reader->errorFunc)
! 4659: reader->errorFunc(reader->errorFuncArg, str, severity,
! 4660: (xmlTextReaderLocatorPtr) ctx);
! 4661: xmlFree(str);
! 4662: }
! 4663: }
! 4664:
! 4665: static void
! 4666: xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error)
! 4667: {
! 4668: xmlParserCtxtPtr ctx = (xmlParserCtxtPtr) ctxt;
! 4669:
! 4670: xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
! 4671:
! 4672: if (error && reader->sErrorFunc) {
! 4673: reader->sErrorFunc(reader->errorFuncArg, (xmlErrorPtr) error);
! 4674: }
! 4675: }
! 4676:
! 4677: static void XMLCDECL
! 4678: xmlTextReaderError(void *ctxt, const char *msg, ...)
! 4679: {
! 4680: va_list ap;
! 4681:
! 4682: va_start(ap, msg);
! 4683: xmlTextReaderGenericError(ctxt,
! 4684: XML_PARSER_SEVERITY_ERROR,
! 4685: xmlTextReaderBuildMessage(msg, ap));
! 4686: va_end(ap);
! 4687:
! 4688: }
! 4689:
! 4690: static void XMLCDECL
! 4691: xmlTextReaderWarning(void *ctxt, const char *msg, ...)
! 4692: {
! 4693: va_list ap;
! 4694:
! 4695: va_start(ap, msg);
! 4696: xmlTextReaderGenericError(ctxt,
! 4697: XML_PARSER_SEVERITY_WARNING,
! 4698: xmlTextReaderBuildMessage(msg, ap));
! 4699: va_end(ap);
! 4700: }
! 4701:
! 4702: static void XMLCDECL
! 4703: xmlTextReaderValidityError(void *ctxt, const char *msg, ...)
! 4704: {
! 4705: va_list ap;
! 4706:
! 4707: int len = xmlStrlen((const xmlChar *) msg);
! 4708:
! 4709: if ((len > 1) && (msg[len - 2] != ':')) {
! 4710: /*
! 4711: * some callbacks only report locator information:
! 4712: * skip them (mimicking behaviour in error.c)
! 4713: */
! 4714: va_start(ap, msg);
! 4715: xmlTextReaderGenericError(ctxt,
! 4716: XML_PARSER_SEVERITY_VALIDITY_ERROR,
! 4717: xmlTextReaderBuildMessage(msg, ap));
! 4718: va_end(ap);
! 4719: }
! 4720: }
! 4721:
! 4722: static void XMLCDECL
! 4723: xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...)
! 4724: {
! 4725: va_list ap;
! 4726:
! 4727: int len = xmlStrlen((const xmlChar *) msg);
! 4728:
! 4729: if ((len != 0) && (msg[len - 1] != ':')) {
! 4730: /*
! 4731: * some callbacks only report locator information:
! 4732: * skip them (mimicking behaviour in error.c)
! 4733: */
! 4734: va_start(ap, msg);
! 4735: xmlTextReaderGenericError(ctxt,
! 4736: XML_PARSER_SEVERITY_VALIDITY_WARNING,
! 4737: xmlTextReaderBuildMessage(msg, ap));
! 4738: va_end(ap);
! 4739: }
! 4740: }
! 4741:
! 4742: /**
! 4743: * xmlTextReaderSetErrorHandler:
! 4744: * @reader: the xmlTextReaderPtr used
! 4745: * @f: the callback function to call on error and warnings
! 4746: * @arg: a user argument to pass to the callback function
! 4747: *
! 4748: * Register a callback function that will be called on error and warnings.
! 4749: *
! 4750: * If @f is NULL, the default error and warning handlers are restored.
! 4751: */
! 4752: void
! 4753: xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
! 4754: xmlTextReaderErrorFunc f, void *arg)
! 4755: {
! 4756: if (f != NULL) {
! 4757: reader->ctxt->sax->error = xmlTextReaderError;
! 4758: reader->ctxt->sax->serror = NULL;
! 4759: reader->ctxt->vctxt.error = xmlTextReaderValidityError;
! 4760: reader->ctxt->sax->warning = xmlTextReaderWarning;
! 4761: reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
! 4762: reader->errorFunc = f;
! 4763: reader->sErrorFunc = NULL;
! 4764: reader->errorFuncArg = arg;
! 4765: #ifdef LIBXML_SCHEMAS_ENABLED
! 4766: if (reader->rngValidCtxt) {
! 4767: xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
! 4768: xmlTextReaderValidityErrorRelay,
! 4769: xmlTextReaderValidityWarningRelay,
! 4770: reader);
! 4771: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
! 4772: reader);
! 4773: }
! 4774: if (reader->xsdValidCtxt) {
! 4775: xmlSchemaSetValidErrors(reader->xsdValidCtxt,
! 4776: xmlTextReaderValidityErrorRelay,
! 4777: xmlTextReaderValidityWarningRelay,
! 4778: reader);
! 4779: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
! 4780: reader);
! 4781: }
! 4782: #endif
! 4783: } else {
! 4784: /* restore defaults */
! 4785: reader->ctxt->sax->error = xmlParserError;
! 4786: reader->ctxt->vctxt.error = xmlParserValidityError;
! 4787: reader->ctxt->sax->warning = xmlParserWarning;
! 4788: reader->ctxt->vctxt.warning = xmlParserValidityWarning;
! 4789: reader->errorFunc = NULL;
! 4790: reader->sErrorFunc = NULL;
! 4791: reader->errorFuncArg = NULL;
! 4792: #ifdef LIBXML_SCHEMAS_ENABLED
! 4793: if (reader->rngValidCtxt) {
! 4794: xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
! 4795: reader);
! 4796: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
! 4797: reader);
! 4798: }
! 4799: if (reader->xsdValidCtxt) {
! 4800: xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
! 4801: reader);
! 4802: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
! 4803: reader);
! 4804: }
! 4805: #endif
! 4806: }
! 4807: }
! 4808:
! 4809: /**
! 4810: * xmlTextReaderSetStructuredErrorHandler:
! 4811: * @reader: the xmlTextReaderPtr used
! 4812: * @f: the callback function to call on error and warnings
! 4813: * @arg: a user argument to pass to the callback function
! 4814: *
! 4815: * Register a callback function that will be called on error and warnings.
! 4816: *
! 4817: * If @f is NULL, the default error and warning handlers are restored.
! 4818: */
! 4819: void
! 4820: xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
! 4821: xmlStructuredErrorFunc f, void *arg)
! 4822: {
! 4823: if (f != NULL) {
! 4824: reader->ctxt->sax->error = NULL;
! 4825: reader->ctxt->sax->serror = xmlTextReaderStructuredError;
! 4826: reader->ctxt->vctxt.error = xmlTextReaderValidityError;
! 4827: reader->ctxt->sax->warning = xmlTextReaderWarning;
! 4828: reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
! 4829: reader->sErrorFunc = f;
! 4830: reader->errorFunc = NULL;
! 4831: reader->errorFuncArg = arg;
! 4832: #ifdef LIBXML_SCHEMAS_ENABLED
! 4833: if (reader->rngValidCtxt) {
! 4834: xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
! 4835: reader);
! 4836: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
! 4837: xmlTextReaderValidityStructuredRelay,
! 4838: reader);
! 4839: }
! 4840: if (reader->xsdValidCtxt) {
! 4841: xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
! 4842: reader);
! 4843: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
! 4844: xmlTextReaderValidityStructuredRelay,
! 4845: reader);
! 4846: }
! 4847: #endif
! 4848: } else {
! 4849: /* restore defaults */
! 4850: reader->ctxt->sax->error = xmlParserError;
! 4851: reader->ctxt->sax->serror = NULL;
! 4852: reader->ctxt->vctxt.error = xmlParserValidityError;
! 4853: reader->ctxt->sax->warning = xmlParserWarning;
! 4854: reader->ctxt->vctxt.warning = xmlParserValidityWarning;
! 4855: reader->errorFunc = NULL;
! 4856: reader->sErrorFunc = NULL;
! 4857: reader->errorFuncArg = NULL;
! 4858: #ifdef LIBXML_SCHEMAS_ENABLED
! 4859: if (reader->rngValidCtxt) {
! 4860: xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
! 4861: reader);
! 4862: xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
! 4863: reader);
! 4864: }
! 4865: if (reader->xsdValidCtxt) {
! 4866: xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
! 4867: reader);
! 4868: xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
! 4869: reader);
! 4870: }
! 4871: #endif
! 4872: }
! 4873: }
! 4874:
! 4875: /**
! 4876: * xmlTextReaderIsValid:
! 4877: * @reader: the xmlTextReaderPtr used
! 4878: *
! 4879: * Retrieve the validity status from the parser context
! 4880: *
! 4881: * Returns the flag value 1 if valid, 0 if no, and -1 in case of error
! 4882: */
! 4883: int
! 4884: xmlTextReaderIsValid(xmlTextReaderPtr reader)
! 4885: {
! 4886: if (reader == NULL)
! 4887: return (-1);
! 4888: #ifdef LIBXML_SCHEMAS_ENABLED
! 4889: if (reader->validate == XML_TEXTREADER_VALIDATE_RNG)
! 4890: return (reader->rngValidErrors == 0);
! 4891: if (reader->validate == XML_TEXTREADER_VALIDATE_XSD)
! 4892: return (reader->xsdValidErrors == 0);
! 4893: #endif
! 4894: if ((reader->ctxt != NULL) && (reader->ctxt->validate == 1))
! 4895: return (reader->ctxt->valid);
! 4896: return (0);
! 4897: }
! 4898:
! 4899: /**
! 4900: * xmlTextReaderGetErrorHandler:
! 4901: * @reader: the xmlTextReaderPtr used
! 4902: * @f: the callback function or NULL is no callback has been registered
! 4903: * @arg: a user argument
! 4904: *
! 4905: * Retrieve the error callback function and user argument.
! 4906: */
! 4907: void
! 4908: xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
! 4909: xmlTextReaderErrorFunc * f, void **arg)
! 4910: {
! 4911: if (f != NULL)
! 4912: *f = reader->errorFunc;
! 4913: if (arg != NULL)
! 4914: *arg = reader->errorFuncArg;
! 4915: }
! 4916: /************************************************************************
! 4917: * *
! 4918: * New set (2.6.0) of simpler and more flexible APIs *
! 4919: * *
! 4920: ************************************************************************/
! 4921:
! 4922: /**
! 4923: * xmlTextReaderSetup:
! 4924: * @reader: an XML reader
! 4925: * @input: xmlParserInputBufferPtr used to feed the reader, will
! 4926: * be destroyed with it.
! 4927: * @URL: the base URL to use for the document
! 4928: * @encoding: the document encoding, or NULL
! 4929: * @options: a combination of xmlParserOption
! 4930: *
! 4931: * Setup an XML reader with new options
! 4932: *
! 4933: * Returns 0 in case of success and -1 in case of error.
! 4934: */
! 4935: int
! 4936: xmlTextReaderSetup(xmlTextReaderPtr reader,
! 4937: xmlParserInputBufferPtr input, const char *URL,
! 4938: const char *encoding, int options)
! 4939: {
! 4940: if (reader == NULL) {
! 4941: if (input != NULL)
! 4942: xmlFreeParserInputBuffer(input);
! 4943: return (-1);
! 4944: }
! 4945:
! 4946: /*
! 4947: * we force the generation of compact text nodes on the reader
! 4948: * since usr applications should never modify the tree
! 4949: */
! 4950: options |= XML_PARSE_COMPACT;
! 4951:
! 4952: reader->doc = NULL;
! 4953: reader->entNr = 0;
! 4954: reader->parserFlags = options;
! 4955: reader->validate = XML_TEXTREADER_NOT_VALIDATE;
! 4956: if ((input != NULL) && (reader->input != NULL) &&
! 4957: (reader->allocs & XML_TEXTREADER_INPUT)) {
! 4958: xmlFreeParserInputBuffer(reader->input);
! 4959: reader->input = NULL;
! 4960: reader->allocs -= XML_TEXTREADER_INPUT;
! 4961: }
! 4962: if (input != NULL) {
! 4963: reader->input = input;
! 4964: reader->allocs |= XML_TEXTREADER_INPUT;
! 4965: }
! 4966: if (reader->buffer == NULL)
! 4967: reader->buffer = xmlBufferCreateSize(100);
! 4968: if (reader->buffer == NULL) {
! 4969: xmlGenericError(xmlGenericErrorContext,
! 4970: "xmlTextReaderSetup : malloc failed\n");
! 4971: return (-1);
! 4972: }
! 4973: if (reader->sax == NULL)
! 4974: reader->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
! 4975: if (reader->sax == NULL) {
! 4976: xmlGenericError(xmlGenericErrorContext,
! 4977: "xmlTextReaderSetup : malloc failed\n");
! 4978: return (-1);
! 4979: }
! 4980: xmlSAXVersion(reader->sax, 2);
! 4981: reader->startElement = reader->sax->startElement;
! 4982: reader->sax->startElement = xmlTextReaderStartElement;
! 4983: reader->endElement = reader->sax->endElement;
! 4984: reader->sax->endElement = xmlTextReaderEndElement;
! 4985: #ifdef LIBXML_SAX1_ENABLED
! 4986: if (reader->sax->initialized == XML_SAX2_MAGIC) {
! 4987: #endif /* LIBXML_SAX1_ENABLED */
! 4988: reader->startElementNs = reader->sax->startElementNs;
! 4989: reader->sax->startElementNs = xmlTextReaderStartElementNs;
! 4990: reader->endElementNs = reader->sax->endElementNs;
! 4991: reader->sax->endElementNs = xmlTextReaderEndElementNs;
! 4992: #ifdef LIBXML_SAX1_ENABLED
! 4993: } else {
! 4994: reader->startElementNs = NULL;
! 4995: reader->endElementNs = NULL;
! 4996: }
! 4997: #endif /* LIBXML_SAX1_ENABLED */
! 4998: reader->characters = reader->sax->characters;
! 4999: reader->sax->characters = xmlTextReaderCharacters;
! 5000: reader->sax->ignorableWhitespace = xmlTextReaderCharacters;
! 5001: reader->cdataBlock = reader->sax->cdataBlock;
! 5002: reader->sax->cdataBlock = xmlTextReaderCDataBlock;
! 5003:
! 5004: reader->mode = XML_TEXTREADER_MODE_INITIAL;
! 5005: reader->node = NULL;
! 5006: reader->curnode = NULL;
! 5007: if (input != NULL) {
! 5008: if (reader->input->buffer->use < 4) {
! 5009: xmlParserInputBufferRead(input, 4);
! 5010: }
! 5011: if (reader->ctxt == NULL) {
! 5012: if (reader->input->buffer->use >= 4) {
! 5013: reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL,
! 5014: (const char *) reader->input->buffer->content, 4, URL);
! 5015: reader->base = 0;
! 5016: reader->cur = 4;
! 5017: } else {
! 5018: reader->ctxt =
! 5019: xmlCreatePushParserCtxt(reader->sax, NULL, NULL, 0, URL);
! 5020: reader->base = 0;
! 5021: reader->cur = 0;
! 5022: }
! 5023: } else {
! 5024: xmlParserInputPtr inputStream;
! 5025: xmlParserInputBufferPtr buf;
! 5026: xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
! 5027:
! 5028: xmlCtxtReset(reader->ctxt);
! 5029: buf = xmlAllocParserInputBuffer(enc);
! 5030: if (buf == NULL) return(-1);
! 5031: inputStream = xmlNewInputStream(reader->ctxt);
! 5032: if (inputStream == NULL) {
! 5033: xmlFreeParserInputBuffer(buf);
! 5034: return(-1);
! 5035: }
! 5036:
! 5037: if (URL == NULL)
! 5038: inputStream->filename = NULL;
! 5039: else
! 5040: inputStream->filename = (char *)
! 5041: xmlCanonicPath((const xmlChar *) URL);
! 5042: inputStream->buf = buf;
! 5043: inputStream->base = inputStream->buf->buffer->content;
! 5044: inputStream->cur = inputStream->buf->buffer->content;
! 5045: inputStream->end =
! 5046: &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
! 5047:
! 5048: inputPush(reader->ctxt, inputStream);
! 5049: reader->cur = 0;
! 5050: }
! 5051: if (reader->ctxt == NULL) {
! 5052: xmlGenericError(xmlGenericErrorContext,
! 5053: "xmlTextReaderSetup : malloc failed\n");
! 5054: return (-1);
! 5055: }
! 5056: }
! 5057: if (reader->dict != NULL) {
! 5058: if (reader->ctxt->dict != NULL) {
! 5059: if (reader->dict != reader->ctxt->dict) {
! 5060: xmlDictFree(reader->dict);
! 5061: reader->dict = reader->ctxt->dict;
! 5062: }
! 5063: } else {
! 5064: reader->ctxt->dict = reader->dict;
! 5065: }
! 5066: } else {
! 5067: if (reader->ctxt->dict == NULL)
! 5068: reader->ctxt->dict = xmlDictCreate();
! 5069: reader->dict = reader->ctxt->dict;
! 5070: }
! 5071: reader->ctxt->_private = reader;
! 5072: reader->ctxt->linenumbers = 1;
! 5073: reader->ctxt->dictNames = 1;
! 5074: /*
! 5075: * use the parser dictionnary to allocate all elements and attributes names
! 5076: */
! 5077: reader->ctxt->docdict = 1;
! 5078: reader->ctxt->parseMode = XML_PARSE_READER;
! 5079:
! 5080: #ifdef LIBXML_XINCLUDE_ENABLED
! 5081: if (reader->xincctxt != NULL) {
! 5082: xmlXIncludeFreeContext(reader->xincctxt);
! 5083: reader->xincctxt = NULL;
! 5084: }
! 5085: if (options & XML_PARSE_XINCLUDE) {
! 5086: reader->xinclude = 1;
! 5087: reader->xinclude_name = xmlDictLookup(reader->dict, XINCLUDE_NODE, -1);
! 5088: options -= XML_PARSE_XINCLUDE;
! 5089: } else
! 5090: reader->xinclude = 0;
! 5091: reader->in_xinclude = 0;
! 5092: #endif
! 5093: #ifdef LIBXML_PATTERN_ENABLED
! 5094: if (reader->patternTab == NULL) {
! 5095: reader->patternNr = 0;
! 5096: reader->patternMax = 0;
! 5097: }
! 5098: while (reader->patternNr > 0) {
! 5099: reader->patternNr--;
! 5100: if (reader->patternTab[reader->patternNr] != NULL) {
! 5101: xmlFreePattern(reader->patternTab[reader->patternNr]);
! 5102: reader->patternTab[reader->patternNr] = NULL;
! 5103: }
! 5104: }
! 5105: #endif
! 5106:
! 5107: if (options & XML_PARSE_DTDVALID)
! 5108: reader->validate = XML_TEXTREADER_VALIDATE_DTD;
! 5109:
! 5110: xmlCtxtUseOptions(reader->ctxt, options);
! 5111: if (encoding != NULL) {
! 5112: xmlCharEncodingHandlerPtr hdlr;
! 5113:
! 5114: hdlr = xmlFindCharEncodingHandler(encoding);
! 5115: if (hdlr != NULL)
! 5116: xmlSwitchToEncoding(reader->ctxt, hdlr);
! 5117: }
! 5118: if ((URL != NULL) && (reader->ctxt->input != NULL) &&
! 5119: (reader->ctxt->input->filename == NULL))
! 5120: reader->ctxt->input->filename = (char *)
! 5121: xmlStrdup((const xmlChar *) URL);
! 5122:
! 5123: reader->doc = NULL;
! 5124:
! 5125: return (0);
! 5126: }
! 5127:
! 5128: /**
! 5129: * xmlTextReaderByteConsumed:
! 5130: * @reader: an XML reader
! 5131: *
! 5132: * This function provides the current index of the parser used
! 5133: * by the reader, relative to the start of the current entity.
! 5134: * This function actually just wraps a call to xmlBytesConsumed()
! 5135: * for the parser context associated with the reader.
! 5136: * See xmlBytesConsumed() for more information.
! 5137: *
! 5138: * Returns the index in bytes from the beginning of the entity or -1
! 5139: * in case the index could not be computed.
! 5140: */
! 5141: long
! 5142: xmlTextReaderByteConsumed(xmlTextReaderPtr reader) {
! 5143: if ((reader == NULL) || (reader->ctxt == NULL))
! 5144: return(-1);
! 5145: return(xmlByteConsumed(reader->ctxt));
! 5146: }
! 5147:
! 5148:
! 5149: /**
! 5150: * xmlReaderWalker:
! 5151: * @doc: a preparsed document
! 5152: *
! 5153: * Create an xmltextReader for a preparsed document.
! 5154: *
! 5155: * Returns the new reader or NULL in case of error.
! 5156: */
! 5157: xmlTextReaderPtr
! 5158: xmlReaderWalker(xmlDocPtr doc)
! 5159: {
! 5160: xmlTextReaderPtr ret;
! 5161:
! 5162: if (doc == NULL)
! 5163: return(NULL);
! 5164:
! 5165: ret = xmlMalloc(sizeof(xmlTextReader));
! 5166: if (ret == NULL) {
! 5167: xmlGenericError(xmlGenericErrorContext,
! 5168: "xmlNewTextReader : malloc failed\n");
! 5169: return(NULL);
! 5170: }
! 5171: memset(ret, 0, sizeof(xmlTextReader));
! 5172: ret->entNr = 0;
! 5173: ret->input = NULL;
! 5174: ret->mode = XML_TEXTREADER_MODE_INITIAL;
! 5175: ret->node = NULL;
! 5176: ret->curnode = NULL;
! 5177: ret->base = 0;
! 5178: ret->cur = 0;
! 5179: ret->allocs = XML_TEXTREADER_CTXT;
! 5180: ret->doc = doc;
! 5181: ret->state = XML_TEXTREADER_START;
! 5182: ret->dict = xmlDictCreate();
! 5183: return(ret);
! 5184: }
! 5185:
! 5186: /**
! 5187: * xmlReaderForDoc:
! 5188: * @cur: a pointer to a zero terminated string
! 5189: * @URL: the base URL to use for the document
! 5190: * @encoding: the document encoding, or NULL
! 5191: * @options: a combination of xmlParserOption
! 5192: *
! 5193: * Create an xmltextReader for an XML in-memory document.
! 5194: * The parsing flags @options are a combination of xmlParserOption.
! 5195: *
! 5196: * Returns the new reader or NULL in case of error.
! 5197: */
! 5198: xmlTextReaderPtr
! 5199: xmlReaderForDoc(const xmlChar * cur, const char *URL, const char *encoding,
! 5200: int options)
! 5201: {
! 5202: int len;
! 5203:
! 5204: if (cur == NULL)
! 5205: return (NULL);
! 5206: len = xmlStrlen(cur);
! 5207:
! 5208: return (xmlReaderForMemory
! 5209: ((const char *) cur, len, URL, encoding, options));
! 5210: }
! 5211:
! 5212: /**
! 5213: * xmlReaderForFile:
! 5214: * @filename: a file or URL
! 5215: * @encoding: the document encoding, or NULL
! 5216: * @options: a combination of xmlParserOption
! 5217: *
! 5218: * parse an XML file from the filesystem or the network.
! 5219: * The parsing flags @options are a combination of xmlParserOption.
! 5220: *
! 5221: * Returns the new reader or NULL in case of error.
! 5222: */
! 5223: xmlTextReaderPtr
! 5224: xmlReaderForFile(const char *filename, const char *encoding, int options)
! 5225: {
! 5226: xmlTextReaderPtr reader;
! 5227:
! 5228: reader = xmlNewTextReaderFilename(filename);
! 5229: if (reader == NULL)
! 5230: return (NULL);
! 5231: xmlTextReaderSetup(reader, NULL, NULL, encoding, options);
! 5232: return (reader);
! 5233: }
! 5234:
! 5235: /**
! 5236: * xmlReaderForMemory:
! 5237: * @buffer: a pointer to a char array
! 5238: * @size: the size of the array
! 5239: * @URL: the base URL to use for the document
! 5240: * @encoding: the document encoding, or NULL
! 5241: * @options: a combination of xmlParserOption
! 5242: *
! 5243: * Create an xmltextReader for an XML in-memory document.
! 5244: * The parsing flags @options are a combination of xmlParserOption.
! 5245: *
! 5246: * Returns the new reader or NULL in case of error.
! 5247: */
! 5248: xmlTextReaderPtr
! 5249: xmlReaderForMemory(const char *buffer, int size, const char *URL,
! 5250: const char *encoding, int options)
! 5251: {
! 5252: xmlTextReaderPtr reader;
! 5253: xmlParserInputBufferPtr buf;
! 5254:
! 5255: buf = xmlParserInputBufferCreateStatic(buffer, size,
! 5256: XML_CHAR_ENCODING_NONE);
! 5257: if (buf == NULL) {
! 5258: return (NULL);
! 5259: }
! 5260: reader = xmlNewTextReader(buf, URL);
! 5261: if (reader == NULL) {
! 5262: xmlFreeParserInputBuffer(buf);
! 5263: return (NULL);
! 5264: }
! 5265: reader->allocs |= XML_TEXTREADER_INPUT;
! 5266: xmlTextReaderSetup(reader, NULL, URL, encoding, options);
! 5267: return (reader);
! 5268: }
! 5269:
! 5270: /**
! 5271: * xmlReaderForFd:
! 5272: * @fd: an open file descriptor
! 5273: * @URL: the base URL to use for the document
! 5274: * @encoding: the document encoding, or NULL
! 5275: * @options: a combination of xmlParserOption
! 5276: *
! 5277: * Create an xmltextReader for an XML from a file descriptor.
! 5278: * The parsing flags @options are a combination of xmlParserOption.
! 5279: * NOTE that the file descriptor will not be closed when the
! 5280: * reader is closed or reset.
! 5281: *
! 5282: * Returns the new reader or NULL in case of error.
! 5283: */
! 5284: xmlTextReaderPtr
! 5285: xmlReaderForFd(int fd, const char *URL, const char *encoding, int options)
! 5286: {
! 5287: xmlTextReaderPtr reader;
! 5288: xmlParserInputBufferPtr input;
! 5289:
! 5290: if (fd < 0)
! 5291: return (NULL);
! 5292:
! 5293: input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
! 5294: if (input == NULL)
! 5295: return (NULL);
! 5296: input->closecallback = NULL;
! 5297: reader = xmlNewTextReader(input, URL);
! 5298: if (reader == NULL) {
! 5299: xmlFreeParserInputBuffer(input);
! 5300: return (NULL);
! 5301: }
! 5302: reader->allocs |= XML_TEXTREADER_INPUT;
! 5303: xmlTextReaderSetup(reader, NULL, URL, encoding, options);
! 5304: return (reader);
! 5305: }
! 5306:
! 5307: /**
! 5308: * xmlReaderForIO:
! 5309: * @ioread: an I/O read function
! 5310: * @ioclose: an I/O close function
! 5311: * @ioctx: an I/O handler
! 5312: * @URL: the base URL to use for the document
! 5313: * @encoding: the document encoding, or NULL
! 5314: * @options: a combination of xmlParserOption
! 5315: *
! 5316: * Create an xmltextReader for an XML document from I/O functions and source.
! 5317: * The parsing flags @options are a combination of xmlParserOption.
! 5318: *
! 5319: * Returns the new reader or NULL in case of error.
! 5320: */
! 5321: xmlTextReaderPtr
! 5322: xmlReaderForIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
! 5323: void *ioctx, const char *URL, const char *encoding,
! 5324: int options)
! 5325: {
! 5326: xmlTextReaderPtr reader;
! 5327: xmlParserInputBufferPtr input;
! 5328:
! 5329: if (ioread == NULL)
! 5330: return (NULL);
! 5331:
! 5332: input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
! 5333: XML_CHAR_ENCODING_NONE);
! 5334: if (input == NULL)
! 5335: return (NULL);
! 5336: reader = xmlNewTextReader(input, URL);
! 5337: if (reader == NULL) {
! 5338: xmlFreeParserInputBuffer(input);
! 5339: return (NULL);
! 5340: }
! 5341: reader->allocs |= XML_TEXTREADER_INPUT;
! 5342: xmlTextReaderSetup(reader, NULL, URL, encoding, options);
! 5343: return (reader);
! 5344: }
! 5345:
! 5346: /**
! 5347: * xmlReaderNewWalker:
! 5348: * @reader: an XML reader
! 5349: * @doc: a preparsed document
! 5350: *
! 5351: * Setup an xmltextReader to parse a preparsed XML document.
! 5352: * This reuses the existing @reader xmlTextReader.
! 5353: *
! 5354: * Returns 0 in case of success and -1 in case of error
! 5355: */
! 5356: int
! 5357: xmlReaderNewWalker(xmlTextReaderPtr reader, xmlDocPtr doc)
! 5358: {
! 5359: if (doc == NULL)
! 5360: return (-1);
! 5361: if (reader == NULL)
! 5362: return (-1);
! 5363:
! 5364: if (reader->input != NULL) {
! 5365: xmlFreeParserInputBuffer(reader->input);
! 5366: }
! 5367: if (reader->ctxt != NULL) {
! 5368: xmlCtxtReset(reader->ctxt);
! 5369: }
! 5370:
! 5371: reader->entNr = 0;
! 5372: reader->input = NULL;
! 5373: reader->mode = XML_TEXTREADER_MODE_INITIAL;
! 5374: reader->node = NULL;
! 5375: reader->curnode = NULL;
! 5376: reader->base = 0;
! 5377: reader->cur = 0;
! 5378: reader->allocs = XML_TEXTREADER_CTXT;
! 5379: reader->doc = doc;
! 5380: reader->state = XML_TEXTREADER_START;
! 5381: if (reader->dict == NULL) {
! 5382: if ((reader->ctxt != NULL) && (reader->ctxt->dict != NULL))
! 5383: reader->dict = reader->ctxt->dict;
! 5384: else
! 5385: reader->dict = xmlDictCreate();
! 5386: }
! 5387: return(0);
! 5388: }
! 5389:
! 5390: /**
! 5391: * xmlReaderNewDoc:
! 5392: * @reader: an XML reader
! 5393: * @cur: a pointer to a zero terminated string
! 5394: * @URL: the base URL to use for the document
! 5395: * @encoding: the document encoding, or NULL
! 5396: * @options: a combination of xmlParserOption
! 5397: *
! 5398: * Setup an xmltextReader to parse an XML in-memory document.
! 5399: * The parsing flags @options are a combination of xmlParserOption.
! 5400: * This reuses the existing @reader xmlTextReader.
! 5401: *
! 5402: * Returns 0 in case of success and -1 in case of error
! 5403: */
! 5404: int
! 5405: xmlReaderNewDoc(xmlTextReaderPtr reader, const xmlChar * cur,
! 5406: const char *URL, const char *encoding, int options)
! 5407: {
! 5408:
! 5409: int len;
! 5410:
! 5411: if (cur == NULL)
! 5412: return (-1);
! 5413: if (reader == NULL)
! 5414: return (-1);
! 5415:
! 5416: len = xmlStrlen(cur);
! 5417: return (xmlReaderNewMemory(reader, (const char *)cur, len,
! 5418: URL, encoding, options));
! 5419: }
! 5420:
! 5421: /**
! 5422: * xmlReaderNewFile:
! 5423: * @reader: an XML reader
! 5424: * @filename: a file or URL
! 5425: * @encoding: the document encoding, or NULL
! 5426: * @options: a combination of xmlParserOption
! 5427: *
! 5428: * parse an XML file from the filesystem or the network.
! 5429: * The parsing flags @options are a combination of xmlParserOption.
! 5430: * This reuses the existing @reader xmlTextReader.
! 5431: *
! 5432: * Returns 0 in case of success and -1 in case of error
! 5433: */
! 5434: int
! 5435: xmlReaderNewFile(xmlTextReaderPtr reader, const char *filename,
! 5436: const char *encoding, int options)
! 5437: {
! 5438: xmlParserInputBufferPtr input;
! 5439:
! 5440: if (filename == NULL)
! 5441: return (-1);
! 5442: if (reader == NULL)
! 5443: return (-1);
! 5444:
! 5445: input =
! 5446: xmlParserInputBufferCreateFilename(filename,
! 5447: XML_CHAR_ENCODING_NONE);
! 5448: if (input == NULL)
! 5449: return (-1);
! 5450: return (xmlTextReaderSetup(reader, input, filename, encoding, options));
! 5451: }
! 5452:
! 5453: /**
! 5454: * xmlReaderNewMemory:
! 5455: * @reader: an XML reader
! 5456: * @buffer: a pointer to a char array
! 5457: * @size: the size of the array
! 5458: * @URL: the base URL to use for the document
! 5459: * @encoding: the document encoding, or NULL
! 5460: * @options: a combination of xmlParserOption
! 5461: *
! 5462: * Setup an xmltextReader to parse an XML in-memory document.
! 5463: * The parsing flags @options are a combination of xmlParserOption.
! 5464: * This reuses the existing @reader xmlTextReader.
! 5465: *
! 5466: * Returns 0 in case of success and -1 in case of error
! 5467: */
! 5468: int
! 5469: xmlReaderNewMemory(xmlTextReaderPtr reader, const char *buffer, int size,
! 5470: const char *URL, const char *encoding, int options)
! 5471: {
! 5472: xmlParserInputBufferPtr input;
! 5473:
! 5474: if (reader == NULL)
! 5475: return (-1);
! 5476: if (buffer == NULL)
! 5477: return (-1);
! 5478:
! 5479: input = xmlParserInputBufferCreateStatic(buffer, size,
! 5480: XML_CHAR_ENCODING_NONE);
! 5481: if (input == NULL) {
! 5482: return (-1);
! 5483: }
! 5484: return (xmlTextReaderSetup(reader, input, URL, encoding, options));
! 5485: }
! 5486:
! 5487: /**
! 5488: * xmlReaderNewFd:
! 5489: * @reader: an XML reader
! 5490: * @fd: an open file descriptor
! 5491: * @URL: the base URL to use for the document
! 5492: * @encoding: the document encoding, or NULL
! 5493: * @options: a combination of xmlParserOption
! 5494: *
! 5495: * Setup an xmltextReader to parse an XML from a file descriptor.
! 5496: * NOTE that the file descriptor will not be closed when the
! 5497: * reader is closed or reset.
! 5498: * The parsing flags @options are a combination of xmlParserOption.
! 5499: * This reuses the existing @reader xmlTextReader.
! 5500: *
! 5501: * Returns 0 in case of success and -1 in case of error
! 5502: */
! 5503: int
! 5504: xmlReaderNewFd(xmlTextReaderPtr reader, int fd,
! 5505: const char *URL, const char *encoding, int options)
! 5506: {
! 5507: xmlParserInputBufferPtr input;
! 5508:
! 5509: if (fd < 0)
! 5510: return (-1);
! 5511: if (reader == NULL)
! 5512: return (-1);
! 5513:
! 5514: input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
! 5515: if (input == NULL)
! 5516: return (-1);
! 5517: input->closecallback = NULL;
! 5518: return (xmlTextReaderSetup(reader, input, URL, encoding, options));
! 5519: }
! 5520:
! 5521: /**
! 5522: * xmlReaderNewIO:
! 5523: * @reader: an XML reader
! 5524: * @ioread: an I/O read function
! 5525: * @ioclose: an I/O close function
! 5526: * @ioctx: an I/O handler
! 5527: * @URL: the base URL to use for the document
! 5528: * @encoding: the document encoding, or NULL
! 5529: * @options: a combination of xmlParserOption
! 5530: *
! 5531: * Setup an xmltextReader to parse an XML document from I/O functions
! 5532: * and source.
! 5533: * The parsing flags @options are a combination of xmlParserOption.
! 5534: * This reuses the existing @reader xmlTextReader.
! 5535: *
! 5536: * Returns 0 in case of success and -1 in case of error
! 5537: */
! 5538: int
! 5539: xmlReaderNewIO(xmlTextReaderPtr reader, xmlInputReadCallback ioread,
! 5540: xmlInputCloseCallback ioclose, void *ioctx,
! 5541: const char *URL, const char *encoding, int options)
! 5542: {
! 5543: xmlParserInputBufferPtr input;
! 5544:
! 5545: if (ioread == NULL)
! 5546: return (-1);
! 5547: if (reader == NULL)
! 5548: return (-1);
! 5549:
! 5550: input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
! 5551: XML_CHAR_ENCODING_NONE);
! 5552: if (input == NULL)
! 5553: return (-1);
! 5554: return (xmlTextReaderSetup(reader, input, URL, encoding, options));
! 5555: }
! 5556: /************************************************************************
! 5557: * *
! 5558: * Utilities *
! 5559: * *
! 5560: ************************************************************************/
! 5561: #ifdef NOT_USED_YET
! 5562:
! 5563: /**
! 5564: * xmlBase64Decode:
! 5565: * @in: the input buffer
! 5566: * @inlen: the size of the input (in), the size read from it (out)
! 5567: * @to: the output buffer
! 5568: * @tolen: the size of the output (in), the size written to (out)
! 5569: *
! 5570: * Base64 decoder, reads from @in and save in @to
! 5571: * TODO: tell jody when this is actually exported
! 5572: *
! 5573: * Returns 0 if all the input was consumer, 1 if the Base64 end was reached,
! 5574: * 2 if there wasn't enough space on the output or -1 in case of error.
! 5575: */
! 5576: static int
! 5577: xmlBase64Decode(const unsigned char *in, unsigned long *inlen,
! 5578: unsigned char *to, unsigned long *tolen)
! 5579: {
! 5580: unsigned long incur; /* current index in in[] */
! 5581:
! 5582: unsigned long inblk; /* last block index in in[] */
! 5583:
! 5584: unsigned long outcur; /* current index in out[] */
! 5585:
! 5586: unsigned long inmax; /* size of in[] */
! 5587:
! 5588: unsigned long outmax; /* size of out[] */
! 5589:
! 5590: unsigned char cur; /* the current value read from in[] */
! 5591:
! 5592: unsigned char intmp[4], outtmp[4]; /* temporary buffers for the convert */
! 5593:
! 5594: int nbintmp; /* number of byte in intmp[] */
! 5595:
! 5596: int is_ignore; /* cur should be ignored */
! 5597:
! 5598: int is_end = 0; /* the end of the base64 was found */
! 5599:
! 5600: int retval = 1;
! 5601:
! 5602: int i;
! 5603:
! 5604: if ((in == NULL) || (inlen == NULL) || (to == NULL) || (tolen == NULL))
! 5605: return (-1);
! 5606:
! 5607: incur = 0;
! 5608: inblk = 0;
! 5609: outcur = 0;
! 5610: inmax = *inlen;
! 5611: outmax = *tolen;
! 5612: nbintmp = 0;
! 5613:
! 5614: while (1) {
! 5615: if (incur >= inmax)
! 5616: break;
! 5617: cur = in[incur++];
! 5618: is_ignore = 0;
! 5619: if ((cur >= 'A') && (cur <= 'Z'))
! 5620: cur = cur - 'A';
! 5621: else if ((cur >= 'a') && (cur <= 'z'))
! 5622: cur = cur - 'a' + 26;
! 5623: else if ((cur >= '0') && (cur <= '9'))
! 5624: cur = cur - '0' + 52;
! 5625: else if (cur == '+')
! 5626: cur = 62;
! 5627: else if (cur == '/')
! 5628: cur = 63;
! 5629: else if (cur == '.')
! 5630: cur = 0;
! 5631: else if (cur == '=') /*no op , end of the base64 stream */
! 5632: is_end = 1;
! 5633: else {
! 5634: is_ignore = 1;
! 5635: if (nbintmp == 0)
! 5636: inblk = incur;
! 5637: }
! 5638:
! 5639: if (!is_ignore) {
! 5640: int nbouttmp = 3;
! 5641:
! 5642: int is_break = 0;
! 5643:
! 5644: if (is_end) {
! 5645: if (nbintmp == 0)
! 5646: break;
! 5647: if ((nbintmp == 1) || (nbintmp == 2))
! 5648: nbouttmp = 1;
! 5649: else
! 5650: nbouttmp = 2;
! 5651: nbintmp = 3;
! 5652: is_break = 1;
! 5653: }
! 5654: intmp[nbintmp++] = cur;
! 5655: /*
! 5656: * if intmp is full, push the 4byte sequence as a 3 byte
! 5657: * sequence out
! 5658: */
! 5659: if (nbintmp == 4) {
! 5660: nbintmp = 0;
! 5661: outtmp[0] = (intmp[0] << 2) | ((intmp[1] & 0x30) >> 4);
! 5662: outtmp[1] =
! 5663: ((intmp[1] & 0x0F) << 4) | ((intmp[2] & 0x3C) >> 2);
! 5664: outtmp[2] = ((intmp[2] & 0x03) << 6) | (intmp[3] & 0x3F);
! 5665: if (outcur + 3 >= outmax) {
! 5666: retval = 2;
! 5667: break;
! 5668: }
! 5669:
! 5670: for (i = 0; i < nbouttmp; i++)
! 5671: to[outcur++] = outtmp[i];
! 5672: inblk = incur;
! 5673: }
! 5674:
! 5675: if (is_break) {
! 5676: retval = 0;
! 5677: break;
! 5678: }
! 5679: }
! 5680: }
! 5681:
! 5682: *tolen = outcur;
! 5683: *inlen = inblk;
! 5684: return (retval);
! 5685: }
! 5686:
! 5687: /*
! 5688: * Test routine for the xmlBase64Decode function
! 5689: */
! 5690: #if 0
! 5691: int
! 5692: main(int argc, char **argv)
! 5693: {
! 5694: char *input = " VW4 gcGV0 \n aXQgdGVzdCAuCg== ";
! 5695:
! 5696: char output[100];
! 5697:
! 5698: char output2[100];
! 5699:
! 5700: char output3[100];
! 5701:
! 5702: unsigned long inlen = strlen(input);
! 5703:
! 5704: unsigned long outlen = 100;
! 5705:
! 5706: int ret;
! 5707:
! 5708: unsigned long cons, tmp, tmp2, prod;
! 5709:
! 5710: /*
! 5711: * Direct
! 5712: */
! 5713: ret = xmlBase64Decode(input, &inlen, output, &outlen);
! 5714:
! 5715: output[outlen] = 0;
! 5716: printf("ret: %d, inlen: %ld , outlen: %ld, output: '%s'\n", ret, inlen,
! 5717: outlen, output)indent: Standard input:179: Error:Unmatched #endif
! 5718: ;
! 5719:
! 5720: /*
! 5721: * output chunking
! 5722: */
! 5723: cons = 0;
! 5724: prod = 0;
! 5725: while (cons < inlen) {
! 5726: tmp = 5;
! 5727: tmp2 = inlen - cons;
! 5728:
! 5729: printf("%ld %ld\n", cons, prod);
! 5730: ret = xmlBase64Decode(&input[cons], &tmp2, &output2[prod], &tmp);
! 5731: cons += tmp2;
! 5732: prod += tmp;
! 5733: printf("%ld %ld\n", cons, prod);
! 5734: }
! 5735: output2[outlen] = 0;
! 5736: printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons,
! 5737: prod, output2);
! 5738:
! 5739: /*
! 5740: * input chunking
! 5741: */
! 5742: cons = 0;
! 5743: prod = 0;
! 5744: while (cons < inlen) {
! 5745: tmp = 100 - prod;
! 5746: tmp2 = inlen - cons;
! 5747: if (tmp2 > 5)
! 5748: tmp2 = 5;
! 5749:
! 5750: printf("%ld %ld\n", cons, prod);
! 5751: ret = xmlBase64Decode(&input[cons], &tmp2, &output3[prod], &tmp);
! 5752: cons += tmp2;
! 5753: prod += tmp;
! 5754: printf("%ld %ld\n", cons, prod);
! 5755: }
! 5756: output3[outlen] = 0;
! 5757: printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons,
! 5758: prod, output3);
! 5759: return (0);
! 5760:
! 5761: }
! 5762: #endif
! 5763: #endif /* NOT_USED_YET */
! 5764: #define bottom_xmlreader
! 5765: #include "elfgcchack.h"
! 5766: #endif /* LIBXML_READER_ENABLED */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmlreader.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2