gnulib-local/lib/libxml/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 dictionnary */
 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" dictionnary 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 dictionnary 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 positive 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);
4054
4055 static void XMLCDECL
4056 xmlTextReaderValidityError(void *ctxt, const char *msg, ...);
4057
4058 static void XMLCDECL
4059 xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...);
4060
4061 static void XMLCDECL
4062 xmlTextReaderValidityErrorRelay(void *ctx, const char *msg, ...)
4063 {
4064     xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
4065
4066     char *str;
4067
4068     va_list ap;
4069
4070     va_start(ap, msg);
4071     str = xmlTextReaderBuildMessage(msg, ap);
4072     if (!reader->errorFunc) {
4073         xmlTextReaderValidityError(ctx, "%s", str);
4074     } else {
4075         reader->errorFunc(reader->errorFuncArg, str,
4076                           XML_PARSER_SEVERITY_VALIDITY_ERROR,
4077                           NULL /* locator */ );
4078     }
4079     if (str != NULL)
4080         xmlFree(str);
4081     va_end(ap);
4082 }
4083
4084 static void XMLCDECL
4085 xmlTextReaderValidityWarningRelay(void *ctx, const char *msg, ...)
4086 {
4087     xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
4088
4089     char *str;
4090
4091     va_list ap;
4092
4093     va_start(ap, msg);
4094     str = xmlTextReaderBuildMessage(msg, ap);
4095     if (!reader->errorFunc) {
4096         xmlTextReaderValidityWarning(ctx, "%s", str);
4097     } else {
4098         reader->errorFunc(reader->errorFuncArg, str,
4099                           XML_PARSER_SEVERITY_VALIDITY_WARNING,
4100                           NULL /* locator */ );
4101     }
4102     if (str != NULL)
4103         xmlFree(str);
4104     va_end(ap);
4105 }
4106
4107 static void
4108   xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error);
4109
4110 static void
4111 xmlTextReaderValidityStructuredRelay(void *userData, xmlErrorPtr error)
4112 {
4113     xmlTextReaderPtr reader = (xmlTextReaderPtr) userData;
4114
4115     if (reader->sErrorFunc) {
4116         reader->sErrorFunc(reader->errorFuncArg, error);
4117     } else {
4118         xmlTextReaderStructuredError(reader, error);
4119     }
4120 }
4121 /**
4122  * xmlTextReaderRelaxNGSetSchema:
4123  * @reader:  the xmlTextReaderPtr used
4124  * @schema:  a precompiled RelaxNG schema
4125  *
4126  * Use RelaxNG to validate the document as it is processed.
4127  * Activation is only possible before the first Read().
4128  * if @schema is NULL, then RelaxNG validation is desactivated.
4129  @ The @schema should not be freed until the reader is deallocated
4130  * or its use has been deactivated.
4131  *
4132  * Returns 0 in case the RelaxNG validation could be (des)activated and
4133  *         -1 in case of error.
4134  */
4135 int
4136 xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, xmlRelaxNGPtr schema) {
4137     if (reader == NULL)
4138         return(-1);
4139     if (schema == NULL) {
4140         if (reader->rngSchemas != NULL) {
4141             xmlRelaxNGFree(reader->rngSchemas);
4142             reader->rngSchemas = NULL;
4143         }
4144         if (reader->rngValidCtxt != NULL) {
4145             if (! reader->rngPreserveCtxt)
4146                 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4147             reader->rngValidCtxt = NULL;
4148         }
4149         reader->rngPreserveCtxt = 0;
4150         return(0);
4151     }
4152     if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4153         return(-1);
4154     if (reader->rngSchemas != NULL) {
4155         xmlRelaxNGFree(reader->rngSchemas);
4156         reader->rngSchemas = NULL;
4157     }
4158     if (reader->rngValidCtxt != NULL) {
4159         if (! reader->rngPreserveCtxt)
4160             xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4161         reader->rngValidCtxt = NULL;
4162     }
4163     reader->rngPreserveCtxt = 0;
4164     reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(schema);
4165     if (reader->rngValidCtxt == NULL)
4166         return(-1);
4167     if (reader->errorFunc != NULL) {
4168         xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4169                         xmlTextReaderValidityErrorRelay,
4170                         xmlTextReaderValidityWarningRelay,
4171                         reader);
4172     }
4173         if (reader->sErrorFunc != NULL) {
4174                 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4175                         xmlTextReaderValidityStructuredRelay,
4176                         reader);
4177     }
4178     reader->rngValidErrors = 0;
4179     reader->rngFullNode = NULL;
4180     reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4181     return(0);
4182 }
4183
4184 /**
4185  * xmlTextReaderLocator:
4186  * @ctx: the xmlTextReaderPtr used
4187  * @file: returned file information
4188  * @line: returned line information
4189  *
4190  * Internal locator function for the readers
4191  *
4192  * Returns 0 in case the Schema validation could be (des)activated and
4193  *         -1 in case of error.
4194  */
4195 static int
4196 xmlTextReaderLocator(void *ctx, const char **file, unsigned long *line) {
4197     xmlTextReaderPtr reader;
4198
4199     if ((ctx == NULL) || ((file == NULL) && (line == NULL)))
4200         return(-1);
4201
4202     if (file != NULL)
4203         *file = NULL;
4204     if (line != NULL)
4205         *line = 0;
4206
4207     reader = (xmlTextReaderPtr) ctx;
4208     if ((reader->ctxt != NULL) && (reader->ctxt->input != NULL)) {
4209         if (file != NULL)
4210             *file = reader->ctxt->input->filename;
4211         if (line != NULL)
4212             *line = reader->ctxt->input->line;
4213         return(0);
4214     }
4215     if (reader->node != NULL) {
4216         long res;
4217         int ret = 0;
4218
4219         if (line != NULL) {
4220             res = xmlGetLineNo(reader->node);
4221             if (res > 0)
4222                 *line = (unsigned long) res;
4223             else
4224                 ret = -1;
4225         }
4226         if (file != NULL) {
4227             xmlDocPtr doc = reader->node->doc;
4228             if ((doc != NULL) && (doc->URL != NULL))
4229                 *file = (const char *) doc->URL;
4230             else
4231                 ret = -1;
4232         }
4233         return(ret);
4234     }
4235     return(-1);
4236 }
4237
4238 /**
4239  * xmlTextReaderSetSchema:
4240  * @reader:  the xmlTextReaderPtr used
4241  * @schema:  a precompiled Schema schema
4242  *
4243  * Use XSD Schema to validate the document as it is processed.
4244  * Activation is only possible before the first Read().
4245  * if @schema is NULL, then Schema validation is desactivated.
4246  @ The @schema should not be freed until the reader is deallocated
4247  * or its use has been deactivated.
4248  *
4249  * Returns 0 in case the Schema validation could be (des)activated and
4250  *         -1 in case of error.
4251  */
4252 int
4253 xmlTextReaderSetSchema(xmlTextReaderPtr reader, xmlSchemaPtr schema) {
4254     if (reader == NULL)
4255         return(-1);
4256     if (schema == NULL) {
4257         if (reader->xsdPlug != NULL) {
4258             xmlSchemaSAXUnplug(reader->xsdPlug);
4259             reader->xsdPlug = NULL;
4260         }
4261         if (reader->xsdValidCtxt != NULL) {
4262             if (! reader->xsdPreserveCtxt)
4263                 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4264             reader->xsdValidCtxt = NULL;
4265         }
4266         reader->xsdPreserveCtxt = 0;
4267         if (reader->xsdSchemas != NULL) {
4268             xmlSchemaFree(reader->xsdSchemas);
4269             reader->xsdSchemas = NULL;
4270         }
4271         return(0);
4272     }
4273     if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4274         return(-1);
4275     if (reader->xsdPlug != NULL) {
4276         xmlSchemaSAXUnplug(reader->xsdPlug);
4277         reader->xsdPlug = NULL;
4278     }
4279     if (reader->xsdValidCtxt != NULL) {
4280         if (! reader->xsdPreserveCtxt)
4281             xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4282         reader->xsdValidCtxt = NULL;
4283     }
4284     reader->xsdPreserveCtxt = 0;
4285     if (reader->xsdSchemas != NULL) {
4286         xmlSchemaFree(reader->xsdSchemas);
4287         reader->xsdSchemas = NULL;
4288     }
4289     reader->xsdValidCtxt = xmlSchemaNewValidCtxt(schema);
4290     if (reader->xsdValidCtxt == NULL) {
4291         xmlSchemaFree(reader->xsdSchemas);
4292         reader->xsdSchemas = NULL;
4293         return(-1);
4294     }
4295     reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4296                                        &(reader->ctxt->sax),
4297                                        &(reader->ctxt->userData));
4298     if (reader->xsdPlug == NULL) {
4299         xmlSchemaFree(reader->xsdSchemas);
4300         reader->xsdSchemas = NULL;
4301         xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4302         reader->xsdValidCtxt = NULL;
4303         return(-1);
4304     }
4305     xmlSchemaValidateSetLocator(reader->xsdValidCtxt,
4306                                 xmlTextReaderLocator,
4307                                 (void *) reader);
4308
4309     if (reader->errorFunc != NULL) {
4310         xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4311                         xmlTextReaderValidityErrorRelay,
4312                         xmlTextReaderValidityWarningRelay,
4313                         reader);
4314     }
4315         if (reader->sErrorFunc != NULL) {
4316                 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4317                         xmlTextReaderValidityStructuredRelay,
4318                         reader);
4319     }
4320     reader->xsdValidErrors = 0;
4321     reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4322     return(0);
4323 }
4324
4325 /**
4326  * xmlTextReaderRelaxNGValidateInternal:
4327  * @reader:  the xmlTextReaderPtr used
4328  * @rng:  the path to a RelaxNG schema or NULL
4329  * @ctxt: the RelaxNG schema validation context or NULL
4330  * @options: options (not yet used)
4331  *
4332  * Use RelaxNG to validate the document as it is processed.
4333  * Activation is only possible before the first Read().
4334  * If both @rng and @ctxt are NULL, then RelaxNG validation is deactivated.
4335  *
4336  * Returns 0 in case the RelaxNG validation could be (de)activated and
4337  *         -1 in case of error.
4338  */
4339 static int
4340 xmlTextReaderRelaxNGValidateInternal(xmlTextReaderPtr reader,
4341                                      const char *rng,
4342                                      xmlRelaxNGValidCtxtPtr ctxt,
4343                                      int options ATTRIBUTE_UNUSED)
4344 {
4345     if (reader == NULL)
4346         return(-1);
4347
4348     if ((rng != NULL) && (ctxt != NULL))
4349         return (-1);
4350
4351     if (((rng != NULL) || (ctxt != NULL)) &&
4352         ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
4353          (reader->ctxt == NULL)))
4354         return(-1);
4355
4356     /* Cleanup previous validation stuff. */
4357     if (reader->rngValidCtxt != NULL) {
4358         if ( !reader->rngPreserveCtxt)
4359             xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4360         reader->rngValidCtxt = NULL;
4361     }
4362     reader->rngPreserveCtxt = 0;
4363     if (reader->rngSchemas != NULL) {
4364         xmlRelaxNGFree(reader->rngSchemas);
4365         reader->rngSchemas = NULL;
4366     }
4367
4368     if ((rng == NULL) && (ctxt == NULL)) {
4369         /* We just want to deactivate the validation, so get out. */
4370         return(0);
4371     }
4372
4373
4374     if (rng != NULL) {
4375         xmlRelaxNGParserCtxtPtr pctxt;
4376         /* Parse the schema and create validation environment. */
4377
4378         pctxt = xmlRelaxNGNewParserCtxt(rng);
4379         if (reader->errorFunc != NULL) {
4380             xmlRelaxNGSetParserErrors(pctxt,
4381                 xmlTextReaderValidityErrorRelay,
4382                 xmlTextReaderValidityWarningRelay,
4383                 reader);
4384         }
4385         if (reader->sErrorFunc != NULL) {
4386             xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4387                 xmlTextReaderValidityStructuredRelay,
4388                 reader);
4389         }
4390         reader->rngSchemas = xmlRelaxNGParse(pctxt);
4391         xmlRelaxNGFreeParserCtxt(pctxt);
4392         if (reader->rngSchemas == NULL)
4393             return(-1);
4394         reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
4395         if (reader->rngValidCtxt == NULL) {
4396             xmlRelaxNGFree(reader->rngSchemas);
4397             reader->rngSchemas = NULL;
4398             return(-1);
4399         }
4400     } else {
4401         /* Use the given validation context. */
4402         reader->rngValidCtxt = ctxt;
4403         reader->rngPreserveCtxt = 1;
4404     }
4405     /*
4406     * Redirect the validation context's error channels to use
4407     * the reader channels.
4408     * TODO: In case the user provides the validation context we
4409     *   could make this redirection optional.
4410     */
4411     if (reader->errorFunc != NULL) {
4412         xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4413                          xmlTextReaderValidityErrorRelay,
4414                          xmlTextReaderValidityWarningRelay,
4415                          reader);
4416     }
4417         if (reader->sErrorFunc != NULL) {
4418                 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4419                         xmlTextReaderValidityStructuredRelay,
4420                         reader);
4421     }
4422     reader->rngValidErrors = 0;
4423     reader->rngFullNode = NULL;
4424     reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4425     return(0);
4426 }
4427
4428 /**
4429  * xmlTextReaderSchemaValidateInternal:
4430  * @reader:  the xmlTextReaderPtr used
4431  * @xsd:  the path to a W3C XSD schema or NULL
4432  * @ctxt: the XML Schema validation context or NULL
4433  * @options: options (not used yet)
4434  *
4435  * Validate the document as it is processed using XML Schema.
4436  * Activation is only possible before the first Read().
4437  * If both @xsd and @ctxt are NULL then XML Schema validation is deactivated.
4438  *
4439  * Returns 0 in case the schemas validation could be (de)activated and
4440  *         -1 in case of error.
4441  */
4442 static int
4443 xmlTextReaderSchemaValidateInternal(xmlTextReaderPtr reader,
4444                                     const char *xsd,
4445                                     xmlSchemaValidCtxtPtr ctxt,
4446                                     int options ATTRIBUTE_UNUSED)
4447 {
4448     if (reader == NULL)
4449         return(-1);
4450
4451     if ((xsd != NULL) && (ctxt != NULL))
4452         return(-1);
4453
4454     if (((xsd != NULL) || (ctxt != NULL)) &&
4455         ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
4456         (reader->ctxt == NULL)))
4457         return(-1);
4458
4459     /* Cleanup previous validation stuff. */
4460     if (reader->xsdPlug != NULL) {
4461         xmlSchemaSAXUnplug(reader->xsdPlug);
4462         reader->xsdPlug = NULL;
4463     }
4464     if (reader->xsdValidCtxt != NULL) {
4465         if (! reader->xsdPreserveCtxt)
4466             xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4467         reader->xsdValidCtxt = NULL;
4468     }
4469     reader->xsdPreserveCtxt = 0;
4470     if (reader->xsdSchemas != NULL) {
4471         xmlSchemaFree(reader->xsdSchemas);
4472         reader->xsdSchemas = NULL;
4473     }
4474
4475     if ((xsd == NULL) && (ctxt == NULL)) {
4476         /* We just want to deactivate the validation, so get out. */
4477         return(0);
4478     }
4479
4480     if (xsd != NULL) {
4481         xmlSchemaParserCtxtPtr pctxt;
4482         /* Parse the schema and create validation environment. */
4483         pctxt = xmlSchemaNewParserCtxt(xsd);
4484         if (reader->errorFunc != NULL) {
4485             xmlSchemaSetParserErrors(pctxt,
4486                 xmlTextReaderValidityErrorRelay,
4487                 xmlTextReaderValidityWarningRelay,
4488                 reader);
4489         }
4490         reader->xsdSchemas = xmlSchemaParse(pctxt);
4491         xmlSchemaFreeParserCtxt(pctxt);
4492         if (reader->xsdSchemas == NULL)
4493             return(-1);
4494         reader->xsdValidCtxt = xmlSchemaNewValidCtxt(reader->xsdSchemas);
4495         if (reader->xsdValidCtxt == NULL) {
4496             xmlSchemaFree(reader->xsdSchemas);
4497             reader->xsdSchemas = NULL;
4498             return(-1);
4499         }
4500         reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4501             &(reader->ctxt->sax),
4502             &(reader->ctxt->userData));
4503         if (reader->xsdPlug == NULL) {
4504             xmlSchemaFree(reader->xsdSchemas);
4505             reader->xsdSchemas = NULL;
4506             xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4507             reader->xsdValidCtxt = NULL;
4508             return(-1);
4509         }
4510     } else {
4511         /* Use the given validation context. */
4512         reader->xsdValidCtxt = ctxt;
4513         reader->xsdPreserveCtxt = 1;
4514         reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4515             &(reader->ctxt->sax),
4516             &(reader->ctxt->userData));
4517         if (reader->xsdPlug == NULL) {
4518             reader->xsdValidCtxt = NULL;
4519             reader->xsdPreserveCtxt = 0;
4520             return(-1);
4521         }
4522     }
4523     xmlSchemaValidateSetLocator(reader->xsdValidCtxt,
4524                                 xmlTextReaderLocator,
4525                                 (void *) reader);
4526     /*
4527     * Redirect the validation context's error channels to use
4528     * the reader channels.
4529     * TODO: In case the user provides the validation context we
4530     *   could make this redirection optional.
4531     */
4532     if (reader->errorFunc != NULL) {
4533         xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4534                          xmlTextReaderValidityErrorRelay,
4535                          xmlTextReaderValidityWarningRelay,
4536                          reader);
4537     }
4538         if (reader->sErrorFunc != NULL) {
4539                 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4540                         xmlTextReaderValidityStructuredRelay,
4541                         reader);
4542     }
4543     reader->xsdValidErrors = 0;
4544     reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4545     return(0);
4546 }
4547
4548 /**
4549  * xmlTextReaderSchemaValidateCtxt:
4550  * @reader:  the xmlTextReaderPtr used
4551  * @ctxt: the XML Schema validation context or NULL
4552  * @options: options (not used yet)
4553  *
4554  * Use W3C XSD schema context to validate the document as it is processed.
4555  * Activation is only possible before the first Read().
4556  * If @ctxt is NULL, then XML Schema validation is deactivated.
4557  *
4558  * Returns 0 in case the schemas validation could be (de)activated and
4559  *         -1 in case of error.
4560  */
4561 int
4562 xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader,
4563                                     xmlSchemaValidCtxtPtr ctxt,
4564                                     int options)
4565 {
4566     return(xmlTextReaderSchemaValidateInternal(reader, NULL, ctxt, options));
4567 }
4568
4569 /**
4570  * xmlTextReaderSchemaValidate:
4571  * @reader:  the xmlTextReaderPtr used
4572  * @xsd:  the path to a W3C XSD schema or NULL
4573  *
4574  * Use W3C XSD schema to validate the document as it is processed.
4575  * Activation is only possible before the first Read().
4576  * If @xsd is NULL, then XML Schema validation is deactivated.
4577  *
4578  * Returns 0 in case the schemas validation could be (de)activated and
4579  *         -1 in case of error.
4580  */
4581 int
4582 xmlTextReaderSchemaValidate(xmlTextReaderPtr reader, const char *xsd)
4583 {
4584     return(xmlTextReaderSchemaValidateInternal(reader, xsd, NULL, 0));
4585 }
4586
4587 /**
4588  * xmlTextReaderRelaxNGValidateCtxt:
4589  * @reader:  the xmlTextReaderPtr used
4590  * @ctxt: the RelaxNG schema validation context or NULL
4591  * @options: options (not used yet)
4592  *
4593  * Use RelaxNG schema context to validate the document as it is processed.
4594  * Activation is only possible before the first Read().
4595  * If @ctxt is NULL, then RelaxNG schema validation is deactivated.
4596  *
4597  * Returns 0 in case the schemas validation could be (de)activated and
4598  *         -1 in case of error.
4599  */
4600 int
4601 xmlTextReaderRelaxNGValidateCtxt(xmlTextReaderPtr reader,
4602                                  xmlRelaxNGValidCtxtPtr ctxt,
4603                                  int options)
4604 {
4605     return(xmlTextReaderRelaxNGValidateInternal(reader, NULL, ctxt, options));
4606 }
4607
4608 /**
4609  * xmlTextReaderRelaxNGValidate:
4610  * @reader:  the xmlTextReaderPtr used
4611  * @rng:  the path to a RelaxNG schema or NULL
4612  *
4613  * Use RelaxNG schema to validate the document as it is processed.
4614  * Activation is only possible before the first Read().
4615  * If @rng is NULL, then RelaxNG schema validation is deactivated.
4616  *
4617  * Returns 0 in case the schemas validation could be (de)activated and
4618  *         -1 in case of error.
4619  */
4620 int
4621 xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng)
4622 {
4623     return(xmlTextReaderRelaxNGValidateInternal(reader, rng, NULL, 0));
4624 }
4625
4626 #endif
4627
4628 /**
4629  * xmlTextReaderIsNamespaceDecl:
4630  * @reader: the xmlTextReaderPtr used
4631  *
4632  * Determine whether the current node is a namespace declaration
4633  * rather than a regular attribute.
4634  *
4635  * Returns 1 if the current node is a namespace declaration, 0 if it
4636  * is a regular attribute or other type of node, or -1 in case of
4637  * error.
4638  */
4639 int
4640 xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader) {
4641     xmlNodePtr node;
4642     if (reader == NULL)
4643         return(-1);
4644     if (reader->node == NULL)
4645         return(-1);
4646     if (reader->curnode != NULL)
4647         node = reader->curnode;
4648     else
4649         node = reader->node;
4650
4651     if (XML_NAMESPACE_DECL == node->type)
4652         return(1);
4653     else
4654         return(0);
4655 }
4656
4657 /**
4658  * xmlTextReaderConstXmlVersion:
4659  * @reader:  the xmlTextReaderPtr used
4660  *
4661  * Determine the XML version of the document being read.
4662  *
4663  * Returns a string containing the XML version of the document or NULL
4664  * in case of error.  The string is deallocated with the reader.
4665  */
4666 const xmlChar *
4667 xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader) {
4668     xmlDocPtr doc = NULL;
4669     if (reader == NULL)
4670         return(NULL);
4671     if (reader->doc != NULL)
4672         doc = reader->doc;
4673     else if (reader->ctxt != NULL)
4674         doc = reader->ctxt->myDoc;
4675     if (doc == NULL)
4676         return(NULL);
4677
4678     if (doc->version == NULL)
4679         return(NULL);
4680     else
4681       return(CONSTSTR(doc->version));
4682 }
4683
4684 /**
4685  * xmlTextReaderStandalone:
4686  * @reader:  the xmlTextReaderPtr used
4687  *
4688  * Determine the standalone status of the document being read.
4689  *
4690  * Returns 1 if the document was declared to be standalone, 0 if it
4691  * was declared to be not standalone, or -1 if the document did not
4692  * specify its standalone status or in case of error.
4693  */
4694 int
4695 xmlTextReaderStandalone(xmlTextReaderPtr reader) {
4696     xmlDocPtr doc = NULL;
4697     if (reader == NULL)
4698         return(-1);
4699     if (reader->doc != NULL)
4700         doc = reader->doc;
4701     else if (reader->ctxt != NULL)
4702         doc = reader->ctxt->myDoc;
4703     if (doc == NULL)
4704         return(-1);
4705
4706     return(doc->standalone);
4707 }
4708
4709 /************************************************************************
4710  *                                                                      *
4711  *                      Error Handling Extensions                       *
4712  *                                                                      *
4713  ************************************************************************/
4714
4715 /* helper to build a xmlMalloc'ed string from a format and va_list */
4716 static char *
4717 xmlTextReaderBuildMessage(const char *msg, va_list ap) {
4718     int size = 0;
4719     int chars;
4720     char *larger;
4721     char *str = NULL;
4722     va_list aq;
4723
4724     while (1) {
4725         VA_COPY(aq, ap);
4726         chars = vsnprintf(str, size, msg, aq);
4727         va_end(aq);
4728         if (chars < 0) {
4729             xmlGenericError(xmlGenericErrorContext, "vsnprintf failed !\n");
4730             if (str)
4731                 xmlFree(str);
4732             return NULL;
4733         }
4734         if ((chars < size) || (size == MAX_ERR_MSG_SIZE))
4735             break;
4736         if (chars < MAX_ERR_MSG_SIZE)
4737         size = chars + 1;
4738         else
4739                 size = MAX_ERR_MSG_SIZE;
4740         if ((larger = (char *) xmlRealloc(str, size)) == NULL) {
4741             xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
4742             if (str)
4743                 xmlFree(str);
4744             return NULL;
4745         }
4746         str = larger;
4747     }
4748
4749     return str;
4750 }
4751
4752 /**
4753  * xmlTextReaderLocatorLineNumber:
4754  * @locator: the xmlTextReaderLocatorPtr used
4755  *
4756  * Obtain the line number for the given locator.
4757  *
4758  * Returns the line number or -1 in case of error.
4759  */
4760 int
4761 xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator) {
4762     /* we know that locator is a xmlParserCtxtPtr */
4763     xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
4764     int ret = -1;
4765
4766     if (locator == NULL)
4767         return(-1);
4768     if (ctx->node != NULL) {
4769         ret = xmlGetLineNo(ctx->node);
4770     }
4771     else {
4772         /* inspired from error.c */
4773         xmlParserInputPtr input;
4774         input = ctx->input;
4775         if ((input->filename == NULL) && (ctx->inputNr > 1))
4776             input = ctx->inputTab[ctx->inputNr - 2];
4777         if (input != NULL) {
4778             ret = input->line;
4779         }
4780         else {
4781             ret = -1;
4782         }
4783     }
4784
4785     return ret;
4786 }
4787
4788 /**
4789  * xmlTextReaderLocatorBaseURI:
4790  * @locator: the xmlTextReaderLocatorPtr used
4791  *
4792  * Obtain the base URI for the given locator.
4793  *
4794  * Returns the base URI or NULL in case of error,
4795  *    if non NULL it need to be freed by the caller.
4796  */
4797 xmlChar *
4798 xmlTextReaderLocatorBaseURI(xmlTextReaderLocatorPtr locator) {
4799     /* we know that locator is a xmlParserCtxtPtr */
4800     xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
4801     xmlChar *ret = NULL;
4802
4803     if (locator == NULL)
4804         return(NULL);
4805     if (ctx->node != NULL) {
4806         ret = xmlNodeGetBase(NULL,ctx->node);
4807     }
4808     else {
4809         /* inspired from error.c */
4810         xmlParserInputPtr input;
4811         input = ctx->input;
4812         if ((input->filename == NULL) && (ctx->inputNr > 1))
4813             input = ctx->inputTab[ctx->inputNr - 2];
4814         if (input != NULL) {
4815             ret = xmlStrdup(BAD_CAST input->filename);
4816         }
4817         else {
4818             ret = NULL;
4819         }
4820     }
4821
4822     return ret;
4823 }
4824
4825 static void
4826 xmlTextReaderGenericError(void *ctxt, xmlParserSeverities severity,
4827                           char *str)
4828 {
4829     xmlParserCtxtPtr ctx = (xmlParserCtxtPtr) ctxt;
4830
4831     xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
4832
4833     if (str != NULL) {
4834         if (reader->errorFunc)
4835             reader->errorFunc(reader->errorFuncArg, str, severity,
4836                               (xmlTextReaderLocatorPtr) ctx);
4837         xmlFree(str);
4838     }
4839 }
4840
4841 static void
4842 xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error)
4843 {
4844     xmlParserCtxtPtr ctx = (xmlParserCtxtPtr) ctxt;
4845
4846     xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
4847
4848     if (error && reader->sErrorFunc) {
4849         reader->sErrorFunc(reader->errorFuncArg, (xmlErrorPtr) error);
4850     }
4851 }
4852
4853 static void XMLCDECL
4854 xmlTextReaderError(void *ctxt, const char *msg, ...)
4855 {
4856     va_list ap;
4857
4858     va_start(ap, msg);
4859     xmlTextReaderGenericError(ctxt,
4860                               XML_PARSER_SEVERITY_ERROR,
4861                               xmlTextReaderBuildMessage(msg, ap));
4862     va_end(ap);
4863
4864 }
4865
4866 static void XMLCDECL
4867 xmlTextReaderWarning(void *ctxt, const char *msg, ...)
4868 {
4869     va_list ap;
4870
4871     va_start(ap, msg);
4872     xmlTextReaderGenericError(ctxt,
4873                               XML_PARSER_SEVERITY_WARNING,
4874                               xmlTextReaderBuildMessage(msg, ap));
4875     va_end(ap);
4876 }
4877
4878 static void XMLCDECL
4879 xmlTextReaderValidityError(void *ctxt, const char *msg, ...)
4880 {
4881     va_list ap;
4882
4883     int len = xmlStrlen((const xmlChar *) msg);
4884
4885     if ((len > 1) && (msg[len - 2] != ':')) {
4886         /*
4887          * some callbacks only report locator information:
4888          * skip them (mimicking behaviour in error.c)
4889          */
4890         va_start(ap, msg);
4891         xmlTextReaderGenericError(ctxt,
4892                                   XML_PARSER_SEVERITY_VALIDITY_ERROR,
4893                                   xmlTextReaderBuildMessage(msg, ap));
4894         va_end(ap);
4895     }
4896 }
4897
4898 static void XMLCDECL
4899 xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...)
4900 {
4901     va_list ap;
4902
4903     int len = xmlStrlen((const xmlChar *) msg);
4904
4905     if ((len != 0) && (msg[len - 1] != ':')) {
4906         /*
4907          * some callbacks only report locator information:
4908          * skip them (mimicking behaviour in error.c)
4909          */
4910         va_start(ap, msg);
4911         xmlTextReaderGenericError(ctxt,
4912                                   XML_PARSER_SEVERITY_VALIDITY_WARNING,
4913                                   xmlTextReaderBuildMessage(msg, ap));
4914         va_end(ap);
4915     }
4916 }
4917
4918 /**
4919  * xmlTextReaderSetErrorHandler:
4920  * @reader:  the xmlTextReaderPtr used
4921  * @f:  the callback function to call on error and warnings
4922  * @arg:    a user argument to pass to the callback function
4923  *
4924  * Register a callback function that will be called on error and warnings.
4925  *
4926  * If @f is NULL, the default error and warning handlers are restored.
4927  */
4928 void
4929 xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
4930                              xmlTextReaderErrorFunc f, void *arg)
4931 {
4932     if (f != NULL) {
4933         reader->ctxt->sax->error = xmlTextReaderError;
4934         reader->ctxt->sax->serror = NULL;
4935         reader->ctxt->vctxt.error = xmlTextReaderValidityError;
4936         reader->ctxt->sax->warning = xmlTextReaderWarning;
4937         reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
4938         reader->errorFunc = f;
4939         reader->sErrorFunc = NULL;
4940         reader->errorFuncArg = arg;
4941 #ifdef LIBXML_SCHEMAS_ENABLED
4942         if (reader->rngValidCtxt) {
4943             xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4944                                      xmlTextReaderValidityErrorRelay,
4945                                      xmlTextReaderValidityWarningRelay,
4946                                      reader);
4947             xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
4948                                                reader);
4949         }
4950         if (reader->xsdValidCtxt) {
4951             xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4952                                     xmlTextReaderValidityErrorRelay,
4953                                     xmlTextReaderValidityWarningRelay,
4954                                     reader);
4955             xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
4956                                               reader);
4957         }
4958 #endif
4959     } else {
4960         /* restore defaults */
4961         reader->ctxt->sax->error = xmlParserError;
4962         reader->ctxt->vctxt.error = xmlParserValidityError;
4963         reader->ctxt->sax->warning = xmlParserWarning;
4964         reader->ctxt->vctxt.warning = xmlParserValidityWarning;
4965         reader->errorFunc = NULL;
4966         reader->sErrorFunc = NULL;
4967         reader->errorFuncArg = NULL;
4968 #ifdef LIBXML_SCHEMAS_ENABLED
4969         if (reader->rngValidCtxt) {
4970             xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
4971                                      reader);
4972             xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
4973                                                reader);
4974         }
4975         if (reader->xsdValidCtxt) {
4976             xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
4977                                     reader);
4978             xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
4979                                               reader);
4980         }
4981 #endif
4982     }
4983 }
4984
4985 /**
4986 * xmlTextReaderSetStructuredErrorHandler:
4987  * @reader:  the xmlTextReaderPtr used
4988  * @f:  the callback function to call on error and warnings
4989  * @arg:    a user argument to pass to the callback function
4990  *
4991  * Register a callback function that will be called on error and warnings.
4992  *
4993  * If @f is NULL, the default error and warning handlers are restored.
4994  */
4995 void
4996 xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
4997                                        xmlStructuredErrorFunc f, void *arg)
4998 {
4999     if (f != NULL) {
5000         reader->ctxt->sax->error = NULL;
5001         reader->ctxt->sax->serror = xmlTextReaderStructuredError;
5002         reader->ctxt->vctxt.error = xmlTextReaderValidityError;
5003         reader->ctxt->sax->warning = xmlTextReaderWarning;
5004         reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
5005         reader->sErrorFunc = f;
5006         reader->errorFunc = NULL;
5007         reader->errorFuncArg = arg;
5008 #ifdef LIBXML_SCHEMAS_ENABLED
5009         if (reader->rngValidCtxt) {
5010             xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
5011                                      reader);
5012             xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
5013                                         xmlTextReaderValidityStructuredRelay,
5014                                                reader);
5015         }
5016         if (reader->xsdValidCtxt) {
5017             xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
5018                                     reader);
5019             xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
5020                                        xmlTextReaderValidityStructuredRelay,
5021                                               reader);
5022         }
5023 #endif
5024     } else {
5025         /* restore defaults */
5026         reader->ctxt->sax->error = xmlParserError;
5027         reader->ctxt->sax->serror = NULL;
5028         reader->ctxt->vctxt.error = xmlParserValidityError;
5029         reader->ctxt->sax->warning = xmlParserWarning;
5030         reader->ctxt->vctxt.warning = xmlParserValidityWarning;
5031         reader->errorFunc = NULL;
5032         reader->sErrorFunc = NULL;
5033         reader->errorFuncArg = NULL;
5034 #ifdef LIBXML_SCHEMAS_ENABLED
5035         if (reader->rngValidCtxt) {
5036             xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
5037                                      reader);
5038             xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
5039                                                reader);
5040         }
5041         if (reader->xsdValidCtxt) {
5042             xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
5043                                     reader);
5044             xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
5045                                               reader);
5046         }
5047 #endif
5048     }
5049 }
5050
5051 /**
5052  * xmlTextReaderIsValid:
5053  * @reader:  the xmlTextReaderPtr used
5054  *
5055  * Retrieve the validity status from the parser context
5056  *
5057  * Returns the flag value 1 if valid, 0 if no, and -1 in case of error
5058  */
5059 int
5060 xmlTextReaderIsValid(xmlTextReaderPtr reader)
5061 {
5062     if (reader == NULL)
5063         return (-1);
5064 #ifdef LIBXML_SCHEMAS_ENABLED
5065     if (reader->validate == XML_TEXTREADER_VALIDATE_RNG)
5066         return (reader->rngValidErrors == 0);
5067     if (reader->validate == XML_TEXTREADER_VALIDATE_XSD)
5068         return (reader->xsdValidErrors == 0);
5069 #endif
5070     if ((reader->ctxt != NULL) && (reader->ctxt->validate == 1))
5071         return (reader->ctxt->valid);
5072     return (0);
5073 }
5074
5075 /**
5076  * xmlTextReaderGetErrorHandler:
5077  * @reader:  the xmlTextReaderPtr used
5078  * @f:  the callback function or NULL is no callback has been registered
5079  * @arg:    a user argument
5080  *
5081  * Retrieve the error callback function and user argument.
5082  */
5083 void
5084 xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
5085                              xmlTextReaderErrorFunc * f, void **arg)
5086 {
5087     if (f != NULL)
5088         *f = reader->errorFunc;
5089     if (arg != NULL)
5090         *arg = reader->errorFuncArg;
5091 }
5092 /************************************************************************
5093  *                                                                      *
5094  *      New set (2.6.0) of simpler and more flexible APIs               *
5095  *                                                                      *
5096  ************************************************************************/
5097
5098 /**
5099  * xmlTextReaderSetup:
5100  * @reader:  an XML reader
5101  * @input: xmlParserInputBufferPtr used to feed the reader, will
5102  *         be destroyed with it.
5103  * @URL:  the base URL to use for the document
5104  * @encoding:  the document encoding, or NULL
5105  * @options:  a combination of xmlParserOption
5106  *
5107  * Setup an XML reader with new options
5108  *
5109  * Returns 0 in case of success and -1 in case of error.
5110  */
5111 int
5112 xmlTextReaderSetup(xmlTextReaderPtr reader,
5113                    xmlParserInputBufferPtr input, const char *URL,
5114                    const char *encoding, int options)
5115 {
5116     if (reader == NULL) {
5117         if (input != NULL)
5118             xmlFreeParserInputBuffer(input);
5119         return (-1);
5120     }
5121
5122     /*
5123      * we force the generation of compact text nodes on the reader
5124      * since usr applications should never modify the tree
5125      */
5126     options |= XML_PARSE_COMPACT;
5127
5128     reader->doc = NULL;
5129     reader->entNr = 0;
5130     reader->parserFlags = options;
5131     reader->validate = XML_TEXTREADER_NOT_VALIDATE;
5132     if ((input != NULL) && (reader->input != NULL) &&
5133         (reader->allocs & XML_TEXTREADER_INPUT)) {
5134         xmlFreeParserInputBuffer(reader->input);
5135         reader->input = NULL;
5136         reader->allocs -= XML_TEXTREADER_INPUT;
5137     }
5138     if (input != NULL) {
5139         reader->input = input;
5140         reader->allocs |= XML_TEXTREADER_INPUT;
5141     }
5142     if (reader->buffer == NULL)
5143         reader->buffer = xmlBufCreateSize(100);
5144     if (reader->buffer == NULL) {
5145         xmlGenericError(xmlGenericErrorContext,
5146                         "xmlTextReaderSetup : malloc failed\n");
5147         return (-1);
5148     }
5149     /* no operation on a reader should require a huge buffer */
5150     xmlBufSetAllocationScheme(reader->buffer,
5151                               XML_BUFFER_ALLOC_BOUNDED);
5152     if (reader->sax == NULL)
5153         reader->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
5154     if (reader->sax == NULL) {
5155         xmlGenericError(xmlGenericErrorContext,
5156                         "xmlTextReaderSetup : malloc failed\n");
5157         return (-1);
5158     }
5159     xmlSAXVersion(reader->sax, 2);
5160     reader->startElement = reader->sax->startElement;
5161     reader->sax->startElement = xmlTextReaderStartElement;
5162     reader->endElement = reader->sax->endElement;
5163     reader->sax->endElement = xmlTextReaderEndElement;
5164 #ifdef LIBXML_SAX1_ENABLED
5165     if (reader->sax->initialized == XML_SAX2_MAGIC) {
5166 #endif /* LIBXML_SAX1_ENABLED */
5167         reader->startElementNs = reader->sax->startElementNs;
5168         reader->sax->startElementNs = xmlTextReaderStartElementNs;
5169         reader->endElementNs = reader->sax->endElementNs;
5170         reader->sax->endElementNs = xmlTextReaderEndElementNs;
5171 #ifdef LIBXML_SAX1_ENABLED
5172     } else {
5173         reader->startElementNs = NULL;
5174         reader->endElementNs = NULL;
5175     }
5176 #endif /* LIBXML_SAX1_ENABLED */
5177     reader->characters = reader->sax->characters;
5178     reader->sax->characters = xmlTextReaderCharacters;
5179     reader->sax->ignorableWhitespace = xmlTextReaderCharacters;
5180     reader->cdataBlock = reader->sax->cdataBlock;
5181     reader->sax->cdataBlock = xmlTextReaderCDataBlock;
5182
5183     reader->mode = XML_TEXTREADER_MODE_INITIAL;
5184     reader->node = NULL;
5185     reader->curnode = NULL;
5186     if (input != NULL) {
5187         if (xmlBufUse(reader->input->buffer) < 4) {
5188             xmlParserInputBufferRead(input, 4);
5189         }
5190         if (reader->ctxt == NULL) {
5191             if (xmlBufUse(reader->input->buffer) >= 4) {
5192                 reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL,
5193                        (const char *) xmlBufContent(reader->input->buffer),
5194                                       4, URL);
5195                 reader->base = 0;
5196                 reader->cur = 4;
5197             } else {
5198                 reader->ctxt =
5199                     xmlCreatePushParserCtxt(reader->sax, NULL, NULL, 0, URL);
5200                 reader->base = 0;
5201                 reader->cur = 0;
5202             }
5203         } else {
5204             xmlParserInputPtr inputStream;
5205             xmlParserInputBufferPtr buf;
5206             xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
5207
5208             xmlCtxtReset(reader->ctxt);
5209             buf = xmlAllocParserInputBuffer(enc);
5210             if (buf == NULL) return(-1);
5211             inputStream = xmlNewInputStream(reader->ctxt);
5212             if (inputStream == NULL) {
5213                 xmlFreeParserInputBuffer(buf);
5214                 return(-1);
5215             }
5216
5217             if (URL == NULL)
5218                 inputStream->filename = NULL;
5219             else
5220                 inputStream->filename = (char *)
5221                     xmlCanonicPath((const xmlChar *) URL);
5222             inputStream->buf = buf;
5223             xmlBufResetInput(buf->buffer, inputStream);
5224
5225             inputPush(reader->ctxt, inputStream);
5226             reader->cur = 0;
5227         }
5228         if (reader->ctxt == NULL) {
5229             xmlGenericError(xmlGenericErrorContext,
5230                             "xmlTextReaderSetup : malloc failed\n");
5231             return (-1);
5232         }
5233     }
5234     if (reader->dict != NULL) {
5235         if (reader->ctxt->dict != NULL) {
5236             if (reader->dict != reader->ctxt->dict) {
5237                 xmlDictFree(reader->dict);
5238                 reader->dict = reader->ctxt->dict;
5239             }
5240         } else {
5241             reader->ctxt->dict = reader->dict;
5242         }
5243     } else {
5244         if (reader->ctxt->dict == NULL)
5245             reader->ctxt->dict = xmlDictCreate();
5246         reader->dict = reader->ctxt->dict;
5247     }
5248     reader->ctxt->_private = reader;
5249     reader->ctxt->linenumbers = 1;
5250     reader->ctxt->dictNames = 1;
5251     /*
5252      * use the parser dictionnary to allocate all elements and attributes names
5253      */
5254     reader->ctxt->docdict = 1;
5255     reader->ctxt->parseMode = XML_PARSE_READER;
5256
5257 #ifdef LIBXML_XINCLUDE_ENABLED
5258     if (reader->xincctxt != NULL) {
5259         xmlXIncludeFreeContext(reader->xincctxt);
5260         reader->xincctxt = NULL;
5261     }
5262     if (options & XML_PARSE_XINCLUDE) {
5263         reader->xinclude = 1;
5264         reader->xinclude_name = xmlDictLookup(reader->dict, XINCLUDE_NODE, -1);
5265         options -= XML_PARSE_XINCLUDE;
5266     } else
5267         reader->xinclude = 0;
5268     reader->in_xinclude = 0;
5269 #endif
5270 #ifdef LIBXML_PATTERN_ENABLED
5271     if (reader->patternTab == NULL) {
5272         reader->patternNr = 0;
5273         reader->patternMax = 0;
5274     }
5275     while (reader->patternNr > 0) {
5276         reader->patternNr--;
5277         if (reader->patternTab[reader->patternNr] != NULL) {
5278             xmlFreePattern(reader->patternTab[reader->patternNr]);
5279             reader->patternTab[reader->patternNr] = NULL;
5280         }
5281     }
5282 #endif
5283
5284     if (options & XML_PARSE_DTDVALID)
5285         reader->validate = XML_TEXTREADER_VALIDATE_DTD;
5286
5287     xmlCtxtUseOptions(reader->ctxt, options);
5288     if (encoding != NULL) {
5289         xmlCharEncodingHandlerPtr hdlr;
5290
5291         hdlr = xmlFindCharEncodingHandler(encoding);
5292         if (hdlr != NULL)
5293             xmlSwitchToEncoding(reader->ctxt, hdlr);
5294     }
5295     if ((URL != NULL) && (reader->ctxt->input != NULL) &&
5296         (reader->ctxt->input->filename == NULL))
5297         reader->ctxt->input->filename = (char *)
5298             xmlStrdup((const xmlChar *) URL);
5299
5300     reader->doc = NULL;
5301
5302     return (0);
5303 }
5304
5305 /**
5306  * xmlTextReaderByteConsumed:
5307  * @reader: an XML reader
5308  *
5309  * This function provides the current index of the parser used
5310  * by the reader, relative to the start of the current entity.
5311  * This function actually just wraps a call to xmlBytesConsumed()
5312  * for the parser context associated with the reader.
5313  * See xmlBytesConsumed() for more information.
5314  *
5315  * Returns the index in bytes from the beginning of the entity or -1
5316  *         in case the index could not be computed.
5317  */
5318 long
5319 xmlTextReaderByteConsumed(xmlTextReaderPtr reader) {
5320     if ((reader == NULL) || (reader->ctxt == NULL))
5321         return(-1);
5322     return(xmlByteConsumed(reader->ctxt));
5323 }
5324
5325
5326 /**
5327  * xmlReaderWalker:
5328  * @doc:  a preparsed document
5329  *
5330  * Create an xmltextReader for a preparsed document.
5331  *
5332  * Returns the new reader or NULL in case of error.
5333  */
5334 xmlTextReaderPtr
5335 xmlReaderWalker(xmlDocPtr doc)
5336 {
5337     xmlTextReaderPtr ret;
5338
5339     if (doc == NULL)
5340         return(NULL);
5341
5342     ret = xmlMalloc(sizeof(xmlTextReader));
5343     if (ret == NULL) {
5344         xmlGenericError(xmlGenericErrorContext,
5345                 "xmlNewTextReader : malloc failed\n");
5346         return(NULL);
5347     }
5348     memset(ret, 0, sizeof(xmlTextReader));
5349     ret->entNr = 0;
5350     ret->input = NULL;
5351     ret->mode = XML_TEXTREADER_MODE_INITIAL;
5352     ret->node = NULL;
5353     ret->curnode = NULL;
5354     ret->base = 0;
5355     ret->cur = 0;
5356     ret->allocs = XML_TEXTREADER_CTXT;
5357     ret->doc = doc;
5358     ret->state = XML_TEXTREADER_START;
5359     ret->dict = xmlDictCreate();
5360     return(ret);
5361 }
5362
5363 /**
5364  * xmlReaderForDoc:
5365  * @cur:  a pointer to a zero terminated string
5366  * @URL:  the base URL to use for the document
5367  * @encoding:  the document encoding, or NULL
5368  * @options:  a combination of xmlParserOption
5369  *
5370  * Create an xmltextReader for an XML in-memory document.
5371  * The parsing flags @options are a combination of xmlParserOption.
5372  *
5373  * Returns the new reader or NULL in case of error.
5374  */
5375 xmlTextReaderPtr
5376 xmlReaderForDoc(const xmlChar * cur, const char *URL, const char *encoding,
5377                 int options)
5378 {
5379     int len;
5380
5381     if (cur == NULL)
5382         return (NULL);
5383     len = xmlStrlen(cur);
5384
5385     return (xmlReaderForMemory
5386             ((const char *) cur, len, URL, encoding, options));
5387 }
5388
5389 /**
5390  * xmlReaderForFile:
5391  * @filename:  a file or URL
5392  * @encoding:  the document encoding, or NULL
5393  * @options:  a combination of xmlParserOption
5394  *
5395  * parse an XML file from the filesystem or the network.
5396  * The parsing flags @options are a combination of xmlParserOption.
5397  *
5398  * Returns the new reader or NULL in case of error.
5399  */
5400 xmlTextReaderPtr
5401 xmlReaderForFile(const char *filename, const char *encoding, int options)
5402 {
5403     xmlTextReaderPtr reader;
5404
5405     reader = xmlNewTextReaderFilename(filename);
5406     if (reader == NULL)
5407         return (NULL);
5408     xmlTextReaderSetup(reader, NULL, NULL, encoding, options);
5409     return (reader);
5410 }
5411
5412 /**
5413  * xmlReaderForMemory:
5414  * @buffer:  a pointer to a char array
5415  * @size:  the size of the array
5416  * @URL:  the base URL to use for the document
5417  * @encoding:  the document encoding, or NULL
5418  * @options:  a combination of xmlParserOption
5419  *
5420  * Create an xmltextReader for an XML in-memory document.
5421  * The parsing flags @options are a combination of xmlParserOption.
5422  *
5423  * Returns the new reader or NULL in case of error.
5424  */
5425 xmlTextReaderPtr
5426 xmlReaderForMemory(const char *buffer, int size, const char *URL,
5427                    const char *encoding, int options)
5428 {
5429     xmlTextReaderPtr reader;
5430     xmlParserInputBufferPtr buf;
5431
5432     buf = xmlParserInputBufferCreateStatic(buffer, size,
5433                                       XML_CHAR_ENCODING_NONE);
5434     if (buf == NULL) {
5435         return (NULL);
5436     }
5437     reader = xmlNewTextReader(buf, URL);
5438     if (reader == NULL) {
5439         xmlFreeParserInputBuffer(buf);
5440         return (NULL);
5441     }
5442     reader->allocs |= XML_TEXTREADER_INPUT;
5443     xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5444     return (reader);
5445 }
5446
5447 /**
5448  * xmlReaderForFd:
5449  * @fd:  an open file descriptor
5450  * @URL:  the base URL to use for the document
5451  * @encoding:  the document encoding, or NULL
5452  * @options:  a combination of xmlParserOption
5453  *
5454  * Create an xmltextReader for an XML from a file descriptor.
5455  * The parsing flags @options are a combination of xmlParserOption.
5456  * NOTE that the file descriptor will not be closed when the
5457  *      reader is closed or reset.
5458  *
5459  * Returns the new reader or NULL in case of error.
5460  */
5461 xmlTextReaderPtr
5462 xmlReaderForFd(int fd, const char *URL, const char *encoding, int options)
5463 {
5464     xmlTextReaderPtr reader;
5465     xmlParserInputBufferPtr input;
5466
5467     if (fd < 0)
5468         return (NULL);
5469
5470     input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
5471     if (input == NULL)
5472         return (NULL);
5473     input->closecallback = NULL;
5474     reader = xmlNewTextReader(input, URL);
5475     if (reader == NULL) {
5476         xmlFreeParserInputBuffer(input);
5477         return (NULL);
5478     }
5479     reader->allocs |= XML_TEXTREADER_INPUT;
5480     xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5481     return (reader);
5482 }
5483
5484 /**
5485  * xmlReaderForIO:
5486  * @ioread:  an I/O read function
5487  * @ioclose:  an I/O close function
5488  * @ioctx:  an I/O handler
5489  * @URL:  the base URL to use for the document
5490  * @encoding:  the document encoding, or NULL
5491  * @options:  a combination of xmlParserOption
5492  *
5493  * Create an xmltextReader for an XML document from I/O functions and source.
5494  * The parsing flags @options are a combination of xmlParserOption.
5495  *
5496  * Returns the new reader or NULL in case of error.
5497  */
5498 xmlTextReaderPtr
5499 xmlReaderForIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
5500                void *ioctx, const char *URL, const char *encoding,
5501                int options)
5502 {
5503     xmlTextReaderPtr reader;
5504     xmlParserInputBufferPtr input;
5505
5506     if (ioread == NULL)
5507         return (NULL);
5508
5509     input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
5510                                          XML_CHAR_ENCODING_NONE);
5511     if (input == NULL) {
5512         if (ioclose != NULL)
5513             ioclose(ioctx);
5514         return (NULL);
5515     }
5516     reader = xmlNewTextReader(input, URL);
5517     if (reader == NULL) {
5518         xmlFreeParserInputBuffer(input);
5519         return (NULL);
5520     }
5521     reader->allocs |= XML_TEXTREADER_INPUT;
5522     xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5523     return (reader);
5524 }
5525
5526 /**
5527  * xmlReaderNewWalker:
5528  * @reader:  an XML reader
5529  * @doc:  a preparsed document
5530  *
5531  * Setup an xmltextReader to parse a preparsed XML document.
5532  * This reuses the existing @reader xmlTextReader.
5533  *
5534  * Returns 0 in case of success and -1 in case of error
5535  */
5536 int
5537 xmlReaderNewWalker(xmlTextReaderPtr reader, xmlDocPtr doc)
5538 {
5539     if (doc == NULL)
5540         return (-1);
5541     if (reader == NULL)
5542         return (-1);
5543
5544     if (reader->input != NULL) {
5545         xmlFreeParserInputBuffer(reader->input);
5546     }
5547     if (reader->ctxt != NULL) {
5548         xmlCtxtReset(reader->ctxt);
5549     }
5550
5551     reader->entNr = 0;
5552     reader->input = NULL;
5553     reader->mode = XML_TEXTREADER_MODE_INITIAL;
5554     reader->node = NULL;
5555     reader->curnode = NULL;
5556     reader->base = 0;
5557     reader->cur = 0;
5558     reader->allocs = XML_TEXTREADER_CTXT;
5559     reader->doc = doc;
5560     reader->state = XML_TEXTREADER_START;
5561     if (reader->dict == NULL) {
5562         if ((reader->ctxt != NULL) && (reader->ctxt->dict != NULL))
5563             reader->dict = reader->ctxt->dict;
5564         else
5565             reader->dict = xmlDictCreate();
5566     }
5567     return(0);
5568 }
5569
5570 /**
5571  * xmlReaderNewDoc:
5572  * @reader:  an XML reader
5573  * @cur:  a pointer to a zero terminated string
5574  * @URL:  the base URL to use for the document
5575  * @encoding:  the document encoding, or NULL
5576  * @options:  a combination of xmlParserOption
5577  *
5578  * Setup an xmltextReader to parse an XML in-memory document.
5579  * The parsing flags @options are a combination of xmlParserOption.
5580  * This reuses the existing @reader xmlTextReader.
5581  *
5582  * Returns 0 in case of success and -1 in case of error
5583  */
5584 int
5585 xmlReaderNewDoc(xmlTextReaderPtr reader, const xmlChar * cur,
5586                 const char *URL, const char *encoding, int options)
5587 {
5588
5589     int len;
5590
5591     if (cur == NULL)
5592         return (-1);
5593     if (reader == NULL)
5594         return (-1);
5595
5596     len = xmlStrlen(cur);
5597     return (xmlReaderNewMemory(reader, (const char *)cur, len,
5598                                URL, encoding, options));
5599 }
5600
5601 /**
5602  * xmlReaderNewFile:
5603  * @reader:  an XML reader
5604  * @filename:  a file or URL
5605  * @encoding:  the document encoding, or NULL
5606  * @options:  a combination of xmlParserOption
5607  *
5608  * parse an XML file from the filesystem or the network.
5609  * The parsing flags @options are a combination of xmlParserOption.
5610  * This reuses the existing @reader xmlTextReader.
5611  *
5612  * Returns 0 in case of success and -1 in case of error
5613  */
5614 int
5615 xmlReaderNewFile(xmlTextReaderPtr reader, const char *filename,
5616                  const char *encoding, int options)
5617 {
5618     xmlParserInputBufferPtr input;
5619
5620     if (filename == NULL)
5621         return (-1);
5622     if (reader == NULL)
5623         return (-1);
5624
5625     input =
5626         xmlParserInputBufferCreateFilename(filename,
5627                                            XML_CHAR_ENCODING_NONE);
5628     if (input == NULL)
5629         return (-1);
5630     return (xmlTextReaderSetup(reader, input, filename, encoding, options));
5631 }
5632
5633 /**
5634  * xmlReaderNewMemory:
5635  * @reader:  an XML reader
5636  * @buffer:  a pointer to a char array
5637  * @size:  the size of the array
5638  * @URL:  the base URL to use for the document
5639  * @encoding:  the document encoding, or NULL
5640  * @options:  a combination of xmlParserOption
5641  *
5642  * Setup an xmltextReader to parse an XML in-memory document.
5643  * The parsing flags @options are a combination of xmlParserOption.
5644  * This reuses the existing @reader xmlTextReader.
5645  *
5646  * Returns 0 in case of success and -1 in case of error
5647  */
5648 int
5649 xmlReaderNewMemory(xmlTextReaderPtr reader, const char *buffer, int size,
5650                    const char *URL, const char *encoding, int options)
5651 {
5652     xmlParserInputBufferPtr input;
5653
5654     if (reader == NULL)
5655         return (-1);
5656     if (buffer == NULL)
5657         return (-1);
5658
5659     input = xmlParserInputBufferCreateStatic(buffer, size,
5660                                       XML_CHAR_ENCODING_NONE);
5661     if (input == NULL) {
5662         return (-1);
5663     }
5664     return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5665 }
5666
5667 /**
5668  * xmlReaderNewFd:
5669  * @reader:  an XML reader
5670  * @fd:  an open file descriptor
5671  * @URL:  the base URL to use for the document
5672  * @encoding:  the document encoding, or NULL
5673  * @options:  a combination of xmlParserOption
5674  *
5675  * Setup an xmltextReader to parse an XML from a file descriptor.
5676  * NOTE that the file descriptor will not be closed when the
5677  *      reader is closed or reset.
5678  * The parsing flags @options are a combination of xmlParserOption.
5679  * This reuses the existing @reader xmlTextReader.
5680  *
5681  * Returns 0 in case of success and -1 in case of error
5682  */
5683 int
5684 xmlReaderNewFd(xmlTextReaderPtr reader, int fd,
5685                const char *URL, const char *encoding, int options)
5686 {
5687     xmlParserInputBufferPtr input;
5688
5689     if (fd < 0)
5690         return (-1);
5691     if (reader == NULL)
5692         return (-1);
5693
5694     input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
5695     if (input == NULL)
5696         return (-1);
5697     input->closecallback = NULL;
5698     return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5699 }
5700
5701 /**
5702  * xmlReaderNewIO:
5703  * @reader:  an XML reader
5704  * @ioread:  an I/O read function
5705  * @ioclose:  an I/O close function
5706  * @ioctx:  an I/O handler
5707  * @URL:  the base URL to use for the document
5708  * @encoding:  the document encoding, or NULL
5709  * @options:  a combination of xmlParserOption
5710  *
5711  * Setup an xmltextReader to parse an XML document from I/O functions
5712  * and source.
5713  * The parsing flags @options are a combination of xmlParserOption.
5714  * This reuses the existing @reader xmlTextReader.
5715  *
5716  * Returns 0 in case of success and -1 in case of error
5717  */
5718 int
5719 xmlReaderNewIO(xmlTextReaderPtr reader, xmlInputReadCallback ioread,
5720                xmlInputCloseCallback ioclose, void *ioctx,
5721                const char *URL, const char *encoding, int options)
5722 {
5723     xmlParserInputBufferPtr input;
5724
5725     if (ioread == NULL)
5726         return (-1);
5727     if (reader == NULL)
5728         return (-1);
5729
5730     input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
5731                                          XML_CHAR_ENCODING_NONE);
5732     if (input == NULL) {
5733         if (ioclose != NULL)
5734             ioclose(ioctx);
5735         return (-1);
5736     }
5737     return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5738 }
5739
5740 /************************************************************************
5741  *                                                                      *
5742  *                      Utilities                                       *
5743  *                                                                      *
5744  ************************************************************************/
5745 #ifdef NOT_USED_YET
5746
5747 /**
5748  * xmlBase64Decode:
5749  * @in:  the input buffer
5750  * @inlen:  the size of the input (in), the size read from it (out)
5751  * @to:  the output buffer
5752  * @tolen:  the size of the output (in), the size written to (out)
5753  *
5754  * Base64 decoder, reads from @in and save in @to
5755  * TODO: tell jody when this is actually exported
5756  *
5757  * Returns 0 if all the input was consumer, 1 if the Base64 end was reached,
5758  *         2 if there wasn't enough space on the output or -1 in case of error.
5759  */
5760 static int
5761 xmlBase64Decode(const unsigned char *in, unsigned long *inlen,
5762                 unsigned char *to, unsigned long *tolen)
5763 {
5764     unsigned long incur;        /* current index in in[] */
5765
5766     unsigned long inblk;        /* last block index in in[] */
5767
5768     unsigned long outcur;       /* current index in out[] */
5769
5770     unsigned long inmax;        /* size of in[] */
5771
5772     unsigned long outmax;       /* size of out[] */
5773
5774     unsigned char cur;          /* the current value read from in[] */
5775
5776     unsigned char intmp[4], outtmp[4];  /* temporary buffers for the convert */
5777
5778     int nbintmp;                /* number of byte in intmp[] */
5779
5780     int is_ignore;              /* cur should be ignored */
5781
5782     int is_end = 0;             /* the end of the base64 was found */
5783
5784     int retval = 1;
5785
5786     int i;
5787
5788     if ((in == NULL) || (inlen == NULL) || (to == NULL) || (tolen == NULL))
5789         return (-1);
5790
5791     incur = 0;
5792     inblk = 0;
5793     outcur = 0;
5794     inmax = *inlen;
5795     outmax = *tolen;
5796     nbintmp = 0;
5797
5798     while (1) {
5799         if (incur >= inmax)
5800             break;
5801         cur = in[incur++];
5802         is_ignore = 0;
5803         if ((cur >= 'A') && (cur <= 'Z'))
5804             cur = cur - 'A';
5805         else if ((cur >= 'a') && (cur <= 'z'))
5806             cur = cur - 'a' + 26;
5807         else if ((cur >= '0') && (cur <= '9'))
5808             cur = cur - '0' + 52;
5809         else if (cur == '+')
5810             cur = 62;
5811         else if (cur == '/')
5812             cur = 63;
5813         else if (cur == '.')
5814             cur = 0;
5815         else if (cur == '=')    /*no op , end of the base64 stream */
5816             is_end = 1;
5817         else {
5818             is_ignore = 1;
5819             if (nbintmp == 0)
5820                 inblk = incur;
5821         }
5822
5823         if (!is_ignore) {
5824             int nbouttmp = 3;
5825
5826             int is_break = 0;
5827
5828             if (is_end) {
5829                 if (nbintmp == 0)
5830                     break;
5831                 if ((nbintmp == 1) || (nbintmp == 2))
5832                     nbouttmp = 1;
5833                 else
5834                     nbouttmp = 2;
5835                 nbintmp = 3;
5836                 is_break = 1;
5837             }
5838             intmp[nbintmp++] = cur;
5839             /*
5840              * if intmp is full, push the 4byte sequence as a 3 byte
5841              * sequence out
5842              */
5843             if (nbintmp == 4) {
5844                 nbintmp = 0;
5845                 outtmp[0] = (intmp[0] << 2) | ((intmp[1] & 0x30) >> 4);
5846                 outtmp[1] =
5847                     ((intmp[1] & 0x0F) << 4) | ((intmp[2] & 0x3C) >> 2);
5848                 outtmp[2] = ((intmp[2] & 0x03) << 6) | (intmp[3] & 0x3F);
5849                 if (outcur + 3 >= outmax) {
5850                     retval = 2;
5851                     break;
5852                 }
5853
5854                 for (i = 0; i < nbouttmp; i++)
5855                     to[outcur++] = outtmp[i];
5856                 inblk = incur;
5857             }
5858
5859             if (is_break) {
5860                 retval = 0;
5861                 break;
5862             }
5863         }
5864     }
5865
5866     *tolen = outcur;
5867     *inlen = inblk;
5868     return (retval);
5869 }
5870
5871 /*
5872  * Test routine for the xmlBase64Decode function
5873  */
5874 #if 0
5875 int
5876 main(int argc, char **argv)
5877 {
5878     char *input = "  VW4 gcGV0        \n      aXQgdGVzdCAuCg== ";
5879
5880     char output[100];
5881
5882     char output2[100];
5883
5884     char output3[100];
5885
5886     unsigned long inlen = strlen(input);
5887
5888     unsigned long outlen = 100;
5889
5890     int ret;
5891
5892     unsigned long cons, tmp, tmp2, prod;
5893
5894     /*
5895      * Direct
5896      */
5897     ret = xmlBase64Decode(input, &inlen, output, &outlen);
5898
5899     output[outlen] = 0;
5900     printf("ret: %d, inlen: %ld , outlen: %ld, output: '%s'\n", ret, inlen,
5901            outlen, output)indent: Standard input:179: Error:Unmatched #endif
5902 ;
5903
5904     /*
5905      * output chunking
5906      */
5907     cons = 0;
5908     prod = 0;
5909     while (cons < inlen) {
5910         tmp = 5;
5911         tmp2 = inlen - cons;
5912
5913         printf("%ld %ld\n", cons, prod);
5914         ret = xmlBase64Decode(&input[cons], &tmp2, &output2[prod], &tmp);
5915         cons += tmp2;
5916         prod += tmp;
5917         printf("%ld %ld\n", cons, prod);
5918     }
5919     output2[outlen] = 0;
5920     printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons,
5921            prod, output2);
5922
5923     /*
5924      * input chunking
5925      */
5926     cons = 0;
5927     prod = 0;
5928     while (cons < inlen) {
5929         tmp = 100 - prod;
5930         tmp2 = inlen - cons;
5931         if (tmp2 > 5)
5932             tmp2 = 5;
5933
5934         printf("%ld %ld\n", cons, prod);
5935         ret = xmlBase64Decode(&input[cons], &tmp2, &output3[prod], &tmp);
5936         cons += tmp2;
5937         prod += tmp;
5938         printf("%ld %ld\n", cons, prod);
5939     }
5940     output3[outlen] = 0;
5941     printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons,
5942            prod, output3);
5943     return (0);
5944
5945 }
5946 #endif
5947 #endif /* NOT_USED_YET */
5948 #define bottom_xmlreader
5949 #include "elfgcchack.h"
5950 #endif /* LIBXML_READER_ENABLED */