git.maemo.org Git - opencv/blob - apps/Hawk/CVEiCL/EiC/src/interpre.c

   1 /* interpre.c
   2  *
   3  *      (C) Copyright Apr 15 1995, Edmond J. Breen.
   4  *                 ALL RIGHTS RESERVED.
   5  * This code may be copied for personal, non-profit use only.
   6  *
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <signal.h>
  12 #include <stddef.h>
  13 #include <string.h>
  14 #include <time.h>
  15 #include <limits.h>
  16
  17 #include "MachSet.h"
  18 #include "global.h"
  19 #include "xalloc.h"
  20 #include "typemod.h"
  21 #include "symbol.h"
  22
  23 #include "error.h"
  24
  25 /* make a safe memory block */
  26 #define MASSIGN \
  27
  28 #define checkPtr(P,s,i) \
  29 if(( (char *)P.p + i ) > (char *) P.ep || P.p < P.sp) {\
  30      if(( (char *)P.p + i ) > (char *) P.ep) {\
  31          EiC_messageDisplay(s ": attempted beyond allowed access area\n"); }\
  32      else\
  33          EiC_messageDisplay(s ": attempted before allowed access area\n");\
  34      raise(SIGSEGV);\
  35 }
  36
  37
  38 #define FMEM         xfree(AR[InSt[p].ext][InSt[p].val.ival].v.p.sp)
  39
  40 #define LDA
  41
  42 #define LVAL
  43
  44 #define stoTYPE(x)   AR[InSt[p].ext][InSt[p].val.ival].v.x =STK[ToP].v.x
  45 #define stoVAL           env->LAR[env->lsp].v = STK[ToP].v;env->lsp++
  46 #define pushVAL          STK[ToP].v = InSt[p].val;
  47 #define assignTYPE       env->LAR[env->lsp-1].type = InSt[p].val.p.p
  48
  49 #define rvalTYPE(x) STK[ToP].v.x = AR[InSt[p].ext][InSt[p].val.ival].v.x
  50
  51
  52
  53 #define drefTYPE(x,y)  checkPtr(STK[ToP].v.p,"READ", sizeof(x) );\
  54                        STK[ToP].v.y = *(x*)STK[ToP].v.p.p
  55
  56
  57
  58 #define refTYPE(x,y)   ToP--;\
  59                        checkPtr(STK[ToP].v.p,"WRITE", sizeof(x) );\
  60                        *(x*)STK[ToP].v.p.p = STK[ToP+1].v.y;\
  61                        STK[ToP].v.y = STK[ToP+1].v.y
  62
  63 #define refMEM        ToP--;\
  64         memcpy(STK[ToP].v.p.p,STK[ToP+1].v.p.p,InSt[p].val.ival);\
  65         STK[ToP].v.p.sp = STK[ToP].v.p.p;\
  66         STK[ToP].v.p.ep = (char*)STK[ToP].v.p.p + InSt[p].val.ival;
  67
  68
  69
  70 #define pushTYPE(x)  STK[ToP].v.x = InSt[p].val.x
  71
  72 #define  castTYPES(x,y,T)  STK[ToP].v.y = (T)STK[ToP].v.x
  73
  74 #define negTYPE(x)   STK[ToP].v.x =  -STK[ToP].v.x
  75 #define addTYPE(x)   ToP--; STK[ToP].v.x += STK[ToP+1].v.x
  76 #define subTYPE(x)   ToP--; STK[ToP].v.x -= STK[ToP+1].v.x
  77 #define divTYPE(x)   ToP--; STK[ToP].v.x /= STK[ToP+1].v.x
  78 #define multTYPE(x)  ToP--;  STK[ToP].v.x *= STK[ToP+1].v.x
  79 #define modTYPE(x)   ToP--;  STK[ToP].v.x %= STK[ToP+1].v.x
  80 #define lshtTYPE(x)  ToP--; STK[ToP].v.x <<= STK[ToP+1].v.x
  81 #define rshtTYPE(x)  ToP--; STK[ToP].v.x >>= STK[ToP+1].v.x
  82 #define ltTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x < STK[ToP+1].v.x
  83 #define leTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x <= STK[ToP+1].v.x
  84 #define eqTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x == STK[ToP+1].v.x
  85 #define neTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x != STK[ToP+1].v.x
  86 #define gtTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x > STK[ToP+1].v.x
  87 #define geTYPE(x)   ToP--; STK[ToP].v.ival = STK[ToP].v.x >= STK[ToP+1].v.x
  88 #define lorTYPE(x)  ToP--; STK[ToP].v.ival = STK[ToP].v.x || STK[ToP+1].v.x
  89 #define landTYPE(x)  STK[ToP].v.ival = STK[ToP].v.x != 0
  90
  91 #define notTYPE(x)  STK[ToP].v.ival = !STK[ToP].v.x
  92
  93 #define borTYPE(x)  ToP--; STK[ToP].v.x = STK[ToP].v.x | STK[ToP+1].v.x
  94 #define xorTYPE(x)  ToP--; STK[ToP].v.x = STK[ToP].v.x ^ STK[ToP+1].v.x
  95 #define andTYPE(x)  ToP--; STK[ToP].v.x = STK[ToP].v.x & STK[ToP+1].v.x
  96 #define compTYPE(x) STK[ToP].v.x = ~STK[ToP].v.x
  97
  98 #define jmpfTYPE(x)  if(STK[ToP].v.x == 0) {\
  99                           STK[ToP].v.ival = 0;\
 100                           p += InSt[p].val.ival-1;\
 101                      } else\
 102                        STK[ToP].v.ival = 1
 103
 104 #define jmptTYPE(x)  if(STK[ToP].v.x != 0) {\
 105                           STK[ToP].v.ival = 1;\
 106                           p += InSt[p].val.ival-1;\
 107                      } else\
 108                        STK[ToP].v.ival = 0
 109
 110 #define  AdjustTop(x)   if(ToP + (x) >= stksz) {\
 111                           stksz += stacksize; \
 112                           STK =  (STK_t *) xrealloc(STK,sizeof(STK_t)\
 113                                                     * stksz); \
 114                                           }
 115
 116 extern unsigned int EiC_CurrentLine;
 117 extern char *EiC_CurrentFile;
 118
 119 extern int EiC_traceON;
 120 extern int EiC_traceFunc;
 121 extern int EiC_interActive;
 122
 123
 124
 125 #define stacksize 200
 126 typedef AR_t STK_t;
 127
 128 STK_t *AR[3];
 129 size_t ARGC;
 130
 131 val_t EiC_STaCK_VaLuE;
 132
 133 void EiC_interpret(environ_t * env)
 134 {
 135
 136     int p;
 137     size_t argc;
 138     unsigned int ToP;
 139     InsT_t *InSt;
 140     STK_t *STK, *hold_AR, *hold_AR1;
 141
 142     /* EXPLANATION OF REGISTERS
 143      *  ToP          stack top;
 144      *  p            program counter;
 145      *  InSt         pointer to instruction set
 146      */
 147
 148
 149
 150     typedef struct {
 151         int p;
 152         unsigned int top;
 153         int lsp;
 154         long offset;
 155         void *file;
 156         void *inst;
 157         void *ar;
 158     } _EiC_jmp_buf;
 159
 160
 161     extern int EiC_TIMER;
 162     extern void EiC_showvalue(AR_t *);
 163     extern void showcode(InsT_t * inst,int i);
 164     int stksz = stacksize;
 165     int lastln = -1;
 166     eicstack_t names = {0, NULL};
 167     val_t v;
 168     void *vp;  /* for temporay use only */
 169
 170     unsigned int ON;
 171     code_t *code;
 172
 173     clock_t start, end;
 174
 175     v.p.p = "::EiC::";
 176     STK = (STK_t *) xcalloc(sizeof(STK_t) * stacksize, 1);
 177     AR[0] = env->AR;
 178     AR[1] = &env->LAR[env->lsp];
 179     InSt = env->CODE.inst;
 180     ToP = 0;
 181     p = 0;
 182
 183     STK[ToP].v.dval = 0;
 184     ON = 1;
 185
 186     start = clock();
 187     EiC_CurrentFile = codeName(&env->CODE);
 188     while (ON) {
 189         if(EiC_CurrentLine != InSt[p].line)   /* for error reporting */
 190             EiC_CurrentLine = InSt[p].line;   /* purposes only */
 191         if(EiC_traceON) {
 192             /*printf("%4d:",p); showcode(&InSt[p],p);
 193             putchar('\n'); */
 194             if(InSt[p].opcode == eiccall) {
 195                 EiC_eicpush(&names,v);
 196                 v.p.p = ((symentry_t *) STK[ToP - 1].v.p.p)->id;
 197                 EiC_formatMessage("\n[%s] ",(char*)v.p.p);
 198             }
 199             if(!EiC_traceFunc && lastln != InSt[p].line && InSt[p].line) {
 200                 lastln = InSt[p].line;
 201                 EiC_formatMessage("%d,",lastln);
 202             }
 203         }
 204         switch (InSt[p].opcode) {
 205         case bump:
 206               AdjustTop(InSt[p].val.ival);
 207             ToP += InSt[p].val.ival;
 208             break;
 209         case jmpFint: jmpfTYPE(ival); break;
 210         case jmpFlng: jmpfTYPE(lval); break;
 211         case jmpFdbl: jmpfTYPE(dval); break;
 212         case jmpFptr: jmpfTYPE(p.p); break;
 213         case jmpFllng: jmpfTYPE(llval); break;
 214
 215         case jmpTint: jmptTYPE(ival); break;
 216         case jmpTlng: jmptTYPE(lval); break;
 217         case jmpTdbl: jmptTYPE(dval); break;
 218         case jmpTptr: jmptTYPE(p.p); break;
 219         case jmpTllng: jmptTYPE(llval); break;
 220
 221         case jmpu: p += InSt[p].val.ival - 1; break;
 222         case dupval:
 223             /* should really adjustTop here !!*/
 224             STK[ToP + 1].v = STK[ToP].v;
 225             ToP += InSt[p].val.ival;
 226             break;
 227         case jmptab:
 228         {
 229               struct {
 230                   int n;
 231                   val_t *loc;
 232               } *tab;
 233               int i;
 234               tab = InSt[p].val.p.p;
 235               for (i = 1; i < tab->n; i += 2)
 236                   if (tab->loc[i].ival == STK[ToP].v.ival) {
 237                       p += tab->loc[i + 1].ival - 1;
 238                       break;
 239                   }
 240               if (i >= tab->n)
 241                   p += tab->loc[0].ival - 1;
 242           }
 243             break;
 244
 245
 246           /* specific float stuff */
 247
 248         case dreffloat: drefTYPE(float, dval); break;
 249         case reffloat: refTYPE(float, dval); break;
 250         case rvalfloat:
 251             STK[ToP].v.dval=AR[InSt[p].ext][InSt[p].val.ival].v.fval;
 252             break;
 253         case stofloat:
 254             AR[InSt[p].ext][InSt[p].val.ival].v.fval = (float)STK[ToP].v.dval;
 255             break;
 256
 257
 258           /* specific short stuff */
 259         case rvalshort:
 260             STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.sval;
 261             break;
 262         case rvalushort:
 263             STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.usval;
 264             break;
 265         case drefushort: drefTYPE(unsigned short, ival); break;
 266         case drefshort: drefTYPE(short, ival); break;
 267         case refshort: refTYPE(short, ival); break;
 268         case stoshort:
 269             AR[InSt[p].ext][InSt[p].val.ival].v.sval = STK[ToP].v.ival;
 270             break;
 271
 272           /* specific char stuff */
 273         case rvalchar:
 274             STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.cval;
 275             break;
 276         case rvaluchar:
 277             STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.ucval;
 278             break;
 279         case stochar:
 280             AR[InSt[p].ext][InSt[p].val.ival].v.cval = STK[ToP].v.ival;
 281             break;
 282         case drefuchar: drefTYPE(unsigned char, ival); break;
 283         case drefchar: drefTYPE(char, ival); break;
 284         case refchar: refTYPE(char, ival); break;
 285         case neguchar: STK[ToP].v.uival = 256 - STK[ToP].v.uival; break;
 286
 287           /* specific int stuff */
 288         case incint: STK[ToP].v.ival += InSt[p].val.ival; break;
 289         case decint: STK[ToP].v.ival -= InSt[p].val.ival; break;
 290         case drefint: drefTYPE(int, ival); break;
 291         case refint: refTYPE(int, ival); break;
 292         case stoint: stoTYPE(ival); break;
 293         case rvalint: rvalTYPE(ival); break;
 294         case pushint: pushTYPE(ival); break;
 295         case negint: negTYPE(ival); break;
 296         case addint: addTYPE(ival); break;
 297         case subint: subTYPE(ival); break;
 298         case divint: divTYPE(ival); break;
 299         case multint: multTYPE(ival); break;
 300         case modint: modTYPE(ival); break;
 301         case lshtint: lshtTYPE(ival); break;
 302         case rshtint: rshtTYPE(ival); break;
 303         case ltint: ltTYPE(ival); break;
 304         case leint: leTYPE(ival); break;
 305         case eqint: eqTYPE(ival); break;
 306         case neint: neTYPE(ival); break;
 307         case gtint: gtTYPE(ival); break;
 308         case geint: geTYPE(ival); break;
 309         case lorint: lorTYPE(ival); break;
 310         case landint: landTYPE(ival); break;
 311         case notint: notTYPE(ival); break;
 312         case borint: borTYPE(ival); break;
 313         case xorint: xorTYPE(ival); break;
 314         case andint: andTYPE(ival); break;
 315         case compint: compTYPE(ival); break;
 316         case int2double: castTYPES(ival, dval, double); break;
 317         case int2ptr: castTYPES(ival, p.p, void *); break;
 318         case int2long: castTYPES(ival, lval, long); break;
 319         case int2llong: castTYPES(ival, llval, eic_llong); break;
 320         case int2uchar: castTYPES(ival, lval, unsigned char); break;
 321         case int2ushort: castTYPES(ival, lval, unsigned short); break;
 322
 323           /* unsigned int stuff */
 324         case incuint: STK[ToP].v.uival += InSt[p].val.uival; break;
 325         case decuint: STK[ToP].v.uival -= InSt[p].val.uival; break;
 326         case drefuint: drefTYPE(unsigned, uival); break;
 327         case refuint: refTYPE(unsigned, uival); break;
 328         case stouint: stoTYPE(uival); break;
 329         case rvaluint: rvalTYPE(uival); break;
 330         case pushuint: pushTYPE(uival); break;
 331         case neguint: negTYPE(uival); break;
 332         case adduint: addTYPE(uival); break;
 333         case subuint: subTYPE(uival); break;
 334         case divuint: divTYPE(uival); break;
 335         case multuint: multTYPE(uival); break;
 336         case moduint: modTYPE(uival); break;
 337         case lshtuint: lshtTYPE(uival); break;
 338         case rshtuint: rshtTYPE(uival); break;
 339         case ltuint: ltTYPE(uival); break;
 340         case leuint: leTYPE(uival); break;
 341         case equint: eqTYPE(uival); break;
 342         case neuint: neTYPE(uival); break;
 343         case gtuint: gtTYPE(uival); break;
 344         case geuint: geTYPE(uival); break;
 345         case loruint: lorTYPE(uival); break;
 346
 347         case notuint: notTYPE(uival); break;
 348         case boruint: borTYPE(uival); break;
 349         case xoruint: xorTYPE(uival); break;
 350         case anduint: andTYPE(uival); break;
 351         case compuint: compTYPE(uival); break;
 352         case uint2double: castTYPES(uival, dval, double); break;
 353         case uint2ptr: castTYPES(uival, p.p, void *); break;
 354         case uint2long: castTYPES(uival, lval, long); break;
 355         case uint2llong: castTYPES(uival, llval, eic_llong); break;
 356
 357           /* specific long stuff */
 358         case inclong: STK[ToP].v.lval += InSt[p].val.ival; break;
 359         case declong: STK[ToP].v.lval -= InSt[p].val.ival; break;
 360         case dreflong: drefTYPE(long, lval); break;
 361         case reflong: refTYPE(long, lval); break;
 362         case stolong: stoTYPE(lval); break;
 363         case rvallong: rvalTYPE(lval); break;
 364         case pushlong: pushTYPE(lval); break;
 365         case neglong: negTYPE(lval); break;
 366         case addlong: addTYPE(lval); break;
 367         case sublong: subTYPE(lval); break;
 368         case divlong: divTYPE(lval); break;
 369         case multlong: multTYPE(lval); break;
 370         case modlong: modTYPE(lval); break;
 371         case lshtlong: lshtTYPE(lval); break;
 372         case rshtlong: rshtTYPE(lval); break;
 373         case ltlong: ltTYPE(lval); break;
 374         case lelong: leTYPE(lval); break;
 375         case eqlong: eqTYPE(lval); break;
 376         case nelong: neTYPE(lval); break;
 377         case gtlong: gtTYPE(lval); break;
 378         case gelong: geTYPE(lval); break;
 379         case lorlong: lorTYPE(lval); break;
 380         case landlong: landTYPE(lval); break;
 381         case notlong: notTYPE(lval); break;
 382         case borlong: borTYPE(lval); break;
 383         case xorlong: xorTYPE(lval); break;
 384         case andlong: andTYPE(lval); break;
 385         case complong: compTYPE(lval); break;
 386         case long2double: castTYPES(lval, dval, double); break;
 387         case long2ptr: castTYPES(lval, p.p, void *); break;
 388         case long2llong: castTYPES(lval, llval, eic_llong); break;
 389         case long2int: castTYPES(lval, ival, int); break;
 390
 391             /* unsigned long stuff */
 392         case inculong: STK[ToP].v.ulval += InSt[p].val.ival; break;
 393         case deculong: STK[ToP].v.ulval -= InSt[p].val.ival; break;
 394         case drefulong: drefTYPE(unsigned long, ulval); break;
 395         case refulong: refTYPE(unsigned long, ulval); break;
 396         case stoulong: stoTYPE(ulval); break;
 397         case rvalulong: rvalTYPE(ulval); break;
 398         case pushulong: pushTYPE(ulval); break;
 399         case negulong: negTYPE(ulval); break;
 400         case addulong: addTYPE(ulval); break;
 401         case subulong: subTYPE(ulval); break;
 402         case divulong: divTYPE(ulval); break;
 403         case multulong: multTYPE(ulval); break;
 404         case modulong: modTYPE(ulval); break;
 405         case lshtulong: lshtTYPE(ulval); break;
 406         case rshtulong: rshtTYPE(ulval); break;
 407         case ltulong: ltTYPE(ulval); break;
 408         case leulong: leTYPE(ulval); break;
 409         case equlong: eqTYPE(ulval); break;
 410         case neulong: neTYPE(ulval); break;
 411         case gtulong: gtTYPE(ulval); break;
 412         case geulong: geTYPE(ulval); break;
 413         case lorulong: lorTYPE(ulval); break;
 414
 415         case notulong: notTYPE(ulval); break;
 416         case borulong: borTYPE(ulval); break;
 417         case xorulong: xorTYPE(ulval); break;
 418         case andulong: andTYPE(ulval); break;
 419         case compulong: compTYPE(ulval); break;
 420         case ulong2double: castTYPES(ulval, dval, double); break;
 421         case ulong2ptr: castTYPES(ulval, p.p, void *); break;
 422         case ulong2int: castTYPES(ulval, ival, int); break;
 423         case ulong2llong: castTYPES(ulval, llval, eic_llong); break;
 424
 425
 426
 427           /* specific long long stuff */
 428         case incllong: STK[ToP].v.llval += InSt[p].val.ival; break;
 429         case decllong: STK[ToP].v.llval -= InSt[p].val.ival; break;
 430         case drefllong: drefTYPE(eic_llong, llval); break;
 431         case refllong: refTYPE(eic_llong, llval); break;
 432         case stollong: stoTYPE(llval); break;
 433         case rvalllong: rvalTYPE(llval); break;
 434         case pushllong: pushTYPE(llval); break;
 435         case negllong: negTYPE(llval); break;
 436         case addllong: addTYPE(llval); break;
 437         case subllong: subTYPE(llval); break;
 438         case divllong: divTYPE(llval); break;
 439         case multllong: multTYPE(llval); break;
 440         case modllong: modTYPE(llval); break;
 441         case lshtllong: lshtTYPE(llval); break;
 442         case rshtllong: rshtTYPE(llval); break;
 443         case ltllong: ltTYPE(llval); break;
 444         case lellong: leTYPE(llval); break;
 445         case eqllong: eqTYPE(llval); break;
 446         case nellong: neTYPE(llval); break;
 447         case gtllong: gtTYPE(llval); break;
 448         case gellong: geTYPE(llval); break;
 449         case lorllong: lorTYPE(llval); break;
 450         case landllong: landTYPE(llval); break;
 451         case notllong: notTYPE(llval); break;
 452         case borllong: borTYPE(llval); break;
 453         case xorllong: xorTYPE(llval); break;
 454         case andllong: andTYPE(llval); break;
 455         case compllong: compTYPE(llval); break;
 456         case llong2double: castTYPES(llval, dval, double); break;
 457         case llong2ptr: castTYPES(llval, p.p, void *); break;
 458         case llong2int: castTYPES(llval, ival, int); break;
 459         case llong2long: castTYPES(llval, lval, long); break;
 460
 461
 462             /* specific double stuff */
 463         case incdouble:STK[ToP].v.dval += InSt[p].val.ival; break;
 464         case decdouble:STK[ToP].v.dval -= InSt[p].val.ival; break;
 465         case drefdouble: drefTYPE(double, dval); break;
 466         case refdouble: refTYPE(double, dval); break;
 467         case stodouble: stoTYPE(dval); break;
 468         case rvaldouble: rvalTYPE(dval); break;
 469         case pushdouble: pushTYPE(dval); break;
 470         case negdouble: negTYPE(dval); break;
 471         case adddouble: addTYPE(dval); break;
 472         case subdouble: subTYPE(dval); break;
 473         case divdouble: divTYPE(dval); break;
 474         case multdouble: multTYPE(dval); break;
 475         case ltdouble: ltTYPE(dval); break;
 476         case ledouble: leTYPE(dval); break;
 477         case eqdouble: eqTYPE(dval); break;
 478         case nedouble: neTYPE(dval); break;
 479         case gtdouble: gtTYPE(dval); break;
 480         case gedouble: geTYPE(dval); break;
 481         case lordouble: lorTYPE(dval); break;
 482         case landdouble: landTYPE(dval); break;
 483         case notdouble: notTYPE(dval); break;
 484
 485         case double2int: castTYPES(dval, uival, unsigned int); break;
 486         case double2long: castTYPES(dval, ulval, unsigned long); break;
 487         case double2llong: castTYPES(dval, llval, eic_llong); break;
 488         case double2float: castTYPES(dval, fval, float); break;
 489
 490
 491           /*specific pointer stuff */
 492         case incptr: STK[ToP].v.p.p = (char *) STK[ToP].v.p.p +
 493                          InSt[p].val.ival; break;
 494         case decptr: STK[ToP].v.p.p = (char *) STK[ToP].v.p.p -
 495                          InSt[p].val.ival; break;
 496         case lda:
 497 #if 0
 498             STK[ToP].v.p = AR[1][InSt[p].val.ival].v.p;
 499             STK[ToP].v.p.p = (char*)STK[ToP].v.p.sp + InSt[p].ext;
 500             STK[ToP].v.p.sp = STK[ToP].v.p.p;
 501 #else
 502
 503             {
 504                 ptr_t *q = &AR[1][InSt[p].val.ival].v.p;
 505                 ptr_t *a = &STK[ToP].v.p;
 506
 507                 a->p   = a->sp = (char*)q->sp + InSt[p].ext;
 508                 a->ep  = q->ep;
 509
 510                 if(vp) { /* patch previous lda assignment */
 511                     ((ptr_t*)vp)->ep = (char*)a->p;
 512                 }
 513                 /* Take advantage of the fact that the next InSt
 514                  * has the location of where `a' is to be stored.
 515                  */
 516                 vp = &AR[1][InSt[p+1].val.ival].v.p;
 517
 518             }
 519
 520 #endif
 521
 522             break;
 523         case ixa:
 524             ToP--;
 525             STK[ToP].v.p.p = (char *) STK[ToP].v.p.p + STK[ToP+1].v.ival*InSt[p].val.ival;
 526             break;
 527         case addptr2int: ToP--;
 528             STK[ToP].v.p.p = (char *) STK[ToP].v.p.p + STK[ToP + 1].v.ival; break;
 529         case addint2ptr: ToP--;
 530             STK[ToP].v.p.p = STK[ToP].v.ival
 531                 + (char *) STK[ToP+1].v.p.p; break;
 532         case subptrint: ToP--;
 533             STK[ToP].v.p.p = (char *) STK[ToP].v.p.p - STK[ToP + 1].v.ival; break;
 534         case subptr:
 535             ToP--;
 536             STK[ToP].v.ival =
 537                 (int) ((long) STK[ToP].v.p.p - (long) STK[ToP+1].v.p.p);
 538             break;
 539
 540         case drefptr:   drefTYPE(ptr_t, p); break;
 541
 542         case drefuptr:  drefTYPE(void**,p.p);
 543                         STK[ToP].v.p.sp = 0;
 544                         STK[ToP].v.p.ep = (void *) ULONG_MAX;
 545                         break;
 546
 547         case refptr: refTYPE(ptr_t, p); break;
 548         case refuptr: refTYPE(void *, p.p); break;
 549
 550         case stoptr: stoTYPE(p); break;
 551         case stouptr: stoTYPE(p.p); break;
 552
 553         case rvalptr: rvalTYPE(p); break;
 554         case rvaluptr: rvalTYPE(p);
 555           STK[ToP].v.p.sp = 0;
 556           STK[ToP].v.p.ep = (void*) ULONG_MAX; /* set to a very high value */
 557             break;
 558
 559         case pushptr: pushTYPE(p); break;
 560         case ltptr: ltTYPE(p.p); break;
 561         case leptr: leTYPE(p.p); break;
 562         case eqptr: eqTYPE(p.p); break;
 563         case neptr: neTYPE(p.p); break;
 564         case gtptr: gtTYPE(p.p); break;
 565         case geptr: geTYPE(p.p); break;
 566         case lorptr: lorTYPE(p.p); break;
 567         case landptr: landTYPE(p.p); break;
 568         case notptr: notTYPE(p.p); break;
 569         case ptr2int: castTYPES(p.p, ival, int); break;
 570         case ptr2long: castTYPES(p.p, lval, long); break;
 571
 572         case lval: /* on the fly safe pointer */
 573             STK[ToP].v.p.p = &AR[InSt[p].ext][InSt[p].val.ival].v;
 574             STK[ToP].v.p.ep = (char *) STK[ToP].v.p.p + (size_t)
 575                 InSt[p].val.p.ep;
 576             STK[ToP].v.p.sp = STK[ToP].v.p.p;
 577             break;
 578         case assigntype: assignTYPE; break;
 579         case stoval:
 580             switch(InSt[p].ext) {
 581               case t_char:
 582               case t_uchar: STK[ToP].v.cval = STK[ToP].v.ival; break;
 583               case t_short:
 584               case t_ushort: STK[ToP].v.sval = STK[ToP].v.ival; break;
 585               case t_float:  STK[ToP].v.fval = STK[ToP].v.dval;
 586 /*            case t_struct:
 587               case t_union:
 588                 printf("stoVa1l with struct/union\n");
 589 */
 590             }
 591
 592             stoVAL; break;
 593         case pushval: pushVAL; break;
 594
 595         case eiccall:
 596
 597             if(!((symentry_t*)STK[ToP - 1].v.p.p)->tag) {
 598                 AdjustTop(6);
 599                 STK[ToP + 1].v.ival = p;
 600                 STK[ToP + 1].type = (void*)EiC_CurrentFile; /* save file */
 601                 STK[ToP + 2].v.p.p = InSt;
 602                 STK[ToP + 3].v.lval = AR[1] - env->LAR;
 603                 STK[ToP + 4].v.ival = env->lsp - STK[ToP].v.ival;
 604
 605                 AR[1] = &env->LAR[env->lsp] /* - STK[ToP].v.ival] */ ;
 606                 code = ! STK[ToP - 1].v.p.p ? NULL :
 607                     AR[0][((symentry_t *)
 608                            STK[ToP - 1].v.p.p)->val.ival].v.p.p;
 609
 610                 if (code == NULL) {
 611                     if(STK[ToP - 1].v.p.p) {
 612                         EiC_formatMessage("Link error: undefined function :-> %s\n",
 613                                           ((symentry_t *) STK[ToP - 1].v.p.p)->id);
 614                     } else
 615                         EiC_formatMessage("Link error: possible usage of a function pointer"
 616                                           " before assignment.\n");
 617                     env->lsp = 0;
 618                     raise(SIGINT);
 619                 }
 620
 621                 EiC_CurrentFile = codeName(code);
 622
 623                 InSt = code->inst;
 624                 p = -1;
 625                 ToP += 5;
 626                 if(EiC_traceON)
 627                     lastln = -1;
 628                 break;
 629             }
 630
 631         case call:
 632           argc = ARGC;
 633           hold_AR = AR[2];
 634           hold_AR1 = AR[1];
 635           ARGC = STK[ToP].v.ival;
 636
 637           /*AR[2] = &env->LAR[env->lsp - ARGC];*/
 638             AR[2] = &env->LAR[env->lsp];
 639             if(InSt[p].ext)
 640                 STK[ToP - 1].v = STK[ToP - 1].v.vfunc ();
 641             else
 642                 STK[ToP - 1].v.vfunc();
 643             env->lsp -= STK[ToP].v.ival;
 644             ARGC = argc;
 645             AR[2] = hold_AR;
 646             AR[1] = hold_AR1;
 647             ToP--; break;
 648
 649         case eicreturn:
 650             ToP -= 6;           /* over write code pointer */
 651
 652             p = STK[ToP + 2].v.ival;
 653             EiC_CurrentFile = (char*)STK[ToP+2].type;
 654
 655             InSt = STK[ToP + 3].v.p.p;
 656
 657             env->lsp = STK[ToP + 5].v.ival;
 658             STK[ToP].v = STK[ToP + 6].v;
 659
 660             AR[1] = &env->LAR[STK[ToP + 4].v.ival];
 661             if(EiC_traceON) {
 662                 EiC_eicpop(&names,&v);
 663                 EiC_formatMessage("\n[%s] ", (char*)v.p.p);
 664                 lastln = -1;
 665             }
 666             break;
 667
 668
 669 #if 1
 670         case __eiclongjmp:
 671         {
 672
 673             _EiC_jmp_buf * reg;
 674
 675             reg = (_EiC_jmp_buf *) ((char*)STK[ToP].v.p.p - STK[ToP+1].v.ival);
 676
 677             p = reg->p;
 678             EiC_CurrentFile = reg->file;
 679             InSt = reg->inst;
 680             env->lsp = reg->lsp;
 681             AR[1] = &env->LAR[reg->offset]; /*reg->ar; */
 682
 683             if(STK[ToP+1].v.ival == 0)
 684                  STK[reg->top].v.ival = 1;
 685             else
 686                  STK[reg->top].v.ival = STK[ToP+1].v.ival;
 687
 688             ToP = reg->top;
 689
 690
 691         }
 692
 693         break;
 694
 695         case __eicsetjmp:
 696         {
 697
 698             _EiC_jmp_buf * reg;
 699
 700             reg = (_EiC_jmp_buf *) STK[ToP].v.p.p;
 701
 702             reg->p = p;
 703             reg->file = (void*)EiC_CurrentFile; /* save file */
 704             reg->inst = InSt;
 705             reg->lsp =  env->lsp;
 706             reg->offset = AR[1] - env->LAR;
 707             reg->ar = AR[1];
 708             reg->top = ToP;
 709
 710             STK[ToP].v.ival = 0;
 711
 712         }
 713
 714         break;
 715 #endif
 716
 717         case massign:
 718             {
 719                 val_t *v = &AR[InSt[p].ext][InSt[p].val.ival].v;
 720                 v->p.sp = (void*)xcalloc(STK[ToP].v.ival,1);
 721                 v->p.ep = (char*)v->p.sp + STK[ToP].v.ival;
 722                 vp = NULL;
 723
 724             }
 725             break;
 726         case fmem: FMEM; break;
 727         case refmem: refMEM; break;
 728         case minit:
 729             memcpy(STK[ToP].v.p.p,InSt[p].val.p.p, InSt[p].ext);
 730             break;
 731         case reducear:
 732             env->lsp -= InSt[p].val.ival;
 733             break;
 734         case checkar:{
 735               size_t d;
 736               ptrdiff_t d2;
 737               d = env->LARsize - env->lsp;
 738               if (d < InSt[p].val.ival) {
 739                   /* printf("expanding AR %d\n",env->LARsize);*/
 740                   d2 = (AR[1] - env->LAR);
 741                   env->LARsize += InSt[p].val.ival - d;
 742                   env->LAR =
 743                       (AR_t *) xrealloc(env->LAR,
 744                                         env->LARsize * sizeof(AR_t));
 745                   AR[1] = &env->LAR[(size_t) d2];
 746               }
 747               if (InSt[p].ext == 0) {
 748                   env->lsp += InSt[p].val.ival;
 749                   /*AR[1][0].v.p.p = NULL;*/
 750               }
 751           }
 752             break;
 753         case halt: STK[ToP].type = InSt[p].val.p.p;
 754               ON = 0;  EiC_STaCK_VaLuE = STK[ToP].v; break;
 755
 756         case empty: break;
 757
 758         }
 759         p++;
 760     }
 761
 762
 763     end = clock();
 764     if(EiC_traceON)
 765         EiC_messageDisplay("\n");
 766
 767     if(EiC_interActive)
 768         EiC_showvalue(&STK[ToP]);
 769
 770     if (EiC_TIMER) {
 771         fprintf(stdout," <time taken>: %g\n",
 772                 (end-start)/(float)CLOCKS_PER_SEC);
 773     }
 774
 775     xfree(STK);
 776 }
 777
 778
 779
 780
 781
 782
 783
 784
 785
 786
 787
 788
 789