xmlreader.c

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