xmlmemory.h File Reference

#include <stdio.h>
#include <libxml/xmlversion.h>

Include dependency graph for xmlmemory.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	XML_GLOBALS_ALLOC

Typedefs
typedef void(*	xmlFreeFunc) (void *mem)
typedef void *	LIBXML_ATTR_ALLOC_SIZE(1) *xmlMallocFunc) (size_t size)
typedef void *(*	xmlReallocFunc) (void *mem, size_t size)
typedef char *(*	xmlStrdupFunc) (const char *str)

Functions
XMLPUBFUN int	xmlMemSetup (xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc, xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc)
XMLPUBFUN int	xmlMemGet (xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc, xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc)
XMLPUBFUN int	xmlGcMemSetup (xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc, xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc)
XMLPUBFUN int	xmlGcMemGet (xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc, xmlMallocFunc *mallocAtomicFunc, xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc)
XML_DEPRECATED XMLPUBFUN int	xmlInitMemory (void)
XML_DEPRECATED XMLPUBFUN void	xmlCleanupMemory (void)
XMLPUBFUN size_t	xmlMemSize (void *ptr)
XMLPUBFUN int	xmlMemUsed (void)
XMLPUBFUN int	xmlMemBlocks (void)
XMLPUBFUN void	xmlMemDisplay (FILE *fp)
XMLPUBFUN void	xmlMemDisplayLast (FILE *fp, long nbBytes)
XMLPUBFUN void	xmlMemShow (FILE *fp, int nr)
XMLPUBFUN void	xmlMemoryDump (void)
XMLPUBFUN void *	xmlMemMalloc (size_t size) LIBXML_ATTR_ALLOC_SIZE(1)
XMLPUBFUN void *	xmlMemRealloc (void *ptr, size_t size)
XMLPUBFUN void	xmlMemFree (void *ptr)
XMLPUBFUN char *	xmlMemoryStrdup (const char *str)
XMLPUBFUN void *	xmlMallocLoc (size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1)
XMLPUBFUN void *	xmlReallocLoc (void *ptr, size_t size, const char *file, int line)
XMLPUBFUN void *	xmlMallocAtomicLoc (size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1)
XMLPUBFUN char *	xmlMemStrdupLoc (const char *str, const char *file, int line)

Variables
XMLPUBVAR xmlMallocFunc	xmlMalloc
XMLPUBVAR xmlMallocFunc	xmlMallocAtomic
XMLPUBVAR xmlReallocFunc	xmlRealloc
XMLPUBVAR xmlFreeFunc	xmlFree
XMLPUBVAR xmlStrdupFunc	xmlMemStrdup

Macro Definition Documentation

XML_GLOBALS_ALLOC

#define XML_GLOBALS_ALLOC

DOC_DISABLE

Definition at line 91 of file xmlmemory.h.

Typedef Documentation

LIBXML_ATTR_ALLOC_SIZE

typedef void * LIBXML_ATTR_ALLOC_SIZE(1) *xmlMallocFunc)(size_t size)

xmlMallocFunc: @size: the size requested in bytes

Signature for a malloc() implementation.

Returns a pointer to the newly allocated block or NULL in case of error.

Definition at line 40 of file xmlmemory.h.

xmlFreeFunc

typedef void(* xmlFreeFunc) (void *mem)

xmlFreeFunc: @mem: an already allocated block of memory

Signature for a free() implementation.

Definition at line 31 of file xmlmemory.h.

xmlReallocFunc

typedef void *(* xmlReallocFunc) (void *mem, size_t size)

xmlReallocFunc: @mem: an already allocated block of memory @size: the new size requested in bytes

Signature for a realloc() implementation.

Returns a pointer to the newly reallocated block or NULL in case of error.

Definition at line 51 of file xmlmemory.h.

xmlStrdupFunc

typedef char *(* xmlStrdupFunc) (const char *str)

xmlStrdupFunc: @str: a zero terminated string

Signature for an strdup() implementation.

