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

##### Functions

    asgnop            X
    asgnop1           X
    getcnt            X
    ifop              X
    inccnt            X
    pcasgconf         X
    putcnt            X
    putline           X
    repop             X
    statement         X
    statlist          X
    ungoto            X
    whilop            X
    withop            X

##### Variables

    cnts              X
    cntstat           X

       1: /*
       2:  * Copyright (c) 1980 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  */
       6:
       7: #ifndef lint
       8: static char sccsid[] = "@(#)stat.c	5.1 (Berkeley) 6/5/85";
       9: #endif not lint
      10:
      11: #include "whoami.h"
      12: #include "0.h"
      13: #include "tree.h"
      14: #include "objfmt.h"
      15: #ifdef PC
      16: #   include <pcc.h>
      17: #   include "pc.h"
      18: #endif PC
      19: #include "tmps.h"
      20:
      21: int cntstat;
      22: short cnts = 3;
      23: #include "opcode.h"
      24: #include "tree_ty.h"
      25:
      26: /*
      27:  * Statement list
      28:  */
      29: statlist(r)
      30:     struct tnode *r;
      31: {
      32:     register struct tnode *sl;
      33:
      34:     for (sl=r; sl != TR_NIL; sl=sl->list_node.next)
      35:         statement(sl->list_node.list);
      36: }
      37:
      38: /*
      39:  * Statement
      40:  */
      41: statement(r)
      42:     struct tnode *r;
      43: {
      44:     register struct tnode *tree_node;
      45:     register struct nl *snlp;
      46:     struct tmps soffset;
      47:
      48:     tree_node = r;
      49:     snlp = nlp;
      50:     soffset = sizes[cbn].curtmps;
      51: top:
      52:     if (cntstat) {
      53:         cntstat = 0;
      54:         putcnt();
      55:     }
      56:     if (tree_node == TR_NIL)
      57:         return;
      58:     line = tree_node->lined.line_no;
      59:     if (tree_node->tag == T_LABEL) {
      60:         labeled(tree_node->label_node.lbl_ptr);
      61:         tree_node = tree_node->label_node.stmnt;
      62:         noreach = FALSE;
      63:         cntstat = 1;
      64:         goto top;
      65:     }
      66:     if (noreach) {
      67:         noreach = FALSE;
      68:         warning();
      69:         error("Unreachable statement");
      70:     }
      71:     switch (tree_node->tag) {
      72:         case T_PCALL:
      73:             putline();
      74: #			ifdef OBJ
      75:                 proc(tree_node);
      76: #			endif OBJ
      77: #			ifdef PC
      78:                 pcproc( tree_node );
      79: #			endif PC
      80:             break;
      81:         case T_ASGN:
      82:             putline();
      83:             asgnop(&(tree_node->asg_node));
      84:             break;
      85:         case T_GOTO:
      86:             putline();
      87:             gotoop(tree_node->goto_node.lbl_ptr);
      88:             noreach = TRUE;
      89:             cntstat = 1;
      90:             break;
      91:         default:
      92:             level++;
      93:             switch (tree_node->tag) {
      94:                 default:
      95:                     panic("stat");
      96:                 case T_IF:
      97:                 case T_IFEL:
      98:                     ifop(&(tree_node->if_node));
      99:                     break;
     100:                 case T_WHILE:
     101:                     whilop(&(tree_node->whi_cas));
     102:                     noreach = FALSE;
     103:                     break;
     104:                 case T_REPEAT:
     105:                     repop(&(tree_node->repeat));
     106:                     break;
     107:                 case T_FORU:
     108:                 case T_FORD:
     109:                         forop(tree_node);
     110:                     noreach = FALSE;
     111:                     break;
     112:                 case T_BLOCK:
     113:                     statlist(tree_node->stmnt_blck.stmnt_list);
     114:                     break;
     115:                 case T_CASE:
     116:                     putline();
     117: #					ifdef OBJ
     118:                         caseop(&(tree_node->whi_cas));
     119: #					endif OBJ
     120: #					ifdef PC
     121:                         pccaseop(&(tree_node->whi_cas));
     122: #					endif PC
     123:                     break;
     124:                 case T_WITH:
     125:                     withop(&(tree_node->with_node));
     126:                     break;
     127:             }
     128:             --level;
     129:             if (gotos[cbn])
     130:                 ungoto();
     131:             break;
     132:     }
     133:     /*
     134: 	 * Free the temporary name list entries defined in
     135: 	 * expressions, e.g. STRs, and WITHPTRs from withs.
     136: 	 */
     137:     nlfree(snlp);
     138:         /*
     139: 	     *	free any temporaries allocated for this statement
     140: 	     *	these come from strings and sets.
     141: 	     */
     142:     tmpfree(&soffset);
     143: }
     144:
     145: ungoto()
     146: {
     147:     register struct nl *p;
     148:
     149:     for (p = gotos[cbn]; p != NLNIL; p = p->chain)
     150:         if ((p->nl_flags & NFORWD) != 0) {
     151:             if (p->value[NL_GOLEV] != NOTYET)
     152:                 if (p->value[NL_GOLEV] > level)
     153:                     p->value[NL_GOLEV] = level;
     154:         } else
     155:             if (p->value[NL_GOLEV] != DEAD)
     156:                 if (p->value[NL_GOLEV] > level)
     157:                     p->value[NL_GOLEV] = DEAD;
     158: }
     159:
     160: putcnt()
     161: {
     162:
     163:     if (monflg == FALSE) {
     164:         return;
     165:     }
     166:     inccnt( getcnt() );
     167: }
     168:
     169: int
     170: getcnt()
     171:     {
     172:
     173:     return ++cnts;
     174:     }
     175:
     176: inccnt( counter )
     177:     int counter;
     178:     {
     179:
     180: #	ifdef OBJ
     181:         (void) put(2, O_COUNT, counter );
     182: #	endif OBJ
     183: #	ifdef PC
     184:         putRV( PCPCOUNT , 0 , counter * sizeof (long) , NGLOBAL , PCCT_INT );
     185:         putleaf( PCC_ICON , 1 , 0 , PCCT_INT , (char *) 0 );
     186:         putop( PCCOM_ASG PCC_PLUS , PCCT_INT );
     187:         putdot( filename , line );
     188: #	endif PC
     189:     }
     190:
     191: putline()
     192: {
     193:
     194: #	ifdef OBJ
     195:         if (opt('p') != 0)
     196:             (void) put(2, O_LINO, line);
     197:
     198:         /*
     199: 	     * put out line number information for pdx
     200: 	     */
     201:         lineno(line);
     202:
     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( PCC_ICON , 0 , 0 , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR )
     214:                 , "_LINO" );
     215:             putop( PCCOM_UNARY PCC_CALL , PCCT_INT );
     216:             putdot( filename , line );
     217:         } else {
     218:             putRV( STMTCOUNT , 0 , 0 , NGLOBAL , PCCT_INT );
     219:             putleaf( PCC_ICON , 1 , 0 , PCCT_INT , (char *) 0 );
     220:             putop( PCCOM_ASG PCC_PLUS , PCCT_INT );
     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:     WITH_NODE *s;
     239: {
     240:     register struct tnode *p;
     241:     register struct nl *r;
     242:     struct nl   *tempnlp;
     243:     struct nl *swl;
     244:
     245:     putline();
     246:     swl = withlist;
     247:     for (p = s->var_list; p != TR_NIL; p = p->list_node.next) {
     248:         tempnlp = tmpalloc((long) (sizeof(int *)), nl+TPTR, REGOK);
     249:             /*
     250: 		     *	no one uses the allocated temporary namelist entry,
     251: 		     *	since we have to use it before we know its type;
     252: 		     *	but we use its runtime location for the with pointer.
     253: 		     */
     254: #		ifdef OBJ
     255:             (void) put(2, O_LV | cbn <<8+INDX, tempnlp -> value[ NL_OFFS ] );
     256: #		endif OBJ
     257: #		ifdef PC
     258:             putRV( (char *) 0 , cbn , tempnlp -> value[ NL_OFFS ] ,
     259:                 tempnlp -> extra_flags , PCCTM_PTR|PCCT_STRTY );
     260: #		endif PC
     261:         r = lvalue(p->list_node.list, MOD , LREQ );
     262:         if (r == NLNIL)
     263:             continue;
     264:         if (r->class != RECORD) {
     265:             error("Variable in with statement refers to %s, not to a record", nameof(r));
     266:             continue;
     267:         }
     268:         r = defnl((char *) 0, WITHPTR, r, tempnlp -> value[ NL_OFFS ] );
     269: #		ifdef PC
     270:             r -> extra_flags |= tempnlp -> extra_flags;
     271: #		endif PC
     272:         r->nl_next = withlist;
     273:         withlist = r;
     274: #		ifdef OBJ
     275:             (void) put(1, PTR_AS);
     276: #		endif OBJ
     277: #		ifdef PC
     278:             putop( PCC_ASSIGN , PCCTM_PTR|PCCT_STRTY );
     279:             putdot( filename , line );
     280: #		endif PC
     281:     }
     282:     statement(s->stmnt);
     283:     withlist = swl;
     284: }
     285:
     286: extern  flagwas;
     287: /*
     288:  * var := expr
     289:  */
     290: asgnop(r)
     291:     ASG_NODE *r;
     292: {
     293:     register struct nl *p;
     294:     register struct tnode *av;
     295:
     296:     /*
     297: 	 * Asgnop's only function is
     298: 	 * to handle function variable
     299: 	 * assignments.  All other assignment
     300: 	 * stuff is handled by asgnop1.
     301: 	 * the if below checks for unqualified lefthandside:
     302: 	 * necessary for fvars.
     303: 	 */
     304:     av = r->lhs_var;
     305:     if (av != TR_NIL && av->tag == T_VAR && av->var_node.qual == TR_NIL) {
     306:         p = lookup1(av->var_node.cptr);
     307:         if (p != NLNIL)
     308:             p->nl_flags = flagwas;
     309:         if (p != NLNIL && p->class == FVAR) {
     310:             /*
     311: 			 * Give asgnop1 the func
     312: 			 * which is the chain of
     313: 			 * the FVAR.
     314: 			 */
     315:             p->nl_flags |= NUSED|NMOD;
     316:             p = p->chain;
     317:             if (p == NLNIL) {
     318:                 p = rvalue(r->rhs_expr, NLNIL , RREQ );
     319:                 return;
     320:             }
     321: #			ifdef OBJ
     322:                 (void) put(2, O_LV | bn << 8+INDX, (int)p->value[NL_OFFS]);
     323:                 if (isa(p->type, "i") && width(p->type) == 1)
     324:                     (void) asgnop1(r, nl+T2INT);
     325:                 else
     326:                     (void) asgnop1(r, p->type);
     327: #			endif OBJ
     328: #			ifdef PC
     329:                 /*
     330: 				 * this should be the lvalue of the fvar,
     331: 				 * but since the second pass knows to use
     332: 				 * the address of the left operand of an
     333: 				 * assignment, what i want here is an rvalue.
     334: 				 * see note in funchdr about fvar allocation.
     335: 				 */
     336:                 p = p -> ptr[ NL_FVAR ];
     337:                 putRV( p -> symbol , bn , p -> value[ NL_OFFS ] ,
     338:                     p -> extra_flags , p2type( p -> type ) );
     339:                 (void) asgnop1( r , p -> type );
     340: #			endif PC
     341:             return;
     342:         }
     343:     }
     344:     (void) asgnop1(r, NLNIL);
     345: }
     346:
     347: /*
     348:  * Asgnop1 handles all assignments.
     349:  * If p is not nil then we are assigning
     350:  * to a function variable, otherwise
     351:  * we look the variable up ourselves.
     352:  */
     353: struct nl *
     354: asgnop1(r, p)
     355:     ASG_NODE *r;
     356:     register struct nl *p;
     357: {
     358:     register struct nl *p1;
     359:     int clas;
     360: #ifdef OBJ
     361:     int w;
     362: #endif OBJ
     363:
     364: #ifdef OBJ
     365:     if (p == NLNIL) {
     366:         p = lvalue(r->lhs_var, MOD|ASGN|NOUSE , LREQ );
     367:         if ( p == NLNIL ) {
     368:         (void) rvalue( r->rhs_expr , NLNIL , RREQ );
     369:         return NLNIL;
     370:         }
     371:         w = width(p);
     372:     } else {
     373:         /*
     374: 	     * assigning to the return value, which is at least
     375: 	     * of width two since it resides on the stack
     376: 	     */
     377:         w = width(p);
     378:         if (w < 2)
     379:         w = 2;
     380:     }
     381:     clas = classify(p);
     382:     if ((clas == TARY || clas == TSTR) && p->chain->class == CRANGE) {
     383:         p1 = lvalue(r->rhs_expr, p , LREQ ); /* SHOULD THIS BE rvalue? */
     384:     } else {
     385:         p1 = rvalue(r->rhs_expr, p , RREQ );
     386:     }
     387: #   endif OBJ
     388: #   ifdef PC
     389:     if (p == NLNIL) {
     390:         /* check for conformant array type */
     391:         codeoff();
     392:         p = rvalue(r->lhs_var, MOD|ASGN|NOUSE, LREQ);
     393:         codeon();
     394:         if (p == NLNIL) {
     395:         (void) rvalue(r->rhs_expr, NLNIL, RREQ);
     396:         return NLNIL;
     397:         }
     398:         clas = classify(p);
     399:         if ((clas == TARY || clas == TSTR) && p->chain->class == CRANGE) {
     400:         return pcasgconf(r, p);
     401:         } else {
     402:         /*
     403: 		 * since the second pass knows that it should reference
     404: 		 * the lefthandside of asignments, what i need here is
     405: 		 * an rvalue.
     406: 		 */
     407:         p = lvalue( r->lhs_var , MOD|ASGN|NOUSE , RREQ );
     408:         }
     409:         if ( p == NLNIL ) {
     410:         (void) rvalue( r->rhs_expr , NLNIL , RREQ );
     411:         return NLNIL;
     412:         }
     413:     }
     414:         /*
     415: 	     *	if this is a scalar assignment,
     416: 	     *	    then i want to rvalue the righthandside.
     417: 	     *	if this is a structure assignment,
     418: 	     *	    then i want an lvalue to the righthandside.
     419: 	     *  that's what the intermediate form sez.
     420: 	     */
     421:     switch ( classify( p ) ) {
     422:         case TINT:
     423:         case TCHAR:
     424:         case TBOOL:
     425:         case TSCAL:
     426:         precheck( p , "_RANG4" , "_RSNG4" );
     427:         /* and fall through */
     428:         case TDOUBLE:
     429:         case TPTR:
     430:         p1 = rvalue( r->rhs_expr , p , RREQ );
     431:         break;
     432:         default:
     433:         p1 = rvalue( r->rhs_expr , p , LREQ );
     434:         break;
     435:     }
     436: #	endif PC
     437:     if (p1 == NLNIL)
     438:         return (NLNIL);
     439:     if (incompat(p1, p, r->rhs_expr)) {
     440:         cerror("Type of expression clashed with type of variable in assignment");
     441:         return (NLNIL);
     442:     }
     443: #	ifdef OBJ
     444:         switch (classify(p)) {
     445:             case TINT:
     446:             case TBOOL:
     447:             case TCHAR:
     448:             case TSCAL:
     449:                 rangechk(p, p1);
     450:                 (void) gen(O_AS2, O_AS2, w, width(p1));
     451:                 break;
     452:             case TDOUBLE:
     453:             case TPTR:
     454:                 (void) gen(O_AS2, O_AS2, w, width(p1));
     455:                 break;
     456:             case TARY:
     457:             case TSTR:
     458:                 if (p->chain->class == CRANGE) {
     459:                 /* conformant array assignment */
     460:                 p1 = p->chain;
     461:                 w = width(p1->type);
     462:                 putcbnds(p1, 1);
     463:                 putcbnds(p1, 0);
     464:                 gen(NIL, T_SUB, w, w);
     465:                 put(2, w > 2? O_CON24: O_CON2, 1);
     466:                 gen(NIL, T_ADD, w, w);
     467:                 putcbnds(p1, 2);
     468:                 gen(NIL, T_MULT, w, w);
     469:                 put(1, O_VAS);
     470:                 break;
     471:                 }
     472:                 /* else fall through */
     473:             default:
     474:                 (void) put(2, O_AS, w);
     475:                 break;
     476:         }
     477: #	endif OBJ
     478: #	ifdef PC
     479:         switch (classify(p)) {
     480:             case TINT:
     481:             case TBOOL:
     482:             case TCHAR:
     483:             case TSCAL:
     484:                 postcheck(p, p1);
     485:                 sconv(p2type(p1), p2type(p));
     486:                 putop( PCC_ASSIGN , p2type( p ) );
     487:                 putdot( filename , line );
     488:                 break;
     489:             case TPTR:
     490:                 putop( PCC_ASSIGN , p2type( p ) );
     491:                 putdot( filename , line );
     492:                 break;
     493:             case TDOUBLE:
     494:                 sconv(p2type(p1), p2type(p));
     495:                 putop( PCC_ASSIGN , p2type( p ) );
     496:                 putdot( filename , line );
     497:                 break;
     498:             default:
     499:                 putstrop(PCC_STASG, PCCM_ADDTYPE(p2type(p), PCCTM_PTR),
     500:                     (int) lwidth(p), align(p));
     501:                 putdot( filename , line );
     502:                 break;
     503:         }
     504: #	endif PC
     505:     return (p); /* Used by for statement */
     506: }
     507:
     508: #ifdef PC
     509: /*
     510:  * assignment to conformant arrays.  Since these are variable length,
     511:  *	we use blkcpy() to perform the assignment.
     512:  *	blkcpy(rhs, lhs, (upper - lower + 1) * width)
     513:  */
     514: struct nl *
     515: pcasgconf(r, p)
     516:     register ASG_NODE *r;
     517:     struct nl *p;
     518: {
     519:     struct nl *p1;
     520:
     521:     if (r == (ASG_NODE *) TR_NIL || p == NLNIL)
     522:         return NLNIL;
     523:     putleaf( PCC_ICON , 0 , 0 , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR) , "_blkcpy" );
     524:     p1 = rvalue( r->rhs_expr , p , LREQ );
     525:     if (p1 == NLNIL)
     526:         return NLNIL;
     527:     p = lvalue( r->lhs_var , MOD|ASGN|NOUSE , LREQ );
     528:     if (p == NLNIL)
     529:         return NLNIL;
     530:     putop(PCC_CM, PCCT_INT);
     531:         /* upper bound */
     532:     p1 = p->chain->nptr[1];
     533:     putRV(p1->symbol, (p1->nl_block & 037), p1->value[0],
     534:         p1->extra_flags, p2type( p1 ) );
     535:         /* minus lower bound */
     536:     p1 = p->chain->nptr[0];
     537:     putRV(p1->symbol, (p1->nl_block & 037), p1->value[0],
     538:         p1->extra_flags, p2type( p1 ) );
     539:     putop( PCC_MINUS, PCCT_INT );
     540:         /* add one */
     541:     putleaf(PCC_ICON, 1, 0, PCCT_INT, 0);
     542:     putop( PCC_PLUS, PCCT_INT );
     543:         /* and multiply by the width */
     544:     p1 = p->chain->nptr[2];
     545:     putRV(p1->symbol, (p1->nl_block & 037), p1->value[0],
     546:         p1->extra_flags, p2type( p1 ) );
     547:     putop( PCC_MUL , PCCT_INT );
     548:     putop(PCC_CM, PCCT_INT);
     549:     putop(PCC_CALL, PCCT_INT);
     550:     putdot( filename , line);
     551:     return p;
     552: }
     553: #endif PC
     554:
     555: /*
     556:  * if expr then stat [ else stat ]
     557:  */
     558: ifop(if_n)
     559:     IF_NODE *if_n;
     560: {
     561:     register struct nl *p;
     562:     register l1, l2;    /* l1 is start of else, l2 is end of else */
     563:     int goc;
     564:     bool nr;
     565:
     566:     goc = gocnt;
     567:     putline();
     568:     p = rvalue(if_n->cond_expr, NLNIL , RREQ );
     569:     if (p == NIL) {
     570:         statement(if_n->then_stmnt);
     571:         noreach = FALSE;
     572:         statement(if_n->else_stmnt);
     573:         noreach = FALSE;
     574:         return;
     575:     }
     576:     if (isnta(p, "b")) {
     577:         error("Type of expression in if statement must be Boolean, not %s", nameof(p));
     578:         statement(if_n->then_stmnt);
     579:         noreach = FALSE;
     580:         statement(if_n->else_stmnt);
     581:         noreach = FALSE;
     582:         return;
     583:     }
     584: #	ifdef OBJ
     585:         l1 = put(2, O_IF, getlab());
     586: #	endif OBJ
     587: #	ifdef PC
     588:         l1 = (int) getlab();
     589:         putleaf( PCC_ICON , l1 , 0 , PCCT_INT , (char *) 0 );
     590:         putop( PCC_CBRANCH , PCCT_INT );
     591:         putdot( filename , line );
     592: #	endif PC
     593:     putcnt();
     594:     statement(if_n->then_stmnt);
     595:     nr = noreach;
     596:     if (if_n->else_stmnt != TR_NIL) {
     597:         /*
     598: 		 * else stat
     599: 		 */
     600:         --level;
     601:         ungoto();
     602:         ++level;
     603: #		ifdef OBJ
     604:             l2 = put(2, O_TRA, getlab());
     605: #		endif OBJ
     606: #		ifdef PC
     607:             l2 = (int) getlab();
     608:             putjbr( (long) l2 );
     609: #		endif PC
     610:         patch((PTR_DCL)l1);
     611:         noreach = FALSE;
     612:         statement(if_n->else_stmnt);
     613:         noreach = (noreach && nr)?TRUE:FALSE;
     614:         l1 = l2;
     615:     } else
     616:         noreach = FALSE;
     617:     patch((PTR_DCL)l1);
     618:     if (goc != gocnt)
     619:         putcnt();
     620: }
     621:
     622: /*
     623:  * while expr do stat
     624:  */
     625: whilop(w_node)
     626:     WHI_CAS *w_node;
     627: {
     628:     register struct nl *p;
     629:     register char *l1, *l2;
     630:     int goc;
     631:
     632:     goc = gocnt;
     633:     l1 = getlab();
     634:     (void) putlab(l1);
     635:     putline();
     636:     p = rvalue(w_node->expr, NLNIL , RREQ );
     637:     if (p == NLNIL) {
     638:         statement(w_node->stmnt_list);
     639:         noreach = FALSE;
     640:         return;
     641:     }
     642:     if (isnta(p, "b")) {
     643:         error("Type of expression in while statement must be Boolean, not %s", nameof(p));
     644:         statement(w_node->stmnt_list);
     645:         noreach = FALSE;
     646:         return;
     647:     }
     648:     l2 = getlab();
     649: #	ifdef OBJ
     650:         (void) put(2, O_IF, l2);
     651: #	endif OBJ
     652: #	ifdef PC
     653:         putleaf( PCC_ICON , (int) l2 , 0 , PCCT_INT , (char *) 0 );
     654:         putop( PCC_CBRANCH , PCCT_INT );
     655:         putdot( filename , line );
     656: #	endif PC
     657:     putcnt();
     658:     statement(w_node->stmnt_list);
     659: #	ifdef OBJ
     660:         (void) put(2, O_TRA, l1);
     661: #	endif OBJ
     662: #	ifdef PC
     663:         putjbr( (long) l1 );
     664: #	endif PC
     665:     patch((PTR_DCL) l2);
     666:     if (goc != gocnt)
     667:         putcnt();
     668: }
     669:
     670: /*
     671:  * repeat stat* until expr
     672:  */
     673: repop(r)
     674:     REPEAT *r;
     675: {
     676:     register struct nl *p;
     677:     register l;
     678:     int goc;
     679:
     680:     goc = gocnt;
     681:     l = (int) putlab(getlab());
     682:     putcnt();
     683:     statlist(r->stmnt_list);
     684:     line = r->line_no;
     685:     p = rvalue(r->term_expr, NLNIL , RREQ );
     686:     if (p == NLNIL)
     687:         return;
     688:     if (isnta(p,"b")) {
     689:         error("Until expression type must be Boolean, not %s, in repeat statement", nameof(p));
     690:         return;
     691:     }
     692: #	ifdef OBJ
     693:         (void) put(2, O_IF, l);
     694: #	endif OBJ
     695: #	ifdef PC
     696:         putleaf( PCC_ICON , l , 0 , PCCT_INT , (char *) 0 );
     697:         putop( PCC_CBRANCH , PCCT_INT );
     698:         putdot( filename , line );
     699: #	endif PC
     700:     if (goc != gocnt)
     701:         putcnt();
     702: }

