# 2.11BSD#431 - /usr/src/ucb/PORT/pascal/px/interp.c

##### Functions

    interpreter       X

##### Variables

    _actfile          X
    _argc             X
    _argv             X
    _cntrs            X
    _display          X
    _dp               X
    _err              X
    _errwin           X
    _fchain           X
    _filefre          X
    _inwin            X
    _lino             X
    _maxptr           X
    _minptr           X
    _mode             X
    _outwin           X
    _pcpcount         X
    _profcnts         X
    _rtns             X
    _runtst           X
    _seed             X
    _stcnt            X
    _stlim            X
    input             X
    opc               X
    opcptr            X
    output            X
    pcaddrp           X

       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: }

#### Defined functions

interpreter defined in line 122; used 1 times

- in /usr/src/ucb/PORT/pascal/px/int.c line 165

#### Defined variables

_actfile defined in line 94; used 2 times

- in line 160(2)

_argc defined in line 26; used 1 times

- in line 1567

_argv defined in line 27; never used
_cntrs defined in line 42; used 3 times

- in line 1205-1208(3)

_display defined in line 23; used 30 times

- in line 165-170(5), 218, 241, 254-257(3), 274, 283, 308-313(2), 977-1001(7), 1008-1036(8), 1043

_dp defined in line 24; used 21 times

- in line 170, 193-194(2), 209-222(7), 240-241(2), 252-254(2), 311-319(6), 325

_err defined in line 49; used 1 times

- in /usr/src/ucb/PORT/pascal/px/vars.h line 59

_errwin defined in line 48; used 1 times

- in line 50

_fchain defined in line 90; never used
_filefre defined in line 89; never used
_inwin defined in line 48; used 1 times

- in line 74

_lino defined in line 25; used 7 times

- in line 198, 220, 238, 250, 327-329(3)

_maxptr defined in line 40; never used
_minptr defined in line 38; never used
_mode defined in line 28; never used
_outwin defined in line 48; used 1 times

- in line 62

_pcpcount defined in line 41; used 3 times

- in line 1207-1212(3)

_profcnts defined in line 111; used 1 times

- in line 181

_rtns defined in line 43; used 1 times

- in line 1206

_runtst defined in line 29; used 33 times

- in line 199-206(3), 223-225(2), 330, 342, 599, 611, 622, 633, 644, 655, 1418, 1439, 1448, 1458, 1466, 1482, 1595, 1630, 1638, 1646, 1654, 1662, 1670, 1679, 1696, 1708, 1720, 1732, 1744, 1756

_seed defined in line 33; never used
_stcnt defined in line 32; used 1 times

- in line 334

_stlim defined in line 31; never used
input defined in line 73; used 1 times

- in /usr/src/ucb/PORT/pascal/px/vars.h line 57

opc defined in line 118; used 1 times

- in line 178

opcptr defined in line 119; used 3 times

- in line 176-178(3)

output defined in line 61; used 1 times

- in /usr/src/ucb/PORT/pascal/px/vars.h line 58

pcaddrp defined in line 104; used 1 times

- in line 147

sccsid defined in line 8; never used

Last modified: 1985-09-19 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1727 |