interpre.c

guide and some example with visualC++

	case stoulong: stoTYPE(ulval); break;
	case rvalulong: rvalTYPE(ulval); break;
	case pushulong: pushTYPE(ulval); break;
	case negulong: negTYPE(ulval); break;
	case addulong: addTYPE(ulval); break;
	case subulong: subTYPE(ulval); break;
	case divulong: divTYPE(ulval); break;
	case multulong: multTYPE(ulval); break;
	case modulong: modTYPE(ulval); break;
	case lshtulong: lshtTYPE(ulval); break;
	case rshtulong: rshtTYPE(ulval); break;
	case ltulong: ltTYPE(ulval); break;
	case leulong: leTYPE(ulval); break;
	case equlong: eqTYPE(ulval); break;
	case neulong: neTYPE(ulval); break;
	case gtulong: gtTYPE(ulval); break;
	case geulong: geTYPE(ulval); break;
	case lorulong: lorTYPE(ulval); break;

	case notulong: notTYPE(ulval); break;
	case borulong: borTYPE(ulval); break;
	case xorulong: xorTYPE(ulval); break;
	case andulong: andTYPE(ulval); break;
	case compulong: compTYPE(ulval); break;
	case ulong2double: castTYPES(ulval, dval, double); break;
	case ulong2ptr: castTYPES(ulval, p.p, void *); break;
	case ulong2int: castTYPES(ulval, ival, int); break;
	case ulong2llong: castTYPES(ulval, llval, eic_llong); break;



	  /* specific long long stuff */
	case incllong: STK[ToP].v.llval += InSt[p].val.ival; break;
	case decllong: STK[ToP].v.llval -= InSt[p].val.ival; break;
	case drefllong: drefTYPE(eic_llong, llval); break;
	case refllong: refTYPE(eic_llong, llval); break;
	case stollong: stoTYPE(llval); break;
	case rvalllong: rvalTYPE(llval); break;
	case pushllong: pushTYPE(llval); break;
	case negllong: negTYPE(llval); break;
	case addllong: addTYPE(llval); break;
	case subllong: subTYPE(llval); break;
	case divllong: divTYPE(llval); break;
	case multllong: multTYPE(llval); break;
	case modllong: modTYPE(llval); break;
	case lshtllong: lshtTYPE(llval); break;
	case rshtllong: rshtTYPE(llval); break;
	case ltllong: ltTYPE(llval); break;
	case lellong: leTYPE(llval); break;
	case eqllong: eqTYPE(llval); break;
	case nellong: neTYPE(llval); break;
	case gtllong: gtTYPE(llval); break;
	case gellong: geTYPE(llval); break;
	case lorllong: lorTYPE(llval); break;
	case landllong: landTYPE(llval); break;
	case notllong: notTYPE(llval); break;
	case borllong: borTYPE(llval); break;
	case xorllong: xorTYPE(llval); break;
	case andllong: andTYPE(llval); break;
	case compllong: compTYPE(llval); break;
	case llong2double: castTYPES(llval, dval, double); break;
	case llong2ptr: castTYPES(llval, p.p, void *); break;
	case llong2int: castTYPES(llval, ival, int); break;
	case llong2long: castTYPES(llval, lval, long); break;


	    /* specific double stuff */
	case incdouble:STK[ToP].v.dval += InSt[p].val.ival; break;
	case decdouble:STK[ToP].v.dval -= InSt[p].val.ival; break;
	case drefdouble: drefTYPE(double, dval); break;
	case refdouble: refTYPE(double, dval); break;
	case stodouble: stoTYPE(dval); break;
	case rvaldouble: rvalTYPE(dval); break;
	case pushdouble: pushTYPE(dval); break;
	case negdouble: negTYPE(dval); break;
	case adddouble: addTYPE(dval); break;
	case subdouble: subTYPE(dval); break;
	case divdouble: divTYPE(dval); break;
	case multdouble: multTYPE(dval); break;
	case ltdouble: ltTYPE(dval); break;
	case ledouble: leTYPE(dval); break;
	case eqdouble: eqTYPE(dval); break;
	case nedouble: neTYPE(dval); break;
	case gtdouble: gtTYPE(dval); break;
	case gedouble: geTYPE(dval); break;
	case lordouble: lorTYPE(dval); break;
	case landdouble: landTYPE(dval); break;
	case notdouble: notTYPE(dval); break;

	case double2int: castTYPES(dval, uival, unsigned int); break;
	case double2long: castTYPES(dval, ulval, unsigned long); break;
	case double2llong: castTYPES(dval, llval, eic_llong); break;
	case double2float: castTYPES(dval, fval, float); break;


	  /*specific pointer stuff */
	case incptr: STK[ToP].v.p.p = (char *) STK[ToP].v.p.p +
			 InSt[p].val.ival; break;
	case decptr: STK[ToP].v.p.p = (char *) STK[ToP].v.p.p -
			 InSt[p].val.ival; break;
	case lda:
#if 0
	    STK[ToP].v.p = AR[1][InSt[p].val.ival].v.p;
	    STK[ToP].v.p.p = (char*)STK[ToP].v.p.sp + InSt[p].ext;
	    STK[ToP].v.p.sp = STK[ToP].v.p.p;
#else

	    {
		ptr_t *q = &AR[1][InSt[p].val.ival].v.p;
		ptr_t *a = &STK[ToP].v.p;
		
		a->p   = a->sp = (char*)q->sp + InSt[p].ext;
		a->ep  = q->ep;

		if(vp) { /* patch previous lda assignment */
		    ((ptr_t*)vp)->ep = (char*)a->p;
		}
		/* Take advantage of the fact that the next InSt
		 * has the location of where `a' is to be stored.
		 */
		vp = &AR[1][InSt[p+1].val.ival].v.p;
		
	    }
	    
#endif
	    
	    break;
	case ixa:
	    ToP--;
	    STK[ToP].v.p.p = (char *) STK[ToP].v.p.p + STK[ToP+1].v.ival*InSt[p].val.ival;
	    break;
	case addptr2int: ToP--;
	    STK[ToP].v.p.p = (char *) STK[ToP].v.p.p + STK[ToP + 1].v.ival; break;
	case addint2ptr: ToP--;
	    STK[ToP].v.p.p = STK[ToP].v.ival
		+ (char *) STK[ToP+1].v.p.p; break;
	case subptrint: ToP--;
	    STK[ToP].v.p.p = (char *) STK[ToP].v.p.p - STK[ToP + 1].v.ival; break;
	case subptr:
	    ToP--;
	    STK[ToP].v.ival =
		(int) ((long) STK[ToP].v.p.p - (long) STK[ToP+1].v.p.p);
	    break;

	case drefptr:   drefTYPE(ptr_t, p); break;

	case drefuptr:  drefTYPE(void**,p.p);
	                STK[ToP].v.p.sp = 0;
			STK[ToP].v.p.ep = (void *) ULONG_MAX;
			break;

	case refptr: refTYPE(ptr_t, p); break;
	case refuptr: refTYPE(void *, p.p); break;

	case stoptr: stoTYPE(p); break;
	case stouptr: stoTYPE(p.p); break;
	    
	case rvalptr: rvalTYPE(p); break;
	case rvaluptr: rvalTYPE(p);
	  STK[ToP].v.p.sp = 0;
	  STK[ToP].v.p.ep = (void*) ULONG_MAX; /* set to a very high value */
	    break;

	case pushptr: pushTYPE(p); break;
	case ltptr: ltTYPE(p.p); break;
	case leptr: leTYPE(p.p); break;
	case eqptr: eqTYPE(p.p); break;
	case neptr: neTYPE(p.p); break;
	case gtptr: gtTYPE(p.p); break;
	case geptr: geTYPE(p.p); break;
	case lorptr: lorTYPE(p.p); break;
	case landptr: landTYPE(p.p); break;
	case notptr: notTYPE(p.p); break;
	case ptr2int: castTYPES(p.p, ival, int); break;
	case ptr2long: castTYPES(p.p, lval, long); break;
	    
	case lval: /* on the fly safe pointer */
	    STK[ToP].v.p.p = &AR[InSt[p].ext][InSt[p].val.ival].v;
	    STK[ToP].v.p.ep = (char *) STK[ToP].v.p.p + (size_t) 
		InSt[p].val.p.ep;
	    STK[ToP].v.p.sp = STK[ToP].v.p.p;
	    break;
	case assigntype: assignTYPE; break;
	case stoval:
	    switch(InSt[p].ext) {
	      case t_char:
	      case t_uchar: STK[ToP].v.cval = STK[ToP].v.ival; break;
	      case t_short:
	      case t_ushort: STK[ToP].v.sval = STK[ToP].v.ival; break;
	      case t_float:  STK[ToP].v.fval = STK[ToP].v.dval;
/*	      case t_struct:
	      case t_union:
		printf("stoVa1l with struct/union\n");
*/
	    }

	    stoVAL; break;
	case pushval: pushVAL; break;
	    
	case eiccall:

	    if(!((symentry_t*)STK[ToP - 1].v.p.p)->tag) {
		AdjustTop(6);
		STK[ToP + 1].v.ival = p;
		STK[ToP + 1].type = (void*)EiC_CurrentFile; /* save file */
		STK[ToP + 2].v.p.p = InSt;
		STK[ToP + 3].v.lval = AR[1] - env->LAR;
		STK[ToP + 4].v.ival = env->lsp - STK[ToP].v.ival;
	    
		AR[1] = &env->LAR[env->lsp] /* - STK[ToP].v.ival] */ ;
		code = ! STK[ToP - 1].v.p.p ? NULL :
		    AR[0][((symentry_t *)
			   STK[ToP - 1].v.p.p)->val.ival].v.p.p;

		if (code == NULL) {
		    if(STK[ToP - 1].v.p.p) {
			EiC_formatMessage("Link error: undefined function :-> %s\n",
					  ((symentry_t *) STK[ToP - 1].v.p.p)->id);
		    } else
			EiC_formatMessage("Link error: possible usage of a function pointer"
					  " before assignment.\n");
		    env->lsp = 0;
		    raise(SIGINT);
		}
	    
		EiC_CurrentFile = codeName(code);

		InSt = code->inst;
		p = -1;
		ToP += 5;
		if(EiC_traceON)
		    lastln = -1;
		break;
	    }

	case call: 
	  argc = ARGC;
	  hold_AR = AR[2];
	  hold_AR1 = AR[1];
	  ARGC = STK[ToP].v.ival;
	  
          /*AR[2] = &env->LAR[env->lsp - ARGC];*/
	    AR[2] = &env->LAR[env->lsp];
	    if(InSt[p].ext)
		STK[ToP - 1].v = STK[ToP - 1].v.vfunc ();
	    else
		STK[ToP - 1].v.vfunc();
	    env->lsp -= STK[ToP].v.ival;
	    ARGC = argc;
	    AR[2] = hold_AR;
	    AR[1] = hold_AR1;
	    ToP--; break;

	case eicreturn:
	    ToP -= 6;		/* over write code pointer */

	    p = STK[ToP + 2].v.ival;
	    EiC_CurrentFile = (char*)STK[ToP+2].type;
	    
	    InSt = STK[ToP + 3].v.p.p;
	
	    env->lsp = STK[ToP + 5].v.ival;
	    STK[ToP].v = STK[ToP + 6].v;

	    AR[1] = &env->LAR[STK[ToP + 4].v.ival];
	    if(EiC_traceON) {
		EiC_eicpop(&names,&v);
		EiC_formatMessage("\n[%s] ", (char*)v.p.p);
		lastln = -1;
	    }
	    break;


