typesets.c

guide and some example with visualC++

	    break;
	  case LSHT:
	    e1->Val.ulval <<= e2->Val.ulval;
	    break;
	  case RSHT:
	    e1->Val.ulval >>= e2->Val.ulval;
	    break;
	  case AND:
	    e1->Val.ulval = e1->Val.ulval & e2->Val.ulval;
	    break;
	  case BOR:
	    e1->Val.ulval = e1->Val.ulval | e2->Val.ulval;
	    break;
	  case XOR:
	    e1->Val.ulval = e1->Val.ulval ^ e2->Val.ulval;
	    break;
	  default:
	    EiC_set_bastype(t_int, e1->Type);
	    switch (op) {
	      case LT:
		e1->Val.ival = e1->Val.ulval < e2->Val.ulval;
		break;
	      case LE:
		e1->Val.ival = e1->Val.ulval <= e2->Val.ulval;
		break;
	      case EQ:
		e1->Val.ival = e1->Val.ulval == e2->Val.ulval;
		break;
	      case NE:
		e1->Val.ival = e1->Val.ulval != e2->Val.ulval;
		break;
	      case GT:
		e1->Val.ival = e1->Val.ulval > e2->Val.ulval;
		break;
	      case GE:
		e1->Val.ival = e1->Val.ulval >= e2->Val.ulval;
		break;
	    }
	    break;
	}
	break;
      case t_pointer:
	switch (op) {
	  case LT:
	    e1->Val.ival = e1->Val.p.p < e2->Val.p.p;
	    break;
	  case LE:
	    e1->Val.ival = e1->Val.p.p <= e2->Val.p.p;
	    break;
	  case EQ:
	    e1->Val.ival = e1->Val.p.p == e2->Val.p.p;
	    break;
	  case NE:
	    e1->Val.ival = e1->Val.p.p != e2->Val.p.p;
	    break;
	  case GT:
	    e1->Val.ival = e1->Val.p.p > e2->Val.p.p;
	    break;
	  case GE:
	    e1->Val.ival = e1->Val.p.p >= e2->Val.p.p;
	    break;
	  default:
	    EiC_error("Illegal constant pointer operation");
	}
	e1->Type = EiC_addtype(t_int, EiC_freetype(e1->Type));
	setConst(e1->Type);
	break;	
      default:
	EiC_error("Illegal constants");
    }
    return 1;
}

void * EiC_getaddress(token_t * e1)
{
    void *p = NULL;
    int t = EiC_gettype(e1->Type);
    switch (t) {
	case t_builtin:
	    if (e1->Sym->val.vfunc != 0)
		p = (void*)e1->Sym->val.vfunc;
	    else
		EiC_error("No link to builtin function");
	    e1->Type = EiC_addtype(t_pointer, e1->Type);
	    break;
	case t_funcdec:
	case t_func:
	    p = e1->Sym;
	    e1->Type = EiC_addtype(t_pointer, e1->Type);
	    break;
	case t_union:
	case t_struct:
	    EiC_error("Illegal use of structure or uion: need an lvalue");
	case t_array:
	    if (t == t_array)
		EiC_exchtype(t_pointer, e1->Type);
	case t_pointer:
	    
	    if(e1->Sym && EiC_gettype(e1->Sym->type) == t_ref) 
		p = EiC_ENV->AR[e1->Sym->val.ival].v.p.p;
	    else
		p = &EiC_ENV->AR[e1->Sym->val.ival].v;
	    break;

	default:
	    /* watch out 4 reference variables */
	    if(e1->Sym && EiC_gettype(e1->Sym->type) == t_ref) {
		e1->Type = EiC_succType(e1->Type);
		if(EiC_gettype(e1->Type) != t_pointer)
		    EiC_error("Illegal use of reference variable: %s", e1->Sym->id);
		p = *(void**)EiC_ENV->AR[e1->Sym->val.ival].v.p.p;
	    } else
		EiC_error("Unknown type: need an lvalue");
    }
    return p;
}

void derefConst(token_t * e1)
{
    /* assumes incoming type is a ptr or array */
    
    e1->Type = EiC_succType(e1->Type);
    
    switch(EiC_gettype(e1->Type)) {
      case t_char:  case t_uchar:
      case t_short: case t_ushort:
      case t_int:   case t_uint:
      case t_long:  case t_ulong:
    case t_llong:
      case t_float: case t_double:
      case t_pointer:
      case t_union:
      case t_struct:
	EiC_generate(&e1->Code,pushptr,&e1->Val, 0);
	e1->Type = EiC_addtype(t_lval,e1->Type);
	 break;
      case t_void:
	return;
      case t_array:
        EiC_exchtype(t_pointer,e1->Type);
	setConst(e1->Type);
        
        break;
      default:
	EiC_error("Unknown const in derefConst");
    }

}

