diff --git a/src/acconfig.h b/src/acconfig.h
index 991d97bc85cfb4995db024a3a691c10320dd3896..40bb9ff06d9bc1e08358c71f8d6bc02732fc7a07 100644
--- a/src/acconfig.h
+++ b/src/acconfig.h
@@ -12,6 +12,9 @@
 /* Define this if you want run time self tests */
 #undef DEBUG
 
+/* Define this if you want malloc debugging */
+#undef DEBUG_MALLOC
+
 @TOP@
 
 /* Enable profiling */
diff --git a/src/array.c b/src/array.c
index 820cda81deb6ee6722671047d2788dae5b315037..5475965fb349edba969a9dc5f8b1efc4992e2cc8 100644
--- a/src/array.c
+++ b/src/array.c
@@ -37,7 +37,7 @@ struct array empty_array=
  * NOTE: the new array have zero references
  */
 
-struct array *low_allocate_array(INT32 size,INT32 extra_space)
+struct array *debug_low_allocate_array(INT32 size,INT32 extra_space)
 {
   struct array *v;
   INT32 e;
diff --git a/src/array.h b/src/array.h
index adde678d110117010586035cdebc6424f4c29693..d524dcf290fec9958d1d5c9f510674778a815b72 100644
--- a/src/array.h
+++ b/src/array.h
@@ -48,7 +48,7 @@ extern struct array empty_array;
 #define OP_SUB MINTERM(OP_TAKE_A,OP_SKIP_A ,OP_SKIP_B)
 
 
-#define free_array(V) do{ struct array *v_=(V); if(!--v_->refs) really_free_array(v_); }while(0)
+#define free_array(V) do{ struct array *v_=(V); debug_malloc_touch(v_); if(!--v_->refs) really_free_array(v_); }while(0)
 
 #define allocate_array(X) low_allocate_array((X),0)
 #define allocate_array_no_init(X,Y) low_allocate_array((X),(Y))
@@ -59,7 +59,7 @@ typedef short_cmpfun (*cmpfun_getter)(TYPE_T);
 
 
 /* Prototypes begin here */
-struct array *low_allocate_array(INT32 size,INT32 extra_space);
+struct array *debug_low_allocate_array(INT32 size,INT32 extra_space);
 void really_free_array(struct array *v);
 void array_index_no_free(struct svalue *s,struct array *v,INT32 index);
 void array_index(struct svalue *s,struct array *v,INT32 index);
@@ -139,5 +139,10 @@ struct array *explode_array(struct array *a, struct array *b);
 struct array *implode_array(struct array *a, struct array *b);
 /* Prototypes end here */
 
+#ifdef DEBUG_MALLOC
+#define low_allocate_array(X,Y) ((struct array *)debug_malloc_touch(debug_low_allocate_array((X),(Y))))
+#else
+#define low_allocate_array debug_low_allocate_array
+#endif
 
 #endif
diff --git a/src/block_alloc.h b/src/block_alloc.h
new file mode 100644
index 0000000000000000000000000000000000000000..f2b41ead34b6602f7e48e6c9a0412e825111e04d
--- /dev/null
+++ b/src/block_alloc.h
@@ -0,0 +1,60 @@
+#define INIT_BLOCK(X)
+#define EXIT_BLOCK(X)
+#define BLOCK_ALLOC(DATA,BSIZE)									\
+												\
+struct PIKE_CONCAT(DATA,_block)									\
+{												\
+  struct PIKE_CONCAT(DATA,_block) *next;							\
+  struct DATA x[BSIZE];										\
+};												\
+												\
+static struct PIKE_CONCAT(DATA,_block) *PIKE_CONCAT(DATA,_blocks)=0;				\
+static struct DATA *PIKE_CONCAT3(free_,DATA,s)=0;						\
+												\
+struct DATA *PIKE_CONCAT(alloc_,DATA)(void)							\
+{												\
+  struct DATA *tmp;										\
+  if(!PIKE_CONCAT3(free_,DATA,s))								\
+  {												\
+    struct PIKE_CONCAT(DATA,_block) *n;								\
+    int e;											\
+    n=(struct PIKE_CONCAT(DATA,_block) *)malloc(sizeof(struct PIKE_CONCAT(DATA,_block)));	\
+    if(!n)											\
+    {												\
+      fprintf(stderr,"Fatal: out of memory.\n");						\
+      exit(17);											\
+    }												\
+    n->next=PIKE_CONCAT(DATA,_blocks);								\
+    PIKE_CONCAT(DATA,_blocks)=n;								\
+												\
+    for(e=0;e<BSIZE;e++)									\
+    {												\
+      n->x[e].next=PIKE_CONCAT3(free_,DATA,s);							\
+      PIKE_CONCAT3(free_,DATA,s)=n->x+e;							\
+    }												\
+  }												\
+												\
+  tmp=PIKE_CONCAT3(free_,DATA,s);								\
+  PIKE_CONCAT3(free_,DATA,s)=tmp->next;								\
+  INIT_BLOCK(tmp);										\
+  return tmp;											\
+}												\
+												\
+inline void PIKE_CONCAT(free_,DATA)(struct DATA *d)						\
+{												\
+  EXIT_BLOCK(d);										\
+  d->next=PIKE_CONCAT3(free_,DATA,s);								\
+  PIKE_CONCAT3(free_,DATA,s)=d;									\
+}												\
+												\
+void PIKE_CONCAT3(free_all_,DATA,_blocks)(void)							\
+{												\
+  struct PIKE_CONCAT(DATA,_block) *tmp;								\
+  while((tmp=PIKE_CONCAT(DATA,_blocks)))							\
+  {												\
+    PIKE_CONCAT(DATA,_blocks)=tmp->next;							\
+    free((char *)tmp);										\
+  }												\
+  PIKE_CONCAT(DATA,_blocks)=0;									\
+}												\
+
diff --git a/src/builtin_functions.c b/src/builtin_functions.c
index d4c6c0e2c628ae5f5f93e04a352ce1b688a0d887..c06da64deb1e92dd01b506ed5ba9371eb829fb66 100644
--- a/src/builtin_functions.c
+++ b/src/builtin_functions.c
@@ -4,7 +4,7 @@
 ||| See the files COPYING and DISCLAIMER for more information.
 \*/
 #include "global.h"
-RCSID("$Id: builtin_functions.c,v 1.60 1998/02/24 00:47:36 mirar Exp $");
+RCSID("$Id: builtin_functions.c,v 1.61 1998/03/03 11:24:28 hubbe Exp $");
 #include "interpret.h"
 #include "svalue.h"
 #include "pike_macros.h"
@@ -670,6 +670,14 @@ void f_exit(INT32 args)
   exit_modules();
 
   UNSET_ONERROR(tmp);
+
+#ifdef DEBUG_MALLOC
+  {
+    extern cleanup_memhdrs(void);
+    cleanup_memhdrs();
+  }
+#endif
+
   exit(i);
 }
 
diff --git a/src/dmalloc.h b/src/dmalloc.h
new file mode 100644
index 0000000000000000000000000000000000000000..91ccb74dac28a933612ad83dfdbfa5f349cdf05c
--- /dev/null
+++ b/src/dmalloc.h
@@ -0,0 +1,38 @@
+#ifdef DEBUG_MALLOC
+
+struct memhdr;
+
+void dump_memhdr_locations(struct memhdr *from,
+			   struct memhdr *notfrom);
+struct memhdr *alloc_memhdr(void);
+void free_memhdr(struct memhdr *mh);
+void add_marks_to_memhdr(struct memhdr *to,void *ptr);
+void low_add_marks_to_memhdr(struct memhdr *to,
+			     struct memhdr *from);
+
+extern int verbose_debug_malloc;
+extern int verbose_debug_exit;
+extern void *debug_malloc(size_t, const char *, int);
+extern char *debug_xalloc(long);
+extern void *debug_calloc(size_t, size_t, const char *, int);
+extern void *debug_realloc(void *, size_t, const char *, int);
+extern void debug_free(void *, const char *, int);
+extern char *debug_strdup(const char *, const char *, int);
+void *debug_malloc_update_location(void *,const char *, int);
+#define malloc(x) debug_malloc((x), __FILE__, __LINE__)
+#define calloc(x, y) debug_calloc((x), (y), __FILE__, __LINE__)
+#define realloc(x, y) debug_realloc((x), (y), __FILE__, __LINE__)
+#define free(x) debug_free((x), __FILE__, __LINE__)
+#define strdup(x) debug_strdup((x), __FILE__, __LINE__)
+#define DO_IF_DMALLOC(X) X
+#define debug_malloc_touch(X) debug_malloc_update_location((X),__FILE__,__LINE__)
+#define debug_malloc_pass(X) debug_malloc_update_location((X),__FILE__,__LINE__)
+#define xalloc(X) ((char *)debug_malloc_touch(debug_xalloc(X)))
+#else
+#define xalloc debug_xalloc
+#define dbm_main main
+#define DO_IF_DMALLOC(X)
+#define debug_malloc_update_location(X,Y,Z) (X)
+#define debug_malloc_touch(X)
+#define debug_malloc_pass(X) (X)
+#endif
diff --git a/src/dynamic_buffer.c b/src/dynamic_buffer.c
index be27f8ecc01893f4dc893e93fef77990637d641d..155be97951cdbd6c7a7be8d2f408aafe286b8bc3 100644
--- a/src/dynamic_buffer.c
+++ b/src/dynamic_buffer.c
@@ -54,7 +54,7 @@ void low_my_binary_strcat(const char *b,INT32 l,dynamic_buffer *buf)
   MEMCPY(low_make_buf_space(l,buf),b,l);
 }
 
-void initialize_buf(dynamic_buffer *buf)
+void debug_initialize_buf(dynamic_buffer *buf)
 {
   buf->s.str=(char *)xalloc((buf->bufsize=BUFFER_BEGIN_SIZE));
   *(buf->s.str)=0;
@@ -110,7 +110,7 @@ char *simple_free_buf(void)
   return complex_free_buf().str;
 }
 
