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