Returns the copy of the string or NULL in case of error.

Definition at line 61 of file xmlmemory.h.

Function Documentation

xmlCleanupMemory()

XML_DEPRECATED XMLPUBFUN void xmlCleanupMemory

(

void

)

xmlCleanupMemory:

DEPRECATED: This function is a no-op. Call xmlCleanupParser to free global state but see the warnings there. xmlCleanupParser should be only called once at program exit. In most cases, you don't have call cleanup functions at all.

Definition at line 870 of file xmlmemory.c.

                       {
}

xmlGcMemGet()

XMLPUBFUN int xmlGcMemGet	(	xmlFreeFunc *	freeFunc,
		xmlMallocFunc *	mallocFunc,
		xmlMallocFunc *	mallocAtomicFunc,
		xmlReallocFunc *	reallocFunc,
		xmlStrdupFunc *	strdupFunc
	)

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

Provides the memory access functions set currently in use The mallocAtomicFunc is specialized for atomic block allocations (i.e. of areas useful for garbage collected memory allocators

Returns 0 on success

Definition at line 1003 of file xmlmemory.c.

                                   {
    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);
}

xmlGcMemSetup()

XMLPUBFUN int xmlGcMemSetup	(	xmlFreeFunc	freeFunc,
		xmlMallocFunc	mallocFunc,
		xmlMallocFunc	mallocAtomicFunc,
		xmlReallocFunc	reallocFunc,
		xmlStrdupFunc	strdupFunc
	)

xmlGcMemSetup: @freeFunc: the free() function to use @mallocFunc: the malloc() function to use @mallocAtomicFunc: the malloc() function to use for atomic allocations @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 ! The mallocAtomicFunc is specialized for atomic block allocations (i.e. of areas useful for garbage collected memory allocators

Should this be blocked if there was already some allocations done ?

Returns 0 on success

Definition at line 967 of file xmlmemory.c.

                                    {
    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;
    return(0);
}

xmlInitMemory()

XML_DEPRECATED XMLPUBFUN int xmlInitMemory

(

void

)

xmlInitMemory:

DEPRECATED: Alias for xmlInitParser.

Definition at line 833 of file xmlmemory.c.

                    {
    xmlInitParser();
    return(0);
}

xmlMallocAtomicLoc()

XMLPUBFUN void * xmlMallocAtomicLoc	(	size_t	size,
		const char *	file,
		int	line
	)

Definition at line 210 of file xmlmemory.c.

{
    MEMHDR *p;
    void *ret;
 
    xmlInitParser();
 
    TEST_POINT
 
    if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlMallocAtomicLoc : Unsigned overflow\n");
    return(NULL);
    }
 
    p = (MEMHDR *) malloc(RESERVE_SIZE+size);
 
    if (!p) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlMallocAtomicLoc : Out of free space\n");
    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);
 
    if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
 
    ret = HDR_2_CLIENT(p);
 
    if (xmlMemTraceBlockAt == ret) {
    xmlGenericError(xmlGenericErrorContext,
            "%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
            (long unsigned)size);
    xmlMallocBreakpoint();
    }
 
    TEST_POINT
 
    return(ret);
}

xmlMallocLoc()

XMLPUBFUN void * xmlMallocLoc	(	size_t	size,
		const char *	file,
		int	line
	)

Definition at line 145 of file xmlmemory.c.

{
    MEMHDR *p;
    void *ret;
 
    xmlInitParser();
 
    TEST_POINT
 
    if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlMallocLoc : Unsigned overflow\n");
    return(NULL);
    }
 
    p = (MEMHDR *) malloc(RESERVE_SIZE+size);
 
    if (!p) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlMallocLoc : Out of free space\n");
    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);
 
    if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
 
    ret = HDR_2_CLIENT(p);
 
    if (xmlMemTraceBlockAt == ret) {
    xmlGenericError(xmlGenericErrorContext,
            "%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
            (long unsigned)size);
    xmlMallocBreakpoint();
    }
 
    TEST_POINT
 
    return(ret);
}

