/*
** Small-C Compiler -- Part 3 -- Expression Analyzer.
** Copyright 1982, 1983, 1985, 1988 J. E. Hendrix
** Copyright 1998 H T Walheim
** All rights reserved.
*/

#include <stdio.h>
#include "cc.h"

#define ST 0   /* is[ST] - symbol table address, else 0 */
#define TI 1   /* is[TI] - type of indirect obj to fetch, else 0 */
#define TA 2   /* is[TA] - type of address, else 0 */
#define TC 3   /* is[TC] - type of constant (INT or UINT), else 0 */
#define CV 4   /* is[CV] - value of constant (+ auxiliary uses) */
#define OP 5   /* is[OP] - code of highest/last binary operator */
#define SA 6   /* is[SA] - stage address of "op 0" code, else 0 */

extern char
 *litq, *glbptr, *lptr,  ssname[NAMESIZE],  quote[2];
extern int
  ch,  csp,  litlab,  litptr,  nch,  op[16],  op2[16],
  opindex,  opsize, *snext;

/***************** lead-in functions *******************/

constexpr(val) int *val; {
  int constant;
  int *before, *start;
  setstage(&before, &start);
  expression(&constant, val);
  clearstage(before, 0);     /* scratch generated code */
  if(constant == 0) error("must be constant expression");
  return constant;
  }

null_is (is)
int is[7];
  {
    int i;

    for (i = 0; i < 7; ++i)
      {
	is[i] = 0;	/* <-- */
      }
  }
    
  
expression(con, val) int *con, *val;
  {
    int i;
    int is[7];

    null_is (is);
    
  if(level1(is)) fetch(is);
  *con = is[TC];
  *val = is[CV];
  }

test(label, parens)  int label, parens;  {
  int is[7];
  int *before, *start;

  null_is (is);
  
  if(parens) need("(");
  while(1) {
    setstage(&before, &start);
    if(level1(is)) fetch(is);
    if(match(",")) clearstage(before, start);
    else break;
    }
  if(parens) need(")");
  if(is[TC]) {             /* constant expression */
    clearstage(before, 0);
    if(is[CV]) return;
    gen(JMPm, label);
    return;
    }
  if(is[SA]) {             /* stage address of "oper 0" code */
    switch(is[OP]) {       /* operator code */
      case EQ12:
      case LE12u: zerojump(EQ10f, label, is); break;
      case NE12:
      case GT12u: zerojump(NE10f, label, is); break;
      case GT12:  zerojump(GT10f, label, is); break;
      case GE12:  zerojump(GE10f, label, is); break;
      case GE12u: clearstage(is[SA], 0);      break;
      case LT12:  zerojump(LT10f, label, is); break;
      case LT12u: zerojump(JMPm,  label, is); break;
      case LE12:  zerojump(LE10f, label, is); break;
      default:    gen(NE10f, label);          break;
      }
    }
  else gen(NE10f, label);
  clearstage(before, start);
  }

/*
** test primary register against zero and jump if false
*/
zerojump(oper, label, is) int oper, label, is[]; {
  clearstage(is[SA], 0);       /* purge conventional code */
  gen(oper, label);
  }

/***************** precedence levels ******************/
#ifdef _MSC_VER
level2();
level3();
level4();
level5();
level6();
level7();
level8();
level9();
level10();
level11();
level12();
level13();
#endif

level1(is) int is[];  {
  int k, is2[7], is3[2], oper, oper2;

  null_is (is2);
  null_is (is3);
  
  k = down1(level2, is);
  if(is[TC])
    {
#ifdef INT32
      gen(GETd1n, is[CV]);
#else
      gen(GETw1n, is[CV]);
#endif
    }
       if(match("|="))  {oper =        oper2 = OR12;}
  else if(match("^="))  {oper =        oper2 = XOR12;}
  else if(match("&="))  {oper =        oper2 = AND12;}
  else if(match("+="))  {oper =        oper2 = ADD12;}
  else if(match("-="))  {oper =        oper2 = SUB12;}
  else if(match("*="))  {oper = MUL12; oper2 = MUL12u;}
  else if(match("/="))  {oper = DIV12; oper2 = DIV12u;}
  else if(match("%="))  {oper = MOD12; oper2 = MOD12u;}
  else if(match(">>=")) {oper =        oper2 = ASR12;}
  else if(match("<<=")) {oper =        oper2 = ASL12;}
  else if(match("="))   {oper =        oper2 = 0;}
  else return k;
                        /* have an assignment operator */
  if(k == 0) {
    needlval();
    return 0;
    }
  is3[ST] = is[ST];
  is3[TI] = is[TI];
  if(is[TI]) {                             /* indirect target */
    if(oper) {                             /* ?= */
      gen(PUSH1, 0);                       /* save address */
      fetch(is);                           /* fetch left side */
      }
    down2(oper, oper2, level1, is, is2);   /* parse right side */
    if(oper) gen(POP2, 0);                 /* retrieve address */
    }
  else {                                   /* direct target */
    if(oper) {                             /* ?= */
      fetch(is);                           /* fetch left side */
      down2(oper, oper2, level1, is, is2); /* parse right side */
      }
    else {                                 /*  = */
      if(level1(is2)) fetch(is2);          /* parse right side */
      }
    }
  store(is3);                              /* store result */
  return 0;
  }

