/*
 * ide_run - Execute an ide parse tree
 *
 * $Revision: 1.1.1.1 $
 */

#include "ide.h"
#include "diag.h"

#include <getopt.h>

struct diagComm *pGlobalComm;
/*
 * Globals to be shared between ide and errlog().
 */
int errNumbers[120];
int errIndex;

char *ideTestName;

/* 
 * dostmt - Top level entry point
 *
 * Establishes a context for "return" statements and initiates execution.
 *
 */

context_t global_context;

/*
 * Create a global context for ide
 *
 * The $0..$n paramters are set up to be the same as the command
 * line arguments to ide.
 *
 */
init_context(argc,argv)
int argc;
char *argv[];
{
	int i;

	for ( i = 0; i < argc; i++ ) {
		global_context.argv[i] = makessym(argv[i]);
		global_context.argc++;
		}
}
/*
 *  handle interrupt - let ide scripts see and react to ^c
 *
 * Whenever ^C is pressed, the user defined function "trap"
 * is executed.  The trap function may be used to reset tty
 * or graphics or anything else.
 */
handle_interrupt()
{
	sym_t *psym;
	node_t *pnode;

	if ( (psym = findsym("trap")) && psym->sym_type == SYM_CMD ) {
		pnode = makenode();
		pnode->node_psym = psym;
		pnode->node_type = OP_CMD;
		dostmt(pnode);
		destroynode(pnode);
		}
}
/*
 * Top level entry point into command executor
 *
 */
dostmt(pnode)
node_t *pnode;
{

	if ( setjmp(global_context.rframe) )
		return;

	dotree(&global_context, pnode);

	return;
}
/*
 * dotree - execute a tree within a given context
 *
 */
dotree(context, pnode)
node_t *pnode;
context_t *context;
{
#ifdef STANDALONE
	_scandevs();
#endif

	if ( ! pnode )
		return;

	switch ( pnode->node_type ) {
		case OP_STMT:
			dotree(context, pnode->node_right);
			dotree(context, pnode->node_left);
			break;
		case OP_PRINT:
			doprint(context, pnode);
			break;
		case OP_IF:
			doif(context, pnode);
			break;
		case OP_WHILE:
			dowhile(context, pnode);
			break;
		case OP_FOR:
			dofor( context, pnode);
			break;
		case OP_DO:
			dodo( context, pnode);
			break;
		case OP_RETURN:
			doreturn(context,pnode);
			break;
		case OP_BREAK:
			longjmp(context->lframe, 2);
			break;
		case OP_CONTINUE:
			longjmp(context->lframe, 3);
			break;
		case OP_SWITCH:
			doswitch(context,pnode);
			break;
		case OP_REPEAT:
			dorepeat(context,pnode);
			break;
		default:
			destroysym(eval(context, pnode));
			break;
		}
}
/*
 * Promote symbol to integer
 *
 * This routine is used whenever the context of an expression requires
 * an integer and we don't have one.  If the symbol is a string, this
 * routine will try to figure out if it looks like a string of digits
 * and then converts it to binary (like awk).
 *
 */
sym_t *
pro_int(psym)
sym_t *psym;
{
	sym_t *tmp;
	int	v = 0;
	int	base = 10;
	char	*p;

	if ( psym->sym_basetype == SYM_INT )
		return psym;
	
	tmp = makesym();
	tmp->sym_basetype = SYM_INT;

	if ( psym->sym_basetype == SYM_STR ) {
		p = psym->sym_s;
		if ( *p == '0' ) {
			base = 8;
			p++;
			if ( *p == 'x' || *p == 'X' ) {
				base = 16;
				p++;
				}
			else
			if ( *p == 'b' || *p == 'B' ) {
				base = 2;
				p++;
				}
			}
		for ( ;isxdigit( *p ); p++ )
			if ( *p > '9' && base < 16 )
				break;
			else
			if ( *p >= 'a' && *p <= 'f' )
				v = (v * base) + (*p - 'a') + 10;
			else
			if ( *p >= 'A' && *p <= 'F' )
				v = (v * base) + (*p - 'A') + 10;
			else
			if ( (*p - '0') >= base )
				break;
			else
				v = (v * base) + (*p - '0');
		if ( *p )
			v = 0;
		tmp->sym_i = v;
		}
	
	destroysym(psym);

	return tmp;
}
/*
 * promote to string
 *
 * This routine is called whenever a string is needed.  It is much simpler
 * to convert to strings than to integers.
 */
