/*
 * ide memory allocation routines
 *
 * All memory is allocated from static pools.
 *
 */

#include "ide.h"
#ident "gfx/common/ide/ide_alloc.c $Revision: 1.1.1.1 $"

#define NEWSYMC 4096	/* total number of symbol records */
#define NEWNODEC 16384	/* total number of node records */

#define NSTR1 2048	/* size of 16 character string pool */
#define NSTR2 1024	/* size of 32 character string pool */
#define NSTR3 512	/* size of 64 character string pool */
#define NSTR4 256	/* size of 128 character string pool */
#define NSTR5 128	/* size of 256 character string pool */

sym_t	*freesym = 0;	/* list of freed symbol records */
sym_t	newsym[NEWSYMC];/* symbol record pool */
int	newsymc = 0;	/* index into newsym */

node_t	*freenode = 0;	/* list of freed node records */
node_t	newnode[NEWNODEC];/* node record pool */
int	newnodec = 0;	/* index into newnode */

/*
 * The following arrays are used for string allocation.
 * Strings are allocated on a best fit of a fixed length
 * storage block. A null byte in the first position of an
 * allocation string indicates that the string is free.
 */
char	string1[NSTR1][16];
char	string2[NSTR2][32];
char	string3[NSTR3][64];
char	string4[NSTR4][128];
char	string5[NSTR5][256];

int	last1 = 0;	/* last string allocated from string1 */
int	last2 = 0;	/*  "     "        "      "   string2 */
int	last3 = 0;	/*  "     "        "      "   string3 */
int	last4 = 0;	/*  "     "        "      "   string4 */
int	last5 = 0;	/*  "     "        "      "   string5 */

int	nstr1 = 0;
int	nstr2 = 0;
int	nstr3 = 0;
int	nstr4 = 0;
int	nstr5 = 0;

int	nnodes = 0;
int	nsyms  = 0;

showmstats()
{
	printf("strings: 16 x %d, 32 x %d, 64 x %d, 128 x %d, 256 x %d\n",
		nstr1, nstr2, nstr3, nstr4, nstr5);

	printf("symbols: %d out of %d used.\n", nsyms, NEWSYMC);
	printf("nodes: %d out of %d used.\n", nnodes, NEWNODEC);
}

/*
 * descend a parse tree freeing each node
 *
 * The descent path must match the tree pattern created in ide_gram.y
 *
 */
destroytree(pnode)
node_t *pnode;
{
	if ( ! pnode )
		return;

	switch ( pnode->node_type ) {
		case OP_STMT:
			destroytree( pnode->node_right);
			destroytree( pnode->node_left);
			break;
		case OP_PRINT:
			destroyexpr(pnode->node_left);
			destroynode(pnode);
			break;
		case OP_IF:
			destroyif(pnode);
			break;
		case OP_WHILE:
			destroywhile(pnode);
			break;
		case OP_FOR:
			destroyfor(pnode);
			break;
		case OP_RETURN:
			destroynode(pnode);
			break;
		case OP_BREAK:
			destroynode(pnode);
			break;
		case OP_CONTINUE:
			destroynode(pnode);
			break;
		case OP_DO:
			destroywhile(pnode);
			break;
		case OP_SWITCH:
			destroyswitch(pnode);
			break;
		case OP_CMD:
			destroycmd(pnode);
			break;
		case OP_REPEAT:
			destroyrepeat(pnode);
			break;
		default:
			destroyexpr(pnode);
			break;
		}
}

destroyrepeat(pnode)
node_t *pnode;
{
	destroytree(pnode->node_right);
	destroysym(pnode->node_psym);
	destroynode(pnode);
}
destroycmd(pnode)
node_t *pnode;
{

	destroyargv(pnode->node_right);
	destroynode(pnode);
}

destroyargv(pnode)
node_t *pnode;
{
	if ( ! pnode )
		return;

	destroyargv(pnode->node_right);
	destroyexpr(pnode->node_left);
	destroynode(pnode);
}
destroyswitch(pnode)
node_t *pnode;
{

	destroysym(pnode->node_psym);
	destroycaselist(pnode->node_right);
	destroynode(pnode);

}

