projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
date and time created 83/02/11 15:44:43 by rrh
[unix-history] / usr / src / usr.bin / pascal / px / interp.c
diff --git a/usr/src/usr.bin/pascal/px/interp.c b/usr/src/usr.bin/pascal/px/interp.c
index 29b3a99..43877ab 100644 (file)
--- a/usr/src/usr.bin/pascal/px/interp.c
+++ b/usr/src/usr.bin/pascal/px/interp.c
@@ -1,12 +1,12 @@
 /* Copyright (c) 1979 Regents of the University of California */
 
 /* Copyright (c) 1979 Regents of the University of California */
 
-static char sccsid[] = "@(#)interp.c 1.16 %G%";
+static char sccsid[] = "@(#)interp.c 1.30 %G%";
 
 #include <math.h>
 
 #include <math.h>
+#include <signal.h>
 #include "whoami.h"
 #include "whoami.h"
-#include "objfmt.h"
 #include "vars.h"
 #include "vars.h"
-#include "panics.h"
+#include "objfmt.h"
 #include "h02opcs.h"
 #include "machdep.h"
 #include "libpc.h"
 #include "h02opcs.h"
 #include "machdep.h"
 #include "libpc.h"
@@ -14,22 +14,23 @@ static char sccsid[] = "@(#)interp.c 1.16 %G%";
 /*
  * program variables
  */
 /*
  * program variables
  */
-union disply   _display;
-struct disp    *_dp;
+union display _display;
+struct dispsave        *_dp;
 long   _lino = 0;
 int    _argc;
 char   **_argv;
 long   _mode;
 long   _lino = 0;
 int    _argc;
 char   **_argv;
 long   _mode;
-bool   _runtst = TRUE;
+long   _runtst = (long)TRUE;
 bool   _nodump = FALSE;
 long   _stlim = 500000;
 long   _stcnt = 0;
 long   _seed = 1;
 bool   _nodump = FALSE;
 long   _stlim = 500000;
 long   _stcnt = 0;
 long   _seed = 1;
-#ifdef VAX
+#ifdef ADDR32
 char   *_minptr = (char *)0x7fffffff;
 char   *_minptr = (char *)0x7fffffff;
-#else
+#endif ADDR32
+#ifdef ADDR16
 char   *_minptr = (char *)0xffff;
 char   *_minptr = (char *)0xffff;
-#endif VAX
+#endif ADDR16
 char   *_maxptr = (char *)0;
 long   *_pcpcount = (long *)0;
 long   _cntrs = 0;
 char   *_maxptr = (char *)0;
 long   *_pcpcount = (long *)0;
 long   _cntrs = 0;
@@ -71,7 +72,7 @@ struct iorechd        input = {
        OUTPUT,                 /* fchain  */
        STDLVL,                 /* flev    */
        "standard input",       /* pfname  */
        OUTPUT,                 /* fchain  */
        STDLVL,                 /* flev    */
        "standard input",       /* pfname  */
-       FTEXT | FREAD | SYNC,   /* funit   */
+       FTEXT|FREAD|SYNC|EOLN,  /* funit   */
        0,                      /* fblk    */
        1                       /* fsize   */
 };
        0,                      /* fblk    */
        1                       /* fsize   */
 };
@@ -90,6 +91,13 @@ struct iorec *_actfile[MAXFILES] = {
        ERR
 };
 
        ERR
 };
 
+/*
+ * stuff for pdx
+ */
+
+union progcntr *pcaddrp;
+asm(".globl _loopaddr");
+
 /*
  * Px profile array
  */
 /*
  * Px profile array
  */
@@ -111,22 +119,27 @@ interpreter(base)
        union progcntr pc;              /* interpreted program cntr */
        register char *vpc;             /* register used for "pc" */
        struct iorec *curfile;          /* active file */
        union progcntr pc;              /* interpreted program cntr */
        register char *vpc;             /* register used for "pc" */
        struct iorec *curfile;          /* active file */
-       register struct stack *stp;     /* active stack frame ptr */
+       register struct blockmark *stp; /* active stack frame ptr */
        /*
         * the following variables are used as scratch
         */
        register char *tcp;
        /*
         * the following variables are used as scratch
         */
        register char *tcp;
+       register short *tsp;
        register long tl, tl1, tl2;
        double td, td1;
        struct sze8 t8;
        register long tl, tl1, tl2;
        double td, td1;
        struct sze8 t8;
+       register short *tsp1;
        long *tlp;
        long *tlp;
-       register short *tsp, *tsp1, ts;
-       bool tb;
        char *tcp1;
        char *tcp1;
-       struct stack *tstp;
-       struct formalrtn *tfp;
+       bool tb;
+       struct blockmark *tstp;
+       register struct formalrtn *tfp;
        union progcntr tpc;
        struct iorec **ip;
        union progcntr tpc;
        struct iorec **ip;
+       int mypid;
+
+       pcaddrp = &pc;
+       mypid = getpid();
 
        /*
         * Setup sets up any hardware specific parameters before
 
        /*
         * Setup sets up any hardware specific parameters before
@@ -147,9 +160,11 @@ interpreter(base)
        _display.frame[0].locvars += 2 * sizeof(struct iorec *);
        *(struct iorec **)(_display.frame[0].locvars + OUTPUT_OFF) = OUTPUT;
        *(struct iorec **)(_display.frame[0].locvars + INPUT_OFF) = INPUT;
        _display.frame[0].locvars += 2 * sizeof(struct iorec *);
        *(struct iorec **)(_display.frame[0].locvars + OUTPUT_OFF) = OUTPUT;
        *(struct iorec **)(_display.frame[0].locvars + INPUT_OFF) = INPUT;
-       stp = (struct stack *)pushsp((long)(sizeof(struct stack)));
+       stp = (struct blockmark *)pushsp((long)(sizeof(struct blockmark)));
        _dp = &_display.frame[0];
        pc.cp = base;
        _dp = &_display.frame[0];
        pc.cp = base;
+
+       asm("_loopaddr:");
        for(;;) {
 #              ifdef DEBUG
                if (++opcptr == 10)
        for(;;) {
 #              ifdef DEBUG
                if (++opcptr == 10)
@@ -160,6 +175,11 @@ interpreter(base)
                _profcnts[*pc.ucp]++;
 #              endif PROFILE
                switch (*pc.ucp++) {
                _profcnts[*pc.ucp]++;
 #              endif PROFILE
                switch (*pc.ucp++) {
+               case O_BPT:                     /* breakpoint trap */
+                       PFLUSH();
+                       kill(mypid, SIGILL);
+                       pc.ucp--;
+                       continue;
                case O_NODUMP:
                        _nodump = TRUE;
                        /* and fall through */
                case O_NODUMP:
                        _nodump = TRUE;
                        /* and fall through */