sym_t *
pro_str(psym)
sym_t *psym;
{
	sym_t	*tmp;
	char	v[MAXSTRLEN];
	char	r[32];
	int	rp  = 0;
	char	*vp = v;
	int	p;

	if ( psym->sym_basetype == SYM_STR )
		return psym;
	
	tmp = makesym();
	tmp->sym_basetype = SYM_STR;

	if ( psym->sym_basetype == SYM_INT ) {
		if ( (p = psym->sym_i) < 0 ) {
			*vp++ = '-';
			p = -p;
			}
		do	{
			r[rp++] = (p % 10)+'0';
			p /= 10;
			} while ( p );
		while ( --rp >= 0 )
			*vp++ = r[rp];
		*vp = '\0';
		tmp->sym_s = makestr(v);
		}
	
	destroysym(psym);

	return tmp;
}
/*
 * docmd - run a command or function.
 *
 * There are two different types of commands:
 *  1. Those defined by the user as an ide function
 *  2. Those defined by ide as builtins.
 *
 */
sym_t *
docmd(context, pnode)
node_t *pnode;
context_t *context;
{
	context_t ccontext;
	sym_t *cmd = pnode->node_psym;
	sym_t *vsym = makesym();
	int i;
	int rc;

	ccontext = *context;

	if ( rc = setjmp(ccontext.rframe) ) {
		--rc;
		goto exit;
		}

	ccontext.argc = makeargv(context, pnode->node_right, ccontext.argv+1)+1;
	ccontext.argv[0] = cmd;

	if ( cmd->sym_flags & SYM_UDEF )
		dotree(&ccontext, cmd->sym_stmt);
	else
	if ( cmd->sym_flags & SYM_CHARARGV ) {
		char *argv[MAXARGC+1];

		argv[0] = cmd->sym_name;

		for ( i = 1; i < ccontext.argc; i++ ) {
			ccontext.argv[i] = pro_str(ccontext.argv[i]);
			argv[i] = ccontext.argv[i]->sym_s;
			}
		
		argv[ccontext.argc] = 0;

		rc = (*cmd->sym_func)(ccontext.argc, argv);
		}
	else
	if ( cmd->sym_flags & SYM_DIAGCOMM ) {
		for (i = 0; i < 120; i++)
		    errNumbers[i] = TEST_NULL;
		errIndex = 0;
		/*
		 * Setup argc, argv stuff, then initialize the global 
		 * communication structure (diagnostic module will access
		 * it as a global).
		 */
		myComm.argv[0] = cmd->sym_name;
		ideTestName = cmd->sym_name;

		for ( i = 1; i < ccontext.argc; i++ ) {
			ccontext.argv[i] = pro_str(ccontext.argv[i]);
			myComm.argv[i] = ccontext.argv[i]->sym_s;
			}
		
		myComm.argv[ccontext.argc] = 0;

		pGlobalComm = &myComm;
		myComm.errorCount = 0;
		myComm.entryNum = 0;
		myComm.errNums = errNumbers;
		myComm.argc = ccontext.argc;

		rc = (*cmd->sym_func)();
		/*
		 * Reset the global optind, in case the test used getopt()
		 * to parse its option arguments.
		 */
		optind = 1;
	}
	else
		rc = (*cmd->sym_func)(ccontext.argc, ccontext.argv);

	exit:
	for ( i = 1; i < ccontext.argc; i++ )
		destroysym(ccontext.argv[i]);
	
	vsym->sym_basetype = SYM_INT;
	vsym->sym_i = rc;

	return vsym;
}
/*
 * build up an argv for a command
 *
 */
makeargv(context, pnode, argv )
context_t *context;
node_t *pnode;
sym_t *argv[];
{
	int argc;

	if ( ! pnode )
		return 0;

	argc = makeargv( context, pnode->node_right, argv );

	if ( argc < MAXARGC )
		argv[argc++] = eval( context, pnode->node_left );

	return argc;
}
/*
 * doif - Do an if-then-else statement
 *
 */
