interp.c

speech signal process tools

/*
  This material contains proprietary software of Entropic Speech, Inc.   
  Any reproduction, distribution, or publication without the prior	   
  written permission of Entropic Speech, Inc. is strictly prohibited.
  Any public distribution of copies of this work authorized in writing by
  Entropic Speech, Inc. must bear the notice			
 								
      "Copyright (c) 1987 Entropic Speech, Inc.; All rights reserved"
 				
*/

 	
#ifndef lint
	char *interp_sccs = "@(#)interp.c	3.14	11/11/94 ESI";
#endif

#include "select.h"
#include "interp.h"
#include "y.tab.h"

#define SN (short*)NULL
#define LLN (long **)NULL


/* this code is based on the hoc interpreter in "Unix Programming
Environment", by Kerningham and Pike */

extern int debug_level;

#define STACKSIZ 256
static 	Stack 	stack[STACKSIZ];	/* interpreter stack */
static 	Stack 	*stackptr;		/* next free spot on stack */

#define PROGSIZ 1000
Inst 	prog[PROGSIZ];			/* the interpreter program memory */
Inst 	*progptr;			/* next free spot in memory */
Inst 	*pc;				/* program counter */

int	run_error;			/* error detected during run */
int	fatal_error;			/* bad error ends select */


void
initcode()
{
	if (debug_level >1) print_func();
	if (debug_level) Fprintf(stderr,"initcode called\n");
	stackptr = stack;
	progptr = prog;
}

void
push(data)
Stack data;
{
	if (stackptr >= &stack[STACKSIZ]) {
		errmsg("Stack overflow handling query expression\n");
		errmsg("Internal error; contact maintainer.\n");
		exit(1);
	}

	*stackptr++ = data;
}

Stack
pop()
{
	if (stackptr <= stack) {
		errmsg("Stack underflow handling query expression\n");
		errmsg("Internal error; contact maintainer.\n");
		exit(1);
	}
	return *--stackptr;
}

void
code(instr)
int (*instr)();
{
	if (debug_level)
		Fprintf(stderr,"code: called with %x.\n",instr);
	if (progptr >= &prog[PROGSIZ]) {
		errmsg("Query expression too complex\n");
		errmsg("Internal error; contact maintainer.\n");
		exit(1);
	}
	progptr->inst = instr;
	progptr++;
	return;
}

void
operand(type,c,d)
int type;
char *c;
double d;
{
	if (debug_level) {
		Fprintf(stderr,"operand: called with code %d.\n",code);
		if(type == CHAR)
		 Fprintf(stderr,"--string %s\n",c);
		else
		 Fprintf(stderr,"--double %lf\n",d);
	}
	if (progptr >= &prog[PROGSIZ]) {
		errmsg("Query expression too complex\n");
		errmsg("Internal error; contact maintainer.\n");
		exit(1);
	}
	if (type == CHAR) {
	 	progptr->sval = c;
		progptr->dval = 0;
		progptr->type = CHAR;
	}
	else if (type == DOUBLE) {
		progptr->dval = d;
		progptr->sval = NULL;
		progptr->type = DOUBLE;
	} else {
		errmsg("Internal error in operand, bad type\n");
		errmsg("Internal error; contact maintainer.\n");
		exit(1);
	}

	progptr->inst = NOOP;
	progptr++;
	return;
}

double
run_interp()
{
	if(debug_level > 1) {
	  for (pc = prog; pc->inst != STOP;) {
		Fprintf(stderr,"prog: i:%x f:%lf s:%s\n",
			pc->inst, pc->dval, pc->sval);
		pc++;
	  }
	  return 0;
	}
	
	stackptr = stack;
	run_error = 0;
	fatal_error = 0;
	for (pc = prog; pc->inst != STOP && !run_error && !fatal_error;)
		{pc++; (*((pc-1)->inst))();}
	if (run_error || fatal_error)  {
		errmsg("expression aborted.\n");
		return 0;
	}
	else
		return stack[0].dval;
}

int
Const()	
{
	Stack data;
	if (debug_level) Fprintf(stderr,"Const: called\n");
	if (pc->type == CHAR) {
		data.sval = (pc++)->sval;
		data.dval = 0;
		data.type = CHAR;
	}
	else {
		data.dval = (pc++)->dval;
		data.sval = NULL;
		data.type = DOUBLE;
	}
	push(data);
}

int
add()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"add: called\n");
	d2 = pop();
	d1 = pop();
	d1.dval = d1.dval += d2.dval;
	d1.type = DOUBLE;
	push(d1);
}

int
sub()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"sub: called\n");
	d2 = pop();
	d1 = pop();
	d1.dval = d1.dval -= d2.dval;
	d1.type = DOUBLE;
	push(d1);
}

int
mul()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"mul: called\n");
	d2 = pop();
	d1 = pop();
	d1.dval = d1.dval *= d2.dval;
	d1.type = DOUBLE;
	push(d1);
}