#if 0
void EiC_addRval(code_t * code, int type, val_t *v, int st)
{
    /* optomise away rvals  */
    int i;
    if((i=nextinst(code))) 
	if(IsSto_op(opcode(code,i-1)) && ivalcode(code,i) == ivalcode(code,i-1))
	    return;

    EiC_generate(code,type,v,st);
}
#endif

void EiC_output(token_t * e1)
{
    static val_t v;
    if (e1->Pflag == 0) {
	int t = EiC_gettype(e1->Type);

	if(isconst(e1->Type)) {
	    switch (t) {
	    CASE_INT:
		EiC_generate(&e1->Code, pushint, &e1->Val, 0); break;
	    CASE_UINT:
		EiC_generate(&e1->Code, pushuint, &e1->Val, 0); break;
	    CASE_LONG:
		EiC_generate(&e1->Code, pushlong, &e1->Val, 0); break;
	    CASE_ULONG:
		EiC_generate(&e1->Code, pushulong, &e1->Val, 0); break;
		case t_llong: EiC_generate(&e1->Code, pushllong, &e1->Val, 0);
		    break;
	    CASE_FLOAT:EiC_generate(&e1->Code, pushdouble, &e1->Val, 0);
	    break;
		case t_union:
		case t_struct:
		case t_array:
		    if (t == t_array)
			EiC_exchtype(t_pointer, e1->Type);
		case t_pointer:
		    EiC_generate(&e1->Code, pushptr, &e1->Val, 0);
		    break;
		case t_void:
		    return;
		default:
		    EiC_error("Unknown const type through output");
	    }
	    e1->Pflag =1;
	    unsetConst(e1->Type);
	    return;
	} 
	
	switch (t) {
	    case t_char:
		EiC_generate(&e1->Code, rvalchar, &e1->Val, EiC_GI(e1));
		EiC_exchtype(t_int,e1->Type);
		break;
	    case t_uchar:
		EiC_generate(&e1->Code, rvaluchar, &e1->Val, EiC_GI(e1));
		EiC_exchtype(t_int,e1->Type);
		break;
	    case t_short:
		EiC_generate(&e1->Code, rvalshort, &e1->Val, EiC_GI(e1));
		EiC_exchtype(t_int,e1->Type);
		break; 
	    case t_ushort:
		EiC_generate(&e1->Code, rvalushort, &e1->Val, EiC_GI(e1));
		EiC_exchtype(t_int,e1->Type);
		break;
	    case t_int:
	    case t_uint:
		/*EiC_addRval(&e1->Code, rvalint, &e1->Val, EiC_GI(e1));*/
		EiC_generate(&e1->Code, rvalint, &e1->Val, EiC_GI(e1));
		break;
	CASE_LONG:
	CASE_ULONG:EiC_generate(&e1->Code, rvallong, &e1->Val, EiC_GI(e1));
	break;
	    
	    case t_llong:
		EiC_generate(&e1->Code, rvalllong, &e1->Val, EiC_GI(e1)); break;

	    case t_float:
		EiC_generate(&e1->Code, rvalfloat, &e1->Val,EiC_GI(e1));
		EiC_exchtype(t_double,e1->Type);
		break;
	    
	    case t_double:
		EiC_generate(&e1->Code, rvaldouble, &e1->Val,EiC_GI(e1));
		break;

	    case t_builtin:
		if (e1->Sym->val.vfunc != 0) {
		    v.vfunc = e1->Sym->val.vfunc;
		    EiC_generate(&e1->Code, pushptr, &v, 0);
		    e1->Type = EiC_addtype(t_pointer, e1->Type);
		} else
		    EiC_error("No link to builtin function");
		break;
	    case t_funcdec:
		EiC_exchtype(t_func, e1->Type);
	    case t_func:
		v.p.p = e1->Sym;
		EiC_generate(&e1->Code, pushptr, &v, 0);
		e1->Type = EiC_addtype(t_pointer, e1->Type);
		break;
	    case t_union:
	    case t_struct:
	    case t_array:
		if (t == t_array)
		    EiC_exchtype(t_pointer, e1->Type);
	    case t_pointer:
		if(issafe(e1->Type))
		    EiC_generate(&e1->Code, rvalptr, &e1->Val, EiC_GI(e1));
		else
		    EiC_generate(&e1->Code, rvaluptr, &e1->Val, EiC_GI(e1));
		break;

	    case t_ref:
 	    
		EiC_generate(&e1->Code, rvaluptr, &e1->Val, EiC_GI(e1));
 	    
		return;

	    case t_lval:
		e1->Type = EiC_succType(e1->Type);
		switch (EiC_gettype(e1->Type)) {
		    case t_uchar:
			EiC_generate(&e1->Code, drefuchar, &e1->Val, 0);
			break;
		    case t_char:
			EiC_generate(&e1->Code, drefchar, &e1->Val, 0);
			break;
		    case t_short:
			EiC_generate(&e1->Code, drefshort, &e1->Val, 0);
			break;
		    case t_ushort:
			EiC_generate(&e1->Code, drefushort, &e1->Val, 0);
			break;
		    case t_int:
			EiC_generate(&e1->Code, drefint, &e1->Val, 0);
			break;
		    case t_uint:
			EiC_generate(&e1->Code, drefuint, &e1->Val, 0);
			break;
		CASE_LONG:EiC_generate(&e1->Code, dreflong, &e1->Val, 0);
		break;
		CASE_ULONG:EiC_generate(&e1->Code, drefulong, &e1->Val, 0);
		break;
		    case t_llong:EiC_generate(&e1->Code, drefllong, &e1->Val, 0);
			break;
		    case t_float:
			EiC_generate(&e1->Code, dreffloat, &e1->Val, 0);
			break;
		    case t_double:
			EiC_generate(&e1->Code, drefdouble, &e1->Val, 0);
			break;
		    case t_array:
		    case t_struct:
		    case t_union:
			break;
		    case t_pointer:
			if(issafe(e1->Type))
			    EiC_generate(&e1->Code, drefptr, &e1->Val, EiC_GI(e1));
			else
			    EiC_generate(&e1->Code, drefuptr, &e1->Val, EiC_GI(e1));
			break;
		
		    case t_funcdec:
		    case t_func:
			e1->Type = EiC_succType(e1->Type);
			if(EiC_gettype(nextType(e1->Type)) == t_void)
			    EiC_generate(&e1->Code, eiccall, &e1->Val, 0);
			else
			    EiC_generate(&e1->Code, eiccall, &e1->Val, 1);
			break;
		    case t_builtin:
			if(EiC_gettype(nextType(e1->Type)) == t_void)
			   EiC_generate(&e1->Code, call, &e1->Val, 0);
			else
			    EiC_generate(&e1->Code, call, &e1->Val, 1);
			e1->Type = EiC_succType(e1->Type);
			break;
		    default:
			EiC_error("Illegal lvalue");
			break;
		}
		break;
	    case t_void:
		return;

	    case ID:
		EiC_error("Undeclared identifier %s",e1->Sym->id);
		break;

	    default:
		EiC_error("Unknown type through output");
		return;
	}
	e1->Pflag = 1;
    }
}