doif( context, pnode)
node_t *pnode;
context_t *context;
{
	sym_t *tmp = pro_int(eval(context, pnode->node_left));

	if ( pnode->node_right && pnode->node_right->node_type == OP_ELSE ) {
		if ( tmp->sym_i )
			dotree(context,pnode->node_right->node_left);
		else
			dotree(context,pnode->node_right->node_right);
		}
	else
		if ( tmp->sym_i)
			dotree(context,pnode->node_right);
	
	destroysym(tmp);
}
/*
 * dorepeat - do a repeat loop
 *
 */
dorepeat(context, pnode)
node_t *pnode;
context_t *context;
{
	int tmp;

	tmp = pnode->node_psym->sym_i;

	if ( tmp )
		while( tmp-- )
			dotree(context, pnode->node_right);
	else
		while( 1 )
			dotree(context, pnode->node_right);

}
/*
 * dowhile - do a while loop
 *
 */
dowhile(context, pnode)
node_t *pnode;
context_t *context;
{
	sym_t *tmp;
	int done = 0;

	do	{
		tmp = pro_int(eval(context, pnode->node_left));
		if ( tmp->sym_i ) {
			context_t lcontext;
			int s;

			lcontext = *context;
			if ( s = setjmp( lcontext.lframe ) ) {
				if ( s == 2 ) /* break */
					done = 1;
				}
			else
				dotree(&lcontext, pnode->node_right);
			}
		else
			done = 1;
		destroysym(tmp);
		} while(!done);

}
/*
 * dofor - do a for loop
 *
 */
dofor(context, pnode)
node_t *pnode;
context_t *context;
{
	node_t *pre;
	node_t *con;
	node_t *end;
	node_t *bod;
	sym_t *tmp;
	context_t lcontext;
	int s;

	pre = pnode->node_left->node_left;
	con = pnode->node_left->node_right;
	end = pnode->node_right->node_left;
	bod = pnode->node_right->node_right;

	if (pre) destroysym(eval(context,pre));

	do	{
		if ( con ) {
			tmp = pro_int(eval(context, con));
			if ( ! tmp->sym_i ) {
				destroysym(tmp);
				break;
				}
			destroysym(tmp);
			}

		lcontext = *context;

		if ( s = setjmp( lcontext.lframe ) ) {
			if ( s == 2 ) /* break */
				break;
			}
		else
			dotree(&lcontext, bod);

		if ( end )
			destroysym(eval(context, end));
		} while (1);

}
/*
 * doreturn - return statement
 *
 */
doreturn(context, pnode)
node_t *pnode;
context_t *context;
{
	int rc;
	sym_t *rsym;

	if (pnode->node_right) {
		rsym = pro_int(eval(context,pnode->node_right));
		rc = rsym->sym_i;
		destroysym(rsym);
		}
	else
		rc = 0;

	longjmp(context->rframe, rc+1);
	/*NOTREACHED*/
}
/*
 * dodo - do a do loop
 *
 */
dodo(context, pnode)
node_t *pnode;
context_t *context;
{
	sym_t *tmp;
	int done = 0;
	context_t lcontext;
	int s;

	do	{
		lcontext = *context;
		if ( s = setjmp( lcontext.lframe ) ) {
			if ( s == 2 ) { /* break = 2 */
				done = 1;
				destroysym(tmp);
				break;
				}
			/* continue = 1 */
			}
		else
			dotree(&lcontext, pnode->node_right);

		tmp = pro_int(eval(context, pnode->node_left));

		if ( !tmp->sym_i )
			done = 1;

		destroysym(tmp);

		} while(!done);
}

doswitch(context, pnode)
node_t *pnode;
context_t *context;
{
	context_t scontext;
	int val;
	sym_t *psym = pro_int(eval(context, pnode->node_left));

	val = psym->sym_i;

	destroysym(psym);

	scontext = *context;

	if ( setjmp(scontext.lframe) )
		return; /* break */

	if (!findcase(&scontext, val, pnode->node_right, 0))
		findcase(&scontext, val, pnode->node_right, 1);
}

