/* asmalloc.c -- microsoft 80x86 assembler
**
** microsoft (r) macro assembler
** copyright (c) microsoft corp 1986, 1987.  all rights reserved
**
** randy nevin
** michael hobbs 7/87
** 10/90 - Quick conversion to 32 bit by Jeff Spencer
**
** Storage allocation/deallocation
**
**	dalloc, dfree
**	talloc, tfree
**	nearalloc, faralloc, pBCBalloc, freefarbuf
 */

#include <stdio.h>
#include "asm86.h"
#include "asmfcn.h"

/*
 *	dalloc/dfree
 *
 *	Allocation/deallocation of descriptor nodes.  Uses a list of
 *	deallocated descriptors available for allocation.
 */

/* dscfree list descriptor */

struct dscfree {
	struct dscfree	*strnext;	/* next string in list */
	UCHAR		size;		/* allocated size      */
	UCHAR		text[1];	/* text of string      */
	};
static struct dscfree *dscrfree = (struct dscfree *)NULL;

#define nearheap(fp) ((int)(((long)(char far *)&pcoffset) >> 16) == highWord(fp))

/*
 *	dalloc - allocate descriptor from temporary list
 */

DSCREC * PASCAL CODESIZE
dalloc (
){
	register struct dscfree *t;

	if (!(t = dscrfree))
	     t = (struct dscfree *)nalloc( sizeof(DSCREC), "dalloc");
	else
	    dscrfree = t->strnext;

	return((DSCREC *)t);
}



/*
 *	dfree - return descriptor to free list
 */

VOID PASCAL CODESIZE
dfree (
	UCHAR *p
){
	register struct dscfree *tp;

	tp = (struct dscfree *)p;
	tp->strnext = dscrfree;
	dscrfree = tp;
}



/*
 *	talloc, tfree
 *
 *	Allocation\deallocation of memory.
 *	Allocation is made with minimum size of TEMPMAX bytes.
 *	Any allocation request for <= TEMPMAX bytes will be made
 *	by grabbing a block off the free list.	Deallocation of these
 *	blocks returns them to the free list.  For blocks larger than
 *	TEMPMAX bytes, nalloc() and free() are called.
 */

#define TEMPMAX 32

static TEXTSTR FAR *tempfree = (TEXTSTR FAR *)NULL;


#ifndef M8086

/*
 *	talloc - allocate space from temporary list
 */

UCHAR * PASCAL
talloc(
	UINT nbytes
){
	register TEXTSTR *t;

	if (nbytes > TEMPMAX)
		t = (TEXTSTR *) nalloc(nbytes, "talloc");
	else if (!(t = tempfree))
		t = (TEXTSTR *) nalloc (TEMPMAX, "talloc");

	else
	    tempfree = t->strnext;

	return ((UCHAR *)t);
}


/*
 *	tfree - return temp allocation to free list
 */
VOID PASCAL
tfree (
      UCHAR *ap,
      UINT nbytes
){
	register TEXTSTR *tp;

	if (nbytes > TEMPMAX)
		free (ap);
	else {
		tp = (TEXTSTR *)ap;
		tp->strnext = tempfree;
		tempfree = tp;
	}
}

#else

/*
 *	talloc - allocate space from temporary list
 */

UCHAR FAR * PASCAL CODESIZE
talloc(
	USHORT nbytes
){
	TEXTSTR FAR *t;

	if (nbytes > TEMPMAX)
		t = (TEXTSTR FAR *) falloc(nbytes, "talloc");
	else if (!(t = tempfree))
		t = (TEXTSTR FAR *) falloc(TEMPMAX, "talloc");

	else
		tempfree = t->strnext;

	return ((UCHAR FAR *)t);
}

/*
 *	tfree - return temp allocation to free list
 */
VOID PASCAL CODESIZE
tfree (
	UCHAR FAR *ap,
	UINT nbytes
){
	register TEXTSTR FAR *tp;

	if (nbytes > TEMPMAX)
		_ffree (ap);
	else {
		tp = (TEXTSTR FAR *)ap;
		tp->strnext = tempfree;
		tempfree = tp;
	}
}

#endif /* NOT M8086 */




#ifndef M8086

/****	nearalloc - normal near memory allocation
 *
 *	nearalloc (usize, szfunc)
 *
 *	Entry	usize = number of bytes to allocate
 *		szfunc = name of calling routine
 *	Returns Pointer to block if successful
 *	Calls	malloc(), memerror()
 *	Note	Generates error if malloc unsuccessful
 *		IF NOT M8086, nalloc AND falloc MAP TO THIS FUNCTION
 */