int
divide()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"divide: called\n");
	d2 = pop();
	d1 = pop();
	if (d2.dval == 0.0) {
		errmsg("Divide by zero; ");
		run_error++;
	}
	else {
		d1.dval = d1.dval /= d2.dval;
		d1.type = DOUBLE;
		push(d1);
	}
}


int
power()
{
	extern double Pow();
	Stack d1, d2;
	if (debug_level) Fprintf(stderr,"power: called\n");
	d2 = pop();
	d1 = pop();
	d1.dval = Pow(d1.dval, d2.dval);
	push(d1);
}

int
negate()
{
	Stack d1;
	if (debug_level) Fprintf(stderr,"negate: called\n");
	d1 = pop();
	d1.dval = -d1.dval;
	push(d1);
}

int
le()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"le: called\n");
	d2 = pop();
	d1 = pop();
	d1.dval = (double)(d1.dval <= d2.dval);
	d1.type = DOUBLE;
	push(d1);
}

int
and()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"and: called\n");
	d2 = pop();
	d1 = pop();
	d1.dval = (double)(d1.dval && (d2.dval != 0));
	d1.type = DOUBLE;
	push(d1);
}

int
or()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"or: called\n");
	d2 = pop();
	d1 = pop();
	d1.dval = (double)(d1.dval || d2.dval);
	d1.type = DOUBLE;
	push(d1);
}

int
lt()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"lt: called\n");
	d2 = pop();
	d1 = pop();
	d1.dval = (double)(d1.dval < d2.dval);
	d1.type = DOUBLE;
	push(d1);
}

int
gt()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"gt: called\n");
	d2 = pop();
	d1 = pop();
	d1.dval = (double)(d1.dval > d2.dval);
	d1.type = DOUBLE;
	push(d1);
}

int
eq()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"eq: called\n");
	d2 = pop();
	d1 = pop();
	if (d2.type == CHAR && d1.type == CODED) 
		d1.dval = cmp_coded(d2.sval,d1.sval,(short)d1.dval);

	else if (d1.type == CHAR && d2.type == CODED)
		d1.dval = cmp_coded(d1.sval,d2.sval,(short)d2.dval);

	else if (d1.type == CHAR && d2.type == CHAR)
		d1.dval = (strcmp(d1.sval,d2.sval) == 0);

	else
		d1.dval = (double)(d1.dval == d2.dval);

	d1.type = DOUBLE;
	push(d1);
}

int
ne()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"ne: called\n");
	d2 = pop();
	d1 = pop();
	if (d2.type == CHAR && d1.type == CODED) 
		d1.dval = !cmp_coded(d2.sval,d1.sval,(short)d1.dval);

	else if (d1.type == CHAR && d2.type == CODED)
		d1.dval = !cmp_coded(d1.sval,d2.sval,(short)d2.dval);

	else if (d1.type == CHAR && d2.type == CHAR)
		d1.dval = (strcmp(d1.sval,d2.sval) != 0);

	else
		d1.dval = (double)(d1.dval != d2.dval);
	d1.type = DOUBLE;
	push(d1);
}

int
ge()
{
	Stack d1,d2;
	if (debug_level) Fprintf(stderr,"ge: called\n");
	d2 = pop();
	d1 = pop();
	d1.dval = (double)(d1.dval >= d2.dval);
	d1.type = DOUBLE;
	push(d1);
}


int
not()
{
	Stack d1;
	if (debug_level) Fprintf(stderr,"not: called\n");
	d1 = pop();
	d1.dval = (double)(!d1.dval);
	d1.type = DOUBLE;
	push(d1);
}

extern struct fea_data *query_rec;
extern struct header *query_hd;
extern char *query_file;
extern long data_ptr;
extern int gf_flag;

int
getfld()
{
	Stack d1;
	long real_index, *dimen, size, index, *lptr;
	short type, rank, *sptr;
	float *fptr;
	double *dptr;
	char *bptr;
	char *ptr, *name;
	double_cplx *dcptr;
	float_cplx *fcptr;
	long_cplx *lcptr;
	short_cplx *scptr;
	byte_cplx *bcptr;
	

	assert(query_rec != NULL);
	assert(query_hd != NULL);
	
	name = (pc++)->sval;
	index = (long)(pc++)->dval;
	d1.type = DOUBLE;	/* default type */
	if (debug_level)
	 Fprintf(stderr,"getfld: name: %s, index: %d\n",name,index);
	if (strcmp(name,"tag") == 0) {
	  d1.dval = query_rec->tag;
	  push(d1);
	  return;
	}
	if (strcmp(name,"FILE") == 0) {
	  d1.sval = query_file;
	  d1.type = CHAR;
	  push(d1);
	  return;
	}
	if (strcmp(name,"REC") == 0) {
	  d1.dval = data_ptr;