/*
 * alloc: heap allocation routines
 *
 * zmark()
 * zrelease()
 * zalloc()
 * zfile()
 * zmrealloc()
 * zunalloc()
 * zstrdup()
 */
#include <stdio.h>
#include "tsh.h"

extern char *mmalloc();
extern char *mrealloc();
extern void mfree();

typedef struct {
    char *ptr;
    int   flag;
#define ISAFILE	0x01	/* this ptr points at a internal file that we */
			/* need to kill */
} mark;

static mark *markarray=(mark*)0;
static int   markcount=0;

/*
 * zmark() sets a heap mark
 */
zmark()
{
    fprintf(stderr, "mark %d\n", markcount);
    return markcount;
} /* zmark */


/*
 * zrelease() mfrees all memory since a zmark
 */
zrelease(mk)
{
    register i;

    fprintf(stderr, "release to %d\n", mk);
    for (i=mk; i<markcount; i++)
	if (markarray[i].ptr) {
	    if (markarray[i].flag & ISAFILE)
		unlink(markarray[i].ptr);
	    mfree(markarray[i].ptr);
	}
    markarray = (mark*)mrealloc(markarray, mk*sizeof(markarray[0]));
    markcount = mk;
} /* zrelease */


/*
 * zalloc()
 */
char *
zalloc(size)
{
    register char *tmp;

    markarray = (mark*)mrealloc(markarray, (1+markcount)*sizeof(markarray[0]));
    if (markarray == (mark*)0) {
	fprintf(stderr, "zalloc heap failure!\n");
	raise(ABORT);
    }
    markarray[markcount].flag = 0;
    markarray[markcount].ptr = tmp = mmalloc(size);
    markcount++;
    if (tmp)
	return tmp;
    fprintf(stderr, "out of memory\n");
    raise(ABORT);
} /* zalloc */


/*
 * zfile(): allocate memory for a file
 */
char *
zfile(size)
{
    register char *tmp = zalloc(size);
    
    markarray[markcount-1].flag |= ISAFILE;
    return tmp;
} /* zfile */


/*
 * zmrealloc(): mreallocates memory on the heap
 */
char *
zmrealloc(ptr, size)
register char *ptr;
{
    register i;

    for (i=0; i<markcount; i++)
	if (markarray[i].ptr == ptr) {
	    if ((ptr=markarray[i].ptr = mrealloc(ptr, size)) == (char*)0) {
		fprintf(stderr, "out of memory\n");
		raise(ABORT);
	    }
	    return ptr;
	}
    fprintf(stderr, "zmrealloc bad memory\n");
    raise(ABORT);
} /* zmrealloc */


/*
 * zunalloc(): mfrees memory
 */
zunalloc(ptr)
register char *ptr;
{
    register i;

    for (i=0; i<markcount; i++)
	if (ptr == markarray[i].ptr) {
	    mfree(ptr);
	    markarray[i].ptr = 0;
	    return;
	}
    fprintf(stderr, "zunalloc bad memory\n");
    raise(ABORT);
} /* zunalloc */


/*
 * zstrdup(): strdup using zalloc()
 */
char *
zstrdup(str)
register char *str;
{
    register char *tmp;

    tmp = zalloc(strlen(str)+1);
    strcpy(tmp, str);
    return tmp;
} /* zstrdup */