@@ -178,7 +198,7 @@ interpreter(base)
                        stp->file = curfile;    /* save active file */
                        tcp = pushsp(tl1);      /* tcp = new top of stack */
                        if (_runtst)            /* zero stack frame */
                        stp->file = curfile;    /* save active file */
                        tcp = pushsp(tl1);      /* tcp = new top of stack */
                        if (_runtst)            /* zero stack frame */
-                               blkclr(tl1, tcp);
+                               blkclr(tcp, tl1);
                        tcp += (int)tl1;        /* offsets of locals are neg */
                        _dp->locvars = tcp;     /* set new display pointer */
                        _dp->stp = stp;
                        tcp += (int)tl1;        /* offsets of locals are neg */
                        _dp->locvars = tcp;     /* set new display pointer */
                        _dp->stp = stp;
@@ -192,25 +212,25 @@ interpreter(base)
                        if (_dp == &_display.frame[1])
                                return;         /* exiting main proc ??? */
                        _lino = stp->lino;      /* restore lino, pc, dp */
                        if (_dp == &_display.frame[1])
                                return;         /* exiting main proc ??? */
                        _lino = stp->lino;      /* restore lino, pc, dp */
-                       pc.cp = stp->pc.cp;
+                       pc.cp = stp->pc;
                        _dp = stp->dp;
                        _runtst = stp->entry->tests;
                        disableovrflo();
                        if (_runtst)
                                enableovrflo();
                        popsp(stp->entry->framesze +    /* pop local vars */
                        _dp = stp->dp;
                        _runtst = stp->entry->tests;
                        disableovrflo();
                        if (_runtst)
                                enableovrflo();
                        popsp(stp->entry->framesze +    /* pop local vars */
-                             sizeof(struct stack) +    /* pop stack frame */
-                             stp->entry->nargs);       /* pop parms */
+                            sizeof(struct blockmark) + /* pop stack frame */
+                            stp->entry->nargs);        /* pop parms */
                        continue;
                case O_CALL:
                        tl = *pc.cp++;
                        tcp = base + *pc.lp++;/* calc new entry point */
                        tcp += sizeof(short);
                        tcp = base + *(long *)tcp;
                        continue;
                case O_CALL:
                        tl = *pc.cp++;
                        tcp = base + *pc.lp++;/* calc new entry point */
                        tcp += sizeof(short);
                        tcp = base + *(long *)tcp;
-                       stp = (struct stack *)
-                               pushsp((long)(sizeof(struct stack)));
+                       stp = (struct blockmark *)
+                               pushsp((long)(sizeof(struct blockmark)));
                        stp->lino = _lino;      /* save lino, pc, dp */
                        stp->lino = _lino;      /* save lino, pc, dp */
-                       stp->pc.cp = pc.cp;
+                       stp->pc = pc.cp;
                        stp->dp = _dp;
                        _dp = &_display.frame[tl]; /* set up new display ptr */
                        pc.cp = tcp;
                        stp->dp = _dp;
                        _dp = &_display.frame[tl]; /* set up new display ptr */
                        pc.cp = tcp;
@@ -219,17 +239,17 @@ interpreter(base)
                        pc.cp++;
                        tcp = popaddr(); /* ptr to display save area */
                        tfp = (struct formalrtn *)popaddr();
                        pc.cp++;
                        tcp = popaddr(); /* ptr to display save area */
                        tfp = (struct formalrtn *)popaddr();
-                       stp = (struct stack *)
-                               pushsp((long)(sizeof(struct stack)));
+                       stp = (struct blockmark *)
+                               pushsp((long)(sizeof(struct blockmark)));
                        stp->lino = _lino;      /* save lino, pc, dp */
                        stp->lino = _lino;      /* save lino, pc, dp */
-                       stp->pc.cp = pc.cp;
+                       stp->pc = pc.cp;
                        stp->dp = _dp;
                        stp->dp = _dp;
-                       pc.cp = tfp->fentryaddr;/* calc new entry point */
+                       pc.cp = (char *)(tfp->fentryaddr);/* new entry point */
                        _dp = &_display.frame[tfp->fbn];/* new display ptr */
                        _dp = &_display.frame[tfp->fbn];/* new display ptr */
-                       blkcpy(tfp->fbn * sizeof(struct disp),
-                               &_display.frame[1], tcp);
-                       blkcpy(tfp->fbn * sizeof(struct disp),
-                               &tfp->fdisp[0], &_display.frame[1]);
+                       blkcpy(&_display.frame[1], tcp,
+                               tfp->fbn * sizeof(struct dispsave));
+                       blkcpy(&tfp->fdisp[0], &_display.frame[1],
+                               tfp->fbn * sizeof(struct dispsave));
                        continue;
                case O_FRTN:
                        tl = *pc.cp++;          /* tl = size of return obj */
                        continue;
                case O_FRTN:
                        tl = *pc.cp++;          /* tl = size of return obj */
@@ -240,22 +260,22 @@ interpreter(base)
                        tcp1 = *(char **)
                            (tcp + tl + sizeof(struct formalrtn *));
                        if (tl != 0) {
                        tcp1 = *(char **)
                            (tcp + tl + sizeof(struct formalrtn *));
                        if (tl != 0) {
-                               blkcpy(tl, tcp, tcp + sizeof(struct formalrtn *)
-                                   + sizeof(char *));
+                               blkcpy(tcp, tcp + sizeof(struct formalrtn *)
+                                   + sizeof(char *), tl);
                        }
                        popsp((long)
                            (sizeof(struct formalrtn *) + sizeof (char *)));
                        }
                        popsp((long)
                            (sizeof(struct formalrtn *) + sizeof (char *)));
-                       blkcpy(tfp->fbn * sizeof(struct disp),
-                           tcp1, &_display.frame[1]);
+                       blkcpy(tcp1, &_display.frame[1],
+                           tfp->fbn * sizeof(struct dispsave));
                        continue;
                case O_FSAV:
                        tfp = (struct formalrtn *)popaddr();
                        tfp->fbn = *pc.cp++;    /* blk number of routine */
                        tcp = base + *pc.lp++;  /* calc new entry point */
                        tcp += sizeof(short);
                        continue;
                case O_FSAV:
                        tfp = (struct formalrtn *)popaddr();
                        tfp->fbn = *pc.cp++;    /* blk number of routine */
                        tcp = base + *pc.lp++;  /* calc new entry point */
                        tcp += sizeof(short);
