4.3BSD - /usr/src/ucb/pascal/src/p2put.c

   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[] = "@(#)p2put.c	5.3 (Berkeley) 6/21/85";
   9: #endif not lint
  10: 
  11:     /*
  12:      *	functions to help pi put out
  13:      *	polish postfix binary portable c compiler intermediate code
  14:      *	thereby becoming the portable pascal compiler
  15:      */
  16: 
  17: #include    "whoami.h"
  18: #ifdef PC
  19: #include    "0.h"
  20: #include    "objfmt.h"
  21: #include    <pcc.h>
  22: #include    "pc.h"
  23: #include    "align.h"
  24: #include    "tmps.h"
  25: 
  26:     /*
  27:      *	emits an ftext operator and a string to the pcstream
  28:      */
  29: puttext( string )
  30:     char    *string;
  31:     {
  32:     int length = str4len( string );
  33: 
  34:     if ( !CGENNING )
  35:         return;
  36:     p2word( PCCM_TRIPLE( PCCF_FTEXT , length , 0 ) );
  37: #	ifdef DEBUG
  38:         if ( opt( 'k' ) ) {
  39:         fprintf( stdout , "PCCF_FTEXT | %3d | 0	" , length );
  40:         }
  41: #	endif
  42:     p2string( string );
  43:     }
  44: 
  45: int
  46: str4len( string )
  47:     char    *string;
  48:     {
  49: 
  50:     return ( ( strlen( string ) + 3 ) / 4 );
  51:     }
  52: 
  53:     /*
  54:      *	put formatted text into a buffer for printing to the pcstream.
  55:      *	a call to putpflush actually puts out the text.
  56:      *	none of arg1 .. arg5 need be present.
  57:      *	and you can add more if you need them.
  58:      */
  59: /* VARARGS */
  60: putprintf( format , incomplete , arg1 , arg2 , arg3 , arg4 , arg5 )
  61:     char    *format;
  62:     int     incomplete;
  63:     {
  64:     static char ppbuffer[ BUFSIZ ];
  65:     static char *ppbufp = ppbuffer;
  66: 
  67:     if ( !CGENNING )
  68:         return;
  69:     sprintf( ppbufp , format , arg1 , arg2 , arg3 , arg4 , arg5 );
  70:     ppbufp = &( ppbuffer[ strlen( ppbuffer ) ] );
  71:     if ( ppbufp >= &( ppbuffer[ BUFSIZ ] ) )
  72:         panic( "putprintf" );
  73:     if ( ! incomplete ) {
  74:         puttext( ppbuffer );
  75:         ppbufp = ppbuffer;
  76:     }
  77:     }
  78: 
  79:     /*
  80:      *	emit a left bracket operator to pcstream
  81:      *	with function number, the maximum temp register, and total local bytes
  82:      */
  83: putlbracket(ftnno, sizesp)
  84:     int     ftnno;
  85:     struct om   *sizesp;
  86: {
  87:     int maxtempreg;
  88:     int alignedframesize;
  89: 
  90: #   ifdef vax
  91:     maxtempreg = sizesp->curtmps.next_avail[REG_GENERAL];
  92: #   endif vax
  93: #   ifdef mc68000
  94:         /*
  95: 	     *	this is how /lib/f1 wants it.
  96: 	     */
  97:     maxtempreg =    (sizesp->curtmps.next_avail[REG_ADDR] << 4)
  98:               | (sizesp->curtmps.next_avail[REG_DATA]);
  99: #   endif mc68000
 100:     alignedframesize = roundup((int)(BITSPERBYTE * -sizesp->curtmps.om_off),
 101:     (long)(BITSPERBYTE * A_STACK));
 102:     p2word( PCCM_TRIPLE( PCCF_FLBRAC , maxtempreg , ftnno ) );
 103:     p2word(alignedframesize);
 104: #   ifdef DEBUG
 105:     if ( opt( 'k' ) ) {
 106:         fprintf(stdout, "PCCF_FLBRAC | %3d | %d	%d\n",
 107:         maxtempreg, ftnno, alignedframesize);
 108:     }
 109: #   endif
 110: }
 111: 
 112:     /*
 113:      *	emit a right bracket operator
 114:      *	which for the binary interface
 115:      *	forces the stack allocate and register mask
 116:      */
 117: putrbracket( ftnno )
 118:     int ftnno;
 119:     {
 120: 
 121:     p2word( PCCM_TRIPLE( PCCF_FRBRAC , 0 , ftnno ) );
 122: #	ifdef DEBUG
 123:         if ( opt( 'k' ) ) {
 124:         fprintf( stdout , "PCCF_FRBRAC |   0 | %d\n" , ftnno );
 125:         }
 126: #	endif
 127:     }
 128: 
 129:     /*
 130:      *	emit an eof operator
 131:      */
 132: puteof()
 133:     {
 134: 
 135:     p2word( PCCF_FEOF );
 136: #	ifdef DEBUG
 137:         if ( opt( 'k' ) ) {
 138:         fprintf( stdout , "PCCF_FEOF\n" );
 139:         }
 140: #	endif
 141:     }
 142: 
 143:     /*
 144:      *	emit a dot operator,
 145:      *	with a source file line number and name
 146:      *	if line is negative, there was an error on that line, but who cares?
 147:      */
 148: putdot( filename , line )
 149:     char    *filename;
 150:     int     line;
 151:     {
 152:     int length = str4len( filename );
 153: 
 154:     if ( line < 0 ) {
 155:         line = -line;
 156:     }
 157:     p2word( PCCM_TRIPLE( PCCF_FEXPR , length , line ) );
 158: #	ifdef DEBUG
 159:         if ( opt( 'k' ) ) {
 160:         fprintf( stdout , "PCCF_FEXPR | %3d | %d	" , length , line );
 161:         }
 162: #	endif
 163:     p2string( filename );
 164:     }
 165: 
 166:     /*
 167:      *	put out a leaf node
 168:      */
 169: putleaf( op , lval , rval , type , name )
 170:     int     op;
 171:     int     lval;
 172:     int     rval;
 173:     int     type;
 174:     char    *name;
 175:     {
 176:     if ( !CGENNING )
 177:         return;
 178:     switch ( op ) {
 179:         default:
 180:         panic( "[putleaf]" );
 181:         case PCC_ICON:
 182:         p2word( PCCM_TRIPLE( PCC_ICON , name != NIL , type ) );
 183:         p2word( lval );
 184: #		ifdef DEBUG
 185:             if ( opt( 'k' ) ) {
 186:             fprintf( stdout , "PCC_ICON | %3d | 0x%x	"
 187:                    , name != NIL , type );
 188:             fprintf( stdout , "%d\n" , lval );
 189:             }
 190: #		endif
 191:         if ( name )
 192:             p2name( name );
 193:         break;
 194:         case PCC_NAME:
 195:         p2word( PCCM_TRIPLE( PCC_NAME , lval != 0 , type ) );
 196:         if ( lval )
 197:             p2word( lval );
 198: #		ifdef DEBUG
 199:             if ( opt( 'k' ) ) {
 200:             fprintf( stdout , "PCC_NAME | %3d | 0x%x	"
 201:                    , lval != 0 , type );
 202:             if ( lval )
 203:                 fprintf( stdout , "%d	" , lval );
 204:             }
 205: #		endif
 206:         p2name( name );
 207:         break;
 208:         case PCC_REG:
 209:         p2word( PCCM_TRIPLE( PCC_REG , rval , type ) );
 210: #		ifdef DEBUG
 211:             if ( opt( 'k' ) ) {
 212:             fprintf( stdout , "PCC_REG | %3d | 0x%x\n" ,
 213:                 rval , type );
 214:             }
 215: #		endif
 216:         break;
 217:     }
 218:     }
 219: 
 220:     /*
 221:      *	rvalues are just lvalues with indirection, except
 222:      *	special cases for registers and for named globals,
 223:      *	whose names are their rvalues.
 224:      */
 225: putRV( name , level , offset , other_flags , type )
 226:     char    *name;
 227:     int     level;
 228:     int     offset;
 229:     char    other_flags;
 230:     int     type;
 231:     {
 232:     char    extname[ BUFSIZ ];
 233:     char    *printname;
 234: 
 235:     if ( !CGENNING )
 236:         return;
 237:     if ( other_flags & NREGVAR ) {
 238:         if ( ( offset < 0 ) || ( offset > P2FP ) ) {
 239:         panic( "putRV regvar" );
 240:         }
 241:         putleaf( PCC_REG , 0 , offset , type , (char *) 0 );
 242:         return;
 243:     }
 244:     if ( whereis( offset , other_flags ) == GLOBALVAR ) {
 245:         if ( name != 0 ) {
 246:         if ( name[0] != '_' ) {
 247:             sprintf( extname , EXTFORMAT , name );
 248:             printname = extname;
 249:         } else {
 250:             printname = name;
 251:         }
 252:         putleaf( PCC_NAME , offset , 0 , type , printname );
 253:         return;
 254:         } else {
 255:         panic( "putRV no name" );
 256:         }
 257:     }
 258:     putLV( name , level , offset , other_flags , type );
 259:     putop( PCCOM_UNARY PCC_MUL , type );
 260:     }
 261: 
 262:     /*
 263:      *	put out an lvalue
 264:      *	given a level and offset
 265:      *	special case for
 266:      *	    named globals, whose lvalues are just their names as constants.
 267:      */
 268: putLV( name , level , offset , other_flags , type )
 269:     char    *name;
 270:     int     level;
 271:     int     offset;
 272:     char    other_flags;
 273:     int     type;
 274: {
 275:     char        extname[ BUFSIZ ];
 276:     char        *printname;
 277: 
 278:     if ( !CGENNING )
 279:     return;
 280:     if ( other_flags & NREGVAR ) {
 281:     panic( "putLV regvar" );
 282:     }
 283:     switch ( whereis( offset , other_flags ) ) {
 284:     case GLOBALVAR:
 285:         if ( ( name != 0 ) ) {
 286:         if ( name[0] != '_' ) {
 287:             sprintf( extname , EXTFORMAT , name );
 288:             printname = extname;
 289:         } else {
 290:             printname = name;
 291:         }
 292:         putleaf( PCC_ICON , offset , 0 , PCCM_ADDTYPE( type , PCCTM_PTR )
 293:             , printname );
 294:         return;
 295:         } else {
 296:         panic( "putLV no name" );
 297:         }
 298:     case PARAMVAR:
 299:         if ( level == cbn ) {
 300:         putleaf( PCC_REG, 0, P2AP, PCCM_ADDTYPE( type , PCCTM_PTR ), (char *) 0 );
 301:         } else {
 302:         putleaf( PCC_NAME , (level * sizeof(struct dispsave)) + AP_OFFSET
 303:             , 0 , PCCTM_PTR | PCCT_CHAR , DISPLAYNAME );
 304:         parts[ level ] |= NONLOCALVAR;
 305:         }
 306:         putleaf( PCC_ICON , offset , 0 , PCCT_INT , (char *) 0 );
 307:         putop( PCC_PLUS , PCCTM_PTR | PCCT_CHAR );
 308:         break;
 309:     case LOCALVAR:
 310:         if ( level == cbn ) {
 311:         putleaf( PCC_REG, 0, P2FP, PCCM_ADDTYPE( type , PCCTM_PTR ), (char *) 0 );
 312:         } else {
 313:         putleaf( PCC_NAME , (level * sizeof(struct dispsave)) + FP_OFFSET
 314:             , 0 , PCCTM_PTR | PCCT_CHAR , DISPLAYNAME );
 315:         parts[ level ] |= NONLOCALVAR;
 316:         }
 317:         putleaf( PCC_ICON , -offset , 0 , PCCT_INT , (char *) 0 );
 318:         putop( PCC_MINUS , PCCTM_PTR | PCCT_CHAR );
 319:         break;
 320:     case NAMEDLOCALVAR:
 321:         if ( level == cbn ) {
 322:         putleaf( PCC_REG, 0, P2FP, PCCM_ADDTYPE( type , PCCTM_PTR ), (char *) 0 );
 323:         } else {
 324:         putleaf( PCC_NAME , (level * sizeof(struct dispsave)) + FP_OFFSET
 325:             , 0 , PCCTM_PTR | PCCT_CHAR , DISPLAYNAME );
 326:         parts[ level ] |= NONLOCALVAR;
 327:         }
 328:         putleaf( PCC_ICON , 0 , 0 , PCCT_INT , name );
 329:         putop( PCC_MINUS , PCCTM_PTR | PCCT_CHAR );
 330:         break;
 331:     }
 332:     return;
 333: }
 334: 
 335:     /*
 336:      *	put out a floating point constant leaf node
 337:      *	the constant is declared in aligned data space
 338:      *	and a PCC_NAME leaf put out for it
 339:      */
 340: putCON8( val )
 341:     double  val;
 342:     {
 343:     char    *label;
 344:     char    name[ BUFSIZ ];
 345: 
 346:     if ( !CGENNING )
 347:         return;
 348:     label = getlab();
 349:     putprintf( "	.data" , 0 );
 350:     aligndot(A_DOUBLE);
 351:     (void) putlab( label );
 352: #	ifdef vax
 353:         putprintf( "	.double 0d%.20e" , 0 , val );
 354: #	endif vax
 355: #	ifdef mc68000
 356:         putprintf( "	.long 	0x%x,0x%x", 0, val);
 357: #	endif mc68000
 358:     putprintf( "	.text" , 0 );
 359:     sprintf( name , PREFIXFORMAT , LABELPREFIX , label );
 360:     putleaf( PCC_NAME , 0 , 0 , PCCT_DOUBLE , name );
 361:     }
 362: 
 363:     /*
 364: 	 * put out either an lvalue or an rvalue for a constant string.
 365: 	 * an lvalue (for assignment rhs's) is the name as a constant,
 366: 	 * an rvalue (for parameters) is just the name.
 367: 	 */
 368: putCONG( string , length , required )
 369:     char    *string;
 370:     int     length;
 371:     int     required;
 372:     {
 373:     char    name[ BUFSIZ ];
 374:     char    *label;
 375:     char    *cp;
 376:     int pad;
 377:     int others;
 378: 
 379:     if ( !CGENNING )
 380:         return;
 381:     putprintf( "	.data" , 0 );
 382:     aligndot(A_STRUCT);
 383:     label = getlab();
 384:     (void) putlab( label );
 385:     cp = string;
 386:     while ( *cp ) {
 387:         putprintf( "	.byte	0%o" , 1 , *cp ++ );
 388:         for ( others = 2 ; ( others <= 8 ) && *cp ; others ++ ) {
 389:         putprintf( ",0%o" , 1 , *cp++ );
 390:         }
 391:         putprintf( "" , 0 );
 392:     }
 393:     pad = length - strlen( string );
 394:     while ( pad-- > 0 ) {
 395:         putprintf( "	.byte	0%o" , 1 , ' ' );
 396:         for ( others = 2 ; ( others <= 8 ) && ( pad-- > 0 ) ; others++ ) {
 397:         putprintf( ",0%o" , 1 , ' ' );
 398:         }
 399:         putprintf( "" , 0 );
 400:     }
 401:     putprintf( "	.byte	0" , 0 );
 402:     putprintf( "	.text"  , 0 );
 403:     sprintf( name , PREFIXFORMAT , LABELPREFIX , label );
 404:     if ( required == RREQ ) {
 405:         putleaf( PCC_NAME , 0 , 0 , PCCTM_ARY | PCCT_CHAR , name );
 406:     } else {
 407:         putleaf( PCC_ICON , 0 , 0 , PCCTM_PTR | PCCT_CHAR , name );
 408:     }
 409:     }
 410: 
 411:     /*
 412:      *	map a pascal type to a c type
 413:      *	this would be tail recursive, but i unfolded it into a for (;;).
 414:      *	this is sort of like isa and lwidth
 415:      *	a note on the types used by the portable c compiler:
 416:      *	    they are divided into a basic type (char, short, int, long, etc.)
 417:      *	    and qualifications on those basic types (pointer, function, array).
 418:      *	    the basic type is kept in the low 4 bits of the type descriptor,
 419:      *	    and the qualifications are arranged in two bit chunks, with the
 420:      *	    most significant on the right,
 421:      *	    and the least significant on the left
 422:      *		e.g. int *foo();
 423:      *			(a function returning a pointer to an integer)
 424:      *		is stored as
 425:      *		    <ptr><ftn><int>
 426:      *	so, we build types recursively
 427:      *	also, we know that /lib/f1 can only deal with 6 qualifications
 428:      *	so we stop the recursion there.  this stops infinite type recursion
 429:      *	through mutually recursive pointer types.
 430:      */
 431: #define MAXQUALS    6
 432: int
 433: p2type( np )
 434:     struct nl   *np;
 435: {
 436: 
 437:     return typerecur( np , 0 );
 438: }
 439: typerecur( np , quals )
 440:     struct nl   *np;
 441:     int     quals;
 442:     {
 443: 
 444:     if ( np == NIL || quals > MAXQUALS ) {
 445:         return PCCT_UNDEF;
 446:     }
 447:     switch ( np -> class ) {
 448:         case SCAL :
 449:         case RANGE :
 450:         case CRANGE :
 451:         if ( np -> type == ( nl + TDOUBLE ) ) {
 452:             return PCCT_DOUBLE;
 453:         }
 454:         switch ( bytes( np -> range[0] , np -> range[1] ) ) {
 455:             case 1:
 456:             return PCCT_CHAR;
 457:             case 2:
 458:             return PCCT_SHORT;
 459:             case 4:
 460:             return PCCT_INT;
 461:             default:
 462:             panic( "p2type int" );
 463:             /* NOTREACHED */
 464:         }
 465:         case STR :
 466:         return ( PCCTM_ARY | PCCT_CHAR );
 467:         case RECORD :
 468:         case SET :
 469:         return PCCT_STRTY;
 470:         case FILET :
 471:         return ( PCCTM_PTR | PCCT_STRTY );
 472:         case CONST :
 473:         case VAR :
 474:         case FIELD :
 475:         return p2type( np -> type );
 476:         case TYPE :
 477:         switch ( nloff( np ) ) {
 478:             case TNIL :
 479:             return ( PCCTM_PTR | PCCT_UNDEF );
 480:             case TSTR :
 481:             return ( PCCTM_ARY | PCCT_CHAR );
 482:             case TSET :
 483:             return PCCT_STRTY;
 484:             default :
 485:             return ( p2type( np -> type ) );
 486:         }
 487:         case REF:
 488:         case WITHPTR:
 489:         case PTR :
 490:         return PCCM_ADDTYPE( typerecur( np -> type , quals + 1 ) , PCCTM_PTR );
 491:         case ARRAY :
 492:         return PCCM_ADDTYPE( typerecur( np -> type , quals + 1 ) , PCCTM_ARY );
 493:         case FUNC :
 494:             /*
 495: 		     * functions are really pointers to functions
 496: 		     * which return their underlying type.
 497: 		     */
 498:         return PCCM_ADDTYPE( PCCM_ADDTYPE( typerecur( np -> type , quals + 2 ) ,
 499:                     PCCTM_FTN ) , PCCTM_PTR );
 500:         case PROC :
 501:             /*
 502: 		     * procedures are pointers to functions
 503: 		     * which return integers (whether you look at them or not)
 504: 		     */
 505:         return PCCM_ADDTYPE( PCCM_ADDTYPE( PCCT_INT , PCCTM_FTN ) , PCCTM_PTR );
 506:         case FFUNC :
 507:         case FPROC :
 508:             /*
 509: 		     *	formal procedures and functions are pointers
 510: 		     *	to structures which describe their environment.
 511: 		     */
 512:         return ( PCCTM_PTR | PCCT_STRTY );
 513:         default :
 514:         panic( "p2type" );
 515:         /* NOTREACHED */
 516:     }
 517:     }
 518: 
 519:     /*
 520:      *	put a typed operator to the pcstream
 521:      */
 522: putop( op , type )
 523:     int     op;
 524:     int     type;
 525:     {
 526:     extern char *p2opname();
 527: 
 528:     if ( !CGENNING )
 529:         return;
 530:     p2word( PCCM_TRIPLE( op , 0 , type ) );
 531: #	ifdef DEBUG
 532:         if ( opt( 'k' ) ) {
 533:         fprintf( stdout , "%s (%d) |   0 | 0x%x\n"
 534:             , p2opname( op ) , op , type );
 535:         }
 536: #	endif
 537:     }
 538: 
 539:     /*
 540:      *	put out a structure operator (STASG, STARG, STCALL, UNARY STCALL )
 541:      *	which looks just like a regular operator, only the size and
 542:      *	alignment go in the next consecutive words
 543:      */
 544: putstrop( op , type , size , alignment )
 545:     int op;
 546:     int type;
 547:     int size;
 548:     int alignment;
 549:     {
 550:     extern char *p2opname();
 551: 
 552:     if ( !CGENNING )
 553:         return;
 554:     p2word( PCCM_TRIPLE( op , 0 , type ) );
 555:     p2word( size );
 556:     p2word( alignment );
 557: #	ifdef DEBUG
 558:         if ( opt( 'k' ) ) {
 559:         fprintf( stdout , "%s (%d) |   0 | 0x%x	%d %d\n"
 560:             , p2opname( op ) , op , type , size , alignment );
 561:         }
 562: #	endif
 563:     }
 564: 
 565:     /*
 566:      *	the string names of p2ops
 567:      */
 568: 
 569: struct p2op {
 570:     int op;
 571:     char *name;
 572: };
 573: 
 574: static struct p2op  p2opnames[] = {
 575:     PCC_ERROR, "PCC_ERROR",
 576:     PCC_NAME, "PCC_NAME",
 577:     PCC_STRING, "PCC_STRING",
 578:     PCC_ICON, "PCC_ICON",
 579:     PCC_FCON, "PCC_FCON",
 580:     PCC_PLUS, "PCC_PLUS",
 581:     PCC_MINUS, "PCC_MINUS",
 582:     PCC_UMINUS, "PCC_UMINUS",
 583:     PCC_MUL, "PCC_MUL",
 584:     PCC_DEREF, "PCC_DEREF",
 585:     PCC_AND, "PCC_AND",
 586:     PCC_ADDROF, "PCC_ADDROF",
 587:     PCC_OR, "PCC_OR",
 588:     PCC_ER, "PCC_ER",
 589:     PCC_QUEST, "PCC_QUEST",
 590:     PCC_COLON, "PCC_COLON",
 591:     PCC_ANDAND, "PCC_ANDAND",
 592:     PCC_OROR, "PCC_OROR",
 593:     PCC_CM, "PCC_CM",
 594:     PCC_ASSIGN, "PCC_ASSIGN",
 595:     PCC_COMOP, "PCC_COMOP",
 596:     PCC_DIV, "PCC_DIV",
 597:     PCC_MOD, "PCC_MOD",
 598:     PCC_LS, "PCC_LS",
 599:     PCC_RS, "PCC_RS",
 600:     PCC_DOT, "PCC_DOT",
 601:     PCC_STREF, "PCC_STREF",
 602:     PCC_CALL, "PCC_CALL",
 603:     PCC_UCALL, "PCC_UCALL",
 604:     PCC_FORTCALL, "PCC_FORTCALL",
 605:     PCC_UFORTCALL, "PCC_UFORTCALL",
 606:     PCC_NOT, "PCC_NOT",
 607:     PCC_COMPL, "PCC_COMPL",
 608:     PCC_INCR, "PCC_INCR",
 609:     PCC_DECR, "PCC_DECR",
 610:     PCC_EQ, "PCC_EQ",
 611:     PCC_NE, "PCC_NE",
 612:     PCC_LE, "PCC_LE",
 613:     PCC_LT, "PCC_LT",
 614:     PCC_GE, "PCC_GE",
 615:     PCC_GT, "PCC_GT",
 616:     PCC_ULE, "PCC_ULE",
 617:     PCC_ULT, "PCC_ULT",
 618:     PCC_UGE, "PCC_UGE",
 619:     PCC_UGT, "PCC_UGT",
 620:     PCC_REG, "PCC_REG",
 621:     PCC_OREG, "PCC_OREG",
 622:     PCC_CCODES, "PCC_CCODES",
 623:     PCC_FREE, "PCC_FREE",
 624:     PCC_STASG, "PCC_STASG",
 625:     PCC_STARG, "PCC_STARG",
 626:     PCC_STCALL, "PCC_STCALL",
 627:     PCC_USTCALL, "PCC_USTCALL",
 628:     PCC_FLD, "PCC_FLD",
 629:     PCC_SCONV, "PCC_SCONV",
 630:     PCC_PCONV, "PCC_PCONV",
 631:     PCC_PMCONV, "PCC_PMCONV",
 632:     PCC_PVCONV, "PCC_PVCONV",
 633:     PCC_FORCE, "PCC_FORCE",
 634:     PCC_CBRANCH, "PCC_CBRANCH",
 635:     PCC_INIT, "PCC_INIT",
 636:     PCC_CAST, "PCC_CAST",
 637:     -1, ""
 638:     };
 639: 
 640: char *
 641: p2opname( op )
 642:     register int    op;
 643:     {
 644:     static char     *p2map[PCC_MAXOP+1];
 645:     static bool     mapready = FALSE;
 646:     register struct p2op    *pp;
 647: 
 648:     if ( mapready == FALSE ) {
 649:         for ( pp = p2opnames; pp->op >= 0; pp++ )
 650:         p2map[ pp->op ] = pp->name;
 651:         mapready = TRUE;
 652:     }
 653:     return ( p2map[ op ] ? p2map[ op ] : "unknown" );
 654:     }
 655: 
 656:     /*
 657:      *	low level routines
 658:      */
 659: 
 660:     /*
 661:      *	puts a long word on the pcstream
 662:      */
 663: p2word( word )
 664:     int     word;
 665:     {
 666: 
 667:     putw( word , pcstream );
 668:     }
 669: 
 670:     /*
 671:      *	put a length 0 mod 4 null padded string onto the pcstream
 672:      */
 673: p2string( string )
 674:     char    *string;
 675:     {
 676:     int slen = strlen( string );
 677:     int wlen = ( slen + 3 ) / 4;
 678:     int plen = ( wlen * 4 ) - slen;
 679:     char    *cp;
 680:     int p;
 681: 
 682:     for ( cp = string ; *cp ; cp++ )
 683:         putc( *cp , pcstream );
 684:     for ( p = 1 ; p <= plen ; p++ )
 685:         putc( '\0' , pcstream );
 686: #	ifdef DEBUG
 687:         if ( opt( 'k' ) ) {
 688:         fprintf( stdout , "\"%s" , string );
 689:         for ( p = 1 ; p <= plen ; p++ )
 690:             fprintf( stdout , "\\0" );
 691:         fprintf( stdout , "\"\n" );
 692:         }
 693: #	endif
 694:     }
 695: 
 696:     /*
 697:      *	puts a name on the pcstream
 698:      */
 699: p2name( name )
 700:     char    *name;
 701:     {
 702:     int pad;
 703: 
 704:     fprintf( pcstream , NAMEFORMAT , name );
 705:     pad = strlen( name ) % sizeof (long);
 706:     for ( ; pad < sizeof (long) ; pad++ ) {
 707:         putc( '\0' , pcstream );
 708:     }
 709: #	ifdef DEBUG
 710:         if ( opt( 'k' ) ) {
 711:         fprintf( stdout , NAMEFORMAT , name );
 712:         pad = strlen( name ) % sizeof (long);
 713:         for ( ; pad < sizeof (long) ; pad++ ) {
 714:             fprintf( stdout , "\\0" );
 715:         }
 716:         fprintf( stdout , "\n" );
 717:         }
 718: #	endif
 719:     }
 720: 
 721:     /*
 722:      *	put out a jump to a label
 723:      */
 724: putjbr( label )
 725:     long    label;
 726:     {
 727: 
 728:     printjbr( LABELPREFIX , label );
 729:     }
 730: 
 731:     /*
 732:      *	put out a jump to any kind of label
 733:      */
 734: printjbr( prefix , label )
 735:     char    *prefix;
 736:     long    label;
 737:     {
 738: 
 739: #	ifdef vax
 740:         putprintf( "	jbr	" , 1 );
 741:         putprintf( PREFIXFORMAT , 0 , prefix , label );
 742: #	endif vax
 743: #	ifdef mc68000
 744:         putprintf( "	jra	" , 1 );
 745:         putprintf( PREFIXFORMAT , 0 , prefix , label );
 746: #	endif mc68000
 747:     }
 748: 
 749:     /*
 750:      *	another version of put to catch calls to put
 751:      */
 752: /* VARARGS */
 753: put()
 754:     {
 755: 
 756:     panic("put()");
 757:     }
 758: 
 759: #endif PC

Defined functions

Defined variables

Defined struct's

Defined macros