-struct pike_string *low_free_buf(dynamic_buffer *buf)
+struct pike_string *debug_low_free_buf(dynamic_buffer *buf)
 {
   struct pike_string *q;
   if(!buf->s.str) return 0;
@@ -121,14 +121,14 @@ struct pike_string *low_free_buf(dynamic_buffer *buf)
   return q;
 }
 
-struct pike_string *free_buf(void) { return low_free_buf(&buff); }
+struct pike_string *debug_free_buf(void) { return low_free_buf(&buff); }
 char *make_buf_space(INT32 space) { return low_make_buf_space(space,&buff); }
 void my_putchar(char b) { low_my_putchar(b,&buff); }
 void my_binary_strcat(const char *b,INT32 l) { low_my_binary_strcat(b,l,&buff); }
 void my_strcat(const char *b) { my_binary_strcat(b,strlen(b)); }
 void init_buf(void) { low_reinit_buf(&buff); }
 void init_buf_with_string(string s) { low_init_buf_with_string(s,&buff); }
-char *return_buf(void)
+char *debug_return_buf(void)
 {
   my_putchar(0);
   return buff.s.str;
diff --git a/src/dynamic_buffer.h b/src/dynamic_buffer.h
index 2858274a0a47367f536ec6c28868b27d03375681..ee1eed7f47616ca80218a02b095628b35b8f1e99 100644
--- a/src/dynamic_buffer.h
+++ b/src/dynamic_buffer.h
@@ -28,21 +28,41 @@ typedef struct dynamic_buffer_s dynamic_buffer;
 char *low_make_buf_space(INT32 space,dynamic_buffer *buf);
 void low_my_putchar(char b,dynamic_buffer *buf);
 void low_my_binary_strcat(const char *b,INT32 l,dynamic_buffer *buf);
-void initialize_buf(dynamic_buffer *buf);
+void debug_initialize_buf(dynamic_buffer *buf);
 void low_reinit_buf(dynamic_buffer *buf);
 void low_init_buf_with_string(string s,dynamic_buffer *buf);
 string complex_free_buf(void);
 void toss_buffer(dynamic_buffer *buf);
 char *simple_free_buf(void);
-struct pike_string *low_free_buf(dynamic_buffer *buf);
-struct pike_string *free_buf(void);
+struct pike_string *debug_low_free_buf(dynamic_buffer *buf);
+struct pike_string *debug_free_buf(void);
 char *make_buf_space(INT32 space);
 void my_putchar(char b);
 void my_binary_strcat(const char *b,INT32 l);
 void my_strcat(const char *b);
 void init_buf(void);
 void init_buf_with_string(string s);
-char *return_buf(void);
+char *debug_return_buf(void);
 /* Prototypes end here */
 
+#ifdef DEBUG_MALLOC
+#define initialize_buf(X) \
+  do { dynamic_buffer *b_=(X); debug_initialize_buf(b_); \
+   debug_malloc_update_location(b_->s.str,__FILE__,__LINE__); } while(0)
+#define low_free_buf(X) \
+  ((struct pike_string *)debug_malloc_touch(debug_low_free_buf(X)))
+
+#define free_buf() \
+  ((struct pike_string *)debug_malloc_touch(debug_free_buf()))
+
+#define return_buf() \
+  ((char *)debug_malloc_touch(debug_return_buf()))
+
+#else
+#define initialize_buf debug_initialize_buf
+#define low_free_buf debug_low_free_buf
+#define free_buf debug_free_buf
+#define return_buf debug_return_buf
+#endif
+
 #endif
diff --git a/src/dynamic_load.c b/src/dynamic_load.c
index 75565d8621e1382aa698d5bc625edec527fd6228..b5a9ce8463543e674405b7af32cdb698b318f3c2 100644
--- a/src/dynamic_load.c
+++ b/src/dynamic_load.c
@@ -157,7 +157,9 @@ void exit_dynamic_load(void)
     struct module_list *tmp=dynamic_module_list;
     dynamic_module_list=tmp->next;
     (*tmp->exit)();
+#ifndef DEBUG_MALLOC
     dlclose(tmp->module);
+#endif
     free((char *)tmp);
   }
 #endif
diff --git a/src/global.h b/src/global.h
index 6fa3746c3d5ced3ecea4004abb0b51766cb24739..6f13703c211e006d82e0e95ec3dfd47115a2617f 100644
--- a/src/global.h
+++ b/src/global.h
@@ -45,6 +45,12 @@ struct svalue;
 #define GC2
 #endif
 
+#if defined(i386)
+#ifndef HANDLES_UNALIGNED_MEMORY_ACCESS
+#define HANDLES_UNALIGNED_MEMORY_ACCESS
+#endif
+#endif
+
 /* AIX requires this to be the first thing in the file.  */
 #ifdef __GNUC__
 # ifdef alloca
@@ -72,6 +78,11 @@ char *alloca ();
 #undef HAVE_STDLIB_H
 #endif
 
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#undef HAVE_MALLOC_H
+#endif
+
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #undef HAVE_UNISTD_H
@@ -121,8 +132,39 @@ char *alloca ();
 #define TYPE_FIELD unsigned INT16
 
 #define FLOAT_TYPE float
+#define INT_TYPE INT32
+
+#define B1_T char
 
+#if SIZEOF_SHORT == 2
+#define B2_T short
+#elif SIZEOF_INT == 2
+#define B2_T int
+#endif
+
+#if SIZEOF_SHORT == 4
+#define B4_T short
+#elif SIZEOF_INT == 4
+#define B4_T int
+#elif SIZEOF_LONG == 4
+#define B4_T long
+#endif
 
+#if SIZEOF_INT == 8
+#define B8_T int
+#elif SIZEOF_LONG == 8
+#define B8_T long
+#elif SIZEOF_CHAR_P == 8
+#define B8_T char *
+#elif defined(B4_T)
+struct b8_t_s { B4_T x,y; };
+#define B8_T struct b8_t_s
+#endif
+
+#if defined(B8_T)
+struct b16_t_s { B8_T x,y; };
+#define B16_T struct b16_t_s
+#endif
 
 
 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
@@ -144,6 +186,7 @@ char *alloca ();
 #endif
 
 #include "port.h"
+#include "dmalloc.h"
 
 
 #ifdef BUFSIZ
diff --git a/src/interpret.h b/src/interpret.h
index 9b5fd6783e9cabbf0bc3f84f811b19b2de879b43..12f0c0e6449eea55a04f3ddd15cc4d11f385765e 100644
--- a/src/interpret.h
+++ b/src/interpret.h
@@ -34,22 +34,23 @@ struct frame
 
 #define pop_stack() do{ free_svalue(--sp); debug_check_stack(); }while(0)
 
-#define push_program(P) do{ struct program *_=(P); sp->u.program=_; sp++->type=T_PROGRAM; }while(0)
+#define push_program(P) do{ struct program *_=(P); debug_malloc_touch(_); sp->u.program=_; sp++->type=T_PROGRAM; }while(0)
 #define push_int(I) do{ INT32 _=(I); sp->u.integer=_;sp->type=T_INT;sp++->subtype=NUMBER_NUMBER; }while(0)
-#define push_mapping(M) do{ struct mapping *_=(M); sp->u.mapping=_; sp++->type=T_MAPPING; }while(0)
-#define push_array(A) do{ struct array *_=(A); sp->u.array=_ ;sp++->type=T_ARRAY; }while(0)
-#define push_multiset(L) do{ struct multiset *_=(L); sp->u.multiset=_; sp++->type=T_MULTISET; }while(0)
-#define push_string(S) do{ struct pike_string *_=(S); sp->subtype=0; sp->u.string=_; sp++->type=T_STRING; }while(0)
-#define push_object(O) do{ struct object  *_=(O); sp->u.object=_; sp++->type=T_OBJECT; }while(0)
+#define push_mapping(M) do{ struct mapping *_=(M); debug_malloc_touch(_); sp->u.mapping=_; sp++->type=T_MAPPING; }while(0)
+#define push_array(A) do{ struct array *_=(A); debug_malloc_touch(_); sp->u.array=_ ;sp++->type=T_ARRAY; }while(0)
+#define push_multiset(L) do{ struct multiset *_=(L); debug_malloc_touch(_); sp->u.multiset=_; sp++->type=T_MULTISET; }while(0)
+#define push_string(S) do{ struct pike_string *_=(S); debug_malloc_touch(_); sp->subtype=0; sp->u.string=_; sp++->type=T_STRING; }while(0)
+#define push_object(O) do{ struct object  *_=(O); debug_malloc_touch(_); sp->u.object=_; sp++->type=T_OBJECT; }while(0)
 #define push_float(F) do{ float _=(F); sp->u.float_number=_; sp++->type=T_FLOAT; }while(0)
 #define push_text(T) push_string(make_shared_string((T)))
+#define push_constant_text(T) do{ sp->subtype=0; MAKE_CONSTANT_SHARED_STRING(sp->u.string,T); sp++->type=T_STRING; }while(0)
 
