Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/parserInternals.c

 /*
  * parserInternals.c : Internal routines (and obsolete ones) needed for the
  *                     XML and HTML parsers.
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
@@ skipping 37 matching lines @@
 #include <libxml/xmlIO.h>
 #include <libxml/uri.h>
 #include <libxml/dict.h>
 #include <libxml/SAX.h>
 #ifdef LIBXML_CATALOG_ENABLED
 #include <libxml/catalog.h>
 #endif
 #include <libxml/globals.h>
 #include <libxml/chvalid.h>
 
+#include "buf.h"
+#include "enc.h"
+
 /*
  * Various global defaults for parsing
  */
 
 /**
  * xmlCheckVersion:
  * @version: the include version number
  *
  * check the compiled lib version against the include one.
  * This can warn or immediately kill the application
  */
 void
 xmlCheckVersion(int version) {
     int myversion = (int) LIBXML_VERSION;
 
     xmlInitParser();
 
     if ((myversion / 10000) != (version / 10000)) {
-        xmlGenericError(xmlGenericErrorContext, 
+        xmlGenericError(xmlGenericErrorContext,
                 "Fatal: program compiled against libxml %d using libxml %d\n",
                 (version / 10000), (myversion / 10000));
-        fprintf(stderr, 
+        fprintf(stderr,
                 "Fatal: program compiled against libxml %d using libxml %d\n",
                 (version / 10000), (myversion / 10000));
     }
     if ((myversion / 100) < (version / 100)) {
-        xmlGenericError(xmlGenericErrorContext, 
+        xmlGenericError(xmlGenericErrorContext,
                 "Warning: program compiled against libxml %d using older %d\n",
                 (version / 100), (myversion / 100));
     }
 }
 
 
 /************************************************************************
  *                                                                      *
- *              Some factorized error routines                          *
+ *              Some factorized error routines                          *
  *                                                                      *
  ************************************************************************/
 
 
 /**
  * xmlErrMemory:
  * @ctxt:  an XML parser context
  * @extra:  extra informations
  *
  * Handle a redefinition of attribute error
@@ skipping 114 matching lines @@
  *
  * Returns 0 if not, non-zero otherwise
  */
 int
 xmlIsLetter(int c) {
     return(IS_BASECHAR(c) || IS_IDEOGRAPHIC(c));
 }
 
 /************************************************************************
  *                                                                      *
- *              Input handling functions for progressive parsing        *
+ *              Input handling functions for progressive parsing        *
  *                                                                      *
  ************************************************************************/
 
 /* #define DEBUG_INPUT */
 /* #define DEBUG_STACK */
 /* #define DEBUG_PUSH */
 
 
 /* we need to keep enough input to show errors in context */
 #define LINE_LEN        80
 
 #ifdef DEBUG_INPUT
 #define CHECK_BUFFER(in) check_buffer(in)
 
 static
 void check_buffer(xmlParserInputPtr in) {
-    if (in->base != in->buf->buffer->content) {
+    if (in->base != xmlBufContent(in->buf->buffer)) {
         xmlGenericError(xmlGenericErrorContext,
                 "xmlParserInput: base mismatch problem\n");
     }
     if (in->cur < in->base) {
         xmlGenericError(xmlGenericErrorContext,
                 "xmlParserInput: cur < base problem\n");
     }
-    if (in->cur > in->base + in->buf->buffer->use) {
+    if (in->cur > in->base + xmlBufUse(in->buf->buffer)) {
         xmlGenericError(xmlGenericErrorContext,
                 "xmlParserInput: cur > base + use problem\n");
     }
-    xmlGenericError(xmlGenericErrorContext,"buffer %x : content %x, cur %d, use %d, size %d\n",
-            (int) in, (int) in->buf->buffer->content, in->cur - in->base,
-            in->buf->buffer->use, in->buf->buffer->size);
+    xmlGenericError(xmlGenericErrorContext,"buffer %x : content %x, cur %d, use %d\n",
+            (int) in, (int) xmlBufContent(in->buf->buffer), in->cur - in->base,
+            xmlBufUse(in->buf->buffer));
 }
 
 #else
-#define CHECK_BUFFER(in) 
+#define CHECK_BUFFER(in)
 #endif
 
 
 /**
  * xmlParserInputRead:
  * @in:  an XML parser input
  * @len:  an indicative size for the lookahead
  *
- * This function refresh the input for the parser. It doesn't try to
- * preserve pointers to the input buffer, and discard already read data
+ * This function was internal and is deprecated.
  *
- * Returns the number of xmlChars read, or -1 in case of error, 0 indicate the
- * end of this entity
+ * Returns -1 as this is an error to use it.
  */
 int
-xmlParserInputRead(xmlParserInputPtr in, int len) {
-    int ret;
-    int used;
-    int indx;
-
-    if (in == NULL) return(-1);
-#ifdef DEBUG_INPUT
-    xmlGenericError(xmlGenericErrorContext, "Read\n");
-#endif
-    if (in->buf == NULL) return(-1);
-    if (in->base == NULL) return(-1);
-    if (in->cur == NULL) return(-1);
-    if (in->buf->buffer == NULL) return(-1);
-    if (in->buf->readcallback == NULL) return(-1);
-
-    CHECK_BUFFER(in);
-
-    used = in->cur - in->buf->buffer->content;
-    ret = xmlBufferShrink(in->buf->buffer, used);
-    if (ret > 0) {
-        in->cur -= ret;
-        in->consumed += ret;
-    }
-    ret = xmlParserInputBufferRead(in->buf, len);
-    if (in->base != in->buf->buffer->content) {
-        /*
-         * the buffer has been reallocated
-         */
-        indx = in->cur - in->base;
-        in->base = in->buf->buffer->content;
-        in->cur = &in->buf->buffer->content[indx];
-    }
-    in->end = &in->buf->buffer->content[in->buf->buffer->use];
-
-    CHECK_BUFFER(in);
-
-    return(ret);
+xmlParserInputRead(xmlParserInputPtr in ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED) {
+    return(-1);
 }
 
 /**
  * xmlParserInputGrow:
  * @in:  an XML parser input
  * @len:  an indicative size for the lookahead
  *
  * This function increase the input for the parser. It tries to
  * preserve pointers to the input buffer, and keep already read data
  *
- * Returns the number of xmlChars read, or -1 in case of error, 0 indicate the
+ * Returns the amount of char read, or -1 in case of error, 0 indicate the
  * end of this entity
  */
 int
 xmlParserInputGrow(xmlParserInputPtr in, int len) {
-    int ret;
-    int indx;
+    size_t ret;
+    size_t indx;
+    const xmlChar *content;
 
-    if (in == NULL) return(-1);
+    if ((in == NULL) || (len < 0)) return(-1);
 #ifdef DEBUG_INPUT
     xmlGenericError(xmlGenericErrorContext, "Grow\n");
 #endif
     if (in->buf == NULL) return(-1);
     if (in->base == NULL) return(-1);
     if (in->cur == NULL) return(-1);
     if (in->buf->buffer == NULL) return(-1);
 
     CHECK_BUFFER(in);
 
     indx = in->cur - in->base;
-    if (in->buf->buffer->use > (unsigned int) indx + INPUT_CHUNK) {
+    if (xmlBufUse(in->buf->buffer) > (unsigned int) indx + INPUT_CHUNK) {
 
         CHECK_BUFFER(in);
 
         return(0);
     }
-    if (in->buf->readcallback != NULL)
+    if (in->buf->readcallback != NULL) {
         ret = xmlParserInputBufferGrow(in->buf, len);
-    else        
+    } else
         return(0);
 
     /*
      * NOTE : in->base may be a "dangling" i.e. freed pointer in this
      *        block, but we use it really as an integer to do some
      *        pointer arithmetic. Insure will raise it as a bug but in
      *        that specific case, that's not !
      */
-    if (in->base != in->buf->buffer->content) {
+
+    content = xmlBufContent(in->buf->buffer);
+    if (in->base != content) {
         /*
          * the buffer has been reallocated
          */
         indx = in->cur - in->base;
-        in->base = in->buf->buffer->content;
-        in->cur = &in->buf->buffer->content[indx];
+        in->base = content;
+        in->cur = &content[indx];
     }
-    in->end = &in->buf->buffer->content[in->buf->buffer->use];
+    in->end = xmlBufEnd(in->buf->buffer);
 
     CHECK_BUFFER(in);
 
     return(ret);
 }
 
 /**
  * xmlParserInputShrink:
  * @in:  an XML parser input
  *
  * This function removes used input for the parser.
  */
 void
 xmlParserInputShrink(xmlParserInputPtr in) {
-    int used;
-    int ret;
-    int indx;
+    size_t used;
+    size_t ret;
+    size_t indx;
+    const xmlChar *content;
 
 #ifdef DEBUG_INPUT
     xmlGenericError(xmlGenericErrorContext, "Shrink\n");
 #endif
     if (in == NULL) return;
     if (in->buf == NULL) return;
     if (in->base == NULL) return;
     if (in->cur == NULL) return;
     if (in->buf->buffer == NULL) return;
 
     CHECK_BUFFER(in);
 
-    used = in->cur - in->buf->buffer->content;
+    used = in->cur - xmlBufContent(in->buf->buffer);
     /*
      * Do not shrink on large buffers whose only a tiny fraction
      * was consumed
      */
     if (used > INPUT_CHUNK) {
-        ret = xmlBufferShrink(in->buf->buffer, used - LINE_LEN);
+        ret = xmlBufShrink(in->buf->buffer, used - LINE_LEN);
         if (ret > 0) {
             in->cur -= ret;
             in->consumed += ret;
         }
-        in->end = &in->buf->buffer->content[in->buf->buffer->use];
+        in->end = xmlBufEnd(in->buf->buffer);
     }
 
     CHECK_BUFFER(in);
 
-    if (in->buf->buffer->use > INPUT_CHUNK) {
+    if (xmlBufUse(in->buf->buffer) > INPUT_CHUNK) {
         return;
     }
     xmlParserInputBufferRead(in->buf, 2 * INPUT_CHUNK);
-    if (in->base != in->buf->buffer->content) {
+    content = xmlBufContent(in->buf->buffer);
+    if (in->base != content) {
         /*
          * the buffer has been reallocated
          */
         indx = in->cur - in->base;
-        in->base = in->buf->buffer->content;
-        in->cur = &in->buf->buffer->content[indx];
+        in->base = content;
+        in->cur = &content[indx];
     }
-    in->end = &in->buf->buffer->content[in->buf->buffer->use];
+    in->end = xmlBufEnd(in->buf->buffer);
 
     CHECK_BUFFER(in);
 }
 
 /************************************************************************
  *                                                                      *
- *              UTF8 character input and related functions              *
+ *              UTF8 character input and related functions              *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlNextChar:
  * @ctxt:  the XML parser context
  *
  * Skip to the next char input char.
  */
 
@@ skipping 30 matching lines @@
             } else
                 ctxt->input->col++;
 
             /*
              * We are supposed to handle UTF8, check it's valid
              * From rfc2044: encoding of the Unicode values on UTF-8:
              *
              * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
              * 0000 0000-0000 007F   0xxxxxxx
              * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
-             * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+             * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
              *
              * Check for the 0x110000 limit too
              */
             cur = ctxt->input->cur;
 
             c = *cur;
             if (c & 0x80) {
                 if (c == 0xC0)
                     goto encoding_error;
                 if (cur[1] == 0) {
@@ skipping 129 matching lines @@
             return((int) *ctxt->input->cur);
     }
     if (ctxt->charset == XML_CHAR_ENCODING_UTF8) {
         /*
          * We are supposed to handle UTF8, check it's valid
          * From rfc2044: encoding of the Unicode values on UTF-8:
          *
          * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
          * 0000 0000-0000 007F   0xxxxxxx
          * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
-         * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+         * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
          *
          * Check for the 0x110000 limit too
          */
         const unsigned char *cur = ctxt->input->cur;
         unsigned char c;
         unsigned int val;
 
         c = *cur;
         if (c & 0x80) {
             if (((c & 0x40) == 0) || (c == 0xC0))
@@ skipping 40 matching lines @@
               /* 2-byte code */
                 *len = 2;
                 val = (cur[0] & 0x1f) << 6;
                 val |= cur[1] & 0x3f;
                 if (val < 0x80)
                     goto encoding_error;
             }
             if (!IS_CHAR(val)) {
                 xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
                                   "Char 0x%X out of allowed range\n", val);
-            }    
+            }
             return(val);
         } else {
             /* 1-byte code */
             *len = 1;
             if (*ctxt->input->cur == 0)
                 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
             if ((*ctxt->input->cur == 0) &&
                 (ctxt->input->end > ctxt->input->cur)) {
                 xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
                                   "Char 0x0 out of allowed range\n", 0);
@@ skipping 43 matching lines @@
     {
         char buffer[150];
 
         snprintf(&buffer[0], 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
                         ctxt->input->cur[0], ctxt->input->cur[1],
                         ctxt->input->cur[2], ctxt->input->cur[3]);
         __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
                      "Input is not proper UTF-8, indicate encoding !\n%s",
                      BAD_CAST buffer, NULL);
     }
-    ctxt->charset = XML_CHAR_ENCODING_8859_1; 
+    ctxt->charset = XML_CHAR_ENCODING_8859_1;
     *len = 1;
     return((int) *ctxt->input->cur);
 }
 
 /**
  * xmlStringCurrentChar:
  * @ctxt:  the XML parser context
  * @cur:  pointer to the beginning of the char
  * @len:  pointer to the length of the char read
  *
  * The current char value, if using UTF-8 this may actually span multiple
  * bytes in the input buffer.
  *
  * Returns the current char value and its length
  */
 
 int
 xmlStringCurrentChar(xmlParserCtxtPtr ctxt, const xmlChar * cur, int *len)
 {
     if ((len == NULL) || (cur == NULL)) return(0);
     if ((ctxt == NULL) || (ctxt->charset == XML_CHAR_ENCODING_UTF8)) {
         /*
          * We are supposed to handle UTF8, check it's valid
          * From rfc2044: encoding of the Unicode values on UTF-8:
          *
          * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
          * 0000 0000-0000 007F   0xxxxxxx
          * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
-         * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+         * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
          *
          * Check for the 0x110000 limit too
          */
         unsigned char c;
         unsigned int val;
 
         c = *cur;
         if (c & 0x80) {
             if ((cur[1] & 0xc0) != 0x80)
                 goto encoding_error;
@@ skipping 72 matching lines @@
     }
     *len = 1;
     return ((int) *cur);
 }
 
 /**
  * xmlCopyCharMultiByte:
  * @out:  pointer to an array of xmlChar
  * @val:  the char value
  *
- * append the char value in the array 
+ * append the char value in the array
  *
  * Returns the number of xmlChar written
  */
 int
 xmlCopyCharMultiByte(xmlChar *out, int val) {
     if (out == NULL) return(0);
     /*
      * We are supposed to handle UTF8, check it's valid
      * From rfc2044: encoding of the Unicode values on UTF-8:
      *
      * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
      * 0000 0000-0000 007F   0xxxxxxx
      * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
-     * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+     * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
      */
     if  (val >= 0x80) {
         xmlChar *savedout = out;
         int bits;
         if (val <   0x800) { *out++= (val >>  6) | 0xC0;  bits=  0; }
         else if (val < 0x10000) { *out++= (val >> 12) | 0xE0;  bits=  6;}
         else if (val < 0x110000)  { *out++= (val >> 18) | 0xF0;  bits=  12; }
         else {
             xmlErrEncodingInt(NULL, XML_ERR_INVALID_CHAR,
                     "Internal error, xmlCopyCharMultiByte 0x%X out of bound\n",
                               val);
             return(0);
         }
         for ( ; bits >= 0; bits-= 6)
             *out++= ((val >> bits) & 0x3F) | 0x80 ;
         return (out - savedout);
     }
     *out = (xmlChar) val;
     return 1;
 }
 
 /**
  * xmlCopyChar:
  * @len:  Ignored, compatibility
  * @out:  pointer to an array of xmlChar
  * @val:  the char value
  *
- * append the char value in the array 
+ * append the char value in the array
  *
  * Returns the number of xmlChar written
  */
 
 int
 xmlCopyChar(int len ATTRIBUTE_UNUSED, xmlChar *out, int val) {
     if (out == NULL) return(0);
     /* the len parameter is ignored */
     if  (val >= 0x80) {
         return(xmlCopyCharMultiByte (out, val));
     }
     *out = (xmlChar) val;
     return 1;
 }
 
 /************************************************************************
  *                                                                      *
  *              Commodity functions to switch encodings                 *
  *                                                                      *
  ************************************************************************/
 
-/* defined in encoding.c, not public */
-int
-xmlCharEncFirstLineInt(xmlCharEncodingHandler *handler, xmlBufferPtr out,
-                       xmlBufferPtr in, int len);
-
 static int
 xmlSwitchToEncodingInt(xmlParserCtxtPtr ctxt,
                        xmlCharEncodingHandlerPtr handler, int len);
 static int
 xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlParserInputPtr input,
                           xmlCharEncodingHandlerPtr handler, int len);
 /**
  * xmlSwitchEncoding:
  * @ctxt:  the parser context
  * @enc:  the encoding value (number)
@@ skipping 219 matching lines @@
              */
             xmlCharEncCloseFunc(input->buf->encoder);
             input->buf->encoder = handler;
             return (0);
         }
         input->buf->encoder = handler;
 
         /*
          * Is there already some content down the pipe to convert ?
          */
-        if ((input->buf->buffer != NULL) && (input->buf->buffer->use > 0)) {
+        if (xmlBufIsEmpty(input->buf->buffer) == 0) {
             int processed;
             unsigned int use;
 
             /*
-             * Specific handling of the Byte Order Mark for 
+             * Specific handling of the Byte Order Mark for
              * UTF-16
              */
             if ((handler->name != NULL) &&
                 (!strcmp(handler->name, "UTF-16LE") ||
                  !strcmp(handler->name, "UTF-16")) &&
                 (input->cur[0] == 0xFF) && (input->cur[1] == 0xFE)) {
                 input->cur += 2;
             }
             if ((handler->name != NULL) &&
                 (!strcmp(handler->name, "UTF-16BE")) &&
@@ skipping 10 matching lines @@
                 (input->cur[0] == 0xEF) &&
                 (input->cur[1] == 0xBB) && (input->cur[2] == 0xBF)) {
                 input->cur += 3;
             }
 
             /*
              * Shrink the current input buffer.
              * Move it as the raw buffer and create a new input buffer
              */
             processed = input->cur - input->base;
-            xmlBufferShrink(input->buf->buffer, processed);
+            xmlBufShrink(input->buf->buffer, processed);
             input->buf->raw = input->buf->buffer;
-            input->buf->buffer = xmlBufferCreate();
+            input->buf->buffer = xmlBufCreate();
             input->buf->rawconsumed = processed;
-            use = input->buf->raw->use;
+            use = xmlBufUse(input->buf->raw);
 
             if (ctxt->html) {
                 /*
                  * convert as much as possible of the buffer
                  */
-                nbchars = xmlCharEncInFunc(input->buf->encoder,
-                                           input->buf->buffer,
-                                           input->buf->raw);
+                nbchars = xmlCharEncInput(input->buf, 1);
             } else {
                 /*
                  * convert just enough to get
                  * '<?xml version="1.0" encoding="xxx"?>'
                  * parsed with the autodetected encoding
                  * into the parser reading buffer.
                  */
-                nbchars = xmlCharEncFirstLineInt(input->buf->encoder,
-                                                 input->buf->buffer,
-                                                 input->buf->raw,
-                                                 len);
+                nbchars = xmlCharEncFirstLineInput(input->buf, len);
             }
             if (nbchars < 0) {
                 xmlErrInternal(ctxt,
                                "switching encoding: encoder error\n",
                                NULL);
                 return (-1);
             }
-            input->buf->rawconsumed += use - input->buf->raw->use;
-            input->base = input->cur = input->buf->buffer->content;
-            input->end = &input->base[input->buf->buffer->use];
-
+            input->buf->rawconsumed += use - xmlBufUse(input->buf->raw);
+            xmlBufResetInput(input->buf->buffer, input);
         }
         return (0);
     } else if (input->length == 0) {
         /*
          * When parsing a static memory array one must know the
          * size to be able to convert the buffer.
          */
         xmlErrInternal(ctxt, "switching encoding : no input\n", NULL);
         return (-1);
     }
@@ skipping 14 matching lines @@
 int
 xmlSwitchInputEncoding(xmlParserCtxtPtr ctxt, xmlParserInputPtr input,
                           xmlCharEncodingHandlerPtr handler) {
     return(xmlSwitchInputEncodingInt(ctxt, input, handler, -1));
 }
 
 /**
  * xmlSwitchToEncodingInt:
  * @ctxt:  the parser context
  * @handler:  the encoding handler
- * @len: the lenght to convert or -1
+ * @len: the length to convert or -1
  *
  * change the input functions when discovering the character encoding
  * of a given entity, and convert only @len bytes of the output, this
  * is needed on auto detect to allows any declared encoding later to
  * convert the actual content after the xmlDecl
  *
  * Returns 0 in case of success, -1 otherwise
  */
 static int
 xmlSwitchToEncodingInt(xmlParserCtxtPtr ctxt,
@@ skipping 21 matching lines @@
  * xmlSwitchToEncoding:
  * @ctxt:  the parser context
  * @handler:  the encoding handler
  *
  * change the input functions when discovering the character encoding
  * of a given entity.
  *
  * Returns 0 in case of success, -1 otherwise
  */
 int
-xmlSwitchToEncoding(xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler) 
+xmlSwitchToEncoding(xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler)
 {
     return (xmlSwitchToEncodingInt(ctxt, handler, -1));
 }
 
 /************************************************************************
  *                                                                      *
  *      Commodity functions to handle entities processing               *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlFreeInputStream:
  * @input:  an xmlParserInputPtr
  *
  * Free up an input stream.
  */
 void
 xmlFreeInputStream(xmlParserInputPtr input) {
     if (input == NULL) return;
 
     if (input->filename != NULL) xmlFree((char *) input->filename);
     if (input->directory != NULL) xmlFree((char *) input->directory);
     if (input->encoding != NULL) xmlFree((char *) input->encoding);
     if (input->version != NULL) xmlFree((char *) input->version);
     if ((input->free != NULL) && (input->base != NULL))
         input->free((xmlChar *) input->base);
-    if (input->buf != NULL) 
+    if (input->buf != NULL)
         xmlFreeParserInputBuffer(input->buf);
     xmlFree(input);
 }
 
 /**
  * xmlNewInputStream:
  * @ctxt:  an XML parser context
  *
- * Create a new input stream structure
+ * Create a new input stream structure.
+ *
  * Returns the new input stream or NULL
  */
 xmlParserInputPtr
 xmlNewInputStream(xmlParserCtxtPtr ctxt) {
     xmlParserInputPtr input;
-    static int id = 0;
 
     input = (xmlParserInputPtr) xmlMalloc(sizeof(xmlParserInput));
     if (input == NULL) {
         xmlErrMemory(ctxt,  "couldn't allocate a new input stream\n");
         return(NULL);
     }
     memset(input, 0, sizeof(xmlParserInput));
     input->line = 1;
     input->col = 1;
     input->standalone = -1;
+
     /*
-     * we don't care about thread reentrancy unicity for a single
-     * parser context (and hence thread) is sufficient.
+     * If the context is NULL the id cannot be initialized, but that
+     * should not happen while parsing which is the situation where
+     * the id is actually needed.
      */
-    input->id = id++;
+    if (ctxt != NULL)
+        input->id = ctxt->input_id++;
+
     return(input);
 }
 
 /**
  * xmlNewIOInputStream:
  * @ctxt:  an XML parser context
  * @input:  an I/O Input
  * @enc:  the charset encoding if known
  *
  * Create a new input stream structure encapsulating the @input into
  * a stream suitable for the parser.
  *
  * Returns the new input stream or NULL
  */
 xmlParserInputPtr
 xmlNewIOInputStream(xmlParserCtxtPtr ctxt, xmlParserInputBufferPtr input,
                     xmlCharEncoding enc) {
     xmlParserInputPtr inputStream;
 
     if (input == NULL) return(NULL);
     if (xmlParserDebugEntities)
         xmlGenericError(xmlGenericErrorContext, "new input from I/O\n");
     inputStream = xmlNewInputStream(ctxt);
     if (inputStream == NULL) {
         return(NULL);
     }
     inputStream->filename = NULL;
     inputStream->buf = input;
-    inputStream->base = inputStream->buf->buffer->content;
-    inputStream->cur = inputStream->buf->buffer->content;
-    inputStream->end = &inputStream->base[inputStream->buf->buffer->use];
+    xmlBufResetInput(inputStream->buf->buffer, inputStream);
+
     if (enc != XML_CHAR_ENCODING_NONE) {
         xmlSwitchEncoding(ctxt, enc);
     }
 
     return(inputStream);
 }
 
 /**
  * xmlNewEntityInputStream:
  * @ctxt:  an XML parser context
@@ skipping 121 matching lines @@
     }
 
     inputStream = xmlNewInputStream(ctxt);
     if (inputStream == NULL)
         return(NULL);
 
     inputStream->buf = buf;
     inputStream = xmlCheckHTTPInput(ctxt, inputStream);
     if (inputStream == NULL)
         return(NULL);
-    
+
     if (inputStream->filename == NULL)
         URI = xmlStrdup((xmlChar *) filename);
     else
         URI = xmlStrdup((xmlChar *) inputStream->filename);
     directory = xmlParserGetDirectory((const char *) URI);
     if (inputStream->filename != NULL) xmlFree((char *)inputStream->filename);
     inputStream->filename = (char *) xmlCanonicPath((const xmlChar *) URI);
     if (URI != NULL) xmlFree((char *) URI);
     inputStream->directory = directory;
 
-    inputStream->base = inputStream->buf->buffer->content;
-    inputStream->cur = inputStream->buf->buffer->content;
-    inputStream->end = &inputStream->base[inputStream->buf->buffer->use];
+    xmlBufResetInput(inputStream->buf->buffer, inputStream);
     if ((ctxt->directory == NULL) && (directory != NULL))
         ctxt->directory = (char *) xmlStrdup((const xmlChar *) directory);
     return(inputStream);
 }
 
 /************************************************************************
  *                                                                      *
  *              Commodity functions to handle parser contexts           *
  *                                                                      *
  ************************************************************************/
@@ skipping 18 matching lines @@
     }
 
     xmlDefaultSAXHandlerInit();
 
     if (ctxt->dict == NULL)
         ctxt->dict = xmlDictCreate();
     if (ctxt->dict == NULL) {
         xmlErrMemory(NULL, "cannot initialize parser context\n");
         return(-1);
     }
+    xmlDictSetLimit(ctxt->dict, XML_MAX_DICTIONARY_LIMIT);
+
     if (ctxt->sax == NULL)
         ctxt->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
     if (ctxt->sax == NULL) {
         xmlErrMemory(NULL, "cannot initialize parser context\n");
         return(-1);
     }
     else
         xmlSAXVersion(ctxt->sax, 2);
 
     ctxt->maxatts = 0;
@@ skipping 91 matching lines @@
     ctxt->spaceNr = 1;
     ctxt->spaceMax = 10;
     ctxt->spaceTab[0] = -1;
     ctxt->space = &ctxt->spaceTab[0];
     ctxt->userData = ctxt;
     ctxt->myDoc = NULL;
     ctxt->wellFormed = 1;
     ctxt->nsWellFormed = 1;
     ctxt->valid = 1;
     ctxt->loadsubset = xmlLoadExtDtdDefaultValue;
+    if (ctxt->loadsubset) {
+        ctxt->options |= XML_PARSE_DTDLOAD;
+    }
     ctxt->validate = xmlDoValidityCheckingDefaultValue;
     ctxt->pedantic = xmlPedanticParserDefaultValue;
+    if (ctxt->pedantic) {
+        ctxt->options |= XML_PARSE_PEDANTIC;
+    }
     ctxt->linenumbers = xmlLineNumbersDefaultValue;
     ctxt->keepBlanks = xmlKeepBlanksDefaultValue;
-    if (ctxt->keepBlanks == 0)
+    if (ctxt->keepBlanks == 0) {
         ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+        ctxt->options |= XML_PARSE_NOBLANKS;
+    }
 
     ctxt->vctxt.finishDtd = XML_CTXT_FINISH_DTD_0;
     ctxt->vctxt.userData = ctxt;
     ctxt->vctxt.error = xmlParserValidityError;
     ctxt->vctxt.warning = xmlParserValidityWarning;
     if (ctxt->validate) {
         if (xmlGetWarningsDefaultValue == 0)
             ctxt->vctxt.warning = NULL;
         else
             ctxt->vctxt.warning = xmlParserValidityWarning;
         ctxt->vctxt.nodeMax = 0;
+        ctxt->options |= XML_PARSE_DTDVALID;
     }
     ctxt->replaceEntities = xmlSubstituteEntitiesDefaultValue;
+    if (ctxt->replaceEntities) {
+        ctxt->options |= XML_PARSE_NOENT;
+    }
     ctxt->record_info = 0;
     ctxt->nbChars = 0;
     ctxt->checkIndex = 0;
     ctxt->inSubset = 0;
     ctxt->errNo = XML_ERR_OK;
     ctxt->depth = 0;
     ctxt->charset = XML_CHAR_ENCODING_UTF8;
     ctxt->catalogs = NULL;
     ctxt->nbentities = 0;
+    ctxt->sizeentities = 0;
+    ctxt->sizeentcopy = 0;
+    ctxt->input_id = 1;
     xmlInitNodeInfoSeq(&ctxt->node_seq);
     return(0);
 }
 
 /**
  * xmlFreeParserCtxt:
  * @ctxt:  an XML parser context
  *
  * Free all the memory used by a parser context. However the parsed
  * document in ctxt->myDoc is not freed.
@@ skipping 25 matching lines @@
     if (ctxt->sax != NULL)
 #endif /* LIBXML_SAX1_ENABLED */
         xmlFree(ctxt->sax);
     if (ctxt->directory != NULL) xmlFree((char *) ctxt->directory);
     if (ctxt->vctxt.nodeTab != NULL) xmlFree(ctxt->vctxt.nodeTab);
     if (ctxt->atts != NULL) xmlFree((xmlChar * *)ctxt->atts);
     if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
     if (ctxt->nsTab != NULL) xmlFree((char *) ctxt->nsTab);
     if (ctxt->pushTab != NULL) xmlFree(ctxt->pushTab);
     if (ctxt->attallocs != NULL) xmlFree(ctxt->attallocs);
-    if (ctxt->attsDefault != NULL) 
+    if (ctxt->attsDefault != NULL)
         xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
     if (ctxt->attsSpecial != NULL)
         xmlHashFree(ctxt->attsSpecial, NULL);
     if (ctxt->freeElems != NULL) {
         xmlNodePtr cur, next;
 
         cur = ctxt->freeElems;
         while (cur != NULL) {
             next = cur->next;
             xmlFree(cur);
@@ skipping 79 matching lines @@
   xmlCtxtReset(ctxt);
 }
 
 
 /**
  * xmlParserFindNodeInfo:
  * @ctx:  an XML parser context
  * @node:  an XML node within the tree
  *
  * Find the parser node info struct for a given node
- * 
+ *
  * Returns an xmlParserNodeInfo block pointer or NULL
  */
 const xmlParserNodeInfo *
 xmlParserFindNodeInfo(const xmlParserCtxtPtr ctx, const xmlNodePtr node)
 {
     unsigned long pos;
 
     if ((ctx == NULL) || (node == NULL))
         return (NULL);
     /* Find position where node should be at */
@@ skipping 37 matching lines @@
     if (seq->buffer != NULL)
         xmlFree(seq->buffer);
     xmlInitNodeInfoSeq(seq);
 }
 
 /**
  * xmlParserFindNodeInfoIndex:
  * @seq:  a node info sequence pointer
  * @node:  an XML node pointer
  *
- * 
+ *
  * xmlParserFindNodeInfoIndex : Find the index that the info record for
  *   the given node is or should be at in a sorted sequence
  *
  * Returns a long indicating the position of the record
  */
 unsigned long
 xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
                            const xmlNodePtr node)
 {
     unsigned long upper, lower, middle;
@@ skipping 36 matching lines @@
                      const xmlParserNodeInfoPtr info)
 {
     unsigned long pos;
 
     if ((ctxt == NULL) || (info == NULL)) return;
 
     /* Find pos and check to see if node is already in the sequence */
     pos = xmlParserFindNodeInfoIndex(&ctxt->node_seq, (xmlNodePtr)
                                      info->node);
 
-    if ((pos < ctxt->node_seq.length) && 
+    if ((pos < ctxt->node_seq.length) &&
         (ctxt->node_seq.buffer != NULL) &&
         (ctxt->node_seq.buffer[pos].node == info->node)) {
         ctxt->node_seq.buffer[pos] = *info;
     }
 
     /* Otherwise, we need to add new node to buffer */
     else {
-        if (ctxt->node_seq.length + 1 > ctxt->node_seq.maximum) {
+        if ((ctxt->node_seq.length + 1 > ctxt->node_seq.maximum) ||
+            (ctxt->node_seq.buffer == NULL)) {
             xmlParserNodeInfo *tmp_buffer;
             unsigned int byte_size;
 
             if (ctxt->node_seq.maximum == 0)
                 ctxt->node_seq.maximum = 2;
             byte_size = (sizeof(*ctxt->node_seq.buffer) *
                         (2 * ctxt->node_seq.maximum));
 
             if (ctxt->node_seq.buffer == NULL)
                 tmp_buffer = (xmlParserNodeInfo *) xmlMalloc(byte_size);
@@ skipping 24 matching lines @@
     }
 }
 
 /************************************************************************
  *                                                                      *
  *              Defaults settings                                       *
  *                                                                      *
  ************************************************************************/
 /**
  * xmlPedanticParserDefault:
- * @val:  int 0 or 1 
+ * @val:  int 0 or 1
  *
  * Set and return the previous value for enabling pedantic warnings.
  *
  * Returns the last value for 0 for no substitution, 1 for substitution.
  */
 
 int
 xmlPedanticParserDefault(int val) {
     int old = xmlPedanticParserDefaultValue;
 
     xmlPedanticParserDefaultValue = val;
     return(old);
 }
 
 /**
  * xmlLineNumbersDefault:
- * @val:  int 0 or 1 
+ * @val:  int 0 or 1
  *
  * Set and return the previous value for enabling line numbers in elements
  * contents. This may break on old application and is turned off by default.
  *
  * Returns the last value for 0 for no substitution, 1 for substitution.
  */
 
 int
 xmlLineNumbersDefault(int val) {
     int old = xmlLineNumbersDefaultValue;
 
     xmlLineNumbersDefaultValue = val;
     return(old);
 }
 
 /**
  * xmlSubstituteEntitiesDefault:
- * @val:  int 0 or 1 
+ * @val:  int 0 or 1
  *
  * Set and return the previous value for default entity support.
  * Initially the parser always keep entity references instead of substituting
  * entity values in the output. This function has to be used to change the
  * default parser behavior
  * SAX::substituteEntities() has to be used for changing that on a file by
  * file basis.
  *
  * Returns the last value for 0 for no substitution, 1 for substitution.
  */
 
 int
 xmlSubstituteEntitiesDefault(int val) {
     int old = xmlSubstituteEntitiesDefaultValue;
 
     xmlSubstituteEntitiesDefaultValue = val;
     return(old);
 }
 
 /**
  * xmlKeepBlanksDefault:
- * @val:  int 0 or 1 
+ * @val:  int 0 or 1
  *
  * Set and return the previous value for default blanks text nodes support.
  * The 1.x version of the parser used an heuristic to try to detect
  * ignorable white spaces. As a result the SAX callback was generating
  * xmlSAX2IgnorableWhitespace() callbacks instead of characters() one, and when
  * using the DOM output text nodes containing those blanks were not generated.
  * The 2.x and later version will switch to the XML standard way and
  * ignorableWhitespace() are only generated when running the parser in
  * validating mode and when the current element doesn't allow CDATA or
  * mixed content.
- * This function is provided as a way to force the standard behavior 
+ * This function is provided as a way to force the standard behavior
  * on 1.X libs and to switch back to the old mode for compatibility when
  * running 1.X client code on 2.X . Upgrade of 1.X code should be done
  * by using xmlIsBlankNode() commodity function to detect the "empty"
  * nodes generated.
  * This value also affect autogeneration of indentation when saving code
  * if blanks sections are kept, indentation is not generated.
  *
  * Returns the last value for 0 for no substitution, 1 for substitution.
  */
 
 int
 xmlKeepBlanksDefault(int val) {
     int old = xmlKeepBlanksDefaultValue;
 
     xmlKeepBlanksDefaultValue = val;
     if (!val) xmlIndentTreeOutput = 1;
     return(old);
 }
 
 #define bottom_parserInternals
 #include "elfgcchack.h"