![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / pi|
Return to stat.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / pi |
1.1 ! root 1: /* Copyright (c) 1979 Regents of the University of California */ ! 2: ! 3: static char sccsid[] = "@(#)stat.c 1.1 8/27/80"; ! 4: ! 5: #include "whoami.h" ! 6: #include "0.h" ! 7: #include "tree.h" ! 8: #include "objfmt.h" ! 9: #ifdef PC ! 10: # include "pcops.h" ! 11: # include "pc.h" ! 12: #endif PC ! 13: ! 14: int cntstat; ! 15: short cnts = 3; ! 16: #include "opcode.h" ! 17: ! 18: /* ! 19: * Statement list ! 20: */ ! 21: statlist(r) ! 22: int *r; ! 23: { ! 24: register *sl; ! 25: ! 26: for (sl=r; sl != NIL; sl=sl[2]) ! 27: statement(sl[1]); ! 28: } ! 29: ! 30: /* ! 31: * Statement ! 32: */ ! 33: statement(r) ! 34: int *r; ! 35: { ! 36: register *s; ! 37: register struct nl *snlp; ! 38: long soffset; ! 39: ! 40: s = r; ! 41: snlp = nlp; ! 42: soffset = sizes[ cbn ].om_off; ! 43: top: ! 44: if (cntstat) { ! 45: cntstat = 0; ! 46: putcnt(); ! 47: } ! 48: if (s == NIL) ! 49: return; ! 50: line = s[1]; ! 51: if (s[0] == T_LABEL) { ! 52: labeled(s[2]); ! 53: s = s[3]; ! 54: noreach = 0; ! 55: cntstat = 1; ! 56: goto top; ! 57: } ! 58: if (noreach) { ! 59: noreach = 0; ! 60: warning(); ! 61: error("Unreachable statement"); ! 62: } ! 63: switch (s[0]) { ! 64: case T_PCALL: ! 65: putline(); ! 66: # ifdef OBJ ! 67: proc(s); ! 68: # endif OBJ ! 69: # ifdef PC ! 70: pcproc( s ); ! 71: # endif PC ! 72: break; ! 73: case T_ASGN: ! 74: putline(); ! 75: asgnop(s); ! 76: break; ! 77: case T_GOTO: ! 78: putline(); ! 79: gotoop(s[2]); ! 80: noreach = 1; ! 81: cntstat = 1; ! 82: break; ! 83: default: ! 84: level++; ! 85: switch (s[0]) { ! 86: default: ! 87: panic("stat"); ! 88: case T_IF: ! 89: case T_IFEL: ! 90: ifop(s); ! 91: break; ! 92: case T_WHILE: ! 93: whilop(s); ! 94: noreach = 0; ! 95: break; ! 96: case T_REPEAT: ! 97: repop(s); ! 98: break; ! 99: case T_FORU: ! 100: case T_FORD: ! 101: # ifdef OBJ ! 102: forop(s); ! 103: # endif OBJ ! 104: # ifdef PC ! 105: pcforop( s ); ! 106: # endif PC ! 107: noreach = 0; ! 108: break; ! 109: case T_BLOCK: ! 110: statlist(s[2]); ! 111: break; ! 112: case T_CASE: ! 113: putline(); ! 114: # ifdef OBJ ! 115: caseop(s); ! 116: # endif OBJ ! 117: # ifdef PC ! 118: pccaseop( s ); ! 119: # endif PC ! 120: break; ! 121: case T_WITH: ! 122: withop(s); ! 123: break; ! 124: case T_ASRT: ! 125: putline(); ! 126: asrtop(s); ! 127: break; ! 128: } ! 129: --level; ! 130: if (gotos[cbn]) ! 131: ungoto(); ! 132: break; ! 133: } ! 134: /* ! 135: * Free the temporary name list entries defined in ! 136: * expressions, e.g. STRs, and WITHPTRs from withs. ! 137: */ ! 138: nlfree(snlp); ! 139: /* ! 140: * free any temporaries allocated for this statement ! 141: * these come from strings and sets. ! 142: */ ! 143: if ( soffset != sizes[ cbn ].om_off ) { ! 144: sizes[ cbn ].om_off = soffset; ! 145: # ifdef PC ! 146: putlbracket( ftnno , -sizes[cbn].om_off ); ! 147: # endif PC ! 148: } ! 149: } ! 150: ! 151: ungoto() ! 152: { ! 153: register struct nl *p; ! 154: ! 155: for (p = gotos[cbn]; p != NIL; p = p->chain) ! 156: if ((p->nl_flags & NFORWD) != 0) { ! 157: if (p->value[NL_GOLEV] != NOTYET) ! 158: if (p->value[NL_GOLEV] > level) ! 159: p->value[NL_GOLEV] = level; ! 160: } else ! 161: if (p->value[NL_GOLEV] != DEAD) ! 162: if (p->value[NL_GOLEV] > level) ! 163: p->value[NL_GOLEV] = DEAD; ! 164: } ! 165: ! 166: putcnt() ! 167: { ! 168: ! 169: if (monflg == 0) { ! 170: return; ! 171: } ! 172: inccnt( getcnt() ); ! 173: } ! 174: ! 175: int ! 176: getcnt() ! 177: { ! 178: ! 179: return ++cnts; ! 180: } ! 181: ! 182: inccnt( counter ) ! 183: int counter; ! 184: { ! 185: ! 186: # ifdef OBJ ! 187: put2(O_COUNT, counter ); ! 188: # endif OBJ ! 189: # ifdef PC ! 190: putRV( PCPCOUNT , 0 , counter * sizeof (long) , P2INT ); ! 191: putleaf( P2ICON , 1 , 0 , P2INT , 0 ); ! 192: putop( P2ASG P2PLUS , P2INT ); ! 193: putdot( filename , line ); ! 194: # endif PC ! 195: } ! 196: ! 197: putline() ! 198: { ! 199: ! 200: # ifdef OBJ ! 201: if (opt('p') != 0) ! 202: put2(O_LINO, line); ! 203: # endif OBJ ! 204: # ifdef PC ! 205: static lastline; ! 206: ! 207: if ( line != lastline ) { ! 208: stabline( line ); ! 209: lastline = line; ! 210: } ! 211: if ( opt( 'p' ) ) { ! 212: if ( opt('t') ) { ! 213: putleaf( P2ICON , 0 , 0 , ADDTYPE( P2FTN | P2INT , P2PTR ) ! 214: , "_LINO" ); ! 215: putop( P2UNARY P2CALL , P2INT ); ! 216: putdot( filename , line ); ! 217: } else { ! 218: putRV( STMTCOUNT , 0 , 0 , P2INT ); ! 219: putleaf( P2ICON , 1 , 0 , P2INT , 0 ); ! 220: putop( P2ASG P2PLUS , P2INT ); ! 221: putdot( filename , line ); ! 222: } ! 223: } ! 224: # endif PC ! 225: } ! 226: ! 227: /* ! 228: * With varlist do stat ! 229: * ! 230: * With statement requires an extra word ! 231: * in automatic storage for each level of withing. ! 232: * These indirect pointers are initialized here, and ! 233: * the scoping effect of the with statement occurs ! 234: * because lookup examines the field names of the records ! 235: * associated with the WITHPTRs on the withlist. ! 236: */ ! 237: withop(s) ! 238: int *s; ! 239: { ! 240: register *p; ! 241: register struct nl *r; ! 242: int i; ! 243: int *swl; ! 244: long soffset; ! 245: ! 246: putline(); ! 247: swl = withlist; ! 248: soffset = sizes[cbn].om_off; ! 249: for (p = s[2]; p != NIL; p = p[2]) { ! 250: i = sizes[cbn].om_off -= sizeof ( int * ); ! 251: if (sizes[cbn].om_off < sizes[cbn].om_max) ! 252: sizes[cbn].om_max = sizes[cbn].om_off; ! 253: # ifdef OBJ ! 254: put2(O_LV | cbn <<8+INDX, i ); ! 255: # endif OBJ ! 256: # ifdef PC ! 257: putlbracket( ftnno , -sizes[cbn].om_off ); ! 258: putRV( 0 , cbn , i , P2PTR|P2STRTY ); ! 259: # endif PC ! 260: r = lvalue(p[1], MOD , LREQ ); ! 261: if (r == NIL) ! 262: continue; ! 263: if (r->class != RECORD) { ! 264: error("Variable in with statement refers to %s, not to a record", nameof(r)); ! 265: continue; ! 266: } ! 267: r = defnl(0, WITHPTR, r, i); ! 268: r->nl_next = withlist; ! 269: withlist = r; ! 270: # ifdef OBJ ! 271: put(1, PTR_AS); ! 272: # endif OBJ ! 273: # ifdef PC ! 274: putop( P2ASSIGN , P2PTR|P2STRTY ); ! 275: putdot( filename , line ); ! 276: # endif PC ! 277: } ! 278: statement(s[3]); ! 279: sizes[cbn].om_off = soffset; ! 280: # ifdef PC ! 281: putlbracket( ftnno , -sizes[cbn].om_off ); ! 282: # endif PC ! 283: withlist = swl; ! 284: } ! 285: ! 286: extern flagwas; ! 287: /* ! 288: * var := expr ! 289: */ ! 290: asgnop(r) ! 291: int *r; ! 292: { ! 293: register struct nl *p; ! 294: register *av; ! 295: ! 296: if (r == NIL) ! 297: return (NIL); ! 298: /* ! 299: * Asgnop's only function is ! 300: * to handle function variable ! 301: * assignments. All other assignment ! 302: * stuff is handled by asgnop1. ! 303: * the if below checks for unqualified lefthandside: ! 304: * necessary for fvars. ! 305: */ ! 306: av = r[2]; ! 307: if (av != NIL && av[0] == T_VAR && av[3] == NIL) { ! 308: p = lookup1(av[2]); ! 309: if (p != NIL) ! 310: p->nl_flags = flagwas; ! 311: if (p != NIL && p->class == FVAR) { ! 312: /* ! 313: * Give asgnop1 the func ! 314: * which is the chain of ! 315: * the FVAR. ! 316: */ ! 317: p->nl_flags |= NUSED|NMOD; ! 318: p = p->chain; ! 319: if (p == NIL) { ! 320: rvalue(r[3], NIL , RREQ ); ! 321: return; ! 322: } ! 323: # ifdef OBJ ! 324: put2(O_LV | bn << 8+INDX, p->value[NL_OFFS]); ! 325: if (isa(p->type, "i") && width(p->type) == 1) ! 326: asgnop1(r, nl+T2INT); ! 327: else ! 328: asgnop1(r, p->type); ! 329: # endif OBJ ! 330: # ifdef PC ! 331: /* ! 332: * this should be the lvalue of the fvar, ! 333: * but since the second pass knows to use ! 334: * the address of the left operand of an ! 335: * assignment, what i want here is an rvalue. ! 336: * see note in funchdr about fvar allocation. ! 337: */ ! 338: p = p -> ptr[ NL_FVAR ]; ! 339: putRV( p -> symbol , bn , p -> value[ NL_OFFS ] ! 340: , p2type( p -> type ) ); ! 341: asgnop1( r , p -> type ); ! 342: # endif PC ! 343: return; ! 344: } ! 345: } ! 346: asgnop1(r, NIL); ! 347: } ! 348: ! 349: /* ! 350: * Asgnop1 handles all assignments. ! 351: * If p is not nil then we are assigning ! 352: * to a function variable, otherwise ! 353: * we look the variable up ourselves. ! 354: */ ! 355: struct nl * ! 356: asgnop1(r, p) ! 357: int *r; ! 358: register struct nl *p; ! 359: { ! 360: register struct nl *p1; ! 361: ! 362: if (r == NIL) ! 363: return (NIL); ! 364: if (p == NIL) { ! 365: # ifdef OBJ ! 366: p = lvalue(r[2], MOD|ASGN|NOUSE , LREQ ); ! 367: # endif OBJ ! 368: # ifdef PC ! 369: /* ! 370: * since the second pass knows that it should reference ! 371: * the lefthandside of asignments, what i need here is ! 372: * an rvalue. ! 373: */ ! 374: p = lvalue( r[2] , MOD|ASGN|NOUSE , RREQ ); ! 375: # endif PC ! 376: if ( p == NIL ) { ! 377: rvalue( r[3] , NIL , RREQ ); ! 378: return NIL; ! 379: } ! 380: } ! 381: # ifdef OBJ ! 382: p1 = rvalue(r[3], p , RREQ ); ! 383: # endif OBJ ! 384: # ifdef PC ! 385: /* ! 386: * if this is a scalar assignment, ! 387: * then i want to rvalue the righthandside. ! 388: * if this is a structure assignment, ! 389: * then i want an lvalue to the righthandside. ! 390: * that's what the intermediate form sez. ! 391: */ ! 392: switch ( classify( p ) ) { ! 393: case TINT: ! 394: case TCHAR: ! 395: case TBOOL: ! 396: case TSCAL: ! 397: precheck( p , "_RANG4" , "_RSNG4" ); ! 398: case TDOUBLE: ! 399: case TPTR: ! 400: p1 = rvalue( r[3] , p , RREQ ); ! 401: break; ! 402: default: ! 403: p1 = rvalue( r[3] , p , LREQ ); ! 404: break; ! 405: } ! 406: # endif PC ! 407: if (p1 == NIL) ! 408: return (NIL); ! 409: if (incompat(p1, p, r[3])) { ! 410: cerror("Type of expression clashed with type of variable in assignment"); ! 411: return (NIL); ! 412: } ! 413: switch (classify(p)) { ! 414: case TINT: ! 415: case TBOOL: ! 416: case TCHAR: ! 417: case TSCAL: ! 418: # ifdef OBJ ! 419: rangechk(p, p1); ! 420: # endif OBJ ! 421: # ifdef PC ! 422: postcheck( p ); ! 423: # endif PC ! 424: case TDOUBLE: ! 425: case TPTR: ! 426: # ifdef OBJ ! 427: gen(O_AS2, O_AS2, width(p), width(p1)); ! 428: # endif OBJ ! 429: # ifdef PC ! 430: putop( P2ASSIGN , p2type( p ) ); ! 431: putdot( filename , line ); ! 432: # endif PC ! 433: break; ! 434: default: ! 435: # ifdef OBJ ! 436: put2(O_AS, width(p)); ! 437: # endif OBJ ! 438: # ifdef PC ! 439: putstrop( P2STASG , p2type( p ) ! 440: , lwidth( p ) , align( p ) ); ! 441: putdot( filename , line ); ! 442: # endif PC ! 443: } ! 444: return (p); /* Used by for statement */ ! 445: } ! 446: ! 447: #ifdef OBJ ! 448: /* ! 449: * for var := expr [down]to expr do stat ! 450: */ ! 451: forop(r) ! 452: int *r; ! 453: { ! 454: register struct nl *t1, *t2; ! 455: int l1, l2, l3; ! 456: long soffset; ! 457: register op; ! 458: struct nl *p; ! 459: int *rr, goc, i; ! 460: ! 461: p = NIL; ! 462: goc = gocnt; ! 463: if (r == NIL) ! 464: goto aloha; ! 465: putline(); ! 466: /* ! 467: * Start with assignment ! 468: * of initial value to for variable ! 469: */ ! 470: t1 = asgnop1(r[2], NIL); ! 471: if (t1 == NIL) { ! 472: rvalue(r[3], NIL , RREQ ); ! 473: statement(r[4]); ! 474: goto aloha; ! 475: } ! 476: rr = r[2]; /* Assignment */ ! 477: rr = rr[2]; /* Lhs variable */ ! 478: if (rr[3] != NIL) { ! 479: error("For variable must be unqualified"); ! 480: rvalue(r[3], NIL , RREQ ); ! 481: statement(r[4]); ! 482: goto aloha; ! 483: } ! 484: p = lookup(rr[2]); ! 485: p->value[NL_FORV] = 1; ! 486: if (isnta(t1, "bcis")) { ! 487: error("For variables cannot be %ss", nameof(t1)); ! 488: statement(r[4]); ! 489: goto aloha; ! 490: } ! 491: /* ! 492: * Allocate automatic ! 493: * space for limit variable ! 494: */ ! 495: sizes[cbn].om_off -= 4; ! 496: if (sizes[cbn].om_off < sizes[cbn].om_max) ! 497: sizes[cbn].om_max = sizes[cbn].om_off; ! 498: i = sizes[cbn].om_off; ! 499: /* ! 500: * Initialize the limit variable ! 501: */ ! 502: put2(O_LV | cbn<<8+INDX, i); ! 503: t2 = rvalue(r[3], NIL , RREQ ); ! 504: if (incompat(t2, t1, r[3])) { ! 505: cerror("Limit type clashed with index type in 'for' statement"); ! 506: statement(r[4]); ! 507: goto aloha; ! 508: } ! 509: put1(width(t2) <= 2 ? O_AS24 : O_AS4); ! 510: /* ! 511: * See if we can skip the loop altogether ! 512: */ ! 513: rr = r[2]; ! 514: if (rr != NIL) ! 515: rvalue(rr[2], NIL , RREQ ); ! 516: put2(O_RV4 | cbn<<8+INDX, i); ! 517: gen(NIL, r[0] == T_FORU ? T_LE : T_GE, width(t1), 4); ! 518: /* ! 519: * L1 will be patched to skip the body of the loop. ! 520: * L2 marks the top of the loop when we go around. ! 521: */ ! 522: put2(O_IF, (l1 = getlab())); ! 523: putlab(l2 = getlab()); ! 524: putcnt(); ! 525: statement(r[4]); ! 526: /* ! 527: * now we see if we get to go again ! 528: */ ! 529: if (opt('t') == 0) { ! 530: /* ! 531: * Easy if we dont have to test ! 532: */ ! 533: put2(O_RV4 | cbn<<8+INDX, i); ! 534: if (rr != NIL) ! 535: lvalue(rr[2], MOD , RREQ ); ! 536: put2((r[0] == T_FORU ? O_FOR1U : O_FOR1D) + (width(t1) >> 1), l2); ! 537: } else { ! 538: line = r[1]; ! 539: putline(); ! 540: if (rr != NIL) ! 541: rvalue(rr[2], NIL , RREQ ); ! 542: put2(O_RV4 | cbn << 8+INDX, i); ! 543: gen(NIL, (r[0] == T_FORU ? T_LT : T_GT), width(t1), 4); ! 544: l3 = put2(O_IF, getlab()); ! 545: lvalue((int *) rr[2], MOD , RREQ ); ! 546: rvalue(rr[2], NIL , RREQ ); ! 547: put2(O_CON2, 1); ! 548: t2 = gen(NIL, r[0] == T_FORU ? T_ADD: T_SUB, width(t1), 2); ! 549: rangechk(t1, t2); /* The point of all this */ ! 550: gen(O_AS2, O_AS2, width(t1), width(t2)); ! 551: put2(O_TRA, l2); ! 552: patch(l3); ! 553: } ! 554: sizes[cbn].om_off += 4; ! 555: patch(l1); ! 556: aloha: ! 557: noreach = 0; ! 558: if (p != NIL) ! 559: p->value[NL_FORV] = 0; ! 560: if (goc != gocnt) ! 561: putcnt(); ! 562: } ! 563: #endif OBJ ! 564: ! 565: /* ! 566: * if expr then stat [ else stat ] ! 567: */ ! 568: ifop(r) ! 569: int *r; ! 570: { ! 571: register struct nl *p; ! 572: register l1, l2; /* l1 is start of else, l2 is end of else */ ! 573: int nr, goc; ! 574: ! 575: goc = gocnt; ! 576: if (r == NIL) ! 577: return; ! 578: putline(); ! 579: p = rvalue(r[2], NIL , RREQ ); ! 580: if (p == NIL) { ! 581: statement(r[3]); ! 582: noreach = 0; ! 583: statement(r[4]); ! 584: noreach = 0; ! 585: return; ! 586: } ! 587: if (isnta(p, "b")) { ! 588: error("Type of expression in if statement must be Boolean, not %s", nameof(p)); ! 589: statement(r[3]); ! 590: noreach = 0; ! 591: statement(r[4]); ! 592: noreach = 0; ! 593: return; ! 594: } ! 595: # ifdef OBJ ! 596: l1 = put2(O_IF, getlab()); ! 597: # endif OBJ ! 598: # ifdef PC ! 599: l1 = getlab(); ! 600: putleaf( P2ICON , l1 , 0 , P2INT , 0 ); ! 601: putop( P2CBRANCH , P2INT ); ! 602: putdot( filename , line ); ! 603: # endif PC ! 604: putcnt(); ! 605: statement(r[3]); ! 606: nr = noreach; ! 607: if (r[4] != NIL) { ! 608: /* ! 609: * else stat ! 610: */ ! 611: --level; ! 612: ungoto(); ! 613: ++level; ! 614: # ifdef OBJ ! 615: l2 = put2(O_TRA, getlab()); ! 616: # endif OBJ ! 617: # ifdef PC ! 618: l2 = getlab(); ! 619: putjbr( l2 ); ! 620: # endif PC ! 621: patch(l1); ! 622: noreach = 0; ! 623: statement(r[4]); ! 624: noreach &= nr; ! 625: l1 = l2; ! 626: } else ! 627: noreach = 0; ! 628: patch(l1); ! 629: if (goc != gocnt) ! 630: putcnt(); ! 631: } ! 632: ! 633: /* ! 634: * while expr do stat ! 635: */ ! 636: whilop(r) ! 637: int *r; ! 638: { ! 639: register struct nl *p; ! 640: register l1, l2; ! 641: int goc; ! 642: ! 643: goc = gocnt; ! 644: if (r == NIL) ! 645: return; ! 646: putlab(l1 = getlab()); ! 647: putline(); ! 648: p = rvalue(r[2], NIL , RREQ ); ! 649: if (p == NIL) { ! 650: statement(r[3]); ! 651: noreach = 0; ! 652: return; ! 653: } ! 654: if (isnta(p, "b")) { ! 655: error("Type of expression in while statement must be Boolean, not %s", nameof(p)); ! 656: statement(r[3]); ! 657: noreach = 0; ! 658: return; ! 659: } ! 660: l2 = getlab(); ! 661: # ifdef OBJ ! 662: put2(O_IF, l2); ! 663: # endif OBJ ! 664: # ifdef PC ! 665: putleaf( P2ICON , l2 , 0 , P2INT , 0 ); ! 666: putop( P2CBRANCH , P2INT ); ! 667: putdot( filename , line ); ! 668: # endif PC ! 669: putcnt(); ! 670: statement(r[3]); ! 671: # ifdef OBJ ! 672: put2(O_TRA, l1); ! 673: # endif OBJ ! 674: # ifdef PC ! 675: putjbr( l1 ); ! 676: # endif PC ! 677: patch(l2); ! 678: if (goc != gocnt) ! 679: putcnt(); ! 680: } ! 681: ! 682: /* ! 683: * repeat stat* until expr ! 684: */ ! 685: repop(r) ! 686: int *r; ! 687: { ! 688: register struct nl *p; ! 689: register l; ! 690: int goc; ! 691: ! 692: goc = gocnt; ! 693: if (r == NIL) ! 694: return; ! 695: l = putlab(getlab()); ! 696: putcnt(); ! 697: statlist(r[2]); ! 698: line = r[1]; ! 699: p = rvalue(r[3], NIL , RREQ ); ! 700: if (p == NIL) ! 701: return; ! 702: if (isnta(p,"b")) { ! 703: error("Until expression type must be Boolean, not %s, in repeat statement", nameof(p)); ! 704: return; ! 705: } ! 706: # ifdef OBJ ! 707: put2(O_IF, l); ! 708: # endif OBJ ! 709: # ifdef PC ! 710: putleaf( P2ICON , l , 0 , P2INT , 0 ); ! 711: putop( P2CBRANCH , P2INT ); ! 712: putdot( filename , line ); ! 713: # endif PC ! 714: if (goc != gocnt) ! 715: putcnt(); ! 716: } ! 717: ! 718: /* ! 719: * assert expr ! 720: */ ! 721: asrtop(r) ! 722: register int *r; ! 723: { ! 724: register struct nl *q; ! 725: ! 726: if (opt('s')) { ! 727: standard(); ! 728: error("Assert statement is non-standard"); ! 729: } ! 730: if (!opt('t')) ! 731: return; ! 732: r = r[2]; ! 733: # ifdef OBJ ! 734: q = rvalue((int *) r, NLNIL , RREQ ); ! 735: # endif OBJ ! 736: # ifdef PC ! 737: putleaf( P2ICON , 0 , 0 ! 738: , ADDTYPE( P2FTN | P2INT , P2PTR ) , "_ASRT" ); ! 739: q = stkrval( r , NLNIL , RREQ ); ! 740: # endif PC ! 741: if (q == NIL) ! 742: return; ! 743: if (isnta(q, "b")) ! 744: error("Assert expression must be Boolean, not %ss", nameof(q)); ! 745: # ifdef OBJ ! 746: put1(O_ASRT); ! 747: # endif OBJ ! 748: # ifdef PC ! 749: putop( P2CALL , P2INT ); ! 750: putdot( filename , line ); ! 751: # endif PC ! 752: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.