destroycaselist( pnode )
node_t *pnode;
{
	if ( ! pnode )
		return;

	if ( pnode->node_type == OP_CASELIST ) {
		destroycaselist( pnode->node_right );
		pnode = pnode->node_left;
		}
	
	if ( pnode->node_psym )
		destroysym(pnode->node_psym);
	
	destroytree( pnode->node_right );
}

destroyif(pnode)
node_t *pnode;
{
	destroyexpr(pnode->node_left);
	if ( pnode->node_right->node_type == OP_ELSE ) {
		destroytree(pnode->node_right->node_left);
		destroytree(pnode->node_right->node_right);
		}
	
	destroynode(pnode->node_right);
	destroynode(pnode);
}

destroyfor(pnode)
node_t *pnode;
{
	node_t *n1 = pnode->node_left->node_left;
	node_t *n2 = pnode->node_left->node_right;
	node_t *n3 = pnode->node_right->node_left;
	node_t *n4 = pnode->node_right->node_right;

	if (n1) destroyexpr(n1);
	if (n2) destroyexpr(n2);
	if (n3) destroyexpr(n3);
	destroytree(n4);

	destroynode(pnode->node_left);
	destroynode(pnode->node_right);
	destroynode(pnode);
}

destroywhile(pnode)
node_t *pnode;
{
	destroyexpr(pnode->node_left);
	destroytree(pnode->node_right);
	destroynode(pnode);
}

destroyexpr(pnode)
node_t *pnode;
{
	if ( ! pnode )
		return;

	switch(pnode->node_type) {
		case OP_SHL:	case OP_SHR:
		case OP_ADD:	case OP_SUB:
		case OP_MUL:	case OP_DIV:
		case OP_MOD:	case OP_LT:	case OP_LE:
		case OP_GT:	case OP_GE:	case OP_EQ:	case OP_NE:
		case OP_OR:	case OP_AND:	case OP_ANDAND:	case OP_OROR:
			destroyexpr(pnode->node_right);
			destroyexpr(pnode->node_left);
			break;
		case OP_ASSIGN:
		case OP_ADDASS: case OP_SUBASS:
		case OP_MULASS: case OP_DIVASS: case OP_MODASS:
		case OP_SHLASS: case OP_SHRASS:
		case OP_ANDASS: case OP_ORASS:
			destroyexpr(pnode->node_right);
			/* Assignments are only made to things in the
			   symbol table so
			   destroysym(pnode->node_psym); is not necessary */
			break;
		case OP_UMINUS:
		case OP_COM:
		case OP_NOT:
			destroyexpr(pnode->node_right);
			break;
		case OP_PRED:
		case OP_PREI:
		case OP_POSTD:
		case OP_POSTI:
			break;
		case OP_VAR:
			destroysym(pnode->node_psym);
			break;
		case OP_FCALL:
		case OP_ARGLIST:
			break;
		}

	destroynode(pnode);
}

/*
 * destroyed nodes are put at the head of the free list
 *
 */
destroynode(pnode)
node_t *pnode;
{
	nnodes--;
	pnode->node_right = freenode;
	freenode = pnode;
	return;
}

/*
 * destroyed symbols are put at the head of the free list
 *
 */
destroysym(psym)
sym_t *psym;
{
	/* symbols with names are permanent */
	if ( psym->sym_flags & SYM_INTABLE )
		return;

	nsyms--;

	if ( psym->sym_basetype == SYM_STR )
		destroystr(psym->sym_s);
	
	psym->sym_hlink = freesym;
	freesym = psym;

	return;
}

/*
 * free a string by setting its string table allocation byte
 * to null.
 */
destroystr(s)
char *s;
{
	if ( ! s )
		return;

	if ( *(s-1) == '1' )
		nstr1--;
	else
	if ( *(s-1) == '2' )
		nstr2--;
	else
	if ( *(s-1) == '3' )
		nstr3--;
	else
	if ( *(s-1) == '4' )
		nstr4--;
	else
	if ( *(s-1) == '5' )
		nstr5--;
	else
		ide_panic("Bad call to destroystr");

	*(s-1) = '\0';
}

/*
 * create a new symbol record by either taking one off of the free list
 * or getting another one out of the pool.
 *
 */
