Return to interp.c CVS log

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

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

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.