-                       tfp->fentryaddr = base + *(long *)tcp;
-                       blkcpy(tfp->fbn * sizeof(struct disp),
-                               &_display.frame[1], &tfp->fdisp[0]);
+                       tfp->fentryaddr = (long (*)())(base + *(long *)tcp);
+                       blkcpy(&_display.frame[1], &tfp->fdisp[0],
+                               tfp->fbn * sizeof(struct dispsave));
                        pushaddr(tfp);
                        continue;
                case O_SDUP2:
                        pushaddr(tfp);
                        continue;
                case O_SDUP2:
@@ -297,7 +317,7 @@ interpreter(base)
                        continue;
                case O_LINO:
                        if (_dp->stp->tos != pushsp((long)(0)))
                        continue;
                case O_LINO:
                        if (_dp->stp->tos != pushsp((long)(0)))
-                               panic(PSTKNEMP);
+                               ERROR("Panic: stack not empty between statements\n");
                        _lino = *pc.cp++;       /* set line number */
                        if (_lino == 0)
                                _lino = *pc.sp++;
                        _lino = *pc.cp++;       /* set line number */
                        if (_lino == 0)
                                _lino = *pc.sp++;
@@ -310,11 +330,11 @@ interpreter(base)
                case O_PUSH:
                        tl = *pc.cp++;
                        if (tl == 0)
                case O_PUSH:
                        tl = *pc.cp++;
                        if (tl == 0)
-                               tl = *pc.usp++;
+                               tl = *pc.lp++;
                        tl = (-tl + 1) & ~1;
                        tcp = pushsp(tl);
                        if (_runtst)
                        tl = (-tl + 1) & ~1;
                        tcp = pushsp(tl);
                        if (_runtst)
-                               blkclr(tl, tcp);
+                               blkclr(tcp, tl);
                        continue;
                case O_IF:
                        pc.cp++;
                        continue;
                case O_IF:
                        pc.cp++;
@@ -340,8 +360,7 @@ interpreter(base)
                        tl = pop4();
                        tl1 = pop4();
                cmplong:
                        tl = pop4();
                        tl1 = pop4();
                cmplong:
-                       tl2 = *pc.cp++;
-                       switch (tl2) {
+                       switch (*pc.cp++) {
                        case releq:
                                push2(tl1 == tl);
                                continue;
                        case releq:
                                push2(tl1 == tl);
                                continue;
@@ -361,7 +380,8 @@ interpreter(base)
                                push2(tl1 >= tl);
                                continue;
                        default:
                                push2(tl1 >= tl);
                                continue;
                        default:
-                               panic(PSYSTEM);
+                               ERROR("Panic: bad relation %d to REL4*\n",
+                                   *(pc.cp - 1));
                                continue;
                        }
                case O_RELG:
                                continue;
                        }
                case O_RELG:
@@ -389,7 +409,7 @@ interpreter(base)
                                tb = RELSGE(tl, tcp + tl1, tcp);
                                break;
                        default:
                                tb = RELSGE(tl, tcp + tl1, tcp);
                                break;
                        default:
-                               panic(PSYSTEM);
+                               ERROR("Panic: bad relation %d to RELG*\n", tl2);
                                break;
                        }
                        popsp(tl1 << 1);
                                break;
                        }
                        popsp(tl1 << 1);
@@ -419,7 +439,7 @@ interpreter(base)
                                tb = RELTGE(tl1, tcp + tl1, tcp);
                                break;
                        default:
                                tb = RELTGE(tl1, tcp + tl1, tcp);
                                break;
                        default:
-                               panic(PSYSTEM);
+                               ERROR("Panic: bad relation %d to RELT*\n", tl2);
                                break;
                        }
                        popsp(tl1 << 1);
                                break;
                        }
                        popsp(tl1 << 1);
@@ -465,20 +485,26 @@ interpreter(base)
                                push2(td1 >= td);
                                continue;
                        default:
                                push2(td1 >= td);
                                continue;
                        default:
-                               panic(PSYSTEM);
+                               ERROR("Panic: bad relation %d to REL8*\n",
+                                   *(pc.cp - 1));
                                continue;
                        }
                case O_AND:
                        pc.cp++;
                                continue;
                        }
                case O_AND:
                        pc.cp++;
-                       push2(pop2() & pop2());
+                       tl = pop2();
+                       tl1 = pop2();
+                       push2(tl1 & tl);
                        continue;
                case O_OR:
                        pc.cp++;
                        continue;
                case O_OR:
                        pc.cp++;
-                       push2(pop2() | pop2());
+                       tl = pop2();
+                       tl1 = pop2();
+                       push2(tl1 | tl);
                        continue;
                case O_NOT:
                        pc.cp++;
                        continue;
                case O_NOT:
                        pc.cp++;
-                       push2(pop2() ^ 1);
+                       tl = pop2();
+                       push2(tl ^ 1);
                        continue;
                case O_AS2:
                        pc.cp++;
                        continue;
                case O_AS2:
                        pc.cp++;
@@ -531,18 +557,22 @@ interpreter(base)
                                tl = *pc.usp++;
                        tl1 = (tl + 1) & ~1;
                        tcp = pushsp((long)(0));
                                tl = *pc.usp++;
                        tl1 = (tl + 1) & ~1;
                        tcp = pushsp((long)(0));
-                       blkcpy(tl, tcp, *(char **)(tcp + tl1));
+                       blkcpy(tcp, *(char **)(tcp + tl1), tl);
                        popsp(tl1 + sizeof(char *));
                        continue;
                case O_INX2P2:
                        tl = *pc.cp++;          /* tl has shift amount */
                        popsp(tl1 + sizeof(char *));
                        continue;
                case O_INX2P2:
                        tl = *pc.cp++;          /* tl has shift amount */
-                       tl1 = (pop2() - *pc.sp++) << tl;
-                       pushaddr(popaddr() + tl1);
+                       tl1 = pop2();
+                       tl1 = (tl1 - *pc.sp++) << tl;
+                       tcp = popaddr();
+                       pushaddr(tcp + tl1);
                        continue;
                case O_INX4P2:
                        tl = *pc.cp++;          /* tl has shift amount */
                        continue;
                case O_INX4P2:
                        tl = *pc.cp++;          /* tl has shift amount */
