3 * (C) Copyright Apr 15 1995, Edmond J. Breen.
5 * This code may be copied for personal, non-profit use only.
25 /* make a safe memory block */
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"); }\
33 EiC_messageDisplay(s ": attempted before allowed access area\n");\
38 #define FMEM xfree(AR[InSt[p].ext][InSt[p].val.ival].v.p.sp)
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
49 #define rvalTYPE(x) STK[ToP].v.x = AR[InSt[p].ext][InSt[p].val.ival].v.x
53 #define drefTYPE(x,y) checkPtr(STK[ToP].v.p,"READ", sizeof(x) );\
54 STK[ToP].v.y = *(x*)STK[ToP].v.p.p
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
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;
70 #define pushTYPE(x) STK[ToP].v.x = InSt[p].val.x
72 #define castTYPES(x,y,T) STK[ToP].v.y = (T)STK[ToP].v.x
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
91 #define notTYPE(x) STK[ToP].v.ival = !STK[ToP].v.x
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
98 #define jmpfTYPE(x) if(STK[ToP].v.x == 0) {\
100 p += InSt[p].val.ival-1;\
104 #define jmptTYPE(x) if(STK[ToP].v.x != 0) {\
105 STK[ToP].v.ival = 1;\
106 p += InSt[p].val.ival-1;\
110 #define AdjustTop(x) if(ToP + (x) >= stksz) {\
111 stksz += stacksize; \
112 STK = (STK_t *) xrealloc(STK,sizeof(STK_t)\
116 extern unsigned int EiC_CurrentLine;
117 extern char *EiC_CurrentFile;
119 extern int EiC_traceON;
120 extern int EiC_traceFunc;
121 extern int EiC_interActive;
125 #define stacksize 200
131 val_t EiC_STaCK_VaLuE;
133 void EiC_interpret(environ_t * env)
140 STK_t *STK, *hold_AR, *hold_AR1;
142 /* EXPLANATION OF REGISTERS
145 * InSt pointer to instruction set
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;
166 eicstack_t names = {0, NULL};
168 void *vp; /* for temporay use only */
176 STK = (STK_t *) xcalloc(sizeof(STK_t) * stacksize, 1);
178 AR[1] = &env->LAR[env->lsp];
179 InSt = env->CODE.inst;
187 EiC_CurrentFile = codeName(&env->CODE);
189 if(EiC_CurrentLine != InSt[p].line) /* for error reporting */
190 EiC_CurrentLine = InSt[p].line; /* purposes only */
192 /*printf("%4d:",p); showcode(&InSt[p],p);
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);
199 if(!EiC_traceFunc && lastln != InSt[p].line && InSt[p].line) {
200 lastln = InSt[p].line;
201 EiC_formatMessage("%d,",lastln);
204 switch (InSt[p].opcode) {
206 AdjustTop(InSt[p].val.ival);
207 ToP += InSt[p].val.ival;
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;
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;
221 case jmpu: p += InSt[p].val.ival - 1; break;
223 /* should really adjustTop here !!*/
224 STK[ToP + 1].v = STK[ToP].v;
225 ToP += InSt[p].val.ival;
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;
241 p += tab->loc[0].ival - 1;
246 /* specific float stuff */
248 case dreffloat: drefTYPE(float, dval); break;
249 case reffloat: refTYPE(float, dval); break;
251 STK[ToP].v.dval=AR[InSt[p].ext][InSt[p].val.ival].v.fval;
254 AR[InSt[p].ext][InSt[p].val.ival].v.fval = (float)STK[ToP].v.dval;
258 /* specific short stuff */
260 STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.sval;
263 STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.usval;
265 case drefushort: drefTYPE(unsigned short, ival); break;
266 case drefshort: drefTYPE(short, ival); break;
267 case refshort: refTYPE(short, ival); break;
269 AR[InSt[p].ext][InSt[p].val.ival].v.sval = STK[ToP].v.ival;
272 /* specific char stuff */
274 STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.cval;
277 STK[ToP].v.ival=AR[InSt[p].ext][InSt[p].val.ival].v.ucval;
280 AR[InSt[p].ext][InSt[p].val.ival].v.cval = STK[ToP].v.ival;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
504 ptr_t *q = &AR[1][InSt[p].val.ival].v.p;
505 ptr_t *a = &STK[ToP].v.p;
507 a->p = a->sp = (char*)q->sp + InSt[p].ext;
510 if(vp) { /* patch previous lda assignment */
511 ((ptr_t*)vp)->ep = (char*)a->p;
513 /* Take advantage of the fact that the next InSt
514 * has the location of where `a' is to be stored.
516 vp = &AR[1][InSt[p+1].val.ival].v.p;
525 STK[ToP].v.p.p = (char *) STK[ToP].v.p.p + STK[ToP+1].v.ival*InSt[p].val.ival;
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;
537 (int) ((long) STK[ToP].v.p.p - (long) STK[ToP+1].v.p.p);
540 case drefptr: drefTYPE(ptr_t, p); break;
542 case drefuptr: drefTYPE(void**,p.p);
544 STK[ToP].v.p.ep = (void *) ULONG_MAX;
547 case refptr: refTYPE(ptr_t, p); break;
548 case refuptr: refTYPE(void *, p.p); break;
550 case stoptr: stoTYPE(p); break;
551 case stouptr: stoTYPE(p.p); break;
553 case rvalptr: rvalTYPE(p); break;
554 case rvaluptr: rvalTYPE(p);
556 STK[ToP].v.p.ep = (void*) ULONG_MAX; /* set to a very high value */
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;
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)
576 STK[ToP].v.p.sp = STK[ToP].v.p.p;
578 case assigntype: assignTYPE; break;
580 switch(InSt[p].ext) {
582 case t_uchar: STK[ToP].v.cval = STK[ToP].v.ival; break;
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;
588 printf("stoVa1l with struct/union\n");
593 case pushval: pushVAL; break;
597 if(!((symentry_t*)STK[ToP - 1].v.p.p)->tag) {
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;
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;
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);
615 EiC_formatMessage("Link error: possible usage of a function pointer"
616 " before assignment.\n");
621 EiC_CurrentFile = codeName(code);
635 ARGC = STK[ToP].v.ival;
637 /*AR[2] = &env->LAR[env->lsp - ARGC];*/
638 AR[2] = &env->LAR[env->lsp];
640 STK[ToP - 1].v = STK[ToP - 1].v.vfunc ();
642 STK[ToP - 1].v.vfunc();
643 env->lsp -= STK[ToP].v.ival;
650 ToP -= 6; /* over write code pointer */
652 p = STK[ToP + 2].v.ival;
653 EiC_CurrentFile = (char*)STK[ToP+2].type;
655 InSt = STK[ToP + 3].v.p.p;
657 env->lsp = STK[ToP + 5].v.ival;
658 STK[ToP].v = STK[ToP + 6].v;
660 AR[1] = &env->LAR[STK[ToP + 4].v.ival];
662 EiC_eicpop(&names,&v);
663 EiC_formatMessage("\n[%s] ", (char*)v.p.p);
675 reg = (_EiC_jmp_buf *) ((char*)STK[ToP].v.p.p - STK[ToP+1].v.ival);
678 EiC_CurrentFile = reg->file;
681 AR[1] = &env->LAR[reg->offset]; /*reg->ar; */
683 if(STK[ToP+1].v.ival == 0)
684 STK[reg->top].v.ival = 1;
686 STK[reg->top].v.ival = STK[ToP+1].v.ival;
700 reg = (_EiC_jmp_buf *) STK[ToP].v.p.p;
703 reg->file = (void*)EiC_CurrentFile; /* save file */
706 reg->offset = AR[1] - env->LAR;
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;
726 case fmem: FMEM; break;
727 case refmem: refMEM; break;
729 memcpy(STK[ToP].v.p.p,InSt[p].val.p.p, InSt[p].ext);
732 env->lsp -= InSt[p].val.ival;
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;
743 (AR_t *) xrealloc(env->LAR,
744 env->LARsize * sizeof(AR_t));
745 AR[1] = &env->LAR[(size_t) d2];
747 if (InSt[p].ext == 0) {
748 env->lsp += InSt[p].val.ival;
749 /*AR[1][0].v.p.p = NULL;*/
753 case halt: STK[ToP].type = InSt[p].val.p.p;
754 ON = 0; EiC_STaCK_VaLuE = STK[ToP].v; break;
765 EiC_messageDisplay("\n");
768 EiC_showvalue(&STK[ToP]);
771 fprintf(stdout," <time taken>: %g\n",
772 (end-start)/(float)CLOCKS_PER_SEC);