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

##### Functions

    getlab            X
    getnext           X
    lenstr            X
    listnames         X
    patch             X
    patch4            X
    patchfil          X
    pflush            X
    put               X
    putlab            X
    putspace          X
    putstr            X
    word              X

##### Variables

    obufp             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[] = "@(#)put.c	5.1 (Berkeley) 6/18/85";
       9: #endif not lint
      10:
      11: #include "whoami.h"
      12: #include "opcode.h"
      13: #include "0.h"
      14: #include "objfmt.h"
      15: #ifdef PC
      16: #   include "pc.h"
      17: #   include "align.h"
      18: #else
      19:     short   *obufp  = obuf;
      20: #endif
      21:
      22: /*
      23:  * If DEBUG is defined, include the table
      24:  * of the printing opcode names.
      25:  */
      26: #ifdef DEBUG
      27: #include "OPnames.h"
      28: #endif
      29:
      30: #ifdef OBJ
      31: /*
      32:  * Put is responsible for the interpreter equivalent of code
      33:  * generation.  Since the interpreter is specifically designed
      34:  * for Pascal, little work is required here.
      35:  */
      36: /*VARARGS*/
      37: put(a)
      38: {
      39:     register int *p, i;
      40:     register char *cp;
      41:     register short *sp;
      42:     register long *lp;
      43:     int n, subop, suboppr, op, oldlc;
      44:     char *string;
      45:     static int casewrd;
      46:
      47:     /*
      48: 	 * It would be nice to do some more
      49: 	 * optimizations here.  The work
      50: 	 * done to collapse offsets in lval
      51: 	 * should be done here, the IFEQ etc
      52: 	 * relational operators could be used
      53: 	 * etc.
      54: 	 */
      55:     oldlc = (int) lc; /* its either this or change put to return a char * */
      56:     if ( !CGENNING )
      57:         /*
      58: 		 * code disabled - do nothing
      59: 		 */
      60:         return (oldlc);
      61:     p = &a;
      62:     n = *p++;
      63:     suboppr = subop = (*p >> 8) & 0377;
      64:     op = *p & 0377;
      65:     string = 0;
      66: #ifdef DEBUG
      67:     if ((cp = otext[op]) == NIL) {
      68:         printf("op= %o\n", op);
      69:         panic("put");
      70:     }
      71: #endif
      72:     switch (op) {
      73:         case O_ABORT:
      74:             cp = "*";
      75:             break;
      76:         case O_AS:
      77:             switch(p[1]) {
      78:             case 0:
      79:                 break;
      80:             case 2:
      81:                 op = O_AS2;
      82:                 n = 1;
      83:                 break;
      84:             case 4:
      85:                 op = O_AS4;
      86:                 n = 1;
      87:                 break;
      88:             case 8:
      89:                 op = O_AS8;
      90:                 n = 1;
      91:                 break;
      92:             default:
      93:                 goto pack;
      94:             }
      95: #			ifdef DEBUG
      96:                 cp = otext[op];
      97: #			endif DEBUG
      98:             break;
      99:         case O_FOR1U:
     100:         case O_FOR2U:
     101:         case O_FOR4U:
     102:         case O_FOR1D:
     103:         case O_FOR2D:
     104:         case O_FOR4D:
     105:             /* relative addressing */
     106:             p[1] -= ( unsigned ) lc + sizeof(short);
     107:             /* try to pack the jump */
     108:             if (p[1] <= 127 && p[1] >= -128) {
     109:                 suboppr = subop = p[1];
     110:                 p++;
     111:                 n--;
     112:             } else {
     113:                 /* have to allow for extra displacement */
     114:                 p[1] -= sizeof(short);
     115:             }
     116:             break;
     117:         case O_CONG:
     118:         case O_LVCON:
     119:         case O_CON:
     120:         case O_LINO:
     121:         case O_NEW:
     122:         case O_DISPOSE:
     123:         case O_DFDISP:
     124:         case O_IND:
     125:         case O_OFF:
     126:         case O_INX2:
     127:         case O_INX4:
     128:         case O_CARD:
     129:         case O_ADDT:
     130:         case O_SUBT:
     131:         case O_MULT:
     132:         case O_IN:
     133:         case O_CASE1OP:
     134:         case O_CASE2OP:
     135:         case O_CASE4OP:
     136:         case O_FRTN:
     137:         case O_WRITES:
     138:         case O_WRITEC:
     139:         case O_WRITEF:
     140:         case O_MAX:
     141:         case O_MIN:
     142:         case O_ARGV:
     143:         case O_CTTOT:
     144:         case O_INCT:
     145:         case O_RANG2:
     146:         case O_RSNG2:
     147:         case O_RANG42:
     148:         case O_RSNG42:
     149:         case O_SUCC2:
     150:         case O_SUCC24:
     151:         case O_PRED2:
     152:         case O_PRED24:
     153:             if (p[1] == 0)
     154:                 break;
     155:         case O_CON2:
     156:         case O_CON24:
     157:         pack:
     158:             if (p[1] <= 127 && p[1] >= -128) {
     159:                 suboppr = subop = p[1];
     160:                 p++;
     161:                 n--;
     162:                 if (op == O_CON2) {
     163:                     op = O_CON1;
     164: #					ifdef DEBUG
     165:                         cp = otext[O_CON1];
     166: #					endif DEBUG
     167:                 }
     168:                 if (op == O_CON24) {
     169:                     op = O_CON14;
     170: #					ifdef DEBUG
     171:                         cp = otext[O_CON14];
     172: #					endif DEBUG
     173:                 }
     174:             }
     175:             break;
     176:         case O_CON8:
     177:             {
     178:             short   *sp = (short *) (&p[1]);
     179:
     180: #ifdef  DEBUG
     181:             if ( opt( 'k' ) )
     182:                 printf ( "%5d\tCON8\t%22.14e\n" ,
     183:                     lc - HEADER_BYTES ,
     184:                     * ( ( double * ) &p[1] ) );
     185: #endif
     186: #			ifdef DEC11
     187:                 word(op);
     188: #			else
     189:                 word(op << 8);
     190: #			endif DEC11
     191:             for ( i = 1 ; i <= 4 ; i ++ )
     192:                 word ( *sp ++ );
     193:             return ( oldlc );
     194:             }
     195:         default:
     196:             if (op >= O_REL2 && op <= O_REL84) {
     197:                 if ((i = (subop >> INDX) * 5 ) >= 30)
     198:                     i -= 30;
     199:                 else
     200:                     i += 2;
     201: #ifdef DEBUG
     202:                 string = &"IFEQ\0IFNE\0IFLT\0IFGT\0IFLE\0IFGE"[i];
     203: #endif
     204:                 suboppr = 0;
     205:             }
     206:             break;
     207:         case O_IF:
     208:         case O_TRA:
     209: /*****
     210: 			codeline = 0;
     211: *****/
     212:             /* relative addressing */
     213:             p[1] -= ( unsigned ) lc + sizeof(short);
     214:             break;
     215:         case O_CONC:
     216: #ifdef DEBUG
     217:             (string = "'x'")[1] = p[1];
     218: #endif
     219:             suboppr = 0;
     220:             op = O_CON1;
     221: #			ifdef DEBUG
     222:                 cp = otext[O_CON1];
     223: #			endif DEBUG
     224:             subop = p[1];
     225:             goto around;
     226:         case O_CONC4:
     227: #ifdef DEBUG
     228:             (string = "'x'")[1] = p[1];
     229: #endif
     230:             suboppr = 0;
     231:             op = O_CON14;
     232:             subop = p[1];
     233:             goto around;
     234:         case O_CON1:
     235:         case O_CON14:
     236:             suboppr = subop = p[1];
     237: around:
     238:             n--;
     239:             break;
     240:         case O_CASEBEG:
     241:             casewrd = 0;
     242:             return (oldlc);
     243:         case O_CASEEND:
     244:             if ((unsigned) lc & 1) {
     245:                 lc--;
     246:                 word(casewrd);
     247:             }
     248:             return (oldlc);
     249:         case O_CASE1:
     250: #ifdef DEBUG
     251:             if (opt('k'))
     252:                 printf("%5d\tCASE1\t%d\n"
     253:                     , lc - HEADER_BYTES, p[1]);
     254: #endif
     255:             /*
     256: 			 * this to build a byte size case table
     257: 			 * saving bytes across calls in casewrd
     258: 			 * so they can be put out by word()
     259: 			 */
     260:             lc++;
     261:             if ((unsigned) lc & 1)
     262: #				ifdef DEC11
     263:                     casewrd = p[1] & 0377;
     264: #				else
     265:                     casewrd = (p[1] & 0377) << 8;
     266: #				endif DEC11
     267:             else {
     268:                 lc -= 2;
     269: #				ifdef DEC11
     270:                     word(((p[1] & 0377) << 8) | casewrd);
     271: #				else
     272:                     word((p[1] & 0377) | casewrd);
     273: #				endif DEC11
     274:             }
     275:             return (oldlc);
     276:         case O_CASE2:
     277: #ifdef DEBUG
     278:             if (opt('k'))
     279:                 printf("%5d\tCASE2\t%d\n"
     280:                     , lc - HEADER_BYTES , p[1]);
     281: #endif
     282:             word(p[1]);
     283:             return (oldlc);
     284:         case O_PUSH:
     285:             lp = (long *)&p[1];
     286:             if (*lp == 0)
     287:                 return (oldlc);
     288:             /* and fall through */
     289:         case O_RANG4:
     290:         case O_RANG24:
     291:         case O_RSNG4:
     292:         case O_RSNG24:
     293:         case O_SUCC4:
     294:         case O_PRED4:
     295:             /* sub opcode optimization */
     296:             lp = (long *)&p[1];
     297:             if (*lp < 128 && *lp >= -128 && *lp != 0) {
     298:                 suboppr = subop = *lp;
     299:                 p += (sizeof(long) / sizeof(int));
     300:                 n--;
     301:             }
     302:             goto longgen;
     303:         case O_TRA4:
     304:         case O_CALL:
     305:         case O_FSAV:
     306:         case O_GOTO:
     307:         case O_NAM:
     308:         case O_READE:
     309:             /* absolute long addressing */
     310:             lp = (long *)&p[1];
     311:             *lp -= HEADER_BYTES;
     312:             goto longgen;
     313:         case O_RV1:
     314:         case O_RV14:
     315:         case O_RV2:
     316:         case O_RV24:
     317:         case O_RV4:
     318:         case O_RV8:
     319:         case O_RV:
     320:         case O_LV:
     321:             /*
     322: 			 * positive offsets represent arguments
     323: 			 * and must use "ap" display entry rather
     324: 			 * than the "fp" entry
     325: 			 */
     326:             if (p[1] >= 0) {
     327:                 subop++;
     328:                 suboppr++;
     329:             }
     330: #			ifdef PDP11
     331:                 break;
     332: #			else
     333:                 /*
     334: 			     * offsets out of range of word addressing
     335: 			     * must use long offset opcodes
     336: 			     */
     337:                 if (p[1] < SHORTADDR && p[1] >= -SHORTADDR)
     338:                     break;
     339:                 else {
     340:                 op += O_LRV - O_RV;
     341: #				ifdef DEBUG
     342:                     cp = otext[op];
     343: #				endif DEBUG
     344:                 }
     345:                 /* and fall through */
     346: #			endif PDP11
     347:         case O_BEG:
     348:         case O_NODUMP:
     349:         case O_CON4:
     350:         case O_CASE4:
     351:         longgen:
     352:             n = (n << 1) - 1;
     353:             if ( op == O_LRV ) {
     354:                 n--;
     355: #				if defined(ADDR32) && !defined(DEC11)
     356:                     p[n / 2] <<= 16;
     357: #				endif
     358:             }
     359: #ifdef DEBUG
     360:             if (opt('k')) {
     361:                 printf("%5d\t%s", lc - HEADER_BYTES, cp+1);
     362:                 if (suboppr)
     363:                     printf(":%d", suboppr);
     364:                 for ( i = 2, lp = (long *)&p[1]; i < n
     365:                     ; i += sizeof ( long )/sizeof ( short ) )
     366:                     printf( "\t%D " , *lp ++ );
     367:                 if (i == n) {
     368:                     sp = (short *)lp;
     369:                     printf( "\t%d ", *sp );
     370:                 }
     371:                 pchr ( '\n' );
     372:             }
     373: #endif
     374:             if ( op != O_CASE4 )
     375: #				ifdef DEC11
     376:                         word((op & 0377) | subop << 8);
     377: #				else
     378:                     word(op << 8 | (subop & 0377));
     379: #				endif DEC11
     380:             for ( i = 1, sp = (short *)&p[1]; i < n; i++)
     381:                 word ( *sp ++ );
     382:             return ( oldlc );
     383:     }
     384: #ifdef DEBUG
     385:     if (opt('k')) {
     386:         printf("%5d\t%s", lc - HEADER_BYTES, cp+1);
     387:         if (suboppr)
     388:             printf(":%d", suboppr);
     389:         if (string)
     390:             printf("\t%s",string);
     391:         if (n > 1)
     392:             pchr('\t');
     393:         for (i=1; i<n; i++)
     394:             printf("%d ", p[i]);
     395:         pchr('\n');
     396:     }
     397: #endif
     398:     if (op != NIL)
     399: #		ifdef DEC11
     400:             word((op & 0377) | subop << 8);
     401: #		else
     402:             word(op << 8 | (subop & 0377));
     403: #		endif DEC11
     404:     for (i=1; i<n; i++)
     405:         word(p[i]);
     406:     return (oldlc);
     407: }
     408: #endif OBJ
     409:
     410: /*
     411:  * listnames outputs a list of enumerated type names which
     412:  * can then be selected from to output a TSCAL
     413:  * a pointer to the address in the code of the namelist
     414:  * is kept in value[ NL_ELABEL ].
     415:  */
     416: listnames(ap)
     417:
     418:     register struct nl *ap;
     419: {
     420:     struct nl *next;
     421: #ifdef OBJ
     422:     register int oldlc;
     423: #endif
     424:     register int len;
     425:     register unsigned w;
     426:     register char *strptr;
     427:
     428:     if ( !CGENNING )
     429:         /* code is off - do nothing */
     430:         return(NIL);
     431:     if (ap->class != TYPE)
     432:         ap = ap->type;
     433:     if (ap->value[ NL_ELABEL ] != 0) {
     434:         /* the list already exists */
     435:         return( ap -> value[ NL_ELABEL ] );
     436:     }
     437: #	ifdef OBJ
     438:         oldlc = (int) lc; /* same problem as put */
     439:         (void) put(2, O_TRA, lc);
     440:         ap->value[ NL_ELABEL ] = (int) lc;
     441: #	endif OBJ
     442: #	ifdef PC
     443:         putprintf("	.data", 0);
     444:         aligndot(A_STRUCT);
     445:         ap -> value[ NL_ELABEL ] = (int) getlab();
     446:         (void) putlab((char *) ap -> value[ NL_ELABEL ] );
     447: #	endif PC
     448:     /* number of scalars */
     449:     next = ap->type;
     450:     len = next->range[1]-next->range[0]+1;
     451: #	ifdef OBJ
     452:         (void) put(2, O_CASE2, len);
     453: #	endif OBJ
     454: #	ifdef PC
     455:         putprintf( "	.word %d" , 0 , len );
     456: #	endif PC
     457:     /* offsets of each scalar name */
     458:     len = (len+1)*sizeof(short);
     459: #	ifdef OBJ
     460:         (void) put(2, O_CASE2, len);
     461: #	endif OBJ
     462: #	ifdef PC
     463:         putprintf( "	.word %d" , 0 , len );
     464: #	endif PC
     465:     next = ap->chain;
     466:     do  {
     467:         for(strptr = next->symbol;  *strptr++;  len++)
     468:             continue;
     469:         len++;
     470: #		ifdef OBJ
     471:             (void) put(2, O_CASE2, len);
     472: #		endif OBJ
     473: #		ifdef PC
     474:             putprintf( "	.word %d" , 0 , len );
     475: #		endif PC
     476:     } while (next = next->chain);
     477:     /* list of scalar names */
     478:     strptr = getnext(ap, &next);
     479: #	ifdef OBJ
     480:         do  {
     481: #		    ifdef DEC11
     482:             w = (unsigned) *strptr;
     483: #		    else
     484:             w = *strptr << 8;
     485: #		    endif DEC11
     486:             if (!*strptr++)
     487:                 strptr = getnext(next, &next);
     488: #		    ifdef DEC11
     489:             w |= *strptr << 8;
     490: #		    else
     491:             w |= (unsigned) *strptr;
     492: #		    endif DEC11
     493:             if (!*strptr++)
     494:                 strptr = getnext(next, &next);
     495:             word((int) w);
     496:         } while (next);
     497:         /* jump over the mess */
     498:         patch((PTR_DCL) oldlc);
     499: #	endif OBJ
     500: #	ifdef PC
     501:         while ( next ) {
     502:         while ( *strptr ) {
     503:             putprintf( "	.byte	0%o" , 1 , *strptr++ );
     504:             for ( w = 2 ; ( w <= 8 ) && *strptr ; w ++ ) {
     505:             putprintf( ",0%o" , 1 , *strptr++ );
     506:             }
     507:             putprintf( "" , 0 );
     508:         }
     509:         putprintf( "	.byte	0" , 0 );
     510:         strptr = getnext( next , &next );
     511:         }
     512:         putprintf( "	.text" , 0 );
     513: #	endif PC
     514:     return( ap -> value[ NL_ELABEL ] );
     515: }
     516:
     517: char *
     518: getnext(next, new)
     519:
     520:     struct nl *next, **new;
     521: {
     522:     if (next != NIL) {
     523:         next = next->chain;
     524:         *new = next;
     525:     }
     526:     if (next == NLNIL)
     527:         return("");
     528: #ifdef OBJ
     529:     if (opt('k') && CGENNING )
     530:         printf("%5d\t\t\"%s\"\n", lc-HEADER_BYTES, next->symbol);
     531: #endif OBJ
     532:     return(next->symbol);
     533: }
     534:
     535: #ifdef OBJ
     536: /*
     537:  * Putspace puts out a table
     538:  * of nothing to leave space
     539:  * for the case branch table e.g.
     540:  */
     541: putspace(n)
     542:     int n;
     543: {
     544:     register i;
     545:
     546:     if ( !CGENNING )
     547:         /*
     548: 		 * code disabled - do nothing
     549: 		 */
     550:         return;
     551: #ifdef DEBUG
     552:     if (opt('k'))
     553:         printf("%5d\t.=.+%d\n", lc - HEADER_BYTES, n);
     554: #endif
     555:     for (i = even(n); i > 0; i -= 2)
     556:         word(0);
     557: }
     558:
     559: putstr(sptr, padding)
     560:
     561:     char *sptr;
     562:     int padding;
     563: {
     564:     register unsigned short w;
     565:     register char *strptr = sptr;
     566:     register int pad = padding;
     567:
     568:     if ( !CGENNING )
     569:         /*
     570: 		 * code disabled - do nothing
     571: 		 */
     572:         return;
     573: #ifdef DEBUG
     574:     if (opt('k'))
     575:         printf("%5d\t\t\"%s\"\n", lc-HEADER_BYTES, strptr);
     576: #endif
     577:     if (pad == 0) {
     578:         do  {
     579: #			ifdef DEC11
     580:                 w = (unsigned short) * strptr;
     581: #			else
     582:                 w = (unsigned short)*strptr<<8;
     583: #			endif DEC11
     584:             if (w)
     585: #				ifdef DEC11
     586:                     w |= *++strptr << 8;
     587: #				else
     588:                     w |= *++strptr;
     589: #				endif DEC11
     590:             word((int) w);
     591:         } while (*strptr++);
     592:     } else {
     593: #		ifdef DEC11
     594:             do  {
     595:                 w = (unsigned short) * strptr;
     596:                 if (w) {
     597:                     if (*++strptr)
     598:                         w |= *strptr << 8;
     599:                     else {
     600:                         w |= ' ' << 8;
     601:                         pad--;
     602:                     }
     603:                     word((int) w);
     604:                 }
     605:             } while (*strptr++);
     606: #		else
     607:             do  {
     608:                 w = (unsigned short)*strptr<<8;
     609:                 if (w) {
     610:                     if (*++strptr)
     611:                         w |= *strptr;
     612:                     else {
     613:                         w |= ' ';
     614:                         pad--;
     615:                     }
     616:                     word(w);
     617:                 }
     618:             } while (*strptr++);
     619: #		endif DEC11
     620:         while (pad > 1) {
     621: #			ifdef DEC11
     622:                 word(' ' | (' ' << 8));
     623: #			else
     624:                 word((' ' << 8) | ' ');
     625: #			endif DEC11
     626:             pad -= 2;
     627:         }
     628:         if (pad == 1)
     629: #			ifdef DEC11
     630:                 word(' ');
     631: #			else
     632:                 word(' ' << 8);
     633: #			endif DEC11
     634:         else
     635:             word(0);
     636:     }
     637: }
     638: #endif OBJ
     639:
     640: #ifndef PC
     641: lenstr(sptr, padding)
     642:
     643:     char *sptr;
     644:     int padding;
     645:
     646: {
     647:     register int cnt;
     648:     register char *strptr = sptr;
     649:
     650:     cnt = padding;
     651:     do  {
     652:         cnt++;
     653:     } while (*strptr++);
     654:     return((++cnt) & ~1);
     655: }
     656: #endif
     657:
     658: /*
     659:  * Patch repairs the branch
     660:  * at location loc to come
     661:  * to the current location.
     662:  *	for PC, this puts down the label
     663:  *	and the branch just references that label.
     664:  *	lets here it for two pass assemblers.
     665:  */
     666: patch(loc)
     667:     PTR_DCL loc;
     668: {
     669:
     670: #	ifdef OBJ
     671:         patchfil(loc, (long)(lc-loc-2), 1);
     672: #	endif OBJ
     673: #	ifdef PC
     674:         (void) putlab((char *) loc );
     675: #	endif PC
     676: }
     677:
     678: #ifdef OBJ
     679: patch4(loc)
     680: PTR_DCL loc;
     681: {
     682:     patchfil(loc, (long)(lc - HEADER_BYTES), 2);
     683: }
     684:
     685: /*
     686:  * Patchfil makes loc+2 have jmploc
     687:  * as its contents.
     688:  */
     689: patchfil(loc, jmploc, words)
     690:     PTR_DCL loc;
     691:     long jmploc;
     692:     int words;
     693: {
     694:     register i;
     695:     extern long lseek();
     696:     short val;
     697:
     698:     if ( !CGENNING )
     699:         return;
     700:     if (loc > (unsigned) lc)
     701:         panic("patchfil");
     702: #ifdef DEBUG
     703:     if (opt('k'))
     704:         printf("\tpatch %u %D\n", loc - HEADER_BYTES, jmploc);
     705: #endif
     706:     val = jmploc;
     707:     do {
     708: #		ifndef DEC11
     709:             if (words > 1)
     710:                 val = jmploc >> 16;
     711:             else
     712:                 val = jmploc;
     713: #		endif DEC11
     714:         i = ((unsigned) loc + 2 - ((unsigned) lc & ~01777))/2;
     715:         if (i >= 0 && i < 1024) {
     716:             obuf[i] = val;
     717:         } else {
     718:             (void) lseek(ofil, (long) loc+2, 0);
     719:             write(ofil, (char *) (&val), 2);
     720:             (void) lseek(ofil, (long) 0, 2);
     721:         }
     722:         loc += 2;
     723: #		ifdef DEC11
     724:             val = jmploc >> 16;
     725: #		endif DEC11
     726:     } while (--words);
     727: }
     728:
     729: /*
     730:  * Put the word o into the code
     731:  */
     732: word(o)
     733:     int o;
     734: {
     735:
     736:     *obufp = o;
     737:     obufp++;
     738:     lc += 2;
     739:     if (obufp >= obuf+512)
     740:         pflush();
     741: }
     742:
     743: extern char *obj;
     744: /*
     745:  * Flush the code buffer
     746:  */
     747: pflush()
     748: {
     749:     register i;
     750:
     751:     i = (obufp - ( ( short * ) obuf ) ) * 2;
     752:     if (i != 0 && write(ofil, (char *) obuf, i) != i)
     753:         perror(obj), pexit(DIED);
     754:     obufp = obuf;
     755: }
     756: #endif OBJ
     757:
     758: /*
     759:  * Getlab - returns the location counter.
     760:  * included here for the eventual code generator.
     761:  *	for PC, thank you!
     762:  */
     763: char *
     764: getlab()
     765: {
     766: #	ifdef OBJ
     767:
     768:         return (lc);
     769: #	endif OBJ
     770: #	ifdef PC
     771:         static long lastlabel;
     772:
     773:         return ( (char *) ++lastlabel );
     774: #	endif PC
     775: }
     776:
     777: /*
     778:  * Putlab - lay down a label.
     779:  *	for PC, just print the label name with a colon after it.
     780:  */
     781: char *
     782: putlab(l)
     783:     char *l;
     784: {
     785:
     786: #	ifdef PC
     787:         putprintf( PREFIXFORMAT , 1 , (int) LABELPREFIX , (int) l );
     788:         putprintf( ":" , 0 );
     789: #	endif PC
     790:     return (l);
     791: }

