![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to p2put.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src|
Return to p2put.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src |
1.1 ! root 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
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.