-                       tl1 = (pop4() - *pc.sp++) << tl;
-                       pushaddr(popaddr() + tl1);
+                       tl1 = pop4();
+                       tl1 = (tl1 - *pc.sp++) << tl;
+                       tcp = popaddr();
+                       pushaddr(tcp + tl1);
                        continue;
                case O_INX2:
                        tl = *pc.cp++;          /* tl has element size */
                        continue;
                case O_INX2:
                        tl = *pc.cp++;          /* tl has element size */
@@ -550,7 +580,8 @@ interpreter(base)
                                tl = *pc.usp++;
                        tl1 = pop2();           /* index */
                        tl2 = *pc.sp++;
                                tl = *pc.usp++;
                        tl1 = pop2();           /* index */
                        tl2 = *pc.sp++;
-                       pushaddr(popaddr() + (tl1 - tl2) * tl);
+                       tcp = popaddr();
+                       pushaddr(tcp + (tl1 - tl2) * tl);
                        tl = *pc.usp++;
                        if (_runtst)
                                SUBSC(tl1, tl2, tl); /* range check */
                        tl = *pc.usp++;
                        if (_runtst)
                                SUBSC(tl1, tl2, tl); /* range check */
@@ -561,7 +592,8 @@ interpreter(base)
                                tl = *pc.usp++;
                        tl1 = pop4();           /* index */
                        tl2 = *pc.sp++;
                                tl = *pc.usp++;
                        tl1 = pop4();           /* index */
                        tl2 = *pc.sp++;
-                       pushaddr(popaddr() + (tl1 - tl2) * tl);
+                       tcp = popaddr();
+                       pushaddr(tcp + (tl1 - tl2) * tl);
                        tl = *pc.usp++;
                        if (_runtst)
                                SUBSC(tl1, tl2, tl); /* range check */
                        tl = *pc.usp++;
                        if (_runtst)
                                SUBSC(tl1, tl2, tl); /* range check */
@@ -570,7 +602,8 @@ interpreter(base)
                        tl = *pc.cp++;
                        if (tl == 0)
                                tl = *pc.usp++;
                        tl = *pc.cp++;
                        if (tl == 0)
                                tl = *pc.usp++;
-                       pushaddr(popaddr() + tl);
+                       tcp = popaddr();
+                       pushaddr(tcp + tl);
                        continue;
                case O_NIL:
                        pc.cp++;
                        continue;
                case O_NIL:
                        pc.cp++;
@@ -578,119 +611,147 @@ interpreter(base)
                        continue;
                case O_ADD2:
                        pc.cp++;
                        continue;
                case O_ADD2:
                        pc.cp++;
-                       push4((long)(pop2() + pop2()));
+                       tl = pop2();
+                       tl1 = pop2();
+                       push4(tl1 + tl);
                        continue;
                case O_ADD4:
                        pc.cp++;
                        continue;
                case O_ADD4:
                        pc.cp++;
-                       push4(pop4() + pop4());
+                       tl = pop4();
+                       tl1 = pop4();
+                       push4(tl1 + tl);
                        continue;
                case O_ADD24:
                        pc.cp++;
                        tl = pop2();
                        continue;
                case O_ADD24:
                        pc.cp++;
                        tl = pop2();
-                       push4(pop4() + tl);
+                       tl1 = pop4();
+                       push4(tl1 + tl);
                        continue;
                case O_ADD42:
                        pc.cp++;
                        tl = pop4();
                        continue;
                case O_ADD42:
                        pc.cp++;
                        tl = pop4();
-                       push4(pop2() + tl);
+                       tl1 = pop2();
+                       push4(tl1 + tl);
                        continue;
                case O_ADD28:
                        pc.cp++;
                        tl = pop2();
                        continue;
                case O_ADD28:
                        pc.cp++;
                        tl = pop2();
-                       push8(pop8() + tl);
+                       td = pop8();
+                       push8(td + tl);
                        continue;
                case O_ADD48:
                        pc.cp++;
                        tl = pop4();
                        continue;
                case O_ADD48:
                        pc.cp++;
                        tl = pop4();
-                       push8(pop8() + tl);
+                       td = pop8();
+                       push8(td + tl);
                        continue;
                case O_ADD82:
                        pc.cp++;
                        td = pop8();
                        continue;
                case O_ADD82:
                        pc.cp++;
                        td = pop8();
-                       push8(pop2() + td);
+                       td1 = pop2();
+                       push8(td1 + td);
                        continue;
                case O_ADD84:
                        pc.cp++;
                        td = pop8();
                        continue;
                case O_ADD84:
                        pc.cp++;
                        td = pop8();
-                       push8(pop4() + td);
+                       td1 = pop4();
+                       push8(td1 + td);
                        continue;
                case O_SUB2:
                        pc.cp++;
                        tl = pop2();
                        continue;
                case O_SUB2:
                        pc.cp++;
                        tl = pop2();
-                       push4(pop2() - tl);
+                       tl1 = pop2();
+                       push4(tl1 - tl);
                        continue;
                case O_SUB4:
                        pc.cp++;
                        tl = pop4();
                        continue;
                case O_SUB4:
                        pc.cp++;
                        tl = pop4();
-                       push4(pop4() - tl);
+                       tl1 = pop4();
+                       push4(tl1 - tl);
                        continue;
                case O_SUB24:
                        pc.cp++;
                        tl = pop2();
                        continue;
                case O_SUB24:
                        pc.cp++;
                        tl = pop2();
-                       push4(pop4() - tl);
+                       tl1 = pop4();
+                       push4(tl1 - tl);
                        continue;
                case O_SUB42:
                        pc.cp++;
                        tl = pop4();
                        continue;
                case O_SUB42:
                        pc.cp++;
                        tl = pop4();
-                       push4(pop2() - tl);
+                       tl1 = pop2();
+                       push4(tl1 - tl);
                        continue;
                case O_SUB28:
                        pc.cp++;
                        tl = pop2();
                        continue;
                case O_SUB28:
                        pc.cp++;
                        tl = pop2();
-                       push8(pop8() - tl);
+                       td = pop8();
+                       push8(td - tl);
                        continue;
                case O_SUB48:
                        pc.cp++;
                        tl = pop4();
                        continue;
                case O_SUB48:
                        pc.cp++;
                        tl = pop4();
