mem.c

bonddb 是一个源于PostgreSQL封装包的对象。它是一个由C/C++编写的快速数据提取层应用软件

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>

#include <glib.h>

#include "mem.h"

#ifdef MEM_TEST

#define MEM_DONT_FREE

#define MAGIC_PRE_HASH  0xdeadbeef
#define MAGIC_POST_HASH 0xabcdef12

#define memsql_error(fmt,args...) fprintf (stderr, "MEM: " fmt "\n" , ##args)
#define min(a,b) (((a) > (b)) ? (b) : (a))

typedef struct
   {
   int pre_id;
   char name[64];
   int size;
   int line;
   char file[32];
#ifdef MEM_DONT_FREE

   int freed;
#endif
   }
memsql_pre_info;

typedef struct
   {
   int post_id;
   }
memsql_post_info;

static GList *memsql_list = NULL;

static void *
memsql_get_post(memsql_pre_info * pre)
   {
   return ((char *)pre) + sizeof(memsql_pre_info) + pre->size;
   }

static void *
memsql_get_data(memsql_pre_info * pre)
   {
   return ((char *)pre) + sizeof(memsql_pre_info);
   }

static memsql_pre_info *
memsql_get_pre(void *data)
   {
   return (void *)(((char *)data) - sizeof(memsql_pre_info));
   }

char *
memsql_strdup_raw(char *funcname, int linenum, char *file,  char *string)
   {
   char *data;

   if (!string)
      return NULL;

   data = memsql_alloc_raw(funcname, linenum,file,strlen(string) + 1);
   if (data)
      strcpy(data, string);

   return data;
   }

void *
memsql_strdup_printf_raw(char *funcname, int linenum, char *file,const char *fmt,...)
	{
	void *retptr;
	gchar *tmpstr;
	va_list args;
	va_start(args,fmt);
	tmpstr = g_strdup_vprintf(fmt,args);
	retptr = memsql_strdup_raw(funcname,linenum,file,tmpstr);
	g_free(tmpstr);
	return retptr;
	}

void *
memsql_alloc_raw(char *funcname, int linenum, char *file, int count)
   {
   int real_size;
   memsql_pre_info *pre;
   memsql_post_info *post;

   real_size = count + sizeof(memsql_pre_info) + sizeof(memsql_post_info);

   pre = malloc(real_size);

   if (!pre)
      {
      memsql_error("Memory full");
      return NULL;
      }

   strncpy(pre->name, funcname, 63);
   pre->name[63] = '\0';
   strncpy(pre->file, file, 31);
   pre->file[31] = '\0';
   pre->line = linenum;
   pre->size = count;
#ifdef MEM_DONT_FREE

   pre->freed = 0;
#endif

   post = memsql_get_post(pre);

   pre->pre_id = MAGIC_PRE_HASH;
   post->post_id = MAGIC_POST_HASH;

   memsql_list = g_list_append(memsql_list, pre);

   return memsql_get_data(pre);
   }

void *
memsql_calloc_raw(char *funcname, int linenum, char *file, int count)
   {
   void *ptr;

   ptr = memsql_alloc_raw(funcname, linenum, file,  count);
   if (ptr)
      memset(ptr, 0, count);

   return ptr;
   }

void *
memsql_realloc_raw(char *funcname, int linenum, char *file,void *mem,  int count)
   {
   void *new_mem;
   memsql_pre_info *pre;
	
   new_mem = memsql_alloc_raw(funcname, linenum, file, count);
   pre = memsql_get_pre(new_mem);
	if (mem!=NULL)
		memcpy(new_mem, mem, min(count, pre->size));

   memsql_free(mem);

   return new_mem;
   }

int
memsql_free(void *mem)
   {
   memsql_pre_info *pre;
   memsql_post_info *post;

   if (!mem)
      return 0;

   pre = memsql_get_pre(mem);

   if (pre->pre_id != MAGIC_PRE_HASH)
      {
      memsql_error("pre hash doesn't match on: %s", pre->name);
		g_assert(NULL);
      }
   post = memsql_get_post(pre);
   if (post->post_id != MAGIC_POST_HASH)
      {
      memsql_error("post hash doesn't match on: %s", pre->name);
		g_assert(NULL);
      }

   /*	memsql_error ("mem list length: %d", g_list_length (memsql_list)); */

#ifdef MEM_DONT_FREE
   if (pre->freed)
      memsql_error("freeing memory block `%s' for a second time", pre->name);

   pre->freed = 1;
#else

   memsql_list = g_list_remove(memsql_list, pre);
   free(pre);
#endif

   return 0;
   }

int
memsql_display(void)
   {
	void *buf;
   GList *cur;
   memsql_pre_info *pre;
   int count = 0;
   int bytes = 0,i;

   for (cur = memsql_list; cur != NULL; cur = cur->next)
      {
      pre = cur->data;
#ifdef MEM_DONT_FREE

      if (!pre->freed)
         {
#endif
         memsql_error("%s: %d: %s() %dbytes still alloced", pre->file, pre->line, pre->name, pre->size);
			/* Uncomment this if you want to display the memory buffer */
			buf = memsql_get_data(pre);
			if (pre->size > 256)
				;
			else
				{
				for(i=0;i<pre->size;i++)
					{
					if (*((char*)buf)>=' ' && *((char*)buf)<='z')
						fprintf(stderr,"%c",*((char*)buf));
					(char*)buf++;
					}
				fprintf(stderr,"\n");
				}
         count++;
         bytes += pre->size;
#ifdef MEM_DONT_FREE

         }
#endif

      }

   if (count)
      memsql_error("%d memory leaks, totaling %d bytes", count, bytes);

   return 0;
   }
#endif

char *
memsql_strappend_raw(char *funcname,int linenum, char *file,  char *string1, char *string2)
   {
   int len = 0;
   char *retval;

   /*	memsql_error ("appending: %s, %s", string1, string2); */

   if (!string1 && !string2)
      return NULL;

   if (string1)
      len += strlen(string1);
   if (string2)
      len += strlen(string2);
#ifdef MEM_TEST
   retval = memsql_alloc_raw(funcname, linenum,file, len + 1);
#else
   retval = g_malloc(len+1);
#endif
   retval[0] = '\0';

   if (string1)
      strcpy(retval, string1);
   if (string2)
      strcat(retval, string2);

   retval[len] = '\0';

   return retval;
   }

char *
memsql_strappend_free_raw(char *funcname,int linenum, char *file,  char *str1, char *str2)
   {
   char *retval;

   retval = memsql_strappend_raw(funcname, linenum,file,str1, str2);

   if (str1)
      memsql_free(str1);
   if (str2)
      memsql_free(str2);

   return retval;
   }