1/* generated from v311.sil by genc.sno on */ 2 3# include "mlink.h" 4# include "parms.h" 5int 6BEGIN(retval) 7 ret_t retval; 8{ 9 ENTRY(BEGIN) 10 init(); 11 ISTACK(); 12 if (D_A(BANRCL) == 0) 13 goto L_NOBANR; 14 io_printf(D_A(PUNCH),TITLEF); 15 io_printf(D_A(PUNCH),SOURCF); 16L_NOBANR: 17 D_RV(TIMECL) = mstime(); 18 D_F(TIMECL) = D_V(TIMECL) = 0; 19 SAVSTK(); 20 PUSH(OCALIM); 21 BLOCK(SCBSCL); 22 D(OCSVCL) = D(SCBSCL); 23 D_F(SCBSCL) &= ~(PTR); 24 D_A(YCL) = D_V(D_A(INITLS)); 25 D_F(YCL) = D_V(YCL) = 0; 26L_SPCNVT: 27 D(XPTR) = D(D_A(INITLS) + D_A(YCL)); 28 D_A(XCL) = D_V(D_A(XPTR)); 29 D_F(XCL) = D_V(XCL) = 0; 30L_SPCNV1: 31 D(ZPTR) = D(D_A(XPTR) + D_A(XCL)); 32 if (D_A(ZPTR) == 0) 33 goto L_SPCNV2; 34 SAVSTK(); 35 PUSH(ZPTR); 36 GENVAR(ZPTR); 37 D(D_A(XPTR) + D_A(XCL)) = D(ZPTR); 38L_SPCNV2: 39 D_A(XCL) -= 2*DESCR; 40 if (D_A(XCL) > 0) 41 goto L_SPCNV1; 42 D_A(YCL) -= DESCR; 43 if (D_A(YCL) > 0) 44 goto L_SPCNVT; 45L_INITD1: 46 D(XPTR) = D(D_A(INITB)); 47 SAVSTK(); 48 PUSH(XPTR); 49 GENVAR(YPTR); 50 D(ZPTR) = D(D_A(INITB) + DESCR); 51 D(D_A(ZPTR)) = D(YPTR); 52 D_A(INITB) += 2*DESCR; 53 if (D_PTR(INITB) < D_PTR(INITE)) 54 goto L_INITD1; 55 GETPARM(XSP); 56 SAVSTK(); 57 PUSH(XSPPTR); 58 GENVAR(PARMVL); 59 D(D_A(ABRTKY) + DESCR) = D(ABOPAT); 60 D(D_A(ARBKY) + DESCR) = D(ARBPAT); 61 D(D_A(BALKY) + DESCR) = D(BALPAT); 62 D(D_A(FAILKY) + DESCR) = D(FALPAT); 63 D(D_A(FNCEKY) + DESCR) = D(FNCPAT); 64 D(D_A(REMKY) + DESCR) = D(REMPAT); 65 D(D_A(SUCCKY) + DESCR) = D(SUCPAT); 66 D_A(VARSYM) = 0; 67 SAVSTK(); 68 PUSH(NMOVER); 69 BLOCK(NBSPTR); 70 D(CMBSCL) = D(SCBSCL); 71 D(UNIT) = D(INPUT); 72 D(OCBSCL) = D(CMBSCL); 73 D(OCLIM) = D(CMBSCL); 74 D_A(OCLIM) += D_A(OCALIM); 75 D_A(OCLIM) -= 7*DESCR; 76 D_A(INICOM) = 1; 77 IO_FILE(UNIT,XSP); 78 SAVSTK(); 79 PUSH(XSPPTR); 80 GENVAR(FILENM); 81 D_A(TMVAL) = 0; 82L_AUTLOP: 83 if (!GETPMPROTO(XSP,TMVAL)) 84 goto L_XLATRN; 85 SAVSTK(); 86 PUSH(XSPPTR); 87 GENVAR(XPTR); 88 D(WPTR) = D(NULVCL); 89 D_A(ERRLCL) += 1; 90 SAVSTK(); 91 LOAD2(NORET); 92 D_A(ERRLCL) = 0; 93 D_A(TMVAL) += 1; 94 goto L_AUTLOP; 95 /*_*/ 96L_XLATRD: 97 if (D_A(LISTCL) == 0) 98 goto L_XLATRN; 99 IO_PRINT(IOKEY, OUTBLK, LNBFSP); 100L_XLATRN: 101 _SPEC(TEXTSP) = _SPEC(NEXTSP); 102 switch (IO_READ(UNIT, TEXTSP)) { 103 case IO_EOF: 104 goto L_XLATIN; 105 case IO_ERR: 106 BRANCH(COMP1) 107 } 108 D_A(TMVAL) = S_L(TEXTSP); 109 D_F(TMVAL) = D_V(TMVAL) = 0; 110 D_A(TMVAL) += STNOSZ; 111 S_L(LNBFSP) = D_A(TMVAL); 112 D_A(LNNOCL) += 1; 113L_XLATNX: 114 switch (STREAM(XSP, TEXTSP, &CARDTB)) { 115 case ST_ERROR: 116 BRANCH(COMP3) 117 case ST_EOS: 118 goto L_XLATRD; 119 } 120 SAVSTK(); 121 switch (NEWCRD(NORET)) { 122 case 1: 123 goto L_XLATRD; 124 } 125 SAVSTK(); 126 switch (CMPILE(NORET)) { 127 case 1: 128 BRANCH(COMP3) 129 case 3: 130 goto L_XLATNX; 131 } 132 D_A(CMOFCL) += DESCR; 133 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(ENDCL); 134 if (D_A(LISTCL) == 0) 135 goto L_XLATP; 136 IO_PRINT(IOKEY, OUTBLK, LNBFSP); 137L_XLATP: 138 if (D_A(STYPE) == EOSTYP) 139 goto L_XLAEND; 140 switch (STREAM(XSP, TEXTSP, &IBLKTB)) { 141 case ST_ERROR: 142 BRANCH(COMP3) 143 case ST_EOS: 144 goto L_XLAEND; 145 } 146 if (D_A(STYPE) == EOSTYP) 147 goto L_XLAEND; 148 if (D_A(STYPE) != NBTYP) 149 BRANCH(COMP7) 150 switch (STREAM(XSP, TEXTSP, &LBLTB)) { 151 case ST_ERROR: 152 case ST_EOS: 153 BRANCH(COMP7) 154 } 155 SAVSTK(); 156 PUSH(XSPPTR); 157 GENVUP(XPTR); 158 D(OCBSCL) = D(D_A(XPTR) + ATTRIB); 159 if (D_A(OCBSCL) == 0) 160 BRANCH(COMP7) 161 if (D_A(STYPE) == EOSTYP) 162 goto L_XLAEND; 163 switch (STREAM(XSP, TEXTSP, &IBLKTB)) { 164 case ST_ERROR: 165 case ST_STOP: 166 BRANCH(COMP7) 167 } 168L_XLAEND: 169 if (D_A(ESAICL) == 0) 170 goto L_XLATSC; 171 io_printf(D_A(PUNCH),ERRCF); 172 if (D_A(NERRCL) == 0) 173 goto L_XLATND; 174 D_A(RETCOD) = 1; 175 BRANCH(FTLEN2) 176 /*_*/ 177L_XLATIN: 178 SAVSTK(); 179 FILCHK(NORET); 180 goto L_XLATRN; 181 /*_*/ 182L_XLATSC: 183 if (D_A(BANRCL) == 0) 184 goto L_XLATND; 185 io_printf(D_A(PUNCH),SUCCF); 186L_XLATND: 187 if (D_A(EXECCL) == 0) 188 BRANCH(END) 189 io_ecomp(); 190 D_A(UNIT) = 0; 191 D_A(LPTR) = 0; 192 D_A(OCLIM) = 0; 193 D_A(LNNOCL) = 0; 194 ZERBLK(D_A(COMREG),D_A(COMDCT)); 195 D(XCL) = D(CMBSCL); 196 D_A(XCL) += D_A(CMOFCL); 197 SAVSTK(); 198 PUSH(XCL); 199 SPLIT(NORET); 200 D_A(LISTCL) = 0; 201 D_A(COMPCL) = 0; 202 D_RV(ETMCL) = mstime(); 203 D_F(ETMCL) = D_V(ETMCL) = 0; 204 D_RV(TIMECL) = D_RV(ETMCL) - D_RV(TIMECL); 205 D_F(TIMECL) = D_F(ETMCL); 206 D_V(TIMECL) = D_V(ETMCL); 207 D_A(CNSLCL) = 1; 208 SAVSTK(); 209 switch (INTERP(NORET)) { 210 case 1: 211 case 2: 212 case 3: 213 BRANCH(MAIN1) 214 } 215 /*_*/ 216} 217static int 218AUGATL(retval) 219 ret_t retval; 220{ 221 ENTRY(AUGATL) 222 POP(A1PTR); 223 POP(A2PTR); 224 POP(A3PTR); 225 if (!LOCAPT(A4PTR,A1PTR,ZEROCL)) 226 goto L_AUG1; 227 D(D_A(A4PTR) + DESCR) = D(A2PTR); 228 D(D_A(A4PTR) + 2*DESCR) = D(A3PTR); 229 D(A5PTR) = D(A1PTR); 230 BRANCH(A5RTN) 231 /*_*/ 232L_AUG1: 233 D_A(A4PTR) = D_V(D_A(A1PTR)); 234 D_F(A4PTR) = D_V(A4PTR) = 0; 235 D_A(A4PTR) += 2*DESCR; 236 D_V(A4PTR) = B; 237 SAVSTK(); 238 PUSH(A4PTR); 239 BLOCK(A5PTR); 240 D(D_A(A5PTR) + D_A(A4PTR)) = D(A3PTR); 241 D_A(A4PTR) -= DESCR; 242 D(D_A(A5PTR) + D_A(A4PTR)) = D(A2PTR); 243 D_A(A4PTR) -= DESCR; 244 MOVBLK(D_A(A5PTR),D_A(A1PTR),D_A(A4PTR)); 245 BRANCH(A5RTN) 246 /*_*/ 247} 248static int 249CODSKP(retval) 250 ret_t retval; 251{ 252 ENTRY(CODSKP) 253 POP(YCL); 254L_CODCNT: 255 D_A(OCICL) += DESCR; 256 D(XCL) = D(D_A(OCBSCL) + D_A(OCICL)); 257 if ((D_F(XCL) & FNC)) 258 goto L_CODFNC; 259L_CODECR: 260 D_A(YCL) -= 1; 261 if (D_A(YCL) < 0) 262 BRANCH(INTR10) 263 if (D_A(YCL) == 0) 264 BRANCH(RTN1) 265 goto L_CODCNT; 266 /*_*/ 267L_CODFNC: 268 PUSH(YCL); 269 D_A(YCL) = D_V(XCL); 270 D_F(YCL) = D_V(YCL) = 0; 271 SAVSTK(); 272 PUSH(YCL); 273 CODSKP(NORET); 274 POP(YCL); 275 goto L_CODECR; 276 /*_*/ 277} 278static int 279DTREP(retval) 280 ret_t retval; 281{ 282 ENTRY(DTREP) 283 POP(A2PTR); 284 if (D_V(A2PTR) == A) 285 goto L_DTARRY; 286 if (D_V(A2PTR) == T) 287 goto L_DTABLE; 288 if (D_V(A2PTR) != R) 289 goto L_DTREP1; 290 REALST(DPSP,A2PTR); 291 goto L_DTREPR; 292 /*_*/ 293L_DTARRY: 294 D(A3PTR) = D(D_A(A2PTR) + DESCR); 295 X_LOCSP(ZSP,A3PTR); 296 D_A(A3PTR) = S_L(ZSP); 297 D_F(A3PTR) = D_V(A3PTR) = 0; 298 if (D_A(A3PTR) > ARRLEN) 299 goto L_DTREP1; 300 S_L(DTARSP) = 0; 301 APDSP(DTARSP,ARRSP); 302 APDSP(DTARSP,LPRNSP); 303 APDSP(DTARSP,QTSP); 304 APDSP(DTARSP,ZSP); 305 APDSP(DTARSP,QTSP); 306L_DTARTB: 307 APDSP(DTARSP,RPRNSP); 308 _SPEC(DPSP) = _SPEC(DTARSP); 309 goto L_DTREPR; 310 /*_*/ 311L_DTABLE: 312 D_A(A3PTR) = D_V(D_A(A2PTR)); 313 D_F(A3PTR) = D_V(A3PTR) = 0; 314 D(A1PTR) = D(D_A(A2PTR) + D_A(A3PTR)); 315 D_A(A3PTR) -= DESCR; 316 D(A2PTR) = D(D_A(A2PTR) + D_A(A3PTR)); 317L_DTABL1: 318 if (D_A(A1PTR) == 1) 319 goto L_DTABL2; 320 D_A(A3PTR) += D_A(A2PTR); 321 D_A(A3PTR) -= 2*DESCR; 322 D(A1PTR) = D(D_A(A1PTR) + D_A(A2PTR)); 323 goto L_DTABL1; 324 /*_*/ 325L_DTABL2: 326 D_A(A3PTR) -= DESCR; 327 D_A(A2PTR) -= 2*DESCR; 328 D_A(A3PTR) /= D_A(DSCRTW); 329 INTSPC(ZSP,A3PTR); 330 S_L(DTARSP) = 0; 331 APDSP(DTARSP,ASSCSP); 332 APDSP(DTARSP,LPRNSP); 333 APDSP(DTARSP,ZSP); 334 APDSP(DTARSP,CMASP); 335 D_A(A2PTR) /= D_A(DSCRTW); 336 INTSPC(ZSP,A2PTR); 337 APDSP(DTARSP,ZSP); 338 goto L_DTARTB; 339 /*_*/ 340L_DTREP1: 341 D_V(DT1CL) = D_V(A2PTR); 342 if (!LOCAPT(A3PTR,DTATL,DT1CL)) 343 goto L_DTREPE; 344 D(A3PTR) = D(D_A(A3PTR) + 2*DESCR); 345 X_LOCSP(DPSP,A3PTR); 346L_DTREPR: 347 D(retval) = D(DPSPTR); 348 RETURN(1) 349 /*_*/ 350L_DTREPE: 351 _SPEC(DPSP) = _SPEC(EXDTSP); 352 goto L_DTREPR; 353 /*_*/ 354} 355static int 356FINDEX(retval) 357 ret_t retval; 358{ 359 ENTRY(FINDEX) 360 POP(F1PTR); 361 if (!LOCAPV(F2PTR,FNCPL,F1PTR)) 362 goto L_FATNF; 363 D(F2PTR) = D(D_A(F2PTR) + DESCR); 364L_FATBAK: 365 D(retval) = D(F2PTR); 366 RETURN(1) 367 /*_*/ 368L_FATNF: 369 D_A(NEXFCL) += 2*DESCR; 370 if (D_A(NEXFCL) > FBLKSZ) 371 goto L_FATBLK; 372L_FATNXT: 373 D(F2PTR) = D(FBLOCK); 374 D_A(F2PTR) += D_A(NEXFCL); 375 SAVSTK(); 376 PUSH(F1PTR); 377 PUSH(F2PTR); 378 PUSH(FNCPL); 379 AUGATL(FNCPL); 380 D(D_A(F2PTR)) = D(UNDFCL); 381 D(D_A(F2PTR) + DESCR) = D(F1PTR); 382 goto L_FATBAK; 383 /*_*/ 384L_FATBLK: 385 SAVSTK(); 386 PUSH(FBLKRQ); 387 BLOCK(FBLOCK); 388 D_F(FBLOCK) |= FNC; 389 D_V(FBLOCK) = 0; 390 D_A(NEXFCL) = (int_t) DESCR; 391 goto L_FATNXT; 392 /*_*/ 393} 394static int 395BLOCK(retval) 396 ret_t retval; 397{ 398 ENTRY(BLOCK) 399 POP(ARG1CL); 400 if (D_A(ARG1CL) >= D_A(SIZLMT)) 401 BRANCH(SIZERR) 402L_BLOCK1: 403 D(BLOCL) = D(FRSGPT); 404 D_V(BLOCL) = D_V(ARG1CL); 405 D_A(FRSGPT) += DESCR; 406 D_A(FRSGPT) += D_A(ARG1CL); 407 if (D_A(TLSGP1) < D_A(FRSGPT)) 408 goto L_BLOGC; 409 ZERBLK(D_A(BLOCL),D_A(ARG1CL)); 410 D_A(D_A(BLOCL)) = D_A(BLOCL); 411 D_F(D_A(BLOCL)) |= TTL; 412 D_V(D_A(BLOCL)) = D_A(ARG1CL); 413 D(retval) = D(BLOCL); 414 RETURN(1) 415 /*_*/ 416L_BLOGC: 417 D_A(FRSGPT) = D_A(BLOCL); 418 SAVSTK(); 419 PUSH(ARG1CL); 420 switch (GC(NORET)) { 421 case 1: 422 BRANCH(ALOC2) 423 case 2: 424 goto L_BLOCK1; 425 } 426 /*_*/ 427} 428static int 429GENVAR(retval) 430 ret_t retval; 431{ 432 ENTRY(GENVAR) 433 D_A(CONVSW) = 0; 434 POP(AXPTR); 435 _SPEC(SPECR1) = _SPEC(D_A(AXPTR)); 436 if (S_L(SPECR1) == 0) 437 BRANCH(RT1NUL) 438 /* FALL */ 439 BRANCH(LOCA1) 440} 441static int 442LOCA1(retval) 443 ret_t retval; 444{ 445 ENTRY(LOCA1) 446 HASH(EQUVCL,SPECR1); 447 D(BUKPTR) = D(OBPTR); 448 D_A(BUKPTR) += D_A(EQUVCL); 449L_LOCA2: 450 D(LSTPTR) = D(BUKPTR); 451 D_A(BUKPTR) = D_A(D_A(BUKPTR) + LNKFLD); 452 if (D_A(BUKPTR) == 0) 453 goto L_LOCA5; 454 if (D_V(D_A(BUKPTR) + LNKFLD) < D_V(EQUVCL)) 455 goto L_LOCA2; 456 if (D_V(D_A(BUKPTR) + LNKFLD) > D_V(EQUVCL)) 457 goto L_LOCA5; 458 X_LOCSP(SPECR2,BUKPTR); 459 if (!LEXEQ(SPECR1,SPECR2)) 460 goto L_LOCA2; 461 D(LCPTR) = D(BUKPTR); 462 goto L_LOCRET; 463 /*_*/ 464L_LOCA5: 465 D_A(AXPTR) = S_L(SPECR1); 466 D_F(AXPTR) = D_V(AXPTR) = 0; 467 D_A(BKLTCL) = X_GETLTH(AXPTR); 468 D_F(BKLTCL) = D_V(BKLTCL) = 0; 469 if (D_A(BKLTCL) > D_A(SIZLMT)) 470 BRANCH(SIZERR) 471L_LOCA7: 472 D(LCPTR) = D(FRSGPT); 473 D_V(LCPTR) = S; 474 D_A(FRSGPT) += DESCR; 475 D_A(FRSGPT) += D_A(BKLTCL); 476 if (D_A(TLSGP1) < D_A(FRSGPT)) 477 goto L_LOCA4; 478 D(D_A(LCPTR)) = D(ZEROCL); 479 D_A(D_A(LCPTR)) = D_A(LCPTR); 480 D_F(D_A(LCPTR)) |= TTL+STTL; 481 D_V(D_A(LCPTR)) = D_A(AXPTR); 482 if (D_A(CONVSW) != 0) 483 goto L_LOCA6; 484 D(D_A(LCPTR) + DESCR) = D(NULVCL); 485 D(D_A(LCPTR) + ATTRIB) = D(ZEROCL); 486 X_LOCSP(SPECR2,LCPTR); 487 S_L(SPECR2) = 0; 488 APDSP(SPECR2,SPECR1); 489L_LOCA6: 490 D_V(D_A(LCPTR) + LNKFLD) = D_V(EQUVCL); 491 D_A(D_A(LCPTR) + LNKFLD) = D_A(BUKPTR); 492 D_A(D_A(LSTPTR) + LNKFLD) = D_A(LCPTR); 493 D_A(VARSYM) += 1; 494L_LOCRET: 495 D(retval) = D(LCPTR); 496 RETURN(1) 497 /*_*/ 498L_LOCA4: 499 D_A(FRSGPT) = D_A(LCPTR); 500 SAVSTK(); 501 PUSH(BKLTCL); 502 switch (GC(NORET)) { 503 case 1: 504 BRANCH(ALOC2) 505 case 2: 506 goto L_LOCA7; 507 } 508 /*_*/ 509} 510static int 511GNVARI(retval) 512 ret_t retval; 513{ 514 ENTRY(GNVARI) 515 D_A(CONVSW) = 0; 516 POP(AXPTR); 517 INTSPC(SPECR1,AXPTR); 518 BRANCH(LOCA1) 519 /*_*/ 520} 521static int 522GENVUP(retval) 523 ret_t retval; 524{ 525 ENTRY(GENVUP) 526 if (D_A(CASECL) == 0) 527 BRANCH(GENVAR) 528 POP(AXPTR); 529 PUSH(AXPTR); 530 _SPEC(SPECR1) = _SPEC(D_A(AXPTR)); 531 RAISE1(SPECR1); 532 BRANCH(GENVAR) 533 /*_*/ 534} 535static int 536CONVAR(retval) 537 ret_t retval; 538{ 539 ENTRY(CONVAR) 540 POP(AXPTR); 541 if (D_A(AXPTR) == 0) 542 BRANCH(RT1NUL) 543 D_A(CONVSW) = 1; 544 D_A(BKLTCL) = X_GETLTH(AXPTR); 545 D_F(BKLTCL) = D_V(BKLTCL) = 0; 546 if (D_A(BKLTCL) > D_A(SIZLMT)) 547 BRANCH(SIZERR) 548 D(TEMPCL) = D(FRSGPT); 549 D_A(TEMPCL) += D_A(BKLTCL); 550 D_A(TEMPCL) += DESCR; 551 if (D_A(TLSGP1) < D_A(TEMPCL)) 552 goto L_CONVR4; 553L_CONVR5: 554 D(D_A(FRSGPT)) = D(ZEROCL); 555 D_A(D_A(FRSGPT)) = D_A(FRSGPT); 556 D_F(D_A(FRSGPT)) |= TTL+STTL; 557 D_V(D_A(FRSGPT)) = D_A(AXPTR); 558 D(D_A(FRSGPT) + DESCR) = D(NULVCL); 559 D(D_A(FRSGPT) + ATTRIB) = D(ZEROCL); 560 D_A(BKLTCL) = D_A(FRSGPT); 561 D(retval) = D(BKLTCL); 562 RETURN(1) 563 /*_*/ 564L_CONVR4: 565 SAVSTK(); 566 PUSH(BKLTCL); 567 switch (GC(NORET)) { 568 case 1: 569 BRANCH(ALOC2) 570 case 2: 571 goto L_CONVR5; 572 } 573 /*_*/ 574} 575static int 576GNVARS(retval) 577 ret_t retval; 578{ 579 ENTRY(GNVARS) 580 POP(AXPTR); 581 if (D_A(AXPTR) == 0) 582 BRANCH(RT1NUL) 583 X_LOCSP(SPECR1,FRSGPT); 584 S_L(SPECR1) = D_A(AXPTR); 585 D_V(D_A(FRSGPT)) = D_A(AXPTR); 586 BRANCH(LOCA1) 587 /*_*/ 588} 589static int 590GC(retval) 591 ret_t retval; 592{ 593 ENTRY(GC) 594 D_RV(GCTMCL) = mstime(); 595 D_F(GCTMCL) = D_V(GCTMCL) = 0; 596 vm_gc_advise(1); 597 POP(GCREQ); 598 PSTACK(BLOCL); 599 D_A(BLOCL) -= D_A(STKPTR); 600 D_V(D_A(STKPTR)) = D_A(BLOCL); 601 D(BKDXU) = D(PRMDX); 602L_GCT: 603 D(GCMPTR) = D(D_A(PRMPTR) + D_A(BKDXU)); 604 if (D_A(GCMPTR) == 0) 605 goto L_GCTDWN; 606 SAVSTK(); 607 PUSH(GCMPTR); 608 GCM(NORET); 609L_GCTDWN: 610 D_A(BKDXU) -= DESCR; 611 if (D_A(BKDXU) != 0) 612 goto L_GCT; 613 D_A(BKPTR) = (int_t) (OBLIST-DESCR); 614L_GCBA1: 615 if (D_PTR(BKPTR) > D_PTR(OBEND)) 616 goto L_GCLAD; 617 D_A(BKPTR) += DESCR; 618 D(ST1PTR) = D(BKPTR); 619L_GCBA2: 620 D_A(ST1PTR) = D_A(D_A(ST1PTR) + LNKFLD); 621 if (D_A(ST1PTR) == 0) 622 goto L_GCBA1; 623 if ((D_F(D_A(ST1PTR)) & MARK)) 624 goto L_GCBA2; 625 D(ST2PTR) = D(D_A(ST1PTR) + DESCR); 626 if (!DCMP(ST2PTR, NULVCL)) 627 goto L_GCBA4; 628 if (D_A(D_A(ST1PTR) + ATTRIB) == (int_t)0) 629 goto L_GCBA2; 630L_GCBA4: 631 D(D_A(GCBLK) + DESCR) = D(ST1PTR); 632 SAVSTK(); 633 PUSH(GCBLK); 634 switch (GCM(NORET)) { 635 case 1: 636 goto L_GCBA2; 637 } 638 /*_*/ 639L_GCLAD: 640 D(CPYCL) = D(HDSGPT); 641 D(TTLCL) = D(HDSGPT); 642L_GCLAD0: 643 D_A(BKDX) = X_BKSIZE(D_A(TTLCL)); 644 D_F(BKDX) = D_V(BKDX) = 0; 645 if (!(D_F(D_A(TTLCL)) & MARK)) 646 goto L_GCLAD7; 647 D_A(CPYCL) += D_A(BKDX); 648 D_A(TTLCL) += D_A(BKDX); 649 if (D_A(TTLCL) == D_A(FRSGPT)) 650 goto L_GCBB1; 651 else 652 goto L_GCLAD0; 653 /*_*/ 654L_GCLAD7: 655 D(MVSGPT) = D(TTLCL); 656L_GCLAD4: 657 D_A(TTLCL) += D_A(BKDX); 658 if (D_A(TTLCL) == D_A(FRSGPT)) 659 goto L_GCBB1; 660 D_A(BKDX) = X_BKSIZE(D_A(TTLCL)); 661 D_F(BKDX) = D_V(BKDX) = 0; 662 if (!(D_F(D_A(TTLCL)) & MARK)) 663 goto L_GCLAD4; 664 D_A(D_A(TTLCL)) = D_A(CPYCL); 665 D_A(CPYCL) += D_A(BKDX); 666 goto L_GCLAD4; 667 /*_*/ 668L_GCBB1: 669 D_A(BKPTR) = (int_t) (OBLIST-DESCR); 670 D_A(NODPCL) = 1; 671L_GCBB2: 672 if (D_PTR(BKPTR) > D_PTR(OBEND)) 673 goto L_GCLAP; 674 D_A(BKPTR) += DESCR; 675 D(ST1PTR) = D(BKPTR); 676L_GCBB3: 677 D(ST2PTR) = D(ST1PTR); 678L_GCBB4: 679 D_A(ST1PTR) = D_A(D_A(ST1PTR) + LNKFLD); 680 if (D_A(ST1PTR) == 0) 681 goto L_GCBB5; 682 if (!(D_F(D_A(ST1PTR)) & MARK)) 683 goto L_GCBB4; 684 D_A(BLOCL) = D_A(D_A(ST1PTR)); 685 D_A(D_A(ST2PTR) + LNKFLD) = D_A(BLOCL); 686 goto L_GCBB3; 687 /*_*/ 688L_GCBB5: 689 D_A(D_A(ST2PTR) + LNKFLD) = D_A(ZEROCL); 690 goto L_GCBB2; 691 /*_*/ 692L_GCLAP: 693 D(TTLCL) = D(HDSGPT); 694L_GCLAP0: 695 D_A(BKDXU) = X_BKSIZE(D_A(TTLCL)); 696 D_F(BKDXU) = D_V(BKDXU) = 0; 697 if ((D_F(D_A(TTLCL)) & STTL)) 698 goto L_GCLAP1; 699 D(BKDX) = D(BKDXU); 700 goto L_GCLAP2; 701 /*_*/ 702L_GCLAP1: 703 D_A(BKDX) = (int_t) (3*DESCR); 704L_GCLAP2: 705 if (!(D_F(D_A(TTLCL)) & MARK)) 706 goto L_GCLAP5; 707 D_A(BKDX) -= DESCR; 708L_GCLAP3: 709 D(DESCL) = D(D_A(TTLCL) + D_A(BKDX)); 710 if (!(D_F(DESCL) & PTR)) 711 goto L_GCLAP4; 712 if (D_PTR(DESCL) < D_PTR(MVSGPT)) 713 goto L_GCLAP4; 714 TOP(TOPCL,OFSET,DESCL); 715 D_A(DESCL) = D_A(OFSET) + D_A(D_A(TOPCL)); 716 D(D_A(TTLCL) + D_A(BKDX)) = D(DESCL); 717L_GCLAP4: 718 D_A(BKDX) -= DESCR; 719 if (D_A(BKDX) != 0) 720 goto L_GCLAP3; 721L_GCLAP5: 722 D_A(TTLCL) += D_A(BKDXU); 723 if (D_A(TTLCL) != D_A(FRSGPT)) 724 goto L_GCLAP0; 725 D(BKDXU) = D(PRMDX); 726L_GCLAT1: 727 D(TTLCL) = D(D_A(PRMPTR) + D_A(BKDXU)); 728 if (D_A(TTLCL) == 0) 729 goto L_GCLAT4; 730 D_A(BKDX) = D_V(D_A(TTLCL)); 731 D_F(BKDX) = D_V(BKDX) = 0; 732L_GCLAT2: 733 D(DESCL) = D(D_A(TTLCL) + D_A(BKDX)); 734 if (!(D_F(DESCL) & PTR)) 735 goto L_GCLAT3; 736 if (D_PTR(DESCL) < D_PTR(MVSGPT)) 737 goto L_GCLAT3; 738 TOP(TOPCL,OFSET,DESCL); 739 D_A(DESCL) = D_A(OFSET) + D_A(D_A(TOPCL)); 740 D(D_A(TTLCL) + D_A(BKDX)) = D(DESCL); 741L_GCLAT3: 742 D_A(BKDX) -= DESCR; 743 if (D_A(BKDX) != 0) 744 goto L_GCLAT2; 745L_GCLAT4: 746 D_A(BKDXU) -= DESCR; 747 if (D_A(BKDXU) != 0) 748 goto L_GCLAT1; 749 D(TTLCL) = D(HDSGPT); 750L_GCLAM0: 751 D_A(BKDXU) = X_BKSIZE(D_A(TTLCL)); 752 D_F(BKDXU) = D_V(BKDXU) = 0; 753 if (D_PTR(TTLCL) >= D_PTR(MVSGPT)) 754 goto L_GCLAM5; 755 D_A(TOPCL) = D_A(D_A(TTLCL)); 756 D(D_A(TOPCL)) = D(D_A(TTLCL)); 757 D_F(D_A(TOPCL)) &= ~(MARK); 758 goto L_GCLAM4; 759 /*_*/ 760L_GCLAM5: 761 D_A(BKDX) = D_A(BKDXU); 762 D_A(BKDX) -= DESCR; 763 if (!(D_F(D_A(TTLCL)) & MARK)) 764 goto L_GCLAM4; 765 D_A(TOPCL) = D_A(D_A(TTLCL)); 766 D(D_A(TOPCL)) = D(D_A(TTLCL)); 767 D_F(D_A(TOPCL)) &= ~(MARK); 768 MOVBLK(D_A(TOPCL),D_A(TTLCL),D_A(BKDX)); 769L_GCLAM4: 770 D_A(TTLCL) += D_A(BKDXU); 771 if (D_A(TTLCL) != D_A(FRSGPT)) 772 goto L_GCLAM0; 773 vm_gc_advise(0); 774 D_A(GCNO) += 1; 775 D_A(NODPCL) = 0; 776 D_A(BKDX) = X_BKSIZE(D_A(TOPCL)); 777 D_F(BKDX) = D_V(BKDX) = 0; 778 D(FRSGPT) = D(TOPCL); 779 D_A(FRSGPT) += D_A(BKDX); 780 D_F(FRSGPT) &= ~(FNC); 781 D(GCGOT) = D(TLSGP1); 782 D_A(GCGOT) -= D_A(FRSGPT); 783 D_A(GCGOT) -= DESCR; 784 D_F(GCGOT) &= ~(PTR); 785 D_RV(TEMPCL) = mstime(); 786 D_F(TEMPCL) = D_V(TEMPCL) = 0; 787 D_RV(TEMPCL) -= D_RV(GCTMCL); 788 D_RV(GCTTTL) += D_RV(TEMPCL); 789 if (D_A(GCTRCL) < 0) 790 goto L_GCTRC; 791 if (D_A(GCTRCL) == 0) 792 goto L_NOGCTR; 793 D_A(GCTRCL) -= 1; 794L_GCTRC: 795 io_printf(D_A(PUNCH),GCFMT,FILENM,LNNOCL,TEMPCL,GCGOT); 796L_NOGCTR: 797 if (D_A(GCREQ) > D_A(GCGOT)) 798 BRANCH(FAIL) 799 D(retval) = D(GCGOT); 800 RETURN(2) 801 /*_*/ 802} 803static int 804GCM(retval) 805 ret_t retval; 806{ 807 ENTRY(GCM) 808 POP(BK1CL); 809 PUSH(ZEROCL); 810L_GCMA1: 811 D_A(BKDX) = D_V(D_A(BK1CL)); 812 D_F(BKDX) = D_V(BKDX) = 0; 813L_GCMA2: 814 D(DESCL) = D(D_A(BK1CL) + D_A(BKDX)); 815 if (!(D_F(DESCL) & PTR)) 816 goto L_GCMA3; 817 if (D_A(DESCL) == 0) 818 goto L_GCMA3; 819 TOP(TOPCL,OFSET,DESCL); 820 if (!(D_F(D_A(TOPCL)) & MARK)) 821 goto L_GCMA4; 822L_GCMA3: 823 D_A(BKDX) -= DESCR; 824 if (D_A(BKDX) != 0) 825 goto L_GCMA2; 826 POP(BK1CL); 827 if (D_A(BK1CL) == 0) 828 BRANCH(RTN1) 829 D_A(BKDX) = D_V(BK1CL); 830 D_F(BKDX) = D_V(BKDX) = 0; 831 goto L_GCMA2; 832 /*_*/ 833L_GCMA4: 834 D_A(BKDX) -= DESCR; 835 if (D_A(BKDX) == 0) 836 goto L_GCMA9; 837 D_V(BK1CL) = D_A(BKDX); 838 PUSH(BK1CL); 839L_GCMA9: 840 D(BK1CL) = D(TOPCL); 841 D_F(D_A(BK1CL)) |= MARK; 842 if (!(D_F(D_A(BK1CL)) & STTL)) 843 goto L_GCMA1; 844 D(BKDX) = D(TWOCL); 845 goto L_GCMA2; 846 /*_*/ 847} 848static int 849SPLIT(retval) 850 ret_t retval; 851{ 852 ENTRY(SPLIT) 853 POP(A4PTR); 854 TOP(A5PTR,A6PTR,A4PTR); 855 if (D_A(A6PTR) == 0) 856 BRANCH(RTN1) 857 D_A(A7PTR) = D_V(D_A(A5PTR)); 858 D_F(A7PTR) = D_V(A7PTR) = 0; 859 D_A(A7PTR) -= D_A(A6PTR); 860 D_A(A7PTR) -= DESCR; 861 if (D_A(A7PTR) <= 0) 862 BRANCH(RTN1) 863 D_V(D_A(A5PTR)) = D_A(A6PTR); 864 D_A(A4PTR) += DESCR; 865 D(D_A(A4PTR)) = D(ZEROCL); 866 D_A(D_A(A4PTR)) = D_A(A4PTR); 867 D_F(D_A(A4PTR)) |= TTL; 868 D_V(D_A(A4PTR)) = D_A(A7PTR); 869 BRANCH(RTN1) 870 /*_*/ 871} 872static int 873BINOP(retval) 874 ret_t retval; 875{ 876 ENTRY(BINOP) 877 SAVSTK(); 878 switch (FORBLK(NORET)) { 879 case 1: 880 goto L_BINOP1; 881 } 882 if (D_A(BRTYPE) == EQTYP) 883 goto L_BINOP2; 884L_BINOP4: 885 if (D_A(BRTYPE) != NBTYP) 886 BRANCH(RTN2) 887 if (D_A(SPITCL) != 0) 888 goto L_BINOP5; 889 switch (STREAM(XSP, TEXTSP, &BIOPTB)) { 890 case ST_ERROR: 891 goto L_BINCON; 892 } 893L_BINOP3: 894 D(ZPTR) = D(STYPE); 895 BRANCH(RTZPTR) 896 /*_*/ 897L_BINOP2: 898 if (D_A(SPITCL) == 0) 899 goto L_BINOP4; 900 D_A(STYPE) = (int_t) BIEQFN; 901 goto L_BINOP3; 902 /*_*/ 903L_BINOP1: 904 SAVSTK(); 905 switch (FORWRD(NORET)) { 906 case 1: 907 BRANCH(COMP3) 908 } 909 switch (D_A(BRTYPE)) { 910 case 2: 911 case 3: 912 case 6: 913 case 7: 914 BRANCH(RTN2) 915 } 916 D_A(EMSGCL) = (int_t) ILLBIN; 917 BRANCH(RTN1) 918 /*_*/ 919L_BINCON: 920 D(ZPTR) = D(CONCL); 921 BRANCH(RTZPTR) 922 /*_*/ 923L_BINOP5: 924 switch (STREAM(XSP, TEXTSP, &SBIPTB)) { 925 case ST_ERROR: 926 goto L_BINCON; 927 } 928 goto L_BINOP3; 929 /*_*/ 930} 931static int 932CMPILE(retval) 933 ret_t retval; 934{ 935 ENTRY(CMPILE) 936 D_A(BRTYPE) = 0; 937 D(BOSCL) = D(CMOFCL); 938 D_A(CSTNCL) += 1; 939 switch (STREAM(XSP, TEXTSP, &LBLTB)) { 940 case ST_ERROR: 941 goto L_CERR1; 942 } 943 if (S_L(XSP) == 0) 944 goto L_CMPILA; 945 D_A(CMOFCL) += DESCR; 946 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(BASECL); 947 D_A(CMBSCL) += D_A(CMOFCL); 948 if (D_PTR(CMBSCL) < D_PTR(OCLIM)) 949 goto L_CMPILO; 950 SAVSTK(); 951 PUSH(CODELT); 952 BLOCK(XCL); 953 D(D_A(CMBSCL)) = D(GOTGCL); 954 D(D_A(CMBSCL) + DESCR) = D(LIT1CL); 955 D(D_A(CMBSCL) + 2*DESCR) = D(XCL); 956 D(CMBSCL) = D(XCL); 957 D(OCLIM) = D(CMBSCL); 958 D_A(OCLIM) += D_A(CODELT); 959 D_A(OCLIM) -= 7*DESCR; 960 D(D_A(CMBSCL) + DESCR) = D(BASECL); 961 D_A(CMBSCL) += DESCR; 962L_CMPILO: 963 D_A(CMOFCL) = 0; 964 D_A(BOSCL) = 0; 965 SAVSTK(); 966 PUSH(XSPPTR); 967 GENVUP(LPTR); 968 if (D_A(D_A(LPTR) + ATTRIB) == (int_t)0) 969 goto L_CMPILC; 970 if (D_A(CNSLCL) == 0) 971 goto L_CERR2; 972L_CMPILC: 973 D(D_A(LPTR) + ATTRIB) = D(CMBSCL); 974 if (DCMP(LPTR, ENDPTR)) 975 BRANCH(RTN2) 976L_CMPILA: 977 SAVSTK(); 978 switch (FORBLK(NORET)) { 979 case 1: 980 goto L_CERR12; 981 } 982 if (D_A(BRTYPE) == EOSTYP) 983 BRANCH(RTN3) 984 D_A(CMOFCL) += DESCR; 985 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(INITCL); 986 D_A(CMOFCL) += DESCR; 987 D(FRNCL) = D(CMOFCL); 988 D_A(CMOFCL) += DESCR; 989 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(LNNOCL); 990 D_A(CMOFCL) += DESCR; 991 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(FILENM); 992 if (D_A(BRTYPE) == NBTYP) 993 goto L_CMPSUB; 994 if (D_A(BRTYPE) == CLNTYP) 995 goto L_CMPGO; 996 else 997 goto L_CERR3; 998 /*_*/ 999L_CMPSUB: 1000 SAVSTK(); 1001 switch (ELEMNT(SUBJND)) { 1002 case 1: 1003 goto L_CDIAG; 1004 case 2: 1005 BRANCH(COMP3) 1006 } 1007 SAVSTK(); 1008 switch (FORBLK(NORET)) { 1009 case 1: 1010 goto L_CERR5; 1011 } 1012 if (D_A(BRTYPE) != NBTYP) 1013 goto L_CMPSB1; 1014 if (D_A(SPITCL) == 0) 1015 goto L_CMPAT2; 1016 { 1017 /* Sigh; this was in assembler in SNOBOL4+ [PLB32] */ 1018 register char *cp; /* [PLB33] */ 1019 cp = S_SP(TEXTSP); /* [PLB33] */ 1020 if (*cp == '?' && /* is break char '?' [PLB32] */ 1021 (S_L(TEXTSP) == 1 || /* yes; is last char? [PLB32] */ 1022 cp[1] == ' ' || cp[1] == '\t')) { /* or next is white? [PLB33] */ 1023 S_O(TEXTSP)++; /* binary ? found. [PLB32] */ 1024 S_L(TEXTSP)--; /* remove from TEXTSP [PLB32] */ 1025 } /* [PLB32] */ 1026 } 1027 goto L_CMPATN; 1028 /*_*/ 1029L_CMPSB1: 1030 if (D_A(BRTYPE) == EQTYP) 1031 goto L_CMPFRM; 1032 SAVSTK(); 1033 PUSH(SUBJND); 1034 TREPUB(NORET); 1035 if (D_A(BRTYPE) == CLNTYP) 1036 goto L_CMPGO; 1037 if (D_A(BRTYPE) == EOSTYP) 1038 goto L_CMPNGO; 1039 else 1040 goto L_CERR5; 1041 /*_*/ 1042L_CMPATN: 1043 SAVSTK(); 1044 PUSH(CNDSIZ); 1045 BLOCK(EXOPND); 1046 D(D_A(EXOPND) + CODE) = D(SCANCL); 1047 D_V(D_A(EXOPND) + CODE) = D_V(ZEROCL); 1048 ADDSON(EXOPND,SUBJND); 1049 D(EXPRND) = D(SUBJND); 1050 SAVSTK(); 1051 switch (EXPR1(PATND)) { 1052 case 1: 1053 goto L_CDIAG; 1054 case 2: 1055 goto L_CMPAT1; 1056 } 1057 /*_*/ 1058L_CMPAT2: 1059 SAVSTK(); 1060 switch (EXPR(PATND)) { 1061 case 1: 1062 goto L_CDIAG; 1063 } 1064 if (D_A(BRTYPE) == EQTYP) 1065 goto L_CMPASP; 1066 D_A(CMOFCL) += DESCR; 1067 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(SCANCL); 1068 SAVSTK(); 1069 PUSH(SUBJND); 1070 TREPUB(NORET); 1071L_CMPAT1: 1072 SAVSTK(); 1073 PUSH(PATND); 1074 TREPUB(NORET); 1075L_CMPTGO: 1076 if (D_A(BRTYPE) == EOSTYP) 1077 goto L_CMPNGO; 1078 if (D_A(BRTYPE) == CLNTYP) 1079 goto L_CMPGO; 1080 else 1081 goto L_CERR5; 1082 /*_*/ 1083L_CMPFRM: 1084 SAVSTK(); 1085 switch (EXPR(FORMND)) { 1086 case 1: 1087 goto L_CDIAG; 1088 } 1089 D_A(CMOFCL) += DESCR; 1090 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(ASGNCL); 1091 SAVSTK(); 1092 PUSH(SUBJND); 1093 TREPUB(NORET); 1094 goto L_CMPFT; 1095 /*_*/ 1096L_CMPASP: 1097 SAVSTK(); 1098 switch (EXPR(FORMND)) { 1099 case 1: 1100 goto L_CDIAG; 1101 } 1102 D_A(CMOFCL) += DESCR; 1103 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(SJSRCL); 1104 SAVSTK(); 1105 PUSH(SUBJND); 1106 TREPUB(NORET); 1107 SAVSTK(); 1108 PUSH(PATND); 1109 TREPUB(NORET); 1110L_CMPFT: 1111 SAVSTK(); 1112 PUSH(FORMND); 1113 switch (TREPUB(NORET)) { 1114 case 1: 1115 goto L_CMPTGO; 1116 } 1117 /*_*/ 1118L_CMPNGO: 1119 D_V(CSTNCL) = D_A(CMOFCL); 1120 D(D_A(CMBSCL) + D_A(FRNCL)) = D(CSTNCL); 1121 BRANCH(RTN3) 1122 /*_*/ 1123L_CMPGO: 1124 SAVSTK(); 1125 switch (FORWRD(NORET)) { 1126 case 1: 1127 BRANCH(COMP3) 1128 } 1129 if (D_A(BRTYPE) == EOSTYP) 1130 goto L_CMPNGO; 1131 if (D_A(BRTYPE) != NBTYP) 1132 goto L_CERR11; 1133 switch (STREAM(XSP, TEXTSP, &GOTOTB)) { 1134 case ST_ERROR: 1135 goto L_CERR11; 1136 case ST_EOS: 1137 goto L_CERR12; 1138 } 1139 D(GOGOCL) = D(GOTLCL); 1140 D_A(GOBRCL) = (int_t) RPTYP; 1141 if (D_A(STYPE) <= D_A(GTOCL)) 1142 goto L_CMPGG; 1143 D(GOGOCL) = D(GOTGCL); 1144 D_A(GOBRCL) = (int_t) RBTYP; 1145L_CMPGG: 1146 switch (D_A(STYPE)) { 1147 case 2: 1148 goto L_CMPSGO; 1149 case 3: 1150 goto L_CMPFGO; 1151 case 5: 1152 goto L_CMPSGO; 1153 case 6: 1154 goto L_CMPFGO; 1155 } 1156L_CMPUGO: 1157 D_V(CSTNCL) = D_A(CMOFCL); 1158 D(D_A(CMBSCL) + D_A(FRNCL)) = D(CSTNCL); 1159 SAVSTK(); 1160 switch (EXPR(GOTOND)) { 1161 case 1: 1162 goto L_CDIAG; 1163 } 1164 if (D_A(BRTYPE) != D_A(GOBRCL)) 1165 goto L_CERR11; 1166 D_A(CMOFCL) += DESCR; 1167 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(GOGOCL); 1168 SAVSTK(); 1169 PUSH(GOTOND); 1170 TREPUB(NORET); 1171 SAVSTK(); 1172 switch (FORWRD(NORET)) { 1173 case 1: 1174 BRANCH(COMP3) 1175 } 1176 if (D_A(BRTYPE) == EOSTYP) 1177 BRANCH(RTN3) 1178 else 1179 goto L_CERR11; 1180 /*_*/ 1181L_CMPSGO: 1182 SAVSTK(); 1183 switch (EXPR(SGOND)) { 1184 case 1: 1185 goto L_CDIAG; 1186 } 1187 if (D_A(BRTYPE) != D_A(GOBRCL)) 1188 goto L_CERR11; 1189 D_A(CMOFCL) += DESCR; 1190 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(GOGOCL); 1191 SAVSTK(); 1192 PUSH(SGOND); 1193 TREPUB(NORET); 1194 SAVSTK(); 1195 switch (FORWRD(NORET)) { 1196 case 1: 1197 BRANCH(COMP3) 1198 } 1199 if (D_A(BRTYPE) != EOSTYP) 1200 goto L_CMPILL; 1201 D_V(CSTNCL) = D_A(CMOFCL); 1202 D(D_A(CMBSCL) + D_A(FRNCL)) = D(CSTNCL); 1203 BRANCH(RTN3) 1204 /*_*/ 1205L_CMPILL: 1206 if (D_A(BRTYPE) != NBTYP) 1207 goto L_CERR11; 1208 switch (STREAM(XSP, TEXTSP, &GOTOTB)) { 1209 case ST_ERROR: 1210 goto L_CERR11; 1211 case ST_EOS: 1212 goto L_CERR12; 1213 } 1214 if (D_A(STYPE) != FGOTYP) 1215 goto L_CMPFTC; 1216 D(GOGOCL) = D(GOTLCL); 1217 D_A(GOBRCL) = (int_t) RPTYP; 1218 goto L_CMPUGO; 1219 /*_*/ 1220L_CMPFTC: 1221 if (D_A(STYPE) != FTOTYP) 1222 goto L_CERR11; 1223 D(GOGOCL) = D(GOTGCL); 1224 D_A(GOBRCL) = (int_t) RBTYP; 1225 goto L_CMPUGO; 1226 /*_*/ 1227L_CMPFGO: 1228 SAVSTK(); 1229 switch (EXPR(FGOND)) { 1230 case 1: 1231 goto L_CDIAG; 1232 } 1233 if (D_A(BRTYPE) != D_A(GOBRCL)) 1234 goto L_CERR11; 1235 SAVSTK(); 1236 switch (FORWRD(NORET)) { 1237 case 1: 1238 BRANCH(COMP3) 1239 } 1240 if (D_A(BRTYPE) != EOSTYP) 1241 goto L_CMPILM; 1242 D_A(CMOFCL) += DESCR; 1243 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(GOTOCL); 1244 D_A(CMOFCL) += DESCR; 1245 D(SRNCL) = D(CMOFCL); 1246 D_V(CSTNCL) = D_A(CMOFCL); 1247 D(D_A(CMBSCL) + D_A(FRNCL)) = D(CSTNCL); 1248 D_A(CMOFCL) += DESCR; 1249 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(GOGOCL); 1250 SAVSTK(); 1251 PUSH(FGOND); 1252 TREPUB(NORET); 1253 D(D_A(CMBSCL) + D_A(SRNCL)) = D(CMOFCL); 1254 BRANCH(RTN3) 1255 /*_*/ 1256L_CMPILM: 1257 if (D_A(BRTYPE) != NBTYP) 1258 goto L_CERR11; 1259 switch (STREAM(XSP, TEXTSP, &GOTOTB)) { 1260 case ST_ERROR: 1261 goto L_CERR11; 1262 case ST_EOS: 1263 goto L_CERR12; 1264 } 1265 if (D_A(STYPE) != SGOTYP) 1266 goto L_CMPSTC; 1267 PUSH(GOTLCL); 1268 D_A(GOBRCL) = (int_t) RPTYP; 1269 goto L_CMPILN; 1270 /*_*/ 1271L_CMPSTC: 1272 if (D_A(STYPE) != STOTYP) 1273 goto L_CERR11; 1274 PUSH(GOTGCL); 1275 D_A(GOBRCL) = (int_t) RBTYP; 1276L_CMPILN: 1277 SAVSTK(); 1278 switch (EXPR(SGOND)) { 1279 case 1: 1280 goto L_CDIAG; 1281 } 1282 if (D_A(BRTYPE) != D_A(GOBRCL)) 1283 goto L_CERR11; 1284 SAVSTK(); 1285 switch (FORWRD(NORET)) { 1286 case 1: 1287 BRANCH(COMP3) 1288 } 1289 if (D_A(BRTYPE) != EOSTYP) 1290 goto L_CERR11; 1291 D_A(CMOFCL) += DESCR; 1292 POP(WCL); 1293 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(WCL); 1294 SAVSTK(); 1295 PUSH(SGOND); 1296 TREPUB(NORET); 1297 D_V(CSTNCL) = D_A(CMOFCL); 1298 D(D_A(CMBSCL) + D_A(FRNCL)) = D(CSTNCL); 1299 D_A(CMOFCL) += DESCR; 1300 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(GOGOCL); 1301 SAVSTK(); 1302 PUSH(FGOND); 1303 switch (TREPUB(NORET)) { 1304 case 1: 1305 BRANCH(RTN3) 1306 } 1307 /*_*/ 1308L_CERR1: 1309 D_A(EMSGCL) = (int_t) EMSG1; 1310 goto L_CDIAG; 1311 /*_*/ 1312L_CERR2: 1313 D_A(EMSGCL) = (int_t) EMSG2; 1314 goto L_CDIAG; 1315 /*_*/ 1316L_CERR3: 1317 D_A(EMSGCL) = (int_t) EMSG3; 1318 goto L_CDIAG; 1319 /*_*/ 1320L_CERR5: 1321 D_A(EMSGCL) = (int_t) ILLBRK; 1322 goto L_CDIAG; 1323 /*_*/ 1324L_CERR12: 1325 D_A(EMSGCL) = (int_t) ILLEOS; 1326 goto L_CDIAG; 1327 /*_*/ 1328L_CERR11: 1329 D_A(EMSGCL) = (int_t) EMSG14; 1330L_CDIAG: 1331 D_A(BOSCL) += DESCR; 1332 D(D_A(CMBSCL) + D_A(BOSCL)) = D(ERORCL); 1333 D_A(BOSCL) += DESCR; 1334 D(D_A(CMBSCL) + D_A(BOSCL)) = D(CSTNCL); 1335 D_A(BOSCL) += DESCR; 1336 D(D_A(CMBSCL) + D_A(BOSCL)) = D(LNNOCL); 1337 D_A(BOSCL) += DESCR; 1338 D(D_A(CMBSCL) + D_A(BOSCL)) = D(FILENM); 1339 D(CMOFCL) = D(BOSCL); 1340 D_A(ESAICL) += DESCR; 1341 if (D_A(ESAICL) > D_A(ESALIM)) 1342 BRANCH(COMP9) 1343 if (D_A(COMPCL) == 0) 1344 goto L_CDIAG4; 1345 { 1346 char *sp, *dp; /* src ptr, desr ptr [PLB40] */ 1347 int len; /* src char count [PLB40] */ 1348 sp = INBUF + STNOSZ; /* get start of statement buffer [PLB40] */ 1349 len = S_O(TEXTSP); /* number of spaces/tabs to skip [PLB77] */ 1350 S_L(ERRSP) = len + 1; /* set pointer line length [PLB77] */ 1351 dp = ERRBUF + STNOSZ; /* get start of marker buffer [PLB40] */ 1352 while (len-- > STNOSZ) { /* for all chars in statement [PLB77] */ 1353 if (*sp++ == '\t') /* if tab [PLB77] */ 1354 *dp++ = '\t'; /* put tab in errbuf [PLB40] */ 1355 else /* else [PLB40] */ 1356 *dp++ = ' '; /* put space [PLB40] */ 1357 } /* [PLB40] */ 1358 *dp++ = '^'; /* store pointer [PLB40] */ 1359 } 1360 IO_PRINT(IOKEY, ERRBLK, LNBFSP); 1361 IO_PRINT(IOKEY, ERRBLK, ERRSP); 1362 if (D_A(LISTCL) == 0) 1363 goto L_CDIAG2; 1364 IO_PRINT(IOKEY, OUTBLK, LNBFSP); 1365 IO_PRINT(IOKEY, OUTBLK, ERRSP); 1366L_CDIAG2: 1367 _SPEC(TSP) = _SPEC(D_A(EMSGCL)); 1368 S_L(CERRSP) = 0; 1369 X_LOCSP(XSP,FILENM); 1370 APDSP(CERRSP,XSP); 1371 APDSP(CERRSP,COLSP); 1372 INTSPC(XSP,LNNOCL); 1373 APDSP(CERRSP,XSP); 1374 APDSP(CERRSP,COLSP); 1375 APDSP(CERRSP,SPCSP); 1376 APDSP(CERRSP,STARSP); 1377 APDSP(CERRSP,TSP); 1378 if (D_A(LISTCL) == 0) 1379 goto L_CDIAG1; 1380 IO_PRINT(IOKEY, OUTBLK, CERRSP); 1381 IO_PRINT(IOKEY, OUTBLK, BLSP); 1382L_CDIAG1: 1383 IO_PRINT(IOKEY, ERRBLK, CERRSP); 1384 IO_PRINT(IOKEY, ERRBLK, BLSP); 1385L_CDIAG4: 1386 SAVSTK(); 1387 PUSH(EMSGCL); 1388 GENVAR(ERRTXT); 1389 if (D_A(UNIT) == 0) 1390 BRANCH(RTN1) 1391 if (D_A(BRTYPE) == EOSTYP) 1392 BRANCH(RTN3) 1393 switch (STREAM(XSP, TEXTSP, &EOSTB)) { 1394 case ST_ERROR: 1395 BRANCH(COMP3) 1396 case ST_STOP: 1397 BRANCH(RTN3) 1398 } 1399L_DIAGRN: 1400 _SPEC(TEXTSP) = _SPEC(NEXTSP); 1401 switch (IO_READ(UNIT, TEXTSP)) { 1402 case IO_EOF: 1403 goto L_DIAGIN; 1404 case IO_ERR: 1405 BRANCH(COMP1) 1406 } 1407 D_A(TMVAL) = S_L(TEXTSP); 1408 D_F(TMVAL) = D_V(TMVAL) = 0; 1409 D_A(TMVAL) += STNOSZ; 1410 S_L(LNBFSP) = D_A(TMVAL); 1411 D_A(LNNOCL) += 1; 1412 switch (STREAM(XSP, TEXTSP, &CARDTB)) { 1413 case ST_ERROR: 1414 BRANCH(COMP3) 1415 case ST_EOS: 1416 goto L_CDIAG7; 1417 } 1418 SAVSTK(); 1419 switch (NEWCRD(NORET)) { 1420 case 3: 1421 BRANCH(RTN3) 1422 } 1423L_CDIAG7: 1424 if (D_A(LISTCL) == 0) 1425 goto L_DIAGRN; 1426 IO_PRINT(IOKEY, OUTBLK, LNBFSP); 1427 goto L_DIAGRN; 1428 /*_*/ 1429L_DIAGIN: 1430 SAVSTK(); 1431 FILCHK(NORET); 1432 goto L_DIAGRN; 1433 /*_*/ 1434} 1435static int 1436ELEMNT(retval) 1437 ret_t retval; 1438{ 1439 ENTRY(ELEMNT) 1440 SAVSTK(); 1441 switch (UNOP(ELEMND)) { 1442 case 1: 1443 BRANCH(RTN2) 1444 } 1445 switch (STREAM(XSP, TEXTSP, &ELEMTB)) { 1446 case ST_ERROR: 1447 BRANCH(ELEICH) 1448 case ST_EOS: 1449 BRANCH(ELEILI) 1450 } 1451 /* FALL */ 1452 BRANCH(ELEMN9) 1453} 1454static int 1455ELEMN9(retval) 1456 ret_t retval; 1457{ 1458 ENTRY(ELEMN9) 1459 switch (D_A(STYPE)) { 1460 case 2: 1461 goto L_ELEILT; 1462 case 3: 1463 goto L_ELEVBL; 1464 case 4: 1465 goto L_ELENST; 1466 case 5: 1467 goto L_ELEFNC; 1468 case 6: 1469 goto L_ELEFLT; 1470 case 7: 1471 goto L_ELEARY; 1472 } 1473 S_L(XSP) -= 1; 1474 S_O(XSP) += 1; 1475 S_L(XSP) -= 1; 1476 SAVSTK(); 1477 PUSH(XSPPTR); 1478 GENVAR(XPTR); 1479L_ELEMN5: 1480 SAVSTK(); 1481 PUSH(CNDSIZ); 1482 BLOCK(ELEXND); 1483 D(D_A(ELEXND) + CODE) = D(LITCL); 1484 SAVSTK(); 1485 PUSH(CNDSIZ); 1486 BLOCK(ELEYND); 1487 D(D_A(ELEYND) + CODE) = D(XPTR); 1488 ADDSON(ELEXND,ELEYND); 1489L_ELEMN1: 1490 if (D_A(ELEMND) != 0) 1491 goto L_ELEMN6; 1492 D(ZPTR) = D(ELEXND); 1493 goto L_ELEMRR; 1494 /*_*/ 1495L_ELEMN6: 1496 ADDSON(ELEMND,ELEXND); 1497L_ELEMNR: 1498 D(ZPTR) = D(ELEMND); 1499L_ELEMRR: 1500 if (D_A(D_A(ZPTR) + FATHER) == (int_t)0) 1501 goto L_ELEM10; 1502 D(ZPTR) = D(D_A(ZPTR) + FATHER); 1503 goto L_ELEMRR; 1504 /*_*/ 1505L_ELEM10: 1506 switch (STREAM(XSP, TEXTSP, &GOTSTB)) { 1507 case ST_ERROR: 1508 case ST_EOS: 1509 BRANCH(RTZPTR) 1510 } 1511 if (D_A(STYPE) == SGOTYP) 1512 BRANCH(ELECMA) 1513 D(ELEMND) = D(ZEROCL); 1514 D(ELEXND) = D(ZPTR); 1515 goto L_ELEAR2; 1516 /*_*/ 1517L_ELEILT: 1518 if (SPCINT(XPTR,XSP)) 1519 goto L_ELEMN5; 1520 else 1521 BRANCH(ELEINT) 1522 /*_*/ 1523L_ELEFLT: 1524 if (SPREAL(XPTR,XSP)) 1525 goto L_ELEMN5; 1526 else 1527 BRANCH(ELEDEC) 1528 /*_*/ 1529L_ELEVBL: 1530 SAVSTK(); 1531 PUSH(XSPPTR); 1532 GENVUP(XPTR); 1533 SAVSTK(); 1534 PUSH(CNDSIZ); 1535 BLOCK(ELEXND); 1536 D(D_A(ELEXND) + CODE) = D(XPTR); 1537 goto L_ELEMN1; 1538 /*_*/ 1539L_ELENST: 1540 PUSH(ELEMND); 1541 SAVSTK(); 1542 switch (EXPR(ELEXND)) { 1543 case 1: 1544 BRANCH(RTN1) 1545 } 1546 POP(ELEMND); 1547 if (D_A(BRTYPE) == RPTYP) 1548 goto L_ELEMN1; 1549 if (D_A(SPITCL) == 0) 1550 BRANCH(ELECMA) 1551 if (D_A(BRTYPE) != CMATYP) 1552 BRANCH(ELECMA) 1553 SAVSTK(); 1554 PUSH(CMACL); 1555 switch (ELEARG(NORET)) { 1556 case 1: 1557 BRANCH(RTN1) 1558 } 1559 if (D_A(BRTYPE) == RPTYP) 1560 goto L_ELEMNR; 1561 else 1562 BRANCH(ELECMA) 1563 /*_*/ 1564L_ELEFNC: 1565 S_L(XSP) -= 1; 1566 SAVSTK(); 1567 PUSH(XSPPTR); 1568 GENVUP(XPTR); 1569 SAVSTK(); 1570 PUSH(XPTR); 1571 FINDEX(XCL); 1572 SAVSTK(); 1573 PUSH(CNDSIZ); 1574 BLOCK(ELEXND); 1575 D(D_A(ELEXND) + CODE) = D(XCL); 1576 if (D_A(ELEMND) == 0) 1577 goto L_ELEMN7; 1578 ADDSON(ELEMND,ELEXND); 1579L_ELEMN7: 1580 PUSH(ELEXND); 1581 SAVSTK(); 1582 switch (EXPR(ELEXND)) { 1583 case 1: 1584 BRANCH(RTN1) 1585 } 1586 POP(ELEMND); 1587 ADDSON(ELEMND,ELEXND); 1588 D(ELEMND) = D(ELEXND); 1589L_ELEMN2: 1590 if (D_A(BRTYPE) == RPTYP) 1591 goto L_ELEMN3; 1592 if (D_A(BRTYPE) != CMATYP) 1593 BRANCH(ELECMA) 1594 PUSH(ELEMND); 1595 SAVSTK(); 1596 switch (EXPR(ELEXND)) { 1597 case 1: 1598 BRANCH(RTN1) 1599 } 1600 POP(ELEMND); 1601 ADDSIB(ELEMND,ELEXND); 1602 D(ELEMND) = D(ELEXND); 1603 goto L_ELEMN2; 1604 /*_*/ 1605L_ELEMN3: 1606 D(ELEXND) = D(D_A(ELEMND) + FATHER); 1607 D(XCL) = D(D_A(ELEXND) + CODE); 1608 D(YCL) = D(D_A(XCL)); 1609 if ((D_F(YCL) & FNC)) 1610 goto L_ELEMNR; 1611 D_A(XCL) = D_V(XCL); 1612 D_F(XCL) = D_V(XCL) = 0; 1613 D_A(YCL) = D_V(YCL); 1614 D_F(YCL) = D_V(YCL) = 0; 1615L_ELEMN4: 1616 if (D_A(XCL) >= D_A(YCL)) 1617 goto L_ELEMNR; 1618 SAVSTK(); 1619 PUSH(CNDSIZ); 1620 BLOCK(ELEYND); 1621 D(D_A(ELEYND) + CODE) = D(LITCL); 1622 SAVSTK(); 1623 PUSH(CNDSIZ); 1624 BLOCK(ELEXND); 1625 D(D_A(ELEXND) + CODE) = D(NULVCL); 1626 ADDSON(ELEYND,ELEXND); 1627 ADDSIB(ELEMND,ELEYND); 1628 D(ELEMND) = D(ELEYND); 1629 D_A(XCL) += 1; 1630 goto L_ELEMN4; 1631 /*_*/ 1632L_ELEARY: 1633 S_L(XSP) -= 1; 1634 SAVSTK(); 1635 PUSH(XSPPTR); 1636 GENVUP(XPTR); 1637 SAVSTK(); 1638 PUSH(CNDSIZ); 1639 BLOCK(ELEXND); 1640 D(D_A(ELEXND) + CODE) = D(XPTR); 1641L_ELEAR2: 1642 SAVSTK(); 1643 PUSH(ITEMCL); 1644 switch (ELEARG(NORET)) { 1645 case 1: 1646 BRANCH(RTN1) 1647 } 1648 if (D_A(BRTYPE) == RBTYP) 1649 goto L_ELEMNR; 1650 else 1651 BRANCH(ELECMA) 1652 /*_*/ 1653} 1654static int 1655ELEARG(retval) 1656 ret_t retval; 1657{ 1658 ENTRY(ELEARG) 1659 POP(XCL); 1660 SAVSTK(); 1661 PUSH(CNDSIZ); 1662 BLOCK(XPTR); 1663 D(D_A(XPTR) + CODE) = D(XCL); 1664 if (D_A(ELEMND) == 0) 1665 goto L_ELEMN8; 1666 ADDSON(ELEMND,XPTR); 1667L_ELEMN8: 1668 ADDSON(XPTR,ELEXND); 1669 D(ELEMND) = D(ELEXND); 1670L_ELEAR1: 1671 PUSH(ELEMND); 1672 SAVSTK(); 1673 switch (EXPR(ELEXND)) { 1674 case 1: 1675 BRANCH(RTN1) 1676 } 1677 POP(ELEMND); 1678 ADDSIB(ELEMND,ELEXND); 1679 D(ELEMND) = D(ELEXND); 1680 if (D_A(BRTYPE) == CMATYP) 1681 goto L_ELEAR1; 1682 else 1683 BRANCH(RTN2) 1684 /*_*/ 1685} 1686static int 1687ELEICH(retval) 1688 ret_t retval; 1689{ 1690 ENTRY(ELEICH) 1691 D_A(EMSGCL) = (int_t) ILCHAR; 1692 BRANCH(RTN1) 1693 /*_*/ 1694} 1695static int 1696ELEILI(retval) 1697 ret_t retval; 1698{ 1699 ENTRY(ELEILI) 1700 if (D_A(STYPE) == 0) 1701 BRANCH(ELEICH) 1702 if (D_A(STYPE) != QLITYP) 1703 BRANCH(ELEMN9) 1704 D_A(EMSGCL) = (int_t) OPNLIT; 1705 BRANCH(RTN1) 1706 /*_*/ 1707} 1708static int 1709ELEINT(retval) 1710 ret_t retval; 1711{ 1712 ENTRY(ELEINT) 1713 D_A(EMSGCL) = (int_t) ILLINT; 1714 BRANCH(RTN1) 1715 /*_*/ 1716} 1717static int 1718ELEDEC(retval) 1719 ret_t retval; 1720{ 1721 ENTRY(ELEDEC) 1722 D_A(EMSGCL) = (int_t) ILLDEC; 1723 BRANCH(RTN1) 1724 /*_*/ 1725} 1726static int 1727ELECMA(retval) 1728 ret_t retval; 1729{ 1730 ENTRY(ELECMA) 1731 D_A(EMSGCL) = (int_t) ILLBRK; 1732 BRANCH(RTN1) 1733 /*_*/ 1734} 1735static int 1736EXPR(retval) 1737 ret_t retval; 1738{ 1739 ENTRY(EXPR) 1740 SAVSTK(); 1741 switch (ELEMNT(EXELND)) { 1742 case 1: 1743 BRANCH(RTN1) 1744 case 2: 1745 goto L_EXPNUL; 1746 } 1747 D_A(EXPRND) = 0; 1748 BRANCH(EXPR2) 1749 /*_*/ 1750L_EXPNUL: 1751 SAVSTK(); 1752 switch (NULNOD(XPTR)) { 1753 case 1: 1754 BRANCH(RTXNAM) 1755 } 1756 /*_*/ 1757} 1758static int 1759EXPR1(retval) 1760 ret_t retval; 1761{ 1762 ENTRY(EXPR1) 1763 PUSH(EXPRND); 1764 SAVSTK(); 1765 switch (ELEMNT(EXELND)) { 1766 case 1: 1767 BRANCH(RTN1) 1768 case 2: 1769 goto L_EXPR12; 1770 } 1771 POP(EXPRND); 1772 BRANCH(EXPR2) 1773 /*_*/ 1774L_EXPR12: 1775 if (D_A(SPITCL) == 0) 1776 goto L_EXPERR; 1777 if (D_A(D_A(EXOPND) + CODE) == (int_t)BISRFN) 1778 goto L_EXPR17; 1779 if (D_A(D_A(EXOPND) + CODE) != (int_t)BIEQFN) 1780 goto L_EXPERR; 1781L_EXPR17: 1782 SAVSTK(); 1783 switch (NULNOD(EXELND)) { 1784 case 1: 1785 goto L_EXPR13; 1786 } 1787 /*_*/ 1788L_EXPR13: 1789 POP(EXPRND); 1790 BRANCH(EXPR7) 1791 /*_*/ 1792L_EXPERR: 1793 D_A(EMSGCL) = (int_t) ILLEOS; 1794 BRANCH(RTN1) 1795 /*_*/ 1796} 1797static int 1798EXPR2(retval) 1799 ret_t retval; 1800{ 1801 ENTRY(EXPR2) 1802 SAVSTK(); 1803 switch (BINOP(EXOPCL)) { 1804 case 1: 1805 BRANCH(RTN1) 1806 case 2: 1807 BRANCH(EXPR7) 1808 } 1809 if (D_A(SPITCL) == 0) 1810 goto L_EXPR14; 1811 if (D_A(EXOPCL) != D_A(ASGNCL)) 1812 goto L_EXPR14; 1813 if (D_A(EXPRND) == 0) 1814 goto L_EXPR14; 1815 D(EXOPND) = D(EXPRND); 1816L_EXPR15: 1817 D(EXEXND) = D(EXOPND); 1818 if (D_A(D_A(EXEXND) + FATHER) == (int_t)0) 1819 goto L_EXPR14; 1820 D(EXOPND) = D(D_A(EXEXND) + FATHER); 1821 if (D_A(D_A(EXOPND) + CODE) != (int_t)BISNFN) 1822 goto L_EXPR15; 1823 D_A(D_A(EXOPND) + CODE) = D_A(SJSRCL); 1824 ADDSIB(EXPRND,EXELND); 1825 D(EXPRND) = D(EXELND); 1826L_EXPR16: 1827 D(EXOPND) = D(D_A(EXPRND) + FATHER); 1828 if (D_A(D_A(EXOPND) + FATHER) == (int_t)0) 1829 BRANCH(EXPR1) 1830 D(EXPRND) = D(EXOPND); 1831 goto L_EXPR16; 1832 /*_*/ 1833L_EXPR14: 1834 SAVSTK(); 1835 PUSH(CNDSIZ); 1836 BLOCK(EXOPND); 1837 D(D_A(EXOPND) + CODE) = D(EXOPCL); 1838 if (D_A(EXPRND) != 0) 1839 goto L_EXPR3; 1840 ADDSON(EXOPND,EXELND); 1841 D(EXPRND) = D(EXELND); 1842 BRANCH(EXPR1) 1843 /*_*/ 1844L_EXPR3: 1845 D(EXOPCL) = D(D_A(EXOPCL) + 2*DESCR); 1846 D_A(EXOPCL) = D_V(EXOPCL); 1847 D_F(EXOPCL) = D_V(EXOPCL) = 0; 1848 D(EXEXND) = D(D_A(EXPRND) + FATHER); 1849 D(XPTR) = D(D_A(EXEXND) + CODE); 1850 D(XPTR) = D(D_A(XPTR) + 2*DESCR); 1851 if (D_A(XPTR) > D_A(EXOPCL)) 1852 goto L_EXPR4; 1853 ADDSIB(EXPRND,EXOPND); 1854 D(EXPRND) = D(EXOPND); 1855 ADDSON(EXPRND,EXELND); 1856 D(EXPRND) = D(EXELND); 1857 BRANCH(EXPR1) 1858 /*_*/ 1859L_EXPR4: 1860 ADDSIB(EXPRND,EXELND); 1861L_EXPR5: 1862 if (D_A(D_A(EXPRND) + FATHER) == (int_t)0) 1863 goto L_EXPR11; 1864 D(EXPRND) = D(D_A(EXPRND) + FATHER); 1865 if (D_A(D_A(EXPRND) + FATHER) == (int_t)0) 1866 goto L_EXPR11; 1867 D(EXEXND) = D(D_A(EXPRND) + FATHER); 1868 D(XPTR) = D(D_A(EXEXND) + CODE); 1869 D(XPTR) = D(D_A(XPTR) + 2*DESCR); 1870 if (D_A(XPTR) > D_A(EXOPCL)) 1871 goto L_EXPR5; 1872 INSERT(EXPRND,EXOPND); 1873 BRANCH(EXPR1) 1874 /*_*/ 1875L_EXPR11: 1876 ADDSON(EXOPND,EXPRND); 1877 BRANCH(EXPR1) 1878 /*_*/ 1879} 1880static int 1881EXPR7(retval) 1882 ret_t retval; 1883{ 1884 ENTRY(EXPR7) 1885 if (D_A(EXPRND) != 0) 1886 goto L_EXPR10; 1887 D(XPTR) = D(EXELND); 1888 goto L_EXPR9; 1889 /*_*/ 1890L_EXPR10: 1891 ADDSIB(EXPRND,EXELND); 1892 D(XPTR) = D(EXPRND); 1893L_EXPR9: 1894 if (D_A(D_A(XPTR) + FATHER) == (int_t)0) 1895 BRANCH(RTXNAM) 1896 D(XPTR) = D(D_A(XPTR) + FATHER); 1897 goto L_EXPR9; 1898 /*_*/ 1899} 1900static int 1901NULNOD(retval) 1902 ret_t retval; 1903{ 1904 ENTRY(NULNOD) 1905 SAVSTK(); 1906 PUSH(CNDSIZ); 1907 BLOCK(EXPRND); 1908 D(D_A(EXPRND) + CODE) = D(LITCL); 1909 SAVSTK(); 1910 PUSH(CNDSIZ); 1911 BLOCK(EXEXND); 1912 D(D_A(EXEXND) + CODE) = D(NULVCL); 1913 ADDSON(EXPRND,EXEXND); 1914 D(retval) = D(EXPRND); 1915 RETURN(1) 1916 /*_*/ 1917} 1918static int 1919FORWRD(retval) 1920 ret_t retval; 1921{ 1922 ENTRY(FORWRD) 1923 switch (STREAM(XSP, TEXTSP, &FRWDTB)) { 1924 case ST_ERROR: 1925 BRANCH(COMP3) 1926 case ST_EOS: 1927 BRANCH(FORRUN) 1928 } 1929 /* FALL */ 1930 BRANCH(FORJRN) 1931} 1932static int 1933FORJRN(retval) 1934 ret_t retval; 1935{ 1936 ENTRY(FORJRN) 1937 D(BRTYPE) = D(STYPE); 1938 BRANCH(RTN2) 1939 /*_*/ 1940} 1941static int 1942FORRUN(retval) 1943 ret_t retval; 1944{ 1945 ENTRY(FORRUN) 1946L_FORRN0: 1947 if (D_A(UNIT) == 0) 1948 goto L_FOREOS; 1949 if (D_A(LISTCL) == 0) 1950 goto L_FORRUR; 1951 IO_PRINT(IOKEY, OUTBLK, LNBFSP); 1952L_FORRUR: 1953 _SPEC(TEXTSP) = _SPEC(NEXTSP); 1954 switch (IO_READ(UNIT, TEXTSP)) { 1955 case IO_EOF: 1956 goto L_FORINC; 1957 case IO_ERR: 1958 BRANCH(COMP1) 1959 } 1960 D_A(TMVAL) = S_L(TEXTSP); 1961 D_F(TMVAL) = D_V(TMVAL) = 0; 1962 D_A(TMVAL) += STNOSZ; 1963 S_L(LNBFSP) = D_A(TMVAL); 1964 D_A(LNNOCL) += 1; 1965 switch (STREAM(XSP, TEXTSP, &CARDTB)) { 1966 case ST_ERROR: 1967 BRANCH(COMP3) 1968 case ST_EOS: 1969 goto L_FORRN0; 1970 } 1971 SAVSTK(); 1972 switch (NEWCRD(NORET)) { 1973 case 1: 1974 goto L_FORRN0; 1975 case 2: 1976 BRANCH(FORWRD) 1977 } 1978L_FOREOS: 1979 D(BRTYPE) = D(EOSCL); 1980 BRANCH(RTN2) 1981 /*_*/ 1982L_FORINC: 1983 SAVSTK(); 1984 FILCHK(NORET); 1985 goto L_FORRUR; 1986 /*_*/ 1987} 1988static int 1989FORBLK(retval) 1990 ret_t retval; 1991{ 1992 ENTRY(FORBLK) 1993 switch (STREAM(XSP, TEXTSP, &IBLKTB)) { 1994 case ST_ERROR: 1995 BRANCH(RTN1) 1996 case ST_EOS: 1997 BRANCH(FORRUN) 1998 case ST_STOP: 1999 BRANCH(FORJRN) 2000 } 2001 /*_*/ 2002} 2003static int 2004FILCHK(retval) 2005 ret_t retval; 2006{ 2007 ENTRY(FILCHK) 2008 if (D_A(INCSTK) == 0) 2009 goto L_FILCK2; 2010 D(LNNOCL) = D(D_A(INCSTK) + 2*DESCR); 2011 D(FILENM) = D(D_A(INCSTK) + 3*DESCR); 2012 D(INCSTK) = D(D_A(INCSTK) + DESCR); 2013 BRANCH(RTN2) 2014 /*_*/ 2015L_FILCK2: 2016 if (!IO_FILE(UNIT,XSP)) 2017 BRANCH(RTN1) 2018 SAVSTK(); 2019 PUSH(XSPPTR); 2020 GENVAR(FILENM); 2021 D_A(LNNOCL) = 0; 2022 BRANCH(RTN1) 2023 /*_*/ 2024} 2025static int 2026NEWCRD(retval) 2027 ret_t retval; 2028{ 2029 ENTRY(NEWCRD) 2030 switch (D_A(STYPE)) { 2031 case 2: 2032 goto L_CMTCRD; 2033 case 3: 2034 goto L_CTLCRD; 2035 case 4: 2036 goto L_CNTCRD; 2037 } 2038 if (D_A(LISTCL) == 0) 2039 BRANCH(RTN3) 2040 D(XCL) = D(CSTNCL); 2041 D_A(XCL) += 1; 2042 INTSPC(TSP,XCL); 2043 if (D_A(LLIST) != 0) 2044 goto L_CARDL; 2045 IO_PAD(LNBFSP,CARDSZ+DSTSZ); 2046 S_L(RNOSP) = 0; 2047 APDSP(RNOSP,TSP); 2048 BRANCH(RTN3) 2049 /*_*/ 2050L_CARDL: 2051 S_L(LNOSP) = 0; 2052 APDSP(LNOSP,TSP); 2053 BRANCH(RTN3) 2054 /*_*/ 2055L_CMTCRD: 2056 if (D_A(LISTCL) == 0) 2057 BRANCH(RTN1) 2058L_CMTCLR: 2059 S_L(LNOSP) = 0; 2060 S_L(RNOSP) = 0; 2061 APDSP(LNOSP,BLNSP); 2062 APDSP(RNOSP,BLNSP); 2063 BRANCH(RTN1) 2064 /*_*/ 2065L_CNTCRD: 2066 S_L(TEXTSP) -= 1; 2067 S_O(TEXTSP) += 1; 2068 if (D_A(LISTCL) == 0) 2069 BRANCH(RTN2) 2070 INTSPC(TSP,CSTNCL); 2071 if (D_A(LLIST) != 0) 2072 goto L_CARDLL; 2073 IO_PAD(LNBFSP,CARDSZ+DSTSZ); 2074 S_L(RNOSP) = 0; 2075 APDSP(RNOSP,TSP); 2076 BRANCH(RTN2) 2077 /*_*/ 2078L_CARDLL: 2079 S_L(LNOSP) = 0; 2080 APDSP(LNOSP,TSP); 2081 BRANCH(RTN2) 2082 /*_*/ 2083L_CTLCRD: 2084 S_L(TEXTSP) -= 1; 2085 S_O(TEXTSP) += 1; 2086 switch (STREAM(XSP, TEXTSP, &FRWDTB)) { 2087 case ST_ERROR: 2088 BRANCH(COMP3) 2089 case ST_EOS: 2090 goto L_CMTCRD; 2091 } 2092 if (D_A(STYPE) != NBTYP) 2093 goto L_CMTCRD; 2094 switch (STREAM(XSP, TEXTSP, &LBLXTB)) { 2095 case ST_ERROR: 2096 case ST_EOS: 2097 goto L_CMTCLR; 2098 } 2099 RAISE1(XSP); 2100 if (LEXEQ(XSP,UNLSP)) 2101 goto L_UNLIST; 2102 if (LEXEQ(XSP,LISTSP)) 2103 goto L_LIST; 2104 if (LEXEQ(XSP,EJCTSP)) 2105 goto L_EJECT; 2106 if (LEXEQ(XSP,ERORSP)) 2107 goto L_ERRORS; 2108 if (LEXEQ(XSP,NERRSP)) 2109 goto L_NOERRS; 2110 if (LEXEQ(XSP,CASESP)) 2111 goto L_CASE; 2112 if (LEXEQ(XSP,INCLSP)) 2113 goto L_INCLUD; 2114 if (LEXEQ(XSP,COPYSP)) 2115 goto L_INCLUD; 2116 if (LEXEQ(XSP,SPITSP)) 2117 goto L_PLSOPS; 2118 if (LEXEQ(XSP,EXECSP)) 2119 goto L_EXEC; 2120 if (LEXEQ(XSP,NEXESP)) 2121 goto L_NOEXEC; 2122 if (LEXEQ(XSP,LINESP)) 2123 goto L_LINE; 2124 goto L_CMTCLR; 2125 /*_*/ 2126L_UNLIST: 2127 D_A(LISTCL) = 0; 2128 BRANCH(RTN1) 2129 /*_*/ 2130L_LIST: 2131 D_A(LISTCL) = 1; 2132 switch (STREAM(XSP, TEXTSP, &FRWDTB)) { 2133 case ST_ERROR: 2134 BRANCH(COMP3) 2135 case ST_EOS: 2136 goto L_CMTCLR; 2137 } 2138 if (D_A(STYPE) != NBTYP) 2139 goto L_CMTCLR; 2140 switch (STREAM(XSP, TEXTSP, &LBLXTB)) { 2141 case ST_ERROR: 2142 case ST_EOS: 2143 goto L_CMTCLR; 2144 } 2145 RAISE1(XSP); 2146 if (!LEXEQ(XSP,LEFTSP)) 2147 goto L_CTLCR2; 2148 D_A(LLIST) = 1; 2149 goto L_CMTCLR; 2150 /*_*/ 2151L_CTLCR2: 2152 D_A(LLIST) = 0; 2153 goto L_CMTCLR; 2154 /*_*/ 2155L_EJECT: 2156 if (D_A(LISTCL) == 0) 2157 goto L_CMTCLR; 2158 io_printf(D_A(OUTPUT),EJECTF); 2159 goto L_CMTCLR; 2160 /*_*/ 2161L_ERRORS: 2162 D_A(NERRCL) = 0; 2163 goto L_CMTCLR; 2164 /*_*/ 2165L_NOERRS: 2166 D_A(NERRCL) = 1; 2167 goto L_CMTCLR; 2168 /*_*/ 2169L_CASE: 2170 switch (STREAM(XSP, TEXTSP, &FRWDTB)) { 2171 case ST_ERROR: 2172 BRANCH(COMP3) 2173 case ST_EOS: 2174 goto L_CASE1; 2175 } 2176 if (D_A(STYPE) != NBTYP) 2177 goto L_CMTCLR; 2178 switch (STREAM(XSP, TEXTSP, &ELEMTB)) { 2179 case ST_ERROR: 2180 case ST_EOS: 2181 goto L_CMTCLR; 2182 } 2183 if (D_A(STYPE) != ILITYP) 2184 goto L_CMTCLR; 2185 SPCINT(CASECL,XSP); 2186 goto L_CMTCLR; 2187 /*_*/ 2188L_CASE1: 2189 D_A(CASECL) = 0; 2190 goto L_CMTCLR; 2191 /*_*/ 2192L_INCLUD: 2193 SAVSTK(); 2194 switch (CTLADV(NORET)) { 2195 case 1: 2196 case 2: 2197 goto L_COMP10; 2198 } 2199 switch (IO_INCLUDE(UNIT, XSP)) { 2200 case INC_FAIL: 2201 goto L_COMP11; 2202 case INC_SKIP: 2203 goto L_CMTCLR; 2204 } 2205 TRIMSP(XSP,XSP); 2206 SAVSTK(); 2207 PUSH(INCLSZ); 2208 BLOCK(XCL); 2209 D(D_A(XCL) + DESCR) = D(INCSTK); 2210 D(D_A(XCL) + 2*DESCR) = D(LNNOCL); 2211 D(D_A(XCL) + 3*DESCR) = D(FILENM); 2212 D(INCSTK) = D(XCL); 2213 SAVSTK(); 2214 PUSH(XSPPTR); 2215 GENVAR(FILENM); 2216 D_A(LNNOCL) = 0; 2217 goto L_CMTCLR; 2218 /*_*/ 2219L_COMP10: 2220 D_A(ERRTYP) = 29; 2221 BRANCH(FTLEND) 2222 /*_*/ 2223L_COMP11: 2224 D_A(ERRTYP) = 30; 2225 BRANCH(FTLEND) 2226 /*_*/ 2227L_PLSOPS: 2228 switch (STREAM(XSP, TEXTSP, &FRWDTB)) { 2229 case ST_ERROR: 2230 BRANCH(COMP3) 2231 case ST_EOS: 2232 goto L_PLSOP2; 2233 } 2234 if (D_A(STYPE) != NBTYP) 2235 goto L_CMTCLR; 2236 switch (STREAM(XSP, TEXTSP, &INTGTB)) { 2237 case ST_ERROR: 2238 goto L_CMTCLR; 2239 case ST_EOS: 2240 goto L_PLSOP1; 2241 } 2242 if (D_A(STYPE) != ILITYP) 2243 goto L_CMTCLR; 2244L_PLSOP1: 2245 SPCINT(SPITCL,XSP); 2246 goto L_PLSOP3; 2247 /*_*/ 2248L_PLSOP2: 2249 D_A(SPITCL) = 0; 2250L_PLSOP3: 2251 goto L_CMTCLR; 2252 /*_*/ 2253L_EXEC: 2254 D_A(EXECCL) = 1; 2255 goto L_CMTCLR; 2256 /*_*/ 2257L_NOEXEC: 2258 D_A(EXECCL) = 0; 2259 goto L_CMTCLR; 2260 /*_*/ 2261L_LINE: 2262 switch (STREAM(XSP, TEXTSP, &FRWDTB)) { 2263 case ST_ERROR: 2264 BRANCH(COMP3) 2265 case ST_EOS: 2266 goto L_CMTCLR; 2267 } 2268 if (D_A(STYPE) != NBTYP) 2269 goto L_CMTCLR; 2270 switch (STREAM(XSP, TEXTSP, &INTGTB)) { 2271 case ST_ERROR: 2272 goto L_COMP12; 2273 case ST_EOS: 2274 goto L_LINE1; 2275 } 2276 if (D_A(STYPE) != ILITYP) 2277 goto L_COMP12; 2278L_LINE1: 2279 if (!SPCINT(LNNOCL,XSP)) 2280 goto L_COMP12; 2281 D_A(LNNOCL) -= 1; 2282 SAVSTK(); 2283 switch (CTLADV(NORET)) { 2284 case 1: 2285 goto L_CMTCLR; 2286 case 2: 2287 goto L_COMP12; 2288 } 2289 SAVSTK(); 2290 PUSH(XSPPTR); 2291 GENVAR(FILENM); 2292 goto L_CMTCLR; 2293 /*_*/ 2294L_COMP12: 2295 D_A(ERRTYP) = 31; 2296 BRANCH(FTLEND) 2297 /*_*/ 2298} 2299static int 2300CTLADV(retval) 2301 ret_t retval; 2302{ 2303 ENTRY(CTLADV) 2304 switch (STREAM(XSP, TEXTSP, &FRWDTB)) { 2305 case ST_ERROR: 2306 BRANCH(COMP3) 2307 case ST_EOS: 2308 BRANCH(RTN1) 2309 } 2310 if (D_A(STYPE) != NBTYP) 2311 BRANCH(RTN1) 2312 switch (STREAM(XSP, TEXTSP, &ELEMTB)) { 2313 case ST_ERROR: 2314 case ST_EOS: 2315 BRANCH(RTN2) 2316 } 2317 if (D_A(STYPE) != QLITYP) 2318 BRANCH(RTN2) 2319 S_L(XSP) -= 1; 2320 S_O(XSP) += 1; 2321 S_L(XSP) -= 1; 2322 BRANCH(RTN3) 2323 /*_*/ 2324} 2325static int 2326TREPUB(retval) 2327 ret_t retval; 2328{ 2329 ENTRY(TREPUB) 2330 POP(YPTR); 2331L_TREPU1: 2332 D(XPTR) = D(D_A(YPTR) + CODE); 2333 D_A(CMOFCL) += DESCR; 2334 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(XPTR); 2335 D(ZPTR) = D(CMBSCL); 2336 D_A(ZPTR) += D_A(CMOFCL); 2337 if (D_PTR(ZPTR) > D_PTR(OCLIM)) 2338 goto L_TREPU5; 2339L_TREPU4: 2340 if (D_A(D_A(YPTR) + LSON) == (int_t)0) 2341 goto L_TREPU2; 2342 D(YPTR) = D(D_A(YPTR) + LSON); 2343 goto L_TREPU1; 2344 /*_*/ 2345L_TREPU2: 2346 if (D_A(D_A(YPTR) + RSIB) == (int_t)0) 2347 goto L_TREPU3; 2348 D(YPTR) = D(D_A(YPTR) + RSIB); 2349 goto L_TREPU1; 2350 /*_*/ 2351L_TREPU3: 2352 if (D_A(D_A(YPTR) + FATHER) == (int_t)0) 2353 BRANCH(RTN1) 2354 D(YPTR) = D(D_A(YPTR) + FATHER); 2355 goto L_TREPU2; 2356 /*_*/ 2357L_TREPU5: 2358 D(ZPTR) = D(CMOFCL); 2359 D_A(ZPTR) += D_A(CODELT); 2360 D_V(ZPTR) = C; 2361 SAVSTK(); 2362 PUSH(ZPTR); 2363 BLOCK(XCL); 2364 if (D_A(LPTR) == 0) 2365 goto L_TREPU6; 2366 D(D_A(LPTR) + ATTRIB) = D(XCL); 2367L_TREPU6: 2368 MOVBLK(D_A(XCL),D_A(CMBSCL),D_A(CMOFCL)); 2369 D(D_A(CMBSCL) + DESCR) = D(GOTGCL); 2370 D(D_A(CMBSCL) + 2*DESCR) = D(LIT1CL); 2371 D(D_A(CMBSCL) + 3*DESCR) = D(XCL); 2372 D_A(CMBSCL) += 3*DESCR; 2373 SAVSTK(); 2374 PUSH(CMBSCL); 2375 SPLIT(NORET); 2376 D(CMBSCL) = D(XCL); 2377 D(OCLIM) = D(CMBSCL); 2378 D_A(OCLIM) += D_A(ZPTR); 2379 D_A(OCLIM) -= 7*DESCR; 2380 goto L_TREPU4; 2381 /*_*/ 2382} 2383static int 2384UNOP(retval) 2385 ret_t retval; 2386{ 2387 ENTRY(UNOP) 2388 SAVSTK(); 2389 switch (FORWRD(NORET)) { 2390 case 1: 2391 BRANCH(COMP3) 2392 } 2393 D_A(XPTR) = 0; 2394 if (D_A(BRTYPE) != NBTYP) 2395 BRANCH(RTN1) 2396L_UNOPA: 2397 switch (STREAM(XSP, TEXTSP, &UNOPTB)) { 2398 case ST_ERROR: 2399 case ST_EOS: 2400 BRANCH(RTXNAM) 2401 } 2402 SAVSTK(); 2403 PUSH(CNDSIZ); 2404 BLOCK(YPTR); 2405 D(D_A(YPTR) + CODE) = D(STYPE); 2406 if (D_A(XPTR) == 0) 2407 goto L_UNOPB; 2408 ADDSON(XPTR,YPTR); 2409L_UNOPB: 2410 D(XPTR) = D(YPTR); 2411 goto L_UNOPA; 2412 /*_*/ 2413} 2414int 2415BASE(retval) 2416 ret_t retval; 2417{ 2418 ENTRY(BASE) 2419 D_A(OCBSCL) += D_A(OCICL); 2420 D_A(OCICL) = 0; 2421 BRANCH(RTNUL3) 2422 /*_*/ 2423} 2424int 2425GOTG(retval) 2426 ret_t retval; 2427{ 2428 ENTRY(GOTG) 2429 SAVSTK(); 2430 switch (ARGVAL(OCBSCL)) { 2431 case 1: 2432 BRANCH(INTR5) 2433 } 2434 if (D_V(OCBSCL) != C) 2435 BRANCH(INTR4) 2436 D_A(OCICL) = 0; 2437 BRANCH(RTNUL3) 2438 /*_*/ 2439} 2440int 2441GOTL(retval) 2442 ret_t retval; 2443{ 2444 ENTRY(GOTL) 2445 D_A(OCICL) += DESCR; 2446 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 2447 if ((D_F(XPTR) & FNC)) 2448 goto L_GOTLC; 2449L_GOTLV: 2450 if (D_A(TRAPCL) <= 0) 2451 goto L_GOTLV1; 2452 if (!LOCAPT(ATPTR,TLABL,XPTR)) 2453 goto L_GOTLV1; 2454 PUSH(XPTR); 2455 SAVSTK(); 2456 PUSH(ATPTR); 2457 TRPHND(NORET); 2458 POP(XPTR); 2459L_GOTLV1: 2460 if (!DCMP(XPTR, RETCL)) 2461 goto L_GOTL1; 2462 RETURN(6) 2463 /*_*/ 2464L_GOTL1: 2465 if (!DCMP(XPTR, FRETCL)) 2466 goto L_GOTL2; 2467 RETURN(4) 2468 /*_*/ 2469L_GOTL2: 2470 if (!DCMP(XPTR, NRETCL)) 2471 goto L_GOTL3; 2472 RETURN(5) 2473 /*_*/ 2474L_GOTL3: 2475 if (!DCMP(XPTR, ABORCL)) 2476 goto L_GOTL4; 2477 if (D_A(XOCBSC) == 0) 2478 BRANCH(CNTERR) 2479 D(ERRTYP) = D(XERRTY); 2480 D(FILENM) = D(XFILEN); 2481 D(STNOCL) = D(XSTNOC); 2482 BRANCH(FTLEND) 2483 /*_*/ 2484L_GOTL4: 2485 if (!DCMP(XPTR, SCNTCL)) 2486 goto L_GOTL5; 2487 D(FRTNCL) = D(XOCICL); 2488 goto L_GOTL5B; 2489 /*_*/ 2490L_GOTL5: 2491 if (!DCMP(XPTR, CONTCL)) 2492 goto L_GOTL6; 2493 D(FRTNCL) = D(XFRTNC); 2494L_GOTL5B: 2495 if (D_A(XOCBSC) == 0) 2496 BRANCH(CNTERR) 2497 D(OCBSCL) = D(XOCBSC); 2498 D(ERRTYP) = D(XERRTY); 2499 D(FILENM) = D(XFILEN); 2500 D(LNNOCL) = D(XLNNOC); 2501 D(STNOCL) = D(XSTNOC); 2502 D(LSFLNM) = D(XLSFLN); 2503 D(LSLNCL) = D(XLSLNC); 2504 D(LSTNCL) = D(XLNNOC); 2505 D_A(XOCBSC) = 0; 2506 BRANCH(FAIL) 2507 /*_*/ 2508L_GOTL6: 2509 D(OCBSCL) = D(D_A(XPTR) + ATTRIB); 2510 if (D_A(OCBSCL) == 0) 2511 BRANCH(INTR4) 2512 D_A(OCICL) = 0; 2513 BRANCH(RTNUL3) 2514 /*_*/ 2515L_GOTLC: 2516 SAVSTK(); 2517 PUSH(XPTR); 2518 switch (INVOKE(XPTR)) { 2519 case 1: 2520 BRANCH(INTR5) 2521 case 3: 2522 BRANCH(INTR4) 2523 } 2524 if (D_V(XPTR) == S) 2525 goto L_GOTLV; 2526 else 2527 BRANCH(INTR4) 2528 /*_*/ 2529} 2530int 2531GOTO(retval) 2532 ret_t retval; 2533{ 2534 ENTRY(GOTO) 2535 D_A(OCICL) += DESCR; 2536 D(OCICL) = D(D_A(OCBSCL) + D_A(OCICL)); 2537 BRANCH(RTNUL3) 2538 /*_*/ 2539} 2540int 2541INIT(retval) 2542 ret_t retval; 2543{ 2544 ENTRY(INIT) 2545 D(LSTNCL) = D(STNOCL); 2546 D_A(OCICL) += DESCR; 2547 D(XCL) = D(D_A(OCBSCL) + D_A(OCICL)); 2548 D_A(STNOCL) = D_A(XCL); 2549 D_A(FRTNCL) = D_V(XCL); 2550 D_F(FRTNCL) = D_V(FRTNCL) = 0; 2551 D_A(LSLNCL) = D_A(LNNOCL); 2552 D_A(OCICL) += DESCR; 2553 D(LNNOCL) = D(D_A(OCBSCL) + D_A(OCICL)); 2554 D_A(LSFLNM) = D_A(FILENM); 2555 D_A(OCICL) += DESCR; 2556 D(FILENM) = D(D_A(OCBSCL) + D_A(OCICL)); 2557 D_A(EXN2CL) += 1; 2558 if (D_A(EXLMCL) < 0) 2559 BRANCH(RTNUL3) 2560 if (D_A(EXNOCL) >= D_A(EXLMCL)) 2561 BRANCH(EXEX) 2562 D_A(EXNOCL) += 1; 2563 if (D_A(TRAPCL) <= 0) 2564 BRANCH(RTNUL3) 2565 if (!LOCAPT(ATPTR,TKEYL,STCTKY)) 2566 BRANCH(RTNUL3) 2567 SAVSTK(); 2568 PUSH(ATPTR); 2569 TRPHND(NORET); 2570 BRANCH(RTNUL3) 2571 /*_*/ 2572} 2573static int 2574INTERP(retval) 2575 ret_t retval; 2576{ 2577 ENTRY(INTERP) 2578L_INTRP0: 2579 D_A(OCICL) += DESCR; 2580 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 2581 if (!(D_F(XPTR) & FNC)) 2582 goto L_INTRP0; 2583 SAVSTK(); 2584 PUSH(XPTR); 2585 switch (INVOKE(XPTR)) { 2586 case 2: 2587 case 3: 2588 goto L_INTRP0; 2589 case 4: 2590 BRANCH(RTN1) 2591 case 5: 2592 BRANCH(RTN2) 2593 case 6: 2594 BRANCH(RTN3) 2595 } 2596 D(OCICL) = D(FRTNCL); 2597 D_A(FALCL) += 1; 2598 if (D_A(TRAPCL) <= 0) 2599 goto L_INTRP0; 2600 if (!LOCAPT(ATPTR,TKEYL,FALKY)) 2601 goto L_INTRP0; 2602 SAVSTK(); 2603 PUSH(ATPTR); 2604 TRPHND(NORET); 2605 goto L_INTRP0; 2606 /*_*/ 2607} 2608static int 2609INVOKE(retval) 2610 ret_t retval; 2611{ 2612 ENTRY(INVOKE) 2613 POP(INCL); 2614 D(XPTR) = D(D_A(INCL)); 2615 if (D_V(INCL) != D_V(XPTR)) 2616 goto L_INVK2; 2617L_INVK1: 2618 BRANCH( ((func_t) (D_A(D_A(INCL))))) 2619 /*_*/ 2620L_INVK2: 2621 if ((D_F(XPTR) & FNC)) 2622 goto L_INVK1; 2623 else 2624 BRANCH(ARGNER) 2625 /*_*/ 2626} 2627static int 2628ARGVAL(retval) 2629 ret_t retval; 2630{ 2631 ENTRY(ARGVAL) 2632 D_A(OCICL) += DESCR; 2633 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 2634 if ((D_F(XPTR) & FNC)) 2635 goto L_ARGVC; 2636L_ARGV1: 2637 if (D_A(INSW) == 0) 2638 goto L_ARGV2; 2639 if (!LOCAPV(ZPTR,INATL,XPTR)) 2640 goto L_ARGV2; 2641 D(ZPTR) = D(D_A(ZPTR) + DESCR); 2642 SAVSTK(); 2643 PUSH(XPTR); 2644 PUSH(ZPTR); 2645 switch (PUTIN(XPTR)) { 2646 case 1: 2647 BRANCH(FAIL) 2648 case 2: 2649 BRANCH(RTXNAM) 2650 } 2651 /*_*/ 2652L_ARGVC: 2653 SAVSTK(); 2654 PUSH(XPTR); 2655 switch (INVOKE(XPTR)) { 2656 case 1: 2657 BRANCH(FAIL) 2658 case 2: 2659 goto L_ARGV1; 2660 case 3: 2661 BRANCH(RTXNAM) 2662 } 2663 /*_*/ 2664L_ARGV2: 2665 D(XPTR) = D(D_A(XPTR) + DESCR); 2666 BRANCH(RTXNAM) 2667 /*_*/ 2668} 2669static int 2670EXPVAL(retval) 2671 ret_t retval; 2672{ 2673 ENTRY(EXPVAL) 2674 D_A(SCL) = 1; 2675 /* FALL */ 2676 BRANCH(EXPVJN) 2677} 2678static int 2679EXPVJN(retval) 2680 ret_t retval; 2681{ 2682 ENTRY(EXPVJN) 2683 POP(XPTR); 2684 /* FALL */ 2685 BRANCH(EXPVJ2) 2686} 2687static int 2688EXPVJ2(retval) 2689 ret_t retval; 2690{ 2691 ENTRY(EXPVJ2) 2692 PUSH(OCBSCL); 2693 PUSH(OCICL); 2694 PUSH(PATBCL); 2695 PUSH(PATICL); 2696 PUSH(WPTR); 2697 PUSH(XCL); 2698 PUSH(YCL); 2699 PUSH(TCL); 2700 PUSH(MAXLEN); 2701 PUSH(LENFCL); 2702 PUSH(PDLPTR); 2703 PUSH(PDLHED); 2704 PUSH(NAMICL); 2705 PUSH(NHEDCL); 2706 SPUSH(HEADSP); 2707 SPUSH(TSP); 2708 SPUSH(TXSP); 2709 SPUSH(XSP); 2710 D(OCBSCL) = D(XPTR); 2711 D_A(OCICL) = (int_t) DESCR; 2712 D(PDLHED) = D(PDLPTR); 2713 D(NHEDCL) = D(NAMICL); 2714 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 2715 if ((D_F(XPTR) & FNC)) 2716 goto L_EXPVC; 2717L_EXPV11: 2718 if (D_A(SCL) == 0) 2719 goto L_EXPV6; 2720 if (D_A(INSW) == 0) 2721 goto L_EXPV4; 2722 if (!LOCAPV(ZPTR,INATL,XPTR)) 2723 goto L_EXPV4; 2724 D(ZPTR) = D(D_A(ZPTR) + DESCR); 2725 SAVSTK(); 2726 PUSH(XPTR); 2727 PUSH(ZPTR); 2728 switch (PUTIN(XPTR)) { 2729 case 1: 2730 goto L_EXPV1; 2731 case 2: 2732 goto L_EXPV6; 2733 } 2734 /*_*/ 2735L_EXPV4: 2736 D(XPTR) = D(D_A(XPTR) + DESCR); 2737L_EXPV6: 2738 D_A(SCL) = 2; 2739 goto L_EXPV7; 2740 /*_*/ 2741L_EXPV9: 2742 POP(SCL); 2743L_EXPV1: 2744 D_A(SCL) = 1; 2745L_EXPV7: 2746 SPOP(XSP); 2747 SPOP(TXSP); 2748 SPOP(TSP); 2749 SPOP(HEADSP); 2750 POP(NHEDCL); 2751 POP(NAMICL); 2752 POP(PDLHED); 2753 POP(PDLPTR); 2754 POP(LENFCL); 2755 POP(MAXLEN); 2756 POP(TCL); 2757 POP(YCL); 2758 POP(XCL); 2759 POP(WPTR); 2760 POP(PATICL); 2761 POP(PATBCL); 2762 POP(OCICL); 2763 POP(OCBSCL); 2764 switch (D_A(SCL)) { 2765 case 1: 2766 BRANCH(FAIL) 2767 case 2: 2768 BRANCH(RTXNAM) 2769 case 3: 2770 BRANCH(RTZPTR) 2771 } 2772 /*_*/ 2773L_EXPVC: 2774 PUSH(SCL); 2775 SAVSTK(); 2776 PUSH(XPTR); 2777 switch (INVOKE(XPTR)) { 2778 case 1: 2779 goto L_EXPV9; 2780 case 2: 2781 goto L_EXPV5; 2782 } 2783 POP(SCL); 2784 if (D_A(SCL) != 0) 2785 goto L_EXPV6; 2786 D_A(SCL) = 3; 2787 D(ZPTR) = D(XPTR); 2788 goto L_EXPV7; 2789 /*_*/ 2790L_EXPV5: 2791 POP(SCL); 2792 goto L_EXPV11; 2793 /*_*/ 2794} 2795static int 2796EXPEVL(retval) 2797 ret_t retval; 2798{ 2799 ENTRY(EXPEVL) 2800 D_A(SCL) = 0; 2801 BRANCH(EXPVJN) 2802 /*_*/ 2803} 2804int 2805EVAL(retval) 2806 ret_t retval; 2807{ 2808 ENTRY(EVAL) 2809 SAVSTK(); 2810 switch (ARGVAL(XPTR)) { 2811 case 1: 2812 BRANCH(FAIL) 2813 } 2814 if (D_V(XPTR) == E) 2815 goto L_EVAL1; 2816 if (D_V(XPTR) == I) 2817 BRANCH(RTXPTR) 2818 if (D_V(XPTR) == R) 2819 BRANCH(RTXPTR) 2820 if (D_V(XPTR) != S) 2821 BRANCH(INTR1) 2822 X_LOCSP(XSP,XPTR); 2823 if (S_L(XSP) == 0) 2824 BRANCH(RTXPTR) 2825 if (SPCINT(XPTR,XSP)) 2826 BRANCH(RTXPTR) 2827 if (SPREAL(XPTR,XSP)) 2828 BRANCH(RTXPTR) 2829 D(ZPTR) = D(XPTR); 2830 SAVSTK(); 2831 switch (CONVE(XPTR)) { 2832 case 1: 2833 BRANCH(FAIL) 2834 case 2: 2835 BRANCH(INTR10) 2836 } 2837L_EVAL1: 2838 D_A(SCL) = 0; 2839 BRANCH(EXPVJ2) 2840 /*_*/ 2841} 2842static int 2843INTVAL(retval) 2844 ret_t retval; 2845{ 2846 ENTRY(INTVAL) 2847 D_A(OCICL) += DESCR; 2848 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 2849 if ((D_F(XPTR) & FNC)) 2850 goto L_INTVC; 2851L_INTV1: 2852 if (D_A(INSW) == 0) 2853 goto L_INTV3; 2854 if (!LOCAPV(ZPTR,INATL,XPTR)) 2855 goto L_INTV3; 2856 D(ZPTR) = D(D_A(ZPTR) + DESCR); 2857 SAVSTK(); 2858 PUSH(XPTR); 2859 PUSH(ZPTR); 2860 switch (PUTIN(XPTR)) { 2861 case 1: 2862 BRANCH(FAIL) 2863 } 2864L_INTV: 2865 X_LOCSP(XSP,XPTR); 2866 if (SPCINT(XPTR,XSP)) 2867 BRANCH(RTXNAM) 2868 if (!SPREAL(XPTR,XSP)) 2869 BRANCH(INTR1) 2870L_INTRI: 2871 CLR_MATH_ERROR(); 2872 D_A(XPTR) = (int_t) D_RV(XPTR); 2873 D_F(XPTR) = 0; 2874 D_V(XPTR) = I; 2875 if (MATH_ERROR()) 2876 BRANCH(INTR1) 2877 BRANCH(RTXNAM) 2878 /*_*/ 2879L_INTV3: 2880 D(XPTR) = D(D_A(XPTR) + DESCR); 2881L_INTV2: 2882 if (D_V(XPTR) == I) 2883 BRANCH(RTXNAM) 2884 if (D_V(XPTR) == R) 2885 goto L_INTRI; 2886 if (D_V(XPTR) == S) 2887 goto L_INTV; 2888 else 2889 BRANCH(INTR1) 2890 /*_*/ 2891L_INTVC: 2892 SAVSTK(); 2893 PUSH(XPTR); 2894 switch (INVOKE(XPTR)) { 2895 case 1: 2896 BRANCH(FAIL) 2897 case 2: 2898 goto L_INTV1; 2899 case 3: 2900 goto L_INTV2; 2901 } 2902 /*_*/ 2903} 2904static int 2905PATVAL(retval) 2906 ret_t retval; 2907{ 2908 ENTRY(PATVAL) 2909 D_A(OCICL) += DESCR; 2910 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 2911 if ((D_F(XPTR) & FNC)) 2912 goto L_PATVC; 2913L_PATV1: 2914 if (D_A(INSW) == 0) 2915 goto L_PATV2; 2916 if (!LOCAPV(ZPTR,INATL,XPTR)) 2917 goto L_PATV2; 2918 D(ZPTR) = D(D_A(ZPTR) + DESCR); 2919 SAVSTK(); 2920 PUSH(XPTR); 2921 PUSH(ZPTR); 2922 switch (PUTIN(XPTR)) { 2923 case 1: 2924 BRANCH(FAIL) 2925 case 2: 2926 BRANCH(RTXNAM) 2927 } 2928 /*_*/ 2929L_PATVC: 2930 SAVSTK(); 2931 PUSH(XPTR); 2932 switch (INVOKE(XPTR)) { 2933 case 1: 2934 BRANCH(FAIL) 2935 case 2: 2936 goto L_PATV1; 2937 case 3: 2938 goto L_PATV3; 2939 } 2940 /*_*/ 2941L_PATV2: 2942 D(XPTR) = D(D_A(XPTR) + DESCR); 2943L_PATV3: 2944 if (D_V(XPTR) == P) 2945 BRANCH(RTXNAM) 2946 if (D_V(XPTR) == S) 2947 BRANCH(RTXNAM) 2948 if (D_V(XPTR) == I) 2949 BRANCH(GENVIX) 2950 if (D_V(XPTR) == R) 2951 goto L_PATVR; 2952 if (D_V(XPTR) != E) 2953 BRANCH(INTR1) 2954 SAVSTK(); 2955 PUSH(STARSZ); 2956 BLOCK(TPTR); 2957 MOVBLK(D_A(TPTR),D_A(STRPAT),D_A(STARSZ)); 2958 D(D_A(TPTR) + 4*DESCR) = D(XPTR); 2959 D(XPTR) = D(TPTR); 2960 BRANCH(RTXNAM) 2961 /*_*/ 2962L_PATVR: 2963 REALST(XSP,XPTR); 2964 SAVSTK(); 2965 PUSH(XSPPTR); 2966 switch (GENVAR(XPTR)) { 2967 case 1: 2968 BRANCH(RTXNAM) 2969 } 2970 /*_*/ 2971} 2972static int 2973VARVAL(retval) 2974 ret_t retval; 2975{ 2976 ENTRY(VARVAL) 2977 D_A(OCICL) += DESCR; 2978 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 2979 if ((D_F(XPTR) & FNC)) 2980 goto L_VARVC; 2981L_VARV1: 2982 if (D_A(INSW) == 0) 2983 goto L_VARV4; 2984 if (!LOCAPV(ZPTR,INATL,XPTR)) 2985 goto L_VARV4; 2986 D(ZPTR) = D(D_A(ZPTR) + DESCR); 2987 SAVSTK(); 2988 PUSH(XPTR); 2989 PUSH(ZPTR); 2990 switch (PUTIN(XPTR)) { 2991 case 1: 2992 BRANCH(FAIL) 2993 case 2: 2994 BRANCH(RTXNAM) 2995 } 2996 /*_*/ 2997L_VARV4: 2998 D(XPTR) = D(D_A(XPTR) + DESCR); 2999L_VARV2: 3000 if (D_V(XPTR) == S) 3001 BRANCH(RTXNAM) 3002 if (D_V(XPTR) == I) 3003 BRANCH(GENVIX) 3004 else 3005 BRANCH(INTR1) 3006 /*_*/ 3007L_VARVC: 3008 SAVSTK(); 3009 PUSH(XPTR); 3010 switch (INVOKE(XPTR)) { 3011 case 1: 3012 BRANCH(FAIL) 3013 case 2: 3014 goto L_VARV1; 3015 case 3: 3016 goto L_VARV2; 3017 } 3018 /*_*/ 3019} 3020static int 3021VARVUP(retval) 3022 ret_t retval; 3023{ 3024 ENTRY(VARVUP) 3025 SAVSTK(); 3026 switch (VARVAL(NORET)) { 3027 case 1: 3028 BRANCH(FAIL) 3029 } 3030 if (D_A(CASECL) == 0) 3031 BRANCH(RTXNAM) 3032 else 3033 BRANCH(VPXPTR) 3034 /*_*/ 3035} 3036static int 3037VPXPTR(retval) 3038 ret_t retval; 3039{ 3040 ENTRY(VPXPTR) 3041 X_LOCSP(SPECR1,XPTR); 3042 if (S_L(SPECR1) == 0) 3043 BRANCH(RTXNAM) 3044 D_A(AXPTR) = S_L(SPECR1); 3045 D_F(AXPTR) = D_V(AXPTR) = 0; 3046 SAVSTK(); 3047 PUSH(AXPTR); 3048 CONVAR(NORET); 3049 X_LOCSP(XSP,FRSGPT); 3050 if (!RAISE2(SPECR1,XSP)) 3051 BRANCH(RTXNAM) 3052 D(D_A(FRSGPT) + DESCR) = D(D_A(XPTR) + DESCR); 3053 D(D_A(FRSGPT) + ATTRIB) = D(D_A(XPTR) + ATTRIB); 3054 SAVSTK(); 3055 PUSH(AXPTR); 3056 switch (GNVARS(XPTR)) { 3057 case 1: 3058 BRANCH(RTXNAM) 3059 } 3060 BRANCH(RTXNAM) 3061 /*_*/ 3062} 3063static int 3064XYARGS(retval) 3065 ret_t retval; 3066{ 3067 ENTRY(XYARGS) 3068 D_A(SCL) = 0; 3069L_XYN: 3070 D_A(OCICL) += DESCR; 3071 D(YPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 3072 if ((D_F(YPTR) & FNC)) 3073 goto L_XYC; 3074L_XY1: 3075 if (D_A(INSW) == 0) 3076 goto L_XY2; 3077 if (!LOCAPV(ZPTR,INATL,YPTR)) 3078 goto L_XY2; 3079 D(ZPTR) = D(D_A(ZPTR) + DESCR); 3080 SAVSTK(); 3081 PUSH(YPTR); 3082 PUSH(ZPTR); 3083 switch (PUTIN(YPTR)) { 3084 case 1: 3085 BRANCH(FAIL) 3086 } 3087L_XY3: 3088 if (D_A(SCL) != 0) 3089 BRANCH(RTN2) 3090 D_A(SCL) = 1; 3091 D(XPTR) = D(YPTR); 3092 goto L_XYN; 3093 /*_*/ 3094L_XY2: 3095 D(YPTR) = D(D_A(YPTR) + DESCR); 3096 goto L_XY3; 3097 /*_*/ 3098L_XYC: 3099 PUSH(SCL); 3100 PUSH(XPTR); 3101 SAVSTK(); 3102 PUSH(YPTR); 3103 switch (INVOKE(YPTR)) { 3104 case 1: 3105 BRANCH(FAIL) 3106 case 2: 3107 goto L_XY4; 3108 } 3109 POP(XPTR); 3110 POP(SCL); 3111 goto L_XY3; 3112 /*_*/ 3113L_XY4: 3114 POP(XPTR); 3115 POP(SCL); 3116 goto L_XY1; 3117 /*_*/ 3118} 3119int 3120ADD(retval) 3121 ret_t retval; 3122{ 3123 ENTRY(ADD) 3124 D_A(SCL) = 1; 3125 BRANCH(ARITH) 3126 /*_*/ 3127} 3128int 3129DIV(retval) 3130 ret_t retval; 3131{ 3132 ENTRY(DIV) 3133 D_A(SCL) = 2; 3134 BRANCH(ARITH) 3135 /*_*/ 3136} 3137int 3138EXPOP(retval) 3139 ret_t retval; 3140{ 3141 ENTRY(EXPOP) 3142 D_A(SCL) = 3; 3143 BRANCH(ARITH) 3144 /*_*/ 3145} 3146int 3147MPY(retval) 3148 ret_t retval; 3149{ 3150 ENTRY(MPY) 3151 D_A(SCL) = 4; 3152 BRANCH(ARITH) 3153 /*_*/ 3154} 3155int 3156SUB(retval) 3157 ret_t retval; 3158{ 3159 ENTRY(SUB) 3160 D_A(SCL) = 5; 3161 BRANCH(ARITH) 3162 /*_*/ 3163} 3164int 3165EQ(retval) 3166 ret_t retval; 3167{ 3168 ENTRY(EQ) 3169 D_A(SCL) = 6; 3170 BRANCH(ARITH) 3171 /*_*/ 3172} 3173int 3174GE(retval) 3175 ret_t retval; 3176{ 3177 ENTRY(GE) 3178 D_A(SCL) = 7; 3179 BRANCH(ARITH) 3180 /*_*/ 3181} 3182int 3183GT(retval) 3184 ret_t retval; 3185{ 3186 ENTRY(GT) 3187 D_A(SCL) = 8; 3188 BRANCH(ARITH) 3189 /*_*/ 3190} 3191int 3192LE(retval) 3193 ret_t retval; 3194{ 3195 ENTRY(LE) 3196 D_A(SCL) = 9; 3197 BRANCH(ARITH) 3198 /*_*/ 3199} 3200int 3201LT(retval) 3202 ret_t retval; 3203{ 3204 ENTRY(LT) 3205 D_A(SCL) = 10; 3206 BRANCH(ARITH) 3207 /*_*/ 3208} 3209int 3210NE(retval) 3211 ret_t retval; 3212{ 3213 ENTRY(NE) 3214 D_A(SCL) = 11; 3215 BRANCH(ARITH) 3216 /*_*/ 3217} 3218int 3219REMDR(retval) 3220 ret_t retval; 3221{ 3222 ENTRY(REMDR) 3223 D_A(SCL) = 12; 3224 BRANCH(ARITH) 3225 /*_*/ 3226} 3227static int 3228ARITH(retval) 3229 ret_t retval; 3230{ 3231 ENTRY(ARITH) 3232 PUSH(SCL); 3233 SAVSTK(); 3234 switch (XYARGS(NORET)) { 3235 case 1: 3236 BRANCH(FAIL) 3237 } 3238 POP(SCL); 3239 D_A(DTCL) = D_V(XPTR); 3240 D_F(DTCL) = D_V(DTCL) = 0; 3241 D_V(DTCL) = D_V(YPTR); 3242 if (DCMP(DTCL, IIDTP)) 3243 goto L_ARTHII; 3244 if (DCMP(DTCL, IVDTP)) 3245 goto L_ARTHIV; 3246 if (DCMP(DTCL, VIDTP)) 3247 goto L_ARTHVI; 3248 if (DCMP(DTCL, VVDTP)) 3249 goto L_ARTHVV; 3250 if (DCMP(DTCL, RRDTP)) 3251 goto L_ARTHRR; 3252 if (DCMP(DTCL, IRDTP)) 3253 goto L_ARTHIR; 3254 if (DCMP(DTCL, RIDTP)) 3255 goto L_ARTHRI; 3256 if (DCMP(DTCL, VRDTP)) 3257 goto L_ARTHVR; 3258 if (DCMP(DTCL, RVDTP)) 3259 goto L_ARTHRV; 3260 else 3261 BRANCH(INTR1) 3262 /*_*/ 3263L_ARTHII: 3264 switch (D_A(SCL)) { 3265 case 1: 3266 goto L_AD; 3267 case 2: 3268 goto L_DV; 3269 case 3: 3270 goto L_EX; 3271 case 4: 3272 goto L_MP; 3273 case 5: 3274 goto L_SB; 3275 case 6: 3276 goto L_CEQ; 3277 case 7: 3278 goto L_CGE; 3279 case 8: 3280 goto L_CGT; 3281 case 9: 3282 goto L_CLE; 3283 case 10: 3284 goto L_CLT; 3285 case 11: 3286 goto L_CNE; 3287 case 12: 3288 goto L_RM; 3289 } 3290 /*_*/ 3291L_ARTHVI: 3292 X_LOCSP(XSP,XPTR); 3293 if (SPCINT(XPTR,XSP)) 3294 goto L_ARTHII; 3295 if (SPREAL(XPTR,XSP)) 3296 goto L_ARTHRI; 3297 else 3298 BRANCH(INTR1) 3299 /*_*/ 3300L_ARTHIV: 3301 X_LOCSP(YSP,YPTR); 3302 if (SPCINT(YPTR,YSP)) 3303 goto L_ARTHII; 3304 if (SPREAL(YPTR,YSP)) 3305 goto L_ARTHIR; 3306 else 3307 BRANCH(INTR1) 3308 /*_*/ 3309L_ARTHVV: 3310 X_LOCSP(XSP,XPTR); 3311 if (SPCINT(XPTR,XSP)) 3312 goto L_ARTHIV; 3313 if (SPREAL(XPTR,XSP)) 3314 goto L_ARTHRV; 3315 else 3316 BRANCH(INTR1) 3317 /*_*/ 3318L_ARTHRR: 3319 switch (D_A(SCL)) { 3320 case 1: 3321 goto L_AR; 3322 case 2: 3323 goto L_DR; 3324 case 3: 3325 goto L_EXR; 3326 case 4: 3327 goto L_MR; 3328 case 5: 3329 goto L_SR; 3330 case 6: 3331 goto L_REQ; 3332 case 7: 3333 goto L_RGE; 3334 case 8: 3335 goto L_RGT; 3336 case 9: 3337 goto L_RLE; 3338 case 10: 3339 goto L_RLT; 3340 case 11: 3341 goto L_RNE; 3342 case 12: 3343 BRANCH(INTR1) 3344 } 3345 /*_*/ 3346L_ARTHIR: 3347 D_RV(XPTR) = (real_t)D_A(XPTR); 3348 D_F(XPTR) = 0; 3349 D_V(XPTR) = R; 3350 goto L_ARTHRR; 3351 /*_*/ 3352L_ARTHRI: 3353 D_RV(YPTR) = (real_t)D_A(YPTR); 3354 D_F(YPTR) = 0; 3355 D_V(YPTR) = R; 3356 goto L_ARTHRR; 3357 /*_*/ 3358L_ARTHVR: 3359 X_LOCSP(XSP,XPTR); 3360 if (SPCINT(XPTR,XSP)) 3361 goto L_ARTHIR; 3362 if (SPREAL(XPTR,XSP)) 3363 goto L_ARTHRR; 3364 else 3365 BRANCH(INTR1) 3366 /*_*/ 3367L_ARTHRV: 3368 X_LOCSP(YSP,YPTR); 3369 if (SPCINT(YPTR,YSP)) 3370 goto L_ARTHRI; 3371 if (SPREAL(YPTR,YSP)) 3372 goto L_ARTHRR; 3373 else 3374 BRANCH(INTR1) 3375 /*_*/ 3376L_AD: 3377 CLR_MATH_ERROR(); 3378 D(ZPTR) = D(XPTR); 3379 D_A(ZPTR) += D_A(YPTR); 3380 if (MATH_ERROR()) 3381 BRANCH(AERROR) 3382 BRANCH(ARTN) 3383 /*_*/ 3384L_DV: 3385 if (D_A(YPTR) == 0) 3386 BRANCH(AERROR) 3387 CLR_MATH_ERROR(); 3388 D(ZPTR) = D(XPTR); 3389 D_A(ZPTR) /= D_A(YPTR); 3390 if (MATH_ERROR()) 3391 BRANCH(AERROR) 3392 BRANCH(ARTN) 3393 /*_*/ 3394L_EX: 3395 if (EXPINT(ZPTR,XPTR,YPTR)) 3396 BRANCH(ARTN) 3397 else 3398 BRANCH(AERROR) 3399 /*_*/ 3400L_MP: 3401 CLR_MATH_ERROR(); 3402 D(ZPTR) = D(XPTR); 3403 D_A(ZPTR) *= D_A(YPTR); 3404 if (MATH_ERROR()) 3405 BRANCH(AERROR) 3406 BRANCH(ARTN) 3407 /*_*/ 3408L_SB: 3409 CLR_MATH_ERROR(); 3410 D(ZPTR) = D(XPTR); 3411 D_A(ZPTR) -= D_A(YPTR); 3412 if (MATH_ERROR()) 3413 BRANCH(AERROR) 3414 BRANCH(ARTN) 3415 /*_*/ 3416L_CEQ: 3417 if (D_A(XPTR) == D_A(YPTR)) 3418 BRANCH(RETNUL) 3419 else 3420 BRANCH(FAIL) 3421 /*_*/ 3422L_CGE: 3423 if (D_A(XPTR) < D_A(YPTR)) 3424 BRANCH(FAIL) 3425 else 3426 BRANCH(RETNUL) 3427 /*_*/ 3428L_CGT: 3429 if (D_A(XPTR) <= D_A(YPTR)) 3430 BRANCH(FAIL) 3431 else 3432 BRANCH(RETNUL) 3433 /*_*/ 3434L_CLE: 3435 if (D_A(XPTR) <= D_A(YPTR)) 3436 BRANCH(RETNUL) 3437 else 3438 BRANCH(FAIL) 3439 /*_*/ 3440L_CLT: 3441 if (D_A(XPTR) < D_A(YPTR)) 3442 BRANCH(RETNUL) 3443 else 3444 BRANCH(FAIL) 3445 /*_*/ 3446L_CNE: 3447 if (D_A(XPTR) == D_A(YPTR)) 3448 BRANCH(FAIL) 3449 else 3450 BRANCH(RETNUL) 3451 /*_*/ 3452L_AR: 3453 CLR_MATH_ERROR(); 3454 D(ZPTR) = D(XPTR); 3455 D_RV(ZPTR) += D_RV(YPTR); 3456 if (RMATH_ERROR(D_RV(ZPTR))) 3457 BRANCH(AERROR) 3458 BRANCH(ARTN) 3459 /*_*/ 3460L_DR: 3461 CLR_MATH_ERROR(); 3462 D(ZPTR) = D(XPTR); 3463 D_RV(ZPTR) /= D_RV(YPTR); 3464 if (RMATH_ERROR(D_RV(ZPTR))) 3465 BRANCH(AERROR) 3466 BRANCH(ARTN) 3467 /*_*/ 3468L_EXR: 3469 if (EXREAL(ZPTR,XPTR,YPTR)) 3470 BRANCH(ARTN) 3471 else 3472 BRANCH(AERROR) 3473 /*_*/ 3474L_MR: 3475 CLR_MATH_ERROR(); 3476 D(ZPTR) = D(XPTR); 3477 D_RV(ZPTR) *= D_RV(YPTR); 3478 if (RMATH_ERROR(D_RV(ZPTR))) 3479 BRANCH(AERROR) 3480 BRANCH(ARTN) 3481 /*_*/ 3482L_SR: 3483 CLR_MATH_ERROR(); 3484 D(ZPTR) = D(XPTR); 3485 D_RV(ZPTR) -= D_RV(YPTR); 3486 if (RMATH_ERROR(D_RV(ZPTR))) 3487 BRANCH(AERROR) 3488 BRANCH(ARTN) 3489 /*_*/ 3490L_REQ: 3491 if (D_RV(XPTR) == D_RV(YPTR)) 3492 BRANCH(RETNUL) 3493 else 3494 BRANCH(FAIL) 3495 /*_*/ 3496L_RGE: 3497 if (D_RV(XPTR) < D_RV(YPTR)) 3498 BRANCH(FAIL) 3499 else 3500 BRANCH(RETNUL) 3501 /*_*/ 3502L_RGT: 3503 if (D_RV(XPTR) <= D_RV(YPTR)) 3504 BRANCH(FAIL) 3505 else 3506 BRANCH(RETNUL) 3507 /*_*/ 3508L_RLE: 3509 if (D_RV(XPTR) <= D_RV(YPTR)) 3510 BRANCH(RETNUL) 3511 else 3512 BRANCH(FAIL) 3513 /*_*/ 3514L_RLT: 3515 if (D_RV(XPTR) < D_RV(YPTR)) 3516 BRANCH(RETNUL) 3517 else 3518 BRANCH(FAIL) 3519 /*_*/ 3520L_RNE: 3521 if (D_RV(XPTR) == D_RV(YPTR)) 3522 BRANCH(FAIL) 3523 else 3524 BRANCH(RETNUL) 3525 /*_*/ 3526L_RM: 3527 if (D_A(YPTR) == 0) 3528 BRANCH(AERROR) 3529 CLR_MATH_ERROR(); 3530 D(ZPTR) = D(XPTR); 3531 D_A(ZPTR) /= D_A(YPTR); 3532 if (MATH_ERROR()) 3533 BRANCH(AERROR) 3534 D(WPTR) = D(ZPTR); 3535 D_A(WPTR) *= D_A(YPTR); 3536 D(ZPTR) = D(XPTR); 3537 D_A(ZPTR) -= D_A(WPTR); 3538 BRANCH(ARTN) 3539 /*_*/ 3540} 3541int 3542INTGER(retval) 3543 ret_t retval; 3544{ 3545 ENTRY(INTGER) 3546 SAVSTK(); 3547 switch (ARGVAL(XPTR)) { 3548 case 1: 3549 BRANCH(FAIL) 3550 } 3551 if (D_V(XPTR) == I) 3552 BRANCH(RETNUL) 3553 if (D_V(XPTR) != S) 3554 BRANCH(FAIL) 3555 X_LOCSP(XSP,XPTR); 3556 if (SPCINT(XPTR,XSP)) 3557 BRANCH(RETNUL) 3558 else 3559 BRANCH(FAIL) 3560 /*_*/ 3561} 3562int 3563MNS(retval) 3564 ret_t retval; 3565{ 3566 ENTRY(MNS) 3567 SAVSTK(); 3568 switch (ARGVAL(XPTR)) { 3569 case 1: 3570 BRANCH(FAIL) 3571 } 3572 if (D_V(XPTR) == I) 3573 goto L_MNSM; 3574 if (D_V(XPTR) == S) 3575 goto L_MNSV; 3576 if (D_V(XPTR) == R) 3577 goto L_MNSR; 3578 else 3579 BRANCH(INTR1) 3580 /*_*/ 3581L_MNSM: 3582 CLR_MATH_ERROR(); 3583 D(ZPTR) = D(XPTR); 3584 D_A(ZPTR) = -D_A(ZPTR); 3585 if (MATH_ERROR()) 3586 BRANCH(AERROR) 3587 BRANCH(ARTN) 3588 /*_*/ 3589L_MNSV: 3590 X_LOCSP(XSP,XPTR); 3591 if (SPCINT(XPTR,XSP)) 3592 goto L_MNSM; 3593 if (!SPREAL(XPTR,XSP)) 3594 BRANCH(INTR1) 3595L_MNSR: 3596 D(ZPTR) = D(XPTR); 3597 D_RV(ZPTR) = -D_RV(ZPTR); 3598 BRANCH(ARTN) 3599 /*_*/ 3600} 3601int 3602PLS(retval) 3603 ret_t retval; 3604{ 3605 ENTRY(PLS) 3606 SAVSTK(); 3607 switch (ARGVAL(ZPTR)) { 3608 case 1: 3609 BRANCH(FAIL) 3610 } 3611 if (D_V(ZPTR) == I) 3612 BRANCH(ARTN) 3613 if (D_V(ZPTR) == S) 3614 goto L_PLSV; 3615 if (D_V(ZPTR) == R) 3616 BRANCH(ARTN) 3617 else 3618 BRANCH(INTR1) 3619 /*_*/ 3620L_PLSV: 3621 X_LOCSP(XSP,ZPTR); 3622 if (SPCINT(ZPTR,XSP)) 3623 BRANCH(ARTN) 3624 if (SPREAL(ZPTR,XSP)) 3625 BRANCH(ARTN) 3626 else 3627 BRANCH(INTR1) 3628 /*_*/ 3629} 3630int 3631ANY(retval) 3632 ret_t retval; 3633{ 3634 ENTRY(ANY) 3635 PUSH(ANYCCL); 3636 BRANCH(CHARZ) 3637 /*_*/ 3638} 3639int 3640BREAKX(retval) 3641 ret_t retval; 3642{ 3643 ENTRY(BREAKX) 3644 PUSH(BRXCCL); 3645 PUSH(ZEROCL); 3646 BRANCH(ABNSND) 3647 /*_*/ 3648} 3649int 3650BREAK(retval) 3651 ret_t retval; 3652{ 3653 ENTRY(BREAK) 3654 PUSH(BRKCCL); 3655 PUSH(ZEROCL); 3656 BRANCH(ABNSND) 3657 /*_*/ 3658} 3659int 3660NOTANY(retval) 3661 ret_t retval; 3662{ 3663 ENTRY(NOTANY) 3664 PUSH(NNYCCL); 3665 BRANCH(CHARZ) 3666 /*_*/ 3667} 3668int 3669SPAN(retval) 3670 ret_t retval; 3671{ 3672 ENTRY(SPAN) 3673 PUSH(SPNCCL); 3674 /* FALL */ 3675 BRANCH(CHARZ) 3676} 3677static int 3678CHARZ(retval) 3679 ret_t retval; 3680{ 3681 ENTRY(CHARZ) 3682 PUSH(CHARCL); 3683 /* FALL */ 3684 BRANCH(ABNSND) 3685} 3686static int 3687ABNSND(retval) 3688 ret_t retval; 3689{ 3690 ENTRY(ABNSND) 3691 SAVSTK(); 3692 switch (ARGVAL(XPTR)) { 3693 case 1: 3694 BRANCH(FAIL) 3695 } 3696 POP(ZCL); 3697 POP(YCL); 3698 if (D_V(XPTR) == S) 3699 BRANCH(PATNOD) 3700 if (D_V(XPTR) == E) 3701 BRANCH(PATNOD) 3702 if (D_V(XPTR) != I) 3703 BRANCH(INTR1) 3704 SAVSTK(); 3705 PUSH(XPTR); 3706 GNVARI(XPTR); 3707 /* FALL */ 3708 BRANCH(PATNOD) 3709} 3710static int 3711PATNOD(retval) 3712 ret_t retval; 3713{ 3714 ENTRY(PATNOD) 3715 if (DCMP(XPTR, NULVCL)) 3716 BRANCH(NONAME) 3717 SAVSTK(); 3718 PUSH(LNODSZ); 3719 BLOCK(TPTR); 3720 MAKNOD(ZPTR,TPTR,ZCL,ZEROCL,YCL,XPTR); 3721 BRANCH(RTZPTR) 3722 /*_*/ 3723} 3724int 3725LEN(retval) 3726 ret_t retval; 3727{ 3728 ENTRY(LEN) 3729 PUSH(LNTHCL); 3730 BRANCH(LPRTND) 3731 /*_*/ 3732} 3733int 3734POS(retval) 3735 ret_t retval; 3736{ 3737 ENTRY(POS) 3738 PUSH(POSICL); 3739 BRANCH(LPRTND) 3740 /*_*/ 3741} 3742int 3743RPOS(retval) 3744 ret_t retval; 3745{ 3746 ENTRY(RPOS) 3747 PUSH(RPSICL); 3748 BRANCH(LPRTND) 3749 /*_*/ 3750} 3751int 3752RTAB(retval) 3753 ret_t retval; 3754{ 3755 ENTRY(RTAB) 3756 PUSH(RTBCL); 3757 BRANCH(LPRTND) 3758 /*_*/ 3759} 3760int 3761TAB(retval) 3762 ret_t retval; 3763{ 3764 ENTRY(TAB) 3765 PUSH(TBCL); 3766 /* FALL */ 3767 BRANCH(LPRTND) 3768} 3769static int 3770LPRTND(retval) 3771 ret_t retval; 3772{ 3773 ENTRY(LPRTND) 3774 SAVSTK(); 3775 switch (ARGVAL(XPTR)) { 3776 case 1: 3777 BRANCH(FAIL) 3778 } 3779 POP(YCL); 3780 D(ZCL) = D(ZEROCL); 3781 if (D_V(XPTR) == I) 3782 goto L_LPRTNI; 3783 if (D_V(XPTR) == E) 3784 BRANCH(PATNOD) 3785 if (D_V(XPTR) != S) 3786 BRANCH(INTR1) 3787 X_LOCSP(ZSP,XPTR); 3788 if (!SPCINT(XPTR,ZSP)) 3789 BRANCH(INTR1) 3790L_LPRTNI: 3791 if (D_A(XPTR) < 0) 3792 BRANCH(LENERR) 3793 if (!DCMP(YCL, LNTHCL)) 3794 BRANCH(PATNOD) 3795 D_A(ZCL) = D_A(XPTR); 3796 BRANCH(PATNOD) 3797 /*_*/ 3798} 3799int 3800ARBNO(retval) 3801 ret_t retval; 3802{ 3803 ENTRY(ARBNO) 3804 SAVSTK(); 3805 switch (PATVAL(XPTR)) { 3806 case 1: 3807 BRANCH(FAIL) 3808 } 3809 if (D_V(XPTR) == P) 3810 goto L_ARBP; 3811 if (D_V(XPTR) != S) 3812 BRANCH(INTR1) 3813 X_LOCSP(TSP,XPTR); 3814 D_A(TMVAL) = S_L(TSP); 3815 D_F(TMVAL) = D_V(TMVAL) = 0; 3816 SAVSTK(); 3817 PUSH(LNODSZ); 3818 BLOCK(TPTR); 3819 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR); 3820L_ARBP: 3821 D_A(XSIZ) = D_V(D_A(XPTR)); 3822 D_F(XSIZ) = D_V(XSIZ) = 0; 3823 D(TSIZ) = D(XSIZ); 3824 D_A(TSIZ) += D_A(ARBSIZ); 3825 D_V(TSIZ) = P; 3826 SAVSTK(); 3827 PUSH(TSIZ); 3828 BLOCK(TPTR); 3829 D(ZPTR) = D(TPTR); 3830 D_A(TSIZ) = D_V(D_A(ARHEAD)); 3831 D_F(TSIZ) = D_V(TSIZ) = 0; 3832 CPYPAT(TPTR,ARHEAD,ZEROCL,ZEROCL,ZEROCL,TSIZ); 3833 D(ZSIZ) = D(XSIZ); 3834 D_A(ZSIZ) += D_A(TSIZ); 3835 CPYPAT(TPTR,XPTR,ZEROCL,TSIZ,ZSIZ,XSIZ); 3836 D(TSIZ) = D(NODSIZ); 3837 D_A(TSIZ) += D_A(NODSIZ); 3838 CPYPAT(TPTR,ARTAIL,ZEROCL,ZSIZ,ZEROCL,TSIZ); 3839 D_A(ZSIZ) = D_A(TSIZ) + D_A(ZSIZ); 3840 D_F(ZSIZ) = D_F(TSIZ); 3841 D_V(ZSIZ) = D_V(TSIZ); 3842 CPYPAT(TPTR,ARBACK,ZEROCL,ZSIZ,TSIZ,TSIZ); 3843 BRANCH(RTZPTR) 3844 /*_*/ 3845} 3846int 3847ATOP(retval) 3848 ret_t retval; 3849{ 3850 ENTRY(ATOP) 3851 D_A(OCICL) += DESCR; 3852 D(YPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 3853 if (!(D_F(YPTR) & FNC)) 3854 goto L_ATOP1; 3855 SAVSTK(); 3856 PUSH(YPTR); 3857 switch (INVOKE(YPTR)) { 3858 case 1: 3859 BRANCH(FAIL) 3860 case 2: 3861 goto L_ATOP1; 3862 } 3863 if (D_V(YPTR) != E) 3864 BRANCH(NEMO) 3865L_ATOP1: 3866 SAVSTK(); 3867 PUSH(LNODSZ); 3868 BLOCK(TPTR); 3869 MAKNOD(ZPTR,TPTR,ZEROCL,ZEROCL,ATOPCL,YPTR); 3870 BRANCH(RTZPTR) 3871 /*_*/ 3872} 3873int 3874NAM(retval) 3875 ret_t retval; 3876{ 3877 ENTRY(NAM) 3878 PUSH(ENMECL); 3879 BRANCH(NAM5) 3880 /*_*/ 3881} 3882int 3883DOL(retval) 3884 ret_t retval; 3885{ 3886 ENTRY(DOL) 3887 PUSH(ENMICL); 3888 /* FALL */ 3889 BRANCH(NAM5) 3890} 3891static int 3892NAM5(retval) 3893 ret_t retval; 3894{ 3895 ENTRY(NAM5) 3896 SAVSTK(); 3897 switch (PATVAL(XPTR)) { 3898 case 1: 3899 BRANCH(FAIL) 3900 } 3901 D_A(OCICL) += DESCR; 3902 D(YPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 3903 if ((D_F(YPTR) & FNC)) 3904 goto L_NAMC2; 3905L_NAM3: 3906 if (D_V(XPTR) == S) 3907 goto L_NAMV; 3908 if (D_V(XPTR) == P) 3909 goto L_NAMP; 3910 else 3911 BRANCH(INTR1) 3912 /*_*/ 3913L_NAMC2: 3914 PUSH(XPTR); 3915 SAVSTK(); 3916 PUSH(YPTR); 3917 switch (INVOKE(YPTR)) { 3918 case 1: 3919 BRANCH(FAIL) 3920 case 2: 3921 goto L_NAM4; 3922 } 3923 if (D_V(YPTR) != E) 3924 BRANCH(NEMO) 3925L_NAM4: 3926 POP(XPTR); 3927 goto L_NAM3; 3928 /*_*/ 3929L_NAMV: 3930 X_LOCSP(TSP,XPTR); 3931 D_A(TMVAL) = S_L(TSP); 3932 D_F(TMVAL) = D_V(TMVAL) = 0; 3933 SAVSTK(); 3934 PUSH(LNODSZ); 3935 BLOCK(TPTR); 3936 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR); 3937L_NAMP: 3938 SAVSTK(); 3939 PUSH(SNODSZ); 3940 BLOCK(TPTR); 3941 MAKNOD(WPTR,TPTR,ZEROCL,ZEROCL,NMECL,NULL); 3942 SAVSTK(); 3943 PUSH(LNODSZ); 3944 BLOCK(TPTR); 3945 POP(TVAL); 3946 MAKNOD(YPTR,TPTR,ZEROCL,ZEROCL,TVAL,YPTR); 3947 D_A(XSIZ) = D_V(D_A(XPTR)); 3948 D_F(XSIZ) = D_V(XSIZ) = 0; 3949 D(YSIZ) = D(XSIZ); 3950 D_A(YSIZ) += D_A(NODSIZ); 3951 D_A(TSIZ) = D_V(D_A(YPTR)); 3952 D_F(TSIZ) = D_V(TSIZ) = 0; 3953 D(ZSIZ) = D(YSIZ); 3954 D_A(ZSIZ) += D_A(TSIZ); 3955 D_V(ZSIZ) = P; 3956 SAVSTK(); 3957 PUSH(ZSIZ); 3958 BLOCK(TPTR); 3959 D(ZPTR) = D(TPTR); 3960 LVALUE(TVAL,XPTR); 3961 CPYPAT(TPTR,WPTR,TVAL,ZEROCL,NODSIZ,NODSIZ); 3962 CPYPAT(TPTR,XPTR,ZEROCL,NODSIZ,YSIZ,XSIZ); 3963 CPYPAT(TPTR,YPTR,ZEROCL,YSIZ,ZEROCL,TSIZ); 3964 BRANCH(RTZPTR) 3965 /*_*/ 3966} 3967int 3968OR(retval) 3969 ret_t retval; 3970{ 3971 ENTRY(OR) 3972 SAVSTK(); 3973 switch (PATVAL(XPTR)) { 3974 case 1: 3975 BRANCH(FAIL) 3976 } 3977 PUSH(XPTR); 3978 SAVSTK(); 3979 switch (PATVAL(YPTR)) { 3980 case 1: 3981 BRANCH(FAIL) 3982 } 3983 POP(XPTR); 3984 D_A(DTCL) = D_V(XPTR); 3985 D_F(DTCL) = D_V(DTCL) = 0; 3986 D_V(DTCL) = D_V(YPTR); 3987 if (DCMP(DTCL, VVDTP)) 3988 goto L_ORVV; 3989 if (DCMP(DTCL, VPDTP)) 3990 goto L_ORVP; 3991 if (DCMP(DTCL, PVDTP)) 3992 goto L_ORPV; 3993 if (DCMP(DTCL, PPDTP)) 3994 goto L_ORPP; 3995 else 3996 BRANCH(INTR1) 3997 /*_*/ 3998L_ORVV: 3999 X_LOCSP(XSP,XPTR); 4000 D_A(TMVAL) = S_L(XSP); 4001 D_F(TMVAL) = D_V(TMVAL) = 0; 4002 SAVSTK(); 4003 PUSH(LNODSZ); 4004 BLOCK(TPTR); 4005 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR); 4006L_ORPV: 4007 X_LOCSP(YSP,YPTR); 4008 D_A(TMVAL) = S_L(YSP); 4009 D_F(TMVAL) = D_V(TMVAL) = 0; 4010 SAVSTK(); 4011 PUSH(LNODSZ); 4012 BLOCK(TPTR); 4013 MAKNOD(YPTR,TPTR,TMVAL,ZEROCL,CHRCL,YPTR); 4014L_ORPP: 4015 D_A(XSIZ) = D_V(D_A(XPTR)); 4016 D_F(XSIZ) = D_V(XSIZ) = 0; 4017 D_A(YSIZ) = D_V(D_A(YPTR)); 4018 D_F(YSIZ) = D_V(YSIZ) = 0; 4019 D(TSIZ) = D(XSIZ); 4020 D_A(TSIZ) += D_A(YSIZ); 4021 D_V(TSIZ) = P; 4022 SAVSTK(); 4023 PUSH(TSIZ); 4024 BLOCK(TPTR); 4025 D(ZPTR) = D(TPTR); 4026 CPYPAT(TPTR,XPTR,ZEROCL,ZEROCL,ZEROCL,XSIZ); 4027 CPYPAT(TPTR,YPTR,ZEROCL,XSIZ,ZEROCL,YSIZ); 4028 LINKOR(ZPTR,XSIZ); 4029 BRANCH(RTZPTR) 4030 /*_*/ 4031L_ORVP: 4032 X_LOCSP(XSP,XPTR); 4033 D_A(TMVAL) = S_L(XSP); 4034 D_F(TMVAL) = D_V(TMVAL) = 0; 4035 SAVSTK(); 4036 PUSH(LNODSZ); 4037 BLOCK(TPTR); 4038 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR); 4039 goto L_ORPP; 4040 /*_*/ 4041} 4042int 4043SCAN(retval) 4044 ret_t retval; 4045{ 4046 ENTRY(SCAN) 4047 SAVSTK(); 4048 switch (ARGVAL(XPTR)) { 4049 case 1: 4050 BRANCH(FAIL) 4051 } 4052 PUSH(XPTR); 4053 SAVSTK(); 4054 switch (PATVAL(YPTR)) { 4055 case 1: 4056 BRANCH(FAIL) 4057 } 4058 POP(XPTR); 4059 D_A(DTCL) = D_V(XPTR); 4060 D_F(DTCL) = D_V(DTCL) = 0; 4061 D_V(DTCL) = D_V(YPTR); 4062 D_A(SCNCL) += 1; 4063 if (DCMP(DTCL, VVDTP)) 4064 goto L_SCANVV; 4065 if (DCMP(DTCL, VPDTP)) 4066 goto L_SCANVP; 4067 if (DCMP(DTCL, IVDTP)) 4068 goto L_SCANIV; 4069 if (DCMP(DTCL, RVDTP)) 4070 goto L_SCANRV; 4071 if (DCMP(DTCL, RPDTP)) 4072 goto L_SCANRP; 4073 if (DCMP(DTCL, IPDTP)) 4074 goto L_SCANIP; 4075 else 4076 BRANCH(INTR1) 4077 /*_*/ 4078L_SCANVV: 4079 X_LOCSP(XSP,XPTR); 4080 X_LOCSP(YSP,YPTR); 4081L_SCANVB: 4082 if (S_L(XSP) < S_L(YSP)) 4083 BRANCH(FAIL) 4084 _SPEC(TSP) = _SPEC(XSP); 4085 S_L(TSP) = S_L(YSP); 4086 if (LEXEQ(TSP,YSP)) 4087 BRANCH(RTYPTR) 4088 if (D_A(ANCCL) != 0) 4089 BRANCH(FAIL) 4090 S_L(XSP) -= 1; 4091 S_O(XSP) += 1; 4092 goto L_SCANVB; 4093 /*_*/ 4094L_SCANIV: 4095 SAVSTK(); 4096 PUSH(XPTR); 4097 GNVARI(XPTR); 4098 goto L_SCANVV; 4099 /*_*/ 4100L_SCANVP: 4101 X_LOCSP(XSP,XPTR); 4102 SAVSTK(); 4103 switch (SCNR(NORET)) { 4104 case 1: 4105 case 3: 4106 BRANCH(FAIL) 4107 } 4108 SAVSTK(); 4109 switch (NMD(NORET)) { 4110 case 1: 4111 BRANCH(FAIL) 4112 } 4113 if (S_L(TXSP) >= S_L(HEADSP)) 4114 goto L_SCANV1; 4115 X_REMSP(XSP,HEADSP,TXSP); 4116 goto L_SCANV2; 4117 /*_*/ 4118L_SCANV1: 4119 X_REMSP(XSP,TXSP,HEADSP); 4120L_SCANV2: 4121 SAVSTK(); 4122 PUSH(XSPPTR); 4123 switch (GENVAR(YPTR)) { 4124 case 1: 4125 BRANCH(RTYPTR) 4126 } 4127 /*_*/ 4128L_SCANIP: 4129 SAVSTK(); 4130 PUSH(XPTR); 4131 GNVARI(XPTR); 4132 goto L_SCANVP; 4133 /*_*/ 4134L_SCANRV: 4135 REALST(XSP,XPTR); 4136 SAVSTK(); 4137 PUSH(XSPPTR); 4138 switch (GENVAR(XPTR)) { 4139 case 1: 4140 goto L_SCANVV; 4141 } 4142 /*_*/ 4143L_SCANRP: 4144 REALST(XSP,XPTR); 4145 SAVSTK(); 4146 PUSH(XSPPTR); 4147 switch (GENVAR(XPTR)) { 4148 case 1: 4149 goto L_SCANVP; 4150 } 4151 /*_*/ 4152} 4153int 4154SJSR(retval) 4155 ret_t retval; 4156{ 4157 ENTRY(SJSR) 4158 D_A(OCICL) += DESCR; 4159 D(WPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 4160 if ((D_F(WPTR) & FNC)) 4161 goto L_SJSRC1; 4162L_SJSR1: 4163 if (D_A(INSW) == 0) 4164 goto L_SJSR1A; 4165 if (!LOCAPV(ZPTR,INATL,WPTR)) 4166 goto L_SJSR1A; 4167 D(ZPTR) = D(D_A(ZPTR) + DESCR); 4168 SAVSTK(); 4169 PUSH(WPTR); 4170 PUSH(ZPTR); 4171 switch (PUTIN(XPTR)) { 4172 case 1: 4173 BRANCH(FAIL) 4174 case 2: 4175 goto L_SJSR1B; 4176 } 4177 /*_*/ 4178L_SJSR1A: 4179 D(XPTR) = D(D_A(WPTR) + DESCR); 4180L_SJSR1B: 4181 PUSH(WPTR); 4182 PUSH(XPTR); 4183 SAVSTK(); 4184 switch (PATVAL(YPTR)) { 4185 case 1: 4186 BRANCH(FAIL) 4187 } 4188 POP(XPTR); 4189 D_A(DTCL) = D_V(XPTR); 4190 D_F(DTCL) = D_V(DTCL) = 0; 4191 D_V(DTCL) = D_V(YPTR); 4192 D_A(SCNCL) += 1; 4193 if (DCMP(DTCL, VVDTP)) 4194 goto L_SJSSVV; 4195 if (DCMP(DTCL, VPDTP)) 4196 goto L_SJSSVP; 4197 if (DCMP(DTCL, IVDTP)) 4198 goto L_SJSSIV; 4199 if (DCMP(DTCL, RVDTP)) 4200 goto L_SJSSRV; 4201 if (DCMP(DTCL, RPDTP)) 4202 goto L_SJSSRP; 4203 if (DCMP(DTCL, IPDTP)) 4204 goto L_SJSSIP; 4205 else 4206 BRANCH(INTR1) 4207 /*_*/ 4208L_SJSRC1: 4209 SAVSTK(); 4210 PUSH(WPTR); 4211 switch (INVOKE(WPTR)) { 4212 case 1: 4213 BRANCH(FAIL) 4214 case 2: 4215 goto L_SJSR1; 4216 case 3: 4217 BRANCH(NEMO) 4218 } 4219 /*_*/ 4220L_SJSSVP: 4221 X_LOCSP(XSP,XPTR); 4222 SAVSTK(); 4223 switch (SCNR(NORET)) { 4224 case 1: 4225 case 3: 4226 BRANCH(FAIL) 4227 } 4228 D_A(NAMGCL) = 1; 4229 X_REMSP(TAILSP,XSP,TXSP); 4230 goto L_SJSS1; 4231 /*_*/ 4232L_SJSSIP: 4233 SAVSTK(); 4234 PUSH(XPTR); 4235 GNVARI(XPTR); 4236 goto L_SJSSVP; 4237 /*_*/ 4238L_SJSSIV: 4239 SAVSTK(); 4240 PUSH(XPTR); 4241 GNVARI(XPTR); 4242 goto L_SJSSVV; 4243 /*_*/ 4244L_SJSSRV: 4245 REALST(XSP,XPTR); 4246 SAVSTK(); 4247 PUSH(XSPPTR); 4248 switch (GENVAR(XPTR)) { 4249 case 1: 4250 goto L_SJSSVV; 4251 } 4252 /*_*/ 4253L_SJSSRP: 4254 REALST(XSP,XPTR); 4255 SAVSTK(); 4256 PUSH(XSPPTR); 4257 switch (GENVAR(XPTR)) { 4258 case 1: 4259 goto L_SJSSVP; 4260 } 4261 /*_*/ 4262L_SJVVON: 4263 if (D_A(ANCCL) != 0) 4264 BRANCH(FAIL) 4265 S_L(HEADSP) += D_A(ONECL); 4266 S_L(XSP) -= 1; 4267 S_O(XSP) += 1; 4268 goto L_SJSSV2; 4269 /*_*/ 4270L_SJSSVV: 4271 X_LOCSP(XSP,XPTR); 4272 X_LOCSP(YSP,YPTR); 4273 _SPEC(HEADSP) = _SPEC(XSP); 4274 S_L(HEADSP) = 0; 4275L_SJSSV2: 4276 if (S_L(XSP) < S_L(YSP)) 4277 BRANCH(FAIL) 4278 _SPEC(TSP) = _SPEC(XSP); 4279 S_L(TSP) = S_L(YSP); 4280 if (!LEXEQ(TSP,YSP)) 4281 goto L_SJVVON; 4282 D_A(NAMGCL) = 0; 4283 X_REMSP(TAILSP,XSP,TSP); 4284L_SJSS1: 4285 SPUSH(TAILSP); 4286 SPUSH(HEADSP); 4287 if (D_A(NAMGCL) == 0) 4288 goto L_SJSS1A; 4289 SAVSTK(); 4290 switch (NMD(NORET)) { 4291 case 1: 4292 BRANCH(FAIL) 4293 } 4294L_SJSS1A: 4295 SAVSTK(); 4296 switch (ARGVAL(ZPTR)) { 4297 case 1: 4298 BRANCH(FAIL) 4299 } 4300 SPOP(HEADSP); 4301 SPOP(TAILSP); 4302 POP(WPTR); 4303 if (S_L(HEADSP) != 0) 4304 goto L_SJSSDT; 4305 if (S_L(TAILSP) == 0) 4306 goto L_SJSRV1; 4307L_SJSSDT: 4308 if (D_V(ZPTR) == S) 4309 goto L_SJSRV; 4310 if (D_V(ZPTR) == P) 4311 goto L_SJSRP; 4312 if (D_V(ZPTR) == I) 4313 goto L_SJSRI; 4314 if (D_V(ZPTR) == R) 4315 goto L_SJSRR; 4316 if (D_V(ZPTR) != E) 4317 BRANCH(INTR1) 4318 SAVSTK(); 4319 PUSH(STARSZ); 4320 BLOCK(TPTR); 4321 MOVBLK(D_A(TPTR),D_A(STRPAT),D_A(STARSZ)); 4322 D(D_A(TPTR) + 4*DESCR) = D(ZPTR); 4323 D(ZPTR) = D(TPTR); 4324L_SJSRP: 4325 _SPEC(XSP) = _SPEC(HEADSP); 4326 SAVSTK(); 4327 PUSH(XSPPTR); 4328 GENVAR(XPTR); 4329 D_A(TMVAL) = S_L(HEADSP); 4330 D_F(TMVAL) = D_V(TMVAL) = 0; 4331 SAVSTK(); 4332 PUSH(LNODSZ); 4333 BLOCK(TPTR); 4334 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR); 4335 _SPEC(YSP) = _SPEC(TAILSP); 4336 SAVSTK(); 4337 PUSH(YSPPTR); 4338 GENVAR(YPTR); 4339 D_A(TMVAL) = S_L(TAILSP); 4340 D_F(TMVAL) = D_V(TMVAL) = 0; 4341 SAVSTK(); 4342 PUSH(LNODSZ); 4343 BLOCK(TPTR); 4344 MAKNOD(YPTR,TPTR,TMVAL,ZEROCL,CHRCL,YPTR); 4345 D_A(XSIZ) = D_V(D_A(XPTR)); 4346 D_F(XSIZ) = D_V(XSIZ) = 0; 4347 D_A(YSIZ) = D_V(D_A(YPTR)); 4348 D_F(YSIZ) = D_V(YSIZ) = 0; 4349 D_A(ZSIZ) = D_V(D_A(ZPTR)); 4350 D_F(ZSIZ) = D_V(ZSIZ) = 0; 4351 D(TSIZ) = D(XSIZ); 4352 D_A(TSIZ) += D_A(ZSIZ); 4353 D_A(TSIZ) += D_A(YSIZ); 4354 D_V(TSIZ) = P; 4355 SAVSTK(); 4356 PUSH(TSIZ); 4357 BLOCK(TPTR); 4358 D(VVAL) = D(TPTR); 4359 LVALUE(TVAL,ZPTR); 4360 CPYPAT(TPTR,XPTR,TVAL,ZEROCL,XSIZ,XSIZ); 4361 LVALUE(TVAL,YPTR); 4362 D(TSIZ) = D(XSIZ); 4363 D_A(TSIZ) += D_A(ZSIZ); 4364 CPYPAT(TPTR,ZPTR,TVAL,XSIZ,TSIZ,ZSIZ); 4365 CPYPAT(TPTR,YPTR,ZEROCL,TSIZ,ZEROCL,YSIZ); 4366 D(ZPTR) = D(VVAL); 4367 goto L_SJSRV1; 4368 /*_*/ 4369L_SJSRV: 4370 X_LOCSP(ZSP,ZPTR); 4371L_SJSRS: 4372 D_A(XPTR) = S_L(TAILSP); 4373 D_F(XPTR) = D_V(XPTR) = 0; 4374 D_A(YPTR) = S_L(HEADSP); 4375 D_F(YPTR) = D_V(YPTR) = 0; 4376 D_A(ZPTR) = S_L(ZSP); 4377 D_F(ZPTR) = D_V(ZPTR) = 0; 4378 D_A(XPTR) += D_A(YPTR); 4379 D_A(XPTR) += D_A(ZPTR); 4380 if (D_A(XPTR) > D_A(MLENCL)) 4381 BRANCH(INTR8) 4382 SAVSTK(); 4383 PUSH(XPTR); 4384 CONVAR(ZPTR); 4385 X_LOCSP(TSP,ZPTR); 4386 S_L(TSP) = 0; 4387 APDSP(TSP,HEADSP); 4388 APDSP(TSP,ZSP); 4389 APDSP(TSP,TAILSP); 4390 SAVSTK(); 4391 PUSH(XPTR); 4392 GNVARS(ZPTR); 4393L_SJSRV1: 4394 D(D_A(WPTR) + DESCR) = D(ZPTR); 4395 if (D_A(OUTSW) == 0) 4396 goto L_SJSRV2; 4397 if (!LOCAPV(YPTR,OUTATL,WPTR)) 4398 goto L_SJSRV2; 4399 D(YPTR) = D(D_A(YPTR) + DESCR); 4400 SAVSTK(); 4401 PUSH(ZPTR); 4402 PUSH(YPTR); 4403 PUTOUT(NORET); 4404L_SJSRV2: 4405 if (D_A(TRAPCL) <= 0) 4406 BRANCH(RTZPTR) 4407 if (!LOCAPT(ATPTR,TVALL,WPTR)) 4408 BRANCH(RTZPTR) 4409 SAVSTK(); 4410 PUSH(ATPTR); 4411 switch (TRPHND(NORET)) { 4412 case 1: 4413 BRANCH(RTZPTR) 4414 } 4415 /*_*/ 4416L_SJSRI: 4417 INTSPC(ZSP,ZPTR); 4418 goto L_SJSRS; 4419 /*_*/ 4420L_SJSRR: 4421 REALST(ZSP,ZPTR); 4422 goto L_SJSRS; 4423 /*_*/ 4424} 4425static int 4426SCNR(retval) 4427 ret_t retval; 4428{ 4429 ENTRY(SCNR) 4430 D_A(MAXLEN) = S_L(XSP); 4431 D_F(MAXLEN) = D_V(MAXLEN) = 0; 4432 LVALUE(YSIZ,YPTR); 4433 if (D_A(FULLCL) != 0) 4434 goto L_SCNR1; 4435 if (D_A(YSIZ) > D_A(MAXLEN)) 4436 BRANCH(FAIL) 4437L_SCNR1: 4438 _SPEC(TXSP) = _SPEC(XSP); 4439 S_L(TXSP) = 0; 4440 D(PDLPTR) = D(PDLHED); 4441 D(NAMICL) = D(NHEDCL); 4442 if (D_A(ANCCL) != 0) 4443 goto L_SCNR3; 4444 if (D_A(FULLCL) == 0) 4445 goto L_SCNR4; 4446 D(YSIZ) = D(MAXLEN); 4447 goto L_SCNR5; 4448 /*_*/ 4449L_SCNR4: 4450 D_A(YSIZ) = D_A(MAXLEN) - D_A(YSIZ); 4451 D_F(YSIZ) = D_F(MAXLEN); 4452 D_V(YSIZ) = D_V(MAXLEN); 4453L_SCNR5: 4454 D_A(YSIZ) += D_A(CHARCL); 4455 PUSH(YPTR); 4456 PUSH(YSIZ); 4457 _SPEC(HEADSP) = _SPEC(TXSP); 4458 D_A(PDLPTR) += 3*DESCR; 4459 if (D_A(PDLPTR) > D_A(PDLEND)) 4460 BRANCH(INTR31) 4461 D_A(LENFCL) = 1; 4462 D(D_A(PDLPTR) + DESCR) = D(SCONCL); 4463 D_A(TMVAL) = S_L(TXSP); 4464 D_F(TMVAL) = D_V(TMVAL) = 0; 4465 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL); 4466 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL); 4467 BRANCH(SCIN) 4468 /*_*/ 4469L_SCNR3: 4470 D_A(PDLPTR) += 3*DESCR; 4471 if (D_A(PDLPTR) > D_A(PDLEND)) 4472 BRANCH(INTR31) 4473 S_L(HEADSP) = 0; 4474 D(D_A(PDLPTR) + DESCR) = D(SCFLCL); 4475 D_A(TMVAL) = S_L(TXSP); 4476 D_F(TMVAL) = D_V(TMVAL) = 0; 4477 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL); 4478 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL); 4479 BRANCH(SCIN) 4480 /*_*/ 4481} 4482static int 4483SCIN(retval) 4484 ret_t retval; 4485{ 4486 ENTRY(SCIN) 4487 D_A(UNSCCL) = 0; 4488 /* FALL */ 4489 BRANCH(SCIN1) 4490} 4491static int 4492SCIN1(retval) 4493 ret_t retval; 4494{ 4495 ENTRY(SCIN1) 4496L_SCIN1A: 4497 D(PATBCL) = D(YPTR); 4498 if (D_A(UNSCCL) != 0) 4499 goto L_UNSC; 4500 D_A(PATICL) = 0; 4501L_SCIN2: 4502 D_A(LENFCL) = 1; 4503L_SCIN3: 4504 D_A(PATICL) += DESCR; 4505 D(ZCL) = D(D_A(PATBCL) + D_A(PATICL)); 4506 D_A(PATICL) += DESCR; 4507 D(XCL) = D(D_A(PATBCL) + D_A(PATICL)); 4508 D_A(PATICL) += DESCR; 4509 D(YCL) = D(D_A(PATBCL) + D_A(PATICL)); 4510 D_A(PDLPTR) += 3*DESCR; 4511 if (D_A(PDLPTR) > D_A(PDLEND)) 4512 BRANCH(INTR31) 4513 D(D_A(PDLPTR) + DESCR) = D(XCL); 4514 D_A(TMVAL) = S_L(TXSP); 4515 D_F(TMVAL) = D_V(TMVAL) = 0; 4516 D_V(TMVAL) = D_V(YCL); 4517 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL); 4518 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL); 4519 if (D_A(FULLCL) != 0) 4520 goto L_SCIN4; 4521 if (S_L(TXSP) + D_A(YCL) > D_A(MAXLEN)) 4522 goto L_SALT1; 4523L_SCIN4: 4524 D(PTBRCL) = D(D_A(ZCL)); 4525 goto L_PATBRA; 4526 /*_*/ 4527L_SALF: 4528L_TSALF: 4529L_SALF1: 4530 D_A(LENFCL) = 0; 4531 goto L_SALT2; 4532 /*_*/ 4533L_SALT: 4534L_TSALT: 4535L_SALT1: 4536 D(LENFCL) = D(D_A(PDLPTR) + 3*DESCR); 4537L_SALT2: 4538 D(XCL) = D(D_A(PDLPTR) + DESCR); 4539 D(YCL) = D(D_A(PDLPTR) + 2*DESCR); 4540 D_A(PDLPTR) -= 3*DESCR; 4541 D(PATICL) = D(XCL); 4542 if (D_A(PATICL) == 0) 4543 goto L_SALT3; 4544 S_L(TXSP) = D_A(YCL); 4545 if (!(D_F(PATICL) & FNC)) 4546 goto L_SCIN3; 4547 D(PTBRCL) = D(D_A(PATICL)); 4548L_PATBRA: 4549 switch (D_A(PTBRCL)) { 4550 case 1: 4551 goto L_ANYC; 4552 case 2: 4553 goto L_ARBF; 4554 case 3: 4555 goto L_ARBN; 4556 case 4: 4557 goto L_ATP; 4558 case 5: 4559 goto L_CHR; 4560 case 6: 4561 goto L_BAL; 4562 case 7: 4563 goto L_BALF; 4564 case 8: 4565 goto L_BRKC; 4566 case 9: 4567 goto L_BRKX; 4568 case 10: 4569 goto L_BRKXF; 4570 case 11: 4571 goto L_DNME; 4572 case 12: 4573 goto L_DNME1; 4574 case 13: 4575 goto L_EARB; 4576 case 14: 4577 goto L_DSAR; 4578 case 15: 4579 goto L_ENME; 4580 case 16: 4581 goto L_ENMI; 4582 case 17: 4583 goto L_FARB; 4584 case 18: 4585 goto L_FNME; 4586 case 19: 4587 goto L_LNTH; 4588 case 20: 4589 goto L_NME; 4590 case 21: 4591 goto L_NNYC; 4592 case 22: 4593 goto L_ONAR; 4594 case 23: 4595 goto L_ONRF; 4596 case 24: 4597 goto L_POSI; 4598 case 25: 4599 goto L_RPSI; 4600 case 26: 4601 goto L_RTB; 4602 case 27: 4603 BRANCH(FAIL) 4604 case 28: 4605 goto L_SALF; 4606 case 29: 4607 goto L_SCOK; 4608 case 30: 4609 goto L_SCON; 4610 case 31: 4611 goto L_SPNC; 4612 case 32: 4613 goto L_STAR; 4614 case 33: 4615 goto L_TB; 4616 case 34: 4617 BRANCH(RTNUL3) 4618 case 35: 4619 goto L_FNCE; 4620 case 36: 4621 goto L_SUCF; 4622 } 4623 BRANCH(INTR13) 4624 /*_*/ 4625L_UNSC: 4626 D_A(UNSCCL) = 0; 4627 D(PATBCL) = D(YPTR); 4628L_SALT3: 4629 if (D_A(LENFCL) != 0) 4630 goto L_SALT1; 4631 goto L_SALF1; 4632 /*_*/ 4633L_SCOK: 4634L_TSCOK: 4635 D_A(PATICL) = D_V(XCL); 4636 D_F(PATICL) = D_V(PATICL) = 0; 4637 if (D_A(PATICL) == 0) 4638 BRANCH(RTN2) 4639 else 4640 goto L_SCIN2; 4641 /*_*/ 4642L_SCON: 4643 if (D_A(FULLCL) != 0) 4644 goto L_SCON1; 4645 if (D_A(LENFCL) != 0) 4646 BRANCH(FAIL) 4647L_SCON1: 4648 POP(YSIZ); 4649 POP(YPTR); 4650 D_A(YSIZ) -= 1; 4651 if (D_A(YSIZ) < 0) 4652 BRANCH(INTR13) 4653 if (D_A(YSIZ) == 0) 4654 BRANCH(FAIL) 4655 S_L(TXSP) += D_A(ONECL); 4656 PUSH(YPTR); 4657 PUSH(YSIZ); 4658 _SPEC(HEADSP) = _SPEC(TXSP); 4659 D_A(PDLPTR) += 3*DESCR; 4660 if (D_A(PDLPTR) > D_A(PDLEND)) 4661 BRANCH(INTR31) 4662 D_A(LENFCL) = 1; 4663 D(D_A(PDLPTR) + DESCR) = D(SCONCL); 4664 D_A(TMVAL) = S_L(TXSP); 4665 D_F(TMVAL) = D_V(TMVAL) = 0; 4666 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL); 4667 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL); 4668 goto L_SCIN1A; 4669 /*_*/ 4670L_BRKC: 4671 D_A(SCL) = 2; 4672 goto L_ABNS; 4673 /*_*/ 4674L_BRKX: 4675 D_A(SCL) = 5; 4676 goto L_ABNS; 4677 /*_*/ 4678L_NNYC: 4679 D_A(SCL) = 3; 4680 goto L_ABNS; 4681 /*_*/ 4682L_SPNC: 4683 D_A(SCL) = 4; 4684 goto L_ABNS; 4685 /*_*/ 4686L_ANYC: 4687 D_A(SCL) = 1; 4688L_ABNS: 4689 D_A(PATICL) += DESCR; 4690 D(XPTR) = D(D_A(PATBCL) + D_A(PATICL)); 4691L_ABNS1: 4692 if (D_V(XPTR) == S) 4693 goto L_ABNSV; 4694 if (D_V(XPTR) == E) 4695 goto L_ABNSE; 4696 if (D_V(XPTR) == I) 4697 goto L_ABNSI; 4698 else 4699 goto L_SCDTER; 4700 /*_*/ 4701L_ABNSE: 4702 PUSH(SCL); 4703 SAVSTK(); 4704 PUSH(XPTR); 4705 switch (EXPVAL(XPTR)) { 4706 case 1: 4707 goto L_ABNSF; 4708 case 2: 4709 goto L_ABNS2; 4710 } 4711L_ABNSF: 4712 POP(SCL); 4713 goto L_SALF; 4714 /*_*/ 4715L_ABNS2: 4716 POP(SCL); 4717 goto L_ABNS1; 4718 /*_*/ 4719L_ABNSI: 4720 SAVSTK(); 4721 PUSH(XPTR); 4722 GNVARI(XPTR); 4723L_ABNSV: 4724 if (D_A(XPTR) == 0) 4725 goto L_SCNAME; 4726 switch (D_A(SCL)) { 4727 case 1: 4728 case 3: 4729 goto L_ANYC3; 4730 case 4: 4731 goto L_SPNV; 4732 } 4733 if (DCMP(XPTR, TBLBCS)) 4734 goto L_ANYC3; 4735 clertb(&BRKTB,AC_CONTIN); 4736 X_LOCSP(YSP,XPTR); 4737 PLUGTB(&BRKTB,AC_STOPSH,YSP); 4738 D(TBLBCS) = D(XPTR); 4739L_ANYC3: 4740 _SPEC(VSP) = _SPEC(XSP); 4741 if (D_A(FULLCL) != 0) 4742 goto L_ANYC4; 4743 S_L(VSP) = D_A(MAXLEN); 4744 if (S_L(VSP) < S_L(TXSP)) 4745 goto L_SALT; 4746 if (S_L(XSP) + D_A(ZEROCL) <= D_A(MAXLEN)) 4747 goto L_ANYC4; 4748 S_L(VSP) += D_A(ONECL); 4749L_ANYC4: 4750 X_REMSP(YSP,VSP,TXSP); 4751 switch (D_A(SCL)) { 4752 case 1: 4753 case 3: 4754 goto L_ANYC7; 4755 } 4756 switch (STREAM(ZSP, YSP, &BRKTB)) { 4757 case ST_ERROR: 4758 goto L_SALF; 4759 case ST_EOS: 4760 goto L_SALT; 4761 } 4762 D_A(XPTR) = S_L(ZSP); 4763 D_F(XPTR) = D_V(XPTR) = 0; 4764 S_L(TXSP) += D_A(XPTR); 4765 if (D_A(SCL) != 5) 4766 goto L_SCOK; 4767 D_A(PDLPTR) += 3*DESCR; 4768 if (D_A(PDLPTR) > D_A(PDLEND)) 4769 BRANCH(INTR31) 4770 D(D_A(PDLPTR) + DESCR) = D(ZEROCL); 4771 D(D_A(PDLPTR) + 2*DESCR) = D(PATICL); 4772 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL); 4773 D_A(TVAL) = S_L(TXSP); 4774 D_F(TVAL) = D_V(TVAL) = 0; 4775 D_A(TMVAL) = D_A(TVAL); 4776 D_A(PDLPTR) += 3*DESCR; 4777 if (D_A(PDLPTR) > D_A(PDLEND)) 4778 BRANCH(INTR31) 4779 D(D_A(PDLPTR) + DESCR) = D(BRXFCL); 4780 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL); 4781 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL); 4782 goto L_SCOK; 4783 /*_*/ 4784L_ANYC7: 4785 if (S_L(YSP) == 0) 4786 goto L_SALT; 4787 if (XANY(YSP,XPTR)) 4788 goto L_ANYC5; 4789 if (D_A(SCL) == 1) 4790 goto L_SALF; 4791L_ANYC6: 4792 S_L(TXSP) += D_A(ONECL); 4793 goto L_SCOK; 4794L_ANYC5: 4795 if (D_A(SCL) == 3) 4796 goto L_SALF; 4797 else 4798 goto L_ANYC6; 4799 /*_*/ 4800L_BRKXF: 4801 D(PATICL) = D(D_A(PDLPTR) + 2*DESCR); 4802 D_A(PATICL) -= DESCR; 4803 D_A(PDLPTR) -= 3*DESCR; 4804 if (D_A(FULLCL) == 0) 4805 goto L_BRXF1; 4806 D_A(NVAL) = 0; 4807 goto L_BRXF3; 4808 /*_*/ 4809L_BRXF1: 4810 if (D_A(LENFCL) != 0) 4811 goto L_SALT; 4812 D_A(NVAL) = D_V(YCL); 4813 D_F(NVAL) = D_V(NVAL) = 0; 4814L_BRXF3: 4815 if (S_L(TXSP) + D_A(NVAL) >= D_A(MAXLEN)) 4816 goto L_SALT; 4817 D(XCL) = D(D_A(PDLPTR) + DESCR); 4818 S_L(TXSP) += D_A(ONECL); 4819 goto L_BRKX; 4820 /*_*/ 4821L_SPNV: 4822 if (DCMP(XPTR, TBLSCS)) 4823 goto L_SPNC3; 4824 clertb(&SPANTB,AC_STOPSH); 4825 X_LOCSP(YSP,XPTR); 4826 PLUGTB(&SPANTB,AC_CONTIN,YSP); 4827 D(TBLSCS) = D(XPTR); 4828L_SPNC3: 4829 if (S_L(XSP) <= S_L(TXSP)) 4830 goto L_SALT; 4831 X_REMSP(YSP,XSP,TXSP); 4832 switch (STREAM(ZSP, YSP, &SPANTB)) { 4833 case ST_ERROR: 4834 goto L_SALF; 4835 } 4836 if (S_L(ZSP) == 0) 4837 goto L_SALF; 4838 D_A(XPTR) = S_L(ZSP); 4839 D_F(XPTR) = D_V(XPTR) = 0; 4840 if (D_A(FULLCL) != 0) 4841 goto L_SPNC5; 4842 if (S_L(TXSP) + D_A(XPTR) > D_A(MAXLEN)) 4843 goto L_SALT; 4844L_SPNC5: 4845 S_L(TXSP) += D_A(XPTR); 4846 goto L_SCOK; 4847 /*_*/ 4848L_LNTH: 4849 D_A(SCL) = 1; 4850L_LPRRT: 4851 D_A(PATICL) += DESCR; 4852 D(XPTR) = D(D_A(PATBCL) + D_A(PATICL)); 4853 PUSH(SCL); 4854L_LPRRT1: 4855 if (D_V(XPTR) == I) 4856 goto L_LPRRTI; 4857 if (D_V(XPTR) == E) 4858 goto L_LPRRTE; 4859 if (D_V(XPTR) == S) 4860 goto L_LPRRTV; 4861 POP(SCL); 4862 goto L_SCDTER; 4863L_LPRRTE: 4864 SAVSTK(); 4865 PUSH(XPTR); 4866 switch (EXPVAL(XPTR)) { 4867 case 2: 4868 goto L_LPRRT1; 4869 } 4870 POP(SCL); 4871 goto L_TSALF; 4872 /*_*/ 4873L_LPRRTV: 4874 X_LOCSP(ZSP,XPTR); 4875 if (!SPCINT(XPTR,ZSP)) 4876 goto L_SCDTER; 4877L_LPRRTI: 4878 POP(SCL); 4879 switch (D_A(SCL)) { 4880 case 2: 4881 goto L_POSII; 4882 case 3: 4883 goto L_RPSII; 4884 case 4: 4885 goto L_RTBI; 4886 case 5: 4887 goto L_TBI; 4888 } 4889 if (D_A(XPTR) < 0) 4890 goto L_SCLENR; 4891 if (S_L(TXSP) + D_A(XPTR) > D_A(MAXLEN)) 4892 goto L_TSALT; 4893 S_L(TXSP) += D_A(XPTR); 4894 goto L_SCOK; 4895 /*_*/ 4896L_POSII: 4897 if (D_A(XPTR) < 0) 4898 goto L_SCLENR; 4899 D_A(NVAL) = S_L(TXSP); 4900 D_F(NVAL) = D_V(NVAL) = 0; 4901 if (D_A(XPTR) > D_A(MAXLEN)) 4902 goto L_TSALT; 4903 if (D_A(XPTR) == D_A(NVAL)) 4904 goto L_TSCOK; 4905 if (D_A(XPTR) > D_A(NVAL)) 4906 goto L_TSALF; 4907 goto L_SALT; 4908 /*_*/ 4909L_RPSII: 4910 if (D_A(XPTR) < 0) 4911 goto L_SCLENR; 4912 D_A(NVAL) = S_L(XSP); 4913 D_F(NVAL) = D_V(NVAL) = 0; 4914 D(TVAL) = D(NVAL); 4915 D_A(TVAL) -= D_A(XPTR); 4916 D_A(NVAL) = S_L(TXSP); 4917 D_F(NVAL) = D_V(NVAL) = 0; 4918 if (D_A(NVAL) < D_A(TVAL)) 4919 goto L_TSALF; 4920 if (D_A(NVAL) == D_A(TVAL)) 4921 goto L_TSCOK; 4922 goto L_TSALT; 4923 /*_*/ 4924L_RTBI: 4925 if (D_A(XPTR) < 0) 4926 goto L_SCLENR; 4927 D_A(NVAL) = S_L(XSP); 4928 D_F(NVAL) = D_V(NVAL) = 0; 4929 D(TVAL) = D(NVAL); 4930 D_A(TVAL) -= D_A(XPTR); 4931 D_A(NVAL) = S_L(TXSP); 4932 D_F(NVAL) = D_V(NVAL) = 0; 4933 if (D_A(NVAL) > D_A(TVAL)) 4934 goto L_TSALT; 4935 if (D_A(FULLCL) != 0) 4936 goto L_RTBII; 4937 D_A(NVAL) = D_V(YCL); 4938 D_F(NVAL) = D_V(NVAL) = 0; 4939 D_A(NVAL) = D_A(MAXLEN) - D_A(NVAL); 4940 D_F(NVAL) = D_F(MAXLEN); 4941 D_V(NVAL) = D_V(MAXLEN); 4942 if (D_A(NVAL) < D_A(TVAL)) 4943 goto L_TSALT; 4944L_RTBII: 4945 S_L(TXSP) = D_A(TVAL); 4946 goto L_SCOK; 4947 /*_*/ 4948L_TBI: 4949 if (D_A(XPTR) < 0) 4950 goto L_SCLENR; 4951 D_A(NVAL) = S_L(TXSP); 4952 D_F(NVAL) = D_V(NVAL) = 0; 4953 if (D_A(NVAL) > D_A(XPTR)) 4954 goto L_TSALT; 4955 if (D_A(XPTR) > D_A(MAXLEN)) 4956 goto L_TSALT; 4957 S_L(TXSP) = D_A(XPTR); 4958 goto L_SCOK; 4959 /*_*/ 4960L_POSI: 4961 D_A(SCL) = 2; 4962 goto L_LPRRT; 4963 /*_*/ 4964L_RPSI: 4965 D_A(SCL) = 3; 4966 goto L_LPRRT; 4967 /*_*/ 4968L_RTB: 4969 D_A(SCL) = 4; 4970 goto L_LPRRT; 4971 /*_*/ 4972L_TB: 4973 D_A(SCL) = 5; 4974 goto L_LPRRT; 4975 /*_*/ 4976L_ARBN: 4977 D_A(TMVAL) = S_L(TXSP); 4978 D_F(TMVAL) = D_V(TMVAL) = 0; 4979 PUSH(TMVAL); 4980 goto L_SCOK; 4981 /*_*/ 4982L_ARBF: 4983 POP(TMVAL); 4984 goto L_ONAR2; 4985 /*_*/ 4986L_EARB: 4987 POP(TMVAL); 4988 D(D_A(PDLPTR) + DESCR) = D(TMVAL); 4989 D_A(TMVAL) = S_L(TXSP); 4990 D_F(TMVAL) = D_V(TMVAL) = 0; 4991 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL); 4992 D(D_A(PDLPTR) + 3*DESCR) = D(ZEROCL); 4993 goto L_SCOK; 4994 /*_*/ 4995L_ONAR: 4996 if (D_A(FULLCL) != 0) 4997 goto L_TSCOK; 4998 D(TVAL) = D(ZEROCL); 4999 D_A(TVAL) = D_A(D_A(PDLPTR) + -2*DESCR); 5000 D_A(TMVAL) = S_L(TXSP); 5001 D_F(TMVAL) = D_V(TMVAL) = 0; 5002 if (D_A(TVAL) != D_A(TMVAL)) 5003 goto L_TSCOK; 5004L_ONAR1: 5005 PUSH(TVAL); 5006 D_A(PDLPTR) -= 6*DESCR; 5007L_ONAR2: 5008 if (D_A(LENFCL) != 0) 5009 goto L_TSALT; 5010 goto L_SALF; 5011 /*_*/ 5012L_ONRF: 5013 D(TVAL) = D(ZEROCL); 5014 D_A(TVAL) = D_A(D_A(PDLPTR) + -2*DESCR); 5015 goto L_ONAR1; 5016 /*_*/ 5017L_FARB: 5018 if (D_A(FULLCL) == 0) 5019 goto L_FARB2; 5020 D_A(NVAL) = 0; 5021 goto L_FARB3; 5022 /*_*/ 5023L_FARB2: 5024 if (D_A(LENFCL) != 0) 5025 goto L_FARB1; 5026 D_A(NVAL) = D_V(YCL); 5027 D_F(NVAL) = D_V(NVAL) = 0; 5028L_FARB3: 5029 D_A(TVAL) = S_L(TXSP); 5030 D_F(TVAL) = D_V(TVAL) = 0; 5031 D_A(TVAL) += D_A(NVAL); 5032 if (D_A(TVAL) >= D_A(MAXLEN)) 5033 goto L_FARB1; 5034 S_L(TXSP) += D_A(ONECL); 5035 D_A(TVAL) = S_L(TXSP); 5036 D_F(TVAL) = D_V(TVAL) = 0; 5037 D_A(D_A(PDLPTR) + 2*DESCR) = D_A(TVAL); 5038 goto L_SCOK; 5039 /*_*/ 5040L_FARB1: 5041 D_A(PDLPTR) -= 3*DESCR; 5042 goto L_SALT; 5043 /*_*/ 5044L_ATP: 5045 D_A(PATICL) += DESCR; 5046 D(XPTR) = D(D_A(PATBCL) + D_A(PATICL)); 5047L_ATP1: 5048 if (D_V(XPTR) == E) 5049 goto L_ATPEXN; 5050 D_A(NVAL) = S_L(TXSP); 5051 D_F(NVAL) = D_V(NVAL) = 0; 5052 D_V(NVAL) = I; 5053 D(D_A(XPTR) + DESCR) = D(NVAL); 5054 if (D_A(OUTSW) == 0) 5055 goto L_ATP2; 5056 if (!LOCAPV(ZPTR,OUTATL,XPTR)) 5057 goto L_ATP2; 5058 D(ZPTR) = D(D_A(ZPTR) + DESCR); 5059 SAVSTK(); 5060 PUSH(NVAL); 5061 PUSH(ZPTR); 5062 PUTOUT(NORET); 5063L_ATP2: 5064 if (D_A(TRAPCL) == 0) 5065 goto L_TSCOK; 5066 if (!LOCAPT(ATPTR,TVALL,XPTR)) 5067 goto L_TSCOK; 5068 PUSH(PATBCL); 5069 PUSH(PATICL); 5070 PUSH(WPTR); 5071 PUSH(XCL); 5072 PUSH(YCL); 5073 PUSH(MAXLEN); 5074 PUSH(LENFCL); 5075 PUSH(PDLPTR); 5076 PUSH(PDLHED); 5077 PUSH(NAMICL); 5078 PUSH(NHEDCL); 5079 SPUSH(HEADSP); 5080 SPUSH(TSP); 5081 SPUSH(TXSP); 5082 SPUSH(XSP); 5083 D(PDLHED) = D(PDLPTR); 5084 D(NHEDCL) = D(NAMICL); 5085 SAVSTK(); 5086 PUSH(ATPTR); 5087 TRPHND(NORET); 5088 SPOP(XSP); 5089 SPOP(TXSP); 5090 SPOP(TSP); 5091 SPOP(HEADSP); 5092 POP(NHEDCL); 5093 POP(NAMICL); 5094 POP(PDLHED); 5095 POP(PDLPTR); 5096 POP(LENFCL); 5097 POP(MAXLEN); 5098 POP(YCL); 5099 POP(XCL); 5100 POP(WPTR); 5101 POP(PATICL); 5102 POP(PATBCL); 5103 goto L_SCOK; 5104 /*_*/ 5105L_ATPEXN: 5106 SAVSTK(); 5107 PUSH(XPTR); 5108 switch (EXPEVL(XPTR)) { 5109 case 1: 5110 goto L_TSALF; 5111 case 2: 5112 goto L_ATP1; 5113 case 3: 5114 goto L_SCNEMO; 5115 } 5116 /*_*/ 5117L_BAL: 5118L_BALF1: 5119 if (D_A(FULLCL) == 0) 5120 goto L_BALF4; 5121 D_A(NVAL) = 0; 5122 goto L_BALF2; 5123 /*_*/ 5124L_BALF4: 5125 D_A(NVAL) = D_V(YCL); 5126 D_F(NVAL) = D_V(NVAL) = 0; 5127L_BALF2: 5128 D_A(TVAL) = S_L(TXSP); 5129 D_F(TVAL) = D_V(TVAL) = 0; 5130 D_A(TVAL) += D_A(NVAL); 5131 if (D_A(TVAL) >= D_A(MAXLEN)) 5132 goto L_BAL1; 5133 D_A(TVAL) = D_A(MAXLEN) - D_A(TVAL); 5134 D_F(TVAL) = D_F(MAXLEN); 5135 D_V(TVAL) = D_V(MAXLEN); 5136 if (!GETBAL(TXSP,TVAL)) 5137 goto L_BAL1; 5138 D_A(TVAL) = S_L(TXSP); 5139 D_F(TVAL) = D_V(TVAL) = 0; 5140 D_A(D_A(PDLPTR) + 2*DESCR) = D_A(TVAL); 5141 goto L_SCOK; 5142 /*_*/ 5143L_BAL1: 5144 D_A(PDLPTR) -= 3*DESCR; 5145 if (D_PTR(PDLPTR) < D_PTR(PDLHED)) 5146 BRANCH(INTR13) 5147 else 5148 goto L_TSALF; 5149 /*_*/ 5150L_BALF: 5151 if (D_A(FULLCL) == 0) 5152 goto L_BALF3; 5153 D_A(NVAL) = 0; 5154 goto L_BALF2; 5155 /*_*/ 5156L_BALF3: 5157 if (D_A(LENFCL) == 0) 5158 goto L_BALF1; 5159 else 5160 goto L_BAL1; 5161 /*_*/ 5162L_CHR: 5163 D_A(PATICL) += DESCR; 5164 D(YPTR) = D(D_A(PATBCL) + D_A(PATICL)); 5165L_CHR1: 5166 X_LOCSP(TSP,YPTR); 5167L_CHR2: 5168 X_REMSP(VSP,XSP,TXSP); 5169 if (S_L(VSP) < S_L(TSP)) 5170 goto L_TSALT; 5171 S_L(VSP) = S_L(TSP); 5172 if (!LEXEQ(VSP,TSP)) 5173 goto L_TSALF; 5174 D_A(YPTR) = S_L(TSP); 5175 D_F(YPTR) = D_V(YPTR) = 0; 5176 S_L(TXSP) += D_A(YPTR); 5177 goto L_SCOK; 5178 /*_*/ 5179L_STAR: 5180 D_A(PATICL) += DESCR; 5181 D(YPTR) = D(D_A(PATBCL) + D_A(PATICL)); 5182L_STAR2: 5183 SAVSTK(); 5184 PUSH(YPTR); 5185 switch (EXPVAL(YPTR)) { 5186 case 1: 5187 goto L_TSALF; 5188 } 5189 if (D_V(YPTR) == E) 5190 goto L_STAR2; 5191 D(XPTR) = D(PATBCL); 5192 D_A(XPTR) += D_A(PATICL); 5193 D(D_A(XPTR) + 7*DESCR) = D(YPTR); 5194 if (D_V(YPTR) == S) 5195 goto L_CHR1; 5196 if (D_V(YPTR) == P) 5197 goto L_STARP; 5198 if (D_V(YPTR) != I) 5199 goto L_SCDTER; 5200 INTSPC(TSP,YPTR); 5201 goto L_CHR2; 5202 /*_*/ 5203L_STARP: 5204 if (D_A(FULLCL) == 0) 5205 goto L_STARP1; 5206 D_A(NVAL) = 0; 5207 goto L_STARP4; 5208 /*_*/ 5209L_STARP1: 5210 D_A(NVAL) = D_V(YCL); 5211 D_F(NVAL) = D_V(NVAL) = 0; 5212L_STARP4: 5213 D_A(NVAL) = D_A(MAXLEN) - D_A(NVAL); 5214 D_F(NVAL) = D_F(MAXLEN); 5215 D_V(NVAL) = D_V(MAXLEN); 5216 if (D_A(NVAL) < 0) 5217 goto L_TSALT; 5218 LVALUE(TSIZ,YPTR); 5219 if (D_A(FULLCL) != 0) 5220 goto L_STARP6; 5221 if (D_A(TSIZ) > D_A(NVAL)) 5222 goto L_TSALT; 5223L_STARP6: 5224 D_A(PDLPTR) += 3*DESCR; 5225 if (D_A(PDLPTR) > D_A(PDLEND)) 5226 BRANCH(INTR31) 5227 D(D_A(PDLPTR) + DESCR) = D(SCFLCL); 5228 D_A(TMVAL) = S_L(TXSP); 5229 D_F(TMVAL) = D_V(TMVAL) = 0; 5230 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL); 5231 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL); 5232 PUSH(MAXLEN); 5233 PUSH(PATBCL); 5234 PUSH(PATICL); 5235 PUSH(XCL); 5236 PUSH(YCL); 5237 D(MAXLEN) = D(NVAL); 5238 SAVSTK(); 5239 switch (SCIN(NORET)) { 5240 case 1: 5241 goto L_STARP5; 5242 case 3: 5243 BRANCH(RTNUL3) 5244 } 5245L_STARP2: 5246 POP(YCL); 5247 POP(XCL); 5248 POP(PATICL); 5249 POP(PATBCL); 5250 POP(MAXLEN); 5251 goto L_SCOK; 5252 /*_*/ 5253L_STARP5: 5254 POP(YCL); 5255 POP(XCL); 5256 POP(PATICL); 5257 POP(PATBCL); 5258 POP(MAXLEN); 5259L_STARP3: 5260 if (D_A(LENFCL) != 0) 5261 goto L_TSALT; 5262 goto L_SALF; 5263 /*_*/ 5264L_DSAR: 5265 D_A(PATICL) += DESCR; 5266 D(YPTR) = D(D_A(PATBCL) + D_A(PATICL)); 5267 if (D_V(YPTR) == S) 5268 goto L_STARP3; 5269 if (D_V(YPTR) == P) 5270 goto L_DSARP; 5271 if (D_V(YPTR) == I) 5272 goto L_STARP3; 5273 else 5274 goto L_SCDTER; 5275 /*_*/ 5276L_DSARP: 5277 if (D_A(FULLCL) == 0) 5278 goto L_DSARP1; 5279 D_A(NVAL) = 0; 5280 goto L_DSARP2; 5281 /*_*/ 5282L_DSARP1: 5283 D_A(NVAL) = D_V(YCL); 5284 D_F(NVAL) = D_V(NVAL) = 0; 5285L_DSARP2: 5286 D_A(NVAL) = D_A(MAXLEN) - D_A(NVAL); 5287 D_F(NVAL) = D_F(MAXLEN); 5288 D_V(NVAL) = D_V(MAXLEN); 5289 PUSH(MAXLEN); 5290 PUSH(PATBCL); 5291 PUSH(PATICL); 5292 PUSH(XCL); 5293 PUSH(YCL); 5294 D(MAXLEN) = D(NVAL); 5295 D_A(UNSCCL) = 1; 5296 SAVSTK(); 5297 switch (SCIN1(NORET)) { 5298 case 1: 5299 goto L_STARP5; 5300 case 2: 5301 goto L_STARP2; 5302 case 3: 5303 BRANCH(RTNUL3) 5304 } 5305 /*_*/ 5306L_FNCE: 5307 D_A(PDLPTR) += 3*DESCR; 5308 if (D_A(PDLPTR) > D_A(PDLEND)) 5309 BRANCH(INTR31) 5310 D(D_A(PDLPTR) + DESCR) = D(FNCFCL); 5311 D_A(TMVAL) = S_L(TXSP); 5312 D_F(TMVAL) = D_V(TMVAL) = 0; 5313 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL); 5314 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL); 5315 D_A(LENFCL) = 1; 5316 goto L_SCOK; 5317 /*_*/ 5318L_NME: 5319 D_A(PDLPTR) += 3*DESCR; 5320 if (D_A(PDLPTR) > D_A(PDLEND)) 5321 BRANCH(INTR31) 5322 D(D_A(PDLPTR) + DESCR) = D(FNMECL); 5323 D_A(TMVAL) = S_L(TXSP); 5324 D_F(TMVAL) = D_V(TMVAL) = 0; 5325 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL); 5326 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL); 5327 PUSH(TMVAL); 5328 D_A(LENFCL) = 1; 5329 goto L_SCOK; 5330 /*_*/ 5331L_FNME: 5332 POP(TVAL); 5333L_FNME1: 5334 if (D_A(LENFCL) == 0) 5335 goto L_TSALF; 5336 else 5337 goto L_TSALT; 5338 /*_*/ 5339L_ENME: 5340 D_A(PATICL) += DESCR; 5341 D(YPTR) = D(D_A(PATBCL) + D_A(PATICL)); 5342 POP(NVAL); 5343 D_V(YCL) = D_A(NVAL); 5344 _SPEC(TSP) = _SPEC(TXSP); 5345 S_L(TSP) = D_A(NVAL); 5346 X_REMSP(TSP,TXSP,TSP); 5347 D(TPTR) = D(NBSPTR); 5348 D_A(TPTR) += D_A(NAMICL); 5349 _SPEC(D_A(TPTR) + DESCR) = _SPEC(TSP); 5350 D(D_A(TPTR) + DESCR+SPEC) = D(YPTR); 5351 D_A(NAMICL) += DESCR+SPEC; 5352 if (D_A(NAMICL) == D_A(NMOVER)) 5353 goto L_ENME1; 5354 if (D_A(NAMICL) > D_A(NMOVER)) 5355 BRANCH(INTR13) 5356L_ENME2: 5357 D_A(PDLPTR) += DESCR+SPEC; 5358 if (D_A(PDLPTR) > D_A(PDLEND)) 5359 BRANCH(INTR31) 5360 D(D_A(PDLPTR) + DESCR) = D(DNMECL); 5361L_ENME3: 5362 D_A(TMVAL) = S_L(TXSP); 5363 D_F(TMVAL) = D_V(TMVAL) = 0; 5364 D_V(TMVAL) = D_V(YCL); 5365 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL); 5366 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL); 5367 D_A(LENFCL) = 1; 5368 goto L_SCOK; 5369 /*_*/ 5370L_ENME1: 5371 D(WCL) = D(NMOVER); 5372 D_A(NMOVER) += NAMLSZ*SPDR; 5373 SAVSTK(); 5374 PUSH(NMOVER); 5375 BLOCK(TPTR); 5376 MOVBLK(D_A(TPTR),D_A(NBSPTR),D_A(WCL)); 5377 D(NBSPTR) = D(TPTR); 5378 goto L_ENME2; 5379 /*_*/ 5380L_DNME: 5381 D_A(NAMICL) -= DESCR+SPEC; 5382 D(TPTR) = D(NBSPTR); 5383 D_A(TPTR) += D_A(NAMICL); 5384L_DNME1: 5385 D_A(VVAL) = D_V(YCL); 5386 D_F(VVAL) = D_V(VVAL) = 0; 5387 PUSH(VVAL); 5388 goto L_FNME1; 5389 /*_*/ 5390L_ENMI: 5391 D_A(PATICL) += DESCR; 5392 D(YPTR) = D(D_A(PATBCL) + D_A(PATICL)); 5393 POP(NVAL); 5394 D_V(YCL) = D_A(NVAL); 5395 _SPEC(TSP) = _SPEC(TXSP); 5396 S_L(TSP) = D_A(NVAL); 5397 X_REMSP(TSP,TXSP,TSP); 5398 D_A(ZCL) = S_L(TSP); 5399 D_F(ZCL) = D_V(ZCL) = 0; 5400 if (D_A(ZCL) > D_A(MLENCL)) 5401 goto L_SCLNOR; 5402 if (D_V(YPTR) == E) 5403 goto L_ENMEXN; 5404L_ENMI5: 5405 if (D_V(YPTR) == K) 5406 goto L_ENMIC; 5407 SAVSTK(); 5408 PUSH(TSPPTR); 5409 GENVAR(VVAL); 5410L_ENMI3: 5411 D(D_A(YPTR) + DESCR) = D(VVAL); 5412 if (D_A(OUTSW) == 0) 5413 goto L_ENMI4; 5414 if (!LOCAPV(ZPTR,OUTATL,YPTR)) 5415 goto L_ENMI4; 5416 D(ZPTR) = D(D_A(ZPTR) + DESCR); 5417 SAVSTK(); 5418 PUSH(VVAL); 5419 PUSH(ZPTR); 5420 PUTOUT(NORET); 5421L_ENMI4: 5422 if (D_A(TRAPCL) <= 0) 5423 goto L_ENMI2; 5424 if (!LOCAPT(ATPTR,TVALL,YPTR)) 5425 goto L_ENMI2; 5426 PUSH(PATBCL); 5427 PUSH(PATICL); 5428 PUSH(WPTR); 5429 PUSH(XCL); 5430 PUSH(YCL); 5431 PUSH(MAXLEN); 5432 PUSH(LENFCL); 5433 PUSH(PDLPTR); 5434 PUSH(PDLHED); 5435 PUSH(NAMICL); 5436 PUSH(NHEDCL); 5437 SPUSH(HEADSP); 5438 SPUSH(TSP); 5439 SPUSH(TXSP); 5440 SPUSH(XSP); 5441 D(PDLHED) = D(PDLPTR); 5442 D(NHEDCL) = D(NAMICL); 5443 SAVSTK(); 5444 PUSH(ATPTR); 5445 TRPHND(NORET); 5446 SPOP(XSP); 5447 SPOP(TXSP); 5448 SPOP(TSP); 5449 SPOP(HEADSP); 5450 POP(NHEDCL); 5451 POP(NAMICL); 5452 POP(PDLHED); 5453 POP(PDLPTR); 5454 POP(LENFCL); 5455 POP(MAXLEN); 5456 POP(YCL); 5457 POP(XCL); 5458 POP(WPTR); 5459 POP(PATICL); 5460 POP(PATBCL); 5461L_ENMI2: 5462 D_A(PDLPTR) += 3*DESCR; 5463 if (D_A(PDLPTR) > D_A(PDLEND)) 5464 BRANCH(INTR31) 5465 D(D_A(PDLPTR) + DESCR) = D(DNMICL); 5466 goto L_ENME3; 5467 /*_*/ 5468L_ENMIC: 5469 if (SPCINT(VVAL,TSP)) 5470 goto L_ENMI3; 5471 else 5472 goto L_SCDTER; 5473 /*_*/ 5474L_ENMEXN: 5475 PUSH(ZEROCL); 5476 SAVSTK(); 5477 PUSH(YPTR); 5478 switch (EXPEVL(YPTR)) { 5479 case 1: 5480 goto L_TSALF; 5481 case 3: 5482 goto L_SCNEMO; 5483 } 5484 POP(ZEROCL); 5485 goto L_ENMI5; 5486 /*_*/ 5487L_SUCE: 5488 D_A(PDLPTR) += 3*DESCR; 5489 if (D_A(PDLPTR) > D_A(PDLEND)) 5490 BRANCH(INTR31) 5491 D(D_A(PDLPTR) + DESCR) = D(SUCFCL); 5492 D_A(TMVAL) = S_L(TXSP); 5493 D_F(TMVAL) = D_V(TMVAL) = 0; 5494 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL); 5495 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL); 5496 D_A(LENFCL) = 1; 5497 goto L_SCOK; 5498 /*_*/ 5499L_SUCF: 5500 D(XCL) = D(D_A(PDLPTR) + DESCR); 5501 D(YCL) = D(D_A(PDLPTR) + 2*DESCR); 5502 goto L_SUCE; 5503 /*_*/ 5504L_SCDTER: 5505 D_A(ERRTYP) = 1; 5506 goto L_SCERSX; 5507 /*_*/ 5508L_SCLENR: 5509 D_A(ERRTYP) = 14; 5510 goto L_SCERSX; 5511 /*_*/ 5512L_SCLNOR: 5513 D_A(ERRTYP) = 15; 5514 goto L_SCERSX; 5515 /*_*/ 5516L_SCNAME: 5517 D_A(ERRTYP) = 4; 5518 goto L_SCERSX; 5519 /*_*/ 5520L_SCNEMO: 5521 D_A(ERRTYP) = 8; 5522L_SCERSX: 5523 SAVSTK(); 5524 SCERST(NORET); 5525 goto L_TSALF; 5526 /*_*/ 5527} 5528int 5529DEFINE(retval) 5530 ret_t retval; 5531{ 5532 ENTRY(DEFINE) 5533 SAVSTK(); 5534 switch (VARVAL(XPTR)) { 5535 case 1: 5536 BRANCH(FAIL) 5537 } 5538 PUSH(XPTR); 5539 SAVSTK(); 5540 switch (VARVUP(YPTR)) { 5541 case 1: 5542 BRANCH(FAIL) 5543 } 5544 POP(XPTR); 5545 X_LOCSP(XSP,XPTR); 5546 switch (STREAM(YSP, XSP, &VARATB)) { 5547 case ST_ERROR: 5548 case ST_EOS: 5549 BRANCH(PROTER) 5550 } 5551 if (D_A(STYPE) != LPTYP) 5552 BRANCH(PROTER) 5553 SAVSTK(); 5554 PUSH(YSPPTR); 5555 GENVUP(XPTR); 5556 SAVSTK(); 5557 PUSH(XPTR); 5558 FINDEX(ZCL); 5559 if (!DCMP(YPTR, NULVCL)) 5560 goto L_DEFIN3; 5561 D(YPTR) = D(XPTR); 5562L_DEFIN3: 5563 PUSH(YPTR); 5564 D(YCL) = D(ZEROCL); 5565 PUSH(XPTR); 5566L_DEFIN4: 5567 S_L(XSP) -= 1; 5568 S_O(XSP) += 1; 5569 switch (STREAM(YSP, XSP, &VARATB)) { 5570 case ST_ERROR: 5571 case ST_EOS: 5572 BRANCH(PROTER) 5573 } 5574 switch (D_A(STYPE)) { 5575 case 1: 5576 BRANCH(PROTER) 5577 case 3: 5578 goto L_DEFIN6; 5579 } 5580 if (S_L(YSP) == 0) 5581 goto L_DEFIN4; 5582 SAVSTK(); 5583 PUSH(YSPPTR); 5584 GENVUP(XPTR); 5585 PUSH(XPTR); 5586 D_A(YCL) += 1; 5587 goto L_DEFIN4; 5588 /*_*/ 5589L_DEFIN6: 5590 if (S_L(YSP) == 0) 5591 goto L_DEFIN9; 5592 D_A(YCL) += 1; 5593 SAVSTK(); 5594 PUSH(YSPPTR); 5595 GENVUP(XPTR); 5596 PUSH(XPTR); 5597L_DEFIN9: 5598 D_V(DEFCL) = D_A(YCL); 5599L_DEFIN8: 5600 S_L(XSP) -= 1; 5601 S_O(XSP) += 1; 5602 switch (STREAM(YSP, XSP, &VARATB)) { 5603 case ST_ERROR: 5604 BRANCH(PROTER) 5605 case ST_EOS: 5606 goto L_DEF10; 5607 } 5608 if (D_A(STYPE) != CMATYP) 5609 BRANCH(PROTER) 5610 if (S_L(YSP) == 0) 5611 goto L_DEFIN8; 5612 SAVSTK(); 5613 PUSH(YSPPTR); 5614 GENVUP(XPTR); 5615 PUSH(XPTR); 5616 D_A(YCL) += 1; 5617 goto L_DEFIN8; 5618 /*_*/ 5619L_DEF10: 5620 if (S_L(YSP) == 0) 5621 goto L_DEF11; 5622 SAVSTK(); 5623 PUSH(YSPPTR); 5624 GENVUP(XPTR); 5625 PUSH(XPTR); 5626 D_A(YCL) += 1; 5627L_DEF11: 5628 D_A(YCL) += 2; 5629 D_A(XCL) = D_A(YCL); 5630 D_A(XCL) *= DESCR; 5631 D_F(XCL) = D_V(XCL) = 0; 5632 D_V(XCL) = B; 5633 SAVSTK(); 5634 PUSH(XCL); 5635 BLOCK(XPTR); 5636 D(D_A(ZCL)) = D(DEFCL); 5637 D(D_A(ZCL) + DESCR) = D(XPTR); 5638 D_A(XPTR) += D_A(XCL); 5639L_DEF12: 5640 D_A(XPTR) -= DESCR; 5641 POP(YPTR); 5642 D(D_A(XPTR) + DESCR) = D(YPTR); 5643 D_A(YCL) -= 1; 5644 if (D_A(YCL) == 0) 5645 BRANCH(RETNUL) 5646 else 5647 goto L_DEF12; 5648 /*_*/ 5649} 5650int 5651DEFFNC(retval) 5652 ret_t retval; 5653{ 5654 ENTRY(DEFFNC) 5655 D_A(XCL) = D_V(INCL); 5656 D_F(XCL) = D_V(XCL) = 0; 5657 D(WCL) = D(XCL); 5658 D(YCL) = D(INCL); 5659 PSTACK(YPTR); 5660 PUSH(NULVCL); 5661L_DEFF1: 5662 D_A(OCICL) += DESCR; 5663 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 5664 if ((D_F(XPTR) & FNC)) 5665 goto L_DEFFC; 5666L_DEFF2: 5667 if (D_A(INSW) == 0) 5668 goto L_DEFF14; 5669 if (!LOCAPV(ZPTR,INATL,XPTR)) 5670 goto L_DEFF14; 5671 D(ZPTR) = D(D_A(ZPTR) + DESCR); 5672 PUSH(XCL); 5673 PUSH(WCL); 5674 PUSH(YCL); 5675 PUSH(YPTR); 5676 SAVSTK(); 5677 PUSH(XPTR); 5678 PUSH(ZPTR); 5679 switch (PUTIN(XPTR)) { 5680 case 1: 5681 BRANCH(FAIL) 5682 } 5683 POP(YPTR); 5684 POP(YCL); 5685 POP(WCL); 5686 POP(XCL); 5687 goto L_DEFF3; 5688 /*_*/ 5689L_DEFF14: 5690 D(XPTR) = D(D_A(XPTR) + DESCR); 5691L_DEFF3: 5692 PUSH(XPTR); 5693 D_A(XCL) -= 1; 5694 if (D_A(XCL) < 0) 5695 BRANCH(INTR10) 5696 if (D_A(XCL) > 0) 5697 goto L_DEFF1; 5698 D(XCL) = D(D_A(YCL)); 5699 D_A(XCL) = D_V(XCL); 5700 D_F(XCL) = D_V(XCL) = 0; 5701L_DEFF4: 5702 if (D_A(WCL) == D_A(XCL)) 5703 goto L_DEFF5; 5704 if (D_A(WCL) > D_A(XCL)) 5705 goto L_DEFF9; 5706 PUSH(NULVCL); 5707 D_A(WCL) += 1; 5708 goto L_DEFF4; 5709 /*_*/ 5710L_DEFF9: 5711 POP(ZCL); 5712 D_A(WCL) -= 1; 5713 goto L_DEFF4; 5714 /*_*/ 5715L_DEFF5: 5716 D(ZCL) = D(D_A(YCL) + DESCR); 5717 D(XPTR) = D(ZCL); 5718 D_A(WCL) = D_V(D_A(ZCL)); 5719 D_F(WCL) = D_V(WCL) = 0; 5720 D(WPTR) = D(ZCL); 5721 D_A(WPTR) += D_A(WCL); 5722 D_A(XCL) += 1; 5723L_DEFF8: 5724 D_A(XPTR) += DESCR; 5725 D_A(YPTR) += DESCR; 5726 D(ZPTR) = D(D_A(XPTR) + DESCR); 5727 D(TPTR) = D(D_A(ZPTR) + DESCR); 5728 D(ATPTR) = D(D_A(YPTR) + DESCR); 5729 D(D_A(ZPTR) + DESCR) = D(ATPTR); 5730 D(D_A(YPTR) + DESCR) = D(TPTR); 5731 D_A(XCL) -= 1; 5732 if (D_A(XCL) < 0) 5733 BRANCH(INTR10) 5734 if (D_A(XCL) > 0) 5735 goto L_DEFF8; 5736L_DEFF10: 5737 D_A(XPTR) += DESCR; 5738 if (D_A(XPTR) == D_A(WPTR)) 5739 goto L_DEFFGO; 5740 D(ZPTR) = D(D_A(XPTR) + DESCR); 5741 D(TPTR) = D(D_A(ZPTR) + DESCR); 5742 PUSH(TPTR); 5743 D(D_A(ZPTR) + DESCR) = D(NULVCL); 5744 goto L_DEFF10; 5745 /*_*/ 5746L_DEFFGO: 5747 PUSH(FILENM); 5748 PUSH(LNNOCL); 5749 PUSH(FRTNCL); 5750 PUSH(STNOCL); 5751 PUSH(OCICL); 5752 PUSH(OCBSCL); 5753 PUSH(ZCL); 5754 PUSH(ZCL); 5755 D(XCL) = D(D_A(ZCL) + DESCR); 5756 if (D_A(D_A(XCL) + ATTRIB) == (int_t)0) 5757 BRANCH(UNDFFE) 5758 D(OCBSCL) = D(D_A(XCL) + ATTRIB); 5759 if (D_A(TRACL) <= 0) 5760 goto L_DEFF18; 5761 D_A(TRACL) -= 1; 5762 D(ATPTR) = D(D_A(ZCL) + 2*DESCR); 5763 PUSH(ZCL); 5764 SAVSTK(); 5765 PUSH(ATPTR); 5766 switch (FENTR2(NORET)) { 5767 case 1: 5768 case 2: 5769 BRANCH(INTR10) 5770 } 5771 POP(ZCL); 5772L_DEFF18: 5773 if (D_A(TRAPCL) <= 0) 5774 goto L_DEFF19; 5775 D(ATPTR) = D(D_A(ZCL) + 2*DESCR); 5776 if (!LOCAPT(ATPTR,TFENTL,ATPTR)) 5777 goto L_DEFF19; 5778 PUSH(OCBSCL); 5779 PUSH(ZCL); 5780 SAVSTK(); 5781 PUSH(ATPTR); 5782 TRPHND(NORET); 5783 POP(ZCL); 5784 POP(OCBSCL); 5785L_DEFF19: 5786 D_A(LVLCL) += 1; 5787 if (D_A(TRAPCL) <= 0) 5788 goto L_DEFF15; 5789 if (!LOCAPT(ATPTR,TKEYL,FNCLKY)) 5790 goto L_DEFF15; 5791 SAVSTK(); 5792 PUSH(ATPTR); 5793 TRPHND(NORET); 5794L_DEFF15: 5795 D_A(OCICL) = 0; 5796 SAVSTK(); 5797 switch (INTERP(NORET)) { 5798 case 1: 5799 goto L_DEFFF; 5800 case 2: 5801 goto L_DEFFNR; 5802 } 5803 D(RETPCL) = D(RETCL); 5804L_DEFFS1: 5805 POP(ZCL); 5806 if (D_A(TRACL) <= 0) 5807 goto L_DEFF20; 5808 D_A(TRACL) -= 1; 5809 D(ATPTR) = D(D_A(ZCL) + 2*DESCR); 5810 PUSH(ZCL); 5811 SAVSTK(); 5812 PUSH(ATPTR); 5813 switch (FNEXT2(NORET)) { 5814 case 1: 5815 case 2: 5816 BRANCH(INTR10) 5817 } 5818 POP(ZCL); 5819L_DEFF20: 5820 if (D_A(TRAPCL) <= 0) 5821 goto L_DEFFS2; 5822 D(ATPTR) = D(D_A(ZCL) + 2*DESCR); 5823 if (!LOCAPT(ATPTR,TFEXTL,ATPTR)) 5824 goto L_DEFFS2; 5825 PUSH(RETPCL); 5826 PUSH(ZCL); 5827 SAVSTK(); 5828 PUSH(ATPTR); 5829 TRPHND(NORET); 5830 POP(ZCL); 5831 POP(RETPCL); 5832L_DEFFS2: 5833 D_A(LVLCL) -= 1; 5834 if (D_A(TRAPCL) <= 0) 5835 goto L_DEFF17; 5836 if (!LOCAPT(ATPTR,TKEYL,FNCLKY)) 5837 goto L_DEFF17; 5838 PUSH(RETPCL); 5839 PUSH(ZCL); 5840 SAVSTK(); 5841 PUSH(ATPTR); 5842 TRPHND(NORET); 5843 POP(ZCL); 5844 POP(RETPCL); 5845L_DEFF17: 5846 POP(ZCL); 5847 POP(OCBSCL); 5848 POP(OCICL); 5849 POP(STNOCL); 5850 POP(FRTNCL); 5851 POP(LNNOCL); 5852 POP(FILENM); 5853 D_A(WCL) = D_V(D_A(ZCL)); 5854 D_F(WCL) = D_V(WCL) = 0; 5855 D_A(WCL) -= DESCR; 5856 if (D_A(WCL) <= 0) 5857 BRANCH(INTR10) 5858 D(WPTR) = D(ZCL); 5859 D_A(WPTR) += D_A(WCL); 5860 D(YPTR) = D(ZCL); 5861 D_A(YPTR) += DESCR; 5862 D(ZPTR) = D(D_A(YPTR) + DESCR); 5863 D(ZPTR) = D(D_A(ZPTR) + DESCR); 5864L_DEFF6: 5865 POP(XPTR); 5866 D(YPTR) = D(D_A(WPTR) + DESCR); 5867 D(D_A(YPTR) + DESCR) = D(XPTR); 5868 D_A(WPTR) -= DESCR; 5869 if (D_A(WPTR) != D_A(ZCL)) 5870 goto L_DEFF6; 5871 if (DCMP(RETPCL, FRETCL)) 5872 BRANCH(FAIL) 5873 if (!DCMP(RETPCL, NRETCL)) 5874 BRANCH(RTZPTR) 5875 D(XPTR) = D(ZPTR); 5876 if (D_V(XPTR) == S) 5877 goto L_DEFFVX; 5878 if (D_V(XPTR) == I) 5879 BRANCH(GENVIX) 5880 if (D_V(XPTR) == N) 5881 BRANCH(RTXNAM) 5882 if (D_V(XPTR) == K) 5883 BRANCH(RTXNAM) 5884 else 5885 BRANCH(NONAME) 5886L_DEFFVX: 5887 if (D_A(XPTR) == 0) 5888 BRANCH(NONAME) 5889 else 5890 BRANCH(RTXNAM) 5891 /*_*/ 5892L_DEFFF: 5893 D(RETPCL) = D(FRETCL); 5894 goto L_DEFFS1; 5895 /*_*/ 5896L_DEFFC: 5897 PUSH(XCL); 5898 PUSH(WCL); 5899 PUSH(YCL); 5900 PUSH(YPTR); 5901 SAVSTK(); 5902 PUSH(XPTR); 5903 switch (INVOKE(XPTR)) { 5904 case 1: 5905 BRANCH(FAIL) 5906 case 2: 5907 goto L_DEFFN; 5908 } 5909 POP(YPTR); 5910 POP(YCL); 5911 POP(WCL); 5912 POP(XCL); 5913 goto L_DEFF3; 5914 /*_*/ 5915L_DEFFN: 5916 POP(YPTR); 5917 POP(YCL); 5918 POP(WCL); 5919 POP(XCL); 5920 goto L_DEFF2; 5921 /*_*/ 5922L_DEFFNR: 5923 D(RETPCL) = D(NRETCL); 5924 goto L_DEFFS1; 5925 /*_*/ 5926} 5927int 5928LOAD(retval) 5929 ret_t retval; 5930{ 5931 ENTRY(LOAD) 5932 SAVSTK(); 5933 switch (VARVAL(XPTR)) { 5934 case 1: 5935 BRANCH(FAIL) 5936 } 5937 PUSH(XPTR); 5938 SAVSTK(); 5939 switch (VARVAL(WPTR)) { 5940 case 1: 5941 BRANCH(FAIL) 5942 } 5943 POP(XPTR); 5944 /* FALL */ 5945 BRANCH(LOAD2) 5946} 5947static int 5948LOAD2(retval) 5949 ret_t retval; 5950{ 5951 ENTRY(LOAD2) 5952 X_LOCSP(VSP,WPTR); 5953 X_LOCSP(XSP,XPTR); 5954 switch (STREAM(YSP, XSP, &VARATB)) { 5955 case ST_ERROR: 5956 case ST_EOS: 5957 BRANCH(PROTER) 5958 } 5959 if (D_A(STYPE) != LPTYP) 5960 BRANCH(PROTER) 5961 SAVSTK(); 5962 PUSH(YSPPTR); 5963 GENVUP(XPTR); 5964 SAVSTK(); 5965 PUSH(XPTR); 5966 FINDEX(ZCL); 5967 D(YCL) = D(ZEROCL); 5968L_LOAD4: 5969 S_L(XSP) -= 1; 5970 S_O(XSP) += 1; 5971 switch (STREAM(ZSP, XSP, &VARATB)) { 5972 case ST_ERROR: 5973 goto L_LOAD1; 5974 case ST_EOS: 5975 BRANCH(PROTER) 5976 } 5977 switch (D_A(STYPE)) { 5978 case 1: 5979 BRANCH(PROTER) 5980 case 3: 5981 goto L_LOAD6; 5982 } 5983 SAVSTK(); 5984 PUSH(ZSPPTR); 5985 GENVUP(XPTR); 5986 if (!LOCAPV(XPTR,DTATL,XPTR)) 5987 goto L_LOAD9; 5988 D(XPTR) = D(D_A(XPTR) + DESCR); 5989 PUSH(XPTR); 5990L_LOAD10: 5991 D_A(YCL) += 1; 5992 goto L_LOAD4; 5993 /*_*/ 5994L_LOAD6: 5995 D_A(YCL) += 1; 5996 SAVSTK(); 5997 PUSH(ZSPPTR); 5998 GENVAR(XPTR); 5999 if (!LOCAPV(XPTR,DTATL,XPTR)) 6000 goto L_LOAD11; 6001 D(XPTR) = D(D_A(XPTR) + DESCR); 6002 PUSH(XPTR); 6003L_LOAD13: 6004 S_L(XSP) -= 1; 6005 S_O(XSP) += 1; 6006 SAVSTK(); 6007 PUSH(XSPPTR); 6008 GENVAR(XPTR); 6009 if (!LOCAPV(XPTR,DTATL,XPTR)) 6010 goto L_LOAD7; 6011 D(XPTR) = D(D_A(XPTR) + DESCR); 6012 PUSH(XPTR); 6013L_LOAD8: 6014 D_V(LODCL) = D_A(YCL); 6015 D_A(YCL) += 1; 6016 D_A(XCL) = D_A(YCL); 6017 D_A(XCL) *= DESCR; 6018 D_F(XCL) = D_V(XCL) = 0; 6019 D_A(XCL) += DESCR; 6020 D_V(XCL) = B; 6021 SAVSTK(); 6022 PUSH(XCL); 6023 BLOCK(XPTR); 6024 D(D_A(ZCL)) = D(LODCL); 6025 D(D_A(ZCL) + DESCR) = D(XPTR); 6026 D_A(XPTR) += D_A(XCL); 6027L_LOAD12: 6028 D_A(XPTR) -= DESCR; 6029 POP(YPTR); 6030 D(D_A(XPTR) + DESCR) = D(YPTR); 6031 D_A(YCL) -= 1; 6032 if (D_A(YCL) > 0) 6033 goto L_LOAD12; 6034 if (!_LOAD(YPTR,YSP,VSP)) 6035 BRANCH(FAIL) 6036 D(D_A(XPTR)) = D(YPTR); 6037 BRANCH(RETNUL) 6038 /*_*/ 6039L_LOAD7: 6040 PUSH(ZEROCL); 6041 goto L_LOAD8; 6042 /*_*/ 6043L_LOAD9: 6044 PUSH(ZEROCL); 6045 goto L_LOAD10; 6046 /*_*/ 6047L_LOAD1: 6048 PUSH(ZEROCL); 6049 _SPEC(TSP) = _SPEC(XSP); 6050 S_L(TSP) = 1; 6051 D_A(YCL) += 1; 6052 if (LEXEQ(TSP,RPRNSP)) 6053 goto L_LOAD13; 6054 else 6055 goto L_LOAD4; 6056 /*_*/ 6057L_LOAD11: 6058 PUSH(ZEROCL); 6059 goto L_LOAD13; 6060 /*_*/ 6061} 6062int 6063UNLOAD(retval) 6064 ret_t retval; 6065{ 6066 ENTRY(UNLOAD) 6067 SAVSTK(); 6068 switch (VARVUP(XPTR)) { 6069 case 1: 6070 BRANCH(FAIL) 6071 } 6072 SAVSTK(); 6073 PUSH(XPTR); 6074 FINDEX(ZCL); 6075 D(D_A(ZCL)) = D(UNDFCL); 6076 X_LOCSP(XSP,XPTR); 6077 _UNLOAD(XSP); 6078 BRANCH(RETNUL) 6079 /*_*/ 6080} 6081int 6082LNKFNC(retval) 6083 ret_t retval; 6084{ 6085 ENTRY(LNKFNC) 6086 D_A(XCL) = D_V(INCL); 6087 D_F(XCL) = D_V(XCL) = 0; 6088 D(YCL) = D(INCL); 6089 D(WCL) = D(D_A(YCL)); 6090 D_A(WCL) = D_V(WCL); 6091 D_F(WCL) = D_V(WCL) = 0; 6092 D(WPTR) = D(ZEROCL); 6093 D(ZCL) = D(D_A(YCL) + DESCR); 6094 PSTACK(YPTR); 6095 D_A(TCL) = (int_t) (2*DESCR); 6096L_LNKF1: 6097 PUSH(XCL); 6098 PUSH(ZCL); 6099 PUSH(TCL); 6100 PUSH(YPTR); 6101 PUSH(WCL); 6102 PUSH(YCL); 6103 PUSH(WPTR); 6104 SAVSTK(); 6105 switch (ARGVAL(XPTR)) { 6106 case 1: 6107 BRANCH(FAIL) 6108 } 6109 POP(WPTR); 6110 POP(YCL); 6111 POP(WCL); 6112 POP(YPTR); 6113 POP(TCL); 6114 POP(ZCL); 6115 POP(XCL); 6116 D_A(WCL) -= 1; 6117 if (D_A(WCL) < 0) 6118 goto L_LNKF6; 6119 D(ZPTR) = D(D_A(ZCL) + D_A(TCL)); 6120 if (D_V(ZPTR) == 0) 6121 goto L_LNKF6; 6122 if (D_V(ZPTR) == D_V(XPTR)) 6123 goto L_LNKF6; 6124 D_A(DTCL) = D_V(XPTR); 6125 D_F(DTCL) = D_V(DTCL) = 0; 6126 D_V(DTCL) = D_V(ZPTR); 6127 if (DCMP(DTCL, VIDTP)) 6128 goto L_LNKVI; 6129 if (DCMP(DTCL, IVDTP)) 6130 goto L_LNKIV; 6131 if (DCMP(DTCL, RIDTP)) 6132 goto L_LNKRI; 6133 if (DCMP(DTCL, IRDTP)) 6134 goto L_LNKIR; 6135 if (DCMP(DTCL, RVDTP)) 6136 goto L_LNKRV; 6137 if (DCMP(DTCL, VRDTP)) 6138 goto L_LNKVR; 6139 else 6140 BRANCH(INTR1) 6141L_LNKIV: 6142 SAVSTK(); 6143 PUSH(XPTR); 6144 switch (GNVARI(XPTR)) { 6145 case 1: 6146 goto L_LNKF6; 6147 } 6148 /*_*/ 6149L_LNKRI: 6150 CLR_MATH_ERROR(); 6151 D_A(XPTR) = (int_t) D_RV(XPTR); 6152 D_F(XPTR) = 0; 6153 D_V(XPTR) = I; 6154 if (MATH_ERROR()) 6155 BRANCH(INTR1) 6156 goto L_LNKF6; 6157 /*_*/ 6158L_LNKIR: 6159 D_RV(XPTR) = (real_t)D_A(XPTR); 6160 D_F(XPTR) = 0; 6161 D_V(XPTR) = R; 6162 goto L_LNKF6; 6163 /*_*/ 6164L_LNKVR: 6165 X_LOCSP(XSP,XPTR); 6166 if (SPCINT(XPTR,XSP)) 6167 goto L_LNKIR; 6168 if (SPREAL(XPTR,XSP)) 6169 goto L_LNKF6; 6170 else 6171 BRANCH(INTR1) 6172 /*_*/ 6173L_LNKRV: 6174 REALST(XSP,XPTR); 6175 SAVSTK(); 6176 PUSH(XSPPTR); 6177 switch (GENVAR(XPTR)) { 6178 case 1: 6179 goto L_LNKF6; 6180 } 6181 /*_*/ 6182L_LNKVI: 6183 X_LOCSP(XSP,XPTR); 6184 if (SPCINT(XPTR,XSP)) 6185 goto L_LNKF6; 6186 if (SPREAL(XPTR,XSP)) 6187 goto L_LNKRI; 6188 else 6189 BRANCH(INTR1) 6190L_LNKF6: 6191 D_A(TCL) += DESCR; 6192 PUSH(XPTR); 6193 D_A(WPTR) += 1; 6194 D_A(XCL) -= 1; 6195 if (D_A(XCL) > 0) 6196 goto L_LNKF1; 6197L_LNKF4: 6198 if (D_A(WCL) <= 0) 6199 goto L_LNKF5; 6200 PUSH(NULVCL); 6201 D_A(WPTR) += 1; 6202 D_A(WCL) -= 1; 6203 goto L_LNKF4; 6204 /*_*/ 6205L_LNKF5: 6206 D_A(WCL) = D_V(D_A(ZCL)); 6207 D_F(WCL) = D_V(WCL) = 0; 6208 D(XPTR) = D(ZCL); 6209 D_A(XPTR) += D_A(WCL); 6210 D(ZPTR) = D(D_A(XPTR)); 6211 D(ZCL) = D(D_A(ZCL) + DESCR); 6212 D_A(YPTR) += 2*DESCR; 6213 if (!CALLX(ZPTR,YPTR,WPTR,ZCL)) 6214 BRANCH(FAIL) 6215 if (D_V(ZPTR) != L) 6216 BRANCH(RTZPTR) 6217 _SPEC(ZSP) = _SPEC(D_A(ZPTR)); 6218 BRANCH(GENVRZ) 6219 /*_*/ 6220} 6221int 6222ARRAY(retval) 6223 ret_t retval; 6224{ 6225 ENTRY(ARRAY) 6226 SAVSTK(); 6227 switch (VARVAL(XPTR)) { 6228 case 1: 6229 BRANCH(FAIL) 6230 } 6231 PUSH(XPTR); 6232 SAVSTK(); 6233 switch (ARGVAL(TPTR)) { 6234 case 1: 6235 BRANCH(FAIL) 6236 } 6237 POP(XPTR); 6238 D_A(ARRMRK) = 0; 6239 D(WCL) = D(ZEROCL); 6240 D(XCL) = D(ONECL); 6241 X_LOCSP(XSP,XPTR); 6242 PUSH(XPTR); 6243L_ARRAY1: 6244 switch (STREAM(YSP, XSP, &NUMBTB)) { 6245 case ST_ERROR: 6246 BRANCH(PROTER) 6247 case ST_EOS: 6248 goto L_ARROT1; 6249 } 6250 if (!SPCINT(YCL,YSP)) 6251 BRANCH(PROTER) 6252 switch (D_A(STYPE)) { 6253 case 2: 6254 goto L_ARRAY3; 6255 } 6256 S_L(XSP) -= 1; 6257 S_O(XSP) += 1; 6258 switch (STREAM(ZSP, XSP, &NUMBTB)) { 6259 case ST_ERROR: 6260 BRANCH(PROTER) 6261 case ST_EOS: 6262 goto L_ARROT2; 6263 } 6264 if (!SPCINT(ZCL,ZSP)) 6265 BRANCH(PROTER) 6266 switch (D_A(STYPE)) { 6267 case 1: 6268 BRANCH(PROTER) 6269 case 2: 6270 goto L_ARRAY5; 6271 } 6272 /*_*/ 6273L_ARRAY3: 6274 if (D_A(YCL) <= 0) 6275 BRANCH(PROTER) 6276 D(ZCL) = D(YCL); 6277 D_A(YCL) = 1; 6278 goto L_ARRAY6; 6279 /*_*/ 6280L_ARRAY5: 6281 D_A(ZCL) -= D_A(YCL); 6282 D_A(ZCL) += D_A(ONECL); 6283 if (D_A(ZCL) < 0) 6284 BRANCH(PROTER) 6285L_ARRAY6: 6286 D_V(YCL) = D_A(ZCL); 6287 PUSH(YCL); 6288 CLR_MATH_ERROR(); 6289 D_A(XCL) *= D_A(ZCL); 6290 if (MATH_ERROR()) 6291 BRANCH(PROTER) 6292 D_A(WCL) += 1; 6293 if (D_A(ARRMRK) != 0) 6294 goto L_ARRAY7; 6295 S_L(XSP) -= 1; 6296 S_O(XSP) += 1; 6297 goto L_ARRAY1; 6298 /*_*/ 6299L_ARROT1: 6300 D_A(ARRMRK) = 1; 6301 if (SPCINT(YCL,YSP)) 6302 goto L_ARRAY3; 6303 else 6304 BRANCH(PROTER) 6305 /*_*/ 6306L_ARROT2: 6307 D_A(ARRMRK) = 1; 6308 if (SPCINT(ZCL,ZSP)) 6309 goto L_ARRAY5; 6310 else 6311 BRANCH(PROTER) 6312 /*_*/ 6313L_ARRAY7: 6314 D(ZCL) = D(XCL); 6315 D_A(ZCL) += D_A(WCL); 6316 D_A(ZCL) += 2; 6317 D_A(ZCL) *= DESCR; 6318 D_F(ZCL) = D_V(ZCL) = 0; 6319 D_V(ZCL) = A; 6320 SAVSTK(); 6321 PUSH(ZCL); 6322 BLOCK(ZPTR); 6323 D(XPTR) = D(ZPTR); 6324 D(WPTR) = D(XPTR); 6325 D_A(WPTR) += D_A(ZCL); 6326 D(D_A(ZPTR) + 2*DESCR) = D(WCL); 6327 D_A(XPTR) += DESCR; 6328L_ARRAY8: 6329 D_A(XPTR) += DESCR; 6330 POP(YPTR); 6331 D(D_A(XPTR) + DESCR) = D(YPTR); 6332 D_A(WCL) -= 1; 6333 if (D_A(WCL) == 0) 6334 goto L_ARRFIL; 6335 if (D_A(WCL) > 0) 6336 goto L_ARRAY8; 6337L_ARRAY9: 6338 D(D_A(XPTR) + DESCR) = D(TPTR); 6339L_ARRFIL: 6340 D_A(XPTR) += DESCR; 6341 if (D_PTR(XPTR) < D_PTR(WPTR)) 6342 goto L_ARRAY9; 6343 if (D_PTR(XPTR) > D_PTR(WPTR)) 6344 BRANCH(INTR10) 6345 POP(WPTR); 6346 D(D_A(ZPTR) + DESCR) = D(WPTR); 6347 BRANCH(RTZPTR) 6348 /*_*/ 6349} 6350int 6351ASSOC(retval) 6352 ret_t retval; 6353{ 6354 ENTRY(ASSOC) 6355 SAVSTK(); 6356 switch (INTVAL(XPTR)) { 6357 case 1: 6358 BRANCH(FAIL) 6359 } 6360 PUSH(XPTR); 6361 SAVSTK(); 6362 switch (INTVAL(WPTR)) { 6363 case 1: 6364 BRANCH(FAIL) 6365 } 6366 CLR_MATH_ERROR(); 6367 D(ZPTR) = D(WPTR); 6368 D_A(ZPTR) *= D_A(DSCRTW); 6369 if (MATH_ERROR()) 6370 BRANCH(SIZERR) 6371 D_A(ZPTR) += 2*DESCR; 6372 if (D_A(ZPTR) >= D_A(SIZLMT)) 6373 BRANCH(SIZERR) 6374 POP(XPTR); 6375 if (D_A(XPTR) < 0) 6376 BRANCH(LENERR) 6377 if (D_A(XPTR) > 0) 6378 goto L_ASSOC1; 6379 D_A(XPTR) = (int_t) EXTSIZ; 6380L_ASSOC1: 6381 D_A(XPTR) += 1; 6382 D_A(XPTR) *= 2*DESCR; 6383 D_F(XPTR) = D_V(XPTR) = 0; 6384 if (D_A(WPTR) < 0) 6385 BRANCH(LENERR) 6386 if (D_A(WPTR) > 0) 6387 goto L_ASSOC4; 6388 D_A(WPTR) = (int_t) EXTSIZ; 6389L_ASSOC4: 6390 D_A(WPTR) += 1; 6391 D_A(WPTR) *= 2*DESCR; 6392 D_F(WPTR) = D_V(WPTR) = 0; 6393 D_V(XPTR) = T; 6394 /* FALL */ 6395 BRANCH(ASSOCE) 6396} 6397static int 6398ASSOCE(retval) 6399 ret_t retval; 6400{ 6401 ENTRY(ASSOCE) 6402 SAVSTK(); 6403 PUSH(XPTR); 6404 BLOCK(ZPTR); 6405 D(D_A(ZPTR) + D_A(XPTR)) = D(ONECL); 6406 D_A(XPTR) -= DESCR; 6407 D(D_A(ZPTR) + D_A(XPTR)) = D(WPTR); 6408L_ASSOC2: 6409 D_A(XPTR) -= 2*DESCR; 6410 D(D_A(ZPTR) + D_A(XPTR)) = D(NULVCL); 6411 if (D_A(XPTR) == DESCR) 6412 BRANCH(RTZPTR) 6413 else 6414 goto L_ASSOC2; 6415 /*_*/ 6416} 6417int 6418DATDEF(retval) 6419 ret_t retval; 6420{ 6421 ENTRY(DATDEF) 6422 SAVSTK(); 6423 switch (VARVAL(XPTR)) { 6424 case 1: 6425 BRANCH(FAIL) 6426 } 6427 D_A(DATACL) = 0; 6428 X_LOCSP(XSP,XPTR); 6429 switch (STREAM(YSP, XSP, &VARATB)) { 6430 case ST_ERROR: 6431 case ST_EOS: 6432 BRANCH(PROTER) 6433 } 6434 if (D_A(STYPE) != LPTYP) 6435 BRANCH(PROTER) 6436 SAVSTK(); 6437 PUSH(YSPPTR); 6438 GENVUP(XPTR); 6439 SAVSTK(); 6440 PUSH(XPTR); 6441 FINDEX(ZCL); 6442 D_V(DATSEG) += 1; 6443 if (D_V(DATSEG) == DATSIZ) 6444 BRANCH(INTR27) 6445 D(YCL) = D(ZEROCL); 6446 SAVSTK(); 6447 PUSH(XPTR); 6448 PUSH(DATSEG); 6449 PUSH(DTATL); 6450 AUGATL(DTATL); 6451 PSTACK(WPTR); 6452 PUSH(DATSEG); 6453 PUSH(XPTR); 6454L_DATA3: 6455 S_L(XSP) -= 1; 6456 S_O(XSP) += 1; 6457 if (D_A(DATACL) != 0) 6458 goto L_DAT5; 6459 switch (STREAM(YSP, XSP, &VARATB)) { 6460 case ST_ERROR: 6461 case ST_EOS: 6462 BRANCH(PROTER) 6463 } 6464 switch (D_A(STYPE)) { 6465 case 1: 6466 BRANCH(PROTER) 6467 case 3: 6468 goto L_DATA6; 6469 } 6470L_DATA4: 6471 if (S_L(YSP) == 0) 6472 goto L_DATA3; 6473 SAVSTK(); 6474 PUSH(YSPPTR); 6475 GENVUP(XPTR); 6476 PUSH(XPTR); 6477 SAVSTK(); 6478 PUSH(XPTR); 6479 FINDEX(XCL); 6480 D(WCL) = D(D_A(XCL)); 6481 if (!DCMP(WCL, FLDCL)) 6482 goto L_DAT6; 6483 D(ZPTR) = D(D_A(XCL) + DESCR); 6484 D_A(TCL) = D_A(YCL); 6485 D_A(TCL) *= DESCR; 6486 D_F(TCL) = D_V(TCL) = 0; 6487 SAVSTK(); 6488 PUSH(TCL); 6489 PUSH(DATSEG); 6490 PUSH(ZPTR); 6491 AUGATL(ZPTR); 6492L_DAT7: 6493 D(D_A(XCL) + DESCR) = D(ZPTR); 6494 D_A(YCL) += 1; 6495 goto L_DATA3; 6496 /*_*/ 6497L_DATA6: 6498 D_A(DATACL) = 1; 6499 goto L_DATA4; 6500 /*_*/ 6501L_DAT5: 6502 if (S_L(XSP) != 0) 6503 BRANCH(PROTER) 6504 if (D_A(YCL) == 0) 6505 BRANCH(PROTER) 6506 D_V(DATCL) = D_A(YCL); 6507 D(D_A(ZCL)) = D(DATCL); 6508 D_A(YCL) *= DESCR; 6509 D_F(YCL) = D_V(YCL) = 0; 6510 D_A(YCL) += 2*DESCR; 6511 D_V(YCL) = D_V(DATSEG); 6512 SAVSTK(); 6513 PUSH(YCL); 6514 BLOCK(ZPTR); 6515 D_A(WPTR) += DESCR; 6516 MOVBLK(D_A(ZPTR),D_A(WPTR),D_A(YCL)); 6517 D(D_A(ZCL) + DESCR) = D(ZPTR); 6518 BRANCH(RETNUL) 6519 /*_*/ 6520L_DAT6: 6521 D(D_A(XCL)) = D(FLDCL); 6522 SAVSTK(); 6523 PUSH(TWOCL); 6524 BLOCK(ZPTR); 6525 D(D_A(ZPTR) + DESCR) = D(DATSEG); 6526 D_A(TCL) = D_A(YCL); 6527 D_A(TCL) *= DESCR; 6528 D_F(TCL) = D_V(TCL) = 0; 6529 D(D_A(ZPTR) + 2*DESCR) = D(TCL); 6530 goto L_DAT7; 6531 /*_*/ 6532} 6533int 6534PROTO(retval) 6535 ret_t retval; 6536{ 6537 ENTRY(PROTO) 6538 SAVSTK(); 6539 switch (ARGVAL(XPTR)) { 6540 case 1: 6541 BRANCH(FAIL) 6542 } 6543 if (D_V(XPTR) != A) 6544 BRANCH(NONARY) 6545 D(ZPTR) = D(D_A(XPTR) + DESCR); 6546 BRANCH(RTZPTR) 6547 /*_*/ 6548} 6549int 6550FREEZE(retval) 6551 ret_t retval; 6552{ 6553 ENTRY(FREEZE) 6554 SAVSTK(); 6555 switch (ARGVAL(XPTR)) { 6556 case 1: 6557 BRANCH(FAIL) 6558 } 6559 if (D_V(XPTR) != T) 6560 BRANCH(NONARY) 6561 D_F(D_A(XPTR)) |= FRZN; 6562 BRANCH(RETNUL) 6563 /*_*/ 6564} 6565int 6566THAW(retval) 6567 ret_t retval; 6568{ 6569 ENTRY(THAW) 6570 SAVSTK(); 6571 switch (ARGVAL(XPTR)) { 6572 case 1: 6573 BRANCH(FAIL) 6574 } 6575 if (D_V(XPTR) != T) 6576 BRANCH(NONARY) 6577 D_F(D_A(XPTR)) &= ~(FRZN); 6578 BRANCH(RETNUL) 6579 /*_*/ 6580} 6581int 6582ITEM(retval) 6583 ret_t retval; 6584{ 6585 ENTRY(ITEM) 6586 D_A(XCL) = D_V(INCL); 6587 D_F(XCL) = D_V(XCL) = 0; 6588 D_A(XCL) -= 1; 6589 PUSH(XCL); 6590 SAVSTK(); 6591 switch (ARGVAL(YCL)) { 6592 case 1: 6593 BRANCH(FAIL) 6594 } 6595 POP(XCL); 6596 if (D_V(YCL) == A) 6597 goto L_ARYAD3; 6598 if (D_V(YCL) == T) 6599 goto L_ASSCR; 6600 else 6601 BRANCH(NONARY) 6602L_ARYAD3: 6603 D(WCL) = D(XCL); 6604L_ARYAD1: 6605 if (D_A(XCL) <= 0) 6606 goto L_ARYAD2; 6607 PUSH(XCL); 6608 PUSH(WCL); 6609 PUSH(YCL); 6610 SAVSTK(); 6611 switch (INTVAL(XPTR)) { 6612 case 1: 6613 BRANCH(FAIL) 6614 } 6615 POP(YCL); 6616 POP(WCL); 6617 POP(XCL); 6618 PUSH(XPTR); 6619 D_A(XCL) -= 1; 6620 goto L_ARYAD1; 6621 /*_*/ 6622L_ARYAD2: 6623 D(ZPTR) = D(ZEROCL); 6624 D(ZCL) = D(D_A(YCL) + 2*DESCR); 6625 D_A(YPTR) = D_A(ZCL); 6626 D_A(YPTR) *= DESCR; 6627 D_F(YPTR) = D_V(YPTR) = 0; 6628 D_A(YPTR) = D_A(YCL) + D_A(YPTR); 6629 D_F(YPTR) = D_F(YCL); 6630 D_V(YPTR) = D_V(YCL); 6631 D_A(YPTR) += 2*DESCR; 6632L_ARYAD7: 6633 if (D_A(WCL) == D_A(ZCL)) 6634 goto L_ARYAD9; 6635 if (D_A(WCL) > D_A(ZCL)) 6636 BRANCH(ARGNER) 6637 PUSH(ZEROCL); 6638 D_A(WCL) += 1; 6639 goto L_ARYAD7; 6640 /*_*/ 6641L_ARYAD9: 6642 D_A(YCL) += 2*DESCR; 6643 D(WPTR) = D(D_A(YCL) + DESCR); 6644 D_A(TPTR) = D_V(WPTR); 6645 D_F(TPTR) = D_V(TPTR) = 0; 6646L_ARYA11: 6647 POP(XPTR); 6648 D_A(XPTR) -= D_A(WPTR); 6649 if (D_A(XPTR) < 0) 6650 BRANCH(FAIL) 6651 if (D_A(XPTR) >= D_A(TPTR)) 6652 BRANCH(FAIL) 6653 D_A(XPTR) = D_A(ZPTR) + D_A(XPTR); 6654 D_F(XPTR) = D_F(ZPTR); 6655 D_V(XPTR) = D_V(ZPTR); 6656 D_A(ZCL) -= 1; 6657 if (D_A(ZCL) == 0) 6658 goto L_ARYA12; 6659 D_A(YCL) += DESCR; 6660 D(WPTR) = D(D_A(YCL) + DESCR); 6661 D_A(TPTR) = D_V(WPTR); 6662 D_F(TPTR) = D_V(TPTR) = 0; 6663 D(ZPTR) = D(XPTR); 6664 D_A(ZPTR) *= D_A(TPTR); 6665 goto L_ARYA11; 6666 /*_*/ 6667L_ARYA12: 6668 D_A(XPTR) *= DESCR; 6669 D_F(XPTR) = D_V(XPTR) = 0; 6670 D_A(XPTR) = D_A(YPTR) + D_A(XPTR); 6671 D_F(XPTR) = D_F(YPTR); 6672 D_V(XPTR) = D_V(YPTR); 6673L_ARYA10: 6674 D_V(XPTR) = N; 6675 BRANCH(RTXNAM) 6676 /*_*/ 6677L_ASSCR: 6678 if (D_A(XCL) != 1) 6679 BRANCH(ARGNER) 6680 PUSH(YCL); 6681 SAVSTK(); 6682 switch (ARGVAL(YPTR)) { 6683 case 1: 6684 BRANCH(FAIL) 6685 } 6686 POP(XPTR); 6687 D(YCL) = D(XPTR); 6688L_ASSCR5: 6689 if (LOCAPV(XPTR,XPTR,YPTR)) 6690 goto L_ARYA10; 6691 D_A(TCL) = D_V(D_A(XPTR)); 6692 D_F(TCL) = D_V(TCL) = 0; 6693 D(ZPTR) = D(D_A(XPTR) + D_A(TCL)); 6694 if (D_A(ZPTR) == 1) 6695 goto L_ASSCR6; 6696 D(XPTR) = D(ZPTR); 6697 goto L_ASSCR5; 6698 /*_*/ 6699L_ASSCR6: 6700 if ((D_F(D_A(YCL)) & FRZN)) 6701 BRANCH(RETNUL) 6702 if (!LOCAPV(XPTR,XPTR,ZEROCL)) 6703 goto L_ASSCR3; 6704L_ASSCR8: 6705 D(D_A(XPTR) + 2*DESCR) = D(YPTR); 6706 goto L_ARYA10; 6707 /*_*/ 6708L_ASSCR3: 6709 D_A(TCL) -= DESCR; 6710 D(WPTR) = D(D_A(XPTR) + D_A(TCL)); 6711 D(ZCL) = D(XPTR); 6712 SAVSTK(); 6713 PUSH(WPTR); 6714 BLOCK(ZPTR); 6715 D(XPTR) = D(WPTR); 6716 SAVSTK(); 6717 switch (ASSOCE(XPTR)) { 6718 case 1: 6719 case 2: 6720 BRANCH(INTR10) 6721 } 6722 D_A(TCL) += DESCR; 6723 D(D_A(ZCL) + D_A(TCL)) = D(XPTR); 6724 goto L_ASSCR8; 6725 /*_*/ 6726} 6727int 6728DEFDAT(retval) 6729 ret_t retval; 6730{ 6731 ENTRY(DEFDAT) 6732 D_A(XCL) = D_V(INCL); 6733 D_F(XCL) = D_V(XCL) = 0; 6734 D(WCL) = D(XCL); 6735 D(YCL) = D(INCL); 6736 PSTACK(YPTR); 6737L_DEFD1: 6738 D_A(OCICL) += DESCR; 6739 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 6740 if ((D_F(XPTR) & FNC)) 6741 goto L_DEFDC; 6742L_DEFD2: 6743 if (D_A(INSW) == 0) 6744 goto L_DEFD8; 6745 if (!LOCAPV(ZPTR,INATL,XPTR)) 6746 goto L_DEFD8; 6747 D(ZPTR) = D(D_A(ZPTR) + DESCR); 6748 PUSH(XCL); 6749 PUSH(WCL); 6750 PUSH(YCL); 6751 PUSH(YPTR); 6752 SAVSTK(); 6753 PUSH(XPTR); 6754 PUSH(ZPTR); 6755 switch (PUTIN(XPTR)) { 6756 case 1: 6757 BRANCH(FAIL) 6758 } 6759 POP(YPTR); 6760 POP(YCL); 6761 POP(WCL); 6762 POP(XCL); 6763 goto L_DEFD3; 6764 /*_*/ 6765L_DEFD8: 6766 D(XPTR) = D(D_A(XPTR) + DESCR); 6767L_DEFD3: 6768 PUSH(XPTR); 6769 D_A(XCL) -= 1; 6770 if (D_A(XCL) < 0) 6771 BRANCH(INTR10) 6772 if (D_A(XCL) > 0) 6773 goto L_DEFD1; 6774 D(XCL) = D(D_A(YCL)); 6775 D_A(XCL) = D_V(XCL); 6776 D_F(XCL) = D_V(XCL) = 0; 6777L_DEFD4: 6778 if (D_A(WCL) >= D_A(XCL)) 6779 goto L_DEFD5; 6780 PUSH(NULVCL); 6781 D_A(WCL) += 1; 6782 goto L_DEFD4; 6783 /*_*/ 6784L_DEFD5: 6785 D(WCL) = D(D_A(YCL) + DESCR); 6786 D_A(XCL) *= DESCR; 6787 D_F(XCL) = D_V(XCL) = 0; 6788 D_V(XCL) = D_V(WCL); 6789 SAVSTK(); 6790 PUSH(XCL); 6791 BLOCK(ZPTR); 6792 D_A(YPTR) += DESCR; 6793 MOVBLK(D_A(ZPTR),D_A(YPTR),D_A(XCL)); 6794 BRANCH(RTZPTR) 6795 /*_*/ 6796L_DEFDC: 6797 PUSH(XCL); 6798 PUSH(WCL); 6799 PUSH(YCL); 6800 PUSH(YPTR); 6801 SAVSTK(); 6802 PUSH(XPTR); 6803 switch (INVOKE(XPTR)) { 6804 case 1: 6805 BRANCH(FAIL) 6806 case 2: 6807 goto L_DEFDN; 6808 } 6809 POP(YPTR); 6810 POP(YCL); 6811 POP(WCL); 6812 POP(XCL); 6813 goto L_DEFD3; 6814 /*_*/ 6815L_DEFDN: 6816 POP(YPTR); 6817 POP(YCL); 6818 POP(WCL); 6819 POP(XCL); 6820 goto L_DEFD2; 6821 /*_*/ 6822} 6823int 6824FIELD(retval) 6825 ret_t retval; 6826{ 6827 ENTRY(FIELD) 6828 PUSH(INCL); 6829 SAVSTK(); 6830 switch (ARGVAL(XPTR)) { 6831 case 1: 6832 BRANCH(FAIL) 6833 } 6834 if (DCMP(XPTR, NULVCL)) 6835 BRANCH(NONAME) 6836 POP(YCL); 6837 if (D_V(XPTR) == I) 6838 goto L_FIELD2; 6839 if (D_V(XPTR) != S) 6840 goto L_FIELD1; 6841 if (D_A(CASECL) == 0) 6842 goto L_FIELD1; 6843 SAVSTK(); 6844 switch (VPXPTR(NORET)) { 6845 case 1: 6846 BRANCH(FAIL) 6847 } 6848L_FIELD1: 6849 D_V(DT1CL) = D_V(XPTR); 6850 D(YPTR) = D(D_A(YCL) + DESCR); 6851 if (!LOCAPT(ZCL,YPTR,DT1CL)) 6852 BRANCH(INTR1) 6853 D(ZCL) = D(D_A(ZCL) + 2*DESCR); 6854 D_A(XPTR) += D_A(ZCL); 6855 D_V(XPTR) = N; 6856 BRANCH(RTXNAM) 6857 /*_*/ 6858L_FIELD2: 6859 SAVSTK(); 6860 PUSH(XPTR); 6861 switch (GNVARI(XPTR)) { 6862 case 1: 6863 goto L_FIELD1; 6864 } 6865 /*_*/ 6866} 6867int 6868RSORT(retval) 6869 ret_t retval; 6870{ 6871 ENTRY(RSORT) 6872 D_A(SCL) = 1; 6873 BRANCH(SORT1) 6874 /*_*/ 6875} 6876int 6877SORT(retval) 6878 ret_t retval; 6879{ 6880 ENTRY(SORT) 6881 D_A(SCL) = 0; 6882 /* FALL */ 6883 BRANCH(SORT1) 6884} 6885static int 6886SORT1(retval) 6887 ret_t retval; 6888{ 6889 ENTRY(SORT1) 6890 D_A(WCL) = D_V(INCL); 6891 D_F(WCL) = D_V(WCL) = 0; 6892 PUSH(WCL); 6893 PUSH(SCL); 6894 SAVSTK(); 6895 switch (ARGVAL(XPTR)) { 6896 case 1: 6897 BRANCH(FAIL) 6898 } 6899 D(WPTR) = D(XPTR); 6900 if (D_V(XPTR) == A) 6901 goto L_SORT2; 6902 if (D_V(XPTR) != T) 6903 BRANCH(NONARY) 6904 SAVSTK(); 6905 PUSH(XPTR); 6906 switch (ICNVTA(XPTR)) { 6907 case 1: 6908 BRANCH(FAIL) 6909 } 6910L_SORT2: 6911 POP(SCL); 6912 POP(WCL); 6913 D(XCL) = D(D_A(XPTR) + 2*DESCR); 6914 D_A(YPTR) = D_A(XCL); 6915 D_A(YPTR) *= DESCR; 6916 D_F(YPTR) = D_V(YPTR) = 0; 6917 D_A(YPTR) = D_A(XPTR) + D_A(YPTR); 6918 D_F(YPTR) = D_F(XPTR); 6919 D_V(YPTR) = D_V(XPTR); 6920 D_A(YPTR) += 2*DESCR; 6921 D(YCL) = D(ONECL); 6922 if (D_A(XCL) < 2) 6923 goto L_SORT3; 6924 if (D_A(XCL) > 2) 6925 BRANCH(INTR30) 6926 D(YCL) = D(D_A(XPTR) + 3*DESCR); 6927 D_A(YCL) = D_V(YCL); 6928 D_F(YCL) = D_V(YCL) = 0; 6929L_SORT3: 6930 D(ZCL) = D(D_A(YPTR)); 6931 D_A(ZCL) = D_V(ZCL); 6932 D_F(ZCL) = D_V(ZCL) = 0; 6933 D_A(ZCL) *= DESCR; 6934 D_F(ZCL) = D_V(ZCL) = 0; 6935 D(ZPTR) = D(YPTR); 6936 if (D_A(WCL) < 2) 6937 goto L_SORT5; 6938 if (D_A(WCL) > 2) 6939 BRANCH(ARGNER) 6940 PUSH(WPTR); 6941 PUSH(XPTR); 6942 PUSH(YPTR); 6943 PUSH(ZPTR); 6944 PUSH(XCL); 6945 PUSH(YCL); 6946 PUSH(ZCL); 6947 PUSH(SCL); 6948 SAVSTK(); 6949 switch (ARGVAL(WCL)) { 6950 case 1: 6951 BRANCH(FAIL) 6952 } 6953 POP(SCL); 6954 POP(ZCL); 6955 POP(YCL); 6956 POP(XCL); 6957 POP(ZPTR); 6958 POP(YPTR); 6959 POP(XPTR); 6960 POP(WPTR); 6961 D(A3PTR) = D(ZEROCL); 6962 if (D_V(WCL) == I) 6963 goto L_SORT3C; 6964 if (D_V(WCL) == S) 6965 goto L_SORT3B; 6966 if (D_V(WCL) == R) 6967 goto L_SORT3A; 6968 else 6969 BRANCH(INTR30) 6970 /*_*/ 6971L_SORT3A: 6972 CLR_MATH_ERROR(); 6973 D_A(WCL) = (int_t) D_RV(WCL); 6974 D_F(WCL) = 0; 6975 D_V(WCL) = I; 6976 if (MATH_ERROR()) 6977 BRANCH(INTR30) 6978 goto L_SORT3C; 6979L_SORT3B: 6980 X_LOCSP(XSP,WCL); 6981 if (SPCINT(WCL,XSP)) 6982 goto L_SORT3C; 6983 if (SPREAL(WCL,XSP)) 6984 goto L_SORT3A; 6985 if (D_A(XCL) != 1) 6986 BRANCH(INTR30) 6987 if (!LOCAPV(WCL,FNCPL,WCL)) 6988 BRANCH(INTR30) 6989 D(WCL) = D(D_A(WCL) + DESCR); 6990 D(TCL) = D(D_A(WCL)); 6991 if (D_A(TCL) != D_A(FLDCL)) 6992 BRANCH(INTR30) 6993 D(A3PTR) = D(D_A(WCL) + DESCR); 6994 D(WCL) = D(ONECL); 6995L_SORT3C: 6996 if (D_A(XCL) != 1) 6997 goto L_SORT4; 6998 if (D_A(WCL) == 1) 6999 goto L_SORT5; 7000 else 7001 BRANCH(INTR30) 7002 /*_*/ 7003L_SORT4: 7004 D(TCL) = D(D_A(XPTR) + 3*DESCR); 7005 CLR_MATH_ERROR(); 7006 D_A(WCL) -= D_A(TCL); 7007 if (MATH_ERROR()) 7008 BRANCH(INTR30) 7009 goto L_SORT4A; 7010L_SORT4A: 7011 if (D_A(WCL) < 0) 7012 BRANCH(INTR30) 7013 if (D_A(WCL) >= D_A(YCL)) 7014 BRANCH(INTR30) 7015 CLR_MATH_ERROR(); 7016 D_A(WCL) *= D_A(ZCL); 7017 if (MATH_ERROR()) 7018 BRANCH(INTR30) 7019 D(ZPTR) = D(YPTR); 7020 D_A(ZPTR) += D_A(WCL); 7021L_SORT5: 7022 D_A(XCL) = 0; 7023 if (D_V(WPTR) == A) 7024 goto L_SORTA; 7025 D_A(TCL) = D_V(D_A(XPTR)); 7026 D_F(TCL) = D_V(TCL) = 0; 7027 D(TPTR) = D(XPTR); 7028 D_A(TPTR) += D_A(TCL); 7029 D_A(TPTR) -= D_A(ZCL); 7030 D_A(A4PTR) = (int_t) (-DESCR); 7031 D_A(A5PTR) = 0; 7032 if (D_A(ZPTR) == D_A(YPTR)) 7033 goto L_SORTT1; 7034 D_A(A5PTR) = (int_t) (-DESCR); 7035L_SORTT1: 7036 D_A(WCL) = D_V(D_A(WPTR)); 7037 D_F(WCL) = D_V(WCL) = 0; 7038 D_A(WCL) -= 2*DESCR; 7039 D_A(WCL) = D_A(WPTR) + D_A(WCL); 7040 D_F(WCL) = D_F(WPTR); 7041 D_V(WCL) = D_V(WPTR); 7042L_SORTT2: 7043 D(TCL) = D(D_A(WPTR) + DESCR); 7044 if (DCMP(TCL, NULVCL)) 7045 goto L_SORTT3; 7046 D_A(XCL) += DESCR; 7047 D(A6PTR) = D(WPTR); 7048 D_A(A6PTR) += D_A(A5PTR); 7049 D_A(A6PTR) += 2*DESCR; 7050 D(D_A(TPTR) + D_A(XCL)) = D(A6PTR); 7051 if (D_A(XCL) == D_A(ZCL)) 7052 goto L_SORTGO; 7053L_SORTT3: 7054 D_A(WPTR) += 2*DESCR; 7055 if (D_A(WCL) != D_A(WPTR)) 7056 goto L_SORTT2; 7057 D(WPTR) = D(D_A(WCL) + 2*DESCR); 7058 goto L_SORTT1; 7059 /*_*/ 7060L_SORTA: 7061 D_A(WCL) = D_V(D_A(WPTR)); 7062 D_F(WCL) = D_V(WCL) = 0; 7063 D_V(WCL) = A; 7064 SAVSTK(); 7065 PUSH(WCL); 7066 BLOCK(XPTR); 7067 D_A(A4PTR) = (int_t) (4*DESCR); 7068 MOVBLK(D_A(XPTR),D_A(WPTR),D_A(A4PTR)); 7069 D(TPTR) = D(XPTR); 7070 D_A(TPTR) += D_A(WCL); 7071 D_A(TPTR) -= D_A(ZCL); 7072 D(A5PTR) = D(ZPTR); 7073 D_A(A5PTR) -= D_A(YPTR); 7074 D_F(A5PTR) &= ~(PTR); 7075 D_A(A4PTR) = D_A(ZCL); 7076L_SORTA1: 7077 D_A(XCL) += DESCR; 7078 D_A(ZPTR) += DESCR; 7079 D(D_A(TPTR) + D_A(XCL)) = D(ZPTR); 7080 if (D_A(XCL) != D_A(ZCL)) 7081 goto L_SORTA1; 7082L_SORTGO: 7083 D_A(A6PTR) = D_A(ZCL); 7084L_SORT6: 7085 if (D_A(A6PTR) <= DESCR) 7086 goto L_SORT12; 7087 D_A(A6PTR) /= D_A(TWOCL); 7088 D_A(A6PTR) *= DESCR; 7089 D_F(A6PTR) = D_V(A6PTR) = 0; 7090 D(XCL) = D(ZCL); 7091 D_A(XCL) -= D_A(A6PTR); 7092L_SORT7: 7093 D(TCL) = D(ZEROCL); 7094 D_A(A7PTR) = (int_t) DESCR; 7095L_SORT8: 7096 D(LPTR) = D(A7PTR); 7097 D_A(LPTR) += D_A(A6PTR); 7098 D(F1PTR) = D(D_A(TPTR) + D_A(A7PTR)); 7099 D(F2PTR) = D(D_A(TPTR) + D_A(LPTR)); 7100 D(A1PTR) = D(D_A(F1PTR)); 7101 D(A2PTR) = D(D_A(F2PTR)); 7102L_SORT9: 7103 D_A(DTCL) = D_V(A1PTR); 7104 D_F(DTCL) = D_V(DTCL) = 0; 7105 D_V(DTCL) = D_V(A2PTR); 7106 if (DCMP(DTCL, VVDTP)) 7107 goto L_CVV; 7108 if (DCMP(DTCL, IIDTP)) 7109 goto L_CII; 7110 if (DCMP(DTCL, RIDTP)) 7111 goto L_CRI; 7112 if (DCMP(DTCL, IRDTP)) 7113 goto L_CIR; 7114 if (DCMP(DTCL, RRDTP)) 7115 goto L_CRR; 7116 goto L_COTH; 7117 /*_*/ 7118L_CVV: 7119 X_LOCSP(XSP,A1PTR); 7120 X_LOCSP(YSP,A2PTR); 7121 { 7122 int x = LEXCMP(XSP,YSP); 7123 if (x < 0) 7124 goto L_CMPLT; 7125 if (x == 0) 7126 goto L_CMPEQ; 7127 goto L_CMPGT; 7128 } 7129L_CIR: 7130 D_RV(A1PTR) = (real_t)D_A(A1PTR); 7131 D_F(A1PTR) = 0; 7132 D_V(A1PTR) = R; 7133 goto L_CRR; 7134 /*_*/ 7135L_CRI: 7136 D_RV(A2PTR) = (real_t)D_A(A2PTR); 7137 D_F(A2PTR) = 0; 7138 D_V(A2PTR) = R; 7139 goto L_CRR; 7140 /*_*/ 7141L_CII: 7142 if (D_A(A1PTR) < D_A(A2PTR)) 7143 goto L_CMPLT; 7144 if (D_A(A1PTR) == D_A(A2PTR)) 7145 goto L_CMPEQ; 7146 goto L_CMPGT; 7147 /*_*/ 7148L_CRR: 7149 if (isnan(D_RV(A1PTR))) 7150 goto L_CRR1; 7151 if (isnan(D_RV(A2PTR))) 7152 goto L_CMPLT; 7153 if (D_RV(A1PTR) < D_RV(A2PTR)) 7154 goto L_CMPLT; 7155 if (D_RV(A1PTR) == D_RV(A2PTR)) 7156 goto L_CMPEQ; 7157 goto L_CMPGT; 7158 /*_*/ 7159L_CRR1: 7160 if (isnan(D_RV(A2PTR))) 7161 goto L_CMPEQ; 7162 else 7163 goto L_CMPGT; 7164 /*_*/ 7165L_CMPEQ: 7166 if (D_PTR(F1PTR) <= D_PTR(F2PTR)) 7167 goto L_CMPNXT; 7168 else 7169 goto L_SWAP; 7170L_CMPGT: 7171 if (D_A(SCL) == 0) 7172 goto L_SWAP; 7173 else 7174 goto L_CMPNXT; 7175L_CMPLT: 7176 if (D_A(SCL) == 0) 7177 goto L_CMPNXT; 7178L_SWAP: 7179 D(D_A(TPTR) + D_A(A7PTR)) = D(F2PTR); 7180 D(D_A(TPTR) + D_A(LPTR)) = D(F1PTR); 7181 D_A(TCL) += 1; 7182L_CMPNXT: 7183 if (D_A(A7PTR) >= D_A(XCL)) 7184 goto L_SORT11; 7185 D_A(A7PTR) += DESCR; 7186 goto L_SORT8; 7187 /*_*/ 7188L_SORT11: 7189 if (D_A(TCL) == 0) 7190 goto L_SORT6; 7191 else 7192 goto L_SORT7; 7193 /*_*/ 7194L_COTH: 7195 if (D_A(A3PTR) == 0) 7196 goto L_COTH2; 7197 if (D_V(A1PTR) < DATSTA) 7198 goto L_COTH0; 7199 D_V(DT1CL) = D_V(A1PTR); 7200 if (!LOCAPT(ZPTR,A3PTR,DT1CL)) 7201 BRANCH(INTR1) 7202 D(ZPTR) = D(D_A(ZPTR) + 2*DESCR); 7203 D_A(A1PTR) += D_A(ZPTR); 7204 D(A1PTR) = D(D_A(A1PTR) + DESCR); 7205 goto L_SORT9; 7206 /*_*/ 7207L_COTH0: 7208 if (D_V(A2PTR) < DATSTA) 7209 goto L_COTH2; 7210 D_V(DT1CL) = D_V(A2PTR); 7211 if (!LOCAPT(ZPTR,A3PTR,DT1CL)) 7212 BRANCH(INTR1) 7213 D(ZPTR) = D(D_A(ZPTR) + 2*DESCR); 7214 D_A(A2PTR) += D_A(ZPTR); 7215 D(A2PTR) = D(D_A(A2PTR) + DESCR); 7216 goto L_SORT9; 7217L_COTH2: 7218 if (D_V(A1PTR) == D_V(A2PTR)) 7219 goto L_COTH1; 7220 D_A(A1PTR) = D_V(A1PTR); 7221 D_F(A1PTR) = D_V(A1PTR) = 0; 7222 D_A(A2PTR) = D_V(A2PTR); 7223 D_F(A2PTR) = D_V(A2PTR) = 0; 7224L_COTH1: 7225 if (D_PTR(A1PTR) < D_PTR(A2PTR)) 7226 goto L_CMPLT; 7227 if (D_PTR(A1PTR) == D_PTR(A2PTR)) 7228 goto L_CMPEQ; 7229 goto L_CMPGT; 7230 /*_*/ 7231L_SORT12: 7232 D(XCL) = D(D_A(XPTR) + 2*DESCR); 7233 D_A(WPTR) = D_A(XCL); 7234 D_A(WPTR) *= DESCR; 7235 D_F(WPTR) = D_V(WPTR) = 0; 7236 D_A(WPTR) = D_A(XPTR) + D_A(WPTR); 7237 D_F(WPTR) = D_F(XPTR); 7238 D_V(WPTR) = D_V(XPTR); 7239 D_A(WPTR) += 3*DESCR; 7240 D(LPTR) = D(ONECL); 7241 D_A(LPTR) *= DESCR; 7242 D_F(LPTR) = D_V(LPTR) = 0; 7243L_SORT13: 7244 D(ZPTR) = D(D_A(TPTR) + D_A(LPTR)); 7245 D_A(ZPTR) -= D_A(A5PTR); 7246 D(YPTR) = D(WPTR); 7247 D_A(A6PTR) = D_A(YCL); 7248 D_A(A6PTR) *= DESCR; 7249 D_F(A6PTR) = D_V(A6PTR) = 0; 7250L_SORT14: 7251 D(D_A(YPTR)) = D(D_A(ZPTR)); 7252 D_A(ZPTR) += D_A(A4PTR); 7253 D_A(YPTR) += D_A(ZCL); 7254 D_A(A6PTR) -= DESCR; 7255 if (D_A(A6PTR) != 0) 7256 goto L_SORT14; 7257 D_A(WPTR) += DESCR; 7258 D_A(LPTR) += DESCR; 7259 if (D_PTR(LPTR) <= D_PTR(ZCL)) 7260 goto L_SORT13; 7261 PUSH(ZEROCL); 7262 PUSH(ZEROCL); 7263 PUSH(ZEROCL); 7264 PUSH(ZEROCL); 7265 POP(YPTR); 7266 POP(ZPTR); 7267 POP(F1PTR); 7268 POP(F2PTR); 7269 BRANCH(RTXPTR) 7270 /*_*/ 7271} 7272int 7273READ(retval) 7274 ret_t retval; 7275{ 7276 ENTRY(READ) 7277 SAVSTK(); 7278 switch (IND(XPTR)) { 7279 case 1: 7280 BRANCH(FAIL) 7281 } 7282 PUSH(XPTR); 7283 SAVSTK(); 7284 switch (INTVAL(YPTR)) { 7285 case 1: 7286 BRANCH(FAIL) 7287 } 7288 PUSH(YPTR); 7289 SAVSTK(); 7290 switch (VARVAL(ZPTR)) { 7291 case 1: 7292 BRANCH(FAIL) 7293 } 7294 POP(YPTR); 7295 if (D_A(YPTR) < 0) 7296 BRANCH(UNTERR) 7297 if (D_A(YPTR) == 0) 7298 goto L_READ5; 7299L_READ6: 7300 PUSH(YPTR); 7301 PUSH(ZPTR); 7302 SAVSTK(); 7303 switch (VARVAL(TPTR)) { 7304 case 1: 7305 BRANCH(FAIL) 7306 } 7307 X_LOCSP(XSP,TPTR); 7308 POP(ZPTR); 7309 POP(YPTR); 7310 POP(XPTR); 7311 X_LOCSP(ZSP,ZPTR); 7312 D(ZPTR) = D(ZEROCL); 7313 if (!IO_OPENI(YPTR,XSP,ZSP,ZPTR)) 7314 BRANCH(FAIL) 7315 if (D_A(ZPTR) < 0) 7316 BRANCH(LENERR) 7317 if (D_A(ZPTR) > 0) 7318 goto L_READ2; 7319 if (!LOCAPT(TPTR,INSATL,YPTR)) 7320 goto L_READ4; 7321L_READ3: 7322 if (!LOCAPV(ZPTR,INATL,XPTR)) 7323 goto L_READ1; 7324 D(D_A(ZPTR) + DESCR) = D(TPTR); 7325 BRANCH(RETNUL) 7326 /*_*/ 7327L_READ1: 7328 SAVSTK(); 7329 PUSH(XPTR); 7330 PUSH(TPTR); 7331 PUSH(INATL); 7332 switch (AUGATL(INATL)) { 7333 case 1: 7334 BRANCH(RETNUL) 7335 } 7336 /*_*/ 7337L_READ4: 7338 D(ZPTR) = D(DFLSIZ); 7339L_READ2: 7340 SAVSTK(); 7341 PUSH(IOBLSZ); 7342 BLOCK(TPTR); 7343 D(D_A(TPTR) + DESCR) = D(YPTR); 7344 D(D_A(TPTR) + 2*DESCR) = D(ZPTR); 7345 goto L_READ3; 7346 /*_*/ 7347L_READ5: 7348 D_A(YPTR) = (int_t) UNITI; 7349 goto L_READ6; 7350 /*_*/ 7351} 7352int 7353PRINT(retval) 7354 ret_t retval; 7355{ 7356 ENTRY(PRINT) 7357 SAVSTK(); 7358 switch (IND(XPTR)) { 7359 case 1: 7360 BRANCH(FAIL) 7361 } 7362 PUSH(XPTR); 7363 SAVSTK(); 7364 switch (INTVAL(YPTR)) { 7365 case 1: 7366 BRANCH(FAIL) 7367 } 7368 PUSH(YPTR); 7369 SAVSTK(); 7370 switch (VARVAL(ZPTR)) { 7371 case 1: 7372 BRANCH(FAIL) 7373 } 7374 PUSH(ZPTR); 7375 SAVSTK(); 7376 switch (VARVAL(TPTR)) { 7377 case 1: 7378 BRANCH(FAIL) 7379 } 7380 POP(ZPTR); 7381 POP(YPTR); 7382 POP(XPTR); 7383 X_LOCSP(XSP,TPTR); 7384 X_LOCSP(ZSP,ZPTR); 7385 if (!IO_OPENO(YPTR,XSP,ZSP)) 7386 BRANCH(FAIL) 7387 if (D_A(YPTR) < 0) 7388 BRANCH(UNTERR) 7389 if (D_A(YPTR) == 0) 7390 goto L_PRINT5; 7391L_PRINT6: 7392 if (D_A(ZPTR) != 0) 7393 goto L_PRINT2; 7394 if (!LOCAPT(TPTR,OTSATL,YPTR)) 7395 goto L_PRINT4; 7396L_PRINT3: 7397 if (!LOCAPV(ZPTR,OUTATL,XPTR)) 7398 goto L_PRINT1; 7399 D(D_A(ZPTR) + DESCR) = D(TPTR); 7400 BRANCH(RETNUL) 7401 /*_*/ 7402L_PRINT1: 7403 SAVSTK(); 7404 PUSH(XPTR); 7405 PUSH(TPTR); 7406 PUSH(OUTATL); 7407 switch (AUGATL(OUTATL)) { 7408 case 1: 7409 BRANCH(RETNUL) 7410 } 7411 /*_*/ 7412L_PRINT4: 7413 D(ZPTR) = D(DFLFST); 7414L_PRINT2: 7415 SAVSTK(); 7416 PUSH(IOBLSZ); 7417 BLOCK(TPTR); 7418 D(D_A(TPTR) + DESCR) = D(YPTR); 7419 D(D_A(TPTR) + 2*DESCR) = D(ZPTR); 7420 goto L_PRINT3; 7421 /*_*/ 7422L_PRINT5: 7423 D_A(YPTR) = (int_t) UNITO; 7424 goto L_PRINT6; 7425 /*_*/ 7426} 7427int 7428BKSPCE(retval) 7429 ret_t retval; 7430{ 7431 ENTRY(BKSPCE) 7432 D_A(SCL) = 1; 7433 BRANCH(IOOP) 7434 /*_*/ 7435} 7436int 7437ENDFIL(retval) 7438 ret_t retval; 7439{ 7440 ENTRY(ENDFIL) 7441 D_A(SCL) = 2; 7442 BRANCH(IOOP) 7443 /*_*/ 7444} 7445int 7446REWIND(retval) 7447 ret_t retval; 7448{ 7449 ENTRY(REWIND) 7450 D_A(SCL) = 3; 7451 BRANCH(IOOP) 7452 /*_*/ 7453} 7454int 7455SET(retval) 7456 ret_t retval; 7457{ 7458 ENTRY(SET) 7459 D_A(SCL) = 4; 7460 /* FALL */ 7461 BRANCH(IOOP) 7462} 7463static int 7464IOOP(retval) 7465 ret_t retval; 7466{ 7467 ENTRY(IOOP) 7468 PUSH(SCL); 7469 SAVSTK(); 7470 switch (INTVAL(XCL)) { 7471 case 1: 7472 BRANCH(FAIL) 7473 } 7474 if (D_A(XCL) <= 0) 7475 BRANCH(UNTERR) 7476 POP(SCL); 7477 switch (D_A(SCL)) { 7478 case 2: 7479 goto L_EOP; 7480 case 3: 7481 goto L_ROP; 7482 case 4: 7483 goto L_SOP; 7484 } 7485 io_backspace(D_A(XCL)); 7486 BRANCH(RETNUL) 7487 /*_*/ 7488L_EOP: 7489 if (!io_endfile(D_A(XCL))) 7490 BRANCH(COMP6) 7491 BRANCH(RETNUL) 7492 /*_*/ 7493L_ROP: 7494 io_rewind(D_A(XCL)); 7495 BRANCH(RETNUL) 7496 /*_*/ 7497L_SOP: 7498 PUSH(XCL); 7499 SAVSTK(); 7500 switch (INTVAL(XPTR)) { 7501 case 1: 7502 BRANCH(FAIL) 7503 } 7504 PUSH(XPTR); 7505 SAVSTK(); 7506 switch (INTVAL(YPTR)) { 7507 case 1: 7508 BRANCH(FAIL) 7509 } 7510 POP(XPTR); 7511 POP(XCL); 7512 if (IO_SEEK(XCL,XPTR,YPTR)) 7513 BRANCH(RTXPTR) 7514 else 7515 BRANCH(FAIL) 7516 /*_*/ 7517} 7518int 7519DETACH(retval) 7520 ret_t retval; 7521{ 7522 ENTRY(DETACH) 7523 SAVSTK(); 7524 switch (IND(XPTR)) { 7525 case 1: 7526 BRANCH(FAIL) 7527 } 7528 if (!LOCAPV(ZPTR,INATL,XPTR)) 7529 goto L_DTCH1; 7530 D(D_A(ZPTR) + DESCR) = D(ZEROCL); 7531 D(D_A(ZPTR) + 2*DESCR) = D(ZEROCL); 7532L_DTCH1: 7533 if (!LOCAPV(ZPTR,OUTATL,XPTR)) 7534 BRANCH(RETNUL) 7535 D(D_A(ZPTR) + DESCR) = D(ZEROCL); 7536 D(D_A(ZPTR) + 2*DESCR) = D(ZEROCL); 7537 BRANCH(RETNUL) 7538 /*_*/ 7539} 7540static int 7541PUTIN(retval) 7542 ret_t retval; 7543{ 7544 ENTRY(PUTIN) 7545 POP(IO1PTR); 7546 POP(IO2PTR); 7547 D(IO3PTR) = D(D_A(IO1PTR) + DESCR); 7548 D(IO1PTR) = D(D_A(IO1PTR) + 2*DESCR); 7549 SAVSTK(); 7550 PUSH(IO1PTR); 7551 CONVAR(IO4PTR); 7552 X_LOCSP(IOSP,IO4PTR); 7553 D_A(RSTAT) += 1; 7554 switch (IO_READ(IO3PTR, IOSP)) { 7555 case IO_EOF: 7556 BRANCH(FAIL) 7557 case IO_ERR: 7558 BRANCH(COMP5) 7559 } 7560 if (D_A(TRIMCL) == 0) 7561 goto L_PUTIN1; 7562 TRIMSP(IOSP,IOSP); 7563L_PUTIN1: 7564 D_A(IO1PTR) = S_L(IOSP); 7565 D_F(IO1PTR) = D_V(IO1PTR) = 0; 7566 if (D_A(IO1PTR) > D_A(MLENCL)) 7567 BRANCH(INTR8) 7568 if (D_V(IO2PTR) == K) 7569 goto L_PUTIN3; 7570 SAVSTK(); 7571 PUSH(IO1PTR); 7572 GNVARS(IO1PTR); 7573L_PUTIN2: 7574 D(D_A(IO2PTR) + DESCR) = D(IO1PTR); 7575 D(retval) = D(IO1PTR); 7576 RETURN(2) 7577L_PUTIN3: 7578 X_LOCSP(XSP,IO1PTR); 7579 if (SPCINT(IO1PTR,XSP)) 7580 goto L_PUTIN2; 7581 else 7582 BRANCH(INTR1) 7583 /*_*/ 7584} 7585static int 7586PUTOUT(retval) 7587 ret_t retval; 7588{ 7589 ENTRY(PUTOUT) 7590 POP(IO1PTR); 7591 POP(IO2PTR); 7592 if (D_V(IO2PTR) == S) 7593 goto L_PUTV; 7594 if (D_V(IO2PTR) == I) 7595 goto L_PUTI; 7596 SAVSTK(); 7597 PUSH(IO2PTR); 7598 DTREP(IO2PTR); 7599 _SPEC(IOSP) = _SPEC(D_A(IO2PTR)); 7600 goto L_PUTVU; 7601 /*_*/ 7602L_PUTV: 7603 X_LOCSP(IOSP,IO2PTR); 7604L_PUTVU: 7605 IO_PRINT(IOKEY, IO1PTR, IOSP); 7606 if (D_A(IOKEY) == 0) 7607 BRANCH(COMP6) 7608 D_A(WSTAT) += 1; 7609 BRANCH(RTN1) 7610 /*_*/ 7611L_PUTI: 7612 INTSPC(IOSP,IO2PTR); 7613 goto L_PUTVU; 7614 /*_*/ 7615} 7616int 7617TRACE(retval) 7618 ret_t retval; 7619{ 7620 ENTRY(TRACE) 7621 SAVSTK(); 7622 switch (IND(XPTR)) { 7623 case 1: 7624 BRANCH(FAIL) 7625 } 7626 PUSH(XPTR); 7627 SAVSTK(); 7628 switch (VARVUP(YPTR)) { 7629 case 1: 7630 BRANCH(FAIL) 7631 } 7632 PUSH(YPTR); 7633 SAVSTK(); 7634 switch (ARGVAL(WPTR)) { 7635 case 1: 7636 BRANCH(FAIL) 7637 } 7638 PUSH(WPTR); 7639 SAVSTK(); 7640 switch (VARVUP(ZPTR)) { 7641 case 1: 7642 BRANCH(FAIL) 7643 } 7644 POP(WPTR); 7645 POP(YPTR); 7646 POP(XPTR); 7647 if (!DCMP(YPTR, NULVCL)) 7648 goto L_TRAC5; 7649 D(YPTR) = D(VALTRS); 7650L_TRAC5: 7651 if (!LOCAPV(YPTR,TRATL,YPTR)) 7652 goto L_TRAC1; 7653 D(YPTR) = D(D_A(YPTR) + DESCR); 7654 BRANCH(TRACEP) 7655 /*_*/ 7656L_TRAC1: 7657 if (!DCMP(YPTR, FUNTCL)) 7658 BRANCH(INTR30) 7659 D(YPTR) = D(TFNCLP); 7660 SAVSTK(); 7661 switch (TRACEP(NORET)) { 7662 case 1: 7663 case 2: 7664 BRANCH(INTR10) 7665 } 7666 D(YPTR) = D(TFNRLP); 7667 BRANCH(TRACEP) 7668 /*_*/ 7669} 7670static int 7671TRACEP(retval) 7672 ret_t retval; 7673{ 7674 ENTRY(TRACEP) 7675 D(TPTR) = D(D_A(YPTR) + DESCR); 7676 if (DCMP(ZPTR, NULVCL)) 7677 goto L_TRAC2; 7678 SAVSTK(); 7679 PUSH(ZPTR); 7680 FINDEX(TPTR); 7681L_TRAC2: 7682 D_A(XSIZ) = (int_t) (5*DESCR); 7683 D_V(XSIZ) = C; 7684 SAVSTK(); 7685 PUSH(XSIZ); 7686 BLOCK(XCL); 7687 MOVBLK(D_A(XCL),D_A(TRCBLK),D_A(XSIZ)); 7688 D_V(TPTR) = 2; 7689 D(D_A(XCL) + 1*DESCR) = D(TPTR); 7690 D(D_A(XCL) + 3*DESCR) = D(XPTR); 7691 D(D_A(XCL) + 5*DESCR) = D(WPTR); 7692 D(TPTR) = D(D_A(YPTR)); 7693 if (D_A(TPTR) == 0) 7694 goto L_TRAC4; 7695 if (!LOCAPT(TPTR,TPTR,XPTR)) 7696 goto L_TRAC3; 7697 D(D_A(TPTR) + 2*DESCR) = D(XCL); 7698 BRANCH(RETNUL) 7699 /*_*/ 7700L_TRAC3: 7701 SAVSTK(); 7702 PUSH(XCL); 7703 PUSH(XPTR); 7704 PUSH(TPTR); 7705 AUGATL(TPTR); 7706L_TRAC6: 7707 D(D_A(YPTR)) = D(TPTR); 7708 BRANCH(RETNUL) 7709 /*_*/ 7710L_TRAC4: 7711 SAVSTK(); 7712 PUSH(TWOCL); 7713 BLOCK(TPTR); 7714 D(D_A(TPTR) + DESCR) = D(XPTR); 7715 D(D_A(TPTR) + 2*DESCR) = D(XCL); 7716 goto L_TRAC6; 7717 /*_*/ 7718} 7719int 7720STOPTR(retval) 7721 ret_t retval; 7722{ 7723 ENTRY(STOPTR) 7724 SAVSTK(); 7725 switch (IND(XPTR)) { 7726 case 1: 7727 BRANCH(FAIL) 7728 } 7729 PUSH(XPTR); 7730 SAVSTK(); 7731 switch (VARVUP(YPTR)) { 7732 case 1: 7733 BRANCH(FAIL) 7734 } 7735 POP(XPTR); 7736 if (!DCMP(YPTR, NULVCL)) 7737 goto L_STOPT2; 7738 D(YPTR) = D(VALTRS); 7739L_STOPT2: 7740 if (!LOCAPV(YPTR,TRATL,YPTR)) 7741 goto L_STOPT1; 7742 D(YPTR) = D(D_A(YPTR) + DESCR); 7743 BRANCH(STOPTP) 7744 /*_*/ 7745L_STOPT1: 7746 if (!DCMP(YPTR, FUNTCL)) 7747 BRANCH(INTR30) 7748 D(YPTR) = D(TFNCLP); 7749 SAVSTK(); 7750 switch (STOPTP(NORET)) { 7751 case 1: 7752 BRANCH(FAIL) 7753 case 2: 7754 BRANCH(INTR10) 7755 } 7756 D(YPTR) = D(TFNRLP); 7757 BRANCH(STOPTP) 7758 /*_*/ 7759} 7760static int 7761STOPTP(retval) 7762 ret_t retval; 7763{ 7764 ENTRY(STOPTP) 7765 D(YPTR) = D(D_A(YPTR)); 7766 if (!LOCAPT(YPTR,YPTR,XPTR)) 7767 BRANCH(FAIL) 7768 D(D_A(YPTR) + DESCR) = D(ZEROCL); 7769 D(D_A(YPTR) + 2*DESCR) = D(ZEROCL); 7770 BRANCH(RETNUL) 7771 /*_*/ 7772} 7773int 7774FENTR(retval) 7775 ret_t retval; 7776{ 7777 ENTRY(FENTR) 7778 SAVSTK(); 7779 switch (VARVAL(WPTR)) { 7780 case 1: 7781 BRANCH(FAIL) 7782 } 7783 /* FALL */ 7784 BRANCH(FENTR3) 7785} 7786static int 7787FENTR3(retval) 7788 ret_t retval; 7789{ 7790 ENTRY(FENTR3) 7791 S_L(PROTSP) = 0; 7792 X_LOCSP(XSP,FILENM); 7793 APDSP(PROTSP,XSP); 7794 APDSP(PROTSP,COLSP); 7795 INTSPC(XSP,LNNOCL); 7796 APDSP(PROTSP,XSP); 7797 APDSP(PROTSP,TRSTSP); 7798 INTSPC(XSP,STNOCL); 7799 APDSP(PROTSP,XSP); 7800 APDSP(PROTSP,COLSP); 7801 APDSP(PROTSP,SPCSP); 7802 APDSP(PROTSP,TRLVSP); 7803 INTSPC(XSP,LVLCL); 7804 APDSP(PROTSP,XSP); 7805 APDSP(PROTSP,TRCLSP); 7806 X_LOCSP(XSP,WPTR); 7807 D_A(TCL) = S_L(XSP); 7808 D_F(TCL) = D_V(TCL) = 0; 7809 if (D_A(TCL) >= BUFLEN) 7810 BRANCH(FXOVR) 7811 APDSP(PROTSP,XSP); 7812 APDSP(PROTSP,LPRNSP); 7813 D_A(WCL) = 0; 7814L_FNTRLP: 7815 D_A(WCL) += 1; 7816 SAVSTK(); 7817 PUSH(WCL); 7818 PUSH(WPTR); 7819 switch (ARGINT(ZPTR)) { 7820 case 1: 7821 goto L_FENTR4; 7822 case 2: 7823 BRANCH(INTR10) 7824 } 7825 D(ZPTR) = D(D_A(ZPTR) + DESCR); 7826 if (D_V(ZPTR) == S) 7827 goto L_DEFTV; 7828 if (D_V(ZPTR) == I) 7829 goto L_DEFTI; 7830 SAVSTK(); 7831 PUSH(ZPTR); 7832 DTREP(A2PTR); 7833 _SPEC(XSP) = _SPEC(D_A(A2PTR)); 7834 D_A(SCL) = S_L(XSP); 7835 D_F(SCL) = D_V(SCL) = 0; 7836 D_A(TCL) += D_A(SCL); 7837 if (D_A(TCL) >= BUFLEN) 7838 BRANCH(FXOVR) 7839L_DEFTIA: 7840 APDSP(PROTSP,XSP); 7841 goto L_DEFDTT; 7842 /*_*/ 7843L_DEFTI: 7844 INTSPC(XSP,ZPTR); 7845 goto L_DEFTIA; 7846 /*_*/ 7847L_DEFTV: 7848 X_LOCSP(XSP,ZPTR); 7849 D_A(SCL) = S_L(XSP); 7850 D_F(SCL) = D_V(SCL) = 0; 7851 D_A(TCL) += D_A(SCL); 7852 if (D_A(TCL) >= BUFLEN) 7853 BRANCH(FXOVR) 7854 APDSP(PROTSP,QTSP); 7855 APDSP(PROTSP,XSP); 7856 APDSP(PROTSP,QTSP); 7857L_DEFDTT: 7858 APDSP(PROTSP,CMASP); 7859 goto L_FNTRLP; 7860 /*_*/ 7861L_FENTR4: 7862 if (D_A(WCL) == 1) 7863 goto L_FENTR5; 7864 S_L(PROTSP) -= 1; 7865L_FENTR5: 7866 APDSP(PROTSP,RPRNSP); 7867 D_RV(ZPTR) = mstime(); 7868 D_F(ZPTR) = D_V(ZPTR) = 0; 7869 D_RV(ZPTR) -= D_RV(ETMCL); 7870 REALST(XSP,ZPTR); 7871 APDSP(PROTSP,ETIMSP); 7872 APDSP(PROTSP,XSP); 7873 IO_PRINT(IOKEY, OUTBLK, PROTSP); 7874 BRANCH(RTNUL3) 7875 /*_*/ 7876} 7877static int 7878FENTR2(retval) 7879 ret_t retval; 7880{ 7881 ENTRY(FENTR2) 7882 POP(WPTR); 7883 BRANCH(FENTR3) 7884 /*_*/ 7885} 7886static int 7887FXOVR(retval) 7888 ret_t retval; 7889{ 7890 ENTRY(FXOVR) 7891 io_printf(D_A(OUTPUT),PRTOVF); 7892 BRANCH(RTNUL3) 7893 /*_*/ 7894} 7895int 7896KEYTR(retval) 7897 ret_t retval; 7898{ 7899 ENTRY(KEYTR) 7900 D_A(FNVLCL) = 1; 7901 SAVSTK(); 7902 switch (VARVAL(WPTR)) { 7903 case 1: 7904 BRANCH(FAIL) 7905 } 7906 X_LOCSP(XSP,WPTR); 7907 SAVSTK(); 7908 PUSH(WPTR); 7909 switch (KEYT(YCL)) { 7910 case 1: 7911 BRANCH(INTR10) 7912 } 7913 /* FALL */ 7914 BRANCH(KEYTR3) 7915} 7916static int 7917KEYTR3(retval) 7918 ret_t retval; 7919{ 7920 ENTRY(KEYTR3) 7921 S_L(PROTSP) = 0; 7922 X_LOCSP(XSP,FILENM); 7923 APDSP(PROTSP,XSP); 7924 APDSP(PROTSP,COLSP); 7925 INTSPC(XSP,LNNOCL); 7926 APDSP(PROTSP,XSP); 7927 APDSP(PROTSP,TRSTSP); 7928 INTSPC(TSP,STNOCL); 7929 APDSP(PROTSP,TSP); 7930 APDSP(PROTSP,COLSP); 7931 APDSP(PROTSP,SPCSP); 7932 if (D_A(FNVLCL) == 0) 7933 goto L_KEYTR4; 7934 APDSP(PROTSP,AMPSP); 7935L_KEYTR4: 7936 APDSP(PROTSP,XSP); 7937 APDSP(PROTSP,BLSP); 7938 if (D_A(FNVLCL) == 0) 7939 goto L_KEYTR5; 7940 INTSPC(YSP,YCL); 7941 APDSP(PROTSP,EQLSP); 7942L_KEYTR5: 7943 APDSP(PROTSP,YSP); 7944 D_RV(YPTR) = mstime(); 7945 D_F(YPTR) = D_V(YPTR) = 0; 7946 D_RV(YPTR) -= D_RV(ETMCL); 7947 REALST(XSP,YPTR); 7948 APDSP(PROTSP,ETIMSP); 7949 APDSP(PROTSP,XSP); 7950 IO_PRINT(IOKEY, OUTBLK, PROTSP); 7951 BRANCH(RTN2) 7952 /*_*/ 7953} 7954int 7955LABTR(retval) 7956 ret_t retval; 7957{ 7958 ENTRY(LABTR) 7959 D_A(FNVLCL) = 0; 7960 SAVSTK(); 7961 switch (VARVAL(YPTR)) { 7962 case 1: 7963 BRANCH(FAIL) 7964 } 7965 X_LOCSP(YSP,YPTR); 7966 _SPEC(XSP) = _SPEC(XFERSP); 7967 BRANCH(KEYTR3) 7968 /*_*/ 7969} 7970static int 7971TRPHND(retval) 7972 ret_t retval; 7973{ 7974 ENTRY(TRPHND) 7975 POP(ATPTR); 7976 D_A(TRAPCL) -= 1; 7977 PUSH(FILENM); 7978 PUSH(LNNOCL); 7979 PUSH(LSTNCL); 7980 PUSH(STNOCL); 7981 PUSH(FRTNCL); 7982 PUSH(OCBSCL); 7983 PUSH(OCICL); 7984 PUSH(TRAPCL); 7985 PUSH(TRACL); 7986 D(OCBSCL) = D(D_A(ATPTR) + 2*DESCR); 7987 D_A(OCICL) = (int_t) DESCR; 7988 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 7989 D_A(TRAPCL) = 0; 7990 D_A(TRACL) = 0; 7991 SAVSTK(); 7992 PUSH(XPTR); 7993 INVOKE(NORET); 7994 POP(TRACL); 7995 POP(TRAPCL); 7996 POP(OCICL); 7997 POP(OCBSCL); 7998 POP(FRTNCL); 7999 POP(STNOCL); 8000 POP(LSTNCL); 8001 POP(LNNOCL); 8002 POP(FILENM); 8003 BRANCH(RTN1) 8004 /*_*/ 8005} 8006int 8007VALTR(retval) 8008 ret_t retval; 8009{ 8010 ENTRY(VALTR) 8011 D_A(FNVLCL) = 1; 8012 /* FALL */ 8013 BRANCH(VALTR2) 8014} 8015static int 8016VALTR2(retval) 8017 ret_t retval; 8018{ 8019 ENTRY(VALTR2) 8020 SAVSTK(); 8021 switch (IND(XPTR)) { 8022 case 1: 8023 BRANCH(FAIL) 8024 } 8025 PUSH(XPTR); 8026 SAVSTK(); 8027 switch (VARVAL(ZPTR)) { 8028 case 1: 8029 BRANCH(FAIL) 8030 } 8031 POP(XPTR); 8032 /* FALL */ 8033 BRANCH(VALTR4) 8034} 8035static int 8036VALTR4(retval) 8037 ret_t retval; 8038{ 8039 ENTRY(VALTR4) 8040 S_L(TRACSP) = 0; 8041 X_LOCSP(XSP,FILENM); 8042 APDSP(TRACSP,XSP); 8043 APDSP(TRACSP,COLSP); 8044 INTSPC(XSP,LNNOCL); 8045 APDSP(TRACSP,XSP); 8046 APDSP(TRACSP,TRSTSP); 8047 INTSPC(XSP,STNOCL); 8048 APDSP(TRACSP,XSP); 8049 APDSP(TRACSP,COLSP); 8050 APDSP(TRACSP,SPCSP); 8051 if (D_A(FNVLCL) == 0) 8052 BRANCH(FNEXT1) 8053 if (D_V(XPTR) != S) 8054 BRANCH(DEFDT) 8055 /* FALL */ 8056 BRANCH(VALTR3) 8057} 8058static int 8059VALTR3(retval) 8060 ret_t retval; 8061{ 8062 ENTRY(VALTR3) 8063 X_LOCSP(XSP,XPTR); 8064 D_A(TCL) = S_L(XSP); 8065 D_F(TCL) = D_V(TCL) = 0; 8066 if (D_A(TCL) >= BUFLEN) 8067 BRANCH(VXOVR) 8068 /* FALL */ 8069 BRANCH(VALTR1) 8070} 8071static int 8072VALTR1(retval) 8073 ret_t retval; 8074{ 8075 ENTRY(VALTR1) 8076 APDSP(TRACSP,XSP); 8077 APDSP(TRACSP,BLEQSP); 8078 D(YPTR) = D(D_A(XPTR) + DESCR); 8079 if (D_V(YPTR) == S) 8080 BRANCH(TRV) 8081 if (D_V(YPTR) == I) 8082 BRANCH(TRI) 8083 SAVSTK(); 8084 PUSH(YPTR); 8085 DTREP(XPTR); 8086 _SPEC(XSP) = _SPEC(D_A(XPTR)); 8087 /* FALL */ 8088 BRANCH(TRI2) 8089} 8090static int 8091TRI2(retval) 8092 ret_t retval; 8093{ 8094 ENTRY(TRI2) 8095 APDSP(TRACSP,XSP); 8096 BRANCH(TRPRT) 8097 /*_*/ 8098} 8099static int 8100TRV(retval) 8101 ret_t retval; 8102{ 8103 ENTRY(TRV) 8104 X_LOCSP(XSP,YPTR); 8105 D_A(SCL) = S_L(XSP); 8106 D_F(SCL) = D_V(SCL) = 0; 8107 D_A(TCL) += D_A(SCL); 8108 if (D_A(TCL) >= BUFLEN) 8109 BRANCH(VXOVR) 8110 APDSP(TRACSP,QTSP); 8111 APDSP(TRACSP,XSP); 8112 APDSP(TRACSP,QTSP); 8113 /* FALL */ 8114 BRANCH(TRPRT) 8115} 8116static int 8117TRPRT(retval) 8118 ret_t retval; 8119{ 8120 ENTRY(TRPRT) 8121 D_RV(YPTR) = mstime(); 8122 D_F(YPTR) = D_V(YPTR) = 0; 8123 D_RV(YPTR) -= D_RV(ETMCL); 8124 REALST(XSP,YPTR); 8125 APDSP(TRACSP,ETIMSP); 8126 APDSP(TRACSP,XSP); 8127 IO_PRINT(IOKEY, OUTBLK, TRACSP); 8128 BRANCH(RTNUL3) 8129 /*_*/ 8130} 8131static int 8132TRI(retval) 8133 ret_t retval; 8134{ 8135 ENTRY(TRI) 8136 INTSPC(XSP,YPTR); 8137 BRANCH(TRI2) 8138 /*_*/ 8139} 8140static int 8141DEFDT(retval) 8142 ret_t retval; 8143{ 8144 ENTRY(DEFDT) 8145 X_LOCSP(XSP,ZPTR); 8146 BRANCH(VALTR1) 8147 /*_*/ 8148} 8149int 8150FNEXTR(retval) 8151 ret_t retval; 8152{ 8153 ENTRY(FNEXTR) 8154 D_A(FNVLCL) = 0; 8155 BRANCH(VALTR2) 8156 /*_*/ 8157} 8158static int 8159FNEXT1(retval) 8160 ret_t retval; 8161{ 8162 ENTRY(FNEXT1) 8163 APDSP(TRACSP,TRLVSP); 8164 D(XCL) = D(LVLCL); 8165 D_A(XCL) -= 1; 8166 INTSPC(XSP,XCL); 8167 APDSP(TRACSP,XSP); 8168 APDSP(TRACSP,BLSP); 8169 X_LOCSP(XSP,RETPCL); 8170 APDSP(TRACSP,XSP); 8171 APDSP(TRACSP,OFSP); 8172 if (!DCMP(RETPCL, FRETCL)) 8173 BRANCH(VALTR3) 8174 X_LOCSP(XSP,XPTR); 8175 D_A(TCL) = S_L(XSP); 8176 D_F(TCL) = D_V(TCL) = 0; 8177 if (D_A(TCL) >= BUFLEN) 8178 BRANCH(VXOVR) 8179 APDSP(TRACSP,XSP); 8180 BRANCH(TRPRT) 8181 /*_*/ 8182} 8183static int 8184FNEXT2(retval) 8185 ret_t retval; 8186{ 8187 ENTRY(FNEXT2) 8188 D_A(FNVLCL) = 0; 8189 POP(XPTR); 8190 BRANCH(VALTR4) 8191 /*_*/ 8192} 8193static int 8194VXOVR(retval) 8195 ret_t retval; 8196{ 8197 ENTRY(VXOVR) 8198 io_printf(D_A(OUTPUT),PRTOVF); 8199 BRANCH(RTNUL3) 8200 /*_*/ 8201} 8202int 8203SETXIT(retval) 8204 ret_t retval; 8205{ 8206 ENTRY(SETXIT) 8207 SAVSTK(); 8208 switch (VARVUP(XPTR)) { 8209 case 1: 8210 BRANCH(INTR30) 8211 } 8212 if (D_A(XPTR) == 0) 8213 goto L_SETXI2; 8214 D(YPTR) = D(D_A(XPTR) + ATTRIB); 8215 if (D_A(YPTR) == 0) 8216 BRANCH(INTR30) 8217L_SETXI2: 8218 D(YPTR) = D(XITPTR); 8219 D(XITPTR) = D(XPTR); 8220 BRANCH(RTYPTR) 8221 /*_*/ 8222} 8223static int 8224XITHND(retval) 8225 ret_t retval; 8226{ 8227 ENTRY(XITHND) 8228 if (D_A(XITPTR) == 0) 8229 BRANCH(FAIL) 8230 if (D_A(XOCBSC) != 0) 8231 BRANCH(XITERR) 8232 D(XFILEN) = D(FILENM); 8233 D(XLNNOC) = D(LNNOCL); 8234 D(XSTNOC) = D(STNOCL); 8235 D(XLSFLN) = D(LSFLNM); 8236 D(XLSLNC) = D(LSLNCL); 8237 D(XLNNOC) = D(LNNOCL); 8238 D(XERRTY) = D(ERRTYP); 8239 D(XOCBSC) = D(OCBSCL); 8240 D(XFRTNC) = D(FRTNCL); 8241 D(XOCICL) = D(OCICL); 8242 D(OCBSCL) = D(D_A(XITPTR) + ATTRIB); 8243 if (D_A(OCBSCL) == 0) 8244 BRANCH(INTR4) 8245 D_A(FRTNCL) = 0; 8246 D_A(XITPTR) = 0; 8247 BRANCH(RETNUL) 8248 /*_*/ 8249} 8250int 8251ASGN(retval) 8252 ret_t retval; 8253{ 8254 ENTRY(ASGN) 8255 D_A(OCICL) += DESCR; 8256 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 8257 if ((D_F(XPTR) & FNC)) 8258 goto L_ASGNC; 8259L_ASGNV: 8260 if (D_V(XPTR) == K) 8261 goto L_ASGNIC; 8262 D_A(OCICL) += DESCR; 8263 D(YPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 8264 if ((D_F(YPTR) & FNC)) 8265 goto L_ASGNCV; 8266L_ASGNVN: 8267 if (D_A(INSW) == 0) 8268 goto L_ASGNV1; 8269 if (!LOCAPV(ZPTR,INATL,YPTR)) 8270 goto L_ASGNV1; 8271 D(ZPTR) = D(D_A(ZPTR) + DESCR); 8272 SAVSTK(); 8273 PUSH(YPTR); 8274 PUSH(ZPTR); 8275 switch (PUTIN(YPTR)) { 8276 case 1: 8277 BRANCH(FAIL) 8278 case 2: 8279 goto L_ASGNVV; 8280 } 8281 /*_*/ 8282L_ASGNV1: 8283 D(YPTR) = D(D_A(YPTR) + DESCR); 8284L_ASGNVV: 8285 D(D_A(XPTR) + DESCR) = D(YPTR); 8286 if (D_A(OUTSW) == 0) 8287 goto L_ASGN1; 8288 if (!LOCAPV(ZPTR,OUTATL,XPTR)) 8289 goto L_ASGN1; 8290 D(ZPTR) = D(D_A(ZPTR) + DESCR); 8291 SAVSTK(); 8292 PUSH(YPTR); 8293 PUSH(ZPTR); 8294 PUTOUT(NORET); 8295L_ASGN1: 8296 if (D_A(TRAPCL) <= 0) 8297 BRANCH(RTYPTR) 8298 if (!LOCAPT(ATPTR,TVALL,XPTR)) 8299 BRANCH(RTYPTR) 8300 PUSH(YPTR); 8301 SAVSTK(); 8302 PUSH(ATPTR); 8303 TRPHND(NORET); 8304 POP(YPTR); 8305 BRANCH(RTYPTR) 8306 /*_*/ 8307L_ASGNC: 8308 SAVSTK(); 8309 PUSH(XPTR); 8310 switch (INVOKE(XPTR)) { 8311 case 1: 8312 BRANCH(FAIL) 8313 case 2: 8314 goto L_ASGNV; 8315 case 3: 8316 BRANCH(NEMO) 8317 } 8318 /*_*/ 8319L_ASGNCV: 8320 PUSH(XPTR); 8321 SAVSTK(); 8322 PUSH(YPTR); 8323 switch (INVOKE(YPTR)) { 8324 case 1: 8325 BRANCH(FAIL) 8326 case 2: 8327 goto L_ASGNVP; 8328 } 8329L_ASGNCJ: 8330 POP(XPTR); 8331 goto L_ASGNVV; 8332 /*_*/ 8333L_ASGNVP: 8334 POP(XPTR); 8335 goto L_ASGNVN; 8336 /*_*/ 8337L_ASGNIC: 8338 PUSH(XPTR); 8339 SAVSTK(); 8340 switch (INTVAL(YPTR)) { 8341 case 1: 8342 BRANCH(FAIL) 8343 case 2: 8344 goto L_ASGNCJ; 8345 } 8346 /*_*/ 8347} 8348int 8349CONCAT(retval) 8350 ret_t retval; 8351{ 8352 ENTRY(CONCAT) 8353 SAVSTK(); 8354 switch (XYARGS(NORET)) { 8355 case 1: 8356 BRANCH(FAIL) 8357 } 8358 if (DCMP(XPTR, NULVCL)) 8359 BRANCH(RTYPTR) 8360 if (DCMP(YPTR, NULVCL)) 8361 BRANCH(RTXPTR) 8362 if (D_V(XPTR) == S) 8363 goto L_CON5; 8364 if (D_V(XPTR) == P) 8365 goto L_CON5; 8366 if (D_V(XPTR) == I) 8367 goto L_CON4I; 8368 if (D_V(XPTR) == R) 8369 goto L_CON4R; 8370 if (D_V(XPTR) != E) 8371 BRANCH(INTR1) 8372 SAVSTK(); 8373 PUSH(STARSZ); 8374 BLOCK(TPTR); 8375 MOVBLK(D_A(TPTR),D_A(STRPAT),D_A(STARSZ)); 8376 D(D_A(TPTR) + 4*DESCR) = D(XPTR); 8377 D(XPTR) = D(TPTR); 8378 goto L_CON5; 8379 /*_*/ 8380L_CON4R: 8381 REALST(REALSP,XPTR); 8382 _SPEC(XSP) = _SPEC(REALSP); 8383 SAVSTK(); 8384 PUSH(XSPPTR); 8385 switch (GENVAR(XPTR)) { 8386 case 1: 8387 goto L_CON5; 8388 } 8389 /*_*/ 8390L_CON4I: 8391 INTSPC(ZSP,XPTR); 8392 SAVSTK(); 8393 PUSH(ZSPPTR); 8394 GENVAR(XPTR); 8395L_CON5: 8396 if (D_V(YPTR) == S) 8397 goto L_CON7; 8398 if (D_V(YPTR) == P) 8399 goto L_CON7; 8400 if (D_V(YPTR) == I) 8401 goto L_CON5I; 8402 if (D_V(YPTR) == R) 8403 goto L_CON5R; 8404 if (D_V(YPTR) != E) 8405 BRANCH(INTR1) 8406 SAVSTK(); 8407 PUSH(STARSZ); 8408 BLOCK(TPTR); 8409 MOVBLK(D_A(TPTR),D_A(STRPAT),D_A(STARSZ)); 8410 D(D_A(TPTR) + 4*DESCR) = D(YPTR); 8411 D(YPTR) = D(TPTR); 8412 goto L_CON7; 8413 /*_*/ 8414L_CON5R: 8415 REALST(REALSP,YPTR); 8416 _SPEC(YSP) = _SPEC(REALSP); 8417 SAVSTK(); 8418 PUSH(YSPPTR); 8419 switch (GENVAR(YPTR)) { 8420 case 1: 8421 goto L_CON7; 8422 } 8423 /*_*/ 8424L_CON5I: 8425 INTSPC(ZSP,YPTR); 8426 SAVSTK(); 8427 PUSH(ZSPPTR); 8428 GENVAR(YPTR); 8429L_CON7: 8430 D_A(DTCL) = D_V(XPTR); 8431 D_F(DTCL) = D_V(DTCL) = 0; 8432 D_V(DTCL) = D_V(YPTR); 8433 if (DCMP(DTCL, VVDTP)) 8434 goto L_CONVV; 8435 if (DCMP(DTCL, VPDTP)) 8436 goto L_CONVP; 8437 if (DCMP(DTCL, PVDTP)) 8438 goto L_CONPV; 8439 if (DCMP(DTCL, PPDTP)) 8440 goto L_CONPP; 8441 else 8442 BRANCH(INTR1) 8443 /*_*/ 8444L_CONVV: 8445 X_LOCSP(XSP,XPTR); 8446 X_LOCSP(YSP,YPTR); 8447 D_A(XCL) = S_L(XSP); 8448 D_F(XCL) = D_V(XCL) = 0; 8449 D_A(YCL) = S_L(YSP); 8450 D_F(YCL) = D_V(YCL) = 0; 8451 D_A(XCL) += D_A(YCL); 8452 if (D_A(XCL) > D_A(MLENCL)) 8453 BRANCH(INTR8) 8454 SAVSTK(); 8455 PUSH(XCL); 8456 CONVAR(ZPTR); 8457 X_LOCSP(TSP,ZPTR); 8458 S_L(TSP) = 0; 8459 APDSP(TSP,XSP); 8460 APDSP(TSP,YSP); 8461 BRANCH(GENVSZ) 8462 /*_*/ 8463L_CONVP: 8464 X_LOCSP(TSP,XPTR); 8465 D_A(TMVAL) = S_L(TSP); 8466 D_F(TMVAL) = D_V(TMVAL) = 0; 8467 SAVSTK(); 8468 PUSH(LNODSZ); 8469 BLOCK(TPTR); 8470 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR); 8471L_CONPP: 8472 D_A(XSIZ) = D_V(D_A(XPTR)); 8473 D_F(XSIZ) = D_V(XSIZ) = 0; 8474 D_A(YSIZ) = D_V(D_A(YPTR)); 8475 D_F(YSIZ) = D_V(YSIZ) = 0; 8476 D(TSIZ) = D(XSIZ); 8477 D_A(TSIZ) += D_A(YSIZ); 8478 D_V(TSIZ) = P; 8479 SAVSTK(); 8480 PUSH(TSIZ); 8481 BLOCK(TPTR); 8482 D(ZPTR) = D(TPTR); 8483 LVALUE(TVAL,YPTR); 8484 CPYPAT(TPTR,XPTR,TVAL,ZEROCL,XSIZ,XSIZ); 8485 CPYPAT(TPTR,YPTR,ZEROCL,XSIZ,ZEROCL,YSIZ); 8486 BRANCH(RTZPTR) 8487 /*_*/ 8488L_CONPV: 8489 X_LOCSP(TSP,YPTR); 8490 D_A(TMVAL) = S_L(TSP); 8491 D_F(TMVAL) = D_V(TMVAL) = 0; 8492 SAVSTK(); 8493 PUSH(LNODSZ); 8494 BLOCK(TPTR); 8495 MAKNOD(YPTR,TPTR,TMVAL,ZEROCL,CHRCL,YPTR); 8496 goto L_CONPP; 8497 /*_*/ 8498} 8499int 8500IND(retval) 8501 ret_t retval; 8502{ 8503 ENTRY(IND) 8504 SAVSTK(); 8505 switch (ARGVAL(XPTR)) { 8506 case 1: 8507 BRANCH(FAIL) 8508 } 8509 if (D_V(XPTR) == S) 8510 goto L_INDV; 8511 if (D_V(XPTR) == N) 8512 BRANCH(RTXNAM) 8513 if (D_V(XPTR) == I) 8514 BRANCH(GENVIX) 8515 if (D_V(XPTR) == K) 8516 BRANCH(RTXNAM) 8517 else 8518 BRANCH(INTR1) 8519 /*_*/ 8520L_INDV: 8521 if (D_A(XPTR) == 0) 8522 BRANCH(NONAME) 8523 if (D_A(CASECL) == 0) 8524 BRANCH(RTXNAM) 8525 else 8526 BRANCH(VPXPTR) 8527 /*_*/ 8528} 8529int 8530KEYWRD(retval) 8531 ret_t retval; 8532{ 8533 ENTRY(KEYWRD) 8534 D_A(OCICL) += DESCR; 8535 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 8536 if ((D_F(XPTR) & FNC)) 8537 BRANCH(KEYC) 8538 /* FALL */ 8539 BRANCH(KEYN) 8540} 8541static int 8542KEYN(retval) 8543 ret_t retval; 8544{ 8545 ENTRY(KEYN) 8546 if (!LOCAPV(XPTR,KNATL,XPTR)) 8547 goto L_KEYV; 8548 D_V(XPTR) = K; 8549 BRANCH(RTXNAM) 8550 /*_*/ 8551L_KEYV: 8552 if (!LOCAPV(ATPTR,KVATL,XPTR)) 8553 BRANCH(UNKNKW) 8554 D(ZPTR) = D(D_A(ATPTR) + DESCR); 8555 BRANCH(RTZPTR) 8556 /*_*/ 8557} 8558static int 8559KEYC(retval) 8560 ret_t retval; 8561{ 8562 ENTRY(KEYC) 8563 SAVSTK(); 8564 PUSH(XPTR); 8565 switch (INVOKE(XPTR)) { 8566 case 1: 8567 BRANCH(FAIL) 8568 case 2: 8569 BRANCH(KEYN) 8570 case 3: 8571 BRANCH(NEMO) 8572 } 8573 /*_*/ 8574} 8575static int 8576KEYT(retval) 8577 ret_t retval; 8578{ 8579 ENTRY(KEYT) 8580 POP(XPTR); 8581 BRANCH(KEYN) 8582 /*_*/ 8583} 8584int 8585LIT(retval) 8586 ret_t retval; 8587{ 8588 ENTRY(LIT) 8589 D_A(OCICL) += DESCR; 8590 D(ZPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 8591 BRANCH(RTZPTR) 8592 /*_*/ 8593} 8594int 8595NAME(retval) 8596 ret_t retval; 8597{ 8598 ENTRY(NAME) 8599 D_A(OCICL) += DESCR; 8600 D(ZPTR) = D(D_A(OCBSCL) + D_A(OCICL)); 8601 if (!(D_F(ZPTR) & FNC)) 8602 BRANCH(RTZPTR) 8603 SAVSTK(); 8604 PUSH(ZPTR); 8605 switch (INVOKE(ZPTR)) { 8606 case 1: 8607 BRANCH(FAIL) 8608 case 2: 8609 BRANCH(RTZPTR) 8610 case 3: 8611 BRANCH(NEMO) 8612 } 8613 /*_*/ 8614} 8615static int 8616NMD(retval) 8617 ret_t retval; 8618{ 8619 ENTRY(NMD) 8620 D(TCL) = D(NHEDCL); 8621L_NMD1: 8622 if (D_A(TCL) == D_A(NAMICL)) 8623 BRANCH(RTN2) 8624 if (D_A(TCL) > D_A(NAMICL)) 8625 BRANCH(INTR13) 8626 D(TPTR) = D(NBSPTR); 8627 D_A(TPTR) += D_A(TCL); 8628 _SPEC(TSP) = _SPEC(D_A(TPTR) + DESCR); 8629 D(TVAL) = D(D_A(TPTR) + DESCR+SPEC); 8630 D_A(XCL) = S_L(TSP); 8631 D_F(XCL) = D_V(XCL) = 0; 8632 if (D_A(XCL) > D_A(MLENCL)) 8633 BRANCH(INTR8) 8634 if (D_V(TVAL) == E) 8635 goto L_NAMEXN; 8636L_NMD5: 8637 if (D_V(TVAL) == K) 8638 goto L_NMDIC; 8639 SAVSTK(); 8640 PUSH(TSPPTR); 8641 GENVAR(VVAL); 8642L_NMD4: 8643 D(D_A(TVAL) + DESCR) = D(VVAL); 8644 if (D_A(OUTSW) == 0) 8645 goto L_NMD3; 8646 if (!LOCAPV(ZPTR,OUTATL,TVAL)) 8647 goto L_NMD3; 8648 D(ZPTR) = D(D_A(ZPTR) + DESCR); 8649 SAVSTK(); 8650 PUSH(VVAL); 8651 PUSH(ZPTR); 8652 PUTOUT(NORET); 8653L_NMD3: 8654 if (D_A(TRAPCL) <= 0) 8655 goto L_NMD2; 8656 if (!LOCAPT(ATPTR,TVALL,TVAL)) 8657 goto L_NMD2; 8658 PUSH(TCL); 8659 PUSH(NAMICL); 8660 PUSH(NHEDCL); 8661 D(NHEDCL) = D(NAMICL); 8662 SAVSTK(); 8663 PUSH(ATPTR); 8664 TRPHND(NORET); 8665 POP(NHEDCL); 8666 POP(NAMICL); 8667 POP(TCL); 8668L_NMD2: 8669 D_A(TCL) += DESCR+SPEC; 8670 goto L_NMD1; 8671 /*_*/ 8672L_NMDIC: 8673 if (SPCINT(VVAL,TSP)) 8674 goto L_NMD4; 8675 else 8676 BRANCH(INTR1) 8677 /*_*/ 8678L_NAMEXN: 8679 SAVSTK(); 8680 PUSH(TVAL); 8681 switch (EXPEVL(TVAL)) { 8682 case 1: 8683 BRANCH(FAIL) 8684 case 2: 8685 goto L_NMD5; 8686 case 3: 8687 BRANCH(NEMO) 8688 } 8689 /*_*/ 8690} 8691int 8692STR(retval) 8693 ret_t retval; 8694{ 8695 ENTRY(STR) 8696 D(ZPTR) = D(OCBSCL); 8697 D_A(ZPTR) += D_A(OCICL); 8698 SAVSTK(); 8699 PUSH(ONECL); 8700 CODSKP(NORET); 8701 D_V(ZPTR) = E; 8702 BRANCH(RTZPTR) 8703 /*_*/ 8704} 8705int 8706DIFFER(retval) 8707 ret_t retval; 8708{ 8709 ENTRY(DIFFER) 8710 SAVSTK(); 8711 switch (XYARGS(NORET)) { 8712 case 1: 8713 BRANCH(FAIL) 8714 } 8715 if (DCMP(XPTR, YPTR)) 8716 BRANCH(FAIL) 8717 else 8718 BRANCH(RETNUL) 8719 /*_*/ 8720} 8721int 8722FUNCTN(retval) 8723 ret_t retval; 8724{ 8725 ENTRY(FUNCTN) 8726 SAVSTK(); 8727 switch (VARVUP(XPTR)) { 8728 case 1: 8729 BRANCH(FAIL) 8730 } 8731 if (!LOCAPV(XPTR,FNCPL,XPTR)) 8732 BRANCH(FAIL) 8733 D(XPTR) = D(D_A(XPTR) + DESCR); 8734 D(XPTR) = D(D_A(XPTR)); 8735 if (D_A(XPTR) == D_A(UNDFCL)) 8736 BRANCH(FAIL) 8737 else 8738 BRANCH(RETNUL) 8739 /*_*/ 8740} 8741int 8742IDENT(retval) 8743 ret_t retval; 8744{ 8745 ENTRY(IDENT) 8746 SAVSTK(); 8747 switch (XYARGS(NORET)) { 8748 case 1: 8749 BRANCH(FAIL) 8750 } 8751 if (DCMP(XPTR, YPTR)) 8752 BRANCH(RETNUL) 8753 else 8754 BRANCH(FAIL) 8755 /*_*/ 8756} 8757int 8758LABEL(retval) 8759 ret_t retval; 8760{ 8761 ENTRY(LABEL) 8762 SAVSTK(); 8763 switch (VARVUP(NORET)) { 8764 case 1: 8765 BRANCH(FAIL) 8766 } 8767 D(XPTR) = D(D_A(XPTR) + ATTRIB); 8768 if (D_A(XPTR) == 0) 8769 BRANCH(FAIL) 8770 else 8771 BRANCH(RETNUL) 8772 /*_*/ 8773} 8774int 8775LEQ(retval) 8776 ret_t retval; 8777{ 8778 ENTRY(LEQ) 8779 SAVSTK(); 8780 switch (VARVAL(XPTR)) { 8781 case 1: 8782 BRANCH(FAIL) 8783 } 8784 PUSH(XPTR); 8785 SAVSTK(); 8786 switch (VARVAL(YPTR)) { 8787 case 1: 8788 BRANCH(FAIL) 8789 } 8790 POP(XPTR); 8791 if (DCMP(XPTR, YPTR)) 8792 BRANCH(RETNUL) 8793 else 8794 BRANCH(FAIL) 8795 /*_*/ 8796} 8797int 8798LGE(retval) 8799 ret_t retval; 8800{ 8801 ENTRY(LGE) 8802 SAVSTK(); 8803 switch (VARVAL(XPTR)) { 8804 case 1: 8805 BRANCH(FAIL) 8806 } 8807 PUSH(XPTR); 8808 SAVSTK(); 8809 switch (VARVAL(YPTR)) { 8810 case 1: 8811 BRANCH(FAIL) 8812 } 8813 POP(XPTR); 8814 if (DCMP(XPTR, YPTR)) 8815 BRANCH(RETNUL) 8816 if (D_A(XPTR) == 0) 8817 BRANCH(FAIL) 8818 if (D_A(YPTR) == 0) 8819 BRANCH(RETNUL) 8820 X_LOCSP(XSP,XPTR); 8821 X_LOCSP(YSP,YPTR); 8822 if (LEXCMP(XSP,YSP) < 0) 8823 BRANCH(FAIL) 8824 else 8825 BRANCH(RETNUL) 8826 /*_*/ 8827} 8828int 8829LGT(retval) 8830 ret_t retval; 8831{ 8832 ENTRY(LGT) 8833 SAVSTK(); 8834 switch (VARVAL(XPTR)) { 8835 case 1: 8836 BRANCH(FAIL) 8837 } 8838 PUSH(XPTR); 8839 SAVSTK(); 8840 switch (VARVAL(YPTR)) { 8841 case 1: 8842 BRANCH(FAIL) 8843 } 8844 POP(XPTR); 8845 if (DCMP(XPTR, YPTR)) 8846 BRANCH(FAIL) 8847 if (D_A(XPTR) == 0) 8848 BRANCH(FAIL) 8849 if (D_A(YPTR) == 0) 8850 BRANCH(RETNUL) 8851 X_LOCSP(XSP,XPTR); 8852 X_LOCSP(YSP,YPTR); 8853 if (LEXCMP(XSP,YSP) <= 0) 8854 BRANCH(FAIL) 8855 else 8856 BRANCH(RETNUL) 8857 /*_*/ 8858} 8859int 8860LLE(retval) 8861 ret_t retval; 8862{ 8863 ENTRY(LLE) 8864 SAVSTK(); 8865 switch (VARVAL(XPTR)) { 8866 case 1: 8867 BRANCH(FAIL) 8868 } 8869 PUSH(XPTR); 8870 SAVSTK(); 8871 switch (VARVAL(YPTR)) { 8872 case 1: 8873 BRANCH(FAIL) 8874 } 8875 POP(XPTR); 8876 if (DCMP(XPTR, YPTR)) 8877 BRANCH(RETNUL) 8878 if (D_A(XPTR) == 0) 8879 BRANCH(RETNUL) 8880 if (D_A(YPTR) == 0) 8881 BRANCH(FAIL) 8882 X_LOCSP(XSP,XPTR); 8883 X_LOCSP(YSP,YPTR); 8884 if (LEXCMP(XSP,YSP) <= 0) 8885 BRANCH(RETNUL) 8886 else 8887 BRANCH(FAIL) 8888 /*_*/ 8889} 8890int 8891LLT(retval) 8892 ret_t retval; 8893{ 8894 ENTRY(LLT) 8895 SAVSTK(); 8896 switch (VARVAL(XPTR)) { 8897 case 1: 8898 BRANCH(FAIL) 8899 } 8900 PUSH(XPTR); 8901 SAVSTK(); 8902 switch (VARVAL(YPTR)) { 8903 case 1: 8904 BRANCH(FAIL) 8905 } 8906 POP(XPTR); 8907 if (DCMP(XPTR, YPTR)) 8908 BRANCH(FAIL) 8909 if (D_A(XPTR) == 0) 8910 BRANCH(RETNUL) 8911 if (D_A(YPTR) == 0) 8912 BRANCH(FAIL) 8913 X_LOCSP(XSP,XPTR); 8914 X_LOCSP(YSP,YPTR); 8915 if (LEXCMP(XSP,YSP) < 0) 8916 BRANCH(RETNUL) 8917 else 8918 BRANCH(FAIL) 8919 /*_*/ 8920} 8921int 8922LNE(retval) 8923 ret_t retval; 8924{ 8925 ENTRY(LNE) 8926 SAVSTK(); 8927 switch (VARVAL(XPTR)) { 8928 case 1: 8929 BRANCH(FAIL) 8930 } 8931 PUSH(XPTR); 8932 SAVSTK(); 8933 switch (VARVAL(YPTR)) { 8934 case 1: 8935 BRANCH(FAIL) 8936 } 8937 POP(XPTR); 8938 if (DCMP(XPTR, YPTR)) 8939 BRANCH(FAIL) 8940 else 8941 BRANCH(RETNUL) 8942 /*_*/ 8943} 8944int 8945NEG(retval) 8946 ret_t retval; 8947{ 8948 ENTRY(NEG) 8949 PUSH(OCBSCL); 8950 PUSH(OCICL); 8951 SAVSTK(); 8952 switch (ARGVAL(NORET)) { 8953 case 2: 8954 BRANCH(FAIL) 8955 } 8956 POP(OCICL); 8957 POP(OCBSCL); 8958 SAVSTK(); 8959 PUSH(ONECL); 8960 switch (CODSKP(NORET)) { 8961 case 1: 8962 BRANCH(RETNUL) 8963 } 8964 /*_*/ 8965} 8966int 8967QUES(retval) 8968 ret_t retval; 8969{ 8970 ENTRY(QUES) 8971 SAVSTK(); 8972 switch (ARGVAL(NORET)) { 8973 case 1: 8974 BRANCH(FAIL) 8975 case 2: 8976 BRANCH(RETNUL) 8977 } 8978 /*_*/ 8979} 8980int 8981CHAR(retval) 8982 ret_t retval; 8983{ 8984 ENTRY(CHAR) 8985 SAVSTK(); 8986 switch (INTVAL(XCL)) { 8987 case 1: 8988 BRANCH(FAIL) 8989 } 8990 if (D_A(XCL) < 0) 8991 BRANCH(LENERR) 8992 if (D_A(XCL) >= 256) 8993 BRANCH(INTR30) 8994 SAVSTK(); 8995 PUSH(ONECL); 8996 CONVAR(XPTR); 8997 X_LOCSP(XSP,XPTR); 8998 { 8999 *S_SP(XSP) = D_A(XCL); /* Store argument as char */ 9000 } 9001 SAVSTK(); 9002 PUSH(ONECL); 9003 GNVARS(XPTR); 9004 BRANCH(RTXPTR) 9005 /*_*/ 9006} 9007int 9008LPAD(retval) 9009 ret_t retval; 9010{ 9011 ENTRY(LPAD) 9012 D_A(SCL) = 0; 9013 BRANCH(RPAD0) 9014 /*_*/ 9015} 9016int 9017RPAD(retval) 9018 ret_t retval; 9019{ 9020 ENTRY(RPAD) 9021 D_A(SCL) = 1; 9022 /* FALL */ 9023 BRANCH(RPAD0) 9024} 9025static int 9026RPAD0(retval) 9027 ret_t retval; 9028{ 9029 ENTRY(RPAD0) 9030 PUSH(SCL); 9031 SAVSTK(); 9032 switch (VARVAL(XPTR)) { 9033 case 1: 9034 BRANCH(FAIL) 9035 } 9036 PUSH(XPTR); 9037 SAVSTK(); 9038 switch (INTVAL(ZPTR)) { 9039 case 1: 9040 BRANCH(FAIL) 9041 } 9042 PUSH(ZPTR); 9043 SAVSTK(); 9044 switch (VARVAL(WPTR)) { 9045 case 1: 9046 BRANCH(FAIL) 9047 } 9048 POP(ZPTR); 9049 POP(XPTR); 9050 POP(SCL); 9051 X_LOCSP(VSP,WPTR); 9052 X_LOCSP(XSP,XPTR); 9053 if (D_A(ZPTR) > D_A(MLENCL)) 9054 BRANCH(INTR8) 9055 if (D_A(ZEROCL) > D_A(ZPTR)) 9056 BRANCH(LENERR) 9057 D_A(YPTR) = S_L(XSP); 9058 D_F(YPTR) = D_V(YPTR) = 0; 9059 if (D_A(YPTR) >= D_A(ZPTR)) 9060 BRANCH(RTXPTR) 9061 D_A(XCL) = D_A(ZPTR); 9062 SAVSTK(); 9063 PUSH(XCL); 9064 CONVAR(ZPTR); 9065 X_LOCSP(TSP,ZPTR); 9066 PAD(SCL,TSP,XSP,VSP); 9067 BRANCH(GENVSZ) 9068 /*_*/ 9069} 9070int 9071APPLY(retval) 9072 ret_t retval; 9073{ 9074 ENTRY(APPLY) 9075 D_A(XCL) = D_V(INCL); 9076 D_F(XCL) = D_V(XCL) = 0; 9077 D_A(XCL) -= 1; 9078 if (D_A(XCL) < 1) 9079 BRANCH(ARGNER) 9080 PUSH(XCL); 9081 SAVSTK(); 9082 switch (VARVUP(XPTR)) { 9083 case 1: 9084 BRANCH(FAIL) 9085 } 9086 POP(XCL); 9087 if (!LOCAPV(XPTR,FNCPL,XPTR)) 9088 BRANCH(UNDF) 9089 D(INCL) = D(D_A(XPTR) + DESCR); 9090 D_V(INCL) = D_A(XCL); 9091 SAVSTK(); 9092 PUSH(INCL); 9093 switch (INVOKE(ZPTR)) { 9094 case 1: 9095 BRANCH(FAIL) 9096 case 3: 9097 BRANCH(RTZPTR) 9098 } 9099 D(XPTR) = D(ZPTR); 9100 BRANCH(RTXNAM) 9101 /*_*/ 9102} 9103int 9104ARG(retval) 9105 ret_t retval; 9106{ 9107 ENTRY(ARG) 9108 PUSH(ONECL); 9109 PUSH(DEFCL); 9110 BRANCH(ARG1) 9111 /*_*/ 9112} 9113static int 9114ARGINT(retval) 9115 ret_t retval; 9116{ 9117 ENTRY(ARGINT) 9118 POP(XPTR); 9119 POP(XCL); 9120 PUSH(ONECL); 9121 PUSH(DEFCL); 9122 BRANCH(ARG2) 9123 /*_*/ 9124} 9125int 9126LOCAL(retval) 9127 ret_t retval; 9128{ 9129 ENTRY(LOCAL) 9130 PUSH(ONECL); 9131 PUSH(ZEROCL); 9132 PUSH(DEFCL); 9133 BRANCH(ARG1) 9134 /*_*/ 9135} 9136int 9137FIELDS(retval) 9138 ret_t retval; 9139{ 9140 ENTRY(FIELDS) 9141 PUSH(ZEROCL); 9142 PUSH(ZEROCL); 9143 PUSH(DATCL); 9144 /* FALL */ 9145 BRANCH(ARG1) 9146} 9147static int 9148ARG1(retval) 9149 ret_t retval; 9150{ 9151 ENTRY(ARG1) 9152 SAVSTK(); 9153 switch (VARVUP(XPTR)) { 9154 case 1: 9155 BRANCH(FAIL) 9156 } 9157 PUSH(XPTR); 9158 SAVSTK(); 9159 switch (INTVAL(XCL)) { 9160 case 1: 9161 BRANCH(FAIL) 9162 } 9163 if (D_A(ZEROCL) >= D_A(XCL)) 9164 BRANCH(FAIL) 9165 POP(XPTR); 9166 /* FALL */ 9167 BRANCH(ARG2) 9168} 9169static int 9170ARG2(retval) 9171 ret_t retval; 9172{ 9173 ENTRY(ARG2) 9174 if (!LOCAPV(XPTR,FNCPL,XPTR)) 9175 BRANCH(INTR30) 9176 D(XPTR) = D(D_A(XPTR) + DESCR); 9177 D(YCL) = D(D_A(XPTR)); 9178 D(XPTR) = D(D_A(XPTR) + DESCR); 9179 POP(ZCL); 9180 POP(ALCL); 9181 if (D_A(YCL) != D_A(ZCL)) 9182 BRANCH(INTR30) 9183 D_A(XCL) *= DESCR; 9184 D_F(XCL) = D_V(XCL) = 0; 9185 D_A(XCL) += 2*DESCR; 9186 D_A(YCL) = D_V(YCL); 9187 D_F(YCL) = D_V(YCL) = 0; 9188 D_A(YCL) *= DESCR; 9189 D_F(YCL) = D_V(YCL) = 0; 9190 if (D_A(ALCL) == 0) 9191 goto L_ARG4; 9192 D_A(YCL) += 2*DESCR; 9193 D(ZCL) = D(YCL); 9194 goto L_ARG5; 9195 /*_*/ 9196L_ARG4: 9197 D_A(ZCL) = D_V(D_A(XPTR)); 9198 D_F(ZCL) = D_V(ZCL) = 0; 9199 POP(ALCL); 9200 if (D_A(ALCL) == 0) 9201 goto L_ARG5; 9202 D_A(XCL) += D_A(YCL); 9203L_ARG5: 9204 if (D_A(XCL) > D_A(ZCL)) 9205 BRANCH(FAIL) 9206 D(ZPTR) = D(D_A(XPTR) + D_A(XCL)); 9207 BRANCH(RTZPTR) 9208 /*_*/ 9209} 9210int 9211CLEAR(retval) 9212 ret_t retval; 9213{ 9214 ENTRY(CLEAR) 9215 SAVSTK(); 9216 switch (ARGVAL(NORET)) { 9217 case 1: 9218 BRANCH(FAIL) 9219 } 9220 D_A(DMPPTR) = (int_t) (OBLIST-DESCR); 9221L_CLEAR1: 9222 if (D_PTR(DMPPTR) > D_PTR(OBEND)) 9223 BRANCH(RETNUL) 9224 D_A(DMPPTR) += DESCR; 9225 D(YPTR) = D(DMPPTR); 9226L_CLEAR2: 9227 D_A(YPTR) = D_A(D_A(YPTR) + LNKFLD); 9228 if (D_A(YPTR) == 0) 9229 goto L_CLEAR1; 9230 D(D_A(YPTR) + DESCR) = D(NULVCL); 9231 goto L_CLEAR2; 9232 /*_*/ 9233} 9234int 9235CMA(retval) 9236 ret_t retval; 9237{ 9238 ENTRY(CMA) 9239 D_A(ZCL) = D_V(INCL); 9240 D_F(ZCL) = D_V(ZCL) = 0; 9241L_CMA1: 9242 if (D_A(ZCL) == 0) 9243 BRANCH(FAIL) 9244 PUSH(ZCL); 9245 PUSH(OCBSCL); 9246 PUSH(OCICL); 9247 SAVSTK(); 9248 switch (ARGVAL(XPTR)) { 9249 case 1: 9250 goto L_CMA2; 9251 } 9252 POP(OCICL); 9253 POP(OCBSCL); 9254 POP(ZCL); 9255 SAVSTK(); 9256 PUSH(ZCL); 9257 switch (CODSKP(NORET)) { 9258 case 1: 9259 BRANCH(RTXPTR) 9260 } 9261L_CMA2: 9262 POP(OCICL); 9263 POP(OCBSCL); 9264 POP(ZCL); 9265 D_A(ZCL) -= 1; 9266 SAVSTK(); 9267 PUSH(ONECL); 9268 switch (CODSKP(NORET)) { 9269 case 1: 9270 goto L_CMA1; 9271 } 9272 /*_*/ 9273} 9274int 9275COLECT(retval) 9276 ret_t retval; 9277{ 9278 ENTRY(COLECT) 9279 SAVSTK(); 9280 switch (INTVAL(XPTR)) { 9281 case 1: 9282 BRANCH(FAIL) 9283 } 9284 if (D_A(XPTR) < 0) 9285 BRANCH(LENERR) 9286 SAVSTK(); 9287 PUSH(XPTR); 9288 switch (GC(ZPTR)) { 9289 case 1: 9290 BRANCH(FAIL) 9291 } 9292 D_V(ZPTR) = I; 9293 BRANCH(RTZPTR) 9294 /*_*/ 9295} 9296int 9297COPY(retval) 9298 ret_t retval; 9299{ 9300 ENTRY(COPY) 9301 SAVSTK(); 9302 switch (ARGVAL(XPTR)) { 9303 case 1: 9304 BRANCH(FAIL) 9305 } 9306 if (D_V(XPTR) == S) 9307 BRANCH(INTR1) 9308 if (D_V(XPTR) == I) 9309 BRANCH(INTR1) 9310 if (D_V(XPTR) == R) 9311 BRANCH(INTR1) 9312 if (D_V(XPTR) == N) 9313 BRANCH(INTR1) 9314 if (D_V(XPTR) == K) 9315 BRANCH(INTR1) 9316 if (D_V(XPTR) == E) 9317 BRANCH(INTR1) 9318 if (D_V(XPTR) == T) 9319 BRANCH(INTR1) 9320 D_A(XCL) = D_V(D_A(XPTR)); 9321 D_F(XCL) = D_V(XCL) = 0; 9322 D_V(XCL) = D_V(XPTR); 9323 SAVSTK(); 9324 PUSH(XCL); 9325 BLOCK(ZPTR); 9326 MOVBLK(D_A(ZPTR),D_A(XPTR),D_A(XCL)); 9327 BRANCH(RTZPTR) 9328 /*_*/ 9329} 9330int 9331CNVRT(retval) 9332 ret_t retval; 9333{ 9334 ENTRY(CNVRT) 9335 SAVSTK(); 9336 switch (ARGVAL(ZPTR)) { 9337 case 1: 9338 BRANCH(FAIL) 9339 } 9340 PUSH(ZPTR); 9341 SAVSTK(); 9342 switch (VARVUP(YPTR)) { 9343 case 1: 9344 BRANCH(FAIL) 9345 } 9346 POP(ZPTR); 9347 if (!LOCAPV(XPTR,DTATL,YPTR)) 9348 goto L_CNV1; 9349 D(XPTR) = D(D_A(XPTR) + DESCR); 9350 D_A(DTCL) = D_V(ZPTR); 9351 D_F(DTCL) = D_V(DTCL) = 0; 9352 D_V(DTCL) = D_V(XPTR); 9353 if (DCMP(DTCL, IVDTP)) 9354 BRANCH(CNVIV) 9355 if (DCMP(DTCL, VCDTP)) 9356 BRANCH(RECOMP) 9357 if (DCMP(DTCL, VEDTP)) 9358 BRANCH(CONVE) 9359 if (DCMP(DTCL, VRDTP)) 9360 BRANCH(CONVR) 9361 if (DCMP(DTCL, RIDTP)) 9362 BRANCH(CONRI) 9363 if (DCMP(DTCL, IRDTP)) 9364 BRANCH(CONIR) 9365 if (DCMP(DTCL, VIDTP)) 9366 BRANCH(CNVVI) 9367 if (DCMP(DTCL, ATDTP)) 9368 BRANCH(CNVAT) 9369 if (DCMP(DTCL, TADTP)) 9370 BRANCH(CNVTA) 9371 if (D_V(ZPTR) == D_V(XPTR)) 9372 BRANCH(RTZPTR) 9373 if (D_V(XPTR) == S) 9374 BRANCH(CNVRTS) 9375 else 9376 BRANCH(FAIL) 9377 /*_*/ 9378L_CNV1: 9379 X_LOCSP(YSP,YPTR); 9380 if (!LEXEQ(YSP,NUMSP)) 9381 BRANCH(INTR1) 9382 if (D_V(ZPTR) == I) 9383 BRANCH(RTZPTR) 9384 if (D_V(ZPTR) == R) 9385 BRANCH(RTZPTR) 9386 if (D_V(ZPTR) != S) 9387 BRANCH(FAIL) 9388 X_LOCSP(ZSP,ZPTR); 9389 if (SPCINT(ZPTR,ZSP)) 9390 BRANCH(RTZPTR) 9391 if (SPREAL(ZPTR,ZSP)) 9392 BRANCH(RTZPTR) 9393 else 9394 BRANCH(FAIL) 9395 /*_*/ 9396} 9397static int 9398RECOMP(retval) 9399 ret_t retval; 9400{ 9401 ENTRY(RECOMP) 9402 D_A(SCL) = 1; 9403 /* FALL */ 9404 BRANCH(RECOMJ) 9405} 9406static int 9407RECOMJ(retval) 9408 ret_t retval; 9409{ 9410 ENTRY(RECOMJ) 9411 X_LOCSP(TEXTSP,ZPTR); 9412L_RECOMT: 9413 D_A(OCALIM) = S_L(TEXTSP); 9414 D_F(OCALIM) = D_V(OCALIM) = 0; 9415 if (D_A(OCALIM) == 0) 9416 goto L_RECOMN; 9417 D_A(OCALIM) *= DESCR; 9418 D_F(OCALIM) = D_V(OCALIM) = 0; 9419 D_A(OCALIM) += 6*DESCR; 9420 D_V(OCALIM) = C; 9421 SAVSTK(); 9422 PUSH(OCALIM); 9423 BLOCK(CMBSCL); 9424 D(OCLIM) = D(CMBSCL); 9425 D_A(OCLIM) += D_A(OCALIM); 9426 D_A(OCLIM) -= 6*DESCR; 9427 D_A(CMOFCL) = 0; 9428 D_A(ESAICL) = 0; 9429 PUSH(CMBSCL); 9430 switch (D_A(SCL)) { 9431 case 2: 9432 BRANCH(CONVEX) 9433 } 9434L_RECOM1: 9435 if (S_L(TEXTSP) == 0) 9436 goto L_RECOM2; 9437 SAVSTK(); 9438 switch (CMPILE(NORET)) { 9439 case 1: 9440 goto L_RECOMF; 9441 case 3: 9442 goto L_RECOM1; 9443 } 9444L_RECOM2: 9445 D_A(SCL) = 3; 9446L_RECOMQ: 9447 D_A(CMOFCL) += DESCR; 9448 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(ENDCL); 9449 POP(ZPTR); 9450 BRANCH(RECOMZ) 9451 /*_*/ 9452L_RECOMF: 9453 D_A(SCL) = 1; 9454 goto L_RECOMQ; 9455 /*_*/ 9456L_RECOMN: 9457 _SPEC(TEXTSP) = _SPEC(BLSP); 9458 goto L_RECOMT; 9459 /*_*/ 9460} 9461static int 9462RECOMZ(retval) 9463 ret_t retval; 9464{ 9465 ENTRY(RECOMZ) 9466 D_A(CMBSCL) += D_A(CMOFCL); 9467 SAVSTK(); 9468 PUSH(CMBSCL); 9469 SPLIT(NORET); 9470 D_A(OCLIM) = 0; 9471 D_A(LPTR) = 0; 9472 ZERBLK(D_A(COMREG),D_A(COMDCT)); 9473 switch (D_A(SCL)) { 9474 case 1: 9475 BRANCH(FAIL) 9476 case 2: 9477 BRANCH(INTR10) 9478 case 3: 9479 BRANCH(RTZPTR) 9480 } 9481 /*_*/ 9482} 9483int 9484CODER(retval) 9485 ret_t retval; 9486{ 9487 ENTRY(CODER) 9488 SAVSTK(); 9489 switch (VARVAL(ZPTR)) { 9490 case 1: 9491 BRANCH(FAIL) 9492 case 2: 9493 BRANCH(RECOMP) 9494 } 9495 /*_*/ 9496} 9497static int 9498CONVE(retval) 9499 ret_t retval; 9500{ 9501 ENTRY(CONVE) 9502 D_A(SCL) = 2; 9503 BRANCH(RECOMJ) 9504 /*_*/ 9505} 9506static int 9507CONVEX(retval) 9508 ret_t retval; 9509{ 9510 ENTRY(CONVEX) 9511 SAVSTK(); 9512 switch (EXPR(FORMND)) { 9513 case 1: 9514 BRANCH(FAIL) 9515 } 9516 if (S_L(TEXTSP) != 0) 9517 BRANCH(FAIL) 9518 SAVSTK(); 9519 PUSH(FORMND); 9520 TREPUB(NORET); 9521 D(ZPTR) = D(CMBSCL); 9522 D_V(ZPTR) = E; 9523 D_A(SCL) = 3; 9524 BRANCH(RECOMZ) 9525 /*_*/ 9526} 9527static int 9528CONVR(retval) 9529 ret_t retval; 9530{ 9531 ENTRY(CONVR) 9532 X_LOCSP(ZSP,ZPTR); 9533 if (SPCINT(ZPTR,ZSP)) 9534 BRANCH(CONIR) 9535 if (SPREAL(ZPTR,ZSP)) 9536 BRANCH(RTZPTR) 9537 else 9538 BRANCH(FAIL) 9539 /*_*/ 9540} 9541static int 9542CONIR(retval) 9543 ret_t retval; 9544{ 9545 ENTRY(CONIR) 9546 D_RV(ZPTR) = (real_t)D_A(ZPTR); 9547 D_F(ZPTR) = 0; 9548 D_V(ZPTR) = R; 9549 BRANCH(RTZPTR) 9550 /*_*/ 9551} 9552static int 9553CONRI(retval) 9554 ret_t retval; 9555{ 9556 ENTRY(CONRI) 9557 CLR_MATH_ERROR(); 9558 D_A(ZPTR) = (int_t) D_RV(ZPTR); 9559 D_F(ZPTR) = 0; 9560 D_V(ZPTR) = I; 9561 if (MATH_ERROR()) 9562 BRANCH(FAIL) 9563 BRANCH(RTZPTR) 9564 /*_*/ 9565} 9566static int 9567CNVIV(retval) 9568 ret_t retval; 9569{ 9570 ENTRY(CNVIV) 9571 SAVSTK(); 9572 PUSH(ZPTR); 9573 switch (GNVARI(ZPTR)) { 9574 case 1: 9575 BRANCH(RTZPTR) 9576 } 9577 /*_*/ 9578} 9579static int 9580CNVVI(retval) 9581 ret_t retval; 9582{ 9583 ENTRY(CNVVI) 9584 X_LOCSP(ZSP,ZPTR); 9585 if (SPCINT(ZPTR,ZSP)) 9586 BRANCH(RTZPTR) 9587 if (SPREAL(ZPTR,ZSP)) 9588 BRANCH(CONRI) 9589 else 9590 BRANCH(FAIL) 9591 /*_*/ 9592} 9593static int 9594CNVRTS(retval) 9595 ret_t retval; 9596{ 9597 ENTRY(CNVRTS) 9598 SAVSTK(); 9599 PUSH(ZPTR); 9600 DTREP(XPTR); 9601 _SPEC(ZSP) = _SPEC(D_A(XPTR)); 9602 BRANCH(GENVRZ) 9603 /*_*/ 9604} 9605static int 9606CNVTA(retval) 9607 ret_t retval; 9608{ 9609 ENTRY(CNVTA) 9610 D(WPTR) = D(ZPTR); 9611 SAVSTK(); 9612 PUSH(ZPTR); 9613 switch (ICNVTA(ZPTR)) { 9614 case 1: 9615 BRANCH(FAIL) 9616 } 9617 D(YPTR) = D(ZPTR); 9618 D_A(YCL) *= DESCR; 9619 D_F(YCL) = D_V(YCL) = 0; 9620 D_A(YPTR) += 5*DESCR; 9621 D(TPTR) = D(YPTR); 9622 D_A(TPTR) += D_A(YCL); 9623L_CNVTA8: 9624 D_A(WCL) = D_V(D_A(WPTR)); 9625 D_F(WCL) = D_V(WCL) = 0; 9626 D_A(WCL) -= 2*DESCR; 9627 D_A(WCL) = D_A(WPTR) + D_A(WCL); 9628 D_F(WCL) = D_F(WPTR); 9629 D_V(WCL) = D_V(WPTR); 9630L_CNVTA3: 9631 D(TCL) = D(D_A(WPTR) + DESCR); 9632 if (DCMP(TCL, NULVCL)) 9633 goto L_CNVTA5; 9634 D(D_A(TPTR)) = D(TCL); 9635 D(D_A(YPTR)) = D(D_A(WPTR) + 2*DESCR); 9636 D_A(YPTR) += DESCR; 9637 D_A(TPTR) += DESCR; 9638L_CNVTA5: 9639 D_A(WPTR) += 2*DESCR; 9640 if (D_A(WCL) != D_A(WPTR)) 9641 goto L_CNVTA3; 9642 D(WPTR) = D(D_A(WCL) + 2*DESCR); 9643 if (D_A(WPTR) != 1) 9644 goto L_CNVTA8; 9645 D_A(TPTR) = 0; 9646 BRANCH(RTZPTR) 9647 /*_*/ 9648} 9649static int 9650ICNVTA(retval) 9651 ret_t retval; 9652{ 9653 ENTRY(ICNVTA) 9654 POP(YPTR); 9655 D(YCL) = D(ZEROCL); 9656L_CNVTA7: 9657 D_A(XCL) = D_V(D_A(YPTR)); 9658 D_F(XCL) = D_V(XCL) = 0; 9659 D(ZCL) = D(XCL); 9660 D_A(XCL) -= 3*DESCR; 9661L_CNVTA1: 9662 D(WCL) = D(D_A(YPTR) + D_A(XCL)); 9663 if (DCMP(WCL, NULVCL)) 9664 goto L_CNVTA2; 9665 D_A(YCL) += 1; 9666L_CNVTA2: 9667 if (D_A(XCL) == DESCR) 9668 goto L_CNVTA6; 9669 D_A(XCL) -= 2*DESCR; 9670 goto L_CNVTA1; 9671 /*_*/ 9672L_CNVTA6: 9673 D(YPTR) = D(D_A(YPTR) + D_A(ZCL)); 9674 if (D_A(YPTR) != 1) 9675 goto L_CNVTA7; 9676 if (D_A(YCL) == 0) 9677 BRANCH(FAIL) 9678 D_A(XCL) = D_A(YCL); 9679 D_A(XCL) *= 2*DESCR; 9680 D_F(XCL) = D_V(XCL) = 0; 9681 INTSPC(YSP,YCL); 9682 S_L(PROTSP) = 0; 9683 APDSP(PROTSP,YSP); 9684 APDSP(PROTSP,CMASP); 9685 D(WCL) = D(ZEROCL); 9686 D_A(WCL) = 2; 9687 INTSPC(XSP,WCL); 9688 APDSP(PROTSP,XSP); 9689 _SPEC(XSP) = _SPEC(PROTSP); 9690 SAVSTK(); 9691 PUSH(XSPPTR); 9692 GENVAR(TPTR); 9693 D(ZCL) = D(XCL); 9694 D_A(XCL) += 4*DESCR; 9695 SAVSTK(); 9696 PUSH(XCL); 9697 BLOCK(ZPTR); 9698 D_V(ZPTR) = A; 9699 D(ATPRCL) = D(TPTR); 9700 D_V(ATEXCL) = D_A(YCL); 9701 MOVBLK(D_A(ZPTR),D_A(ATRHD),D_A(FRDSCL)); 9702 D(retval) = D(ZPTR); 9703 RETURN(2) 9704 /*_*/ 9705} 9706static int 9707CNVAT(retval) 9708 ret_t retval; 9709{ 9710 ENTRY(CNVAT) 9711 D(XCL) = D(D_A(ZPTR) + 2*DESCR); 9712 D(YPTR) = D(ZPTR); 9713 if (D_A(XCL) != 2) 9714 BRANCH(FAIL) 9715 D(XCL) = D(D_A(ZPTR) + 3*DESCR); 9716 if (D_V(XCL) != 2) 9717 BRANCH(FAIL) 9718 D_A(XCL) = D_V(D_A(ZPTR)); 9719 D_F(XCL) = D_V(XCL) = 0; 9720 D_A(XCL) -= 2*DESCR; 9721 SAVSTK(); 9722 PUSH(XCL); 9723 BLOCK(XPTR); 9724 D_V(XPTR) = T; 9725 D(YCL) = D(D_A(ZPTR) + 4*DESCR); 9726 D(ZPTR) = D(XPTR); 9727 D(D_A(XPTR) + D_A(XCL)) = D(ONECL); 9728 D_A(XCL) -= DESCR; 9729 D(TCL) = D(EXTVAL); 9730 D_A(TCL) += 2*DESCR; 9731 D(D_A(XPTR) + D_A(XCL)) = D(TCL); 9732 D_A(YCL) = D_V(YCL); 9733 D_F(YCL) = D_V(YCL) = 0; 9734 D_A(YCL) *= DESCR; 9735 D_F(YCL) = D_V(YCL) = 0; 9736 D_A(YPTR) += 5*DESCR; 9737 D(WPTR) = D(YPTR); 9738 D_A(WPTR) += D_A(YCL); 9739L_CNVAT2: 9740 D(D_A(XPTR) + DESCR) = D(D_A(WPTR)); 9741 D(D_A(XPTR) + 2*DESCR) = D(D_A(YPTR)); 9742 D_A(YCL) -= DESCR; 9743 if (D_A(YCL) == 0) 9744 BRANCH(RTZPTR) 9745 D_A(XPTR) += 2*DESCR; 9746 D_A(WPTR) += DESCR; 9747 D_A(YPTR) += DESCR; 9748 goto L_CNVAT2; 9749 /*_*/ 9750} 9751int 9752DATE(retval) 9753 ret_t retval; 9754{ 9755 ENTRY(DATE) 9756 SAVSTK(); 9757 switch (ARGVAL(XPTR)) { 9758 case 1: 9759 BRANCH(FAIL) 9760 } 9761 _DATE(ZSP,XPTR); 9762 BRANCH(GENVRZ) 9763 /*_*/ 9764} 9765int 9766DT(retval) 9767 ret_t retval; 9768{ 9769 ENTRY(DT) 9770 SAVSTK(); 9771 switch (ARGVAL(A2PTR)) { 9772 case 1: 9773 BRANCH(FAIL) 9774 } 9775 D_V(DT1CL) = D_V(A2PTR); 9776 if (!LOCAPT(A3PTR,DTATL,DT1CL)) 9777 goto L_DTEXTN; 9778 D(A3PTR) = D(D_A(A3PTR) + 2*DESCR); 9779L_DTRTN: 9780 D(retval) = D(A3PTR); 9781 RETURN(3) 9782 /*_*/ 9783L_DTEXTN: 9784 D(A3PTR) = D(EXTPTR); 9785 goto L_DTRTN; 9786 /*_*/ 9787} 9788int 9789DMP(retval) 9790 ret_t retval; 9791{ 9792 ENTRY(DMP) 9793 SAVSTK(); 9794 switch (INTVAL(XPTR)) { 9795 case 1: 9796 BRANCH(FAIL) 9797 } 9798 if (D_A(XPTR) == 0) 9799 BRANCH(RETNUL) 9800 /* FALL */ 9801 BRANCH(DUMP) 9802} 9803static int 9804DUMP(retval) 9805 ret_t retval; 9806{ 9807 ENTRY(DUMP) 9808 D_A(WPTR) = (int_t) (OBLIST-DESCR); 9809L_DMPB: 9810 if (D_PTR(WPTR) > D_PTR(OBEND)) 9811 BRANCH(RETNUL) 9812 D_A(WPTR) += DESCR; 9813 D(YPTR) = D(WPTR); 9814L_DMPA: 9815 D_A(YPTR) = D_A(D_A(YPTR) + LNKFLD); 9816 if (D_A(YPTR) == 0) 9817 goto L_DMPB; 9818 D(XPTR) = D(D_A(YPTR) + DESCR); 9819 if (DCMP(XPTR, NULVCL)) 9820 goto L_DMPA; 9821 S_L(DMPSP) = 0; 9822 X_LOCSP(YSP,YPTR); 9823 D_A(YCL) = S_L(YSP); 9824 D_F(YCL) = D_V(YCL) = 0; 9825 if (D_A(YCL) >= BUFLEN) 9826 goto L_DMPOVR; 9827 APDSP(DMPSP,YSP); 9828 APDSP(DMPSP,BLEQSP); 9829 if (D_V(XPTR) == S) 9830 goto L_DMPV; 9831 if (D_V(XPTR) == I) 9832 goto L_DMPI; 9833 SAVSTK(); 9834 PUSH(XPTR); 9835 DTREP(A1PTR); 9836 _SPEC(YSP) = _SPEC(D_A(A1PTR)); 9837L_DMPX: 9838 D_A(XCL) = S_L(YSP); 9839 D_F(XCL) = D_V(XCL) = 0; 9840 D_A(YCL) += D_A(XCL); 9841 if (D_A(YCL) > BUFLEN) 9842 goto L_DMPOVR; 9843 APDSP(DMPSP,YSP); 9844 if (D_V(XPTR) != T) 9845 goto L_DMPRT; 9846 if (!(D_F(D_A(XPTR)) & FRZN)) 9847 goto L_DMPRT; 9848 APDSP(DMPSP,FRZNSP); 9849 goto L_DMPRT; 9850 /*_*/ 9851L_DMPV: 9852 X_LOCSP(YSP,XPTR); 9853 D_A(XCL) = S_L(YSP); 9854 D_F(XCL) = D_V(XCL) = 0; 9855 D_A(YCL) += D_A(XCL); 9856 if (D_A(YCL) > BUFLEN) 9857 goto L_DMPOVR; 9858 APDSP(DMPSP,QTSP); 9859 APDSP(DMPSP,YSP); 9860 APDSP(DMPSP,QTSP); 9861L_DMPRT: 9862 IO_PRINT(IOKEY, OUTBLK, DMPSP); 9863 goto L_DMPA; 9864 /*_*/ 9865L_DMPI: 9866 INTSPC(YSP,XPTR); 9867 goto L_DMPX; 9868 /*_*/ 9869L_DMPOVR: 9870 io_printf(D_A(OUTPUT),PRTOVF); 9871 goto L_DMPA; 9872 /*_*/ 9873} 9874static int 9875DMK(retval) 9876 ret_t retval; 9877{ 9878 ENTRY(DMK) 9879 io_printf(D_A(OUTPUT),PKEYF); 9880 D_A(XCL) = D_V(D_A(KNLIST)); 9881 D_F(XCL) = D_V(XCL) = 0; 9882L_DMPK1: 9883 D(XPTR) = D(D_A(KNLIST) + D_A(XCL)); 9884 D_A(XCL) -= DESCR; 9885 D(YPTR) = D(D_A(KNLIST) + D_A(XCL)); 9886 INTSPC(YSP,YPTR); 9887 X_LOCSP(XSP,XPTR); 9888 S_L(DMPSP) = 0; 9889 APDSP(DMPSP,AMPSP); 9890 APDSP(DMPSP,XSP); 9891 APDSP(DMPSP,BLEQSP); 9892 APDSP(DMPSP,YSP); 9893 IO_PRINT(IOKEY, OUTBLK, DMPSP); 9894 D_A(XCL) -= DESCR; 9895 if (D_A(XCL) == 0) 9896 BRANCH(RTN1) 9897 else 9898 goto L_DMPK1; 9899 /*_*/ 9900} 9901int 9902DUPL(retval) 9903 ret_t retval; 9904{ 9905 ENTRY(DUPL) 9906 SAVSTK(); 9907 switch (VARVAL(XPTR)) { 9908 case 1: 9909 BRANCH(FAIL) 9910 } 9911 PUSH(XPTR); 9912 SAVSTK(); 9913 switch (INTVAL(YPTR)) { 9914 case 1: 9915 BRANCH(FAIL) 9916 } 9917 POP(XPTR); 9918 if (D_A(YPTR) < 0) 9919 BRANCH(FAIL) 9920 if (D_A(YPTR) == 0) 9921 BRANCH(RETNUL) 9922 X_LOCSP(XSP,XPTR); 9923 D_A(XCL) = S_L(XSP); 9924 D_F(XCL) = D_V(XCL) = 0; 9925 CLR_MATH_ERROR(); 9926 D_A(XCL) *= D_A(YPTR); 9927 if (MATH_ERROR()) 9928 BRANCH(AERROR) 9929 if (D_A(XCL) > D_A(MLENCL)) 9930 BRANCH(INTR8) 9931 SAVSTK(); 9932 PUSH(XCL); 9933 CONVAR(ZPTR); 9934 X_LOCSP(TSP,ZPTR); 9935 S_L(TSP) = 0; 9936L_DUPL1: 9937 APDSP(TSP,XSP); 9938 D_A(YPTR) -= 1; 9939 if (D_A(YPTR) == 0) 9940 BRANCH(GENVSZ) 9941 else 9942 goto L_DUPL1; 9943 /*_*/ 9944} 9945int 9946OPSYN(retval) 9947 ret_t retval; 9948{ 9949 ENTRY(OPSYN) 9950 SAVSTK(); 9951 switch (VARVUP(XPTR)) { 9952 case 1: 9953 BRANCH(FAIL) 9954 } 9955 PUSH(XPTR); 9956 SAVSTK(); 9957 switch (VARVUP(YPTR)) { 9958 case 1: 9959 BRANCH(FAIL) 9960 } 9961 PUSH(YPTR); 9962 SAVSTK(); 9963 switch (INTVAL(ZPTR)) { 9964 case 1: 9965 BRANCH(FAIL) 9966 } 9967 POP(YPTR); 9968 POP(XPTR); 9969 if (D_A(XPTR) == 0) 9970 BRANCH(NONAME) 9971 if (D_A(ZPTR) == 1) 9972 goto L_UNYOP; 9973 if (D_A(ZPTR) == 2) 9974 goto L_BNYOP; 9975 if (D_A(ZPTR) != 0) 9976 BRANCH(INTR30) 9977 SAVSTK(); 9978 PUSH(XPTR); 9979 FINDEX(XPTR); 9980L_UNBF: 9981 SAVSTK(); 9982 PUSH(YPTR); 9983 FINDEX(YPTR); 9984L_OPPD: 9985 D(D_A(XPTR)) = D(D_A(YPTR)); 9986 D(D_A(XPTR) + DESCR) = D(D_A(YPTR) + DESCR); 9987 BRANCH(RETNUL) 9988 /*_*/ 9989L_UNYOP: 9990 X_LOCSP(XSP,XPTR); 9991 if (S_L(XSP) != 1) 9992 goto L_UNAF; 9993 _SPEC(ZSP) = _SPEC(PROTSP); 9994 S_L(ZSP) = 0; 9995 APDSP(ZSP,XSP); 9996 APDSP(ZSP,LPRNSP); 9997 switch (STREAM(TSP, ZSP, &UNOPTB)) { 9998 case ST_ERROR: 9999 case ST_EOS: 10000 goto L_UNAF; 10001 } 10002 D(XPTR) = D(STYPE); 10003L_UNCF: 10004 X_LOCSP(YSP,YPTR); 10005 if (S_L(YSP) != 1) 10006 goto L_UNBF; 10007 _SPEC(ZSP) = _SPEC(PROTSP); 10008 S_L(ZSP) = 0; 10009 APDSP(ZSP,YSP); 10010 APDSP(ZSP,LPRNSP); 10011 switch (STREAM(TSP, ZSP, &UNOPTB)) { 10012 case ST_ERROR: 10013 case ST_EOS: 10014 goto L_UNBF; 10015 } 10016 D(YPTR) = D(STYPE); 10017 goto L_OPPD; 10018 /*_*/ 10019L_UNAF: 10020 SAVSTK(); 10021 PUSH(XPTR); 10022 FINDEX(XPTR); 10023 goto L_UNCF; 10024 /*_*/ 10025L_BNYOP: 10026 X_LOCSP(XSP,XPTR); 10027 if (S_L(XSP) > S_L(EQLSP)) 10028 goto L_BNAF; 10029 _SPEC(ZSP) = _SPEC(PROTSP); 10030 S_L(ZSP) = 0; 10031 APDSP(ZSP,XSP); 10032 APDSP(ZSP,BLSP); 10033 if (D_A(SPITCL) != 0) 10034 goto L_BNYOP2; 10035 switch (STREAM(TSP, ZSP, &BIOPTB)) { 10036 case ST_ERROR: 10037 case ST_EOS: 10038 goto L_BNAF; 10039 } 10040 goto L_BNYOP3; 10041 /*_*/ 10042L_BNYOP2: 10043 switch (STREAM(TSP, ZSP, &SBIPTB)) { 10044 case ST_ERROR: 10045 case ST_EOS: 10046 goto L_BNAF; 10047 } 10048L_BNYOP3: 10049 if (S_L(ZSP) != 0) 10050 goto L_BNAF; 10051 D(XPTR) = D(STYPE); 10052L_BNCF: 10053 X_LOCSP(YSP,YPTR); 10054 if (S_L(YSP) > S_L(EQLSP)) 10055 goto L_BNBF; 10056 _SPEC(ZSP) = _SPEC(PROTSP); 10057 S_L(ZSP) = 0; 10058 APDSP(ZSP,YSP); 10059 APDSP(ZSP,BLSP); 10060 if (D_A(SPITCL) != 0) 10061 goto L_BNCF2; 10062 switch (STREAM(TSP, ZSP, &BIOPTB)) { 10063 case ST_ERROR: 10064 case ST_EOS: 10065 goto L_BNBF; 10066 } 10067 goto L_BNCF3; 10068 /*_*/ 10069L_BNCF2: 10070 switch (STREAM(TSP, ZSP, &SBIPTB)) { 10071 case ST_ERROR: 10072 case ST_EOS: 10073 goto L_BNBF; 10074 } 10075L_BNCF3: 10076 if (S_L(ZSP) != 0) 10077 goto L_BNBF; 10078 D(YPTR) = D(STYPE); 10079 goto L_OPPD; 10080 /*_*/ 10081L_BNAF: 10082 if (LEXEQ(XSP,BLSP)) 10083 goto L_BNCN; 10084 SAVSTK(); 10085 PUSH(XPTR); 10086 FINDEX(XPTR); 10087 goto L_BNCF; 10088 /*_*/ 10089L_BNCN: 10090 D(XPTR) = D(CONCL); 10091 goto L_BNCF; 10092 /*_*/ 10093L_BNBF: 10094 if (!LEXEQ(YSP,BLSP)) 10095 goto L_UNBF; 10096 D(YPTR) = D(CONCL); 10097 goto L_OPPD; 10098 /*_*/ 10099} 10100int 10101RPLACE(retval) 10102 ret_t retval; 10103{ 10104 ENTRY(RPLACE) 10105 SAVSTK(); 10106 switch (VARVAL(XPTR)) { 10107 case 1: 10108 BRANCH(FAIL) 10109 } 10110 PUSH(XPTR); 10111 SAVSTK(); 10112 switch (VARVAL(YPTR)) { 10113 case 1: 10114 BRANCH(FAIL) 10115 } 10116 PUSH(YPTR); 10117 SAVSTK(); 10118 switch (VARVAL(ZPTR)) { 10119 case 1: 10120 BRANCH(FAIL) 10121 } 10122 POP(YPTR); 10123 POP(XPTR); 10124 if (D_A(XPTR) == 0) 10125 BRANCH(RTXPTR) 10126 X_LOCSP(YSP,YPTR); 10127 X_LOCSP(ZSP,ZPTR); 10128 if (S_L(ZSP) != S_L(YSP)) 10129 BRANCH(FAIL) 10130 if (D_A(YPTR) == 0) 10131 BRANCH(FAIL) 10132 X_LOCSP(XSP,XPTR); 10133 D_A(XCL) = S_L(XSP); 10134 D_F(XCL) = D_V(XCL) = 0; 10135 SAVSTK(); 10136 PUSH(XCL); 10137 CONVAR(ZPTR); 10138 X_LOCSP(TSP,ZPTR); 10139 S_L(TSP) = 0; 10140 APDSP(TSP,XSP); 10141 _RPLACE(TSP,YSP,ZSP); 10142 BRANCH(GENVSZ) 10143 /*_*/ 10144} 10145int 10146REVERS(retval) 10147 ret_t retval; 10148{ 10149 ENTRY(REVERS) 10150 SAVSTK(); 10151 switch (VARVAL(XPTR)) { 10152 case 1: 10153 BRANCH(FAIL) 10154 } 10155 X_LOCSP(XSP,XPTR); 10156 D_A(ZPTR) = S_L(XSP); 10157 D_F(ZPTR) = D_V(ZPTR) = 0; 10158 if (D_A(ZPTR) == 0) 10159 BRANCH(RETNUL) 10160 D_A(XCL) = D_A(ZPTR); 10161 SAVSTK(); 10162 PUSH(XCL); 10163 CONVAR(ZPTR); 10164 X_LOCSP(TSP,ZPTR); 10165 REVERSE(TSP,XSP); 10166 BRANCH(GENVSZ) 10167 /*_*/ 10168} 10169int 10170SIZE(retval) 10171 ret_t retval; 10172{ 10173 ENTRY(SIZE) 10174 SAVSTK(); 10175 switch (VARVAL(XPTR)) { 10176 case 1: 10177 BRANCH(FAIL) 10178 } 10179 X_LOCSP(XSP,XPTR); 10180 D_A(ZPTR) = S_L(XSP); 10181 D_F(ZPTR) = D_V(ZPTR) = 0; 10182 D_V(ZPTR) = I; 10183 BRANCH(RTZPTR) 10184 /*_*/ 10185} 10186int 10187SUBSTR(retval) 10188 ret_t retval; 10189{ 10190 ENTRY(SUBSTR) 10191 SAVSTK(); 10192 switch (VARVAL(XPTR)) { 10193 case 1: 10194 BRANCH(FAIL) 10195 } 10196 PUSH(XPTR); 10197 SAVSTK(); 10198 switch (INTVAL(YPTR)) { 10199 case 1: 10200 BRANCH(FAIL) 10201 } 10202 PUSH(YPTR); 10203 SAVSTK(); 10204 switch (INTVAL(ZPTR)) { 10205 case 1: 10206 BRANCH(FAIL) 10207 } 10208 POP(YPTR); 10209 POP(XPTR); 10210 if (D_A(YPTR) < 1) 10211 BRANCH(FAIL) 10212 D_A(YPTR) -= 1; 10213 X_LOCSP(XSP,XPTR); 10214 D_A(WPTR) = S_L(XSP); 10215 D_F(WPTR) = D_V(WPTR) = 0; 10216 D_A(WPTR) -= D_A(YPTR); 10217 if (D_A(ZPTR) > D_A(WPTR)) 10218 BRANCH(FAIL) 10219 if (D_A(ZPTR) < 0) 10220 BRANCH(FAIL) 10221 if (D_A(ZPTR) > 0) 10222 goto L_SSNOFX; 10223 D_A(ZPTR) = D_A(WPTR); 10224L_SSNOFX: 10225 if (D_A(ZPTR) < 0) 10226 BRANCH(FAIL) 10227 if (D_A(ZPTR) == 0) 10228 BRANCH(RETNUL) 10229 D_A(XCL) = D_A(ZPTR); 10230 SAVSTK(); 10231 PUSH(XCL); 10232 CONVAR(ZPTR); 10233 X_LOCSP(TSP,ZPTR); 10234 XSUBSTR(TSP,XSP,YPTR); 10235 BRANCH(GENVSZ) 10236 /*_*/ 10237} 10238int 10239TIME(retval) 10240 ret_t retval; 10241{ 10242 ENTRY(TIME) 10243 SAVSTK(); 10244 switch (ARGVAL(NORET)) { 10245 case 1: 10246 BRANCH(FAIL) 10247 } 10248 D_RV(ZPTR) = mstime(); 10249 D_F(ZPTR) = D_V(ZPTR) = 0; 10250 D_RV(ZPTR) -= D_RV(ETMCL); 10251 D_V(ZPTR) = R; 10252 BRANCH(RTZPTR) 10253 /*_*/ 10254} 10255int 10256TRIM(retval) 10257 ret_t retval; 10258{ 10259 ENTRY(TRIM) 10260 SAVSTK(); 10261 switch (VARVAL(XPTR)) { 10262 case 1: 10263 BRANCH(FAIL) 10264 } 10265 X_LOCSP(ZSP,XPTR); 10266 TRIMSP(ZSP,ZSP); 10267 BRANCH(GENVRZ) 10268 /*_*/ 10269} 10270int 10271VDIFFR(retval) 10272 ret_t retval; 10273{ 10274 ENTRY(VDIFFR) 10275 SAVSTK(); 10276 switch (XYARGS(NORET)) { 10277 case 1: 10278 BRANCH(FAIL) 10279 } 10280 if (DCMP(XPTR, YPTR)) 10281 BRANCH(FAIL) 10282 else 10283 BRANCH(RTXPTR) 10284 /*_*/ 10285} 10286static int 10287RT1NUL(retval) 10288 ret_t retval; 10289{ 10290 ENTRY(RT1NUL) 10291 D(retval) = D(NULVCL); 10292 RETURN(1) 10293 /*_*/ 10294} 10295static int 10296RTN1(retval) 10297 ret_t retval; 10298{ 10299 ENTRY(RTN1) 10300 /* FALL */ 10301 BRANCH(FAIL) 10302} 10303static int 10304FAIL(retval) 10305 ret_t retval; 10306{ 10307 ENTRY(FAIL) 10308 RETURN(1) 10309 /*_*/ 10310} 10311static int 10312RETNUL(retval) 10313 ret_t retval; 10314{ 10315 ENTRY(RETNUL) 10316 D(retval) = D(NULVCL); 10317 RETURN(3) 10318 /*_*/ 10319} 10320static int 10321RTN2(retval) 10322 ret_t retval; 10323{ 10324 ENTRY(RTN2) 10325 RETURN(2) 10326 /*_*/ 10327} 10328static int 10329RTN3(retval) 10330 ret_t retval; 10331{ 10332 ENTRY(RTN3) 10333 /* FALL */ 10334 BRANCH(RTNUL3) 10335} 10336static int 10337RTNUL3(retval) 10338 ret_t retval; 10339{ 10340 ENTRY(RTNUL3) 10341 RETURN(3) 10342 /*_*/ 10343} 10344static int 10345RTXNAM(retval) 10346 ret_t retval; 10347{ 10348 ENTRY(RTXNAM) 10349 D(retval) = D(XPTR); 10350 RETURN(2) 10351 /*_*/ 10352} 10353static int 10354RTXPTR(retval) 10355 ret_t retval; 10356{ 10357 ENTRY(RTXPTR) 10358 D(retval) = D(XPTR); 10359 RETURN(3) 10360 /*_*/ 10361} 10362static int 10363RTYPTR(retval) 10364 ret_t retval; 10365{ 10366 ENTRY(RTYPTR) 10367 D(retval) = D(YPTR); 10368 RETURN(3) 10369 /*_*/ 10370} 10371static int 10372ARTN(retval) 10373 ret_t retval; 10374{ 10375 ENTRY(ARTN) 10376 D_A(ARTHCL) += 1; 10377 /* FALL */ 10378 BRANCH(RTZPTR) 10379} 10380static int 10381RTZPTR(retval) 10382 ret_t retval; 10383{ 10384 ENTRY(RTZPTR) 10385 D(retval) = D(ZPTR); 10386 RETURN(3) 10387 /*_*/ 10388} 10389static int 10390A5RTN(retval) 10391 ret_t retval; 10392{ 10393 ENTRY(A5RTN) 10394 D(retval) = D(A5PTR); 10395 RETURN(1) 10396 /*_*/ 10397} 10398static int 10399GENVSZ(retval) 10400 ret_t retval; 10401{ 10402 ENTRY(GENVSZ) 10403 SAVSTK(); 10404 PUSH(XCL); 10405 switch (GNVARS(ZPTR)) { 10406 case 1: 10407 BRANCH(RTZPTR) 10408 } 10409 /*_*/ 10410} 10411static int 10412GENVRZ(retval) 10413 ret_t retval; 10414{ 10415 ENTRY(GENVRZ) 10416 SAVSTK(); 10417 PUSH(ZSPPTR); 10418 switch (GENVAR(ZPTR)) { 10419 case 1: 10420 BRANCH(RTZPTR) 10421 } 10422 /*_*/ 10423} 10424static int 10425GENVIX(retval) 10426 ret_t retval; 10427{ 10428 ENTRY(GENVIX) 10429 SAVSTK(); 10430 PUSH(XPTR); 10431 switch (GNVARI(XPTR)) { 10432 case 1: 10433 BRANCH(RTXNAM) 10434 } 10435 /*_*/ 10436} 10437int 10438END(retval) 10439 ret_t retval; 10440{ 10441 ENTRY(END) 10442 if (D_A(ERRLCL) <= 0) 10443 goto L_END2; 10444 D_A(ERRLCL) -= 1; 10445 D_A(ERRTYP) = 0; 10446 D_A(ERRTXT) = 0; 10447 D(FRTNCL) = D(OCICL); 10448 D_A(FRTNCL) -= DESCR; 10449 D(LSTNCL) = D(STNOCL); 10450 D_A(LSLNCL) = D_A(LNNOCL); 10451 D_A(LSFLNM) = D_A(FILENM); 10452 SAVSTK(); 10453 switch (XITHND(NORET)) { 10454 case 3: 10455 BRANCH(RTNUL3) 10456 } 10457L_END2: 10458 io_flushall(0); 10459 if (D_A(BANRCL) == 0) 10460 BRANCH(FTLEN2) 10461 io_printf(D_A(PUNCH),NRMEND,LVLCL); 10462 io_printf(D_A(PUNCH),LASTSF,FILENM,LNNOCL,STNOCL); 10463 BRANCH(FTLEN2) 10464 /*_*/ 10465} 10466static int 10467FTLEND(retval) 10468 ret_t retval; 10469{ 10470 ENTRY(FTLEND) 10471 io_flushall(0); 10472 io_printf(D_A(PUNCH),FTLCF,FILENM,LNNOCL,ERRTYP,STNOCL,LVLCL); 10473 D_A(RETCOD) = 1; 10474 if (D_A(INICOM) != 0) 10475 goto L_FTLEN3; 10476 io_printf(D_A(PUNCH),ALOCFL); 10477 BRANCH(ENDALL) 10478 /*_*/ 10479L_FTLEN3: 10480 D_A(YCL) = D_A(ERRTYP); 10481 D_A(YCL) *= DESCR; 10482 D_F(YCL) = D_V(YCL) = 0; 10483 D(YCL) = D(D_A(MSGNO) + D_A(YCL)); 10484 _SPEC(TSP) = _SPEC(D_A(YCL)); 10485 IO_PRINT(IOKEY, ERRBLK, TSP); 10486 /* FALL */ 10487 BRANCH(FTLEN2) 10488} 10489static int 10490FTLEN2(retval) 10491 ret_t retval; 10492{ 10493 ENTRY(FTLEN2) 10494 ISTACK(); 10495 if (D_A(COMPCL) == 0) 10496 goto L_FTLEN4; 10497 D_RV(ETMCL) = mstime(); 10498 D_F(ETMCL) = D_V(ETMCL) = 0; 10499 D_RV(TIMECL) = D_RV(ETMCL) - D_RV(TIMECL); 10500 D_F(TIMECL) = D_F(ETMCL); 10501 D_V(TIMECL) = D_V(ETMCL); 10502 D_A(ETMCL) = 0; 10503 goto L_FTLEN1; 10504 /*_*/ 10505L_FTLEN4: 10506 D_RV(XCL) = mstime(); 10507 D_F(XCL) = D_V(XCL) = 0; 10508 D_RV(ETMCL) = D_RV(XCL) - D_RV(ETMCL); 10509 D_F(ETMCL) = D_F(XCL); 10510 D_V(ETMCL) = D_V(XCL); 10511L_FTLEN1: 10512 if (D_A(DMPCL) == 0) 10513 goto L_END1; 10514 if (D_A(NODPCL) != 0) 10515 goto L_DMPNO; 10516 ordvst(); 10517 io_printf(D_A(OUTPUT),STDMP); 10518 io_printf(D_A(OUTPUT),NVARF); 10519 SAVSTK(); 10520 switch (DUMP(NORET)) { 10521 case 1: 10522 case 2: 10523 BRANCH(INTR10) 10524 case 3: 10525 goto L_DMPK; 10526 } 10527 /*_*/ 10528L_DMPNO: 10529 io_printf(D_A(OUTPUT),INCGCF); 10530 io_printf(D_A(OUTPUT),NODMPF); 10531 goto L_END1; 10532 /*_*/ 10533L_DMPK: 10534 SAVSTK(); 10535 DMK(NORET); 10536L_END1: 10537 if (D_A(STATCL) == 0) 10538 BRANCH(ENDALL) 10539 io_printf(D_A(PUNCH),STATHD); 10540 io_printf(D_A(PUNCH),CMTIME,TIMECL); 10541 io_printf(D_A(PUNCH),INTIME,ETMCL); 10542 io_printf(D_A(PUNCH),EXNO,EXN2CL,FALCL); 10543 io_printf(D_A(PUNCH),ARTHNO,ARTHCL); 10544 io_printf(D_A(PUNCH),SCANNO,SCNCL); 10545 io_printf(D_A(PUNCH),STGENO,GCNO); 10546 io_printf(D_A(PUNCH),STGETM,GCTTTL); 10547 io_printf(D_A(PUNCH),READNO,RSTAT); 10548 io_printf(D_A(PUNCH),WRITNO,WSTAT); 10549 if (D_A(EXN2CL) != 0) 10550 goto L_END2; 10551 D_RV(FCL) = (real_t)D_A(ZEROCL); 10552 D_F(FCL) = 0; 10553 D_V(FCL) = R; 10554 goto L_AVTIME; 10555 /*_*/ 10556L_END2: 10557 D_RV(EXN2CL) = (real_t)D_A(EXN2CL); 10558 D_F(EXN2CL) = 0; 10559 D_V(EXN2CL) = R; 10560 D(FCL) = D(ETMCL); 10561 D_RV(FCL) /= D_RV(EXN2CL); 10562 { 10563 /* convert to microseconds [PLB71] */ 10564 /* First (and only) use of REAL constant, so just escape to C */ 10565 D_RV(FCL) *= 1000.0; 10566 } 10567L_AVTIME: 10568 io_printf(D_A(PUNCH),TIMEPS,FCL); 10569 /* FALL */ 10570 BRANCH(ENDALL) 10571} 10572static int 10573ENDALL(retval) 10574 ret_t retval; 10575{ 10576 ENTRY(ENDALL) 10577 endex(D_A(ABNDCL)); 10578 return 0; 10579 /*_*/ 10580} 10581int 10582SYSCUT(retval) 10583 ret_t retval; 10584{ 10585 ENTRY(SYSCUT) 10586 io_flushall(0); 10587 io_printf(D_A(PUNCH),SYSCMT,FILENM,LNNOCL,SIGNCL,STNOCL,LVLCL); 10588 if (D_A(CUTNO) != 0) 10589 BRANCH(ENDALL) 10590 D_A(CUTNO) = 1; 10591 D_A(RETCOD) = 1; 10592 BRANCH(FTLEN2) 10593 /*_*/ 10594} 10595static int 10596AERROR(retval) 10597 ret_t retval; 10598{ 10599 ENTRY(AERROR) 10600 D_A(ERRTYP) = 2; 10601 BRANCH(FTLTST) 10602 /*_*/ 10603} 10604static int 10605ALOC2(retval) 10606 ret_t retval; 10607{ 10608 ENTRY(ALOC2) 10609 D_A(ERRTYP) = 20; 10610 BRANCH(FTLEND) 10611 /*_*/ 10612} 10613int 10614ARGNER(retval) 10615 ret_t retval; 10616{ 10617 ENTRY(ARGNER) 10618 D_A(ERRTYP) = 25; 10619 BRANCH(FTLEND) 10620 /*_*/ 10621} 10622static int 10623COMP1(retval) 10624 ret_t retval; 10625{ 10626 ENTRY(COMP1) 10627 D_A(ERRTYP) = 32; 10628 BRANCH(FTLTST) 10629 /*_*/ 10630} 10631int 10632INTR10(retval) 10633 ret_t retval; 10634{ 10635 ENTRY(INTR10) 10636 /* FALL */ 10637 BRANCH(INTR13) 10638} 10639static int 10640INTR13(retval) 10641 ret_t retval; 10642{ 10643 ENTRY(INTR13) 10644 /* FALL */ 10645 BRANCH(COMP3) 10646} 10647static int 10648COMP3(retval) 10649 ret_t retval; 10650{ 10651 ENTRY(COMP3) 10652 D_A(ERRTYP) = 17; 10653 BRANCH(FTLEND) 10654 /*_*/ 10655} 10656static int 10657COMP5(retval) 10658 ret_t retval; 10659{ 10660 ENTRY(COMP5) 10661 D_A(ERRTYP) = 11; 10662 BRANCH(FTLTST) 10663 /*_*/ 10664} 10665static int 10666COMP6(retval) 10667 ret_t retval; 10668{ 10669 ENTRY(COMP6) 10670 D_A(ERRTYP) = 33; 10671 BRANCH(FTLTST) 10672 /*_*/ 10673} 10674static int 10675COMP7(retval) 10676 ret_t retval; 10677{ 10678 ENTRY(COMP7) 10679 D_A(ERRTYP) = 27; 10680 BRANCH(FTLEND) 10681 /*_*/ 10682} 10683static int 10684COMP9(retval) 10685 ret_t retval; 10686{ 10687 ENTRY(COMP9) 10688 D_A(ERRTYP) = 26; 10689 D_A(ESAICL) -= DESCR; 10690 BRANCH(FTLEND) 10691 /*_*/ 10692} 10693int 10694EROR(retval) 10695 ret_t retval; 10696{ 10697 ENTRY(EROR) 10698 D_A(ERRTYP) = 28; 10699 D_A(OCICL) += DESCR; 10700 D(STNOCL) = D(D_A(OCBSCL) + D_A(OCICL)); 10701 D_A(OCICL) += DESCR; 10702 D(LNNOCL) = D(D_A(OCBSCL) + D_A(OCICL)); 10703 D_A(OCICL) += DESCR; 10704 D(FILENM) = D(D_A(OCBSCL) + D_A(OCICL)); 10705 BRANCH(FTLEND) 10706 /*_*/ 10707} 10708static int 10709EXEX(retval) 10710 ret_t retval; 10711{ 10712 ENTRY(EXEX) 10713 D_A(ERRTYP) = 22; 10714 BRANCH(FTLEND) 10715 /*_*/ 10716} 10717static int 10718INTR1(retval) 10719 ret_t retval; 10720{ 10721 ENTRY(INTR1) 10722 D_A(ERRTYP) = 1; 10723 BRANCH(FTLTST) 10724 /*_*/ 10725} 10726static int 10727INTR4(retval) 10728 ret_t retval; 10729{ 10730 ENTRY(INTR4) 10731 D_A(ERRTYP) = 24; 10732 BRANCH(FTLEND) 10733 /*_*/ 10734} 10735static int 10736INTR5(retval) 10737 ret_t retval; 10738{ 10739 ENTRY(INTR5) 10740 D_A(ERRTYP) = 19; 10741 BRANCH(FTLEND) 10742 /*_*/ 10743} 10744static int 10745INTR8(retval) 10746 ret_t retval; 10747{ 10748 ENTRY(INTR8) 10749 D_A(ERRTYP) = 15; 10750 BRANCH(FTLTST) 10751 /*_*/ 10752} 10753static int 10754INTR27(retval) 10755 ret_t retval; 10756{ 10757 ENTRY(INTR27) 10758 D_A(ERRTYP) = 13; 10759 BRANCH(FTLTST) 10760 /*_*/ 10761} 10762static int 10763INTR30(retval) 10764 ret_t retval; 10765{ 10766 ENTRY(INTR30) 10767 D_A(ERRTYP) = 10; 10768 BRANCH(FTLTST) 10769 /*_*/ 10770} 10771static int 10772INTR31(retval) 10773 ret_t retval; 10774{ 10775 ENTRY(INTR31) 10776 D_A(ERRTYP) = 16; 10777 D_A(SCERCL) = 3; 10778 BRANCH(FTERST) 10779 /*_*/ 10780} 10781static int 10782LENERR(retval) 10783 ret_t retval; 10784{ 10785 ENTRY(LENERR) 10786 D_A(ERRTYP) = 14; 10787 BRANCH(FTLTST) 10788 /*_*/ 10789} 10790static int 10791MAIN1(retval) 10792 ret_t retval; 10793{ 10794 ENTRY(MAIN1) 10795 D_A(ERRTYP) = 18; 10796 BRANCH(FTLEND) 10797 /*_*/ 10798} 10799static int 10800NEMO(retval) 10801 ret_t retval; 10802{ 10803 ENTRY(NEMO) 10804 D_A(ERRTYP) = 8; 10805 BRANCH(FTLTST) 10806 /*_*/ 10807} 10808static int 10809NONAME(retval) 10810 ret_t retval; 10811{ 10812 ENTRY(NONAME) 10813 D_A(ERRTYP) = 4; 10814 BRANCH(FTLTST) 10815 /*_*/ 10816} 10817static int 10818NONARY(retval) 10819 ret_t retval; 10820{ 10821 ENTRY(NONARY) 10822 D_A(ERRTYP) = 3; 10823 BRANCH(FTLTST) 10824 /*_*/ 10825} 10826int 10827OVER(retval) 10828 ret_t retval; 10829{ 10830 ENTRY(OVER) 10831 D_A(ERRTYP) = 21; 10832 BRANCH(FTLEND) 10833 /*_*/ 10834} 10835static int 10836PROTER(retval) 10837 ret_t retval; 10838{ 10839 ENTRY(PROTER) 10840 D_A(ERRTYP) = 6; 10841 BRANCH(FTLTST) 10842 /*_*/ 10843} 10844static int 10845SIZERR(retval) 10846 ret_t retval; 10847{ 10848 ENTRY(SIZERR) 10849 D_A(ERRTYP) = 23; 10850 BRANCH(FTLEND) 10851 /*_*/ 10852} 10853int 10854UNDF(retval) 10855 ret_t retval; 10856{ 10857 ENTRY(UNDF) 10858 D_A(ERRTYP) = 5; 10859 BRANCH(FTLTST) 10860 /*_*/ 10861} 10862static int 10863UNDFFE(retval) 10864 ret_t retval; 10865{ 10866 ENTRY(UNDFFE) 10867 D_A(ERRTYP) = 9; 10868 BRANCH(FTLTST) 10869 /*_*/ 10870} 10871static int 10872UNKNKW(retval) 10873 ret_t retval; 10874{ 10875 ENTRY(UNKNKW) 10876 D_A(ERRTYP) = 7; 10877 BRANCH(FTLTST) 10878 /*_*/ 10879} 10880static int 10881UNTERR(retval) 10882 ret_t retval; 10883{ 10884 ENTRY(UNTERR) 10885 D_A(ERRTYP) = 12; 10886 BRANCH(FTLTST) 10887 /*_*/ 10888} 10889static int 10890XITERR(retval) 10891 ret_t retval; 10892{ 10893 ENTRY(XITERR) 10894 D_A(ERRTYP) = 34; 10895 BRANCH(FTLEND) 10896 /*_*/ 10897} 10898static int 10899CNTERR(retval) 10900 ret_t retval; 10901{ 10902 ENTRY(CNTERR) 10903 D_A(ERRTYP) = 35; 10904 BRANCH(FTLEND) 10905 /*_*/ 10906} 10907static int 10908SCERST(retval) 10909 ret_t retval; 10910{ 10911 ENTRY(SCERST) 10912 D_A(SCERCL) = 1; 10913 BRANCH(FTERST) 10914 /*_*/ 10915} 10916static int 10917FTLTST(retval) 10918 ret_t retval; 10919{ 10920 ENTRY(FTLTST) 10921 D_A(SCERCL) = 2; 10922 /* FALL */ 10923 BRANCH(FTERST) 10924} 10925static int 10926FTERST(retval) 10927 ret_t retval; 10928{ 10929 ENTRY(FTERST) 10930 if (D_A(ERRLCL) <= 0) 10931 BRANCH(FTLEND) 10932 D_A(ERRLCL) -= 1; 10933 D_A(YCL) = D_A(ERRTYP); 10934 D_A(YCL) *= DESCR; 10935 D_F(YCL) = D_V(YCL) = 0; 10936 D(YCL) = D(D_A(MSGNO) + D_A(YCL)); 10937 _SPEC(TSP) = _SPEC(D_A(YCL)); 10938 SAVSTK(); 10939 PUSH(TSPPTR); 10940 GENVAR(ERRTXT); 10941 if (D_A(TRAPCL) <= 0) 10942 goto L_FTERBR; 10943 if (!LOCAPT(ATPTR,TKEYL,ERRTKY)) 10944 goto L_FTERBR; 10945 PUSH(SCERCL); 10946 SAVSTK(); 10947 PUSH(ATPTR); 10948 TRPHND(NORET); 10949 POP(SCERCL); 10950L_FTERBR: 10951 SAVSTK(); 10952 XITHND(NORET); 10953 switch (D_A(SCERCL)) { 10954 case 1: 10955 case 2: 10956 BRANCH(FAIL) 10957 case 3: 10958 BRANCH(RTNUL3) 10959 } 10960 /* PANIC? */ 10961 ; 10962} 10963