level2(is1)  int is1[]; {
  int is2[7], is3[7], k, flab, endlab, *before, *after;
  
  null_is (is2);
  null_is (is3);
  
  k = down1(level3, is1);                   /* expression 1 */
  if(match("?") == 0) return k;
  dropout(k, NE10f, flab = getlabel(), is1);
  if(down1(level2, is2)) fetch(is2);        /* expression 2 */
  else if(is2[TC])
    {
#ifdef INT32
      gen(GETd1n, is2[CV]);
#else
      gen(GETw1n, is2[CV]);
#endif
    }
  need(":");
  gen(JMPm, endlab = getlabel());
  gen(LABm, flab);
  if(down1(level2, is3)) fetch(is3);        /* expression 3 */
  else if(is3[TC])
    {
#ifdef INT32
      gen(GETd1n, is3[CV]);
#else
      gen(GETw1n, is3[CV]);
#endif
    }
  gen(LABm, endlab);

  is1[TC] = is1[CV] = 0;
  if(is2[TC] && is3[TC]) {                  /* expr1 ? const2 : const3 */
    is1[TA] = is1[TI] = is1[SA] = 0;
    }
  else if(is3[TC]) {                        /* expr1 ? var2 : const3 */
    is1[TA] = is2[TA];
    is1[TI] = is2[TI];
    is1[SA] = is2[SA];
    }
  else if((is2[TC])                         /* expr1 ? const2 : var3 */
       || (is2[TA] == is3[TA])) {           /* expr1 ? same2 : same3 */
    is1[TA] = is3[TA];
    is1[TI] = is3[TI];
    is1[SA] = is3[SA];
    }
  else error("mismatched expressions");
  return 0;
  }

level3 (is) int is[]; {return skim("||", EQ10f, 1, 0, level4,  is);}
level4 (is) int is[]; {return skim("&&", NE10f, 0, 1, level5,  is);}
level5 (is) int is[]; {return down("|",            0, level6,  is);}
level6 (is) int is[]; {return down("^",            1, level7,  is);}
level7 (is) int is[]; {return down("&",            2, level8,  is);}
level8 (is) int is[]; {return down("== !=",        3, level9,  is);}
level9 (is) int is[]; {return down("<= >= < >",    5, level10, is);}
level10(is) int is[]; {return down(">> <<",        9, level11, is);}
level11(is) int is[]; {return down("+ -",         11, level12, is);}
level12(is) int is[]; {return down("* / %",       13, level13, is);}