void EiC_do_inc_dec(token_t * e1, int op)
{
    val_t v;
    int t;
    
    switch (EiC_gettype(e1->Type)) {
      CASE_INT:
	t = EiC_gettype(e1->Type);
	EiC_output(e1);
	v.ival = 1;
	if (op == INC)
	    op = incint;
	else
	    op = decint;
	EiC_exchtype(t,e1->Type);
	break;
      CASE_UINT:
	t = EiC_gettype(e1->Type);
	EiC_output(e1);
	v.ival = 1;
	if (op == INC)
	    op = incuint;
	else
	    op = decuint;
	EiC_exchtype(t,e1->Type);
	break;
      CASE_LONG:
	EiC_output(e1);
	v.ival = 1;
	if (op == INC)
	    op = inclong;
	else
	    op = declong;
	break;
      CASE_ULONG:
	EiC_output(e1);
	v.ival = 1;
	if (op == INC)
	    op = inculong;
	else
	    op = deculong;
	break;
    case t_llong:
	EiC_output(e1);
	v.ival = 1;
	if (op == INC)
	    op = incllong;
	else
	    op = decllong;
	break;
      
      case t_pointer:
	EiC_output(e1);
	v.ival = EiC_get_sizeof(nextType(e1->Type));
	if (op == INC)
	    op = incptr;
	else
	    op = decptr;
	break;
      case t_lval:
	v.ival = 1;
	EiC_generate(&e1->Code, dupval, &v, 0);
	EiC_output(e1);
	EiC_do_inc_dec(e1, op);
	v.ival = 1;
	/*EiC_generate(&e1->Code, bump, &v, 0);*/
	e1->Type = EiC_addtype(t_lval, e1->Type);
	return;
      case t_float:
      case t_double:
	t = EiC_gettype(e1->Type);
	EiC_output(e1);
	v.ival = 1;
	if (op == INC)
	    op = incdouble;
	else
	    op = decdouble;
	EiC_exchtype(t,e1->Type);
	break;
	
      default:
	EiC_error("Cannot apply inc\\dec");
	return;
    }
    EiC_generate(&e1->Code, op, &v, 0);
}