#### Defined functions

getlab defined in line 763; used 38 times

- in line 445
- in /usr/src/ucb/PORT/pascal/src/0.h line 719
- in /usr/src/ucb/PORT/pascal/src/case.c line 179
- in /usr/src/ucb/PORT/pascal/src/cset.c line 409
- in /usr/src/ucb/PORT/pascal/src/fend.c line 544, 561, 573-579(3), 696, 819-825(3), 934
- in /usr/src/ucb/PORT/pascal/src/fhdr.c line 255
- in /usr/src/ucb/PORT/pascal/src/forop.c line 239, 282, 303, 328
- in /usr/src/ucb/PORT/pascal/src/lab.c line 77, 83
- in /usr/src/ucb/PORT/pascal/src/p2put.c line 348, 383
- in /usr/src/ucb/PORT/pascal/src/pccaseop.c line 126, 156-157(2), 172, 262, 404
- in /usr/src/ucb/PORT/pascal/src/stab.c line 317, 362
- in /usr/src/ucb/PORT/pascal/src/stat.c line 585-588(2), 604-607(2), 633, 648, 681

getnext defined in line 517; used 5 times

- in line 478, 487, 494, 510
- in /usr/src/ucb/PORT/pascal/src/0.h line 720

lenstr defined in line 641; used 4 times