level13(is)  int is[];  {
  int k;
  char *ptr;
  if(match("++")) {                 /* ++lval */
    if(level13(is) == 0) {
      needlval();
      return 0;
      }
    step(rINC1, is, 0);
    return 0;
    }
  else if(match("--")) {            /* --lval */
    if(level13(is) == 0) {
      needlval();
      return 0;
      }
    step(rDEC1, is, 0);
    return 0;
    }
  else if(match("~")) {             /* ~ */
    if(level13(is)) fetch(is);
    gen(COM1, 0);
    is[CV] = ~ is[CV];
    return (is[SA] = 0);
    }
  else if(match("!")) {             /* ! */
    if(level13(is)) fetch(is);
    gen(LNEG1, 0);
    is[CV] = ! is[CV];
    return (is[SA] = 0);
    }
  else if(match("-")) {             /* unary - */
    if(level13(is)) fetch(is);
    gen(ANEG1, 0);
    is[CV] = -is[CV];
    return (is[SA] = 0);
    }
  else if(match("*")) {             /* unary * */
    if(level13(is)) fetch(is);
    if(ptr = is[ST]) is[TI] = ptr[TYPE];
    else             is[TI] = INT;
    is[SA] =       /* no (op 0) stage address */
    is[TA] =       /* not an address */
    is[TC] = 0;    /* not a constant */
    is[CV] = 1;    /* omit fetch() on func call */
    return 1;
    }
  else if(amatch("sizeof", 6)) {    /* sizeof() */
    int sz, p;  char *ptr, sname[NAMESIZE];
    if(match("(")) p = 1;
    else           p = 0;
    sz = 0;
    if     (amatch("unsigned", 8))  sz = INTSIZE;
    if     (amatch("int",      3))  sz = INTSIZE;
    else if(amatch("char",     4))  sz = 1;
    if(sz) {if(match("*"))          sz = PTRSIZE;}
    else if(symname(sname)
         && ((ptr = findloc(sname)) ||
             (ptr = findglb(sname)))
         && ptr[IDENT] != FUNCTION
         && ptr[IDENT] != LABEL)    sz = getint(ptr+SIZE, INTSIZE);
    else if(sz == 0) error("must be object or type");
    if(p) need(")");
    is[TC] = INT;
    is[CV] = sz;
    is[TA] = is[TI] = is[ST] = 0;
    return 0;
    }
  else if(match("&")) {             /* unary & */
    if(level13(is) == 0) {
      error("illegal address");
      return 0;
      }
    ptr = is[ST];
    is[TA] = ptr[TYPE];
    if(is[TI]) return 0;
    gen(POINT1m, ptr);
    is[TI] = ptr[TYPE];
    return 0;
    }
  else {
    k = level14(is);
    if(match("++")) {               /* lval++ */
      if(k == 0) {
        needlval();
        return 0;
        }
      step(rINC1, is, rDEC1);
      return 0;
      }
    else if(match("--")) {          /* lval-- */
      if(k == 0) {
        needlval();
        return 0;
        }
      step(rDEC1, is, rINC1);
      return 0;
      }
    else return k;
    }
  }

level14(is)  int *is; {
  int k, consta, val;
  char *ptr, *before, *start;
  k = primary(is);
  ptr = is[ST];
  blanks();
  if(ch == '[' || ch == '(') {
    int is2[7];                     /* allocate only if needed */

    null_is (is2);
    
    while(1) {
      if(match("[")) {              /* [subscript] */
        if(ptr == 0) {
          error("can't subscript");
          skip();
          need("]");
          return 0;
          }
        if(is[TA]) {if(k) fetch(is);}
        else       {error("can't subscript"); k = 0;}
        setstage(&before, &start);
        is2[TC] = 0;
        down2(0, 0, level1, is2, is2);
        need("]");
        if(is2[TC]) {
          clearstage(before, 0);
          if(is2[CV])
	    {             /* only add if non-zero */
	      if(ptr[TYPE] >> 2 == BPD)
		{
#ifdef INT32
		  gen(GETd2n, is2[CV] << LBPD);
#else
		  gen(GETw2n, is2[CV] << LBPD);
#endif
		}
	      else if(ptr[TYPE] >> 2 == BPW)
		{
#ifdef INT32
		  gen(GETd2n, is2[CV] << LBPW);
#else
		  gen(GETw2n, is2[CV] << LBPW);
#endif
		}
	      else
		{
#ifdef INT32
		  gen(GETd2n, is2[CV]);
#else
		  gen(GETw2n, is2[CV]);
#endif
		}
	      gen(ADD12, 0);
            }
          }
        else
	  {
	    if(ptr[TYPE] >> 2 == BPD)
	      {
		gen(DBL1, 0);
		gen(DBL1, 0);
	      }
	    else if(ptr[TYPE] >> 2 == BPW)
	      {
		gen(DBL1, 0);
	      }
	    gen(ADD12, 0);
          }
        is[TA] = 0;
        is[TI] = ptr[TYPE];
        k = 1;
        }
      else if(match("(")) {         /* function(...) */
        if(ptr == 0) callfunc(0);
        else if(ptr[IDENT] != FUNCTION) {
          if(k && !is[CV]) fetch(is);
          callfunc(0);
          }
        else callfunc(ptr);
        k = is[ST] = is[TC] = is[CV] = 0;
        }
      else return k;
      }
    }
  if(ptr && ptr[IDENT] == FUNCTION) {
    gen(POINT1m, ptr);
    is[ST] = 0;
    return 0;
    }
  return k;
  }

