text: /*
   * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
   * See the copyright notice in the ACK home directory, in the file "Copyright".
   */
  #ifndef NORCSID
  static char rcsid[]= "$Id$";
  #endif
  
  #include <assert.h>
  #include <stdlib.h>
  #include <stdio.h>
  #include <string.h>
  #include "param.h"
  #include "set.h"
  #include "reg.h"
  #include "lookup.h"
  #include "token.h"
  #include "property.h"
  #include "expr.h"
  #include "regvar.h"
  #include <cgg_cg.h>
  #include <em_reg.h>
  #include "extern.h"
  
  extern set_t l_sets[];
  
  i_expr(e) expr_t e; {
  
  	if (e.ex_typ != TYPINT)
  		error("Expression should be integer");
  	return(e.ex_index);
  }
  
  b_expr(e) expr_t e; {
  	if (e.ex_typ != TYPBOOL)
  		error("Expression should be boolean");
  	return(e.ex_index);
  }
  
  expr_t make_expr(type,operator,op1,op2) {
  	expr_t result;
  
  	result.ex_typ=type;
  	result.ex_index=ex_lookup(operator,op1,op2);
  	return(result);
  }
  
  expr_t regno_expr(regno) {
  	expr_t result;
  	register i;
  
  	result.ex_typ = TYPREG;
  	result.ex_index = ex_lookup(EX_REG,regno,0);
  	for (i=0;i<SZOFSET(MAXREGS);i++)
  		result.ex_regset[i] = 0;
  	BIS(result.ex_regset,regno);
  	return(result);
  }
  
  expr_t ident_expr(name) char *name; {
  	register symbol *sy_p;
  
  	sy_p = lookup(name,symany,mustexist);
  	if (sy_p->sy_type==symconst)
  		return(make_expr(TYPINT,EX_CON,
  			   (int) (sy_p->sy_value.syv_cstval&0xFFFF),
  			   (int) (sy_p->sy_value.syv_cstval>>16)));
  	else if (sy_p->sy_type==symsconst)
  		return(make_expr(TYPADDR,EX_STRING,sy_p->sy_value.syv_stringno,0));
  	else if (sy_p->sy_type!=symreg)
  		error("Wrong type of identifier %s",name);
  	return(regno_expr(sy_p->sy_value.syv_regno));
  }
  
  expr_t subreg_expr(tokarg,subreg) {
  	expr_t result;
  
  	result.ex_typ = TYPREG;
  	subregset(l_sets[tokpatset[tokarg > 0 ? tokarg-1 : tokarg]].set_val,
  		  subreg,result.ex_regset);
  	result.ex_index = ex_lookup(EX_SUBREG,tokarg,subreg);
  	return(result);
  }
  
  subregset(sp,subreg,regset) register short *sp; register short *regset; {
  	register i;
  	register reginfo *rp;
  
  	for (i=0;i<SZOFSET(MAXREGS);i++)
  		regset[i]=0;
  	for (i=1;i<nregs;i++)	if (BIT(sp,i)) {
  		if(subreg) {
  			rp = &l_regs[i];
  			if (rp->ri_memb[subreg-1]==0)
  				error("Register %s in set has no member %d",
  					rp->ri_name,subreg);
  			BIS(regset,rp->ri_memb[subreg-1]);
  		} else
  			BIS(regset,i);
  	}
  	for(;i<nregs+MAXTOKENS;i++) if(BIT(sp,i))
  		error("Set contains %s, which is not a register",
  			l_tokens[i-nregs]->tk_name);
  }
  
  membset(setno,name,regset,appearance,restyp,typp)
  char *name,*appearance;
  short *regset;
  int *typp;
  {
  	register short *sp;
  	register token_p tp;
  	register i,j,k;
  	int thistyp;
  	int typesdiffer=0;
  	int res_j= -1;
  
  	if (setno < 0) return 0;
  	sp = l_sets[setno].set_val;
  	for (i=1;i<nregs;i++) if (BIT(sp,i)) {
  		error("Set in %s contains %s, which is not a token",
  			appearance,l_regs[i].ri_name);
  		break;
  	}
  	for (i=0;i<SZOFSET(MAXREGS);i++)
  		regset[i] = 0;
  	for (i=nregs;i<nregs+MAXTOKENS;i++) if (BIT(sp,i)) {
  		tp = l_tokens[i-nregs];
  		for(j=0;j<MAXATT &&
  		        (tp->tk_att[j].ta_type == -3 ||
  			 strcmp(tp->tk_att[j].ta_name,name));j++)
  			;
  		if (j==MAXATT)
  			error("Token %s does not contain %s",tp->tk_name,name);
  		else if (j!=res_j && res_j != -1)
  			typesdiffer=1;
  		else {
  			res_j = j;
  			thistyp = tp->tk_att[j].ta_type;
  			if (thistyp== -2) {
  				if (restyp!=TYPADDR && restyp!=0)
  					typesdiffer=1;
  				else
  					restyp=TYPADDR;
  			} else if (thistyp== -1) {
  				if (restyp!=TYPINT && restyp!=0)
  					typesdiffer=1;
  				else
  					restyp=TYPINT;
  			} else {
  				if (restyp!=TYPREG && restyp!=0)
  					typesdiffer=1;
  				else {
  					restyp=TYPREG;
  					for(k=0;k<SZOFSET(MAXREGS);k++)
  						regset[k] |=
  						    l_props[tp->tk_att[j].ta_type].pr_regset[k];
  				}
  			}
  		}
  	}
  	if (typesdiffer)
  		error("%s is not a valid expression; types differ in the set",
  			appearance);
  	*typp = restyp==0 ? TYPINT : restyp;
  	return(res_j == -1 ? 0 : res_j);
  }
  
  expr_t memb_expr(setno,name,appearance,tokarg) char *name,*appearance; {
  	expr_t result;
  	int res_j;
  
  	res_j = membset(setno,name,result.ex_regset,appearance,0,&result.ex_typ);
  	result.ex_index = ex_lookup(EX_TOKFIELD,tokarg,res_j+1);
  	return(result);
  }
  
  expr_t tokm_expr(tokarg,name) char *name; {
  	char app[100];
  	int tokarg1 = tokarg > 0 ? tokarg : 1;
  
  	sprintf(app,"%%%d.%s",tokarg1,name);
  	return(memb_expr(tokpatset[tokarg1-1],name,app,tokarg));
  }
  
  expr_t perc_ident_expr(name) char *name; {
  	char app[100];
  
  	sprintf(app,"%%%s",name);
  	return(memb_expr(cursetno,name,app,0));
  }
  
  expr_t all_expr(all_no,subreg) {
  	set_t localset;
  	register i;
  	register short *sp;
  	expr_t result;
  
  	sp = l_props[allreg[all_no]].pr_regset;
  	for (i=0;i<SETSIZE;i++)
  		localset.set_val[i] = i<SZOFSET(MAXREGS) ? sp[i] : 0;
  	subregset(localset.set_val,subreg,result.ex_regset);
  	result.ex_typ = TYPREG;
  	result.ex_index = ex_lookup(EX_ALLREG,all_no+1,subreg);
  	return(result);
  }
  
  eq2expr(e1,e2) expr_t e1,e2; {
  
  	if (e1.ex_typ != e2.ex_typ)
  		error("Expressions around == should have equal type");
  	switch (e1.ex_typ) {
  	default: assert(0);
  	case TYPBOOL:
  		error("== on booleans not implemented");
  	case TYPINT:
  		return(EX_NCPEQ);
  	case TYPADDR:
  		return(EX_SCPEQ);
  	case TYPREG:
  		return(EX_RCPEQ);
  	}
  }
  
  ne2expr(e1,e2) expr_t e1,e2; {
  
  	if (e1.ex_typ != e2.ex_typ)
  		error("Expressions around != should have equal type");
  	switch (e1.ex_typ) {
  	default: assert(0);
  	case TYPBOOL:
  		error("!= on booleans not implemented");
  	case TYPINT:
  		return(EX_NCPNE);
  	case TYPADDR:
  		return(EX_SCPNE);
  	case TYPREG:
  		return(EX_RCPNE);
  	}
  }
  
  expr_t sum_expr(e1,e2) expr_t e1,e2; {
  	int operator,op1,op2;
  	expr_t result;
  
  	operator = EX_CAT; op1 = e1.ex_index; op2 = e2.ex_index;
  	if (e1.ex_typ==e2.ex_typ) {
  		result.ex_typ = e1.ex_typ;
  		if (e1.ex_typ == TYPINT)
  			operator = EX_PLUS;
  		else if (e1.ex_typ != TYPADDR)
  			error("+ is not implemented on this type");
  	} else {
  		result.ex_typ = TYPADDR;
  		if (e1.ex_typ != TYPADDR) {
  			if (e1.ex_typ!=TYPINT)
  				error("Wrong left operand of +");
  			op1 = ex_lookup(EX_TOSTRING,op1,0);
  		}
  		if (e2.ex_typ != TYPADDR) {
  			if (e2.ex_typ!=TYPINT)
  				error("Wrong right operand of +");
  			op2 = ex_lookup(EX_TOSTRING,op2,0);
  		}
  	}
  	result.ex_index=ex_lookup(operator,op1,op2);
  	return(result);
  }
  
  expr_t iextoaddr(e) expr_t e; {
  	expr_t result;
  
  	result.ex_typ = TYPADDR;
  	result.ex_index = ex_lookup(EX_TOSTRING,e.ex_index,0);
  	return(result);
  }
  
  expr_t regvar_expr(e,regtyp,regsiz) expr_t e; {
  	expr_t result;
  	int i, regno, s, two_sizes;
  
  	two_sizes = (regtyp == reg_float && reglap != 0);
  	if (regsiz == -1) {
  		/* reglap: Can't guess between 2 sizes of reg_float. */
  		if (two_sizes && regsiz == -1)
  			error("Must use regvar_w() or regvar_d()");
  		else
  			regsiz = rvsize[regtyp];
  	}
  
  	result = make_expr(TYPREG,EX_REGVAR,i_expr(e),regsiz);
  	for(i=0;i<SZOFSET(MAXREGS);i++)
  		result.ex_regset[i]=0;
  
  	/* s = the size of the registers in rvnumbers[regtyp] */
  	s = two_sizes ? reglap : rvsize[regtyp];
  	if (s == regsiz) {
  		for(i=0;i<nregvar[regtyp];i++)
  			BIS(result.ex_regset,rvnumbers[regtyp][i]);
  	}
  	/* reglap: Also check the 2nd size of reg_float. */
  	if (two_sizes && rvsize[regtyp] == regsiz) {
  		for(i=0;i<nregvar[regtyp];i++) {
  			/* regno = first subregister */
  			regno = l_regs[rvnumbers[regtyp][i]].ri_memb[0];
  			if (regno != 0)
  				BIS(result.ex_regset, regno);
  		}
  	}
  	return(result);
  }
  		
  /*
   * Node table lookup part
   */
  
  node_t nodes[MAXNODES];
  int nnodes=0;
  
  initnodes() {
  
  	nodes[0].ex_operator = EX_CON;
  	nodes[0].ex_lnode = 0;
  	nodes[0].ex_rnode = 0;
  	nnodes++;
  }
  
  ex_lookup(operator,lnode,rnode) {
  	register node_p p;
  
  	for(p=nodes+1;p< &nodes[nnodes];p++) {
  		if (p->ex_operator != operator)
  			continue;
  		if (p->ex_lnode != lnode)
  			continue;
  		if (p->ex_rnode != rnode)
  			continue;
  		return(p-nodes);
  	}
  	NEXT(nnodes,MAXNODES,"Node");
  	p->ex_operator = operator;
  	p->ex_lnode = lnode;
  	p->ex_rnode = rnode;
  	return(p-nodes);
  }
  