interpre.c

guide and some example with visualC++

/* interpre.c
 *
 *	(C) Copyright Apr 15 1995, Edmond J. Breen.
 *		   ALL RIGHTS RESERVED.
 * This code may be copied for personal, non-profit use only.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <stddef.h>
#include <string.h>
#include <time.h>
#include <limits.h>

#include "MachSet.h"
#include "global.h"
#include "xalloc.h"
#include "typemod.h"
#include "symbol.h"

#include "error.h"

/* make a safe memory block */
#define MASSIGN \

#define checkPtr(P,s,i) \
if(( (char *)P.p + i ) > (char *) P.ep || P.p < P.sp) {\
     if(( (char *)P.p + i ) > (char *) P.ep) {\
	 EiC_messageDisplay(s ": attempted beyond allowed access area\n"); }\
     else\
	 EiC_messageDisplay(s ": attempted before allowed access area\n");\
     raise(SIGSEGV);\
}


#define FMEM         xfree(AR[InSt[p].ext][InSt[p].val.ival].v.p.sp)

#define LDA                     

#define LVAL

#define stoTYPE(x)   AR[InSt[p].ext][InSt[p].val.ival].v.x =STK[ToP].v.x
#define stoVAL   	 env->LAR[env->lsp].v = STK[ToP].v;env->lsp++
#define pushVAL   	 STK[ToP].v = InSt[p].val;
#define assignTYPE	 env->LAR[env->lsp-1].type = InSt[p].val.p.p
 
#define rvalTYPE(x) STK[ToP].v.x = AR[InSt[p].ext][InSt[p].val.ival].v.x
 

										   
#define drefTYPE(x,y)  checkPtr(STK[ToP].v.p,"READ", sizeof(x) );\
                       STK[ToP].v.y = *(x*)STK[ToP].v.p.p



#define refTYPE(x,y)   ToP--;\
		       checkPtr(STK[ToP].v.p,"WRITE", sizeof(x) );\
		       *(x*)STK[ToP].v.p.p = STK[ToP+1].v.y;\
                       STK[ToP].v.y = STK[ToP+1].v.y

#define refMEM        ToP--;\
        memcpy(STK[ToP].v.p.p,STK[ToP+1].v.p.p,InSt[p].val.ival);\
        STK[ToP].v.p.sp = STK[ToP].v.p.p;\
        STK[ToP].v.p.ep = (char*)STK[ToP].v.p.p + InSt[p].val.ival;



#define pushTYPE(x)  STK[ToP].v.x = InSt[p].val.x
 
#define  castTYPES(x,y,T)  STK[ToP].v.y = (T)STK[ToP].v.x
 
#define negTYPE(x)   STK[ToP].v.x =  -STK[ToP].v.x
#define addTYPE(x)   ToP--; STK[ToP].v.x += STK[ToP+1].v.x
#define subTYPE(x)   ToP--; STK[ToP].v.x -= STK[ToP+1].v.x
#define divTYPE(x)   ToP--; STK[ToP].v.x /= STK[ToP+1].v.x
#define multTYPE(x)  ToP--;  STK[ToP].v.x *= STK[ToP+1].v.x
#define modTYPE(x)   ToP--;  STK[ToP].v.x %= STK[ToP+1].v.x
#define lshtTYPE(x)  ToP--; STK[ToP].v.x <<= STK[ToP+1].v.x
#define rshtTYPE(x)  ToP--; STK[ToP].v.x >>= STK[ToP+1].v.x
#define ltTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x < STK[ToP+1].v.x
#define leTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x <= STK[ToP+1].v.x
#define eqTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x == STK[ToP+1].v.x
#define neTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x != STK[ToP+1].v.x
#define gtTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x > STK[ToP+1].v.x
#define geTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x >= STK[ToP+1].v.x
#define lorTYPE(x)  ToP--; STK[ToP].v.ival = STK[ToP].v.x || STK[ToP+1].v.x
#define landTYPE(x)  STK[ToP].v.ival = STK[ToP].v.x != 0

