Update libxml to 2.7.7.

third_party/libxml/xmlmemory.c

 /*
  * xmlmemory.c:  libxml memory allocator wrapper.
  *
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
 #include "libxml.h"
 
 #include <string.h>
@@ skipping 16 matching lines @@
 
 #ifdef HAVE_CTYPE_H
 #include <ctype.h>
 #endif
 
 /* #define DEBUG_MEMORY */
 
 /**
  * MEM_LIST:
  *
- * keep track of all allocated blocks for error reporting 
+ * keep track of all allocated blocks for error reporting
  * Always build the memory list !
  */
 #ifdef DEBUG_MEMORY_LOCATION
 #ifndef MEM_LIST
 #define MEM_LIST /* keep a list of all the allocated memory blocks */
 #endif
 #endif
 
 #include <libxml/globals.h>     /* must come before xmlmemory.h */
 #include <libxml/xmlmemory.h>
@@ skipping 107 matching lines @@
  * a malloc() equivalent, with logging of the allocation info.
  *
  * Returns a pointer to the allocated area or NULL in case of lack of memory.
  */
 
 void *
 xmlMallocLoc(size_t size, const char * file, int line)
 {
     MEMHDR *p;
     void *ret;
-    
+
     if (!xmlMemInitialized) xmlInitMemory();
 #ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
             "Malloc(%d)\n",size);
 #endif
 
     TEST_POINT
-    
+
     p = (MEMHDR *) malloc(RESERVE_SIZE+size);
 
     if (!p) {
         xmlGenericError(xmlGenericErrorContext,
                 "xmlMallocLoc : Out of free space\n");
         xmlMemoryDump();
         return(NULL);
-    }   
+    }
     p->mh_tag = MEMTAG;
     p->mh_size = size;
     p->mh_type = MALLOC_TYPE;
     p->mh_file = file;
     p->mh_line = line;
     xmlMutexLock(xmlMemMutex);
     p->mh_number = ++block;
     debugMemSize += size;
     debugMemBlocks++;
     if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
 #ifdef MEM_LIST
     debugmem_list_add(p);
 #endif
     xmlMutexUnlock(xmlMemMutex);
-    
+
 #ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
             "Malloc(%d) Ok\n",size);
 #endif
-    
+
     if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
 
     ret = HDR_2_CLIENT(p);
 
     if (xmlMemTraceBlockAt == ret) {
         xmlGenericError(xmlGenericErrorContext,
-                        "%p : Malloc(%d) Ok\n", xmlMemTraceBlockAt, size);
+                        "%p : Malloc(%ld) Ok\n", xmlMemTraceBlockAt, size);
         xmlMallocBreakpoint();
     }
 
     TEST_POINT
 
     return(ret);
 }
 
 /**
  * xmlMallocAtomicLoc:
  * @size:  an int specifying the size in byte to allocate.
  * @file:  the file name or NULL
  * @line:  the line number
  *
  * a malloc() equivalent, with logging of the allocation info.
  *
  * Returns a pointer to the allocated area or NULL in case of lack of memory.
  */
 
 void *
 xmlMallocAtomicLoc(size_t size, const char * file, int line)
 {
     MEMHDR *p;
     void *ret;
-    
+
     if (!xmlMemInitialized) xmlInitMemory();
 #ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
             "Malloc(%d)\n",size);
 #endif
 
     TEST_POINT
-    
+
     p = (MEMHDR *) malloc(RESERVE_SIZE+size);
 
     if (!p) {
         xmlGenericError(xmlGenericErrorContext,
                 "xmlMallocLoc : Out of free space\n");
         xmlMemoryDump();
         return(NULL);
-    }   
+    }
     p->mh_tag = MEMTAG;
     p->mh_size = size;
     p->mh_type = MALLOC_ATOMIC_TYPE;
     p->mh_file = file;
     p->mh_line = line;
     xmlMutexLock(xmlMemMutex);
     p->mh_number = ++block;
     debugMemSize += size;
     debugMemBlocks++;
     if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
 #ifdef MEM_LIST
     debugmem_list_add(p);
 #endif
     xmlMutexUnlock(xmlMemMutex);
 
 #ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
             "Malloc(%d) Ok\n",size);
 #endif
