ReactOS  0.4.14-dev-49-gfb4591c
xmlmemory.c
Go to the documentation of this file.
1 /*
2  * xmlmemory.c: libxml memory allocator wrapper.
3  *
4  * daniel@veillard.com
5  */
6 
7 #define IN_LIBXML
8 #include "libxml.h"
9 
10 #include <string.h>
11 
12 #ifdef HAVE_SYS_TYPES_H
13 #include <sys/types.h>
14 #endif
15 
16 #ifdef HAVE_TIME_H
17 #include <time.h>
18 #endif
19 
20 #ifdef HAVE_STDLIB_H
21 #include <stdlib.h>
22 #else
23 #ifdef HAVE_MALLOC_H
24 #include <malloc.h>
25 #endif
26 #endif
27 
28 #ifdef HAVE_CTYPE_H
29 #include <ctype.h>
30 #endif
31 
32 /* #define DEBUG_MEMORY */
33 
40 #ifdef DEBUG_MEMORY_LOCATION
41 #ifndef MEM_LIST
42 #define MEM_LIST /* keep a list of all the allocated memory blocks */
43 #endif
44 #endif
45 
46 #include <libxml/globals.h> /* must come before xmlmemory.h */
47 #include <libxml/xmlmemory.h>
48 #include <libxml/xmlerror.h>
49 #include <libxml/threads.h>
50 
51 static int xmlMemInitialized = 0;
52 static unsigned long debugMemSize = 0;
53 static unsigned long debugMemBlocks = 0;
54 static unsigned long debugMaxMemSize = 0;
56 
57 void xmlMallocBreakpoint(void);
58 
59 /************************************************************************
60  * *
61  * Macros, variables and associated types *
62  * *
63  ************************************************************************/
64 
65 #if !defined(LIBXML_THREAD_ENABLED) && !defined(LIBXML_THREAD_ALLOC_ENABLED)
66 #ifdef xmlMalloc
67 #undef xmlMalloc
68 #endif
69 #ifdef xmlRealloc
70 #undef xmlRealloc
71 #endif
72 #ifdef xmlMemStrdup
73 #undef xmlMemStrdup
74 #endif
75 #endif
76 
77 /*
78  * Each of the blocks allocated begin with a header containing informations
79  */
80 
81 #define MEMTAG 0x5aa5
82 
83 #define MALLOC_TYPE 1
84 #define REALLOC_TYPE 2
85 #define STRDUP_TYPE 3
86 #define MALLOC_ATOMIC_TYPE 4
87 #define REALLOC_ATOMIC_TYPE 5
88 
89 typedef struct memnod {
90  unsigned int mh_tag;
91  unsigned int mh_type;
92  unsigned long mh_number;
93  size_t mh_size;
94 #ifdef MEM_LIST
95  struct memnod *mh_next;
96  struct memnod *mh_prev;
97 #endif
98  const char *mh_file;
99  unsigned int mh_line;
100 } MEMHDR;
101 
102 
103 #ifdef SUN4
104 #define ALIGN_SIZE 16
105 #else
106 #define ALIGN_SIZE sizeof(double)
107 #endif
108 #define HDR_SIZE sizeof(MEMHDR)
109 #define RESERVE_SIZE (((HDR_SIZE + (ALIGN_SIZE-1)) \
110  / ALIGN_SIZE ) * ALIGN_SIZE)
111 
112 #define MAX_SIZE_T ((size_t)-1)
113 
114 #define CLIENT_2_HDR(a) ((void *) (((char *) (a)) - RESERVE_SIZE))
115 #define HDR_2_CLIENT(a) ((void *) (((char *) (a)) + RESERVE_SIZE))
116 
117 
118 static unsigned int block=0;
119 static unsigned int xmlMemStopAtBlock = 0;
120 static void *xmlMemTraceBlockAt = NULL;
121 #ifdef MEM_LIST
122 static MEMHDR *memlist = NULL;
123 #endif
124 
125 static void debugmem_tag_error(void *addr);
126 #ifdef MEM_LIST
127 static void debugmem_list_add(MEMHDR *);
128 static void debugmem_list_delete(MEMHDR *);
129 #endif
130 #define Mem_Tag_Err(a) debugmem_tag_error(a);
131 
132 #ifndef TEST_POINT
133 #define TEST_POINT
134 #endif
135 
144 void
147  "xmlMallocBreakpoint reached on block %d\n", xmlMemStopAtBlock);
148 }
149 
161 void *
162 xmlMallocLoc(size_t size, const char * file, int line)
163 {
164  MEMHDR *p;
165  void *ret;
166 
168 #ifdef DEBUG_MEMORY
170  "Malloc(%d)\n",size);
171 #endif
172 
173  TEST_POINT
174 
175  if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
177  "xmlMallocLoc : Unsigned overflow\n");
178  xmlMemoryDump();
179  return(NULL);
180  }
181 
183 
184  if (!p) {
186  "xmlMallocLoc : Out of free space\n");
187  xmlMemoryDump();
188  return(NULL);
189  }
190  p->mh_tag = MEMTAG;
191  p->mh_size = size;
192  p->mh_type = MALLOC_TYPE;
193  p->mh_file = file;
194  p->mh_line = line;
196  p->mh_number = ++block;
197  debugMemSize += size;
198  debugMemBlocks++;
200 #ifdef MEM_LIST
201  debugmem_list_add(p);
202 #endif
204 
205 #ifdef DEBUG_MEMORY
207  "Malloc(%d) Ok\n",size);
208 #endif
209 
210  if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
211 
212  ret = HDR_2_CLIENT(p);
213 
214  if (xmlMemTraceBlockAt == ret) {
216  "%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
217  (long unsigned)size);
219  }
220 
221  TEST_POINT
222 
223  return(ret);
224 }
225 
237 void *
238 xmlMallocAtomicLoc(size_t size, const char * file, int line)
239 {
240  MEMHDR *p;
241  void *ret;
242 
244 #ifdef DEBUG_MEMORY
246  "Malloc(%d)\n",size);
247 #endif
248 
249  TEST_POINT
250 
251  if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
253  "xmlMallocAtomicLoc : Unsigned overflow\n");
254  xmlMemoryDump();
255  return(NULL);
256  }
257 
259 
260  if (!p) {
262  "xmlMallocAtomicLoc : Out of free space\n");
263  xmlMemoryDump();
264  return(NULL);
265  }
266  p->mh_tag = MEMTAG;
267  p->mh_size = size;
268  p->mh_type = MALLOC_ATOMIC_TYPE;
269  p->mh_file = file;
270  p->mh_line = line;
272  p->mh_number = ++block;
273  debugMemSize += size;
274  debugMemBlocks++;
276 #ifdef MEM_LIST
277  debugmem_list_add(p);
278 #endif
280 
281 #ifdef DEBUG_MEMORY
283  "Malloc(%d) Ok\n",size);
284 #endif
285 
286  if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
287 
288  ret = HDR_2_CLIENT(p);
289 
290  if (xmlMemTraceBlockAt == ret) {
292  "%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
293  (long unsigned)size);
295  }
296 
297  TEST_POINT
298 
299  return(ret);
300 }
310 void *
312 {
313  return(xmlMallocLoc(size, "none", 0));
314 }
315 
328 void *
329 xmlReallocLoc(void *ptr,size_t size, const char * file, int line)
330 {
331  MEMHDR *p, *tmp;
332  unsigned long number;
333 #ifdef DEBUG_MEMORY
334  size_t oldsize;
335 #endif
336 
337  if (ptr == NULL)
338  return(xmlMallocLoc(size, file, line));
339 
341  TEST_POINT
342 
343  p = CLIENT_2_HDR(ptr);
344  number = p->mh_number;
346  if (p->mh_tag != MEMTAG) {
347  Mem_Tag_Err(p);
348  goto error;
349  }
350  p->mh_tag = ~MEMTAG;
352  debugMemSize -= p->mh_size;
353  debugMemBlocks--;
354 #ifdef DEBUG_MEMORY
355  oldsize = p->mh_size;
356 #endif
357 #ifdef MEM_LIST
358  debugmem_list_delete(p);
359 #endif
361 
362  if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
364  "xmlReallocLoc : Unsigned overflow\n");
365  xmlMemoryDump();
366  return(NULL);
367  }
368 
369  tmp = (MEMHDR *) realloc(p,RESERVE_SIZE+size);
370  if (!tmp) {
371  free(p);
372  goto error;
373  }
374  p = tmp;
375  if (xmlMemTraceBlockAt == ptr) {
377  "%p : Realloced(%lu -> %lu) Ok\n",
378  xmlMemTraceBlockAt, (long unsigned)p->mh_size,
379  (long unsigned)size);
381  }
382  p->mh_tag = MEMTAG;
383  p->mh_number = number;
384  p->mh_type = REALLOC_TYPE;
385  p->mh_size = size;
386  p->mh_file = file;
387  p->mh_line = line;
389  debugMemSize += size;
390  debugMemBlocks++;
392 #ifdef MEM_LIST
393  debugmem_list_add(p);
394 #endif
396 
397  TEST_POINT
398 
399 #ifdef DEBUG_MEMORY
401  "Realloced(%d to %d) Ok\n", oldsize, size);
402 #endif
403  return(HDR_2_CLIENT(p));
404 
405 error:
406  return(NULL);
407 }
408 
419 void *
420 xmlMemRealloc(void *ptr,size_t size) {
421  return(xmlReallocLoc(ptr, size, "none", 0));
422 }
423 
430 void
432 {
433  MEMHDR *p;
434  char *target;
435 #ifdef DEBUG_MEMORY
436  size_t size;
437 #endif
438 
439  if (ptr == NULL)
440  return;
441 
442  if (ptr == (void *) -1) {
444  "trying to free pointer from freed area\n");
445  goto error;
446  }
447 
448  if (xmlMemTraceBlockAt == ptr) {
450  "%p : Freed()\n", xmlMemTraceBlockAt);
452  }
453 
454  TEST_POINT
455 
456  target = (char *) ptr;
457 
458  p = CLIENT_2_HDR(ptr);
459  if (p->mh_tag != MEMTAG) {
460  Mem_Tag_Err(p);
461  goto error;
462  }
463  if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
464  p->mh_tag = ~MEMTAG;
465  memset(target, -1, p->mh_size);
467  debugMemSize -= p->mh_size;
468  debugMemBlocks--;
469 #ifdef DEBUG_MEMORY
470  size = p->mh_size;
471 #endif
472 #ifdef MEM_LIST
473  debugmem_list_delete(p);
474 #endif
476 
477  free(p);
478 
479  TEST_POINT
480 
481 #ifdef DEBUG_MEMORY
483  "Freed(%d) Ok\n", size);
484 #endif
485 
486  return;
487 
488 error:
490  "xmlMemFree(%p) error\n", ptr);
492  return;
493 }
494 
506 char *
507 xmlMemStrdupLoc(const char *str, const char *file, int line)
508 {
509  char *s;
510  size_t size = strlen(str) + 1;
511  MEMHDR *p;
512 
514  TEST_POINT
515 
516  if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
518  "xmlMemStrdupLoc : Unsigned overflow\n");
519  xmlMemoryDump();
520  return(NULL);
521  }
522 
524  if (!p) {
525  goto error;
526  }
527  p->mh_tag = MEMTAG;
528  p->mh_size = size;
529  p->mh_type = STRDUP_TYPE;
530  p->mh_file = file;
531  p->mh_line = line;
533  p->mh_number = ++block;
534  debugMemSize += size;
535  debugMemBlocks++;
537 #ifdef MEM_LIST
538  debugmem_list_add(p);
539 #endif
541 
542  s = (char *) HDR_2_CLIENT(p);
543 
544  if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
545 
546  strcpy(s,str);
547 
548  TEST_POINT
549 
550  if (xmlMemTraceBlockAt == s) {
552  "%p : Strdup() Ok\n", xmlMemTraceBlockAt);
554  }
555 
556  return(s);
557 
558 error:
559  return(NULL);
560 }
561 
571 char *
572 xmlMemoryStrdup(const char *str) {
573  return(xmlMemStrdupLoc(str, "none", 0));
574 }
575 
584 int
585 xmlMemUsed(void) {
586  int res;
587 
589  res = debugMemSize;
591  return(res);
592 }
593 
602 int
604  int res;
605 
609  return(res);
610 }
611 
612 #ifdef MEM_LIST
613 
621 static void
622 xmlMemContentShow(FILE *fp, MEMHDR *p)
623 {
624  int i,j,k,len;
625  const char *buf;
626 
627  if (p == NULL) {
628  fprintf(fp, " NULL");
629  return;
630  }
631  len = p->mh_size;
632  buf = (const char *) HDR_2_CLIENT(p);
633 
634  for (i = 0;i < len;i++) {
635  if (buf[i] == 0) break;
636  if (!isprint((unsigned char) buf[i])) break;
637  }
638  if ((i < 4) && ((buf[i] != 0) || (i == 0))) {
639  if (len >= 4) {
640  MEMHDR *q;
641  void *cur;
642 
643  for (j = 0;(j < len -3) && (j < 40);j += 4) {
644  cur = *((void **) &buf[j]);
645  q = CLIENT_2_HDR(cur);
646  p = memlist;
647  k = 0;
648  while (p != NULL) {
649  if (p == q) break;
650  p = p->mh_next;
651  if (k++ > 100) break;
652  }
653  if ((p != NULL) && (p == q)) {
654  fprintf(fp, " pointer to #%lu at index %d",
655  p->mh_number, j);
656  return;
657  }
658  }
659  }
660  } else if ((i == 0) && (buf[i] == 0)) {
661  fprintf(fp," null");
662  } else {
663  if (buf[i] == 0) fprintf(fp," \"%.25s\"", buf);
664  else {
665  fprintf(fp," [");
666  for (j = 0;j < i;j++)
667  fprintf(fp,"%c", buf[j]);
668  fprintf(fp,"]");
669  }
670  }
671 }
672 #endif
673 
684 void
685 xmlMemDisplayLast(FILE *fp, long nbBytes)
686 {
687 #ifdef MEM_LIST
688  MEMHDR *p;
689  unsigned idx;
690  int nb = 0;
691 #endif
692  FILE *old_fp = fp;
693 
694  if (nbBytes <= 0)
695  return;
696 
697  if (fp == NULL) {
698  fp = fopen(".memorylist", "w");
699  if (fp == NULL)
700  return;
701  }
702 
703 #ifdef MEM_LIST
704  fprintf(fp," Last %li MEMORY ALLOCATED : %lu, MAX was %lu\n",
705  nbBytes, debugMemSize, debugMaxMemSize);
706  fprintf(fp,"BLOCK NUMBER SIZE TYPE\n");
707  idx = 0;
709  p = memlist;
710  while ((p) && (nbBytes > 0)) {
711  fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number,
712  (unsigned long)p->mh_size);
713  switch (p->mh_type) {
714  case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
715  case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
716  case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
717  case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
718  case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
719  default:
720  fprintf(fp,"Unknown memory block, may be corrupted");
722  if (old_fp == NULL)
723  fclose(fp);
724  return;
725  }
726  if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
727  if (p->mh_tag != MEMTAG)
728  fprintf(fp," INVALID");
729  nb++;
730  if (nb < 100)
731  xmlMemContentShow(fp, p);
732  else
733  fprintf(fp," skip");
734 
735  fprintf(fp,"\n");
736  nbBytes -= (unsigned long)p->mh_size;
737  p = p->mh_next;
738  }
740 #else
741  fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
742 #endif
743  if (old_fp == NULL)
744  fclose(fp);
745 }
746 
755 void
757 {
758 #ifdef MEM_LIST
759  MEMHDR *p;
760  unsigned idx;
761  int nb = 0;
762 #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
763  time_t currentTime;
764  char buf[500];
765  struct tm * tstruct;
766 #endif
767 #endif
768  FILE *old_fp = fp;
769 
770  if (fp == NULL) {
771  fp = fopen(".memorylist", "w");
772  if (fp == NULL)
773  return;
774  }
775 
776 #ifdef MEM_LIST
777 #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
778  currentTime = time(NULL);
779  tstruct = localtime(&currentTime);
780  strftime(buf, sizeof(buf) - 1, "%I:%M:%S %p", tstruct);
781  fprintf(fp," %s\n\n", buf);
782 #endif
783 
784 
785  fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n",
787  fprintf(fp,"BLOCK NUMBER SIZE TYPE\n");
788  idx = 0;
790  p = memlist;
791  while (p) {
792  fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number,
793  (unsigned long)p->mh_size);
794  switch (p->mh_type) {
795  case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
796  case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
797  case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
798  case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
799  case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
800  default:
801  fprintf(fp,"Unknown memory block, may be corrupted");
803  if (old_fp == NULL)
804  fclose(fp);
805  return;
806  }
807  if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
808  if (p->mh_tag != MEMTAG)
809  fprintf(fp," INVALID");
810  nb++;
811  if (nb < 100)
812  xmlMemContentShow(fp, p);
813  else
814  fprintf(fp," skip");
815 
816  fprintf(fp,"\n");
817  p = p->mh_next;
818  }
820 #else
821  fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
822 #endif
823  if (old_fp == NULL)
824  fclose(fp);
825 }
826 
827 #ifdef MEM_LIST
828 
829 static void debugmem_list_add(MEMHDR *p)
830 {
831  p->mh_next = memlist;
832  p->mh_prev = NULL;
833  if (memlist) memlist->mh_prev = p;
834  memlist = p;
835 #ifdef MEM_LIST_DEBUG
836  if (stderr)
837  Mem_Display(stderr);
838 #endif
839 }
840 
841 static void debugmem_list_delete(MEMHDR *p)
842 {
843  if (p->mh_next)
844  p->mh_next->mh_prev = p->mh_prev;
845  if (p->mh_prev)
846  p->mh_prev->mh_next = p->mh_next;
847  else memlist = p->mh_next;
848 #ifdef MEM_LIST_DEBUG
849  if (stderr)
850  Mem_Display(stderr);
851 #endif
852 }
853 
854 #endif
855 
856 /*
857  * debugmem_tag_error:
858  *
859  * internal error function.
860  */
861 
862 static void debugmem_tag_error(void *p)
863 {
865  "Memory tag error occurs :%p \n\t bye\n", p);
866 #ifdef MEM_LIST
867  if (stderr)
869 #endif
870 }
871 
872 #ifdef MEM_LIST
873 static FILE *xmlMemoryDumpFile = NULL;
874 #endif
875 
885 void
887 {
888 #ifdef MEM_LIST
889  MEMHDR *p;
890 #endif
891 
892  if (fp != NULL)
893  fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n",
895 #ifdef MEM_LIST
897  if (nr > 0) {
898  fprintf(fp,"NUMBER SIZE TYPE WHERE\n");
899  p = memlist;
900  while ((p) && nr > 0) {
901  fprintf(fp,"%6lu %6lu ",p->mh_number,(unsigned long)p->mh_size);
902  switch (p->mh_type) {
903  case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
904  case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
905  case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
906  case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
907  case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
908  default:fprintf(fp," ??? in ");break;
909  }
910  if (p->mh_file != NULL)
911  fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
912  if (p->mh_tag != MEMTAG)
913  fprintf(fp," INVALID");
914  xmlMemContentShow(fp, p);
915  fprintf(fp,"\n");
916  nr--;
917  p = p->mh_next;
918  }
919  }
921 #endif /* MEM_LIST */
922 }
923 
930 void
932 {
933 #ifdef MEM_LIST
934  FILE *dump;
935 
936  if (debugMaxMemSize == 0)
937  return;
938  dump = fopen(".memdump", "w");
939  if (dump == NULL)
940  xmlMemoryDumpFile = stderr;
941  else xmlMemoryDumpFile = dump;
942 
943  xmlMemDisplay(xmlMemoryDumpFile);
944 
945  if (dump != NULL) fclose(dump);
946 #endif /* MEM_LIST */
947 }
948 
949 
950 /****************************************************************
951  * *
952  * Initialization Routines *
953  * *
954  ****************************************************************/
955 
963 int
965 {
966 #ifdef HAVE_STDLIB_H
967  char *breakpoint;
968 #endif
969 #ifdef DEBUG_MEMORY
971  "xmlInitMemory()\n");
972 #endif
973  /*
974  This is really not good code (see Bug 130419). Suggestions for
975  improvement will be welcome!
976  */
977  if (xmlMemInitialized) return(-1);
978  xmlMemInitialized = 1;
980 
981 #ifdef HAVE_STDLIB_H
982  breakpoint = getenv("XML_MEM_BREAKPOINT");
983  if (breakpoint != NULL) {
985  }
986 #endif
987 #ifdef HAVE_STDLIB_H
988  breakpoint = getenv("XML_MEM_TRACE");
989  if (breakpoint != NULL) {
991  }
992 #endif
993 
994 #ifdef DEBUG_MEMORY
996  "xmlInitMemory() Ok\n");
997 #endif
998  return(0);
999 }
1000 
1007 void
1009 #ifdef DEBUG_MEMORY
1011  "xmlCleanupMemory()\n");
1012 #endif
1013  if (xmlMemInitialized == 0)
1014  return;
1015 
1017  xmlMemMutex = NULL;
1018  xmlMemInitialized = 0;
1019 #ifdef DEBUG_MEMORY
1021  "xmlCleanupMemory() Ok\n");
1022 #endif
1023 }
1024 
1040 int
1041 xmlMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
1042  xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc) {
1043 #ifdef DEBUG_MEMORY
1045  "xmlMemSetup()\n");
1046 #endif
1047  if (freeFunc == NULL)
1048  return(-1);
1049  if (mallocFunc == NULL)
1050  return(-1);
1051  if (reallocFunc == NULL)
1052  return(-1);
1053  if (strdupFunc == NULL)
1054  return(-1);
1055  xmlFree = freeFunc;
1056  xmlMalloc = mallocFunc;
1057  xmlMallocAtomic = mallocFunc;
1058  xmlRealloc = reallocFunc;
1059  xmlMemStrdup = strdupFunc;
1060 #ifdef DEBUG_MEMORY
1062  "xmlMemSetup() Ok\n");
1063 #endif
1064  return(0);
1065 }
1066 
1078 int
1079 xmlMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
1080  xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc) {
1081  if (freeFunc != NULL) *freeFunc = xmlFree;
1082  if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
1083  if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
1084  if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
1085  return(0);
1086 }
1087 
1106 int
1107 xmlGcMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
1108  xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc,
1109  xmlStrdupFunc strdupFunc) {
1110 #ifdef DEBUG_MEMORY
1112  "xmlGcMemSetup()\n");
1113 #endif
1114  if (freeFunc == NULL)
1115  return(-1);
1116  if (mallocFunc == NULL)
1117  return(-1);
1118  if (mallocAtomicFunc == NULL)
1119  return(-1);
1120  if (reallocFunc == NULL)
1121  return(-1);
1122  if (strdupFunc == NULL)
1123  return(-1);
1124  xmlFree = freeFunc;
1125  xmlMalloc = mallocFunc;
1126  xmlMallocAtomic = mallocAtomicFunc;
1127  xmlRealloc = reallocFunc;
1128  xmlMemStrdup = strdupFunc;
1129 #ifdef DEBUG_MEMORY
1131  "xmlGcMemSetup() Ok\n");
1132 #endif
1133  return(0);
1134 }
1135 
1150 int
1151 xmlGcMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
1152  xmlMallocFunc *mallocAtomicFunc, xmlReallocFunc *reallocFunc,
1153  xmlStrdupFunc *strdupFunc) {
1154  if (freeFunc != NULL) *freeFunc = xmlFree;
1155  if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
1156  if (mallocAtomicFunc != NULL) *mallocAtomicFunc = xmlMallocAtomic;
1157  if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
1158  if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
1159  return(0);
1160 }
1161 
1162 #define bottom_xmlmemory
1163 #include "elfgcchack.h"
#define realloc
Definition: debug_ros.c:6
static unsigned int block
Definition: xmlmemory.c:118
XMLPUBVAR xmlMallocFunc xmlMallocAtomic
Definition: globals.h:248
#define MEMTAG
Definition: xmlmemory.c:81
void xmlMemDisplay(FILE *fp)
Definition: xmlmemory.c:756
#define error(str)
Definition: mkdosfs.c:1605
static int xmlMemInitialized
Definition: xmlmemory.c:51
ULONG nr
Definition: thread.c:7
void(XMLCALL * xmlFreeFunc)(void *mem)
Definition: xmlmemory.h:57
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define TEST_POINT
Definition: xmlmemory.c:133
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define free
Definition: debug_ros.c:5
unsigned long mh_number
Definition: xmlmemory.c:92
static void * xmlMemTraceBlockAt
Definition: xmlmemory.c:120
static unsigned long debugMemSize
Definition: xmlmemory.c:52
XMLPUBFUN void XMLCALL xmlMutexUnlock(xmlMutexPtr tok)
Definition: threads.c:257
#define REALLOC_ATOMIC_TYPE
Definition: xmlmemory.c:87
XMLPUBFUN void XMLCALL xmlMutexLock(xmlMutexPtr tok)
Definition: threads.c:229
__u16 time
Definition: mkdosfs.c:366
void *(XMLCALL * xmlReallocFunc)(void *mem, size_t size)
Definition: xmlmemory.h:77
int xmlMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc, xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc)
Definition: xmlmemory.c:1079
#define HDR_2_CLIENT(a)
Definition: xmlmemory.c:115
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
const char * mh_file
Definition: xmlmemory.c:98
static xmlMutexPtr xmlMemMutex
Definition: xmlmemory.c:55
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static size_t double number
Definition: printf.c:64
#define CLIENT_2_HDR(a)
Definition: xmlmemory.c:114
static PVOID ptr
Definition: dispmode.c:27
char *(XMLCALL * xmlStrdupFunc)(const char *str)
Definition: xmlmemory.h:87
unsigned int idx
Definition: utils.c:41
static unsigned int xmlMemStopAtBlock
Definition: xmlmemory.c:119
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
#define REALLOC_TYPE
Definition: xmlmemory.c:84
Definition: parser.c:48
int xmlMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc, xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc)
Definition: xmlmemory.c:1041
_Check_return_ _CRTIMP int __cdecl sscanf(_In_z_ const char *_Src, _In_z_ _Scanf_format_string_ const char *_Format,...)
int xmlInitMemory(void)
Definition: xmlmemory.c:964
void xmlMemoryDump(void)
Definition: xmlmemory.c:931
static unsigned long debugMemBlocks
Definition: xmlmemory.c:53
void * xmlMallocLoc(size_t size, const char *file, int line)
Definition: xmlmemory.c:162
int xmlGcMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc, xmlMallocFunc *mallocAtomicFunc, xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc)
Definition: xmlmemory.c:1151
#define Mem_Tag_Err(a)
Definition: xmlmemory.c:130
XMLPUBVAR xmlReallocFunc xmlRealloc
Definition: globals.h:249
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define STRDUP_TYPE
Definition: xmlmemory.c:85
size_t CDECL strftime(char *str, size_t max, const char *format, const struct tm *mstm)
Definition: strftime.c:293
#define MALLOC_TYPE
Definition: xmlmemory.c:83
void * xmlMallocAtomicLoc(size_t size, const char *file, int line)
Definition: xmlmemory.c:238
GLsizeiptr size
Definition: glext.h:5919
char * xmlMemoryStrdup(const char *str)
Definition: xmlmemory.c:572
unsigned int mh_tag
Definition: xmlmemory.c:90
const char file[]
Definition: icontest.c:11
#define RESERVE_SIZE
Definition: xmlmemory.c:109
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
void xmlMemFree(void *ptr)
Definition: xmlmemory.c:431
size_t mh_size
Definition: xmlmemory.c:93
void breakpoint(void)
char * xmlMemStrdupLoc(const char *str, const char *file, int line)
Definition: xmlmemory.c:507
int ret
void xmlCleanupMemory(void)
Definition: xmlmemory.c:1008
char line[200]
Definition: main.c:97
#define ATTRIBUTE_UNUSED
Definition: win32config.h:132
GLenum const GLvoid * addr
Definition: glext.h:9621
#define MAX_SIZE_T
Definition: xmlmemory.c:112
GLenum GLsizei len
Definition: glext.h:6722
GLdouble s
Definition: gl.h:2039
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
Definition: time.h:76
_CRTIMP struct tm *__cdecl localtime(const time_t *_Time)
Definition: time.h:424
XMLPUBFUN void XMLCALL xmlFreeMutex(xmlMutexPtr tok)
Definition: threads.c:206
int xmlGcMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc, xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc)
Definition: xmlmemory.c:1107
XMLPUBVAR xmlStrdupFunc xmlMemStrdup
Definition: globals.h:251
int xmlMemBlocks(void)
Definition: xmlmemory.c:603
_Check_return_ char *__cdecl getenv(_In_z_ const char *_VarName)
void xmlMemShow(FILE *fp, int nr ATTRIBUTE_UNUSED)
Definition: xmlmemory.c:886
__kernel_time_t time_t
Definition: linux.h:252
#define long
Definition: qsort.c:33
void * xmlReallocLoc(void *ptr, size_t size, const char *file, int line)
Definition: xmlmemory.c:329
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
XMLPUBFUN xmlMutexPtr XMLCALL xmlNewMutex(void)
Definition: threads.c:177
#define isprint(c)
Definition: acclib.h:73
unsigned int mh_type
Definition: xmlmemory.c:91
void xmlMallocBreakpoint(void)
Definition: xmlmemory.c:145
GLuint res
Definition: glext.h:9613
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
void * xmlMemRealloc(void *ptr, size_t size)
Definition: xmlmemory.c:420
GLenum target
Definition: glext.h:7315
FILE * stderr
void xmlMemDisplayLast(FILE *fp, long nbBytes)
Definition: xmlmemory.c:685
#define malloc
Definition: debug_ros.c:4
int xmlMemUsed(void)
Definition: xmlmemory.c:585
static void debugmem_tag_error(void *addr)
Definition: xmlmemory.c:862
struct memnod MEMHDR
GLfloat GLfloat p
Definition: glext.h:8902
static unsigned long debugMaxMemSize
Definition: xmlmemory.c:54
#define memset(x, y, z)
Definition: compat.h:39
unsigned int mh_line
Definition: xmlmemory.c:99
void * xmlMemMalloc(size_t size)
Definition: xmlmemory.c:311
int k
Definition: mpi.c:3369
static void dump(const void *ptr, unsigned len)
Definition: msc.c:102
#define MALLOC_ATOMIC_TYPE
Definition: xmlmemory.c:86
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362
Definition: fci.c:126