-                       push8(pop8() - tl);
+                       td = pop8();
+                       push8(td - tl);
                        continue;
                case O_SUB82:
                        pc.cp++;
                        td = pop8();
                        continue;
                case O_SUB82:
                        pc.cp++;
                        td = pop8();
-                       push8(pop2() - td);
+                       td1 = pop2();
+                       push8(td1 - td);
                        continue;
                case O_SUB84:
                        pc.cp++;
                        td = pop8();
                        continue;
                case O_SUB84:
                        pc.cp++;
                        td = pop8();
-                       push8(pop4() - td);
+                       td1 = pop4();
+                       push8(td1 - td);
                        continue;
                case O_MUL2:
                        pc.cp++;
                        continue;
                case O_MUL2:
                        pc.cp++;
-                       push4((long)(pop2() * pop2()));
+                       tl = pop2();
+                       tl1 = pop2();
+                       push4(tl1 * tl);
                        continue;
                case O_MUL4:
                        pc.cp++;
                        continue;
                case O_MUL4:
                        pc.cp++;
-                       push4(pop4() * pop4());
+                       tl = pop4();
+                       tl1 = pop4();
+                       push4(tl1 * tl);
                        continue;
                case O_MUL24:
                        pc.cp++;
                        tl = pop2();
                        continue;
                case O_MUL24:
                        pc.cp++;
                        tl = pop2();
-                       push4(pop4() * tl);
+                       tl1 = pop4();
+                       push4(tl1 * tl);
                        continue;
                case O_MUL42:
                        pc.cp++;
                        tl = pop4();
                        continue;
                case O_MUL42:
                        pc.cp++;
                        tl = pop4();
-                       push4(pop2() * tl);
+                       tl1 = pop2();
+                       push4(tl1 * tl);
                        continue;
                case O_MUL28:
                        pc.cp++;
                        tl = pop2();
                        continue;
                case O_MUL28:
                        pc.cp++;
                        tl = pop2();
-                       push8(pop8() * tl);
+                       td = pop8();
+                       push8(td * tl);
                        continue;
                case O_MUL48:
                        pc.cp++;
                        tl = pop4();
                        continue;
                case O_MUL48:
                        pc.cp++;
                        tl = pop4();
-                       push8(pop8() * tl);
+                       td = pop8();
+                       push8(td * tl);
                        continue;
                case O_MUL82:
                        pc.cp++;
                        td = pop8();
                        continue;
                case O_MUL82:
                        pc.cp++;
                        td = pop8();
-                       push8(pop2() * td);
+                       td1 = pop2();
+                       push8(td1 * td);
                        continue;
                case O_MUL84:
                        pc.cp++;
                        td = pop8();
                        continue;
                case O_MUL84:
                        pc.cp++;
                        td = pop8();
-                       push8(pop4() * td);
+                       td1 = pop4();
+                       push8(td1 * td);
                        continue;
                case O_ABS2:
                case O_ABS4:
                        continue;
                case O_ABS2:
                case O_ABS4:
@@ -718,60 +779,74 @@ interpreter(base)
                case O_DIV2:
                        pc.cp++;
                        tl = pop2();
                case O_DIV2:
                        pc.cp++;
                        tl = pop2();
-                       push4(pop2() / tl);
+                       tl1 = pop2();
+                       push4(tl1 / tl);
                        continue;
                case O_DIV4:
                        pc.cp++;
                        tl = pop4();
                        continue;
                case O_DIV4:
                        pc.cp++;
                        tl = pop4();
-                       push4(pop4() / tl);
+                       tl1 = pop4();
+                       push4(tl1 / tl);
                        continue;
                case O_DIV24:
                        pc.cp++;
                        tl = pop2();
                        continue;
                case O_DIV24:
                        pc.cp++;
                        tl = pop2();
-                       push4(pop4() / tl);
+                       tl1 = pop4();
+                       push4(tl1 / tl);
                        continue;
                case O_DIV42:
                        pc.cp++;
                        tl = pop4();
                        continue;
                case O_DIV42:
                        pc.cp++;
                        tl = pop4();
-                       push4(pop2() / tl);
+                       tl1 = pop2();
+                       push4(tl1 / tl);
                        continue;
                case O_MOD2:
                        pc.cp++;
                        tl = pop2();
                        continue;
                case O_MOD2:
                        pc.cp++;
                        tl = pop2();
-                       push4(pop2() % tl);
+                       tl1 = pop2();
+                       push4(tl1 % tl);
                        continue;
                case O_MOD4:
                        pc.cp++;
                        tl = pop4();
                        continue;
                case O_MOD4:
                        pc.cp++;
                        tl = pop4();
-                       push4(pop4() % tl);
+                       tl1 = pop4();
+                       push4(tl1 % tl);
                        continue;
                case O_MOD24:
                        pc.cp++;
                        tl = pop2();
                        continue;
                case O_MOD24:
                        pc.cp++;
                        tl = pop2();
-                       push4(pop4() % tl);
+                       tl1 = pop4();
+                       push4(tl1 % tl);
                        continue;
                case O_MOD42:
                        pc.cp++;
                        tl = pop4();
                        continue;
                case O_MOD42:
                        pc.cp++;
                        tl = pop4();
-                       push4(pop2() % tl);
+                       tl1 = pop2();
+                       push4(tl1 % tl);
                        continue;
                case O_ADD8:
                        pc.cp++;
                        continue;
                case O_ADD8:
                        pc.cp++;
-                       push8(pop8() + pop8());
+                       td = pop8();
+                       td1 = pop8();
+                       push8(td1 + td);
                        continue;
                case O_SUB8:
                        pc.cp++;
                        td = pop8();
                        continue;
                case O_SUB8:
                        pc.cp++;
                        td = pop8();
-                       push8(pop8() - td);
+                       td1 = pop8();
+                       push8(td1 - td);
                        continue;
                case O_MUL8:
                        pc.cp++;
                        continue;
                case O_MUL8:
                        pc.cp++;
-                       push8(pop8() * pop8());
+                       td = pop8();
+                       td1 = pop8();
+                       push8(td1 * td);
                        continue;
                case O_DVD8:
                        pc.cp++;
                        td = pop8();
                        continue;
                case O_DVD8:
                        pc.cp++;
                        td = pop8();
-                       push8(pop8() / td);
+                       td1 = pop8();
+                       push8(td1 / td);
                        continue;
                case O_STOI:
                        pc.cp++;
                        continue;
                case O_STOI:
                        pc.cp++;