primary(is)  int *is; {
  char *ptr, sname[NAMESIZE];
  int k;
  if(match("(")) {                  /* (subexpression) */ 
    do k = level1(is); while(match(","));
    need(")");
    return k;
    }
  putint(0, is, 7 << LBPW);         /* clear "is" array */
  if(symname(sname)) {              /* is legal symbol */
    if(ptr = findloc(sname)) {      /* is local */
      if(ptr[IDENT] == LABEL) {
        experr();
        return 0;
        }
      gen(POINT1s, getint(ptr+OFFSET, INTSIZE));
      is[ST] = ptr;
      is[TI] = ptr[TYPE];
      if(ptr[IDENT] == ARRAY) {
        is[TA] = ptr[TYPE];
        return 0;
        }
      if(ptr[IDENT] == POINTER) {
        is[TI] = UINT;
        is[TA] = ptr[TYPE];
        }
      return 1;
      }
    if(ptr = findglb(sname)) {      /* is global */
      is[ST] = ptr;
      if(ptr[IDENT] != FUNCTION) {
        if(ptr[IDENT] == ARRAY) {
          gen(POINT1m, ptr);
          is[TI] = 
          is[TA] = ptr[TYPE];
          return 0;
          }
        if(ptr[IDENT] == POINTER)
          is[TA] = ptr[TYPE];
        return 1;
        }
      }
    else is[ST] = addsym(sname, FUNCTION, INT, 0, 0, &glbptr, AUTOEXT);
    return 0;
    }
  if(constant(is) == 0) experr();
  return 0;
  }

experr() {
  error("invalid expression");
#ifdef INT32
  gen(GETd1n, 0);
#else
  gen(GETw1n, 0);
#endif
  skip();
  }

/* attempt at right to left - do it later */
#ifdef LATER
pushargs (ptr, nargs)
char *ptr;
int nargs;
  {
    if (streq(lptr, ")") != 0)
      return;

    if(endst())
      return;

    if(ptr)
      {
	expression(&consta, &val);
	gen(PUSH1, 0);
      }
    else
      {
	gen(PUSH1, 0);
	expression(&consta, &val);
	gen(SWAP1s, 0);            /* don't push addr */
      }
    nargs = nargs + INTSIZE;         /* count args*BPW */

    if(match(",") == 0) break;
    
  }
#endif

callfunc(ptr)
char *ptr;      /* symbol table entry or 0 */
  {
    int nargs, consta, val;
    
    nargs = 0;
    blanks();                      /* already saw open paren */

    while(streq(lptr, ")") == 0)
      {
	if(endst())
	  break;
	if(ptr)
	  {
	    expression(&consta, &val);
	    gen(PUSH1, 0);
	  }
	else
	  {
	    gen(PUSH1, 0);
	    expression(&consta, &val);
	    gen(SWAP1s, 0);            /* don't push addr */
	  }
	nargs = nargs + INTSIZE;         /* count args*BPW */

	if(match(",") == 0) break;
      }
    need(")");
    if(ptr && (streq(ptr + NAME, "CCARGC") == 0))	/* accessing ... like va_args */
#ifdef INT32
      gen(ARGCNTn, nargs >> LBPD);		/* to get start of frame */
#else
      gen(ARGCNTn, nargs >> LBPW);		/* to get start of frame */
#endif
      
    if(ptr)
      gen(CALLm, ptr);
    else
      gen(CALL1, 0);
    gen(ADDSP, csp + nargs);
  }

/*
** true if is2's operand should be doubled
*/
fdouble (oper, is1, is2)
int oper, is1[], is2[];
{
  //////////////////////////////////////////////////////
  // This is a 'magic' function, its usage and function
  // are not so obvious
  //
  // Purpose:  when indexing an address we must know
  // what we are pointing at so that the indexsize is
  // proper, e,g,
  // charptr++,  should multiply index by a 1
  // shortptr++, should multiply index by a 2
  // intptr++,   should multiply index by a 4
  //
  // Algorithm:
  // IF
  // operation is ADD12 or SUB12
  // AND
  // is1 is an address (pointer, array or via & operator
  // AND
  // is2 is NOT an address (pointer, array or via & operator
  // THEN 
  // return the multiplication factor based on s1 (or true)
  // ELSE
  // return 0 (or false)
  //
  // Usage: The return value is used as a 'boolean'
  // for nonconstant values, indicating that runtime code
  // is necessary to do the necessary multiplication
  // For contant value the return value is used to do a compile-time
  // multiplication (shift actually)
  //

  if ((oper == ADD12 || oper == SUB12)
      && (is2[TA] == 0))
    {
      switch (is1[TA]>>2)
	{
	  default:
	  case 1:		// char
	    return (0);
	  case 2:		// short
	    return (1);
	  case 4:		// int
	    return (2);
	}
    }
  
  return (0);


  
/*
  - original code -
  if((oper != ADD12 && oper != SUB12)
     || (is1[TA] >> 2 != BPW)
     || (is2[TA]))
    
    return 0;

  
  return 1;
*/
}