#define notTYPE(x)  STK[ToP].v.ival = !STK[ToP].v.x
 
#define borTYPE(x)  ToP--; STK[ToP].v.x = STK[ToP].v.x | STK[ToP+1].v.x
#define xorTYPE(x)  ToP--; STK[ToP].v.x = STK[ToP].v.x ^ STK[ToP+1].v.x
#define andTYPE(x)  ToP--; STK[ToP].v.x = STK[ToP].v.x & STK[ToP+1].v.x
#define compTYPE(x) STK[ToP].v.x = ~STK[ToP].v.x
 
#define jmpfTYPE(x)  if(STK[ToP].v.x == 0) {\
                          STK[ToP].v.ival = 0;\
                          p += InSt[p].val.ival-1;\
                     } else\
                       STK[ToP].v.ival = 1

#define jmptTYPE(x)  if(STK[ToP].v.x != 0) {\
                          STK[ToP].v.ival = 1;\
                          p += InSt[p].val.ival-1;\
                     } else\
                       STK[ToP].v.ival = 0

#define  AdjustTop(x)   if(ToP + (x) >= stksz) {\
			  stksz += stacksize; \
			  STK =  (STK_t *) xrealloc(STK,sizeof(STK_t)\
						    * stksz); \
					  }

extern unsigned int EiC_CurrentLine;
extern char *EiC_CurrentFile;

extern int EiC_traceON;
extern int EiC_traceFunc;
extern int EiC_interActive;



#define stacksize 200
typedef AR_t STK_t;

STK_t *AR[3];
size_t ARGC;

val_t EiC_STaCK_VaLuE;

