int doEntry()
{
func_t *F;
symentry_t *sym;
sym = EiC_lookup(stand_tab,"main");
if(!sym) {
if(!ScriptMode)
EiC_messageDisplay("Error: Missing `main'\n");
return 0;
}
if(sym) {
if(EiC_gettype(sym->type) != t_func) {
EiC_messageDisplay("Error: `main' NOT DECLARED as a function\n");
return 0;
}
/* check return type of main */
if(EiC_gettype(nextType(sym->type)) != t_int) {
EiC_messageDisplay("Error: function `main' MUST return an `int' type\n");
return 0;
}
/* get number of arguments */
F = EiC_getInf(sym->type);
if(getFNp(F) <= 1) /* allow for void argument */
EiC_prolineString(FORMAT1);
else if(getFNp(F) <= 2)
EiC_prolineString(FORMAT2);
else
EiC_messageDisplay("Error: too many arguments being "
"passed to `main'\n");
/*EiC_prolineString(FORMAT3);*/
}
return 1;
}
void EiCp_Reset(int flag)
{
int errR = 0;
size_t xalloc_top = EiC_xalloc_NextEntryNum();
if(flag) EiC_messageDisplay("Error: clean up forced\n");
/* The while loop is a precaution against
* errors that occur during cleanup.
*/
while(errR < 10) {
/*if(flag) {sprintf(buff,"%d,",errR); EiC_messageDisplay(buff);}*/
switch(errR++) {
case 0: EiC_lut_CleanUp(lut_bot); break;
case 1: EiC_ENV_CleanUp(ENV_bot); break;
case 2: EiC_pp_CleanUp(pp_bot); break;
case 3: /* Vic's change */
if(EiC_ENV->ARgar.n)
xmark(EiC_ENV->ARgar.val,eicstay); /*End Vic's change */
EiC_xalloc_CleanUp(xalloc_bot,xalloc_top); break;
default:
/*if(flag) EiC_messageDisplay("\n");*/
errR = 10;
}
}
}
void EiC_Mod_Error(char * fmt, ...)
{
char buff[512];
va_list args;
va_start(args,fmt);
sprintf(buff,fmt,args);
EiC_messageDisplay(buff);
va_end(args);
raise(SIGSEGV);
}
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;
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);
}
void runEiC()
{
void EiC_remTempories(void);
void EiC_peephole(code_t *c);
int EiC_getHistLineNo(), hfrom = 0;
inRunEiC = 1;
InitFileControl();
switch(setjmp(env)) {
case 0:
jmpOn = 1;
EiCp_initiateReset();
#ifndef NO_HISTORY
hfrom = EiC_getHistLineNo();
#endif
inbuf = EiC_nextproline();
EiC_initlex(inbuf);
EiC_initparser();
EiC_parse(EiC_ENV);
EiC_peephole(&getenvcode(EiC_ENV));
if(EiC_listcodeON)
do_displays();
if (EiC_ENV->CODE.nextinst && EiC_interpON && !EiC_ParseError)
EiC_interpret(EiC_ENV);
break;
default:
EiC_messageDisplay("EiC reports an unRecognised jmp condition");
case Err_:
EiC_ParseError = 1;
break;
case Exit_:
EiC_messageDisplay("Exit called: force clean up!\n");
EiC_ParseError = 1;
break;
}
if (EiC_errs)
EiC_clear_err_msgs();
if(FREE_G_STRING)
EiC_xfreemark(eicgstring);
free_env_code();
EiC_remTempories();
if(EiC_ParseError) {
if(EiC_ENV->lsp != 0) {
//EiC_messageDisplay("EiC Reset Local Stack Pointer\n");
EiC_ENV->lsp = 0;
}
/*
if(EiC_ENV->ARgar.n)
xmark(EiC_ENV->ARgar.val,eicstay);
*/
EiCp_Reset(1);
firstInst.inst = NULL; //maks: the code is not valid anymore
EiC_ParseError = 0;
} else {
#ifndef NO_HISTORY
if(EiChist)
EiC_save_history(EiChist,hfrom);
#endif
}
if(EiC_memdumpON) {
EiC_marksyms(NON_LEAK);
if(EiC_verboseON)
printf("--- XMEM DUMP\n");
xdumpnonmark("xdump", NON_LEAK); //maks
}
inRunEiC = 0;
}
void EiC_startEiC(int argc, char **argv)
{
extern int EiC_load_history(char *fname,int prompt);
#if defined(WIN32) || defined(_DJGPP)
signal(SIGABRT, EiC_bus_err);
#else
signal(SIGBUS, EiC_bus_err);
#endif
signal(SIGILL, EiC_ill_oper);
signal(SIGSEGV, EiC_stor_access);
signal(SIGFPE, EiC_float_err);
signal(SIGINT, EiC_term_int);
#if defined(WIN32) || defined(_DJGPP)
signal(SIGTERM, EiC_exit_call);
#else
signal(SIGUSR1, EiC_exit_call);
#endif
EiC_getSwitchCommands(&argc,&argv);
#ifndef NO_ARGV
if(argc-- >0) {
if(!EiC_run(argc+1,argv+1))
EiC_error("Error: Failed to run %s\n",argv[1]);
exit(0);
}
#endif
if(!silent) {
fputs(Version,stdout);
}
#ifndef NO_HISTORY
if(StartUpH)
EiC_setinfile("starteic.h");
if(HistoryFile) {
char * name = "EiChist.lst";
if(reStart) {
puts("Re Initiating EiC -- please wait.");
if(EiC_load_history(name,prompt)) {
runEiC(); /* ensure that startup files have
been loaded and compiled */
EiChist = fopen(name,"w");
EiC_save_history(EiChist,0);
fclose(EiChist);
EiChist=NULL;
EiC_Include_file(name,1);
runEiC();
EiChist = fopen(name,"a");
} else {
EiC_error("Error: unable to load history file\n");
HistoryFile = 0;
EiChist = NULL;
}
puts("Done.");
} else {
EiChist = fopen(name,"w");
if(!EiChist) {
EiC_messageDisplay("Failed to create EiChist.lst\n"
"Start No history file mode switch\n");
HistoryFile = 0;
}
}
if(HistoryFile)
setvbuf(EiChist,NULL,_IOLBF,0);
}
#endif
#ifdef PPCLIB
setvbuf(stdout,NULL,_IONBF,0);
setvbuf(stderr,NULL,_IONBF,0);
#endif
/* Hawk start change */
/* while(1) */
/* runEiC(); */
/* Hawk change */
}
void runEiC()
{
void EiC_remTempories(void);
void EiC_peephole(code_t *c);
int EiC_getHistLineNo(), hfrom = 0;
/* Hawk start change */
EiC_ParseError = 0;
/* Hawk change */
/* Hawk start change */
#ifdef WIN32
__try {
#endif
/* Hawk change */
switch(setjmp(env)) {
case 0:
jmpOn = 1;
EiCp_initiateReset();
#ifndef NO_HISTORY
hfrom = EiC_getHistLineNo();
#endif
inbuf = EiC_nextproline();
EiC_initlex(inbuf);
EiC_initparser();
EiC_parse(EiC_ENV);
EiC_peephole(&getenvcode(EiC_ENV));
if(EiC_listcodeON)
do_displays();
if (EiC_ENV->CODE.nextinst && EiC_interpON && !EiC_ParseError)
EiC_interpret(EiC_ENV);
break;
default:
EiC_messageDisplay("EiC reports an unRecognised jmp condition in starteic.c");
case Err_:
EiC_ParseError = 1;
break;
case Exit_:
EiC_messageDisplay("Exit called: force clean up!\n");
EiC_ParseError = 1;
break;
}
/* Hawk start change */
#ifdef WIN32
} __finally {
#endif
/* Hawk change */
if (EiC_errs)
EiC_clear_err_msgs();
if(FREE_G_STRING)
EiC_xfreemark(eicgstring);
free_env_code();
EiC_remTempories();
if(EiC_ParseError) {
if(EiC_ENV->lsp != 0) {
EiC_messageDisplay("EiC::Reset Local Stack Pointer\n");
EiC_ENV->lsp = 0;
}
/*
if(EiC_ENV->ARgar.n)
xmark(EiC_ENV->ARgar.val,eicstay);
*/
EiCp_Reset(1);
/* Hawk start change */
EiC_ParseError = 0;
/* Hawk change */
} else {
#ifndef NO_HISTORY
if(EiChist)
EiC_save_history(EiChist,hfrom);
#endif
}
if(EiC_memdumpON) {
EiC_marksyms(NON_LEAK);
if(EiC_verboseON)
printf("--- XMEM DUMP\n");
xdumpnonmark("eicxdump", NON_LEAK);
}
#ifdef WIN32
}
#endif
}