UCHAR * CODESIZE PASCAL
nearalloc(
    UINT usize,
    char * szfunc
){
    register char * pchT;

    if (!(pchT = malloc(usize)))
	memerror(szfunc);

    return(pchT);
}


#else


/****	nearalloc - normal near memory allocation
 *
 *	nearalloc (usize)
 *
 *	Entry	usize = number of bytes to allocate
 *	Returns Pointer to block if successful
 *	Calls	malloc(), memerror()
 *	Note	Generates error if malloc unsuccessful
 */

UCHAR * CODESIZE PASCAL
nearalloc(
    USHORT usize
){
    register char * pchT;

    if (!(pchT = malloc(usize)))
	outofmem();

    return(pchT);
}



/****	faralloc - Routine for normal far memory allocation
 *
 *	faralloc (usize)
 *
 *	Entry	usize = number of bytes to allocate
 *	Returns Pointer to block if successful
 *	Calls	_fmalloc(), nearheap(), freefarbuf(), memerror(), _ffree()
 *	Note	Should call instead of _fmalloc(),
 *		at least after the first call to pBCBalloc() has been made.
 *		Not called by pBCBalloc.
 *		Generates error if memory full
 */

UCHAR FAR * CODESIZE PASCAL
faralloc(
    USHORT usize
){
    char FAR * fpchT;

#ifdef BCBOPT
    /* need check of _fmalloc 'ing into near heap too */

    while ( (!(fpchT = _fmalloc(usize)) || nearheap(fpchT)) && pBCBAvail) {

	fBuffering = FALSE;		/* can't buffer any more */

	if (fpchT)
	    _ffree(fpchT);

	freefarbuf();
    }
#endif

#ifdef FLATMODEL   /* If 32 bit small model then use normal malloc */
    fpchT = malloc(usize);
#else
    fpchT = _fmalloc(usize);
#endif
    if (!fpchT)
	outofmem();

    return (fpchT);
}



#ifdef BCBOPT
/****	pBCBalloc - allocate a BCB and associated buffer
 *
 *	pBCBalloc ()
 *
 *	Entry	fBuffering must be TRUE
 *	Returns pointer to BCB (connected to buffer if bufalloc() successful)
 *	Calls	bufalloc()
 *	Note	Returns a BCB even if buffer allocation fails
 *		Returns NULL only after Out-of-memory error
 */

BCB * FAR PASCAL
pBCBalloc(
    UINT cbBuf
){
    register BCB * pBCBT;
    char FARIO * pfchT;

    pBCBT = (BCB *) nearalloc(sizeof(BCB));

#ifndef XENIX286

    if ((pfchT = _fmalloc(cbBuf)) && nearheap(pfchT)) {

	_ffree(pfchT);
	pfchT = NULL;
    }

    if (!(pfchT)) 
#else
	pfchT = NULL;
#endif

    {

	fBuffering = FALSE;	    /* can't buffer anymore */
	pBCBT->filepos = 0;

    } 
#ifndef XENIX286
    else {

	pFCBCur->cbufCur = cbBuf;
	pBCBT->pBCBPrev = pBCBAvail;
	pBCBAvail = pBCBT;
    }
#endif

    pFCBCur->pbufCur = pBCBT->pbuf = pfchT;
    pBCBT->pBCBNext = NULL;
    pBCBT->fInUse = 0;
    return(pBCBT);
}
#endif //BCBOPT

#ifdef BCBOPT
/****	freefarbuf - free a file buffer
 *
 *	freefarbuf ()
 *
 *	Entry
 *	Returns
 *	Calls	_ffree()
 *	Note	Frees the last-allocated file buffer
 */

freefarbuf(
){

    while (pBCBAvail && pBCBAvail->fInUse)
	pBCBAvail = pBCBAvail->pBCBPrev;

    if (pBCBAvail) {
#ifdef XENIX286
	free(pBCBAvail->pbuf);
#else
	_ffree(pBCBAvail->pbuf);
#endif
	pBCBAvail->pbuf = NULL;
	pBCBAvail = pBCBAvail->pBCBPrev;
    }
}
#endif //BCBOPT
#endif /* M8086 */





#if 0

/*	sleazy way to check for valid heap
 *	_mcalls tells how calls to malloc were made so that
 *	a countdown breakpoint can be set for _mcalls iterations
 */

extern	char *_nmalloc();

long _mcalls;

UCHAR *
malloc (
	UINT n
){
	register UINT fb;
	fb = _freect(0);      /* walks near heap - usually loops if corrupt */
	_mcalls++;
	return (_nmalloc(n));
}

#endif /* 0 */