void EiC_interpret(environ_t * env)
{

    int p;
    size_t argc;
    unsigned int ToP;
    InsT_t *InSt;
    STK_t *STK, *hold_AR, *hold_AR1;

    /* EXPLANATION OF REGISTERS
     *  ToP          stack top;
     *  p            program counter;
     *  InSt         pointer to instruction set
     */



    typedef struct {
	int p;
	unsigned int top;
	int lsp;
	long offset;
	void *file;
	void *inst;
	void *ar;
    } _EiC_jmp_buf;


    extern int EiC_TIMER;
    extern void EiC_showvalue(AR_t *);
    extern void showcode(InsT_t * inst,int i);
    int stksz = stacksize;
    int lastln = -1;
    eicstack_t names = {0, NULL};
    val_t v;
    void *vp;  /* for temporay use only */
    
    unsigned int ON;
    code_t *code;
    
    clock_t start, end;

    v.p.p = "::EiC::";
    STK = (STK_t *) xcalloc(sizeof(STK_t) * stacksize, 1);
    AR[0] = env->AR;
    AR[1] = &env->LAR[env->lsp];
    InSt = env->CODE.inst;
    ToP = 0;
    p = 0;
    
    STK[ToP].v.dval = 0;
    ON = 1;

    start = clock();
    EiC_CurrentFile = codeName(&env->CODE);
    while (ON) {
	if(EiC_CurrentLine != InSt[p].line)   /* for error reporting */
	    EiC_CurrentLine = InSt[p].line;   /* purposes only */
	if(EiC_traceON) {
	    /*printf("%4d:",p); showcode(&InSt[p],p);
	    putchar('\n'); */
	    if(InSt[p].opcode == eiccall) {
		EiC_eicpush(&names,v);
		v.p.p = ((symentry_t *) STK[ToP - 1].v.p.p)->id;
		EiC_formatMessage("\n[%s] ",(char*)v.p.p);
	    }
	    if(!EiC_traceFunc && lastln != InSt[p].line && InSt[p].line) {
		lastln = InSt[p].line;
		EiC_formatMessage("%d,",lastln);
	    }
	}
	switch (InSt[p].opcode) {
	case bump:
	      AdjustTop(InSt[p].val.ival);
	    ToP += InSt[p].val.ival;
	    break;
	case jmpFint: jmpfTYPE(ival); break;
	case jmpFlng: jmpfTYPE(lval); break;
	case jmpFdbl: jmpfTYPE(dval); break;
	case jmpFptr: jmpfTYPE(p.p); break;
	case jmpFllng: jmpfTYPE(llval); break;
	      
	case jmpTint: jmptTYPE(ival); break;
	case jmpTlng: jmptTYPE(lval); break;
	case jmpTdbl: jmptTYPE(dval); break;
	case jmpTptr: jmptTYPE(p.p); break;
	case jmpTllng: jmptTYPE(llval); break;

	case jmpu: p += InSt[p].val.ival - 1; break;
	case dupval:
	    /* should really adjustTop here !!*/
	    STK[ToP + 1].v = STK[ToP].v;
	    ToP += InSt[p].val.ival;
	    break;
	case jmptab:
	{
	      struct {
		  int n;
		  val_t *loc;
	      } *tab;
	      int i;
	      tab = InSt[p].val.p.p;
	      for (i = 1; i < tab->n; i += 2)
		  if (tab->loc[i].ival == STK[ToP].v.ival) {
		      p += tab->loc[i + 1].ival - 1;
		      break;
		  }
	      if (i >= tab->n)
		  p += tab->loc[0].ival - 1;
	  }
	    break;


	  /* specific float stuff */

	case dreffloat: drefTYPE(float, dval); break;
	case reffloat: refTYPE(float, dval); break;
	case rvalfloat:
	    STK[ToP].v.dval=AR[InSt[p].ext][InSt[p].val.ival].v.fval;
	    break;
	case stofloat:
	    AR[InSt[p].ext][InSt[p].val.ival].v.fval = (float)STK[ToP].v.dval;
	    break;

	    
	  /* specific short stuff */
	case rvalshort:
	    STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.sval;
	    break;
	case rvalushort:
	    STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.usval;
	    break;
	case drefushort: drefTYPE(unsigned short, ival); break; 
	case drefshort: drefTYPE(short, ival); break;
	case refshort: refTYPE(short, ival); break;
	case stoshort:
	    AR[InSt[p].ext][InSt[p].val.ival].v.sval = STK[ToP].v.ival;
	    break;

	  /* specific char stuff */ 
	case rvalchar:
	    STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.cval;
	    break;
	case rvaluchar:
	    STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.ucval;
	    break;
	case stochar:
	    AR[InSt[p].ext][InSt[p].val.ival].v.cval = STK[ToP].v.ival;
	    break;
	case drefuchar: drefTYPE(unsigned char, ival); break;
	case drefchar: drefTYPE(char, ival); break;
	case refchar: refTYPE(char, ival); break;
	case neguchar: STK[ToP].v.uival = 256 - STK[ToP].v.uival; break;

	  /* specific int stuff */
	case incint: STK[ToP].v.ival += InSt[p].val.ival; break;
	case decint: STK[ToP].v.ival -= InSt[p].val.ival; break;
	case drefint: drefTYPE(int, ival); break;
	case refint: refTYPE(int, ival); break;
	case stoint: stoTYPE(ival); break;
	case rvalint: rvalTYPE(ival); break;
	case pushint: pushTYPE(ival); break;
	case negint: negTYPE(ival); break;
	case addint: addTYPE(ival); break;
	case subint: subTYPE(ival); break;
	case divint: divTYPE(ival); break;
	case multint: multTYPE(ival); break;
	case modint: modTYPE(ival); break;
	case lshtint: lshtTYPE(ival); break;
	case rshtint: rshtTYPE(ival); break;
	case ltint: ltTYPE(ival); break;
	case leint: leTYPE(ival); break;
	case eqint: eqTYPE(ival); break;
	case neint: neTYPE(ival); break;
	case gtint: gtTYPE(ival); break;
	case geint: geTYPE(ival); break;
	case lorint: lorTYPE(ival); break;
	case landint: landTYPE(ival); break;
	case notint: notTYPE(ival); break;
	case borint: borTYPE(ival); break;
	case xorint: xorTYPE(ival); break;
	case andint: andTYPE(ival); break;
	case compint: compTYPE(ival); break;
	case int2double: castTYPES(ival, dval, double); break;
	case int2ptr: castTYPES(ival, p.p, void *); break;
	case int2long: castTYPES(ival, lval, long); break;
	case int2llong: castTYPES(ival, llval, eic_llong); break;
	case int2uchar: castTYPES(ival, lval, unsigned char); break;
	case int2ushort: castTYPES(ival, lval, unsigned short); break;
	    
	  /* unsigned int stuff */
	case incuint: STK[ToP].v.uival += InSt[p].val.uival; break;
	case decuint: STK[ToP].v.uival -= InSt[p].val.uival; break;
	case drefuint: drefTYPE(unsigned, uival); break;
	case refuint: refTYPE(unsigned, uival); break;
	case stouint: stoTYPE(uival); break;
	case rvaluint: rvalTYPE(uival); break;
	case pushuint: pushTYPE(uival); break;
	case neguint: negTYPE(uival); break;
	case adduint: addTYPE(uival); break;
	case subuint: subTYPE(uival); break;
	case divuint: divTYPE(uival); break;
	case multuint: multTYPE(uival); break;
	case moduint: modTYPE(uival); break;
	case lshtuint: lshtTYPE(uival); break;
	case rshtuint: rshtTYPE(uival); break;
	case ltuint: ltTYPE(uival); break;
	case leuint: leTYPE(uival); break;
	case equint: eqTYPE(uival); break;
	case neuint: neTYPE(uival); break;
	case gtuint: gtTYPE(uival); break;
	case geuint: geTYPE(uival); break;
	case loruint: lorTYPE(uival); break;

	case notuint: notTYPE(uival); break;
	case boruint: borTYPE(uival); break;
	case xoruint: xorTYPE(uival); break;
	case anduint: andTYPE(uival); break;
	case compuint: compTYPE(uival); break;
	case uint2double: castTYPES(uival, dval, double); break;
	case uint2ptr: castTYPES(uival, p.p, void *); break;
	case uint2long: castTYPES(uival, lval, long); break;
	case uint2llong: castTYPES(uival, llval, eic_llong); break;

	  /* specific long stuff */
	case inclong: STK[ToP].v.lval += InSt[p].val.ival; break;
	case declong: STK[ToP].v.lval -= InSt[p].val.ival; break;
	case dreflong: drefTYPE(long, lval); break;
	case reflong: refTYPE(long, lval); break;
	case stolong: stoTYPE(lval); break;
	case rvallong: rvalTYPE(lval); break;
	case pushlong: pushTYPE(lval); break;
	case neglong: negTYPE(lval); break;
	case addlong: addTYPE(lval); break;
	case sublong: subTYPE(lval); break;
	case divlong: divTYPE(lval); break;
	case multlong: multTYPE(lval); break;
	case modlong: modTYPE(lval); break;
	case lshtlong: lshtTYPE(lval); break;
	case rshtlong: rshtTYPE(lval); break;
	case ltlong: ltTYPE(lval); break;
	case lelong: leTYPE(lval); break;
	case eqlong: eqTYPE(lval); break;
	case nelong: neTYPE(lval); break;
	case gtlong: gtTYPE(lval); break;
	case gelong: geTYPE(lval); break;
	case lorlong: lorTYPE(lval); break;
	case landlong: landTYPE(lval); break;
	case notlong: notTYPE(lval); break;
	case borlong: borTYPE(lval); break;
	case xorlong: xorTYPE(lval); break;
	case andlong: andTYPE(lval); break;
	case complong: compTYPE(lval); break;
	case long2double: castTYPES(lval, dval, double); break;
	case long2ptr: castTYPES(lval, p.p, void *); break;
	case long2llong: castTYPES(lval, llval, eic_llong); break;
	case long2int: castTYPES(lval, ival, int); break;

	    /* unsigned long stuff */
	case inculong: STK[ToP].v.ulval += InSt[p].val.ival; break;
	case deculong: STK[ToP].v.ulval -= InSt[p].val.ival; break;
	case drefulong: drefTYPE(unsigned long, ulval); break;
	case refulong: refTYPE(unsigned long, ulval); break;