Initial revision

1 files changed, 996 insertions, 0 deletions

diff --git a/clients/xzwrite/nmalloc.c b/clients/xzwrite/nmalloc.c
new file mode 100644
index 0000000..42994cd
--- /dev/null
+++ b/clients/xzwrite/nmalloc.c
@@ -0,0 +1,996 @@
+#define scribblecheck
+#define public
+#define rcheck
+#define NBUCKETS 30
+
+#include <stdio.h>
+#ifdef MALLOC_DEBUG
+#define register
+#endif MALLOC_DEBUG
+malloc_warning(s)
+     char *s;
+{
+  printf("Malloc warning: %s\n",s);
+}
+
+botch(s)
+     char *s;
+{
+  printf("Botch: <%s> dumping core...\n",s);
+  fflush(stdout);
+  fflush(stderr);
+  abort();
+}
+
+/*   Copyright (C) 1985 Richard M. Stallman,
+    based mostly on the public domain work of others.
+
+This program is distributed in the hope that it will be useful,
+but without any warranty.  No author or distributor
+accepts responsibility to anyone for the consequences of using it
+or for whether it serves any particular purpose or works at all,
+unless he says so in writing.
+
+   Permission is granted to anyone to distribute verbatim copies
+   of this program's source code as received, in any medium, provided that
+   the copyright notice, the nonwarraty notice above
+   and this permission notice are preserved,
+   and that the distributor grants the recipient all rights
+   for further redistribution as permitted by this notice,
+   and informs him of these rights.
+
+   Permission is granted to distribute modified versions of this
+   program's source code, or of portions of it, under the above
+   conditions, plus the conditions that all changed files carry
+   prominent notices stating who last changed them and that the
+   derived material, including anything packaged together with it and
+   conceptually functioning as a modification of it rather than an
+   application of it, is in its entirety subject to a permission
+   notice identical to this one.
+
+   Permission is granted to distribute this program (verbatim or
+   as modified) in compiled or executable form, provided verbatim
+   redistribution is permitted as stated above for source code, and
+    A.  it is accompanied by the corresponding machine-readable
+      source code, under the above conditions, or
+    B.  it is accompanied by a written offer, with no time limit,
+      to distribute the corresponding machine-readable source code,
+      under the above conditions, to any one, in return for reimbursement
+      of the cost of distribution.   Verbatim redistribution of the
+      written offer must be permitted.  Or,
+    C.  it is distributed by someone who received only the
+      compiled or executable form, and is accompanied by a copy of the
+      written offer of source code which he received along with it.
+
+   Permission is granted to distribute this program (verbatim or as modified)
+   in executable form as part of a larger system provided that the source
+   code for this program, including any modifications used,
+   is also distributed or offered as stated in the preceding paragraph.
+
+In other words, you are welcome to use, share and improve this program.
+You are forbidden to forbid anyone else to use, share and improve
+what you give them.   Help stamp out software-hoarding!  */
+
+/****************************************************************
+ *								*
+ *		Helpful historical comments			*
+ *								*
+ ****************************************************************/
+
+/*
+ * @(#)nmalloc.c 1 (Caltech) 2/21/82
+ *
+ *	U of M Modified: 20 Jun 1983 ACT: strange hacks for Emacs
+ *
+ *	Nov 1983, Mike@BRL, Added support for 4.1C/4.2 BSD.
+ *
+ * This is a very fast storage allocator.  It allocates blocks of a small 
+ * number of different sizes, and keeps free lists of each size.  Blocks
+ * that don't exactly fit are passed up to the next larger size.  In this 
+ * implementation, the available sizes are (2^n)-4 (or -16) bytes long.
+ * This is designed for use in a program that uses vast quantities of
+ * memory, but bombs when it runs out.  To make it a little better, it
+ * warns the user when he starts to get near the end.
+ *
+ * June 84, ACT: modified rcheck code to check the range given to malloc,
+ * rather than the range determined by the 2-power used.
+ *
+ * Jan 85, RMS: calls malloc_warning to issue warning on nearly full.
+ * No longer Emacs-specific; can serve as all-purpose malloc for GNU.
+ * You should call malloc_init to reinitialize after loading dumped Emacs.
+ * Call malloc_stats to get info on memory stats if MSTATS turned on.
+ * realloc knows how to return same block given, just changing its size,
+ * if the power of 2 is correct.
+ *
+ * Jan 86, WDC: Removed Emacs specific stuff, and neatened a few comments.
+ *
+ * March 86 WDC: Added in code by Eichin for Scribble checking of blocks
+ * Scribble check writes a known pattern into the free blocks, checks it
+ * to see if it is still undamaged before allocating it.  It writes a
+ * different pattern into the space beyond the end of an allocated block,
+ * and tests it for damage when expanding the block's bounds in realloc.
+ * Note, this check takes *TIME* and should not be compiled in by default.
+ *
+ * Aug 18 1986, MWE: added 'public' stuff to allow makedecl to generate
+ * a malloc.h file.
+ * 
+ * Berkeley UNIX 4.3 has a storage allocator that shares a common
+ * ancestor with this one.  It handles realloc compatibly with the
+ * archaic use of realloc on an already freed block to "compact"
+ * storage.  It uses a pagesize system call rather than assuming the
+ * page size is 1024 bytes.  Finally it guarantees that a freed block
+ * is not munged by the allocator itself, incase someone wants to fiddle
+ * with freed space after freeing it but before allocating more.
+ *
+ * This particular storage allocator would benefit from having a
+ * non-hardwired pagesize.  But because of the scribble check it would
+ * not be useful to keep the free pointer in the header.  SO: When you
+ * free something allocated with this allocator, DONT TRY TO USE IT.
+ * It is GUARANTEED to be damaged by the freeing process.
+ *
+ * For interfacing to systems that want to be able to ask the size of
+ * the allocated block, rather than remembering it, the m_blocksize
+ * function, rips open the block and tells you how big it is.  The size
+ * returned is nbytes, the number of bytes asked for, NOT the actual
+ * amount of space in the block.
+ *
+ * This malloc also has a horrible but very useful hack which can be
+ * enabled by defined MALLOC_DEBUG.  This causes malloc to keep track
+ * of who requested a particular block of memory to be malloc'ed or
+ * free'ed.  A dump function (which is usually called from a signal
+ * handler) will then print out what all the blocks of memory and who
+ * last malloc'ed or free'ed it.  It accomplishes this feat by opening
+ * the binary and groveling over the symbol table.  Thus, this is not
+ * guaranteed to work across all systems.  It will work on BSD 4.[23]
+ * systems, however.
+ */
+
+/****************************************************************
+ *								*
+ *	 Includes, declarations, and definitions		*
+ *								*
+ ****************************************************************/
+#include "nmalloc.h"
+#ifndef public
+#define New(TYPE) ((TYPE *)malloc(sizeof(TYPE)))
+#endif public
+/* Determine which kind of system this is.  */
+#include <signal.h>
+#ifndef SIGTSTP
+#define USG
+#else /* SIGTSTP */
+#ifdef SIGIO
+#define BSD42
+#endif /* SIGIO */
+#endif /* SIGTSTP */
+
+#ifndef BSD42
+#ifndef USG
+#include <sys/vlimit.h>		/* warn the user when near the end */
+#endif
+#else /* if BSD42 */
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif /* BSD42 */
+
+#ifdef scribblecheck
+#define rcheck
+#endif /* we need to have range data to use block boundary checking */
+
+#ifdef rcheck
+/*
+ * To implement range checking, we write magic values in at the
+ * beginning and end of each allocated block, and make sure they
+ * are undisturbed whenever a free or a realloc occurs.
+ */
+
+/* Written in each of the 4 bytes following the block's real space */
+#define MAGIC1 0x55
+#define MAGICFREE 0x69		/* 0110 1001 Magic value for Free blocks */
+
+/* Written in the 4 bytes before the block's real space */
+#define MAGIC4 0x55555555
+#define MAGICFREE4 0x69696969
+
+#define ASSERT(p) if (!(p)) botch("p"); else
+#define EXTRA  4		/* 4 bytes extra for MAGIC1s */
+#else
+#define ASSERT(p)
+#define EXTRA  0
+#endif /* rcheck */
+
+#define ISALLOC ((char) 0xf7)	/* magic byte that implies allocation */
+#define ISFREE ((char) 0x54)	/* magic byte that implies free block */
+				/* this is for error checking only */
+
+/* If range checking is not turned on, all we have is a flag
+ * indicating whether memory is allocated, an index in nextf[],
+ * and a field that tells how many bytes.
+ * To realloc() memory we copy nbytes.
+ * 16 bits of header space is unused.
+ */
+struct mhead {
+	char     mh_alloc;	/* ISALLOC or ISFREE */
+	char     mh_index;	/* index in nextf[] */
+	unsigned short mh_extra;/* Currently wasted 16 bits */
+/* Remainder are valid only when block is allocated */
+	unsigned mh_nbytes;	/* number of bytes allocated */
+#ifdef MALLOC_DEBUG
+	char	*mh_parent;	/* set to caller of malloc/realloc */
+	struct mhead *mh_link;	/* set to next block or NULL */
+#endif MALLOC_DEBUG
+#ifdef rcheck
+	int      mh_magic4;	/* should be == MAGIC4 */
+#endif /* rcheck */
+};
+
+#ifdef MALLOC_DEBUG
+struct mhead *baselink=NULL;
+struct mhead *endlink=NULL;
+#endif MALLOC_DEBUG
+
+/*
+ * Access free-list pointer of a block.
+ * It is stored at block + 4.
+ * This is not a field in the mhead structure because we want
+ * sizeof (struct mhead) to describe the overhead for when the
+ * block is in use, and we do not want the free-list pointer
+ * to count in that.
+ */
+#define CHAIN(a) \
+  (*(struct mhead **) (sizeof (char *) + (char *) (a)))
+
+
+/****************************************************************
+ *								*
+ *		Variable Creations				*
+ *								*
+ ****************************************************************/
+
+extern char etext;
+extern char *start_of_data ();  /* This seems necessary for USG */
+
+/* These two are for user programs to look at, when they are interested.  */
+
+int malloc_sbrk_used;       /* amount of data space used now */
+int malloc_sbrk_unused;     /* amount more we can have */
+
+/* start of data space; can be changed by calling init_malloc */
+static char *data_space_start = 0;
+
+#ifdef MSTATS
+/*
+ * nmalloc[i] is the difference between the number of mallocs and frees
+ * for a given block size.
+ */
+static int nmalloc[NBUCKETS];
+static int nmal, nfre;
+#endif /* MSTATS */
+
+/*
+ * nextf[i] is the pointer to the next free block of size 2^(i+3).  The
+ * smallest allocatable block is 8 bytes.  The overhead information will
+ * go in the first int of the block, and the returned pointer will point
+ * to the second.
+ */
+static struct mhead *nextf[NBUCKETS];
+
+/* Number of bytes of writable memory we can expect to be able to get */
+static int lim_data = 0;
+/* Level number of warnings already issued.
+ * 0 -- no warnings issued.
+ * 1 -- 75% warning already issued.
+ * 2 -- 85% warning already issued.
+ */
+static int warnlevel = 0;
+
+/* nonzero once initial bunch of free blocks made */
+static int gotpool;
+
+/****************************************************************
+ *								*
+ *		Start of procedures				*
+ *								*
+ *	malloc_init, m_blocksize				*
+ *								*
+ ****************************************************************/
+
+/*
+ * Cause reinitialization based on job parameters;
+ * also declare where the end of pure storage is.
+ */
+public malloc_init (start)
+     char *start;
+{
+  data_space_start = start;
+  lim_data = 0;
+  warnlevel = 0;
+#ifdef MALLOC_DEBUG
+  baselink = NULL;
+  endlink = NULL;
+#endif MALLOC_DEBUG
+}
+
+public int m_blocksize(a_block)
+     register char *a_block;
+{
+  if (a_block == (char *)0) return 0;
+  return(((struct mhead *)a_block-1)->mh_nbytes);
+}
+
+/****************************************************************
+ *								*
+ *    morecore - Ask the system for more memory			*
+ *								*
+ ****************************************************************/
+
+static
+morecore (nu)			/* ask system for more memory */
+     register int nu;		/* size index to get more of  */
+{
+  char *sbrk ();
+  register char *cp;
+  register int nblks;
+  register int siz;
+
+  if (!data_space_start)
+    {
+#if defined(USG)
+      data_space_start = start_of_data ();
+#else /* not USG */
+      data_space_start = &etext;
+#endif /* not USG */
+    }
+
+  if (lim_data == 0)
+    get_lim_data ();
+
+  /* On initial startup, get two blocks of each size up to 1k bytes */
+  if (!gotpool)
+    getpool (), getpool (), gotpool = 1;
+
+  /* Find current end of memory and issue warning if getting near max */
+
+  cp = sbrk (0);
+  siz = cp - data_space_start;
+  malloc_sbrk_used = siz;
+  malloc_sbrk_unused = lim_data - siz;
+
+  switch (warnlevel)
+    {
+    case 0: 
+      if (siz > (lim_data / 4) * 3)
+	{
+	  warnlevel++;
+	  malloc_warning ("Warning: past 75% of memory limit");
+	}
+      break;
+    case 1: 
+      if (siz > (lim_data / 20) * 17)
+	{
+	  warnlevel++;
+	  malloc_warning ("Warning: past 85% of memory limit");
+	}
+      break;
+    case 2: 
+      if (siz > (lim_data / 20) * 19)
+	{
+	  warnlevel++;
+	  malloc_warning ("Warning: past 95% of memory limit");
+	}
+      break;
+    }
+
+  if ((int) cp & 0x3ff)	/* land on 1K boundaries */
+    sbrk (1024 - ((int) cp & 0x3ff));
+
+  /* Take at least 2k, and figure out how many blocks of the desired size
+    we're about to get */
+  nblks = 1;
+  if ((siz = nu) < 8)
+    nblks = 1 << ((siz = 8) - nu);
+
+  if ((cp = sbrk (1 << (siz + 3))) == (char *) -1)
+    return;			/* no more room! */
+  if ((int) cp & 7)
+    {		/* shouldn't happen, but just in case */
+      cp = (char *) (((int) cp + 8) & ~7);
+      nblks--;
+    }
+
+  /* save new header and link the nblks blocks together */
+  nextf[nu] = (struct mhead *) cp;
+  siz = 1 << (nu + 3);
+  while (1)
+    {
+      ((struct mhead *) cp) -> mh_alloc = ISFREE;
+      ((struct mhead *) cp) -> mh_index = nu;
+#ifdef MALLOC_DEBUG
+      ((struct mhead *) cp) -> mh_parent = NULL;
+      ((struct mhead *) cp) -> mh_link = NULL;
+#endif MALLOC_DEBUG
+#ifdef rcheck
+      ((struct mhead *) cp) -> mh_magic4 = MAGICFREE4;
+#endif /* rcheck */
+#ifdef scribblecheck
+    {
+      /* Check that upper stuff was still MAGIC1 */
+      register char *m = (char *)((struct mhead *)cp+1);
+      register char *en = (8<<nu) + cp;
+      /* Fill whole block with MAGICFREE */
+      while (m<en) *m++ = MAGICFREE;
+    }
+#endif /* scribblecheck */
+
+      /* Clear newly allocated blocks, to match free ones */
+      if (--nblks <= 0) break;
+      CHAIN ((struct mhead *) cp) = (struct mhead *) (cp + siz);
+      cp += siz;
+    }
+  CHAIN ((struct mhead *) cp) = 0;
+}
+
+/****************************************************************
+ *								*
+ *	getpool - Get initial pools of small blocks		*
+ *								*
+ ****************************************************************/
+
+static
+getpool ()
+{
+  register int nu;
+  register char *cp = sbrk (0);
+
+  if ((int) cp & 0x3ff)	/* land on 1K boundaries */
+    sbrk (1024 - ((int) cp & 0x3ff));
+
+  /* Get 2k of storage */
+
+  cp = sbrk (04000);
+  if (cp == (char *) -1)
+    return;
+
+  /* Divide it into an initial 8-word block
+     plus one block of size 2**nu for nu = 3 ... 10.  */
+
+  CHAIN (cp) = nextf[0];
+  nextf[0] = (struct mhead *) cp;
+  ((struct mhead *) cp) -> mh_alloc = ISFREE;
+  ((struct mhead *) cp) -> mh_index = 0;
+#ifdef MALLOC_DEBUG
+  ((struct mhead *) cp) -> mh_parent = NULL;
+  ((struct mhead *) cp) -> mh_link = NULL;
+#endif MALLOC_DEBUG
+#ifdef rcheck
+      ((struct mhead *) cp) -> mh_magic4 = MAGICFREE4;
+#endif /* rcheck */
+  cp += 8;
+
+  for (nu = 0; nu < 7; nu++)
+    {
+      CHAIN (cp) = nextf[nu];
+      nextf[nu] = (struct mhead *) cp;
+      ((struct mhead *) cp) -> mh_alloc = ISFREE;
+      ((struct mhead *) cp) -> mh_index = nu;
+#ifdef rcheck
+      ((struct mhead *) cp) -> mh_magic4 = MAGICFREE4;
+#endif /* rcheck */
+#ifdef scribblecheck
+    {
+      register char *m = (char *)((struct mhead *)cp+1);
+      register char *en = (8<<nu) + cp;
+      /* Fill whole block with MAGICFREE */
+      while (m<en) *m++ = MAGICFREE;
+    }
+#endif /* scribblecheck */
+      cp += 8 << nu;
+    }
+}
+
+/****************************************************************
+ *								*
+ *	malloc - get a block of space from a pool		*
+ *								*
+ ****************************************************************/
+
+public char *
+malloc (n)		/* get a block */
+     unsigned n;
+{
+  register struct mhead *p;
+  register unsigned int nbytes;
+  register int nunits = 0;
+
+#ifdef MALLOC_DEBUG
+  char *PAPA = *(char **)(&n-2);
+#endif MALLOC_DEBUG
+
+  /* Figure out how many bytes are required, rounding up to the nearest
+     multiple of 4, then figure out which nextf[] area to use */
+  nbytes = (n + sizeof *p + EXTRA + 3) & ~3;
+  {
+    register unsigned int   shiftr = (nbytes - 1) >> 2;
+
+    while (shiftr >>= 1)
+      nunits++;
+  }
+
+  /* If there are no blocks of the appropriate size, go get some */
+  /* COULD SPLIT UP A LARGER BLOCK HERE ... ACT */
+  if (nextf[nunits] == 0)
+    morecore (nunits);
+
+  /* Get one block off the list, and set the new list head */
+  if ((p = nextf[nunits]) == 0)
+    return 0;
+  nextf[nunits] = CHAIN (p);
+
+  /* Check for free block clobbered */
+  /* If not for this check, we would gobble a clobbered free chain ptr */
+  /* and bomb out on the NEXT allocate of this size block */
+  if (p -> mh_alloc != ISFREE || p -> mh_index != nunits)
+    botch ("block on free list clobbered");
+#ifdef rcheck
+  if (p -> mh_magic4 != MAGICFREE4)
+    botch ("Magic in block on free list clobbered");
+#endif /* rcheck */
+#ifdef scribblecheck
+  /* Check for block filled with magic numbers, then change to zeros */
+  {
+    register char  *m = (char *) (p + 1);
+    register char *en = (8<<p->mh_index) + (char *) p;
+    register int  block_valid = 0;
+    while(m<en && (block_valid=(*m==MAGICFREE)))
+      *m++=(char)0;
+    /* so, status comes out as 1 if ok, 0 if terminated */
+    if (!block_valid) botch ("data on free list damaged");
+  }
+#endif /* scribblecheck */
+  /* Fill in the info, and if range checking, set up the magic numbers */
+  p -> mh_alloc = ISALLOC;
+  p -> mh_nbytes = n;
+#ifdef MALLOC_DEBUG
+  p -> mh_parent = PAPA;
+  if(!baselink)
+    {
+      baselink = p;
+      endlink = p;
+    }
+  else if (p -> mh_link == NULL && endlink != p)
+    {
+      endlink -> mh_link = p;
+      endlink = p;
+    }
+#endif MALLOC_DEBUG
+#ifdef rcheck
+  p -> mh_magic4 = MAGIC4;
+  {
+    register char  *m = (char *) (p + 1) + n;
+#ifdef scribblecheck
+    register char *en = (8<<p->mh_index)+(char *)p;
+    /* point to end of block */
+    while (m<en) *m++ = MAGIC1;
+#else /* scribblecheck */
+    *m++ = MAGIC1, *m++ = MAGIC1, *m++ = MAGIC1, *m = MAGIC1; 
+#endif /* scribblecheck */
+  }
+#endif /* not rcheck */
+#ifdef MSTATS
+  nmalloc[nunits]++;
+  nmal++;
+#endif /* MSTATS */
+  return (char *) (p + 1);
+}
+
+/****************************************************************
+ *								*
+ *	free - Free a block of space				*
+ *								*
+ ****************************************************************/
+
+public free (mem)
+     char *mem;
+{
+  register struct mhead *p;
+#ifdef MALLOC_DEBUG
+  char *PAPA = *(char **)((&mem)-2);
+#endif MALLOC_DEBUG
+  {
+    register char *ap = mem;
+
+    ASSERT (ap != 0);
+    p = (struct mhead *) ap - 1;
+    ASSERT (p -> mh_alloc == ISALLOC);
+#ifdef rcheck
+    ASSERT (p -> mh_magic4 == MAGIC4);
+    ap += p -> mh_nbytes;
+    p->mh_magic4 = MAGICFREE4;
+    ASSERT (*ap++ == MAGIC1); ASSERT (*ap++ == MAGIC1);
+    ASSERT (*ap++ == MAGIC1); ASSERT (*ap   == MAGIC1);
+#endif /* rcheck */
+  }
+  {
+    register int nunits = p -> mh_index;
+
+    ASSERT (nunits < NBUCKETS);
+#ifdef scribblecheck
+    {
+      /* Check that upper stuff was still MAGIC1 */
+      register char  *m = (char *) (p + 1) + p->mh_nbytes;
+      register char *en = (8<<p->mh_index) + (char *) p;
+      register int  block_valid = 0;
+      while(m<en && (block_valid=(*m++==MAGIC1)));
+      if (!block_valid) botch ("block freed with data out of bounds");
+      /* Fill whole block with MAGICFREE */
+      m = (char *) (p + 1);
+      while (m<en) *m++ = MAGICFREE;
+    }
+#endif /* scribblecheck */
+    p -> mh_alloc = ISFREE;
+    CHAIN (p) = nextf[nunits];
+    nextf[nunits] = p;
+#ifdef MSTATS
+    nmalloc[nunits]--;
+    nfre++;
+#endif /* MSTATS */
+  }
+#ifdef MALLOC_DEBUG
+  p -> mh_parent = PAPA;	/* since it IS freed... */
+#endif MALLOC_DEBUG
+}
+
+/****************************************************************
+ *								*
+ *	realloc - resize a block, copy if necessary		*
+ *								*
+ ****************************************************************/
+
+public char *
+realloc (mem, n)
+     char *mem;
+     register unsigned n;
+{
+  register struct mhead *p;
+  register unsigned int tocopy;
+  register int nbytes;
+  register int nunits;
+#ifdef MALLOC_DEBUG
+  char *PAPA = *(char **)((&mem)-2);
+#endif MALLOC_DEBUG
+
+  if ((p = (struct mhead *) mem) == 0)
+    return malloc (n);		/* well, shouldn't realloc(NULL) anyway... */
+  p--;
+#ifdef MALLOC_DEBUG
+  p -> mh_parent = PAPA;
+#endif MALLOC_DEBUG
+  nunits = p -> mh_index;
+  ASSERT (p -> mh_alloc == ISALLOC);
+  tocopy = p -> mh_nbytes;
+#ifdef rcheck
+  ASSERT (p -> mh_magic4 == MAGIC4);
+  {
+    register char *m = mem + tocopy;
+#ifdef scribblecheck
+    register char *en = (8<<p->mh_index) + (char *)p;
+    register int block_valid = 0;
+    while(m<en && (block_valid=(*m++==MAGIC1)));
+    if (!block_valid) botch ("out of bounds data on realloc");
+#else /* scribblecheck */
+    ASSERT (*m++ == MAGIC1); ASSERT (*m++ == MAGIC1);
+    ASSERT (*m++ == MAGIC1); ASSERT (*m   == MAGIC1);
+#endif /* scribblecheck */
+  }
+#endif /* not rcheck */
+
+  /* See if desired size rounds to same power of 2 as actual size. */
+  nbytes = (n + sizeof *p + EXTRA + 7) & ~7;
+
+  /* If ok, use the same block, just marking its size as changed.  */
+  if (nbytes > (4 << nunits) && nbytes <= (8 << nunits))
+    {
+      /* Here we check on realloc if we are grabbing unused space */
+#ifdef rcheck
+      register char *m = mem + tocopy;
+#ifdef scribblecheck
+      register char *en = (8<<p->mh_index) + (char *) p;
+      while (m<en) *m++=(char)0;
+#else /* scribblecheck */
+      *m++ = 0;  *m++ = 0;  *m++ = 0;  *m++ = 0;
+#endif /* scribblecheck */
+      m = mem + n;
+#ifdef scribblecheck
+      while(m<en) *m++ = MAGIC1;
+#else /* scribblecheck */
+      *m++ = MAGIC1;  *m++ = MAGIC1;  *m++ = MAGIC1;  *m++ = MAGIC1;
+#endif /* scribblecheck */
+#endif /* not rcheck */
+      p-> mh_nbytes = n;
+      return mem;
+    }
+
+  if (n < tocopy)
+    tocopy = n;
+  {
+    register char *new;
+
+    if ((new = malloc (n)) == 0)
+      return 0;
+    bcopy (mem, new, tocopy);
+    free (mem);
+    return new;
+  }
+}
+
+/****************************************************************
+ *								*
+ *	Memory Statistics stuff					*
+ *								*
+ ****************************************************************/
+
+#ifdef MSTATS
+/* Return statistics describing allocation of blocks of size 2**n. */
+
+#ifndef public
+struct mstats_value
+  {
+    int blocksize;
+    int nfree;
+    int nused;
+  };
+#endif public
+
+public struct mstats_value
+malloc_stats (size)
+     int size;
+{
+	struct mstats_value v;
+	register int i;
+	register struct mhead *p;
+
+	v.nfree = 0;
+
+	if (size < 0 || size >= NBUCKETS) {
+		v.blocksize = 0;
+		v.nused = 0;
+		return v;
+	}
+
+	v.blocksize = 1 << (size + 3);
+	v.nused = nmalloc[size];
+
+	for (p = nextf[size]; p; p = CHAIN (p))
+		v.nfree++;
+
+	return v;
+}
+
+/*
+ * showall - print out statistics about malloc
+ * 
+ * Prints two lines of numbers, one showing the length of the free list
+ * for each size category, the second showing the number of mallocs -
+ * frees for each size category.
+ */
+showall(v)
+	char **v;
+{
+  	register int i, j;
+  	register struct mhead *p;
+  	int totfree = 0,
+  	totused = 0;
+
+  	printf("tcsh memory allocation statistics\nfree:\t");
+  	for (i = 0; i < NBUCKETS; i++) {
+		j=0;
+  		for (p = nextf[i]; p; p = CHAIN(p))
+  			j++;
+  		printf(" %4d", j);
+  		totfree += j * (1 << (i + 3));
+  	}
+  	printf("\nused:\t");
+  	for (i = 0; i < NBUCKETS; i++) {
+  		printf(" %4d", nmalloc[i]);
+  		totused += nmalloc[i] * (1 << (i + 3));
+  	}
+  	printf("\n\tTotal in use: %d, total free: %d\n",
+	    totused, totfree);
+}
+#endif
+
+/****************************************************************
+ *								*
+ *	Stuff having to do with determining memory limits	*
+ *								*
+ ****************************************************************/
+
+/*
+ *	This function returns the total number of bytes that the process
+ *	will be allowed to allocate via the sbrk(2) system call.  On
+ *	BSD systems this is the total space allocatable to stack and
+ *	data.  On USG systems this is the data space only.
+ */
+
+#ifdef USG
+
+public get_lim_data ()
+{
+  extern long ulimit ();
+    
+  lim_data = ulimit (3, 0);
+  lim_data -= (long) data_space_start;
+}
+
+#else /* not USG */
+#ifndef BSD42
+
+public get_lim_data ()
+{
+  lim_data = vlimit (LIM_DATA, -1);
+}
+
+#else /* BSD42 */
+
+public get_lim_data ()
+{
+  struct rlimit XXrlimit;
+
+  getrlimit (RLIMIT_DATA, &XXrlimit);
+  lim_data = XXrlimit.rlim_cur;		/* soft limit */
+}
+
+#endif /* BSD42 */
+#endif /* not USG */
+#ifdef MALLOC_DEBUG
+/*
+ Here we have the interesting dump routines to describe the inner
+ state of malloc.
+ */
+
+#include <a.out.h>
+#include <stab.h>
+#include <sys/file.h>
+
+/*
+ * malloc_dump_all --- displays what routines malloced what and when.
+ *
+ * This is a gross kludge.  However, it's wonderful for finding memory
+ * leaks and other malloc problems.  
+ */
+malloc_dump_all(file)
+     char *file;
+{
+  int fd;
+  struct mhead *p;
+  struct exec base;
+  struct nlist *nls;
+  int numsyms;
+  char *strtab;
+  int strtablen;
+  int stat;
+
+  printf("Dumping state:\n");
+
+  fd = open(file, O_RDONLY, 0777); /* open the binary */
+  if(fd<0) 
+    {
+      perror("malloc_dump_all:open");
+      return;
+    }
+
+  stat = lseek(fd, 0L, L_SET);	/* seek (redundant... for later) */
+  if(stat < 0)
+    {
+      perror("malloc_dump_all:initseek");
+      return;
+    }
+
+  stat = read(fd, &base, sizeof(base));	/* read in base block */
+  if(stat <= 0)
+    {
+      perror("malloc_dump_all:read");
+      return;
+    }
+
+  stat = lseek(fd, N_SYMOFF(base), L_SET); /* seek to symtab */
+  if(stat < 0)
+    {
+      perror("malloc_dump_all:symseek");
+      return;
+    }
+  nls = (struct nlist *)malloc(base.a_syms);
+  numsyms = base.a_syms / sizeof(struct nlist);
+
+  stat = read(fd, nls, base.a_syms);	/* read in symtab */
+  if(stat <= 0)
+    {
+      perror("malloc_dump_all:symread");
+      return;
+    }
+
+  stat = lseek(fd, N_STROFF(base), L_SET); /* seek to string table */
+  if(stat < 0)
+    {
+      perror("malloc_dump_all:seekstrtab");
+      return;
+    }
+
+  stat = read(fd, &strtablen, sizeof(strtablen)); /* read stringtable len */
+  if(stat <= 0)
+    {
+      perror("malloc_dump_all:readstrtablen");
+      return;
+    }
+  strtab = malloc(strtablen);
+
+  stat = read(fd, strtab, strtablen); /* read in stringtable */
+  if(stat <= 0)
+    {
+      perror("malloc_dump_all:readstrtab");
+      return;
+    }
+
+  for(p = baselink; p != endlink; p = p -> mh_link)
+    {
+      find_sym(nls, numsyms, strtab, p -> mh_parent);
+      switch (p -> mh_alloc) {
+      case ISALLOC:
+	      printf(" allocated %d bytes\n",p->mh_nbytes);
+	      break;
+      case ISFREE:
+	      printf(" freed block\n");
+	      break;
+      default:
+	      printf(" invalid block (%d)\n", p-> mh_nbytes);
+	      break;
+      }
+    }
+  flush(stdout);
+  free(strtab);
+  free(nls);
+  printf("Done dumping state.\n");
+}
+
+find_sym(nls, numsyms, strs, par)
+     struct nlist *nls;
+     int numsyms;
+     char *strs;
+     char *par;
+{
+  int sym, stat;
+  int last;
+  int tfile=0, tf0=0;
+  char *x;
+
+  x = par;
+
+  sym = -1;
+  while(++sym < numsyms)
+    {
+      switch(nls[sym].n_type)
+	{
+	case N_TEXT:
+	case N_SO:
+	  tf0 = tfile;
+	  tfile = nls[sym].n_un.n_strx;
+	case N_SLINE:
+	  if(((char *)nls[sym].n_value) > x)
+	    {
+	      sym = numsyms;
+	    }
+	  else
+	    {
+	      last = nls[sym].n_desc;
+	    }
+	  break;
+	default:
+	  break;
+	}
+    }
+
+
+  printf("\"%s\", line %d: Address[0x%x]", strs+tf0-sizeof(int), last, x);
+
+}
+#endif MALLOC_DEBUG