Referenced by xmlMemMalloc(), and xmlReallocLoc().

xmlMemBlocks()

XMLPUBFUN int xmlMemBlocks

(

void

)

xmlMemBlocks:

Provides the number of memory areas currently allocated

Returns an int representing the number of blocks

Definition at line 557 of file xmlmemory.c.

                   {
    int res;
 
    xmlMutexLock(&xmlMemMutex);
    res = debugMemBlocks;
    xmlMutexUnlock(&xmlMemMutex);
    return(res);
}

xmlMemDisplay()

XMLPUBFUN void xmlMemDisplay

(

FILE *

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

Definition at line 644 of file xmlmemory.c.

{
#ifdef MEM_LIST
    MEMHDR *p;
    unsigned idx;
    int     nb = 0;
    time_t currentTime;
    char buf[500];
    struct tm * tstruct;
#endif
    FILE *old_fp = fp;
 
    if (fp == NULL) {
    fp = fopen(".memorylist", "w");
    if (fp == NULL)
        return;
    }
 
#ifdef MEM_LIST
    currentTime = time(NULL);
    tstruct = localtime(&currentTime);
    strftime(buf, sizeof(buf) - 1, "%I:%M:%S %p", tstruct);
    fprintf(fp,"      %s\n\n", buf);
 
 
    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) {
           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++;
 
        fprintf(fp,"\n");
        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);
}

Referenced by debugmem_tag_error(), and xmlMemoryDump().

xmlMemDisplayLast()

XMLPUBFUN void xmlMemDisplayLast	(	FILE *	fp,
		long	nbBytes
	)

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.

Definition at line 577 of file xmlmemory.c.

{
#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++;
 
        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);
}

xmlMemFree()

XMLPUBFUN void xmlMemFree

(

void *

ptr

)

xmlMemFree: @ptr: the memory block pointer

a free() equivalent, with error checking.

Definition at line 381 of file xmlmemory.c.

{
    MEMHDR *p;
    char *target;
 
    if (ptr == NULL)
    return;
 
    if (ptr == (void *) -1) {
    xmlGenericError(xmlGenericErrorContext,
        "trying to free pointer from freed area\n");
        goto error;
    }
 
    if (xmlMemTraceBlockAt == ptr) {
    xmlGenericError(xmlGenericErrorContext,
            "%p : Freed()\n", xmlMemTraceBlockAt);
    xmlMallocBreakpoint();
    }
 
    TEST_POINT
 
    target = (char *) ptr;
 
    p = CLIENT_2_HDR(ptr);
    if (p->mh_tag != MEMTAG) {
        Mem_Tag_Err(p);
        goto error;
    }
    if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
    p->mh_tag = ~MEMTAG;
    memset(target, -1, p->mh_size);
    xmlMutexLock(&xmlMemMutex);
    debugMemSize -= p->mh_size;
    debugMemBlocks--;
#ifdef MEM_LIST
    debugmem_list_delete(p);
#endif
    xmlMutexUnlock(&xmlMemMutex);
 
    free(p);
 
    TEST_POINT
 
    return;
 
error:
    xmlGenericError(xmlGenericErrorContext,
        "xmlMemFree(%p) error\n", ptr);
    xmlMallocBreakpoint();
    return;
}

xmlMemGet()

XMLPUBFUN int xmlMemGet	(	xmlFreeFunc *	freeFunc,
		xmlMallocFunc *	mallocFunc,
		xmlReallocFunc *	reallocFunc,
		xmlStrdupFunc *	strdupFunc
	)

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

Provides the memory access functions set currently in use

Returns 0 on success

Definition at line 939 of file xmlmemory.c.

                                                              {
    if (freeFunc != NULL) *freeFunc = xmlFree;
    if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
    if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
    if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
    return(0);
}

xmlMemMalloc()

XMLPUBFUN void * xmlMemMalloc

(

size_t

size

)