- in /usr/src/ucb/PORT/pascal/src/fend.c line 105, 244
- in /usr/src/ucb/PORT/pascal/src/proc.c line 612
- in /usr/src/ucb/PORT/pascal/src/stkrval.c line 174

listnames defined in line 416; used 4 times

- in /usr/src/ucb/PORT/pascal/src/pcproc.c line 791, 1110
- in /usr/src/ucb/PORT/pascal/src/proc.c line 434, 786

patch defined in line 666; used 7 times

- in line 498
- in /usr/src/ucb/PORT/pascal/src/case.c line 232-235(2)
- in /usr/src/ucb/PORT/pascal/src/forop.c line 429
- in /usr/src/ucb/PORT/pascal/src/stat.c line 610, 617, 665

patch4 defined in line 679; used 2 times

- in /usr/src/ucb/PORT/pascal/src/fend.c line 90
- in /usr/src/ucb/PORT/pascal/src/lab.c line 254

patchfil defined in line 689; used 7 times

- in line 671, 682
- in /usr/src/ucb/PORT/pascal/src/case.c line 206-211(2)
- in /usr/src/ucb/PORT/pascal/src/fend.c line 287-288(2), 471

pflush defined in line 747; used 3 times

- in line 740
- in /usr/src/ucb/PORT/pascal/src/main.c line 377
- in /usr/src/ucb/PORT/pascal/src/yymain.c line 166