@@ -794,42 +869,50 @@ interpreter(base)
                case O_DVD2:
                        pc.cp++;
                        td = pop2();
                case O_DVD2:
                        pc.cp++;
                        td = pop2();
-                       push8(pop2() / td);
+                       td1 = pop2();
+                       push8(td1 / td);
                        continue;
                case O_DVD4:
                        pc.cp++;
                        td = pop4();
                        continue;
                case O_DVD4:
                        pc.cp++;
                        td = pop4();
-                       push8(pop4() / td);
+                       td1 = pop4();
+                       push8(td1 / td);
                        continue;
                case O_DVD24:
                        pc.cp++;
                        td = pop2();
                        continue;
                case O_DVD24:
                        pc.cp++;
                        td = pop2();
-                       push8(pop4() / td);
+                       td1 = pop4();
+                       push8(td1 / td);
                        continue;
                case O_DVD42:
                        pc.cp++;
                        td = pop4();
                        continue;
                case O_DVD42:
                        pc.cp++;
                        td = pop4();
-                       push8(pop2() / td);
+                       td1 = pop2();
+                       push8(td1 / td);
                        continue;
                case O_DVD28:
                        pc.cp++;
                        td = pop2();
                        continue;
                case O_DVD28:
                        pc.cp++;
                        td = pop2();
-                       push8(pop8() / td);
+                       td1 = pop8();
+                       push8(td1 / td);
                        continue;
                case O_DVD48:
                        pc.cp++;
                        td = pop4();
                        continue;
                case O_DVD48:
                        pc.cp++;
                        td = pop4();
-                       push8(pop8() / td);
+                       td1 = pop8();
+                       push8(td1 / td);
                        continue;
                case O_DVD82:
                        pc.cp++;
                        td = pop8();
                        continue;
                case O_DVD82:
                        pc.cp++;
                        td = pop8();
-                       push8(pop2() / td);
+                       td1 = pop2();
+                       push8(td1 / td);
                        continue;
                case O_DVD84:
                        pc.cp++;
                        td = pop8();
                        continue;
                case O_DVD84:
                        pc.cp++;
                        td = pop8();
-                       push8(pop4() / td);
+                       td1 = pop4();
+                       push8(td1 / td);
                        continue;
                case O_RV1:
                        tcp = _display.raw[*pc.ucp++];
                        continue;
                case O_RV1:
                        tcp = _display.raw[*pc.ucp++];
@@ -860,7 +943,7 @@ interpreter(base)
                        tcp += *pc.sp++;
                        tl = *pc.usp++;
                        tcp1 = pushsp((tl + 1) & ~1);
                        tcp += *pc.sp++;
                        tl = *pc.usp++;
                        tcp1 = pushsp((tl + 1) & ~1);
-                       blkcpy(tl, tcp, tcp1);
+                       blkcpy(tcp, tcp1, tl);
                        continue;
                case O_LV:
                        tcp = _display.raw[*pc.ucp++];
                        continue;
                case O_LV:
                        tcp = _display.raw[*pc.ucp++];
@@ -895,7 +978,7 @@ interpreter(base)
                        tcp += (int)*pc.lp++;
                        tl = *pc.usp++;
                        tcp1 = pushsp((tl + 1) & ~1);
                        tcp += (int)*pc.lp++;
                        tl = *pc.usp++;
                        tcp1 = pushsp((tl + 1) & ~1);
-                       blkcpy(tl, tcp, tcp1);
+                       blkcpy(tcp, tcp1, tl);
                        continue;
                case O_LLV:
                        tcp = _display.raw[*pc.ucp++];
                        continue;
                case O_LLV:
                        tcp = _display.raw[*pc.ucp++];
@@ -931,7 +1014,7 @@ interpreter(base)
                                tl = *pc.usp++;
                        tcp = popaddr();
                        tcp1 = pushsp((tl + 1) & ~1);
                                tl = *pc.usp++;
                        tcp = popaddr();
                        tcp1 = pushsp((tl + 1) & ~1);
-                       blkcpy(tl, tcp, tcp1);
+                       blkcpy(tcp, tcp1, tl);
                        continue;
                case O_CON1:
                        push2((short)(*pc.cp++));
                        continue;
                case O_CON1:
                        push2((short)(*pc.cp++));
@@ -961,7 +1044,7 @@ interpreter(base)
                                tl = *pc.usp++;
                        tl = (tl + 1) & ~1;
                        tcp = pushsp(tl);
                                tl = *pc.usp++;
                        tl = (tl + 1) & ~1;
                        tcp = pushsp(tl);
-                       blkcpy(tl, pc.cp, tcp);
+                       blkcpy(pc.cp, tcp, tl);
                        pc.cp += (int)tl;
                        continue;
                case O_CONG:
                        pc.cp += (int)tl;
                        continue;
                case O_CONG:
@@ -970,7 +1053,7 @@ interpreter(base)
                                tl = *pc.usp++;
                        tl1 = (tl + 1) & ~1;
                        tcp = pushsp(tl1);
                                tl = *pc.usp++;
                        tl1 = (tl + 1) & ~1;
                        tcp = pushsp(tl1);
-                       blkcpy(tl1, pc.cp, tcp);
+                       blkcpy(pc.cp, tcp, tl1);
                        pc.cp += (int)((tl + 2) & ~1);
                        continue;
                case O_LVCON:
                        pc.cp += (int)((tl + 2) & ~1);
                        continue;
                case O_LVCON:
@@ -1052,13 +1135,18 @@ interpreter(base)
                        continue;
                case O_HALT:
                        pc.cp++;
                        continue;
                case O_HALT:
                        pc.cp++;
-                       panic(PHALT);
+                       if (_nodump == TRUE)
+                               psexit(0);
+                       fputs("\nCall to procedure halt\n", stderr);
+                       backtrace("Halted");
+                       psexit(0);
                        continue;
                case O_PXPBUF:
                        pc.cp++;
                        _cntrs = *pc.lp++;
                        _rtns = *pc.lp++;
                        continue;
                case O_PXPBUF:
                        pc.cp++;
                        _cntrs = *pc.lp++;
                        _rtns = *pc.lp++;