-    
+
     if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
 
     ret = HDR_2_CLIENT(p);
 
     if (xmlMemTraceBlockAt == ret) {
         xmlGenericError(xmlGenericErrorContext,
-                        "%p : Malloc(%d) Ok\n", xmlMemTraceBlockAt, size);
+                        "%p : Malloc(%ld) Ok\n", xmlMemTraceBlockAt, size);
         xmlMallocBreakpoint();
     }
 
     TEST_POINT
 
     return(ret);
 }
 /**
  * xmlMemMalloc:
  * @size:  an int specifying the size in byte to allocate.
@@ skipping 47 matching lines @@
     xmlMutexLock(xmlMemMutex);
     debugMemSize -= p->mh_size;
     debugMemBlocks--;
 #ifdef DEBUG_MEMORY
     oldsize = p->mh_size;
 #endif
 #ifdef MEM_LIST
     debugmem_list_delete(p);
 #endif
     xmlMutexUnlock(xmlMemMutex);
-    
+
     p = (MEMHDR *) realloc(p,RESERVE_SIZE+size);
     if (!p) {
          goto error;
     }
     if (xmlMemTraceBlockAt == ptr) {
         xmlGenericError(xmlGenericErrorContext,
-                        "%p : Realloced(%d -> %d) Ok\n",
+                        "%p : Realloced(%ld -> %ld) Ok\n",
                         xmlMemTraceBlockAt, p->mh_size, size);
         xmlMallocBreakpoint();
     }
     p->mh_tag = MEMTAG;
     p->mh_number = number;
     p->mh_type = REALLOC_TYPE;
     p->mh_size = size;
     p->mh_file = file;
     p->mh_line = line;
     xmlMutexLock(xmlMemMutex);
     debugMemSize += size;
     debugMemBlocks++;
     if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
 #ifdef MEM_LIST
     debugmem_list_add(p);
 #endif
     xmlMutexUnlock(xmlMemMutex);
 
     TEST_POINT
 
 #ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
             "Realloced(%d to %d) Ok\n", oldsize, size);
 #endif
     return(HDR_2_CLIENT(p));
-    
-error:    
+
+error:
     return(NULL);
 }
 
 /**
  * xmlMemRealloc:
  * @ptr:  the initial memory block pointer
  * @size:  an int specifying the size in byte to allocate.
  *
  * a realloc() equivalent, with logging of the allocation info.
  *
@@ skipping 59 matching lines @@
     xmlMutexUnlock(xmlMemMutex);
 
     free(p);
 
     TEST_POINT
 
 #ifdef DEBUG_MEMORY
     xmlGenericError(xmlGenericErrorContext,
             "Freed(%d) Ok\n", size);
 #endif
-    
+
     return;
-    
-error:    
+
+error:
     xmlGenericError(xmlGenericErrorContext,
             "xmlMemFree(%lX) error\n", (unsigned long) ptr);
     xmlMallocBreakpoint();
     return;
 }
 
 /**
  * xmlMemStrdupLoc:
  * @str:  the initial string pointer
  * @file:  the file name or NULL
@@ skipping 25 matching lines @@
     p->mh_line = line;
     xmlMutexLock(xmlMemMutex);
     p->mh_number = ++block;
     debugMemSize += size;
     debugMemBlocks++;
     if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
 #ifdef MEM_LIST
     debugmem_list_add(p);
 #endif
     xmlMutexUnlock(xmlMemMutex);
-    
+
     s = (char *) HDR_2_CLIENT(p);
-    
+
     if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
 
     if (s != NULL)
       strcpy(s,str);
     else
       goto error;
-    
+
     TEST_POINT
 
     if (xmlMemTraceBlockAt == s) {
         xmlGenericError(xmlGenericErrorContext,
                         "%p : Strdup() Ok\n", xmlMemTraceBlockAt);
         xmlMallocBreakpoint();
     }
 
     return(s);
 
@@ skipping 83 matching lines @@
                 if ((p != NULL) && (p == q)) {
                     fprintf(fp, " pointer to #%lu at index %d",
                             p->mh_number, j);
                     return;
                 }
             }
         }
     } else if ((i == 0) && (buf[i] == 0)) {
         fprintf(fp," null");
     } else {
-        if (buf[i] == 0) fprintf(fp," \"%.25s\"", buf); 
+        if (buf[i] == 0) fprintf(fp," \"%.25s\"", buf);
         else {
             fprintf(fp," [");
             for (j = 0;j < i;j++)
                 fprintf(fp,"%c", buf[j]);
             fprintf(fp,"]");
         }
     }
 }
 #endif
 
 /**
+ * xmlMemDisplayLast:
+ * @fp:  a FILE descriptor used as the output file, if NULL, the result is
+ *       written to the file .memorylist
+ * @nbBytes: the amount of memory to dump
+ *
+ * the last nbBytes of memory allocated and not freed, useful for dumping
+ * the memory left allocated between two places at runtime.
+ */
+
+void
+xmlMemDisplayLast(FILE *fp, long nbBytes)
+{
+#ifdef MEM_LIST
+    MEMHDR *p;
+    unsigned idx;
+    int     nb = 0;
+#endif
+    FILE *old_fp = fp;
+
+    if (nbBytes <= 0)
+        return;
+
+    if (fp == NULL) {
+        fp = fopen(".memorylist", "w");
+        if (fp == NULL)
+            return;
+    }
+
+#ifdef MEM_LIST
+    fprintf(fp,"   Last %li MEMORY ALLOCATED : %lu, MAX was %lu\n",
+            nbBytes, debugMemSize, debugMaxMemSize);
+    fprintf(fp,"BLOCK  NUMBER   SIZE  TYPE\n");
+    idx = 0;
+    xmlMutexLock(xmlMemMutex);
+    p = memlist;
+    while ((p) && (nbBytes > 0)) {
+          fprintf(fp,"%-5u  %6lu %6lu ",idx++,p->mh_number,
+                  (unsigned long)p->mh_size);
+        switch (p->mh_type) {
+           case STRDUP_TYPE:fprintf(fp,"strdup()  in ");break;
+           case MALLOC_TYPE:fprintf(fp,"malloc()  in ");break;
+           case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
+           case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc()  in ");break;
+           case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
+           default:
+                fprintf(fp,"Unknown memory block, may be corrupted");
+                xmlMutexUnlock(xmlMemMutex);
+                if (old_fp == NULL)
+                    fclose(fp);
+                return;
+        }
+        if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
+        if (p->mh_tag != MEMTAG)
+              fprintf(fp,"  INVALID");
+        nb++;
+        if (nb < 100)
+            xmlMemContentShow(fp, p);
+        else
+            fprintf(fp," skip");
+
+        fprintf(fp,"\n");
+        nbBytes -= (unsigned long)p->mh_size;
+        p = p->mh_next;
+    }
+    xmlMutexUnlock(xmlMemMutex);
+#else
+    fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
+#endif
+    if (old_fp == NULL)
+        fclose(fp);
+}
+
+/**
  * xmlMemDisplay:
  * @fp:  a FILE descriptor used as the output file, if NULL, the result is
  *       written to the file .memorylist
  *
  * show in-extenso the memory blocks allocated
  */
 
 void
 xmlMemDisplay(FILE *fp)
 {
@@ skipping 16 matching lines @@
     }
 
 #ifdef MEM_LIST
 #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
     currentTime = time(NULL);
     tstruct = localtime(&currentTime);
     strftime(buf, sizeof(buf) - 1, "%I:%M:%S %p", tstruct);
     fprintf(fp,"      %s\n\n", buf);
 #endif
 
