![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to interp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb / pascal / px|
Return to interp.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / pascal / px |
1.1 root 1: /* Copyright (c) 1979 Regents of the University of California */
2:
3: static char sccsid[] = "@(#)interp.c 1.30 2/9/83";
4:
5: #include <math.h>
6: #include <signal.h>
7: #include "whoami.h"
8: #include "vars.h"
9: #include "objfmt.h"
10: #include "h02opcs.h"
11: #include "machdep.h"
12: #include "libpc.h"
13:
14: /*
15: * program variables
16: */
17: union display _display;
18: struct dispsave *_dp;
19: long _lino = 0;
20: int _argc;
21: char **_argv;
22: long _mode;
23: long _runtst = (long)TRUE;
24: bool _nodump = FALSE;
25: long _stlim = 500000;
26: long _stcnt = 0;
27: long _seed = 1;
28: #ifdef ADDR32
29: char *_minptr = (char *)0x7fffffff;
30: #endif ADDR32
31: #ifdef ADDR16
32: char *_minptr = (char *)0xffff;
33: #endif ADDR16
34: char *_maxptr = (char *)0;
35: long *_pcpcount = (long *)0;
36: long _cntrs = 0;
37: long _rtns = 0;
38:
39: /*
40: * standard files
41: */
42: char _inwin, _outwin, _errwin;
43: struct iorechd _err = {
44: &_errwin, /* fileptr */
45: 0, /* lcount */
46: 0x7fffffff, /* llimit */
47: &_iob[2], /* fbuf */
48: FILNIL, /* fchain */
49: STDLVL, /* flev */
50: "Message file", /* pfname */
51: FTEXT | FWRITE | EOFF, /* funit */
52: 2, /* fblk */
53: 1 /* fsize */
54: };
55: struct iorechd output = {
56: &_outwin, /* fileptr */
57: 0, /* lcount */
58: 0x7fffffff, /* llimit */
59: &_iob[1], /* fbuf */
60: ERR, /* fchain */
61: STDLVL, /* flev */
62: "standard output", /* pfname */
63: FTEXT | FWRITE | EOFF, /* funit */
64: 1, /* fblk */
65: 1 /* fsize */
66: };
67: struct iorechd input = {
68: &_inwin, /* fileptr */
69: 0, /* lcount */
70: 0x7fffffff, /* llimit */
71: &_iob[0], /* fbuf */
72: OUTPUT, /* fchain */
73: STDLVL, /* flev */
74: "standard input", /* pfname */
75: FTEXT|FREAD|SYNC|EOLN, /* funit */
76: 0, /* fblk */
77: 1 /* fsize */
78: };
79:
80: /*
81: * file record variables
82: */
83: long _filefre = PREDEF;
84: struct iorechd _fchain = {
85: 0, 0, 0, 0, /* only use fchain field */
86: INPUT /* fchain */
87: };
88: struct iorec *_actfile[MAXFILES] = {
89: INPUT,
90: OUTPUT,
91: ERR
92: };
93:
94: /*
95: * stuff for pdx
96: */
97:
98: union progcntr *pcaddrp;
99: asm(".globl _loopaddr");
100:
101: /*
102: * Px profile array
103: */
104: #ifdef PROFILE
105: long _profcnts[NUMOPS];
106: #endif PROFILE
107:
108: /*
109: * debugging variables
110: */
111: #ifdef DEBUG
112: char opc[10];
113: long opcptr = 9;
114: #endif DEBUG
115:
116: interpreter(base)
117: char *base;
118: {
119: union progcntr pc; /* interpreted program cntr */
120: register char *vpc; /* register used for "pc" */
121: struct iorec *curfile; /* active file */
122: register struct blockmark *stp; /* active stack frame ptr */
123: /*
124: * the following variables are used as scratch
125: */
126: register char *tcp;
127: register short *tsp;
128: register long tl, tl1, tl2;
129: double td, td1;
130: struct sze8 t8;
131: register short *tsp1;
132: long *tlp;
133: char *tcp1;
134: bool tb;
135: struct blockmark *tstp;
136: register struct formalrtn *tfp;
137: union progcntr tpc;
138: struct iorec **ip;
139: int mypid;
140:
141: pcaddrp = &pc;
142: mypid = getpid();
143:
144: /*
145: * Setup sets up any hardware specific parameters before
146: * starting the interpreter. Typically this is inline replaced
147: * by interp.sed to utilize specific machine instructions.
148: */
149: setup();
150: /*
151: * necessary only on systems which do not initialize
152: * memory to zero
153: */
154: for (ip = &_actfile[3]; ip < &_actfile[MAXFILES]; *ip++ = FILNIL)
155: /* void */;
156: /*
157: * set up global environment, then ``call'' the main program
158: */
159: _display.frame[0].locvars = pushsp((long)(2 * sizeof(struct iorec *)));
160: _display.frame[0].locvars += 2 * sizeof(struct iorec *);
161: *(struct iorec **)(_display.frame[0].locvars + OUTPUT_OFF) = OUTPUT;
162: *(struct iorec **)(_display.frame[0].locvars + INPUT_OFF) = INPUT;
163: stp = (struct blockmark *)pushsp((long)(sizeof(struct blockmark)));
164: _dp = &_display.frame[0];
165: pc.cp = base;
166:
167: asm("_loopaddr:");
168: for(;;) {
169: # ifdef DEBUG
170: if (++opcptr == 10)
171: opcptr = 0;
172: opc[opcptr] = *pc.ucp;
173: # endif DEBUG
174: # ifdef PROFILE
175: _profcnts[*pc.ucp]++;
176: # endif PROFILE
177: switch (*pc.ucp++) {
178: case O_BPT: /* breakpoint trap */
179: PFLUSH();
180: kill(mypid, SIGILL);
181: pc.ucp--;
182: continue;
183: case O_NODUMP:
184: _nodump = TRUE;
185: /* and fall through */
186: case O_BEG:
187: _dp += 1; /* enter local scope */
188: stp->odisp = *_dp; /* save old display value */
189: tl = *pc.ucp++; /* tl = name size */
190: stp->entry = pc.hdrp; /* pointer to entry info */
191: tl1 = pc.hdrp->framesze;/* tl1 = size of frame */
192: _lino = pc.hdrp->offset;
193: _runtst = pc.hdrp->tests;
194: disableovrflo();
195: if (_runtst)
196: enableovrflo();
197: pc.cp += (int)tl; /* skip over proc hdr info */
198: stp->file = curfile; /* save active file */
199: tcp = pushsp(tl1); /* tcp = new top of stack */
200: if (_runtst) /* zero stack frame */
201: blkclr(tcp, tl1);
202: tcp += (int)tl1; /* offsets of locals are neg */
203: _dp->locvars = tcp; /* set new display pointer */
204: _dp->stp = stp;
205: stp->tos = pushsp((long)0); /* set tos pointer */
206: continue;
207: case O_END:
208: PCLOSE(_dp->locvars); /* flush & close local files */
209: stp = _dp->stp;
210: curfile = stp->file; /* restore old active file */
211: *_dp = stp->odisp; /* restore old display entry */
212: if (_dp == &_display.frame[1])
213: return; /* exiting main proc ??? */
214: _lino = stp->lino; /* restore lino, pc, dp */
215: pc.cp = stp->pc;
216: _dp = stp->dp;
217: _runtst = stp->entry->tests;
218: disableovrflo();
219: if (_runtst)
220: enableovrflo();
221: popsp(stp->entry->framesze + /* pop local vars */
222: sizeof(struct blockmark) + /* pop stack frame */
223: stp->entry->nargs); /* pop parms */
224: continue;
225: case O_CALL:
226: tl = *pc.cp++;
227: tcp = base + *pc.lp++;/* calc new entry point */
228: tcp += sizeof(short);
229: tcp = base + *(long *)tcp;
230: stp = (struct blockmark *)
231: pushsp((long)(sizeof(struct blockmark)));
232: stp->lino = _lino; /* save lino, pc, dp */
233: stp->pc = pc.cp;
234: stp->dp = _dp;
235: _dp = &_display.frame[tl]; /* set up new display ptr */
236: pc.cp = tcp;
237: continue;
238: case O_FCALL:
239: pc.cp++;
240: tcp = popaddr(); /* ptr to display save area */
241: tfp = (struct formalrtn *)popaddr();
242: stp = (struct blockmark *)
243: pushsp((long)(sizeof(struct blockmark)));
244: stp->lino = _lino; /* save lino, pc, dp */
245: stp->pc = pc.cp;
246: stp->dp = _dp;
247: pc.cp = (char *)(tfp->fentryaddr);/* new entry point */
248: _dp = &_display.frame[tfp->fbn];/* new display ptr */
249: blkcpy(&_display.frame[1], tcp,
250: tfp->fbn * sizeof(struct dispsave));
251: blkcpy(&tfp->fdisp[0], &_display.frame[1],
252: tfp->fbn * sizeof(struct dispsave));
253: continue;
254: case O_FRTN:
255: tl = *pc.cp++; /* tl = size of return obj */
256: if (tl == 0)
257: tl = *pc.usp++;
258: tcp = pushsp((long)(0));
259: tfp = *(struct formalrtn **)(tcp + tl);
260: tcp1 = *(char **)
261: (tcp + tl + sizeof(struct formalrtn *));
262: if (tl != 0) {
263: blkcpy(tcp, tcp + sizeof(struct formalrtn *)
264: + sizeof(char *), tl);
265: }
266: popsp((long)
267: (sizeof(struct formalrtn *) + sizeof (char *)));
268: blkcpy(tcp1, &_display.frame[1],
269: tfp->fbn * sizeof(struct dispsave));
270: continue;
271: case O_FSAV:
272: tfp = (struct formalrtn *)popaddr();
273: tfp->fbn = *pc.cp++; /* blk number of routine */
274: tcp = base + *pc.lp++; /* calc new entry point */
275: tcp += sizeof(short);
276: tfp->fentryaddr = (long (*)())(base + *(long *)tcp);
277: blkcpy(&_display.frame[1], &tfp->fdisp[0],
278: tfp->fbn * sizeof(struct dispsave));
279: pushaddr(tfp);
280: continue;
281: case O_SDUP2:
282: pc.cp++;
283: tl = pop2();
284: push2((short)(tl));
285: push2((short)(tl));
286: continue;
287: case O_SDUP4:
288: pc.cp++;
289: tl = pop4();
290: push4(tl);
291: push4(tl);
292: continue;
293: case O_TRA:
294: pc.cp++;
295: pc.cp += *pc.sp;
296: continue;
297: case O_TRA4:
298: pc.cp++;
299: pc.cp = base + *pc.lp;
300: continue;
301: case O_GOTO:
302: tstp = _display.frame[*pc.cp++].stp; /* ptr to
303: exit frame */
304: pc.cp = base + *pc.lp;
305: stp = _dp->stp;
306: while (tstp != stp) {
307: if (_dp == &_display.frame[1])
308: ERROR("Active frame not found in non-local goto\n", 0); /* exiting prog ??? */
309: PCLOSE(_dp->locvars); /* close local files */
310: curfile = stp->file; /* restore active file */
311: *_dp = stp->odisp; /* old display entry */
312: _dp = stp->dp; /* restore dp */
313: stp = _dp->stp;
314: }
315: /* pop locals, stack frame, parms, and return values */
316: popsp((long)(stp->tos - pushsp((long)(0))));
317: continue;
318: case O_LINO:
319: if (_dp->stp->tos != pushsp((long)(0)))
320: ERROR("Panic: stack not empty between statements\n");
321: _lino = *pc.cp++; /* set line number */
322: if (_lino == 0)
323: _lino = *pc.sp++;
324: if (_runtst) {
325: LINO(); /* inc statement count */
326: continue;
327: }
328: _stcnt++;
329: continue;
330: case O_PUSH:
331: tl = *pc.cp++;
332: if (tl == 0)
333: tl = *pc.lp++;
334: tl = (-tl + 1) & ~1;
335: tcp = pushsp(tl);
336: if (_runtst)
337: blkclr(tcp, tl);
338: continue;
339: case O_IF:
340: pc.cp++;
341: if (pop2()) {
342: pc.sp++;
343: continue;
344: }
345: pc.cp += *pc.sp;
346: continue;
347: case O_REL2:
348: tl = pop2();
349: tl1 = pop2();
350: goto cmplong;
351: case O_REL24:
352: tl = pop2();
353: tl1 = pop4();
354: goto cmplong;
355: case O_REL42:
356: tl = pop4();
357: tl1 = pop2();
358: goto cmplong;
359: case O_REL4:
360: tl = pop4();
361: tl1 = pop4();
362: cmplong:
363: switch (*pc.cp++) {
364: case releq:
365: push2(tl1 == tl);
366: continue;
367: case relne:
368: push2(tl1 != tl);
369: continue;
370: case rellt:
371: push2(tl1 < tl);
372: continue;
373: case relgt:
374: push2(tl1 > tl);
375: continue;
376: case relle:
377: push2(tl1 <= tl);
378: continue;
379: case relge:
380: push2(tl1 >= tl);
381: continue;
382: default:
383: ERROR("Panic: bad relation %d to REL4*\n",
384: *(pc.cp - 1));
385: continue;
386: }
387: case O_RELG:
388: tl2 = *pc.cp++; /* tc has jump opcode */
389: tl = *pc.usp++; /* tl has comparison length */
390: tl1 = (tl + 1) & ~1; /* tl1 has arg stack length */
391: tcp = pushsp((long)(0));/* tcp pts to first arg */
392: switch (tl2) {
393: case releq:
394: tb = RELEQ(tl, tcp + tl1, tcp);
395: break;
396: case relne:
397: tb = RELNE(tl, tcp + tl1, tcp);
398: break;
399: case rellt:
400: tb = RELSLT(tl, tcp + tl1, tcp);
401: break;
402: case relgt:
403: tb = RELSGT(tl, tcp + tl1, tcp);
404: break;
405: case relle:
406: tb = RELSLE(tl, tcp + tl1, tcp);
407: break;
408: case relge:
409: tb = RELSGE(tl, tcp + tl1, tcp);
410: break;
411: default:
412: ERROR("Panic: bad relation %d to RELG*\n", tl2);
413: break;
414: }
415: popsp(tl1 << 1);
416: push2((short)(tb));
417: continue;
418: case O_RELT:
419: tl2 = *pc.cp++; /* tc has jump opcode */
420: tl1 = *pc.usp++; /* tl1 has comparison length */
421: tcp = pushsp((long)(0));/* tcp pts to first arg */
422: switch (tl2) {
423: case releq:
424: tb = RELEQ(tl1, tcp + tl1, tcp);
425: break;
426: case relne:
427: tb = RELNE(tl1, tcp + tl1, tcp);
428: break;
429: case rellt:
430: tb = RELTLT(tl1, tcp + tl1, tcp);
431: break;
432: case relgt:
433: tb = RELTGT(tl1, tcp + tl1, tcp);
434: break;
435: case relle:
436: tb = RELTLE(tl1, tcp + tl1, tcp);
437: break;
438: case relge:
439: tb = RELTGE(tl1, tcp + tl1, tcp);
440: break;
441: default:
442: ERROR("Panic: bad relation %d to RELT*\n", tl2);
443: break;
444: }
445: popsp(tl1 << 1);
446: push2((short)(tb));
447: continue;
448: case O_REL28:
449: td = pop2();
450: td1 = pop8();
451: goto cmpdbl;
452: case O_REL48:
453: td = pop4();
454: td1 = pop8();
455: goto cmpdbl;
456: case O_REL82:
457: td = pop8();
458: td1 = pop2();
459: goto cmpdbl;
460: case O_REL84:
461: td = pop8();
462: td1 = pop4();
463: goto cmpdbl;
464: case O_REL8:
465: td = pop8();
466: td1 = pop8();
467: cmpdbl:
468: switch (*pc.cp++) {
469: case releq:
470: push2(td1 == td);
471: continue;
472: case relne:
473: push2(td1 != td);
474: continue;
475: case rellt:
476: push2(td1 < td);
477: continue;
478: case relgt:
479: push2(td1 > td);
480: continue;
481: case relle:
482: push2(td1 <= td);
483: continue;
484: case relge:
485: push2(td1 >= td);
486: continue;
487: default:
488: ERROR("Panic: bad relation %d to REL8*\n",
489: *(pc.cp - 1));
490: continue;
491: }
492: case O_AND:
493: pc.cp++;
494: tl = pop2();
495: tl1 = pop2();
496: push2(tl1 & tl);
497: continue;
498: case O_OR:
499: pc.cp++;
500: tl = pop2();
501: tl1 = pop2();
502: push2(tl1 | tl);
503: continue;
504: case O_NOT:
505: pc.cp++;
506: tl = pop2();
507: push2(tl ^ 1);
508: continue;
509: case O_AS2:
510: pc.cp++;
511: tl = pop2();
512: *(short *)popaddr() = tl;
513: continue;
514: case O_AS4:
515: pc.cp++;
516: tl = pop4();
517: *(long *)popaddr() = tl;
518: continue;
519: case O_AS24:
520: pc.cp++;
521: tl = pop2();
522: *(long *)popaddr() = tl;
523: continue;
524: case O_AS42:
525: pc.cp++;
526: tl = pop4();
527: *(short *)popaddr() = tl;
528: continue;
529: case O_AS21:
530: pc.cp++;
531: tl = pop2();
532: *popaddr() = tl;
533: continue;
534: case O_AS41:
535: pc.cp++;
536: tl = pop4();
537: *popaddr() = tl;
538: continue;
539: case O_AS28:
540: pc.cp++;
541: tl = pop2();
542: *(double *)popaddr() = tl;
543: continue;
544: case O_AS48:
545: pc.cp++;
546: tl = pop4();
547: *(double *)popaddr() = tl;
548: continue;
549: case O_AS8:
550: pc.cp++;
551: t8 = popsze8();
552: *(struct sze8 *)popaddr() = t8;
553: continue;
554: case O_AS:
555: tl = *pc.cp++;
556: if (tl == 0)
557: tl = *pc.usp++;
558: tl1 = (tl + 1) & ~1;
559: tcp = pushsp((long)(0));
560: blkcpy(tcp, *(char **)(tcp + tl1), tl);
561: popsp(tl1 + sizeof(char *));
562: continue;
563: case O_INX2P2:
564: tl = *pc.cp++; /* tl has shift amount */
565: tl1 = pop2();
566: tl1 = (tl1 - *pc.sp++) << tl;
567: tcp = popaddr();
568: pushaddr(tcp + tl1);
569: continue;
570: case O_INX4P2:
571: tl = *pc.cp++; /* tl has shift amount */
572: tl1 = pop4();
573: tl1 = (tl1 - *pc.sp++) << tl;
574: tcp = popaddr();
575: pushaddr(tcp + tl1);
576: continue;
577: case O_INX2:
578: tl = *pc.cp++; /* tl has element size */
579: if (tl == 0)
580: tl = *pc.usp++;
581: tl1 = pop2(); /* index */
582: tl2 = *pc.sp++;
583: tcp = popaddr();
584: pushaddr(tcp + (tl1 - tl2) * tl);
585: tl = *pc.usp++;
586: if (_runtst)
587: SUBSC(tl1, tl2, tl); /* range check */
588: continue;
589: case O_INX4:
590: tl = *pc.cp++; /* tl has element size */
591: if (tl == 0)
592: tl = *pc.usp++;
593: tl1 = pop4(); /* index */
594: tl2 = *pc.sp++;
595: tcp = popaddr();
596: pushaddr(tcp + (tl1 - tl2) * tl);
597: tl = *pc.usp++;
598: if (_runtst)
599: SUBSC(tl1, tl2, tl); /* range check */
600: continue;
601: case O_OFF:
602: tl = *pc.cp++;
603: if (tl == 0)
604: tl = *pc.usp++;
605: tcp = popaddr();
606: pushaddr(tcp + tl);
607: continue;
608: case O_NIL:
609: pc.cp++;
610: NIL();
611: continue;
612: case O_ADD2:
613: pc.cp++;
614: tl = pop2();
615: tl1 = pop2();
616: push4(tl1 + tl);
617: continue;
618: case O_ADD4:
619: pc.cp++;
620: tl = pop4();
621: tl1 = pop4();
622: push4(tl1 + tl);
623: continue;
624: case O_ADD24:
625: pc.cp++;
626: tl = pop2();
627: tl1 = pop4();
628: push4(tl1 + tl);
629: continue;
630: case O_ADD42:
631: pc.cp++;
632: tl = pop4();
633: tl1 = pop2();
634: push4(tl1 + tl);
635: continue;
636: case O_ADD28:
637: pc.cp++;
638: tl = pop2();
639: td = pop8();
640: push8(td + tl);
641: continue;
642: case O_ADD48:
643: pc.cp++;
644: tl = pop4();
645: td = pop8();
646: push8(td + tl);
647: continue;
648: case O_ADD82:
649: pc.cp++;
650: td = pop8();
651: td1 = pop2();
652: push8(td1 + td);
653: continue;
654: case O_ADD84:
655: pc.cp++;
656: td = pop8();
657: td1 = pop4();
658: push8(td1 + td);
659: continue;
660: case O_SUB2:
661: pc.cp++;
662: tl = pop2();
663: tl1 = pop2();
664: push4(tl1 - tl);
665: continue;
666: case O_SUB4:
667: pc.cp++;
668: tl = pop4();
669: tl1 = pop4();
670: push4(tl1 - tl);
671: continue;
672: case O_SUB24:
673: pc.cp++;
674: tl = pop2();
675: tl1 = pop4();
676: push4(tl1 - tl);
677: continue;
678: case O_SUB42:
679: pc.cp++;
680: tl = pop4();
681: tl1 = pop2();
682: push4(tl1 - tl);
683: continue;
684: case O_SUB28:
685: pc.cp++;
686: tl = pop2();
687: td = pop8();
688: push8(td - tl);
689: continue;
690: case O_SUB48:
691: pc.cp++;
692: tl = pop4();
693: td = pop8();
694: push8(td - tl);
695: continue;
696: case O_SUB82:
697: pc.cp++;
698: td = pop8();
699: td1 = pop2();
700: push8(td1 - td);
701: continue;
702: case O_SUB84:
703: pc.cp++;
704: td = pop8();
705: td1 = pop4();
706: push8(td1 - td);
707: continue;
708: case O_MUL2:
709: pc.cp++;
710: tl = pop2();
711: tl1 = pop2();
712: push4(tl1 * tl);
713: continue;
714: case O_MUL4:
715: pc.cp++;
716: tl = pop4();
717: tl1 = pop4();
718: push4(tl1 * tl);
719: continue;
720: case O_MUL24:
721: pc.cp++;
722: tl = pop2();
723: tl1 = pop4();
724: push4(tl1 * tl);
725: continue;
726: case O_MUL42:
727: pc.cp++;
728: tl = pop4();
729: tl1 = pop2();
730: push4(tl1 * tl);
731: continue;
732: case O_MUL28:
733: pc.cp++;
734: tl = pop2();
735: td = pop8();
736: push8(td * tl);
737: continue;
738: case O_MUL48:
739: pc.cp++;
740: tl = pop4();
741: td = pop8();
742: push8(td * tl);
743: continue;
744: case O_MUL82:
745: pc.cp++;
746: td = pop8();
747: td1 = pop2();
748: push8(td1 * td);
749: continue;
750: case O_MUL84:
751: pc.cp++;
752: td = pop8();
753: td1 = pop4();
754: push8(td1 * td);
755: continue;
756: case O_ABS2:
757: case O_ABS4:
758: pc.cp++;
759: tl = pop4();
760: push4(tl >= 0 ? tl : -tl);
761: continue;
762: case O_ABS8:
763: pc.cp++;
764: td = pop8();
765: push8(td >= 0.0 ? td : -td);
766: continue;
767: case O_NEG2:
768: pc.cp++;
769: push4((long)(-pop2()));
770: continue;
771: case O_NEG4:
772: pc.cp++;
773: push4(-pop4());
774: continue;
775: case O_NEG8:
776: pc.cp++;
777: push8(-pop8());
778: continue;
779: case O_DIV2:
780: pc.cp++;
781: tl = pop2();
782: tl1 = pop2();
783: push4(tl1 / tl);
784: continue;
785: case O_DIV4:
786: pc.cp++;
787: tl = pop4();
788: tl1 = pop4();
789: push4(tl1 / tl);
790: continue;
791: case O_DIV24:
792: pc.cp++;
793: tl = pop2();
794: tl1 = pop4();
795: push4(tl1 / tl);
796: continue;
797: case O_DIV42:
798: pc.cp++;
799: tl = pop4();
800: tl1 = pop2();
801: push4(tl1 / tl);
802: continue;
803: case O_MOD2:
804: pc.cp++;
805: tl = pop2();
806: tl1 = pop2();
807: push4(tl1 % tl);
808: continue;
809: case O_MOD4:
810: pc.cp++;
811: tl = pop4();
812: tl1 = pop4();
813: push4(tl1 % tl);
814: continue;
815: case O_MOD24:
816: pc.cp++;
817: tl = pop2();
818: tl1 = pop4();
819: push4(tl1 % tl);
820: continue;
821: case O_MOD42:
822: pc.cp++;
823: tl = pop4();
824: tl1 = pop2();
825: push4(tl1 % tl);
826: continue;
827: case O_ADD8:
828: pc.cp++;
829: td = pop8();
830: td1 = pop8();
831: push8(td1 + td);
832: continue;
833: case O_SUB8:
834: pc.cp++;
835: td = pop8();
836: td1 = pop8();
837: push8(td1 - td);
838: continue;
839: case O_MUL8:
840: pc.cp++;
841: td = pop8();
842: td1 = pop8();
843: push8(td1 * td);
844: continue;
845: case O_DVD8:
846: pc.cp++;
847: td = pop8();
848: td1 = pop8();
849: push8(td1 / td);
850: continue;
851: case O_STOI:
852: pc.cp++;
853: push4((long)(pop2()));
854: continue;
855: case O_STOD:
856: pc.cp++;
857: td = pop2();
858: push8(td);
859: continue;
860: case O_ITOD:
861: pc.cp++;
862: td = pop4();
863: push8(td);
864: continue;
865: case O_ITOS:
866: pc.cp++;
867: push2((short)(pop4()));
868: continue;
869: case O_DVD2:
870: pc.cp++;
871: td = pop2();
872: td1 = pop2();
873: push8(td1 / td);
874: continue;
875: case O_DVD4:
876: pc.cp++;
877: td = pop4();
878: td1 = pop4();
879: push8(td1 / td);
880: continue;
881: case O_DVD24:
882: pc.cp++;
883: td = pop2();
884: td1 = pop4();
885: push8(td1 / td);
886: continue;
887: case O_DVD42:
888: pc.cp++;
889: td = pop4();
890: td1 = pop2();
891: push8(td1 / td);
892: continue;
893: case O_DVD28:
894: pc.cp++;
895: td = pop2();
896: td1 = pop8();
897: push8(td1 / td);
898: continue;
899: case O_DVD48:
900: pc.cp++;
901: td = pop4();
902: td1 = pop8();
903: push8(td1 / td);
904: continue;
905: case O_DVD82:
906: pc.cp++;
907: td = pop8();
908: td1 = pop2();
909: push8(td1 / td);
910: continue;
911: case O_DVD84:
912: pc.cp++;
913: td = pop8();
914: td1 = pop4();
915: push8(td1 / td);
916: continue;
917: case O_RV1:
918: tcp = _display.raw[*pc.ucp++];
919: push2((short)(*(tcp + *pc.sp++)));
920: continue;
921: case O_RV14:
922: tcp = _display.raw[*pc.ucp++];
923: push4((long)(*(tcp + *pc.sp++)));
924: continue;
925: case O_RV2:
926: tcp = _display.raw[*pc.ucp++];
927: push2(*(short *)(tcp + *pc.sp++));
928: continue;
929: case O_RV24:
930: tcp = _display.raw[*pc.ucp++];
931: push4((long)(*(short *)(tcp + *pc.sp++)));
932: continue;
933: case O_RV4:
934: tcp = _display.raw[*pc.ucp++];
935: push4(*(long *)(tcp + *pc.sp++));
936: continue;
937: case O_RV8:
938: tcp = _display.raw[*pc.ucp++];
939: pushsze8(*(struct sze8 *)(tcp + *pc.sp++));
940: continue;
941: case O_RV:
942: tcp = _display.raw[*pc.ucp++];
943: tcp += *pc.sp++;
944: tl = *pc.usp++;
945: tcp1 = pushsp((tl + 1) & ~1);
946: blkcpy(tcp, tcp1, tl);
947: continue;
948: case O_LV:
949: tcp = _display.raw[*pc.ucp++];
950: pushaddr(tcp + *pc.sp++);
951: continue;
952: case O_LRV1:
953: tcp = _display.raw[*pc.ucp++];
954: push2((short)(*(tcp + *pc.lp++)));
955: continue;
956: case O_LRV14:
957: tcp = _display.raw[*pc.ucp++];
958: push4((long)(*(tcp + *pc.lp++)));
959: continue;
960: case O_LRV2:
961: tcp = _display.raw[*pc.ucp++];
962: push2(*(short *)(tcp + *pc.lp++));
963: continue;
964: case O_LRV24:
965: tcp = _display.raw[*pc.ucp++];
966: push4((long)(*(short *)(tcp + *pc.lp++)));
967: continue;
968: case O_LRV4:
969: tcp = _display.raw[*pc.ucp++];
970: push4(*(long *)(tcp + *pc.lp++));
971: continue;
972: case O_LRV8:
973: tcp = _display.raw[*pc.ucp++];
974: pushsze8(*(struct sze8 *)(tcp + *pc.lp++));
975: continue;
976: case O_LRV:
977: tcp = _display.raw[*pc.ucp++];
978: tcp += (int)*pc.lp++;
979: tl = *pc.usp++;
980: tcp1 = pushsp((tl + 1) & ~1);
981: blkcpy(tcp, tcp1, tl);
982: continue;
983: case O_LLV:
984: tcp = _display.raw[*pc.ucp++];
985: pushaddr(tcp + *pc.lp++);
986: continue;
987: case O_IND1:
988: pc.cp++;
989: push2((short)(*popaddr()));
990: continue;
991: case O_IND14:
992: pc.cp++;
993: push4((long)(*popaddr()));
994: continue;
995: case O_IND2:
996: pc.cp++;
997: push2(*(short *)(popaddr()));
998: continue;
999: case O_IND24:
1000: pc.cp++;
1001: push4((long)(*(short *)(popaddr())));
1002: continue;
1003: case O_IND4:
1004: pc.cp++;
1005: push4(*(long *)(popaddr()));
1006: continue;
1007: case O_IND8:
1008: pc.cp++;
1009: pushsze8(*(struct sze8 *)(popaddr()));
1010: continue;
1011: case O_IND:
1012: tl = *pc.cp++;
1013: if (tl == 0)
1014: tl = *pc.usp++;
1015: tcp = popaddr();
1016: tcp1 = pushsp((tl + 1) & ~1);
1017: blkcpy(tcp, tcp1, tl);
1018: continue;
1019: case O_CON1:
1020: push2((short)(*pc.cp++));
1021: continue;
1022: case O_CON14:
1023: push4((long)(*pc.cp++));
1024: continue;
1025: case O_CON2:
1026: pc.cp++;
1027: push2(*pc.sp++);
1028: continue;
1029: case O_CON24:
1030: pc.cp++;
1031: push4((long)(*pc.sp++));
1032: continue;
1033: case O_CON4:
1034: pc.cp++;
1035: push4(*pc.lp++);
1036: continue;
1037: case O_CON8:
1038: pc.cp++;
1039: push8(*pc.dbp++);
1040: continue;
1041: case O_CON:
1042: tl = *pc.cp++;
1043: if (tl == 0)
1044: tl = *pc.usp++;
1045: tl = (tl + 1) & ~1;
1046: tcp = pushsp(tl);
1047: blkcpy(pc.cp, tcp, tl);
1048: pc.cp += (int)tl;
1049: continue;
1050: case O_CONG:
1051: tl = *pc.cp++;
1052: if (tl == 0)
1053: tl = *pc.usp++;
1054: tl1 = (tl + 1) & ~1;
1055: tcp = pushsp(tl1);
1056: blkcpy(pc.cp, tcp, tl1);
1057: pc.cp += (int)((tl + 2) & ~1);
1058: continue;
1059: case O_LVCON:
1060: tl = *pc.cp++;
1061: if (tl == 0)
1062: tl = *pc.usp++;
1063: tl = (tl + 1) & ~1;
1064: pushaddr(pc.cp);
1065: pc.cp += (int)tl;
1066: continue;
1067: case O_RANG2:
1068: tl = *pc.cp++;
1069: if (tl == 0)
1070: tl = *pc.sp++;
1071: tl1 = pop2();
1072: push2((short)(RANG4(tl1, tl, (long)(*pc.sp++))));
1073: continue;
1074: case O_RANG42:
1075: tl = *pc.cp++;
1076: if (tl == 0)
1077: tl = *pc.sp++;
1078: tl1 = pop4();
1079: push4(RANG4(tl1, tl, (long)(*pc.sp++)));
1080: continue;
1081: case O_RSNG2:
1082: tl = *pc.cp++;
1083: if (tl == 0)
1084: tl = *pc.sp++;
1085: tl1 = pop2();
1086: push2((short)(RSNG4(tl1, tl)));
1087: continue;
1088: case O_RSNG42:
1089: tl = *pc.cp++;
1090: if (tl == 0)
1091: tl = *pc.sp++;
1092: tl1 = pop4();
1093: push4(RSNG4(tl1, tl));
1094: continue;
1095: case O_RANG4:
1096: tl = *pc.cp++;
1097: if (tl == 0)
1098: tl = *pc.lp++;
1099: tl1 = pop4();
1100: push4(RANG4(tl1, tl, *pc.lp++));
1101: continue;
1102: case O_RANG24:
1103: tl = *pc.cp++;
1104: if (tl == 0)
1105: tl = *pc.lp++;
1106: tl1 = pop2();
1107: push2((short)(RANG4(tl1, tl, *pc.lp++)));
1108: continue;
1109: case O_RSNG4:
1110: tl = *pc.cp++;
1111: if (tl == 0)
1112: tl = *pc.lp++;
1113: tl1 = pop4();
1114: push4(RSNG4(tl1, tl));
1115: continue;
1116: case O_RSNG24:
1117: tl = *pc.cp++;
1118: if (tl == 0)
1119: tl = *pc.lp++;
1120: tl1 = pop2();
1121: push2((short)(RSNG4(tl1, tl)));
1122: continue;
1123: case O_STLIM:
1124: pc.cp++;
1125: STLIM();
1126: popsp((long)(sizeof(long)));
1127: continue;
1128: case O_LLIMIT:
1129: pc.cp++;
1130: LLIMIT();
1131: popsp((long)(sizeof(char *)+sizeof(long)));
1132: continue;
1133: case O_BUFF:
1134: BUFF((long)(*pc.cp++));
1135: continue;
1136: case O_HALT:
1137: pc.cp++;
1138: if (_nodump == TRUE)
1139: psexit(0);
1140: fputs("\nCall to procedure halt\n", stderr);
1141: backtrace("Halted");
1142: psexit(0);
1143: continue;
1144: case O_PXPBUF:
1145: pc.cp++;
1146: _cntrs = *pc.lp++;
1147: _rtns = *pc.lp++;
1148: NEW(&_pcpcount, (_cntrs + 1) * sizeof(long));
1149: blkclr(_pcpcount, (_cntrs + 1) * sizeof(long));
1150: continue;
1151: case O_COUNT:
1152: pc.cp++;
1153: _pcpcount[*pc.usp++]++;
1154: continue;
1155: case O_CASE1OP:
1156: tl = *pc.cp++; /* tl = number of cases */
1157: if (tl == 0)
1158: tl = *pc.usp++;
1159: tsp = pc.sp + tl; /* ptr to end of jump table */
1160: tcp = (char *)tsp; /* tcp = ptr to case values */
1161: tl1 = pop2(); /* tl1 = element to find */
1162: for(; tl > 0; tl--) /* look for element */
1163: if (tl1 == *tcp++)
1164: break;
1165: if (tl == 0) /* default case => error */
1166: CASERNG(tl1);
1167: pc.cp += *(tsp - tl);
1168: continue;
1169: case O_CASE2OP:
1170: tl = *pc.cp++; /* tl = number of cases */
1171: if (tl == 0)
1172: tl = *pc.usp++;
1173: tsp = pc.sp + tl; /* ptr to end of jump table */
1174: tsp1 = tsp; /* tsp1 = ptr to case values */
1175: tl1 = (unsigned short)pop2();/* tl1 = element to find */
1176: for(; tl > 0; tl--) /* look for element */
1177: if (tl1 == *tsp1++)
1178: break;
1179: if (tl == 0) /* default case => error */
1180: CASERNG(tl1);
1181: pc.cp += *(tsp - tl);
1182: continue;
1183: case O_CASE4OP:
1184: tl = *pc.cp++; /* tl = number of cases */
1185: if (tl == 0)
1186: tl = *pc.usp++;
1187: tsp = pc.sp + tl; /* ptr to end of jump table */
1188: tlp = (long *)tsp; /* tlp = ptr to case values */
1189: tl1 = pop4(); /* tl1 = element to find */
1190: for(; tl > 0; tl--) /* look for element */
1191: if (tl1 == *tlp++)
1192: break;
1193: if (tl == 0) /* default case => error */
1194: CASERNG(tl1);
1195: pc.cp += *(tsp - tl);
1196: continue;
1197: case O_ADDT:
1198: tl = *pc.cp++; /* tl has comparison length */
1199: if (tl == 0)
1200: tl = *pc.usp++;
1201: tcp = pushsp((long)(0));/* tcp pts to first arg */
1202: ADDT(tcp + tl, tcp + tl, tcp, tl >> 2);
1203: popsp(tl);
1204: continue;
1205: case O_SUBT:
1206: tl = *pc.cp++; /* tl has comparison length */
1207: if (tl == 0)
1208: tl = *pc.usp++;
1209: tcp = pushsp((long)(0));/* tcp pts to first arg */
1210: SUBT(tcp + tl, tcp + tl, tcp, tl >> 2);
1211: popsp(tl);
1212: continue;
1213: case O_MULT:
1214: tl = *pc.cp++; /* tl has comparison length */
1215: if (tl == 0)
1216: tl = *pc.usp++;
1217: tcp = pushsp((long)(0));/* tcp pts to first arg */
1218: MULT(tcp + tl, tcp + tl, tcp, tl >> 2);
1219: popsp(tl);
1220: continue;
1221: case O_INCT:
1222: tl = *pc.cp++; /* tl has number of args */
1223: if (tl == 0)
1224: tl = *pc.usp++;
1225: tb = INCT();
1226: popsp(tl*sizeof(long));
1227: push2((short)(tb));
1228: continue;
1229: case O_CTTOT:
1230: tl = *pc.cp++; /* tl has number of args */
1231: if (tl == 0)
1232: tl = *pc.usp++;
1233: tl1 = tl * sizeof(long);
1234: tcp = pushsp((long)(0)) + tl1; /* tcp pts to result */
1235: CTTOT(tcp);
1236: popsp(tl*sizeof(long));
1237: continue;
1238: case O_CARD:
1239: tl = *pc.cp++; /* tl has comparison length */
1240: if (tl == 0)
1241: tl = *pc.usp++;
1242: tcp = pushsp((long)(0));/* tcp pts to set */
1243: tl1 = CARD(tcp, tl);
1244: popsp(tl);
1245: push2((short)(tl1));
1246: continue;
1247: case O_IN:
1248: tl = *pc.cp++; /* tl has comparison length */
1249: if (tl == 0)
1250: tl = *pc.usp++;
1251: tl1 = pop4(); /* tl1 is the element */
1252: tcp = pushsp((long)(0));/* tcp pts to set */
1253: tl2 = *pc.sp++; /* lower bound */
1254: tb = IN(tl1, tl2, (long)(*pc.usp++), tcp);
1255: popsp(tl);
1256: push2((short)(tb));
1257: continue;
1258: case O_ASRT:
1259: pc.cp++;
1260: ASRTS();
1261: popsp((long)(sizeof(long)+sizeof(char *)));
1262: continue;
1263: case O_FOR1U:
1264: tl1 = *pc.cp++; /* tl1 loop branch */
1265: if (tl1 == 0)
1266: tl1 = *pc.sp++;
1267: tcp = popaddr(); /* tcp = ptr to index var */
1268: tl = pop4(); /* tl upper bound */
1269: if (*tcp == tl) /* loop is done, fall through */
1270: continue;
1271: *tcp += 1; /* inc index var */
1272: pc.cp += tl1; /* return to top of loop */
1273: continue;
1274: case O_FOR2U:
1275: tl1 = *pc.cp++; /* tl1 loop branch */
1276: if (tl1 == 0)
1277: tl1 = *pc.sp++;
1278: tsp = (short *)popaddr(); /* tsp = ptr to index var */
1279: tl = pop4(); /* tl upper bound */
1280: if (*tsp == tl) /* loop is done, fall through */
1281: continue;
1282: *tsp += 1; /* inc index var */
1283: pc.cp += tl1; /* return to top of loop */
1284: continue;
1285: case O_FOR4U:
1286: tl1 = *pc.cp++; /* tl1 loop branch */
1287: if (tl1 == 0)
1288: tl1 = *pc.sp++;
1289: tlp = (long *)popaddr(); /* tlp = ptr to index var */
1290: tl = pop4(); /* tl upper bound */
1291: if (*tlp == tl) /* loop is done, fall through */
1292: continue;
1293: *tlp += 1; /* inc index var */
1294: pc.cp += tl1; /* return to top of loop */
1295: continue;
1296: case O_FOR1D:
1297: tl1 = *pc.cp++; /* tl1 loop branch */
1298: if (tl1 == 0)
1299: tl1 = *pc.sp++;
1300: tcp = popaddr(); /* tcp = ptr to index var */
1301: tl = pop4(); /* tl upper bound */
1302: if (*tcp == tl) /* loop is done, fall through */
1303: continue;
1304: *tcp -= 1; /* dec index var */
1305: pc.cp += tl1; /* return to top of loop */
1306: continue;
1307: case O_FOR2D:
1308: tl1 = *pc.cp++; /* tl1 loop branch */
1309: if (tl1 == 0)
1310: tl1 = *pc.sp++;
1311: tsp = (short *)popaddr(); /* tsp = ptr to index var */
1312: tl = pop4(); /* tl upper bound */
1313: if (*tsp == tl) /* loop is done, fall through */
1314: continue;
1315: *tsp -= 1; /* dec index var */
1316: pc.cp += tl1; /* return to top of loop */
1317: continue;
1318: case O_FOR4D:
1319: tl1 = *pc.cp++; /* tl1 loop branch */
1320: if (tl1 == 0)
1321: tl1 = *pc.sp++;
1322: tlp = (long *)popaddr(); /* tlp = ptr to index var */
1323: tl = pop4(); /* tl upper bound */
1324: if (*tlp == tl) /* loop is done, fall through */
1325: continue;
1326: *tlp -= 1; /* dec index var */
1327: pc.cp += tl1; /* return to top of loop */
1328: continue;
1329: case O_READE:
1330: pc.cp++;
1331: push2((short)(READE(curfile, base + *pc.lp++)));
1332: continue;
1333: case O_READ4:
1334: pc.cp++;
1335: push4(READ4(curfile));
1336: continue;
1337: case O_READC:
1338: pc.cp++;
1339: push2((short)(READC(curfile)));
1340: continue;
1341: case O_READ8:
1342: pc.cp++;
1343: push8(READ8(curfile));
1344: continue;
1345: case O_READLN:
1346: pc.cp++;
1347: READLN(curfile);
1348: continue;
1349: case O_EOF:
1350: pc.cp++;
1351: push2((short)(TEOF(popaddr())));
1352: continue;
1353: case O_EOLN:
1354: pc.cp++;
1355: push2((short)(TEOLN(popaddr())));
1356: continue;
1357: case O_WRITEC:
1358: if (_runtst) {
1359: WRITEC(curfile);
1360: popsp((long)(*pc.cp++));
1361: continue;
1362: }
1363: fputc();
1364: popsp((long)(*pc.cp++));
1365: continue;
1366: case O_WRITES:
1367: if (_runtst) {
1368: WRITES(curfile);
1369: popsp((long)(*pc.cp++));
1370: continue;
1371: }
1372: fwrite();
1373: popsp((long)(*pc.cp++));
1374: continue;
1375: case O_WRITEF:
1376: if (_runtst) {
1377: WRITEF(curfile);
1378: popsp((long)(*pc.cp++));
1379: continue;
1380: }
1381: fprintf();
1382: popsp((long)(*pc.cp++));
1383: continue;
1384: case O_WRITLN:
1385: pc.cp++;
1386: if (_runtst) {
1387: WRITLN(curfile);
1388: continue;
1389: }
1390: fputc('\n', ACTFILE(curfile));
1391: continue;
1392: case O_PAGE:
1393: pc.cp++;
1394: if (_runtst) {
1395: PAGE(curfile);
1396: continue;
1397: }
1398: fputc(' ', ACTFILE(curfile));
1399: continue;
1400: case O_NAM:
1401: pc.cp++;
1402: tl = pop4();
1403: pushaddr(NAM(tl, base + *pc.lp++));
1404: continue;
1405: case O_MAX:
1406: tl = *pc.cp++;
1407: if (tl == 0)
1408: tl = *pc.usp++;
1409: tl1 = pop4();
1410: if (_runtst) {
1411: push4(MAX(tl1, tl, (long)(*pc.usp++)));
1412: continue;
1413: }
1414: tl1 -= tl;
1415: tl = *pc.usp++;
1416: push4(tl1 > tl ? tl1 : tl);
1417: continue;
1418: case O_MIN:
1419: tl = *pc.cp++;
1420: if (tl == 0)
1421: tl = *pc.usp++;
1422: tl1 = pop4();
1423: push4(tl1 < tl ? tl1 : tl);
1424: continue;
1425: case O_UNIT:
1426: pc.cp++;
1427: curfile = UNIT(popaddr());
1428: continue;
1429: case O_UNITINP:
1430: pc.cp++;
1431: curfile = INPUT;
1432: continue;
1433: case O_UNITOUT:
1434: pc.cp++;
1435: curfile = OUTPUT;
1436: continue;
1437: case O_MESSAGE:
1438: pc.cp++;
1439: PFLUSH();
1440: curfile = ERR;
1441: continue;
1442: case O_PUT:
1443: pc.cp++;
1444: PUT(curfile);
1445: continue;
1446: case O_GET:
1447: pc.cp++;
1448: GET(curfile);
1449: continue;
1450: case O_FNIL:
1451: pc.cp++;
1452: pushaddr(FNIL(popaddr()));
1453: continue;
1454: case O_DEFNAME:
1455: pc.cp++;
1456: DEFNAME();
1457: popsp((long)(2*sizeof(char *)+2*sizeof(long)));
1458: continue;
1459: case O_RESET:
1460: pc.cp++;
1461: RESET();
1462: popsp((long)(2*sizeof(char *)+2*sizeof(long)));
1463: continue;
1464: case O_REWRITE:
1465: pc.cp++;
1466: REWRITE();
1467: popsp((long)(2*sizeof(char *)+2*sizeof(long)));
1468: continue;
1469: case O_FILE:
1470: pc.cp++;
1471: pushaddr(ACTFILE(curfile));
1472: continue;
1473: case O_REMOVE:
1474: pc.cp++;
1475: REMOVE();
1476: popsp((long)(sizeof(char *)+sizeof(long)));
1477: continue;
1478: case O_FLUSH:
1479: pc.cp++;
1480: FLUSH();
1481: popsp((long)(sizeof(char *)));
1482: continue;
1483: case O_PACK:
1484: pc.cp++;
1485: PACK();
1486: popsp((long)(5*sizeof(long)+2*sizeof(char*)));
1487: continue;
1488: case O_UNPACK:
1489: pc.cp++;
1490: UNPACK();
1491: popsp((long)(5*sizeof(long)+2*sizeof(char*)));
1492: continue;
1493: case O_ARGC:
1494: pc.cp++;
1495: push4((long)_argc);
1496: continue;
1497: case O_ARGV:
1498: tl = *pc.cp++; /* tl = size of char array */
1499: if (tl == 0)
1500: tl = *pc.usp++;
1501: tcp = popaddr(); /* tcp = addr of char array */
1502: tl1 = pop4(); /* tl1 = argv subscript */
1503: ARGV(tl1, tcp, tl);
1504: continue;
1505: case O_CLCK:
1506: pc.cp++;
1507: push4(CLCK());
1508: continue;
1509: case O_WCLCK:
1510: pc.cp++;
1511: push4(time(0));
1512: continue;
1513: case O_SCLCK:
1514: pc.cp++;
1515: push4(SCLCK());
1516: continue;
1517: case O_NEW:
1518: tl = *pc.cp++; /* tl = size being new'ed */
1519: if (tl == 0)
1520: tl = *pc.usp++;
1521: tcp = popaddr(); /* ptr to ptr being new'ed */
1522: NEW(tcp, tl);
1523: if (_runtst) {
1524: blkclr(*((char **)(tcp)), tl);
1525: }
1526: continue;
1527: case O_DISPOSE:
1528: tl = *pc.cp++; /* tl = size being disposed */
1529: if (tl == 0)
1530: tl = *pc.usp++;
1531: tcp = popaddr(); /* ptr to ptr being disposed */
1532: DISPOSE(tcp, tl);
1533: *(char **)tcp = (char *)0;
1534: continue;
1535: case O_DFDISP:
1536: tl = *pc.cp++; /* tl = size being disposed */
1537: if (tl == 0)
1538: tl = *pc.usp++;
1539: tcp = popaddr(); /* ptr to ptr being disposed */
1540: DFDISPOSE(tcp, tl);
1541: *(char **)tcp = (char *)0;
1542: continue;
1543: case O_DATE:
1544: pc.cp++;
1545: DATE(popaddr());
1546: continue;
1547: case O_TIME:
1548: pc.cp++;
1549: TIME(popaddr());
1550: continue;
1551: case O_UNDEF:
1552: pc.cp++;
1553: pop8();
1554: push2((short)(0));
1555: continue;
1556: case O_ATAN:
1557: pc.cp++;
1558: if (_runtst) {
1559: push8(ATAN(pop8()));
1560: continue;
1561: }
1562: push8(atan(pop8()));
1563: continue;
1564: case O_COS:
1565: pc.cp++;
1566: if (_runtst) {
1567: push8(COS(pop8()));
1568: continue;
1569: }
1570: push8(cos(pop8()));
1571: continue;
1572: case O_EXP:
1573: pc.cp++;
1574: if (_runtst) {
1575: push8(EXP(pop8()));
1576: continue;
1577: }
1578: push8(exp(pop8()));
1579: continue;
1580: case O_LN:
1581: pc.cp++;
1582: if (_runtst) {
1583: push8(LN(pop8()));
1584: continue;
1585: }
1586: push8(log(pop8()));
1587: continue;
1588: case O_SIN:
1589: pc.cp++;
1590: if (_runtst) {
1591: push8(SIN(pop8()));
1592: continue;
1593: }
1594: push8(sin(pop8()));
1595: continue;
1596: case O_SQRT:
1597: pc.cp++;
1598: if (_runtst) {
1599: push8(SQRT(pop8()));
1600: continue;
1601: }
1602: push8(sqrt(pop8()));
1603: continue;
1604: case O_CHR2:
1605: case O_CHR4:
1606: pc.cp++;
1607: if (_runtst) {
1608: push2((short)(CHR(pop4())));
1609: continue;
1610: }
1611: push2((short)(pop4()));
1612: continue;
1613: case O_ODD2:
1614: case O_ODD4:
1615: pc.cp++;
1616: tl = pop4();
1617: push2((short)(tl & 1));
1618: continue;
1619: case O_SUCC2:
1620: tl = *pc.cp++;
1621: if (tl == 0)
1622: tl = *pc.sp++;
1623: tl1 = pop4();
1624: if (_runtst) {
1625: push2((short)(SUCC(tl1, tl, (long)(*pc.sp++))));
1626: continue;
1627: }
1628: push2((short)(tl1 + 1));
1629: pc.sp++;
1630: continue;
1631: case O_SUCC24:
1632: tl = *pc.cp++;
1633: if (tl == 0)
1634: tl = *pc.sp++;
1635: tl1 = pop4();
1636: if (_runtst) {
1637: push4(SUCC(tl1, tl, (long)(*pc.sp++)));
1638: continue;
1639: }
1640: push4(tl1 + 1);
1641: pc.sp++;
1642: continue;
1643: case O_SUCC4:
1644: tl = *pc.cp++;
1645: if (tl == 0)
1646: tl = *pc.lp++;
1647: tl1 = pop4();
1648: if (_runtst) {
1649: push4(SUCC(tl1, tl, (long)(*pc.lp++)));
1650: continue;
1651: }
1652: push4(tl1 + 1);
1653: pc.lp++;
1654: continue;
1655: case O_PRED2:
1656: tl = *pc.cp++;
1657: if (tl == 0)
1658: tl = *pc.sp++;
1659: tl1 = pop4();
1660: if (_runtst) {
1661: push2((short)(PRED(tl1, tl, (long)(*pc.sp++))));
1662: continue;
1663: }
1664: push2((short)(tl1 - 1));
1665: pc.sp++;
1666: continue;
1667: case O_PRED24:
1668: tl = *pc.cp++;
1669: if (tl == 0)
1670: tl = *pc.sp++;
1671: tl1 = pop4();
1672: if (_runtst) {
1673: push4(PRED(tl1, tl, (long)(*pc.sp++)));
1674: continue;
1675: }
1676: push4(tl1 - 1);
1677: pc.sp++;
1678: continue;
1679: case O_PRED4:
1680: tl = *pc.cp++;
1681: if (tl == 0)
1682: tl = *pc.lp++;
1683: tl1 = pop4();
1684: if (_runtst) {
1685: push4(PRED(tl1, tl, (long)(*pc.lp++)));
1686: continue;
1687: }
1688: push4(tl1 - 1);
1689: pc.lp++;
1690: continue;
1691: case O_SEED:
1692: pc.cp++;
1693: push4(SEED(pop4()));
1694: continue;
1695: case O_RANDOM:
1696: pc.cp++;
1697: push8(RANDOM(pop8()));
1698: continue;
1699: case O_EXPO:
1700: pc.cp++;
1701: push4(EXPO(pop8()));
1702: continue;
1703: case O_SQR2:
1704: case O_SQR4:
1705: pc.cp++;
1706: tl = pop4();
1707: push4(tl * tl);
1708: continue;
1709: case O_SQR8:
1710: pc.cp++;
1711: td = pop8();
1712: push8(td * td);
1713: continue;
1714: case O_ROUND:
1715: pc.cp++;
1716: push4(ROUND(pop8()));
1717: continue;
1718: case O_TRUNC:
1719: pc.cp++;
1720: push4(TRUNC(pop8()));
1721: continue;
1722: default:
1723: ERROR("Panic: bad op code\n");
1724: continue;
1725: }
1726: }
1727: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.