step (oper, is, oper2) int oper, is[], oper2; {
  fetch(is);
  gen(oper, is[TA] ? (is[TA] >> 2) : 1);
  store(is);
  if(oper2) gen(oper2, is[TA] ? (is[TA] >> 2) : 1);
  }

store(is)
int is[];
  {
    char *ptr;
    
    if(is[TI])
      {                     /* putstk */
	if(is[TI] >> 2 == 1)
	  {
	    gen(PUTbp1, 0);
	  }
	else if(is[TI] >> 2 == 2)
	  {
	    gen(PUTwp1, 0);
	  }
	else
	  {
	    gen(PUTdp1, 0);
	  }
      }
    else
      {                          /* putmem */
	ptr = is[ST];
	if(ptr[IDENT] == POINTER)
	  {
#ifdef INT32	/* int and ptr-size are ALWAYS the same */
	  gen(PUTdm1, ptr);
#else
	  gen(PUTwm1, ptr);
#endif
	  }
	else if (ptr[TYPE] >> 2 == 1)
	  {
	    gen(PUTbm1, ptr);
	  }
	else if (ptr[TYPE] >> 2 == BPW)
	  {
	    gen(PUTwm1, ptr);
	  }
	else
	  {
	    gen(PUTdm1, ptr);
	  }
      }
  }

fetch(is)
int is[];
  {
    char *ptr;
    
    ptr = is[ST];
    if(is[TI])                          /* indirect */
      {
	if(is[TI] >> 2 == BPD)		/* pointer to DWORD */
	  {
	    gen(GETd1p,  0);
	  }
	else if(is[TI] >> 2 == BPW)	/* pointer to WORD */
	  {
	    /* if INT32 must make distinction between signed/unsigned <-- */
	    gen(GETw1p,  0);
	  }
	else
	  {
	    if(ptr[TYPE] & UNSIGNED)
	      gen(GETb1pu, 0);
	    else
	      gen(GETb1p,  0);
	  }
      } 
    else
      {					/* direct */
      
	if(ptr[IDENT] == POINTER)
	  {
#ifdef INT32
	    gen(GETd1m,  ptr);
#else
	    gen(GETw1m,  ptr);
#endif	    
	  }
	else if (ptr[TYPE] >> 2 == BPD)
	  {
	    gen(GETd1m,  ptr);
	  }
	else if (ptr[TYPE] >> 2 == BPW)
	  {
	    gen(GETw1m,  ptr);
	  }
	else
	  {
	    if(ptr[TYPE] & UNSIGNED)
	      gen(GETb1mu, ptr);
	    else
	      gen(GETb1m,  ptr);
	  }
      }
  }

constant(is)
int is[];
  {
    int offset;
    
    if (is[TC] = number(is + CV))
      {
#ifdef INT32
	gen(GETd1n,  is[CV]);
#else
	gen(GETw1n,  is[CV]);
#endif
      }
    else if(is[TC] = chrcon(is + CV))
      {
#ifdef INT32
	gen(GETd1n,  is[CV]);
#else
	gen(GETw1n,  is[CV]);
#endif
      }
    else if(string(&offset))
      {
	gen(POINT1l, offset);
      }
    else
      {
	return 0;
      }
    return 1;
  }