-                       NEWZ(&_pcpcount, (_cntrs + 1) * sizeof(long));
+                       NEW(&_pcpcount, (_cntrs + 1) * sizeof(long));
+                       blkclr(_pcpcount, (_cntrs + 1) * sizeof(long));
                        continue;
                case O_COUNT:
                        pc.cp++;
                        continue;
                case O_COUNT:
                        pc.cp++;
@@ -1075,7 +1163,7 @@ interpreter(base)
                                if (tl1 == *tcp++)
                                        break;
                        if (tl == 0)            /* default case => error */
                                if (tl1 == *tcp++)
                                        break;
                        if (tl == 0)            /* default case => error */
-                               ERROR("Label of %D not found in case\n", tl1);
+                               CASERNG(tl1);
                        pc.cp += *(tsp - tl);
                        continue;
                case O_CASE2OP:
                        pc.cp += *(tsp - tl);
                        continue;
                case O_CASE2OP:
@@ -1089,7 +1177,7 @@ interpreter(base)
                                if (tl1 == *tsp1++)
                                        break;
                        if (tl == 0)            /* default case => error */
                                if (tl1 == *tsp1++)
                                        break;
                        if (tl == 0)            /* default case => error */
-                               ERROR("Label of %D not found in case\n", tl1);
+                               CASERNG(tl1);
                        pc.cp += *(tsp - tl);
                        continue;
                case O_CASE4OP:
                        pc.cp += *(tsp - tl);
                        continue;
                case O_CASE4OP:
@@ -1103,7 +1191,7 @@ interpreter(base)
                                if (tl1 == *tlp++)
                                        break;
                        if (tl == 0)            /* default case => error */
                                if (tl1 == *tlp++)
                                        break;
                        if (tl == 0)            /* default case => error */
-                               ERROR("Label of %D not found in case\n", tl1);
+                               CASERNG(tl1);
                        pc.cp += *(tsp - tl);
                        continue;
                case O_ADDT:
                        pc.cp += *(tsp - tl);
                        continue;
                case O_ADDT:
@@ -1169,86 +1257,74 @@ interpreter(base)
                        continue;
                case O_ASRT:
                        pc.cp++;
                        continue;
                case O_ASRT:
                        pc.cp++;
-                       ts = pop2();
-                       ASRT(ts, "");
+                       ASRTS();
+                       popsp((long)(sizeof(long)+sizeof(char *)));
                        continue;
                case O_FOR1U:
                        continue;
                case O_FOR1U:
-                       /*
-                        * with the shadowing of for loop variables
-                        * the variable is always sizeof(long) hence
-                        * nullifying the need for shorter length
-                        * assignments
-                        */
+                       tl1 = *pc.cp++;         /* tl1 loop branch */
+                       if (tl1 == 0)
+                               tl1 = *pc.sp++;
+                       tcp = popaddr();        /* tcp = ptr to index var */
+                       tl = pop4();            /* tl upper bound */
+                       if (*tcp == tl)         /* loop is done, fall through */
+                               continue;
+                       *tcp += 1;              /* inc index var */
+                       pc.cp += tl1;           /* return to top of loop */
+                       continue;
                case O_FOR2U:
                case O_FOR2U:
-                       tl1 = *pc.cp++;         /* tl1 index lower bound */
+                       tl1 = *pc.cp++;         /* tl1 loop branch */
                        if (tl1 == 0)
                                tl1 = *pc.sp++;
                        if (tl1 == 0)
                                tl1 = *pc.sp++;
-                       tlp = (long *)popaddr(); /* tlp = ptr to index var */
-                       if (*tlp < pop4()) {    /* still going up */
-                               tl = *tlp + 1;  /* inc index var */
-                               tl2 = *pc.sp++; /* index upper bound */
-                               if (_runtst)
-                                       RANG4(tl, tl1, tl2);
-                               *tlp = tl;      /* update index var */
-                               pc.cp += *pc.sp;/* return to top of loop */
+                       tsp = (short *)popaddr(); /* tsp = ptr to index var */
+                       tl = pop4();            /* tl upper bound */
+                       if (*tsp == tl)         /* loop is done, fall through */
                                continue;
                                continue;
-                       }
-                       pc.sp += 2;             /* else fall through */
+                       *tsp += 1;              /* inc index var */
+                       pc.cp += tl1;           /* return to top of loop */
                        continue;
                case O_FOR4U:
                        continue;
                case O_FOR4U:
-                       tl1 = *pc.cp++;         /* tl1 index lower bound */
+                       tl1 = *pc.cp++;         /* tl1 loop branch */
                        if (tl1 == 0)
                        if (tl1 == 0)
-                               tl1 = *pc.lp++;
+                               tl1 = *pc.sp++;
                        tlp = (long *)popaddr(); /* tlp = ptr to index var */
                        tlp = (long *)popaddr(); /* tlp = ptr to index var */
-                       if (*tlp < pop4()) {    /* still going up */
-                               tl = *tlp + 1;  /* inc index var */
-                               tl2 = *pc.lp++; /* index upper bound */
-                               if (_runtst)
-                                       RANG4(tl, tl1, tl2);
-                               *tlp = tl;      /* update index var */
-                               pc.cp += *pc.sp;/* return to top of loop */
+                       tl = pop4();            /* tl upper bound */
+                       if (*tlp == tl)         /* loop is done, fall through */
                                continue;
                                continue;
-                       }
-                       pc.sp += 3;             /* else fall through */
+                       *tlp += 1;              /* inc index var */
+                       pc.cp += tl1;           /* return to top of loop */
                        continue;
                case O_FOR1D:
                        continue;
                case O_FOR1D:
-                       /*
-                        * with the shadowing of for loop variables
-                        * the variable is always sizeof(long) hence
-                        * nullifying the need for shorter length
-                        * assignments
-                        */
+                       tl1 = *pc.cp++;         /* tl1 loop branch */
+                       if (tl1 == 0)
+                               tl1 = *pc.sp++;
+                       tcp = popaddr();        /* tcp = ptr to index var */
+                       tl = pop4();            /* tl upper bound */
+                       if (*tcp == tl)         /* loop is done, fall through */
+                               continue;
+                       *tcp -= 1;              /* dec index var */
+                       pc.cp += tl1;           /* return to top of loop */
+                       continue;
                case O_FOR2D:
                case O_FOR2D:
-                       tl1 = *pc.cp++;         /* tl1 index lower bound */
+                       tl1 = *pc.cp++;         /* tl1 loop branch */
                        if (tl1 == 0)
                                tl1 = *pc.sp++;
                        if (tl1 == 0)
                                tl1 = *pc.sp++;