xmlMemMalloc: @size: an int specifying the size in byte to allocate.

a malloc() equivalent, with logging of the allocation info.

Returns a pointer to the allocated area or NULL in case of lack of memory.

Definition at line 272 of file xmlmemory.c.

{
    return(xmlMallocLoc(size, "none", 0));
}

xmlMemoryDump()

XMLPUBFUN void xmlMemoryDump

(

void

)

xmlMemoryDump:

Dump in-extenso the memory blocks allocated to the file .memorylist

Definition at line 802 of file xmlmemory.c.

{
#ifdef MEM_LIST
    FILE *dump;
 
    if (debugMaxMemSize == 0)
    return;
    dump = fopen(".memdump", "w");
    if (dump == NULL)
    xmlMemoryDumpFile = stderr;
    else xmlMemoryDumpFile = dump;
 
    xmlMemDisplay(xmlMemoryDumpFile);
 
    if (dump != NULL) fclose(dump);
#endif /* MEM_LIST */
}

xmlMemoryStrdup()

XMLPUBFUN char * xmlMemoryStrdup

(

const char *

str

)

xmlMemoryStrdup: @str: the initial string pointer

a strdup() equivalent, with logging of the allocation info.

Returns a pointer to the new string or NULL if allocation error occurred.

Definition at line 510 of file xmlmemory.c.

                                 {
    return(xmlMemStrdupLoc(str, "none", 0));
}

xmlMemRealloc()

XMLPUBFUN void * xmlMemRealloc	(	void *	ptr,
		size_t	size
	)

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.

Returns a pointer to the allocated area or NULL in case of lack of memory.

Definition at line 370 of file xmlmemory.c.

                                     {
    return(xmlReallocLoc(ptr, size, "none", 0));
}

xmlMemSetup()

XMLPUBFUN int xmlMemSetup	(	xmlFreeFunc	freeFunc,
		xmlMallocFunc	mallocFunc,
		xmlReallocFunc	reallocFunc,
		xmlStrdupFunc	strdupFunc
	)

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

Definition at line 909 of file xmlmemory.c.

                                                                  {
    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;
    return(0);
}

xmlMemShow()

XMLPUBFUN void xmlMemShow	(	FILE *	fp,
		int nr	ATTRIBUTE_UNUSED
	)

xmlMemShow: @fp: a FILE descriptor used as the output file @nr: number of entries to dump

show a show display of the memory allocated, and dump the @nr last allocated areas which were not freed

Definition at line 758 of file xmlmemory.c.

{
#ifdef MEM_LIST
    MEMHDR *p;
#endif
 
    if (fp != NULL)
    fprintf(fp,"      MEMORY ALLOCATED : %lu, MAX was %lu\n",
        debugMemSize, debugMaxMemSize);
#ifdef MEM_LIST
    xmlMutexLock(&xmlMemMutex);
    if (nr > 0) {
    fprintf(fp,"NUMBER   SIZE  TYPE   WHERE\n");
    p = memlist;
    while ((p) && nr > 0) {
          fprintf(fp,"%6lu %6lu ",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 MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc()  in ");break;
          case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
          case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
        default:fprintf(fp,"   ???    in ");break;
        }
        if (p->mh_file != NULL)
            fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
        if (p->mh_tag != MEMTAG)
        fprintf(fp,"  INVALID");
        fprintf(fp,"\n");
        nr--;
        p = p->mh_next;
    }
    }
    xmlMutexUnlock(&xmlMemMutex);
#endif /* MEM_LIST */
}

xmlMemSize()

XMLPUBFUN size_t xmlMemSize

(

void *

ptr

)

xmlMemSize: @ptr: pointer to the memory allocation

Returns the size of a memory allocation.

Definition at line 522 of file xmlmemory.c.

                      {
    MEMHDR *p;
 
    if (ptr == NULL)
    return(0);
 
    p = CLIENT_2_HDR(ptr);
    if (p->mh_tag != MEMTAG)
        return(0);
 
    return(p->mh_size);
}