#### Defined functions

asgnop defined in line 290; used 1 times

- in line 83

asgnop1 defined in line 353; used 5 times

- in line 324-326(2), 339-344(2)
- in /usr/src/ucb/PORT/pascal/src/0.h line 756

getcnt defined in line 169; used 3 times

- in line 166
- in /usr/src/ucb/PORT/pascal/src/fhdr.c line 88, 257

ifop defined in line 558; used 1 times

- in line 98

inccnt defined in line 176; used 3 times

- in line 166
- in /usr/src/ucb/PORT/pascal/src/fend.c line 191-193(2)

pcasgconf defined in line 514; used 2 times

- in line 400
- in /usr/src/ucb/PORT/pascal/src/0.h line 757

putcnt defined in line 160; used 13 times

- in line 54, 593, 619, 657, 667, 682, 701
- in /usr/src/ucb/PORT/pascal/src/case.c line 217, 239
- in /usr/src/ucb/PORT/pascal/src/forop.c line 354, 438
- in /usr/src/ucb/PORT/pascal/src/pccaseop.c line 196, 251

putline defined in line 191; used 9 times

- in line 73, 82-86(2), 116, 245, 567, 635
- in /usr/src/ucb/PORT/pascal/src/forop.c line 111, 421

repop defined in line 673; used 1 times

- in line 105

statement defined in line 41; used 17 times

- in line 35, 282, 570-572(2), 578-580(2), 594, 612, 638, 644, 658
- in /usr/src/ucb/PORT/pascal/src/case.c line 219
- in /usr/src/ucb/PORT/pascal/src/forop.c line 123, 203, 229, 355
- in /usr/src/ucb/PORT/pascal/src/pccaseop.c line 198

statlist defined in line 29; used 3 times

- in line 113, 683
- in /usr/src/ucb/PORT/pascal/src/fend.c line 277

ungoto defined in line 145; used 4 times

- in line 130, 601
- in /usr/src/ucb/PORT/pascal/src/case.c line 225
- in /usr/src/ucb/PORT/pascal/src/pccaseop.c line 203

whilop defined in line 625; used 1 times

- in line 101

withop defined in line 237; used 1 times

- in line 125

#### Defined variables

cnts defined in line 22; used 1 times

- in line 173

cntstat defined in line 21; used 4 times

- in line 52-53(2), 63, 89

sccsid defined in line 8; never used

Last modified: 1985-06-05 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 2128 |