#if 1
	case __eiclongjmp:
	{

	    _EiC_jmp_buf * reg;

	    reg = (_EiC_jmp_buf *) ((char*)STK[ToP].v.p.p - STK[ToP+1].v.ival);

	    p = reg->p;
	    EiC_CurrentFile = reg->file;
	    InSt = reg->inst;
	    env->lsp = reg->lsp;
	    AR[1] = &env->LAR[reg->offset]; /*reg->ar; */

	    if(STK[ToP+1].v.ival == 0)
		 STK[reg->top].v.ival = 1;
	    else
		 STK[reg->top].v.ival = STK[ToP+1].v.ival;

	    ToP = reg->top;


	}

	break;
	    
	case __eicsetjmp:
	{

	    _EiC_jmp_buf * reg;

	    reg = (_EiC_jmp_buf *) STK[ToP].v.p.p;

	    reg->p = p;
	    reg->file = (void*)EiC_CurrentFile; /* save file */
	    reg->inst = InSt;
	    reg->lsp =  env->lsp;
	    reg->offset = AR[1] - env->LAR;
	    reg->ar = AR[1];
	    reg->top = ToP;

	    STK[ToP].v.ival = 0;

	}

	break;
#endif

        case massign:   
	    {
		val_t *v = &AR[InSt[p].ext][InSt[p].val.ival].v;
		v->p.sp = (void*)xcalloc(STK[ToP].v.ival,1);
		v->p.ep = (char*)v->p.sp + STK[ToP].v.ival;
		vp = NULL;
		
	    }
	    break;
	case fmem: FMEM; break;
	case refmem: refMEM; break;
	case minit:
	    memcpy(STK[ToP].v.p.p,InSt[p].val.p.p, InSt[p].ext); 
	    break;
	case reducear:
	    env->lsp -= InSt[p].val.ival;
	    break;
	case checkar:{
	      size_t d;
	      ptrdiff_t d2;
	      d = env->LARsize - env->lsp;
	      if (d < InSt[p].val.ival) {
		  /* printf("expanding AR %d\n",env->LARsize);*/
		  d2 = (AR[1] - env->LAR);
		  env->LARsize += InSt[p].val.ival - d;
		  env->LAR =
		      (AR_t *) xrealloc(env->LAR,
					env->LARsize * sizeof(AR_t));
		  AR[1] = &env->LAR[(size_t) d2];
	      }
	      if (InSt[p].ext == 0) {
		  env->lsp += InSt[p].val.ival;
		  /*AR[1][0].v.p.p = NULL;*/
	      }
	  }
	    break;
	case halt: STK[ToP].type = InSt[p].val.p.p;
	      ON = 0;  EiC_STaCK_VaLuE = STK[ToP].v; break;

	case empty: break;
	    
	}
	p++;
    }


    end = clock();
    if(EiC_traceON)
	EiC_messageDisplay("\n");
    
    if(EiC_interActive)
	EiC_showvalue(&STK[ToP]);
    
    if (EiC_TIMER) {
	fprintf(stdout," <time taken>: %g\n",
		(end-start)/(float)CLOCKS_PER_SEC);
    }
    
    xfree(STK);
}