put defined in line 37; used 4 times

- in line 439, 452, 460, 471

putlab defined in line 781; used 24 times

- in line 446, 674
- in /usr/src/ucb/PORT/pascal/src/0.h line 725
- in /usr/src/ucb/PORT/pascal/src/cset.c line 412
- in /usr/src/ucb/PORT/pascal/src/fend.c line 580, 592, 652, 826, 835, 890
- in /usr/src/ucb/PORT/pascal/src/forop.c line 283, 329, 411
- in /usr/src/ucb/PORT/pascal/src/lab.c line 96
- in /usr/src/ucb/PORT/pascal/src/p2put.c line 351, 384
- in /usr/src/ucb/PORT/pascal/src/pccaseop.c line 195, 211, 241, 249, 329, 417
- in /usr/src/ucb/PORT/pascal/src/stat.c line 634, 681

putspace defined in line 541; used 1 times

- in /usr/src/ucb/PORT/pascal/src/case.c line 167

putstr defined in line 559; used 7 times

- in /usr/src/ucb/PORT/pascal/src/fend.c line 120, 247
- in /usr/src/ucb/PORT/pascal/src/proc.c line 500, 614
- in /usr/src/ucb/PORT/pascal/src/rval.c line 242
- in /usr/src/ucb/PORT/pascal/src/stkrval.c line 175, 261

word defined in line 732; used 24 times

- in line 187-192(3), 246, 270-272(2), 282, 376-381(3), 400-405(3), 495, 556, 590, 603, 616, 622-624(2), 630-635(3)
- in /usr/src/ucb/PORT/pascal/src/yymain.c line 152

#### Defined variables

obufp defined in line 19; used 5 times

- in line 736-739(3), 751-754(2)

sccsid defined in line 8; never used

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