-    
+
     fprintf(fp,"      MEMORY ALLOCATED : %lu, MAX was %lu\n",
             debugMemSize, debugMaxMemSize);
     fprintf(fp,"BLOCK  NUMBER   SIZE  TYPE\n");
     idx = 0;
     xmlMutexLock(xmlMemMutex);
     p = memlist;
     while (p) {
           fprintf(fp,"%-5u  %6lu %6lu ",idx++,p->mh_number,
                   (unsigned long)p->mh_size);
         switch (p->mh_type) {
@@ skipping 56 matching lines @@
 #endif
 }
 
 #endif
 
 /*
  * debugmem_tag_error:
  *
  * internal error function.
  */
- 
+
 static void debugmem_tag_error(void *p)
 {
      xmlGenericError(xmlGenericErrorContext,
              "Memory tag error occurs :%p \n\t bye\n", p);
 #ifdef MEM_LIST
      if (stderr)
      xmlMemDisplay(stderr);
 #endif
 }
 
@@ skipping 39 matching lines @@
                 fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
             if (p->mh_tag != MEMTAG)
                 fprintf(fp,"  INVALID");
             xmlMemContentShow(fp, p);
             fprintf(fp,"\n");
             nr--;
             p = p->mh_next;
         }
     }
     xmlMutexUnlock(xmlMemMutex);
-#endif /* MEM_LIST */    
+#endif /* MEM_LIST */
 }
 
 /**
  * xmlMemoryDump:
  *
  * Dump in-extenso the memory blocks allocated to the file .memorylist
  */
 
 void
 xmlMemoryDump(void)
