Return to interp.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / pascal / px

Annotation of 42BSD/ucb/pascal/px/interp.c, revision 1.1

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.