number(value)  int *value; {
  int k, minus;
  k = minus = 0;
  while(1) {
    if(match("+")) ;
    else if(match("-")) minus = 1;
    else break;
    }
  if(isdigit(ch) == 0) return 0;
  if(ch == '0') {
    while(ch == '0') inbyte();
    if(toupper(ch) == 'X') {
      inbyte();
      while(isxdigit(ch)) {
        if(isdigit(ch))
             k = k*16 + (inbyte() - '0');
        else k = k*16 + 10 + (toupper(inbyte()) - 'A');
        }
      }
    else while (ch >= '0' && ch <= '7')
      k = k*8 + (inbyte() - '0');
    }
  else while (isdigit(ch)) k = k*10 + (inbyte() - '0');
  if(minus) {
    *value = -k;
    return (INT);
    }
  if((*value = k) < 0) return (UINT);
  else                 return (INT);
  }

chrcon(value)
int *value;
  {
    int k;
    
    k = 0;
    if(match("'") == 0)
      return 0;
    while(ch != '\'')
      k = (k << 8) + (litchar() & 255);
    gch();
    *value = k;
    return (INT);
  }

string(offset) int *offset; {
  char c;
  if(match(quote) == 0) return 0;
  *offset = litptr;
  while (ch != '"') {
    if(ch == 0) break;
    stowlit(litchar(), 1);
    }
  gch();
  litq[litptr++] = 0;
  return 1;
  }

stowlit(value, size) int value, size; {
  if((litptr+size) >= LITMAX) {
    error("literal queue overflow");
    exit(ERRCODE);
    }
  putint(value, litq+litptr, size);
  litptr += size;
  }

litchar() {
  int i, oct;
  if(ch != '\\' || nch == 0) return gch();
  gch();
  switch(ch) {
    case 'n': gch(); return NEWLINE;
    case 't': gch(); return  9;  /* HT */
    case 'b': gch(); return  8;  /* BS */
    case 'f': gch(); return 12;  /* FF */
    }
  i = 3;
  oct = 0;
  while((i--) > 0 && ch >= '0' && ch <= '7')
    oct = (oct << 3) + gch() - '0';
  if(i == 2) return gch();
  else       return oct;
  }

/***************** pipeline functions ******************/

/*
** skim over terms adjoining || and && operators
*/
skim(opstr, tcode, dropval, endval, level, is)
  char *opstr;
  int tcode, dropval, endval, (*level)(), is[]; {
  int k, droplab, endlab;
  droplab = 0;
  while(1) {
    k = down1(level, is);
    if(nextop(opstr)) {
      bump(opsize);
      if(droplab == 0) droplab = getlabel();
      dropout(k, tcode, droplab, is);
      }
    else if(droplab) {
      dropout(k, tcode, droplab, is);
#ifdef INT32
      gen(GETd1n, endval);
#else
      gen(GETw1n, endval);
#endif
      gen(JMPm, endlab = getlabel());
      gen(LABm, droplab);
#ifdef INT32
      gen(GETd1n, dropval);
#else
      gen(GETw1n, dropval);
#endif
      gen(LABm, endlab);
      is[TI] = is[TA] = is[TC] = is[CV] = is[SA] = 0;
      return 0;
      }
    else return k;
    }
  }

/*
** test for early dropout from || or && sequences
*/
dropout(k, tcode, exit1, is)
  int k, tcode, exit1, is[]; {
  if(k) fetch(is);
  else if(is[TC])
    {
#ifdef INT32
      gen(GETd1n, is[CV]);
#else
      gen(GETw1n, is[CV]);
#endif
    }
  gen(tcode, exit1);          /* jumps on false */
  } 

/*
** drop to a lower level
*/
down(opstr, opoff, level, is)
  char *opstr;  int opoff, (*level)(), is[]; {
  int k;
  k = down1(level, is);
  if(nextop(opstr) == 0) return k;
  if(k) fetch(is);
  while(1) {
    if(nextop(opstr)) {
      int is2[7];     /* allocate only if needed */

      null_is (is2);
      
      bump(opsize);
      opindex += opoff;
      down2(op[opindex], op2[opindex], level, is, is2);
      }
    else return 0;
    }
  }

/*
** unary drop to a lower level
*/
down1(level, is) int (*level)(), is[]; {
  int k, *before, *start;
  setstage(&before, &start);
  k = (*level)(is);
  if(is[TC]) clearstage(before, 0);  /* load constant later */
  return k;
  }