-#define ref_push_program(P) do{ struct program *_=(P); _->refs++; sp->u.program=_; sp++->type=T_PROGRAM; }while(0)
-#define ref_push_mapping(M) do{ struct mapping *_=(M); _->refs++; sp->u.mapping=_; sp++->type=T_MAPPING; }while(0)
-#define ref_push_array(A) do{ struct array *_=(A); _->refs++; sp->u.array=_ ;sp++->type=T_ARRAY; }while(0)
-#define ref_push_multiset(L) do{ struct multiset *_=(L); _->refs++; sp->u.multiset=_; sp++->type=T_MULTISET; }while(0)
-#define ref_push_string(S) do{ struct pike_string *_=(S); _->refs++; sp->subtype=0; sp->u.string=_; sp++->type=T_STRING; }while(0)
-#define ref_push_object(O) do{ struct object  *_=(O); _->refs++; sp->u.object=_; sp++->type=T_OBJECT; }while(0)
+#define ref_push_program(P) do{ struct program *_=(P); debug_malloc_touch(_); _->refs++; sp->u.program=_; sp++->type=T_PROGRAM; }while(0)
+#define ref_push_mapping(M) do{ struct mapping *_=(M); debug_malloc_touch(_); _->refs++; sp->u.mapping=_; sp++->type=T_MAPPING; }while(0)
+#define ref_push_array(A) do{ struct array *_=(A); debug_malloc_touch(_); _->refs++; sp->u.array=_ ;sp++->type=T_ARRAY; }while(0)
+#define ref_push_multiset(L) do{ struct multiset *_=(L); debug_malloc_touch(_); _->refs++; sp->u.multiset=_; sp++->type=T_MULTISET; }while(0)
+#define ref_push_string(S) do{ struct pike_string *_=(S); debug_malloc_touch(_); _->refs++; sp->subtype=0; sp->u.string=_; sp++->type=T_STRING; }while(0)
+#define ref_push_object(O) do{ struct object  *_=(O); debug_malloc_touch(_); _->refs++; sp->u.object=_; sp++->type=T_OBJECT; }while(0)
 
 #define push_svalue(S) do { struct svalue *_=(S); assign_svalue_no_free(sp,_); sp++; }while(0)
 
diff --git a/src/language.yacc b/src/language.yacc
index 186321928026016148cdadcb1a266f08996ac730..62d9eda0c8b9564c7271f206ac56a8b87d332ede 100644
--- a/src/language.yacc
+++ b/src/language.yacc
@@ -157,7 +157,7 @@
 /* This is the grammar definition of Pike. */
 
 #include "global.h"
-RCSID("$Id: language.yacc,v 1.50 1997/10/27 09:59:21 hubbe Exp $");
+RCSID("$Id: language.yacc,v 1.51 1998/03/03 11:24:31 hubbe Exp $");
 #ifdef HAVE_MEMORY_H
 #include <memory.h>
 #endif
@@ -193,7 +193,7 @@ struct locals *local_variables = 0;
 
 static int varargs;
 static INT32  current_modifiers;
-static struct pike_string *last_identifier=0;
+struct pike_string *last_identifier=0;
 
 void fix_comp_stack(int sp)
 {
@@ -385,8 +385,7 @@ program_ref: string_constant
   {
     if(last_identifier)
     {
-      push_string(last_identifier);
-      last_identifier->refs++;
+      ref_push_string(last_identifier);
     }else{
       push_text("");
     }
@@ -1321,14 +1320,13 @@ gauge: F_GAUGE catch_arg
 
 typeof: F_TYPEOF '(' expr0 ')'
   {
+    struct pike_string *s;
     node *tmp;
     tmp=mknode(F_ARG_LIST,$3,0);
-    if($3 && $3->type)
-    {
-       $$=mkstrnode(describe_type($3->type));
-    }else{
-       $$=mkstrnode(describe_type(mixed_type_string));
-    }
+
+    s=describe_type( $3 && $3->type ? $3->type : mixed_type_string);
+    $$=mkstrnode(s);
+    free_string(s);
     free_node(tmp);
   } ;
  
diff --git a/src/las.c b/src/las.c
index 736d579f882df609046032ba8d21f93b019559a9..0e121ab9c24ddbc52a9156ed502d16b69e71f3c0 100644
--- a/src/las.c
+++ b/src/las.c
@@ -4,7 +4,7 @@
 ||| See the files COPYING and DISCLAIMER for more information.
 \*/
 #include "global.h"
-RCSID("$Id: las.c,v 1.39 1997/10/05 03:39:25 grubba Exp $");
+RCSID("$Id: las.c,v 1.40 1998/03/03 11:24:32 hubbe Exp $");
 
 #include "language.h"
 #include "interpret.h"
@@ -143,9 +143,10 @@ void free_all_nodes(void)
     struct node_chunk *tmp2;
     int e=0;
 
-
+#ifndef DEBUG
     if(cumulative_parse_error)
     {
+#endif
       
       for(tmp2=node_chunks;tmp2;tmp2=tmp2->next) e+=NODES;
       for(tmp=free_nodes;tmp;tmp=CAR(tmp)) e--;
@@ -166,7 +167,9 @@ void free_all_nodes(void)
 #ifdef DEBUG
 	      if(!cumulative_parse_error)
 	      {
-		fprintf(stderr,"Free node at %p.\n",tmp);
+		fprintf(stderr,"Free node at %p, (%d) (token=%d).\n",tmp, tmp->line_number, tmp->token);
+		if(tmp->token==F_CONSTANT)
+		  print_tree(tmp);
 	      }
 	      else
 #endif
@@ -175,6 +178,7 @@ void free_all_nodes(void)
 		/* Make sure we don't free any nodes twice */
 		if(car_is_node(tmp)) CAR(tmp)=0;
 		if(cdr_is_node(tmp)) CDR(tmp)=0;
+		debug_malloc_touch(tmp->type);
 		free_node(tmp);
 	      }
 	    }
@@ -185,7 +189,9 @@ void free_all_nodes(void)
 	  fatal("Failed to free %d nodes when compiling!\n",e2);
 #endif
       }
+#ifndef DEBUG
     }
+#endif
     while(node_chunks)
     {
       tmp2=node_chunks;
@@ -488,7 +494,7 @@ void resolv_constant(node *n)
   }
 }
 