-                       tlp = (long *)popaddr(); /* tlp = ptr to index var */
-                       if (*tlp > pop4()) {    /* still going down */
-                               tl = *tlp - 1;  /* inc index var */
-                               tl2 = *pc.sp++; /* index upper bound */
-                               if (_runtst)
-                                       RANG4(tl, tl1, tl2);
-                               *tlp = tl;      /* update index var */
-                               pc.cp += *pc.sp;/* return to top of loop */
+                       tsp = (short *)popaddr(); /* tsp = ptr to index var */
+                       tl = pop4();            /* tl upper bound */
+                       if (*tsp == tl)         /* loop is done, fall through */
                                continue;
                                continue;
-                       }
-                       pc.sp += 2;             /* else fall through */
+                       *tsp -= 1;              /* dec index var */
+                       pc.cp += tl1;           /* return to top of loop */
                        continue;
                case O_FOR4D:
                        continue;
                case O_FOR4D:
-                       tl1 = *pc.cp++;         /* tl1 index lower bound */
+                       tl1 = *pc.cp++;         /* tl1 loop branch */
                        if (tl1 == 0)
                        if (tl1 == 0)
-                               tl1 = *pc.lp++;
+                               tl1 = *pc.sp++;
                        tlp = (long *)popaddr(); /* tlp = ptr to index var */
                        tlp = (long *)popaddr(); /* tlp = ptr to index var */
-                       if (*tlp > pop4()) {    /* still going down */
-                               tl = *tlp - 1;  /* inc index var */
-                               tl2 = *pc.lp++; /* index upper bound */
-                               if (_runtst)
-                                       RANG4(tl, tl1, tl2);
-                               *tlp = tl;      /* update index var */
-                               pc.cp += *pc.sp;/* return to top of loop */
+                       tl = pop4();            /* tl upper bound */
+                       if (*tlp == tl)         /* loop is done, fall through */
                                continue;
                                continue;
-                       }
-                       pc.sp += 3;             /* else fall through */
+                       *tlp -= 1;              /* dec index var */
+                       pc.cp += tl1;           /* return to top of loop */
                        continue;
                case O_READE:
                        pc.cp++;
                        continue;
                case O_READE:
                        pc.cp++;
@@ -1438,6 +1514,16 @@ interpreter(base)
                        pc.cp++;
                        push4(SCLCK());
                        continue;
                        pc.cp++;
                        push4(SCLCK());
                        continue;
+               case O_NEW:
+                       tl = *pc.cp++;          /* tl = size being new'ed */
+                       if (tl == 0)
+                               tl = *pc.usp++;
+                       tcp = popaddr();        /* ptr to ptr being new'ed */
+                       NEW(tcp, tl);
+                       if (_runtst) {
+                               blkclr(*((char **)(tcp)), tl);
+                       }
+                       continue;
                case O_DISPOSE:
                        tl = *pc.cp++;          /* tl = size being disposed */
                        if (tl == 0)
                case O_DISPOSE:
                        tl = *pc.cp++;          /* tl = size being disposed */
                        if (tl == 0)
@@ -1446,16 +1532,13 @@ interpreter(base)
                        DISPOSE(tcp, tl);
                        *(char **)tcp = (char *)0;
                        continue;
                        DISPOSE(tcp, tl);
                        *(char **)tcp = (char *)0;
                        continue;
-               case O_NEW:
-                       tl = *pc.cp++;          /* tl = size being new'ed */
+               case O_DFDISP:
+                       tl = *pc.cp++;          /* tl = size being disposed */
                        if (tl == 0)
                                tl = *pc.usp++;
                        if (tl == 0)
                                tl = *pc.usp++;
-                       tcp = popaddr();        /* ptr to ptr being new'ed */
-                       if (_runtst) {
-                               NEWZ(tcp, tl);
-                               continue;
-                       }
-                       NEW(tcp, tl);
+                       tcp = popaddr();        /* ptr to ptr being disposed */
+                       DFDISPOSE(tcp, tl);
+                       *(char **)tcp = (char *)0;
                        continue;
                case O_DATE:
                        pc.cp++;
                        continue;
                case O_DATE:
                        pc.cp++;
@@ -1472,14 +1555,26 @@ interpreter(base)
                        continue;
                case O_ATAN:
                        pc.cp++;
                        continue;
                case O_ATAN:
                        pc.cp++;
+                       if (_runtst) {
+                               push8(ATAN(pop8()));
+                               continue;
+                       }
                        push8(atan(pop8()));
                        continue;
                case O_COS:
                        pc.cp++;
                        push8(atan(pop8()));
                        continue;
                case O_COS:
                        pc.cp++;
+                       if (_runtst) {
+                               push8(COS(pop8()));
+                               continue;
+                       }
                        push8(cos(pop8()));
                        continue;
                case O_EXP:
                        pc.cp++;
                        push8(cos(pop8()));
                        continue;
                case O_EXP:
                        pc.cp++;
+                       if (_runtst) {
+                               push8(EXP(pop8()));
+                               continue;
+                       }
                        push8(exp(pop8()));
                        continue;
                case O_LN:
                        push8(exp(pop8()));
                        continue;
                case O_LN:
@@ -1492,6 +1587,10 @@ interpreter(base)
                        continue;
                case O_SIN:
                        pc.cp++;
                        continue;
                case O_SIN:
                        pc.cp++;
+                       if (_runtst) {
+                               push8(SIN(pop8()));
+                               continue;
+                       }
                        push8(sin(pop8()));
                        continue;
                case O_SQRT:
                        push8(sin(pop8()));
                        continue;
                case O_SQRT:
@@ -1514,7 +1613,8 @@ interpreter(base)
                case O_ODD2:
                case O_ODD4:
                        pc.cp++;
                case O_ODD2:
                case O_ODD4:
                        pc.cp++;
-                       push2((short)(pop4() & 1));
+                       tl = pop4();
+                       push2((short)(tl & 1));
                        continue;
                case O_SUCC2:
                        tl = *pc.cp++;
                        continue;
                case O_SUCC2:
                        tl = *pc.cp++;
@@ -1620,7 +1720,7 @@ interpreter(base)
                        push4(TRUNC(pop8()));
                        continue;
                default:
                        push4(TRUNC(pop8()));
                        continue;
                default:
-                       panic(PBADOP);
+                       ERROR("Panic: bad op code\n");
                        continue;
                }
        }
                        continue;
                }
        }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.