/*
** binary drop to a lower level
*/
down2(oper, oper2, level, is, is2)
  int oper, oper2, (*level)(), is[], is2[]; {
  int *before, *start;
  char *ptr;
  int value;
  setstage(&before, &start);
  is[SA] = 0;                     /* not "... op 0" syntax */
  if(is[TC]) {                    /* consant op unknown */
    if(down1(level, is2)) fetch(is2);
    if(is[CV] == 0) is[SA] = snext;
    gen(GETw2n, is[CV] << fdouble(oper, is2, is));
    }
  else {                          /* variable op unknown */
    gen(PUSH1, 0);                /* at start in the buffer */
    if(down1(level, is2)) fetch(is2);
    if(is2[TC]) {                 /* variable op constant */
      if(is2[CV] == 0) is[SA] = start;
#ifdef INT32
      csp += BPD;                 /* adjust stack and */
#else
      csp += BPW;                 /* adjust stack and */
#endif
      clearstage(before, 0);      /* discard the PUSH */
      if(oper == ADD12) {         /* commutative */
#ifdef INT32
        gen(GETd2n, is2[CV] << fdouble(oper, is, is2));
#else
        gen(GETw2n, is2[CV] << fdouble(oper, is, is2));
#endif
        }
      else {                      /* non-commutative */
        gen(MOVE21, 0);
#ifdef INT32
        gen(GETd1n, is2[CV] << fdouble(oper, is, is2));
#else
        gen(GETw1n, is2[CV] << fdouble(oper, is, is2));
#endif
        }
      }
    else {                        /* variable op variable */
      gen(POP2, 0);
      if(value = fdouble(oper, is, is2))
	{
	  gen(DBL1, 0);		// index size 2
	  if (value > 1)
	    gen(DBL1, 0);	// .. or even 4
	}
      if(value = fdouble(oper, is2, is))
	{
	  gen(DBL2, 0);
	  if (value > 1)
	    gen(DBL2, 0);
	}
      }
    }
  if(oper) {
    if(nosign(is) || nosign(is2)) oper = oper2;
    if(is[TC] = is[TC] & is2[TC]) {               /* constant result */
      is[CV] = calc(is[CV], oper, is2[CV]);
      clearstage(before, 0);  
      if(is2[TC] == UINT) is[TC] = UINT;
      }
    else {                                        /* variable result */
      gen(oper, 0);
      if(oper == SUB12
      && is [TA] >> 2 == BPW
      && is2[TA] >> 2 == BPW) { /* difference of two word addresses */
        gen(SWAP12, 0);
        gen(GETw1n, 1);
        gen(ASR12, 0);          /* div by 2 */
        }
      is[OP] = oper;            /* identify the operator */
      }
    if(oper == SUB12 || oper == ADD12) {
      if(is[TA] && is2[TA])     /*  addr +/- addr */
        is[TA] = 0;
      else if(is2[TA]) {        /* value +/- addr */
        is[ST] = is2[ST];
        is[TI] = is2[TI];
        is[TA] = is2[TA];
        }
      }
    if(is[ST] == 0 || ((ptr = is2[ST]) && (ptr[TYPE] & UNSIGNED)))
      is[ST] = is2[ST];
    }
  }

/*
** unsigned operand?
*/
nosign(is) int is[]; {
  char *ptr;
  if(is[TA]
  || is[TC] == UINT
  || ((ptr = is[ST]) && (ptr[TYPE] & UNSIGNED))
    ) return 1;
  return 0;
  }

/*
** calcualte signed constant result
*/
calc(left, oper, right) int left, oper, right; {
  switch(oper) {
    case ADD12: return (left  +  right); 
    case SUB12: return (left  -  right);
    case MUL12: return (left  *  right); 
    case DIV12: return (left  /  right);
    case MOD12: return (left  %  right); 
    case EQ12:  return (left  == right); 
    case NE12:  return (left  != right);
    case LE12:  return (left  <= right); 
    case GE12:  return (left  >= right);
    case LT12:  return (left  <  right); 
    case GT12:  return (left  >  right);
    case AND12: return (left  &  right);
    case OR12:  return (left  |  right);
    case XOR12: return (left  ^  right); 
    case ASR12: return (left  >> right); 
    case ASL12: return (left  << right);
    } 
  return (calc2(left, oper, right));
  }

/*
** calcualte unsigned constant result
*/
calc2(left, oper, right) unsigned left, right; int oper; {
  switch(oper) {
    case MUL12u: return (left  *  right); 
    case DIV12u: return (left  /  right);
    case MOD12u: return (left  %  right); 
    case LE12u:  return (left  <= right); 
    case GE12u:  return (left  >= right);
    case LT12u:  return (left  <  right); 
    case GT12u:  return (left  >  right);
    } 
  return (0);
  }

