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 }