@@ skipping 26 matching lines @@
  *
  * Initialize the memory layer.
  *
  * Returns 0 on success
  */
 int
 xmlInitMemory(void)
 {
 #ifdef HAVE_STDLIB_H
      char *breakpoint;
-#endif     
+#endif
 #ifdef DEBUG_MEMORY
      xmlGenericError(xmlGenericErrorContext,
              "xmlInitMemory()\n");
-#endif     
+#endif
     /*
      This is really not good code (see Bug 130419).  Suggestions for
      improvement will be welcome!
     */
      if (xmlMemInitialized) return(-1);
      xmlMemInitialized = 1;
      xmlMemMutex = xmlNewMutex();
 
 #ifdef HAVE_STDLIB_H
      breakpoint = getenv("XML_MEM_BREAKPOINT");
      if (breakpoint != NULL) {
          sscanf(breakpoint, "%ud", &xmlMemStopAtBlock);
      }
-#endif     
+#endif
 #ifdef HAVE_STDLIB_H
      breakpoint = getenv("XML_MEM_TRACE");
      if (breakpoint != NULL) {
          sscanf(breakpoint, "%p", &xmlMemTraceBlockAt);
      }
-#endif     
-    
+#endif
+
 #ifdef DEBUG_MEMORY
      xmlGenericError(xmlGenericErrorContext,
              "xmlInitMemory() Ok\n");
-#endif     
+#endif
      return(0);
 }
 
 /**
  * xmlCleanupMemory:
  *
  * Free up all the memory allocated by the library for its own
  * use. This should not be called by user level code.
  */
 void
 xmlCleanupMemory(void) {
 #ifdef DEBUG_MEMORY
      xmlGenericError(xmlGenericErrorContext,
              "xmlCleanupMemory()\n");
-#endif     
+#endif
     if (xmlMemInitialized == 0)
         return;
 
     xmlFreeMutex(xmlMemMutex);
     xmlMemMutex = NULL;
     xmlMemInitialized = 0;
 #ifdef DEBUG_MEMORY
      xmlGenericError(xmlGenericErrorContext,
              "xmlCleanupMemory() Ok\n");
-#endif     
+#endif
 }
 
 /**
  * xmlMemSetup:
  * @freeFunc: the free() function to use
  * @mallocFunc: the malloc() function to use
  * @reallocFunc: the realloc() function to use
  * @strdupFunc: the strdup() function to use
  *
  * Override the default memory access functions with a new set
  * This has to be called before any other libxml routines !
  *
  * Should this be blocked if there was already some allocations
  * done ?
  *
  * Returns 0 on success
  */
 int
 xmlMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
             xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc) {
 #ifdef DEBUG_MEMORY
      xmlGenericError(xmlGenericErrorContext,
              "xmlMemSetup()\n");
-#endif     
+#endif
     if (freeFunc == NULL)
         return(-1);
     if (mallocFunc == NULL)
         return(-1);
     if (reallocFunc == NULL)
         return(-1);
     if (strdupFunc == NULL)
         return(-1);
     xmlFree = freeFunc;
     xmlMalloc = mallocFunc;
     xmlMallocAtomic = mallocFunc;
     xmlRealloc = reallocFunc;
     xmlMemStrdup = strdupFunc;
 #ifdef DEBUG_MEMORY
      xmlGenericError(xmlGenericErrorContext,
              "xmlMemSetup() Ok\n");
-#endif     
+#endif
     return(0);
 }
 
 /**
  * xmlMemGet:
  * @freeFunc: place to save the free() function in use
  * @mallocFunc: place to save the malloc() function in use
  * @reallocFunc: place to save the realloc() function in use
  * @strdupFunc: place to save the strdup() function in use
  *
@@ skipping 29 matching lines @@
  *
  * Returns 0 on success
  */
 int
 xmlGcMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
               xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc,
               xmlStrdupFunc strdupFunc) {
 #ifdef DEBUG_MEMORY
      xmlGenericError(xmlGenericErrorContext,
              "xmlGcMemSetup()\n");
-#endif     
+#endif
     if (freeFunc == NULL)
         return(-1);
     if (mallocFunc == NULL)
         return(-1);
     if (mallocAtomicFunc == NULL)
         return(-1);
     if (reallocFunc == NULL)
         return(-1);
     if (strdupFunc == NULL)
         return(-1);
     xmlFree = freeFunc;
     xmlMalloc = mallocFunc;
     xmlMallocAtomic = mallocAtomicFunc;
     xmlRealloc = reallocFunc;
     xmlMemStrdup = strdupFunc;
 #ifdef DEBUG_MEMORY
      xmlGenericError(xmlGenericErrorContext,
              "xmlGcMemSetup() Ok\n");
-#endif     
+#endif
     return(0);
 }
 
 /**
  * xmlGcMemGet:
  * @freeFunc: place to save the free() function in use
  * @mallocFunc: place to save the malloc() function in use
  * @mallocAtomicFunc: place to save the atomic malloc() function in use
  * @reallocFunc: place to save the realloc() function in use
  * @strdupFunc: place to save the strdup() function in use
@@ skipping 11 matching lines @@
     if (freeFunc != NULL) *freeFunc = xmlFree;
     if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
     if (mallocAtomicFunc != NULL) *mallocAtomicFunc = xmlMallocAtomic;
     if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
     if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
     return(0);
 }
 
 #define bottom_xmlmemory
 #include "elfgcchack.h"