-node *index_node(node *n, struct pike_string * id)
+node *debug_index_node(node *n, struct pike_string * id)
 {
   node *ret;
   JMP_BUF tmp;
diff --git a/src/las.h b/src/las.h
index 46fda27e69e6ff861a7f5d64219c9c819ded4bb1..82dcbb64a7790fb4aacafab9dec122e519e62614 100644
--- a/src/las.h
+++ b/src/las.h
@@ -92,7 +92,7 @@ node *mklocalnode(int var);
 node *mkidentifiernode(int i);
 node *mkcastnode(struct pike_string *type,node *n);
 void resolv_constant(node *n);
-node *index_node(node *n, struct pike_string * id);
+node *debug_index_node(node *n, struct pike_string * id);
 int node_is_eq(node *a,node *b);
 node *mkconstantsvaluenode(struct svalue *s);
 node *mkliteralsvaluenode(struct svalue *s);
@@ -141,4 +141,10 @@ INT32 get_opt_info(void);
 
 extern dynamic_buffer areas[NUM_AREAS];
 
+#ifdef DEBUG_MALLOC
+#define index_node(X,Y) ((node *)debug_malloc_touch(debug_index_node((node *)debug_malloc_touch(X),(struct pike_string *)debug_malloc_touch(Y))))
+#else
+#define index_node debug_index_node
+#endif
+
 #endif
diff --git a/src/lex.c b/src/lex.c
index e829172ebfc61d77afb582a948dc0a9a764b4e2e..b5a5a737cfe334421d373d4a36122a29d33944fa 100644
--- a/src/lex.c
+++ b/src/lex.c
@@ -4,7 +4,7 @@
 ||| See the files COPYING and DISCLAIMER for more information.
 \*/
 #include "global.h"
-RCSID("$Id: lex.c,v 1.34 1997/12/20 19:36:48 grubba Exp $");
+RCSID("$Id: lex.c,v 1.35 1998/03/03 11:24:33 hubbe Exp $");
 #include "language.h"
 #include "array.h"
 #include "lex.h"
@@ -57,6 +57,10 @@ static void calc1(void);
 
 void exit_lex(void)
 {
+  extern struct pike_string *last_identifier;
+  free_string(last_identifier);
+  last_identifier=0;
+
 #ifdef DEBUG
   if(p_flag)
   {
@@ -93,6 +97,16 @@ void exit_lex(void)
 
   if(current_file) free_string(current_file);
   free_reswords();
+
+  while(pike_predefs)
+  {
+    struct pike_predef_s *tmp;
+    tmp=pike_predefs;
+    pike_predefs=tmp->next;
+    free(tmp->name);
+    free(tmp->value);
+    free(tmp);
+  }
 }
 
 struct keyword reserved_words[] =
@@ -1848,7 +1862,7 @@ static void low_lex(void)
 
       if(!strcmp("efun",my_yylval.str) || !strcmp("constant",my_yylval.str))
       {
-	int res = 0;
+	volatile int res = 0;
 	struct svalue *oldsp = sp;
 	struct svalue *sv;
 
diff --git a/src/main.c b/src/main.c
index 637eec9d645c88177972bd7793455ed40ab71e7e..3e5a2e925f20af908be55a1b1389d9b1d7c4af31 100644
--- a/src/main.c
+++ b/src/main.c
@@ -4,7 +4,7 @@
 ||| See the files COPYING and DISCLAIMER for more information.
 \*/
 #include "global.h"
-RCSID("$Id: main.c,v 1.27 1997/11/08 01:34:40 hubbe Exp $");
+RCSID("$Id: main.c,v 1.28 1998/03/03 11:24:33 hubbe Exp $");
 #include "backend.h"
 #include "module.h"
 #include "object.h"
@@ -56,7 +56,7 @@ struct callback *add_post_master_callback(callback_func call,
 }
 
 
-void main(int argc, char **argv, char **env)
+void dbm_main(int argc, char **argv, char **env)
 {
   JMP_BUF back;
   int e, num;
diff --git a/src/mapping.c b/src/mapping.c
index ce1b786be089217eee2058584ce8182ac3f23622..70530d5aaf1d3a661704d17ea1b5b32000531091 100644
--- a/src/mapping.c
+++ b/src/mapping.c
@@ -4,7 +4,7 @@
 ||| See the files COPYING and DISCLAIMER for more information.
 \*/
 #include "global.h"
-RCSID("$Id: mapping.c,v 1.25 1998/02/13 00:44:26 hubbe Exp $");
+RCSID("$Id: mapping.c,v 1.26 1998/03/03 11:24:34 hubbe Exp $");
 #include "main.h"
 #include "object.h"
 #include "mapping.h"
@@ -64,7 +64,12 @@ static void check_mapping_type_fields(struct mapping *m)
  * struct. The size is the max number of indices that can fit in the
  * allocated space.
  */
-static void init_mapping(struct mapping *m, INT32 size)
+#ifdef DEBUG_MALLOC
+#define init_mapping(X,Y) debug_init_mapping((struct mapping *)debug_malloc_touch(X),Y)
+#else
+#define init_mapping debug_init_mapping
+#endif
+static void debug_init_mapping(struct mapping *m, INT32 size)
 {
   char *tmp;
   INT32 e;
@@ -104,7 +109,7 @@ static void init_mapping(struct mapping *m, INT32 size)
 
 /* This function allocates an empty mapping with room for 'size' values
  */
-struct mapping *allocate_mapping(int size)
+struct mapping *debug_allocate_mapping(int size)
 {
   struct mapping *m;
 
diff --git a/src/mapping.h b/src/mapping.h
index 5d7fce75bace51fd3baf29e6c0ee8a82e1b23ecd..b30f7c269d02fa62cbd83dbdab366869371c74c7 100644
--- a/src/mapping.h
+++ b/src/mapping.h
@@ -21,11 +21,11 @@ struct mapping
 #define m_ind_types(m) ((m)->ind_types)
 #define m_val_types(m) ((m)->val_types)
 
-#define free_mapping(M) do{ struct mapping *m_=(M); if(!--m_->refs) really_free_mapping(m_); }while(0)
+#define free_mapping(M) do{ struct mapping *m_=(M); debug_malloc_touch(m_); if(!--m_->refs) really_free_mapping(m_); }while(0)
 
 /* Prototypes begin here */
 struct keypair;
-struct mapping *allocate_mapping(int size);
+struct mapping *debug_allocate_mapping(int size);
 void really_free_mapping(struct mapping *m);
 void mapping_fix_type_field(struct mapping *m);
 void mapping_insert(struct mapping *m,
@@ -71,4 +71,11 @@ void gc_free_all_unreferenced_mappings(void);
 void zap_all_mappings(void);
 void count_memory_in_mappings(INT32 *num_, INT32 *size_);
 /* Prototypes end here */
+
+#ifdef DEBUG_MALLOC
+#define allocate_mapping(X) ((struct mapping *)debug_malloc_touch(debug_allocate_mapping(X)))
+#else
+#define allocate_mapping debug_allocate_mapping
+#endif
+
 #endif
diff --git a/src/module.c b/src/module.c
index 24a282a519594e24de15af4144a8cd01b8b557df..0814f40b2a0848c72363c7de72526c3972cc1b40 100644
--- a/src/module.c
+++ b/src/module.c
@@ -36,9 +36,8 @@ void init_modules(void)
 {
   unsigned int e;
   struct mapping *m = allocate_mapping(10);
-  m->refs++;
   push_text("_static_modules");
-  push_mapping(m);
+  ref_push_mapping(m);
   f_add_constant(2);
 
   for(e=0;e<NELEM(module_list);e++)
@@ -54,6 +53,7 @@ void init_modules(void)
     mapping_insert(m, sp-2, sp-1);
     pop_n_elems(2);
   }
+  free_mapping(m);
 }
 
 void exit_modules(void)
diff --git a/src/modules/Image/colortable.c b/src/modules/Image/colortable.c
index faef61406cd39ebe751461564c4b1a8238a0c776..c58ab665a893006072347544537e3ca43b70b703 100644
--- a/src/modules/Image/colortable.c
+++ b/src/modules/Image/colortable.c
@@ -1,11 +1,11 @@
 #include <config.h>
 
-/* $Id: colortable.c,v 1.28 1997/11/30 22:05:33 grubba Exp $ */
+/* $Id: colortable.c,v 1.29 1998/03/03 11:24:42 hubbe Exp $ */
 
 /*
 **! module Image
 **! note
-**!	$Id: colortable.c,v 1.28 1997/11/30 22:05:33 grubba Exp $
+**!	$Id: colortable.c,v 1.29 1998/03/03 11:24:42 hubbe Exp $
 **! class colortable
 **!
 **!	This object keeps colortable information,
@@ -21,7 +21,7 @@
 #undef COLORTABLE_REDUCE_DEBUG
 
 #include "global.h"
-RCSID("$Id: colortable.c,v 1.28 1997/11/30 22:05:33 grubba Exp $");
+RCSID("$Id: colortable.c,v 1.29 1998/03/03 11:24:42 hubbe Exp $");
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -2897,6 +2897,8 @@ static INLINE void _build_cubicle(struct neo_colortable *nct,
 
 #include "colortable_lookup.h"
 
+#include "dmalloc.h"
+
 #undef NCTLU_DESTINATION
 #undef NCTLU_CACHE_HIT_WRITE
 #undef NCTLU_DITHER_GOT
diff --git a/src/modules/Image/encodings/gif.c b/src/modules/Image/encodings/gif.c
index 601e135a3206b11b93a68a1ebec78b1c8ebf9e8d..a7e790b4fb6f92371e1181c9ad70a7e6aeee0e37 100644
--- a/src/modules/Image/encodings/gif.c
+++ b/src/modules/Image/encodings/gif.c
@@ -1,9 +1,9 @@
-/* $Id: gif.c,v 1.20 1997/11/29 22:48:50 mirar Exp $ */
+/* $Id: gif.c,v 1.21 1998/03/03 11:24:45 hubbe Exp $ */
 
 /*
 **! module Image
 **! note
-**!	$Id: gif.c,v 1.20 1997/11/29 22:48:50 mirar Exp $
+**!	$Id: gif.c,v 1.21 1998/03/03 11:24:45 hubbe Exp $
 **! submodule GIF
 **!
 **!	This submodule keep the GIF encode/decode capabilities
@@ -31,7 +31,7 @@
 
 #include "stralloc.h"
 #include "global.h"
-RCSID("$Id: gif.c,v 1.20 1997/11/29 22:48:50 mirar Exp $");
+RCSID("$Id: gif.c,v 1.21 1998/03/03 11:24:45 hubbe Exp $");
 #include "pike_macros.h"
 #include "object.h"
 #include "constants.h"
@@ -1228,7 +1228,7 @@ void init_image_gif(void)
 
    image_gif_module_program=end_program();
    push_object(clone_object(image_gif_module_program,0));
-   add_constant(make_shared_string("GIF"),sp-1,0);
+   simple_add_constant("GIF",sp-1,0);
    pop_stack();
 }
 
diff --git a/src/modules/Image/encodings/png.c b/src/modules/Image/encodings/png.c
index 21cdafdeb7de15603ee99b99de254d744593379f..90ed492b63b264e49126b4d429e235b5d4b9b3a1 100644
--- a/src/modules/Image/encodings/png.c
+++ b/src/modules/Image/encodings/png.c
@@ -1,9 +1,9 @@
-/* $Id: png.c,v 1.1 1997/11/12 03:37:52 mirar Exp $ */
+/* $Id: png.c,v 1.2 1998/03/03 11:24:45 hubbe Exp $ */
 
 /*
 **! module Image
 **! note
-**!	$Id: png.c,v 1.1 1997/11/12 03:37:52 mirar Exp $
+**!	$Id: png.c,v 1.2 1998/03/03 11:24:45 hubbe Exp $
 **! submodule PNG
 **!
 **!	This submodule keep the PNG encode/decode capabilities
@@ -23,7 +23,7 @@
 
 #include "stralloc.h"
 #include "global.h"
-RCSID("$Id: png.c,v 1.1 1997/11/12 03:37:52 mirar Exp $");
+RCSID("$Id: png.c,v 1.2 1998/03/03 11:24:45 hubbe Exp $");
 #include "pike_macros.h"
 #include "object.h"
 #include "constants.h"
@@ -45,14 +45,16 @@ void image_png__module_value(INT32 args)
 
 void init_image_png(void)
 {
+  struct program *p;
    start_new_program();
    
    add_function("_module_value",image_png__module_value,
 		"function(:object)",0);
 
-   push_object(clone_object(end_program(),0));
-   add_constant(make_shared_string("PNG"),sp-1,0);
+   push_object(clone_object(p=end_program(),0));
+   simple_add_constant("PNG",sp-1,0);
    pop_stack();
+   free_program(p);
 }
 
 void exit_image_png(void)
diff --git a/src/modules/Image/font.c b/src/modules/Image/font.c
index eaeba48fb810504b512d21c02596aa657c600e00..8ae179ea2758ab9d5f172eea8e7794d242329768 100644
--- a/src/modules/Image/font.c
+++ b/src/modules/Image/font.c
@@ -1,4 +1,4 @@
-/* $Id: font.c,v 1.21 1997/11/11 22:17:48 mirar Exp $ */
+/* $Id: font.c,v 1.22 1998/03/03 11:24:43 hubbe Exp $ */
 #include <config.h>
 
 #define SPACE_CHAR 'i'
@@ -6,7 +6,7 @@
 /*
 **! module Image
 **! note
-**!	$Id: font.c,v 1.21 1997/11/11 22:17:48 mirar Exp $
+**!	$Id: font.c,v 1.22 1998/03/03 11:24:43 hubbe Exp $
 **! class font
 **!
 **! note
@@ -126,6 +126,7 @@ Kerningtable types:
 #include <sys/mman.h>
 #endif
 
+#include "dmalloc.h"
 
 static struct program *font_program;
 extern struct program *image_program;
diff --git a/src/modules/Image/image.c b/src/modules/Image/image.c
index b907429f64880278e74a566e03b3f3701736abcd..0362cebbad987996b114ade38e57603b0bd4679e 100644
--- a/src/modules/Image/image.c
+++ b/src/modules/Image/image.c
@@ -1,9 +1,10 @@
-/* $Id: image.c,v 1.70 1998/02/13 00:57:09 hubbe Exp $ */
+
+/* $Id: image.c,v 1.71 1998/03/03 11:24:44 hubbe Exp $ */
 
 /*
 **! module Image
 **! note
-**!	$Id: image.c,v 1.70 1998/02/13 00:57:09 hubbe Exp $
+**!	$Id: image.c,v 1.71 1998/03/03 11:24:44 hubbe Exp $
 **! class image
 **!
 **!	The main object of the <ref>Image</ref> module, this object
@@ -82,7 +83,7 @@
 
 #include "stralloc.h"
 #include "global.h"
-RCSID("$Id: image.c,v 1.70 1998/02/13 00:57:09 hubbe Exp $");
+RCSID("$Id: image.c,v 1.71 1998/03/03 11:24:44 hubbe Exp $");
 #include "pike_macros.h"
 #include "object.h"
 #include "constants.h"
@@ -2765,14 +2766,16 @@ void image_read_lsb_grey(INT32 args)
 
 #define RGB_TYPE "int|void,int|void,int|void,int|void"
 
-void init_font_programs(void);
-void exit_font(void);
-void init_colortable_programs(void);
-void exit_colortable(void);
-void init_image_gif(void);
-void exit_image_gif(void);
-void init_image_pnm(void);
-void exit_image_pnm(void);
+extern void init_font_programs(void);
+extern void exit_font(void);
+extern void init_colortable_programs(void);
+extern void exit_colortable(void);
+extern void init_image_gif(void);
+extern void exit_image_gif(void);
+extern void init_image_pnm(void);
+extern void exit_image_pnm(void);
+extern void init_image_png(void);
+extern void exit_image_png(void);
 
 void pike_module_init(void)
 {
diff --git a/src/modules/files/efuns.c b/src/modules/files/efuns.c
index 8eb487c0b2edd2a3a1e3d5a3ce1c927efee642dc..cecd6614bea2bef294818e0916e15dc7a4badd1e 100644
--- a/src/modules/files/efuns.c
+++ b/src/modules/files/efuns.c
@@ -48,6 +48,8 @@
 # endif
 #endif
 
+#include "dmalloc.h"
+
 struct array *encode_stat(struct stat *s)
 {
   struct array *a;
diff --git a/src/modules/files/file.c b/src/modules/files/file.c
index c2f2a37faafee755d08058e6a66de97ba135036b..f002d3726041cd4be2d1764cd75935206fb8953d 100644
--- a/src/modules/files/file.c
+++ b/src/modules/files/file.c
@@ -6,7 +6,7 @@
 #define READ_BUFFER 8192
 
 #include "global.h"
-RCSID("$Id: file.c,v 1.61 1997/11/08 01:35:41 hubbe Exp $");
+RCSID("$Id: file.c,v 1.62 1998/03/03 11:24:46 hubbe Exp $");
 #include "interpret.h"
 #include "svalue.h"
 #include "stralloc.h"
@@ -60,6 +60,8 @@ RCSID("$Id: file.c,v 1.61 1997/11/08 01:35:41 hubbe Exp $");
 #include <netdb.h>
 #endif
 
+#include "dmalloc.h"
+
 #ifndef SEEK_SET
 #define SEEK_SET 0
 #endif
diff --git a/src/modules/files/socket.c b/src/modules/files/socket.c
index 87a8a63e3424e864efe782deb0020ae9a7a791e0..40b37b558fa578baa4504cda8fd44f9beba8f74b 100644
--- a/src/modules/files/socket.c
+++ b/src/modules/files/socket.c
@@ -46,6 +46,8 @@
 #include <sys/socketvar.h>
 #endif
 
+#include "dmalloc.h"
+
 struct port
 {
   int fd;
diff --git a/src/modules/spider/dumudp.c b/src/modules/spider/dumudp.c
index fb6f4019467da31a3d9dfe2d2ac35b8c1f601b4f..3105c58bb25d39e4417678fd44cdf53641df2598 100644
--- a/src/modules/spider/dumudp.c
+++ b/src/modules/spider/dumudp.c
@@ -1,7 +1,7 @@
 #include "config.h"
 
 #include "global.h"
-RCSID("$Id: dumudp.c,v 1.28 1997/12/07 21:58:12 grubba Exp $");
+RCSID("$Id: dumudp.c,v 1.29 1998/03/03 11:24:47 hubbe Exp $");
 #include "interpret.h"
 #include "svalue.h"
 #include "stralloc.h"
@@ -60,6 +60,8 @@ RCSID("$Id: dumudp.c,v 1.28 1997/12/07 21:58:12 grubba Exp $");
 #include <netdb.h>
 #endif
 
+#include "dmalloc.h"
+
 struct dumudp {
   int fd;
   struct svalue read_callback;
diff --git a/src/modules/spider/spider.c b/src/modules/spider/spider.c
index 6e098a99e2e52a6d1e2eda3ad2b46ae2bb175f01..c4a5926fbf48af7a0253eb808421930ab840b1b0 100644
--- a/src/modules/spider/spider.c
+++ b/src/modules/spider/spider.c
@@ -40,7 +40,7 @@
 #include "threads.h"
 #include "operators.h"
 
-RCSID("$Id: spider.c,v 1.50 1998/03/02 00:29:02 grubba Exp $");
+RCSID("$Id: spider.c,v 1.51 1998/03/03 11:24:48 hubbe Exp $");
 
 #ifdef HAVE_PWD_H
 #include <pwd.h>
@@ -81,6 +81,8 @@ RCSID("$Id: spider.c,v 1.50 1998/03/02 00:29:02 grubba Exp $");
 
 #include "accesseddb.h"
 
+#include "dmalloc.h"
+
 #define MAX_PARSE_RECURSE 102
 
 void do_html_parse(struct pike_string *ss,
diff --git a/src/modules/system/system.c b/src/modules/system/system.c
index 56892ee95badf71353076ff69ead09c7b334e129..2847eef7603f3c7b20e8e85bf36c690b98956278 100644
--- a/src/modules/system/system.c
+++ b/src/modules/system/system.c
@@ -1,5 +1,5 @@
 /*
- * $Id: system.c,v 1.33 1998/03/03 07:56:47 mast Exp $
+ * $Id: system.c,v 1.34 1998/03/03 11:24:48 hubbe Exp $
  *
  * System-call module for Pike
  *
@@ -14,7 +14,7 @@
 #include "system.h"
 
 #include "global.h"
-RCSID("$Id: system.c,v 1.33 1998/03/03 07:56:47 mast Exp $");
+RCSID("$Id: system.c,v 1.34 1998/03/03 11:24:48 hubbe Exp $");
 #include "module_support.h"
 #include "las.h"
 #include "interpret.h"
@@ -59,6 +59,8 @@ RCSID("$Id: system.c,v 1.33 1998/03/03 07:56:47 mast Exp $");
 #include <sys/stat.h>
 #endif /* HAVE_SYS_STAT_H */
 
+#include "dmalloc.h"
+
 /*
  * Functions
  */
diff --git a/src/multiset.h b/src/multiset.h
index 7cc916a59462c4192423c3a88d75a0350d1f62b9..209603d13073ba12ba74e52156b579ee5f7b99da 100644
--- a/src/multiset.h
+++ b/src/multiset.h
@@ -15,7 +15,7 @@ struct multiset
   struct array *ind;
 };
 
-#define free_multiset(L) do{ struct multiset *l_=(L); if(!--l_->refs) really_free_multiset(l_); }while(0)
+#define free_multiset(L) do{ struct multiset *l_=(L); debug_malloc_touch(l_); if(!--l_->refs) really_free_multiset(l_); }while(0)
 
 #define l_sizeof(L) ((L)->ind->size)
 
diff --git a/src/object.c b/src/object.c
index ee5160f98c1ff1689d595c9913c2743fe68fbdc4..6972f02d6d0536a5689593beb84019f39a450471 100644
--- a/src/object.c
+++ b/src/object.c
@@ -4,7 +4,7 @@
 ||| See the files COPYING and DISCLAIMER for more information.
 \*/
 #include "global.h"
-RCSID("$Id: object.c,v 1.29 1997/11/08 01:34:42 hubbe Exp $");
+RCSID("$Id: object.c,v 1.30 1998/03/03 11:24:36 hubbe Exp $");
 #include "object.h"
 #include "dynamic_buffer.h"
 #include "interpret.h"
@@ -115,7 +115,7 @@ static void init_object(struct object *o, int args)
   pop_stack();
 }
 
-struct object *clone_object(struct program *p, int args)
+struct object *debug_clone_object(struct program *p, int args)
 {
   struct object *o=low_clone(p);
   init_object(o,args);
diff --git a/src/object.h b/src/object.h
index b184357d31a5057a7c0adbadf018ff09beddfc10..4be84f95ff49720db0d651296eac0ed65225d8a5 100644
--- a/src/object.h
+++ b/src/object.h
@@ -39,7 +39,7 @@ extern struct program *master_program;
 /* Prototypes begin here */
 void setup_fake_object(void);
 struct object *low_clone(struct program *p);
-struct object *clone_object(struct program *p, int args);
+struct object *debug_clone_object(struct program *p, int args);
 struct object *get_master(void);
 struct object *master(void);
 void destruct(struct object *o);
@@ -75,5 +75,11 @@ void gc_free_all_unreferenced_objects(void);
 void count_memory_in_objects(INT32 *num_, INT32 *size_);
 /* Prototypes end here */
 
+#ifdef MALLOC_DEBUG
+#define clone_object(X,Y) ((struct object *)debug_malloc_touch(debug_clone_object((X),(Y))))
+#else
+#define clone_object debug_clone_object
+#endif
+
 #endif /* OBJECT_H */
 
diff --git a/src/peep.c b/src/peep.c
index 92b620e729845f3cde40e083aea99d790338ef0e..1946711792f3a46038ac6fc083228193376a34fe 100644
--- a/src/peep.c
+++ b/src/peep.c
@@ -10,6 +10,7 @@
 #include "lex.h"
 #include "pike_memory.h"
 #include "peep.h"
+#include "dmalloc.h"
 
 struct p_instr_s
 {
diff --git a/src/pike_memory.c b/src/pike_memory.c
index 00532f24db60013a09272a202eb4281003dbb240..18fda25edaac5205af38b3fc1eb7f6ad071207b6 100644
--- a/src/pike_memory.c
+++ b/src/pike_memory.c
@@ -8,17 +8,6 @@
 #include "error.h"
 #include "pike_macros.h"
 
-char *xalloc(SIZE_T size)
-{
-  char *ret;
-  if(!size) return 0;
-
-  ret=(char *)malloc(size);
-  if(ret) return ret;
-
-  error("Out of memory.\n");
-  return 0;
-}
 
 /* strdup() is used by several modules, so let's provide it */
 #ifndef HAVE_STRDUP
@@ -55,22 +44,36 @@ void swap(char *a, char *b, INT32 size)
 
 void reverse(char *memory, INT32 nitems, INT32 size)
 {
-#define DOSIZE(X,Y)				\
- case X:					\
- {						\
-  struct Y { char tt[X]; };			\
-  struct Y tmp;					\
-  struct Y *start=(struct Y *) memory;		\
-  struct Y *end=start+nitems-1;			\
-  while(start<end){tmp=*start;*(start++)=*end;*(end--)=tmp;} \
-  break;					\
+
+#define DOSIZE(X,Y)						\
+ case X:							\
+ {								\
+  Y tmp;							\
+  Y *start=(Y *) memory;					\
+  Y *end=start+nitems-1;					\
+  while(start<end){tmp=*start;*(start++)=*end;*(end--)=tmp;}	\
+  break;							\
  }
 
+#ifdef HANDLES_UNALIGNED_MEMORY_ACCESS
   switch(size)
+#else
+  switch( (((unsigned long)memory) % size) ? 0 : size)
+#endif
   {
-    DOSIZE(2,TMP2)
-    DOSIZE(4,TMP4)
-    DOSIZE(8,TMP8)
+    DOSIZE(1,B1_T)
+#ifdef B2_T
+    DOSIZE(2,B2_T)
+#endif
+#ifdef B4_T
+    DOSIZE(4,B4_T)
+#endif
+#ifdef B16_T
+    DOSIZE(8,B8_T)
+#endif
+#ifdef B16_T
+    DOSIZE(16,B8_T)
+#endif
   default:
   {
     char *start = (char *) memory;
@@ -93,25 +96,41 @@ void reorder(char *memory, INT32 nitems, INT32 size,INT32 *order)
 {
   INT32 e;
   char *tmp;
+  if(nitems<2) return;
+
+
   tmp=xalloc(size * nitems);
+
 #undef DOSIZE
 #define DOSIZE(X,Y)				\
  case X:					\
  {						\
-  struct Y { char tt[X]; };			\
-  struct Y *from=(struct Y *) memory;		\
-  struct Y *to=(struct Y *) tmp;		\
+  Y *from=(Y *) memory;				\
+  Y *to=(Y *) tmp;				\
   for(e=0;e<nitems;e++) to[e]=from[order[e]];	\
   break;					\
  }
   
 
+#ifdef HANDLES_UNALIGNED_MEMORY_ACCESS
   switch(size)
-  {
-    DOSIZE(2,TMP2)
-    DOSIZE(4,TMP4)
-    DOSIZE(8,TMP8)
-    DOSIZE(16,TMP16)
+#else
+  switch( (((unsigned long)memory) % size) ? 0 : size )
+#endif
+ {
+   DOSIZE(1,B1_T)
+#ifdef B2_T
+     DOSIZE(2,B2_T)
+#endif
+#ifdef B4_T
+     DOSIZE(4,B4_T)
+#endif
+#ifdef B8_T
+     DOSIZE(8,B8_T)
+#endif
+#ifdef B16_T
+    DOSIZE(16,B16_T)
+#endif
 
   default:
     for(e=0;e<nitems;e++) MEMCPY(tmp+e*size, memory+order[e]*size, size);
@@ -126,7 +145,22 @@ unsigned INT32 hashmem(const unsigned char *a,INT32 len,INT32 mlen)
   unsigned INT32 ret;
 
   ret=9248339*len;
-  if(len<mlen) mlen=len;
+  if(len<mlen)
+    mlen=len;
+  else
+  {
+    switch(len-mlen)
+    {
+      default: ret^=(ret<<6) + a[len-7];
+      case 7:
+      case 6: ret^=(ret<<7) + a[len-5];
+      case 5:
+      case 4: ret^=(ret<<4) + a[len-4];
+      case 3: ret^=(ret<<3) + a[len-3];
+      case 2: ret^=(ret<<3) + a[len-2];
+      case 1: ret^=(ret<<3) + a[len-1];
+    }
+  }
   switch(mlen&7)
   {
     case 7: ret^=*(a++);
@@ -140,8 +174,8 @@ unsigned INT32 hashmem(const unsigned char *a,INT32 len,INT32 mlen)
 
 #ifdef HANDLES_UNALIGNED_MEMORY_ACCESS
   {
-    unsigned int *b;
-    b=(unsigned int *)a;
+    unsigned INT32 *b;
+    b=(unsigned INT32 *)a;
 
     for(mlen>>=3;--mlen>=0;)
     {
@@ -152,16 +186,19 @@ unsigned INT32 hashmem(const unsigned char *a,INT32 len,INT32 mlen)
 #else
   for(mlen>>=3;--mlen>=0;)
   {
-    ret^=(ret<<7)+((((((*(a)<<3)+*(a+1))<<4)+*(a+2))<<5)+*(a+3));
-    ret^=(ret>>6)+((((((*(a+4)<<3)+*(a+5))<<4)+*(a+6))<<5)+*(a+7));
-    a+=8;
-
-    /*
-     * ret^=(ret<<7)+((((((*(a++)<<3)+*(a++))<<4)+*(a++))<<5)+*(a++));
-     * ret^=(ret>>6)+((((((*(a++)<<3)+*(a++))<<4)+*(a++))<<5)+*(a++));
-     */
+    register unsigned int t1,t2;
+    t1= *(a++);
+    t2= *(a++);
+    t1=(t1<<5) + *(a++);
+    t2=(t2<<4) + *(a++);
+    t1=(t1<<7) + *(a++);
+    t2=(t2<<5) + *(a++);
+    t1=(t1<<3) + *(a++);
+    t2=(t2<<4) + *(a++);
+    ret^=(ret<<7) + (ret>>6) + t1 + (t2<<6);
   }
 #endif
+
   return ret;
 }
 
@@ -386,3 +423,424 @@ void memfill(char *to,
     }
   }
 }
+
+char *debug_xalloc(long size)
+{
+  char *ret;
+  if(!size) return 0;
+
+  ret=(char *)malloc(size);
+  if(ret) return ret;
+
+  error("Out of memory.\n");
+  return 0;
+}
+
+#ifdef DEBUG_MALLOC
+
+#include "threads.h"
+
+#ifdef _REENTRANT
+static MUTEX_T debug_malloc_mutex;
+#endif
+
+
+#undef malloc
+#undef free
+#undef realloc
+#undef calloc
+#undef strdup
+#undef main
+
+static void add_location(struct memhdr *mh, int locnum);
+static struct memhdr *find_memhdr(void *p);
+
+#include "block_alloc.h"
+
+int verbose_debug_malloc = 0;
+int verbose_debug_exit = 1;
+
+#define HSIZE 1109891
+#define LHSIZE 1109891
+#define FLSIZE 8803
+
+struct fileloc
+{
+  struct fileloc *next;
+  const char *file;
+  int line;
+  int number;
+};
+
+BLOCK_ALLOC(fileloc, 4090)
+
+struct memloc
+{
+  struct memloc *next;
+  struct memhdr *mh;
+  int locnum;
+  int times;
+};
+
+BLOCK_ALLOC(memloc, 16382)
+
+struct memhdr
+{
+  struct memhdr *next;
+  size_t size;
+  void *data;
+  struct memloc *locations;
+};
+
+static struct fileloc *flhash[FLSIZE];
+static struct memloc *mlhash[LHSIZE];
+static struct memhdr *hash[HSIZE];
+
+static struct memhdr no_leak_memlocs;
+static int file_location_number=0;
+
+static int location_number(const char *file, int line)
+{
+  struct fileloc *f,**prev;
+  unsigned long h=(long)file;
+  h*=4711;
+  h+=line;
+  h%=FLSIZE;
+  for(prev=flhash+h;(f=*prev);prev=&f->next)
+  {
+    if(f->line == line && f->file == file)
+    {
+      *prev=f->next;
+      f->next=flhash[h];
+      flhash[h]=f;
+      return f->number;
+    }
+  }
+
+  f=alloc_fileloc();
+  f->line=line;
+  f->file=file;
+  f->number=++file_location_number;
+  f->next=flhash[h];
+  flhash[h]=f;
+  return f->number;
+}
+
+static struct fileloc *find_file_location(int locnum)
+{
+  int e;
+  struct fileloc *r;
+  for(e=0;e<FLSIZE;e++)
+    for(r=flhash[e];r;r=r->next)
+      if(r->number == locnum)
+	return r;
+  fprintf(stderr,"Internal error in DEBUG_MALLOC, failed to find location.\n");
+  exit(127);
+}
+
+void low_add_marks_to_memhdr(struct memhdr *to,
+			     struct memhdr *from)
+{
+  struct memloc *l;
+  if(!from) return;
+  for(l=from->locations;l;l=l->next)
+    add_location(to, l->locnum);
+}
+
+void add_marks_to_memhdr(struct memhdr *to, void *ptr)
+{
+  low_add_marks_to_memhdr(to,find_memhdr(ptr));
+}
+
+static inline unsigned long lhash(struct memhdr *m, int locnum)
+{
+  unsigned long l;
+  l=(long)m;
+  l*=53;
+  l+=locnum;
+  l%=LHSIZE;
+  return l;
+}
+
+#undef INIT_BLOCK
+#undef EXIT_BLOCK
+
+#define INIT_BLOCK(X) X->locations=0
+#define EXIT_BLOCK(X) do {				\
+  struct memloc *ml;					\
+  while((ml=X->locations))				\
+  {							\
+    unsigned long l=lhash(X,ml->locnum);		\
+    if(mlhash[l]==ml) mlhash[l]=0;			\
+							\
+    X->locations=ml->next;				\
+    free_memloc(ml);					\
+  }							\
+}while(0)
+
+BLOCK_ALLOC(memhdr,16382)
+
+#undef INIT_BLOCK
+#undef EXIT_BLOCK
+
+#define INIT_BLOCK(X)
+#define EXIT_BLOCK(X)
+
+
+static struct memhdr *find_memhdr(void *p)
+{
+  struct memhdr *mh,**prev;
+  unsigned long h=(long)p;
+  h%=HSIZE;
+  for(prev=hash+h; (mh=*prev); prev=&mh->next)
+  {
+    if(mh->data==p)
+    {
+      *prev=mh->next;
+      mh->next=hash[h];
+      hash[h]=mh;
+      return mh;
+    }
+  }
+  return NULL;
+}
+
+
+static int find_location(struct memhdr *mh, int locnum)
+{
+  struct memloc *ml;
+  unsigned long l=lhash(mh,locnum);
+
+  if(mlhash[l] &&
+     mlhash[l]->mh==mh &&
+     mlhash[l]->locnum==locnum)
+    return 1;
+
+  for(ml=mh->locations;ml;ml=ml->next)
+  {
+    if(ml->locnum==locnum)
+    {
+      mlhash[l]=ml;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static void add_location(struct memhdr *mh, int locnum)
+{
+  struct memloc *ml;
+  unsigned long l;
+
+#if ( DEBUG_MALLOC - 0 ) < 2
+  if(find_location(&no_leak_memlocs, locnum)) return;
+#endif
+
+  l=lhash(mh,locnum);
+
+  if(mlhash[l] && mlhash[l]->mh==mh && mlhash[l]->locnum==locnum)
+  {
+    mlhash[l]->times++;
+    return;
+  }
+
+  for(ml=mh->locations;ml;ml=ml->next)
+    if(ml->locnum==locnum)
+      break;
+
+  if(!ml)
+  {
+    ml=alloc_memloc();
+    ml->locnum=locnum;
+    ml->next=mh->locations;
+    ml->mh=mh;
+    mh->locations=ml;
+  }
+  ml->times++;
+  mlhash[l]=ml;
+}
+
+static void make_memhdr(void *p, int s, int locnum)
+{
+  struct memhdr *mh=alloc_memhdr();
+  struct memloc *ml=alloc_memloc();
+  unsigned long l=lhash(mh,locnum);
+  unsigned long h=(long)p;
+  h%=HSIZE;
+
+  mh->next=hash[h];
+  mh->data=p;
+  mh->size=s;
+  mh->locations=ml;
+  ml->locnum=locnum;
+  ml->next=0;
+  ml->times=1;
+  hash[h]=mh;
+  mlhash[l]=ml;
+}
+
+static int remove_memhdr(void *p)
+{
+  struct memhdr **prev,*mh;
+  unsigned long h=(long)p;
+  h%=HSIZE;
+  for(prev=hash+h;(mh=*prev);prev=&(mh->next))
+  {
+    if(mh->data==p)
+    {
+      *prev=mh->next;
+      low_add_marks_to_memhdr(&no_leak_memlocs, mh);
+      free_memhdr(mh);
+      
+      return 1;
+    }
+  }
+  return 0;
+}
+
+void *debug_malloc(size_t s, const char *fn, int line)
+{
+  void *m;
+
+  mt_lock(&debug_malloc_mutex);
+
+  m=malloc(s);
+  if(m)
+    make_memhdr(m, s, location_number(fn,line));
+
+  if(verbose_debug_malloc)
+    fprintf(stderr, "malloc(%d) => %p  (%s:%d)\n", s, m, fn, line);
+
+  mt_unlock(&debug_malloc_mutex);
+  return m;
+}
+
+
+void *debug_calloc(size_t a, size_t b, const char *fn, int line)
+{
+  void *m;
+  int locnum;
+  mt_lock(&debug_malloc_mutex);
+  m=calloc(a, b);
+
+  if(m) make_memhdr(m, a*b, location_number(fn,line));
+
+  if(verbose_debug_malloc)
+    fprintf(stderr, "calloc(%d,%d) => %p  (%s:%d)\n", a, b, m, fn, line);
+
+  mt_unlock(&debug_malloc_mutex);
+  return m;
+}
+
+void *debug_realloc(void *p, size_t s, const char *fn, int line)
+{
+  void *m;
+  mt_lock(&debug_malloc_mutex);
+  m=realloc(p, s);
+  if(m) {
+    if(p) remove_memhdr(p);
+    make_memhdr(m, s, location_number(fn,line));
+  }
+  if(verbose_debug_malloc)
+    fprintf(stderr, "realloc(%p,%d) => %p  (%s:%d)\n", p, s, m, fn,line);
+  mt_unlock(&debug_malloc_mutex);
+  return m;
+}
+
+void debug_free(void *p, const char *fn, int line)
+{
+  mt_lock(&debug_malloc_mutex);
+  remove_memhdr(p);
+  free(p);
+  if(verbose_debug_malloc)
+    fprintf(stderr, "free(%p) (%s:%d)\n", p, fn,line);
+  mt_unlock(&debug_malloc_mutex);
+}
+
+char *debug_strdup(const char *s, const char *fn, int line)
+{
+  char *m;
+  mt_lock(&debug_malloc_mutex);
+  m=strdup(s);
+
+  if(m) make_memhdr(m, strlen(s)+1, location_number(fn,line));
+
+  if(verbose_debug_malloc)
+    fprintf(stderr, "strdup(\"%s\") => %p  (%s:%d)\n", s, m, fn, line);
+  mt_unlock(&debug_malloc_mutex);
+  return m;
+}
+
+
+void dump_memhdr_locations(struct memhdr *from,
+			   struct memhdr *notfrom)
+{
+  struct memloc *l;
+  for(l=from->locations;l;l=l->next)
+  {
+    struct fileloc *f;
+    if(notfrom && find_location(notfrom, l->locnum))
+      continue;
+
+    f=find_file_location(l->locnum);
+    fprintf(stderr," *** %s:%d (%d times)\n",f->file,f->line,l->times);
+  }
+}
+
+void cleanup_memhdrs()
+{
+  unsigned long h;
+  mt_lock(&debug_malloc_mutex);
+  if(verbose_debug_exit)
+  {
+    int first=1;
+    for(h=0;h<HSIZE;h++)
+    {
+      struct memhdr *m;
+      for(m=hash[h];m;m=m->next)
+      {
+	struct memloc *l;
+	if(first)
+	{
+	  fprintf(stderr,"\n");
+	  first=0;
+	}
+
+	
+	fprintf(stderr, "LEAK: (%p) %d bytes\n",m->data, m->size);
+	for(l=m->locations;l;l=l->next)
+	{
+	  struct fileloc *f=find_file_location(l->locnum);
+	  fprintf(stderr,"  *** %s:%d (%d times) %s\n",
+		  f->file,
+		  f->line,
+		  l->times,
+		  find_location(&no_leak_memlocs, l->locnum) ? "" : " *");
+	}
+      }
+    }
+  }
+  mt_unlock(&debug_malloc_mutex);
+  mt_destroy(&debug_malloc_mutex);
+}
+
+int main(int argc, char *argv[])
+{
+  extern int dbm_main(int, char **);
+  mt_init(&debug_malloc_mutex);
+  return dbm_main(argc, argv);
+}
+
+void * debug_malloc_update_location(void *p,const char *fn, int line)
+{
+  if(p)
+  {
+    struct memhdr *mh;
+    if((mh=find_memhdr(p)))
+      add_location(mh, location_number(fn,line));
+  }
+  return p;
+}
+
+
+#endif
diff --git a/src/pike_memory.h b/src/pike_memory.h
index e53a9fe6ef9d676fa3f6634ceed07be7f49ab81f..3e124db0d74b181c873481daa8b252239b3efc0a 100644
--- a/src/pike_memory.h
+++ b/src/pike_memory.h
@@ -34,7 +34,7 @@ struct mem_searcher
 };
 
 /* Prototypes begin here */
-char *xalloc(SIZE_T size);
+extern char *debug_xalloc(long);
 void swap(char *a, char *b, INT32 size);
 void reverse(char *memory, INT32 nitems, INT32 size);
 void reorder(char *memory, INT32 nitems, INT32 size,INT32 *order);
diff --git a/src/pike_types.c b/src/pike_types.c
index c474489b4512a45add485efd24b6e1f2c26b3459..c2987e27cf1b65f0e79bd891ecc112247527ccda 100644
--- a/src/pike_types.c
+++ b/src/pike_types.c
@@ -4,7 +4,7 @@
 ||| See the files COPYING and DISCLAIMER for more information.
 \*/
 #include "global.h"
-RCSID("$Id: pike_types.c,v 1.26 1997/09/29 00:57:55 hubbe Exp $");
+RCSID("$Id: pike_types.c,v 1.27 1998/03/03 11:24:39 hubbe Exp $");
 #include <ctype.h>
 #include "svalue.h"
 #include "pike_types.h"
@@ -212,7 +212,7 @@ void push_finished_type(struct pike_string *type)
   for(e=type->len-1;e>=0;e--) push_type(type->str[e]);
 }
 
-struct pike_string *pop_unfinished_type(void)
+struct pike_string *debug_pop_unfinished_type(void)
 {
   int len,e;
   struct pike_string *s;
@@ -226,7 +226,7 @@ struct pike_string *pop_unfinished_type(void)
   return s;
 }
 
-struct pike_string *pop_type(void)
+struct pike_string *debug_pop_type(void)
 {
   struct pike_string *s;
   s=pop_unfinished_type();
diff --git a/src/pike_types.h b/src/pike_types.h
index 0c407f8c10b288d39b5232c35756a018007ce92e..8a4a60c3b4525d008c67ed374551e4884d8414a6 100644
--- a/src/pike_types.h
+++ b/src/pike_types.h
@@ -37,8 +37,8 @@ void type_stack_reverse(void);
 void push_type_int(unsigned INT32 i);
 void push_unfinished_type(char *s);
 void push_finished_type(struct pike_string *type);
-struct pike_string *pop_unfinished_type(void);
-struct pike_string *pop_type(void);
+struct pike_string *debug_pop_unfinished_type(void);
+struct pike_string *debug_pop_type(void);
 struct pike_string *parse_type(char *s);
 void stupid_describe_type(char *a,INT32 len);
 void simple_describe_type(struct pike_string *s);
@@ -58,4 +58,13 @@ char *get_name_of_type(int t);
 void cleanup_pike_types(void);
 /* Prototypes end here */
 
+#ifdef DEBUG_MALLOC
+#define pop_type() ((struct pike_string *)debug_malloc_update_location(debug_pop_type(),__FILE__,__LINE__))
+#define pop_unfinished_type() \
+ ((struct pike_string *)debug_malloc_update_location(debug_pop_unfinished_type(),__FILE__,__LINE__))
+#else
+#define pop_type debug_pop_type
+#define pop_unfinished_type debug_pop_unfinished_type
+#endif
+
 #endif
diff --git a/src/program.c b/src/program.c
index 791f3ddfe33786f189b8771648fcb476f89d4f17..abd5925c2eca15e6596e306db35a0a44c275894c 100644
--- a/src/program.c
+++ b/src/program.c
@@ -4,7 +4,7 @@
 ||| See the files COPYING and DISCLAIMER for more information.
 \*/
 #include "global.h"
-RCSID("$Id: program.c,v 1.46 1997/11/08 01:34:43 hubbe Exp $");
+RCSID("$Id: program.c,v 1.47 1998/03/03 11:24:40 hubbe Exp $");
 #include "program.h"
 #include "object.h"
 #include "dynamic_buffer.h"
@@ -144,8 +144,7 @@ int find_module_identifier(struct pike_string *ident)
     while(--e>=0)
     {
       push_svalue(modules+e);
-      push_string(ident);
-      ident->refs++;
+      ref_push_string(ident);
       f_index(2);
       
       if(!IS_UNDEFINED(sp-1))
@@ -623,7 +622,7 @@ if((prog->PTRS = areas[AREA].s.len/sizeof(TYPE))) \
   p+=MY_ALIGN(areas[AREA].s.len); \
 }
 
-struct program *end_program(void)
+struct program *debug_end_program(void)
 {
   struct pike_string **names;
   int size, i,e,t;
diff --git a/src/program.h b/src/program.h
index 82c6fe9a2077d4b4af19909a14930225fed316d0..b800af9b40523ce1635527529515bd4078b0d399 100644
--- a/src/program.h
+++ b/src/program.h
@@ -208,7 +208,7 @@ void really_free_program(struct program *p);
 void dump_program_desc(struct program *p);
 void toss_current_program(void);
 void check_program(struct program *p);
-struct program *end_program(void);
+struct program *debug_end_program(void);
 SIZE_T add_storage(SIZE_T size);
 void set_init_callback(void (*init)(struct object *));
 void set_exit_callback(void (*exit)(struct object *));
@@ -293,3 +293,8 @@ void my_yyerror(char *fmt,...) ATTRIBUTE((format (printf, 1, 2)));
 
 
 
+#ifdef DEBUG_MALLOC
+#define end_program() ((struct program *)debug_malloc_touch(debug_end_program()))
+#else
+#define end_program debug_end_program
+#endif
diff --git a/src/stralloc.c b/src/stralloc.c
index 431288ae96a043190d2e85980c93dd6fc4e236ad..a61e649df7d48d4e84d49d6e58533d33e786fc43 100644
--- a/src/stralloc.c
+++ b/src/stralloc.c
@@ -124,7 +124,7 @@ static void rehash(void)
 /* note that begin_shared_string expects the _exact_ size of the string,
  * not the maximum size
  */
-struct pike_string *begin_shared_string(int len)
+struct pike_string *debug_begin_shared_string(int len)
 {
   struct pike_string *t;
   t=(struct pike_string *)xalloc(len + sizeof(struct pike_string));
@@ -165,7 +165,7 @@ struct pike_string *end_shared_string(struct pike_string *s)
   return s;
 }
 
-struct pike_string * make_shared_binary_string(const char *str,int len)
+struct pike_string * debug_make_shared_binary_string(const char *str,int len)
 {
   struct pike_string *s;
   int h=StrHash(str,len);
@@ -183,7 +183,7 @@ struct pike_string * make_shared_binary_string(const char *str,int len)
   return s;
 }
 
-struct pike_string *make_shared_string(const char *str)
+struct pike_string *debug_make_shared_string(const char *str)
 {
   return make_shared_binary_string(str, strlen(str));
 }
diff --git a/src/stralloc.h b/src/stralloc.h
index 397c8d639f76cd163cc6a525178f3a1397d6a481..b7faffdde6a5c3f27dee4d07286ddddbe19a4ef2 100644
--- a/src/stralloc.h
+++ b/src/stralloc.h
@@ -25,22 +25,33 @@ struct pike_string
 struct pike_string *debug_findstring(const struct pike_string *foo);
 #endif
 
-#define free_string(s) do{ struct pike_string *_=(s); if(--_->refs<=0) really_free_string(_); }while(0)
+#define free_string(s) do{ struct pike_string *_=(s); debug_malloc_touch(_); if(--_->refs<=0) really_free_string(_); }while(0)
 
-#define my_hash_string(X) ((unsigned long)(X))
+#define my_hash_string(X) ((unsigned long)debug_malloc_pass(X))
 #define my_order_strcmp(X,Y) ((char *)(X)-(char *)(Y))
 #define is_same_string(X,Y) ((X)==(Y))
 
+#ifdef DEBUG_MALLOC
+
+#define reference_shared_string(s) do { struct pike_string *S_=(s); debug_malloc_touch(S_); S_->refs++; }while(0)
+#define copy_shared_string(to,s) do { struct pike_string *S_=(to)=(s); debug_malloc_touch(S_); S_->refs++; }while(0)
+
+#else
+
 #define reference_shared_string(s) (s)->refs++
 #define copy_shared_string(to,s) ((to)=(s))->refs++
 
+
+#endif
+
+
 /* Prototypes begin here */
 struct pike_string *binary_findstring(const char *foo, INT32 l);
 struct pike_string *findstring(const char *foo);
-struct pike_string *begin_shared_string(int len);
+struct pike_string *debug_begin_shared_string(int len);
 struct pike_string *end_shared_string(struct pike_string *s);
-struct pike_string * make_shared_binary_string(const char *str,int len);
-struct pike_string *make_shared_string(const char *str);
+struct pike_string *debug_make_shared_binary_string(const char *str,int len);
+struct pike_string *debug_make_shared_string(const char *str);
 void unlink_pike_string(struct pike_string *s);
 void really_free_string(struct pike_string *s);
 struct pike_string *add_string_status(int verbose);
@@ -65,4 +76,17 @@ void count_memory_in_strings(INT32 *num, INT32 *size);
 void gc_mark_all_strings(void);
 /* Prototypes end here */
 
+#ifdef DEBUG_MALLOC
+#define make_shared_string(X) \
+ ((struct pike_string *)debug_malloc_update_location(debug_make_shared_string(X),__FILE__,__LINE__))
+#define make_shared_binary_string(X,Y) \
+ ((struct pike_string *)debug_malloc_update_location(debug_make_shared_binary_string((X),(Y)),__FILE__,__LINE__))
+#define begin_shared_string(X) \
+ ((struct pike_string *)debug_malloc_update_location(debug_begin_shared_string(X),__FILE__,__LINE__))
+#else
+#define make_shared_string debug_make_shared_string
+#define make_shared_binary_string debug_make_shared_binary_string
+#define begin_shared_string debug_begin_shared_string
+#endif
+
 #endif /* STRALLOC_H */
diff --git a/src/svalue.h b/src/svalue.h
index 5ed08d1b389d14283ce5d958d2fa2484941f1195..e198ff8377757f0780018cc071934cfb38ddb85b 100644
--- a/src/svalue.h
+++ b/src/svalue.h
@@ -182,8 +182,8 @@ do{ \
 
 #endif
 
-#define free_svalue(X) do { struct svalue *_s=(X); check_type(_s->type); check_refs(_s); if(_s->type<=MAX_REF_TYPE && --*(_s->u.refs) <=0) really_free_svalue(_s); }while(0)
-#define assign_svalue_no_free(X,Y) do { struct svalue _tmp, *_to=(X), *_from=(Y); check_type(_from->type); check_refs(_from);  *_to=_tmp=*_from; if(_tmp.type <= MAX_REF_TYPE) _tmp.u.refs[0]++; }while(0)
+#define free_svalue(X) do { struct svalue *_s=(X); check_type(_s->type); check_refs(_s); if(_s->type<=MAX_REF_TYPE) { debug_malloc_touch(_s->u.refs); if(--*(_s->u.refs) <=0) really_free_svalue(_s); } }while(0)
+#define assign_svalue_no_free(X,Y) do { struct svalue _tmp, *_to=(X), *_from=(Y); check_type(_from->type); check_refs(_from);  *_to=_tmp=*_from; if(_tmp.type <= MAX_REF_TYPE) { debug_malloc_touch(_tmp.u.refs); _tmp.u.refs[0]++; } }while(0)
 #define assign_svalue(X,Y) do { struct svalue *_to2=(X), *_from2=(Y); free_svalue(_to2); assign_svalue_no_free(_to2, _from2);  }while(0)
 
 extern struct svalue dest_ob_zero;