sym_t *
makesym()
{
	sym_t *tmp;

	nsyms++;


	if ( freesym ) {
		tmp = freesym;
		freesym = tmp->sym_hlink;
		tmp->sym_indx	= 0;
		tmp->sym_basetype = 0;
		tmp->sym_type	= 0;
		tmp->sym_i	= 0;
		tmp->sym_hlink	= 0;
		tmp->sym_flags  = 0;
		return tmp;
		}
	

	if ( newsymc <  NEWSYMC )
		return &newsym[newsymc++];
	else
		ide_panic("Out of symbols\n");
}

/*
 * same algorithm as above for nodes
 */
node_t *
makenode()
{
	node_t *tmp;

	nnodes++;

	if ( freenode ) {
		tmp = freenode;
		freenode = tmp->node_right;
		tmp->node_type  = 0;
		tmp->node_right = 0;
		tmp->node_left  = 0;
		return tmp;
		}
	
	if ( newnodec < NEWNODEC )
		return &newnode[newnodec++];
	else
		ide_panic("Out of nodes\n");
}
/*
 * allocate space for string
 *
 * A best fit out of 5 possible pools algorithm is used.  The
 * -1 position of the string stores a status byte, null indicates
 * that the string is free.
 *
 */
char *
talloc(len)
int len;
{
	int i;
	char *t;

	len += 1;
	if ( len <= 16 )
		for ( i = last1; i < last1+NSTR1; i++ )
			if ( string1[i % NSTR1][0] == '\0' ) {
				last1 = i % NSTR1;
				t = &string1[last1][1];
				string1[last1][0] = '1';
				nstr1++;
				return t;
				}

	if ( len <= 32 )
		for ( i = last2; i < last2+NSTR2; i++ )
			if ( string2[i % NSTR2][0] == '\0' ) {
				last2 = i % NSTR2;
				t = &string2[last2][1];
				string2[last2][0] = '2';
				nstr2++;
				return t;
				}

	if ( len <= 64 )
		for ( i = last3; i < last3+NSTR3; i++ )
			if ( string3[i % NSTR3][0] == '\0' ) {
				last3 = i % NSTR3;
				t = &string3[last3][1];
				string3[last3][0] = '3';
				nstr3++;
				return t;
				}

	if ( len <= 128 )
		for ( i = last4; i < last4+NSTR4; i++ )
			if ( string4[i % NSTR4][0] == '\0' ) {
				last4 = i % NSTR4;
				t = &string4[last4][1];
				string4[last4][0] = '4';
				nstr4++;
				return t;
				}

	if ( len <= NSTR5 )
		for ( i = last5; i < last5+NSTR5; i++ )
			if ( string5[i % NSTR5][0] == '\0' ) {
				last5 = i % NSTR5;
				t = &string5[last5][1];
				string5[last5][0] = '5';
				nstr5++;
				return t;
				}
	
	ide_panic("Out of string space");
}
/*
 * get space for a string and copy into it
 */
char *
makestr(s)
char *s;
{
	int len = strlen(s);
	char *t;

	t = talloc(len+1);

	strcpy(t, s);

	return t;
}
/*
 * get space for a pair of strings (to be concatenated together) and 
 * copy into it
 */
char *
makecatstring(s1, s2)
char *s1, *s2;
{
	int len = strlen(s1) + strlen(s2);
	char *t;

	t = talloc(len+1);

	strcpy(t, s1);
	strcat(t, s2);

	return t;
}
ide_panic(s)
char *s;
{
	printf("ide panic: %s\n",s);
	exit(1);
}
/*
 * make a symbol out of an integer
 *
 */
sym_t *
makeisym(i)
int i;
{
	sym_t *tmp = makesym();

	tmp->sym_basetype = SYM_INT;
	tmp->sym_type = SYM_CON;
	tmp->sym_i = i;

	return tmp;
}
/*
 * make a symbol out of a string
 *
 */
sym_t *
makessym(s)
char *s;
{
	sym_t *tmp = makesym();

	tmp->sym_basetype = SYM_STR;
	tmp->sym_type = SYM_CON;
	tmp->sym_s = s;

	return tmp;
}