xmlMemStrdupLoc()

XMLPUBFUN char * xmlMemStrdupLoc	(	const char *	str,
		const char *	file,
		int	line
	)

Definition at line 446 of file xmlmemory.c.

{
    char *s;
    size_t size = strlen(str) + 1;
    MEMHDR *p;
 
    xmlInitParser();
    TEST_POINT
 
    if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlMemStrdupLoc : Unsigned overflow\n");
    return(NULL);
    }
 
    p = (MEMHDR *) malloc(RESERVE_SIZE+size);
    if (!p) {
      goto error;
    }
    p->mh_tag = MEMTAG;
    p->mh_size = size;
    p->mh_type = STRDUP_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);
 
    s = (char *) HDR_2_CLIENT(p);
 
    if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
 
    strcpy(s,str);
 
    TEST_POINT
 
    if (xmlMemTraceBlockAt == s) {
    xmlGenericError(xmlGenericErrorContext,
            "%p : Strdup() Ok\n", xmlMemTraceBlockAt);
    xmlMallocBreakpoint();
    }
 
    return(s);
 
error:
    return(NULL);
}

Referenced by xmlMemoryStrdup().

xmlMemUsed()

XMLPUBFUN int xmlMemUsed

(

void

)

xmlMemUsed:

Provides the amount of memory currently allocated

Returns an int representing the amount of memory allocated.

Definition at line 544 of file xmlmemory.c.

                 {
    return(debugMemSize);
}

xmlReallocLoc()

XMLPUBFUN void * xmlReallocLoc	(	void *	ptr,
		size_t	size,
		const char *	file,
		int	line
	)

Definition at line 290 of file xmlmemory.c.

{
    MEMHDR *p, *tmp;
    unsigned long number;
 
    if (ptr == NULL)
        return(xmlMallocLoc(size, file, line));
 
    xmlInitParser();
    TEST_POINT
 
    p = CLIENT_2_HDR(ptr);
    number = p->mh_number;
    if (xmlMemStopAtBlock == number) xmlMallocBreakpoint();
    if (p->mh_tag != MEMTAG) {
       Mem_Tag_Err(p);
     goto error;
    }
    p->mh_tag = ~MEMTAG;
    xmlMutexLock(&xmlMemMutex);
    debugMemSize -= p->mh_size;
    debugMemBlocks--;
#ifdef MEM_LIST
    debugmem_list_delete(p);
#endif
    xmlMutexUnlock(&xmlMemMutex);
 
    if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
    xmlGenericError(xmlGenericErrorContext,
        "xmlReallocLoc : Unsigned overflow\n");
    return(NULL);
    }
 
    tmp = (MEMHDR *) realloc(p,RESERVE_SIZE+size);
    if (!tmp) {
     free(p);
     goto error;
    }
    p = tmp;
    if (xmlMemTraceBlockAt == ptr) {
    xmlGenericError(xmlGenericErrorContext,
            "%p : Realloced(%lu -> %lu) Ok\n",
            xmlMemTraceBlockAt, (long unsigned)p->mh_size,
            (long unsigned)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
 
    return(HDR_2_CLIENT(p));
 
error:
    return(NULL);
}

Referenced by xmlMemRealloc().

Variable Documentation

xmlFree

XMLPUBVAR xmlFreeFunc xmlFree

Definition at line 96 of file xmlmemory.h.

xmlMalloc

XMLPUBVAR xmlMallocFunc xmlMalloc

DOC_ENABLE

Definition at line 93 of file xmlmemory.h.

xmlMallocAtomic

XMLPUBVAR xmlMallocFunc xmlMallocAtomic

Definition at line 94 of file xmlmemory.h.

xmlMemStrdup

XMLPUBVAR xmlStrdupFunc xmlMemStrdup

Definition at line 97 of file xmlmemory.h.

xmlRealloc

XMLPUBVAR xmlReallocFunc xmlRealloc

Definition at line 95 of file xmlmemory.h.