void EiC_do_stooutput(token_t * e1)
{
    
    if (e1->Pflag == 0) {
	switch (EiC_gettype(e1->Type)) {
	  case t_char:
	  case t_uchar:
	    EiC_generate(&e1->Code, stochar, &e1->Val, EiC_GI(e1));
	    break;
	  case t_short:
	  case t_ushort:
	    EiC_generate(&e1->Code, stoshort, &e1->Val, EiC_GI(e1));
	    break;
	  case t_int:
	  case t_uint:
	    EiC_generate(&e1->Code, stoint, &e1->Val, EiC_GI(e1));
	    break;
	  CASE_LONG:
	  CASE_ULONG:EiC_generate(&e1->Code, stolong, &e1->Val, EiC_GI(e1));
	    break;
	case t_llong:EiC_generate(&e1->Code, stollong, &e1->Val, EiC_GI(e1));
	    break;

	  case t_float:
	    EiC_generate(&e1->Code, stofloat, &e1->Val, EiC_GI(e1));
	    break;
	  case t_double:
	    EiC_generate(&e1->Code, stodouble, &e1->Val, EiC_GI(e1));
	    break;
	  case t_pointer:
	    if(issafe(e1->Type))
	      EiC_generate(&e1->Code, stoptr, &e1->Val, EiC_GI(e1));
	    else
	      EiC_generate(&e1->Code, stouptr, &e1->Val, EiC_GI(e1));
	    break;
	  case t_struct:
	  case t_union:{
	      val_t v;
	      v.ival = EiC_get_sizeof(e1->Type);
	      EiC_output(e1);
	      EiC_generate(&e1->Code, refmem, &v, 0);
	  }
	    break;
	  case t_lval:
	    e1->Type = EiC_succType(e1->Type);
	    if(isconst(e1->Type) || isconstp(e1->Type))
		EiC_error("Illegal assignment operation");
	    switch (EiC_gettype(e1->Type)) {
	      case t_uchar:
	      case t_char:
		EiC_generate(&e1->Code, refchar, &e1->Val, 0);
		break;
	      case t_short:
	      case t_ushort:
		EiC_generate(&e1->Code, refshort, &e1->Val, 0);
		break;
	      case t_int:
	      case t_uint:
		EiC_generate(&e1->Code, refint, &e1->Val, 0);
		break;
	      CASE_LONG:EiC_generate(&e1->Code, reflong, &e1->Val, 0);
		break;
	      CASE_ULONG:EiC_generate(&e1->Code, refulong, &e1->Val, 0);
		break;
	    case t_llong:
	      EiC_generate(&e1->Code, refllong, &e1->Val, 0);
		break;
	      case t_float:
		EiC_generate(&e1->Code, reffloat, &e1->Val, 0);
		break;
	      case t_double:
		EiC_generate(&e1->Code, refdouble, &e1->Val, 0);
		break;
	      case t_pointer:
		if(issafe(e1->Type))
		    EiC_generate(&e1->Code, refptr, &e1->Val, EiC_GI(e1));
		else
		    EiC_generate(&e1->Code, refuptr, &e1->Val, EiC_GI(e1));
		break;
	      case t_struct:
	      case t_union:{
		  val_t v;
		  v.ival = EiC_get_sizeof(e1->Type);
		  EiC_generate(&e1->Code, refmem, &v, 0);
	      }
		break;
	      default:
		EiC_error("Illegal lvalue");
		break;
	    }
	    break;
	  default:
	    EiC_error(" Invalid assignment");
	    break;
	}
	e1->Pflag = 1;
    }
}

void binhconst(unsigned opr, token_t * e1, token_t * e2)
{
    void (*f) (unsigned, token_t *, token_t *);
    int t;

    if(!e1->Pflag && isconst(e1->Type) && isconst(e2->Type)) {
      if(e2->Pflag) 
	EiC_output(e1);
      else {
	do_binaryop(e1, e2, opr);
	return;
      }
    
    }
    /*
     * Now perform usual arithmetic conversion
     * i.e promote to larger type.
     */

    if(EiC_gettype(e1->Type) < EiC_gettype(e2->Type))
	t = EiC_gettype(e2->Type);
    else
	t = EiC_gettype(e1->Type);
    
    switch (t) {
      CASE_INT:     f = binhint;    break;
      CASE_UINT:    f = binhuint;   break;
      CASE_LONG:    f = binhlong;   break;
      CASE_ULONG:   f = binhulong;  break;
      CASE_FLOAT:   f = binhdouble; break;
      case t_llong: f = binhllong;  break;
      
      case t_array:
      case t_pointer:
	f = EiC_binhlval;
	break;
      default:
	EiC_error("Unknown type in binhconst");
	return;
    }
    (*f) (opr, e1, e2);
}