findcase(context, val, pnode, flag)
context_t *context;
node_t *pnode;
int val, flag;
{
	sym_t *psym;
	int found = 0;

	if ( ! pnode )
		return;

	if ( pnode->node_type == OP_CASELIST ) {
		found = findcase(context, val, pnode->node_right, flag);
		pnode = pnode->node_left;
		}
	
	if ( ! found ) {
		if ( flag && pnode->node_psym )
			return 0;

		if (!flag && !pnode->node_psym )
			return 0; /* hit default case but still looking */

		if (!flag && pnode->node_psym->sym_i != val)
			return 0;
		
		}
	
	dotree(context, pnode->node_right);

	return 1;
}

doprint(context, pnode)
node_t *pnode;
context_t *context;
{
	sym_t *tmp = eval(context, pnode->node_right);

	if ( pnode->node_psym )
		printf(pnode->node_psym->sym_s, tmp->sym_i);
	else
	switch( tmp->sym_basetype ) {
		case SYM_INT:
			printf("value = %d\n", tmp->sym_i );
			break;
		case SYM_STR:
			printf("value = \"%s\"\n", tmp->sym_s );
			break;
		}
	
	destroysym(tmp);

}

/*
 * eval - expression evaluator
 *
 * This is the heart of the ide interpreter.  Given an expression
 * tree this routine returns a symbol record containing the result
 * of the evaluation. The symbol returned is a temporary symbol and
 * should be destroyed after it is used.
 *
 */
sym_t *
eval(context, pnode)
node_t *pnode;
context_t *context;
{
	sym_t *rsym;
	sym_t *lsym;
	sym_t *vsym;

	switch ( pnode->node_type ) {
		case OP_VAR:
			lsym = pnode->node_psym;
			vsym = makesym();

			if ( lsym->sym_type == SYM_PARAM )
				/* $# */
				if ( lsym->sym_indx == MAXARGC+1 ) {
					vsym->sym_basetype = SYM_INT;
					vsym->sym_type = SYM_VAR;
					vsym->sym_i = context->argc;
					break;
					}
				else
				/* $n where n > argc  */
				if ( lsym->sym_indx >= context->argc ) {
					vsym->sym_basetype = SYM_STR;
					vsym->sym_type = SYM_VAR;
					vsym->sym_s = makestr("");
					break;
					}
				else
				/* $n where n <= argc  */
					lsym = context->argv[lsym->sym_indx];
			
			if ( lsym->sym_basetype == SYM_STR )
				vsym->sym_s = makestr(lsym->sym_s);
			else
			if ( lsym->sym_basetype == SYM_RANGE) {
				vsym->sym_start = lsym->sym_start;
				vsym->sym_count = lsym->sym_count;
				}
			else
				vsym->sym_i = lsym->sym_i;
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_type = SYM_VAR;
			break;
		case OP_ADD:
			rsym = eval(context, pnode->node_right);
			lsym = eval(context, pnode->node_left);
			vsym = makesym();

			if ( rsym->sym_basetype == SYM_STR &&
			     lsym->sym_basetype == SYM_STR  ) {
				vsym->sym_basetype = SYM_STR;
				vsym->sym_s = talloc( strlen(rsym->sym_s)+
						strlen(lsym->sym_s) + 1 );
				strcpy( vsym->sym_s, lsym->sym_s );
				strcat( vsym->sym_s, rsym->sym_s );
				}
			else	{
				rsym = pro_int(rsym);
				lsym = pro_int(lsym);
				vsym->sym_basetype = SYM_INT;
				vsym->sym_i = lsym->sym_i + rsym->sym_i;
				}
			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_SUB:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pro_int(eval(context, pnode->node_left));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;
			vsym->sym_i = lsym->sym_i - rsym->sym_i;
			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_MUL:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pro_int(eval(context, pnode->node_left));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;
			vsym->sym_i = lsym->sym_i * rsym->sym_i;
			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_DIV:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pro_int(eval(context, pnode->node_left));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;
			if ( rsym->sym_i == 0 )
				vsym->sym_i = DIV0RESULT;
			else
				vsym->sym_i = lsym->sym_i / rsym->sym_i;
			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_MOD:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pro_int(eval(context, pnode->node_left));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;
			if ( rsym->sym_i == 0 )
				vsym->sym_i = DIV0RESULT;
			else
				vsym->sym_i = lsym->sym_i % rsym->sym_i;
			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_OR:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pro_int(eval(context, pnode->node_left));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;
			vsym->sym_i = lsym->sym_i | rsym->sym_i;
			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_AND:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pro_int(eval(context, pnode->node_left));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;
			vsym->sym_i = lsym->sym_i & rsym->sym_i;
			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_XOR:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pro_int(eval(context, pnode->node_left));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;
			vsym->sym_i = lsym->sym_i ^ rsym->sym_i;
			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_COM: /* complement */
			rsym = pro_int(eval(context, pnode->node_right));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;
			vsym->sym_i =  ~rsym->sym_i;
			destroysym(rsym);
			break;
		case OP_NOT: /* logical not */
			rsym = pro_int(eval(context, pnode->node_right));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;
			if ( rsym->sym_i )
				vsym->sym_i = 0;
			else
				vsym->sym_i = 1;
			destroysym(rsym);
			break;
		case OP_ANDAND:
			lsym = pro_int(eval(context, pnode->node_left));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;

			/* C evaluation semantics */
			if ( lsym->sym_i ) {
				rsym = pro_int(eval(context,pnode->node_right));
				if ( rsym->sym_i )
					vsym->sym_i = 1;
				}
			else
				vsym->sym_i = 0;

			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_OROR:
			lsym = pro_int(eval(context, pnode->node_left));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;

			/* C evaluation semantics */
			if ( ! lsym->sym_i ) {
				rsym = pro_int(eval(context,pnode->node_right));
				if ( rsym->sym_i )
					vsym->sym_i = 1;
				}
			else
				vsym->sym_i = 1;

			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_LT:
		case OP_LE:
		case OP_GT:
		case OP_GE:
		case OP_EQ:
		case OP_NE:
			{
			int i;
			rsym = eval(context, pnode->node_right);
			lsym = eval(context, pnode->node_left);

			vsym = makesym();
			vsym->sym_basetype = SYM_INT;

			if ( rsym->sym_basetype == SYM_STR &&
			     lsym->sym_basetype == SYM_STR  )
				i = strcmp(lsym->sym_s, rsym->sym_s);
			else	{
				rsym = pro_int(rsym);
				lsym = pro_int(lsym);

				i = lsym->sym_i - rsym->sym_i;
				}

			switch(pnode->node_type) {
				case OP_EQ:
					vsym->sym_i = (i == 0);
					break;
				case OP_NE:
					vsym->sym_i = (i != 0);
					break;
				case OP_GT:
					vsym->sym_i = (i >  0);
					break;
				case OP_LT:
					vsym->sym_i = (i <  0);
					break;
				case OP_GE:
					vsym->sym_i = (i >= 0);
					break;
				case OP_LE:
					vsym->sym_i = (i <= 0);
					break;
				}
			destroysym(rsym);
			destroysym(lsym);
			}
			break;
		case OP_POSTD:
			lsym = pnode->node_psym;
			if ( lsym->sym_basetype == SYM_STR )
				destroystr(lsym->sym_s);
			lsym->sym_basetype = SYM_INT;
			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i--;
			break;
		case OP_POSTI:
			lsym = pnode->node_psym;
			if ( lsym->sym_basetype == SYM_STR )
				destroystr(lsym->sym_s);
			lsym->sym_basetype = SYM_INT;
			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i++;
			break;
		case OP_PRED:
			lsym = pnode->node_psym;
			if ( lsym->sym_basetype == SYM_STR )
				destroystr(lsym->sym_s);
			lsym->sym_basetype = SYM_INT;
			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = --lsym->sym_i;
			break;
		case OP_PREI:
			lsym = pnode->node_psym;
			if ( lsym->sym_basetype == SYM_STR )
				destroystr(lsym->sym_s);
			lsym->sym_basetype = SYM_INT;
			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = ++lsym->sym_i;
			break;
		case OP_SHL:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pro_int(eval(context, pnode->node_left));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;
			vsym->sym_i = lsym->sym_i << rsym->sym_i;
			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_SHR:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pro_int(eval(context, pnode->node_left));
			vsym = makesym();
			vsym->sym_basetype = SYM_INT;
			vsym->sym_i = lsym->sym_i >> rsym->sym_i;
			destroysym(rsym);
			destroysym(lsym);
			break;
		case OP_ASSIGN:
			rsym = eval(context, pnode->node_right);
			lsym = pnode->node_psym;

			if ( lsym->sym_basetype == SYM_STR )
				destroystr(lsym->sym_s);

			if ( lsym->sym_type == SYM_GLOBAL )
				set_global(lsym, rsym);
			else	{
				if ( rsym->sym_basetype == SYM_INT ) {
					lsym->sym_basetype = SYM_INT;
					lsym->sym_i = rsym->sym_i;
					}
				else
				if ( rsym->sym_basetype == SYM_STR ) {
					lsym->sym_basetype = SYM_STR;
					lsym->sym_s = makestr(rsym->sym_s);
					}
				destroysym(rsym);
				}

			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			if ( lsym->sym_basetype == SYM_STR )
				vsym->sym_s = makestr(lsym->sym_s);
			else
				vsym->sym_i = lsym->sym_i;
			break;
		case OP_SUBASS:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pnode->node_psym;

			lsym->sym_basetype = SYM_INT;
			lsym->sym_i -= rsym->sym_i;

			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i;
			destroysym(rsym);
			break;
		case OP_ADDASS:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pnode->node_psym;

			lsym->sym_basetype = SYM_INT;
			lsym->sym_i += rsym->sym_i;

			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i;
			destroysym(rsym);
			break;
		case OP_MULASS:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pnode->node_psym;

			lsym->sym_basetype = SYM_INT;
			lsym->sym_i *= rsym->sym_i;

			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i;
			destroysym(rsym);
			break;
		case OP_DIVASS:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pnode->node_psym;

			lsym->sym_basetype = SYM_INT;

			if ( rsym->sym_i == 0 )
				lsym->sym_i = DIV0RESULT;
			else
				lsym->sym_i /= rsym->sym_i;

			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i;
			destroysym(rsym);
			break;
		case OP_MODASS:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pnode->node_psym;

			lsym->sym_basetype = SYM_INT;

			if ( rsym->sym_i == 0 )
				lsym->sym_i = DIV0RESULT;
			else
				lsym->sym_i %= rsym->sym_i;

			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i;
			destroysym(rsym);
			break;
		case OP_SHLASS:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pnode->node_psym;

			lsym->sym_basetype = SYM_INT;
			lsym->sym_i <<= rsym->sym_i;

			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i;
			destroysym(rsym);
			break;
		case OP_SHRASS:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pnode->node_psym;

			lsym->sym_basetype = SYM_INT;
			lsym->sym_i >>= rsym->sym_i;

			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i;
			destroysym(rsym);
			break;
		case OP_ANDASS:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pnode->node_psym;

			lsym->sym_basetype = SYM_INT;
			lsym->sym_i &= rsym->sym_i;

			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i;
			destroysym(rsym);
			break;
		case OP_ORASS:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pnode->node_psym;

			lsym->sym_basetype = SYM_INT;
			lsym->sym_i |= rsym->sym_i;

			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i;
			destroysym(rsym);
			break;
		case OP_XORASS:
			rsym = pro_int(eval(context, pnode->node_right));
			lsym = pnode->node_psym;

			lsym->sym_basetype = SYM_INT;
			lsym->sym_i ^= rsym->sym_i;

			vsym = makesym();
			vsym->sym_basetype = lsym->sym_basetype;
			vsym->sym_i = lsym->sym_i;
			destroysym(rsym);
			break;
		case OP_CMD:
			vsym = docmd(context,pnode);
			break;
		default:
			vsym = makesym();
			printf("ide: eval bad node type %d\n",pnode->node_type);
			break;
		}
	
	return vsym;
}