![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ld.lex CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / ld|
Return to ld.lex CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / ld |
1.1 ! root 1: %{ ! 2: static char ID[] = "@(#) ld.lex: 1.10 12/1/83"; ! 3: #include "system.h" ! 4: #include <stdio.h> ! 5: #include <signal.h> ! 6: #include "bool.h" ! 7: #include "paths.h" ! 8: #include "sgs.h" ! 9: #include "structs.h" /* global structure definitions */ ! 10: #include "extrns.h" /* external function definitions */ ! 11: #include "y.tab.h" /* tokens generated by yacc */ ! 12: ! 13: #if !ONEPROC || TRVEC ! 14: #include "tv.h" ! 15: #include "ldtv.h" ! 16: #endif ! 17: ! 18: #include "aouthdr.h" ! 19: #if ONEPROC ! 20: #include "instr.h" ! 21: #endif ! 22: ! 23: extern char version[]; /* ld version information */ ! 24: ! 25: /* ! 26: * There are four start states for the lex parse: ! 27: * ! 28: * A : look for initial keyword of a ld directive ! 29: * MEMoREG : scan a ld directive ! 30: * COMA : skip a stand-alone comment ! 31: * COMoMR : skip a comment at the end of a directive ! 32: */ ! 33: ! 34: #define RET1(a) {yylval.ivalue=a;moveit(1,a);return(a);} ! 35: #define RET2(a,b) {yylval.sptr=a;moveit(2,yylval.sptr);return(b);} ! 36: #define RET3(a,b) {yylval.lptr=a;moveit(3,yylval.lptr);return(b);} ! 37: ! 38: ! 39: ! 40: #define LSAVSIZE 6 ! 41: static long lsavarea[LSAVSIZE]; /* local save area for integer tokens */ ! 42: static int lsavndx = 0; ! 43: extern long *savelng(); ! 44: ! 45: #define CSAVSIZE 1024 ! 46: static char csavarea[CSAVSIZE]; /* local save area for string tokens */ ! 47: static char *csavptr = &csavarea[0]; ! 48: extern char *savestr(); ! 49: ! 50: char inline[256]; /* global save area for the current input line */ ! 51: char *inptr = &inline[0]; ! 52: ! 53: char **argptr; /* main procedure argument list */ ! 54: int argcnt; /* and count */ ! 55: ! 56: ! 57: extern int in_y_exp; /* in_y_exp : ! 58: * TRUE : yacc is parsing assignment ! 59: * FALSE : yacc is not in assignment ! 60: * ! 61: * See explanation is ld.yac. ! 62: */ ! 63: ! 64: int assigncnt; /* number of assignment slots */ ! 65: ! 66: ! 67: #if FLEXNAMES ! 68: # define STRBASE 6144 ! 69: #else ! 70: # define STRBASE 3072 ! 71: #endif ! 72: /*eject*/ ! 73: %} ! 74: %start A MEMoREG COMA COMoMR ! 75: %% ! 76: %{ ! 77: long longint; /* local variables used in processing */ ! 78: char *p; /* numbers and strings */ ! 79: %} ! 80: ! 81: <A>"/*" BEGIN COMA; ! 82: <MEMoREG>"/*" BEGIN COMoMR; ! 83: <COMA>"*/" BEGIN A; ! 84: <COMoMR>"*/" BEGIN MEMoREG; ! 85: <COMA,COMoMR>. ; ! 86: ! 87: <A>MEMORY { BEGIN MEMoREG; RET1(MEMORY); } ! 88: <A>REGIONS { BEGIN MEMoREG; RET1(REGIONS); } ! 89: <A>TV { BEGIN MEMoREG; RET1(TV); } ! 90: ! 91: <A>SECTIONS RET1(SECTIONS); ! 92: <A>DSECT RET1(DSECT); ! 93: <A>NOLOAD RET1(NOLOAD); ! 94: <A>COPY RET1(COPY); ! 95: <A>INFO RET1(INFO); ! 96: ! 97: <MEMoREG>"}" { BEGIN A; RET1(RBRACE); } ! 98: <MEMoREG>ORIGIN|origin|org|o RET1(ORG); ! 99: <MEMoREG>LENGTH|length|len|l RET1(LEN); ! 100: <MEMoREG>SPARE|spare|s RET1(SPARE); ! 101: <MEMoREG>RANGE|range RET1(RANGE); ! 102: <MEMoREG>ASSIGN|assign RET1(ASSIGN); ! 103: ! 104: <A,MEMoREG>"." RET1(DOT); ! 105: <A,MEMoREG>"}" RET1(RBRACE); ! 106: <A,MEMoREG>"{" RET1(LBRACE); ! 107: <A,MEMoREG>")" RET1(RPAREN); ! 108: <A,MEMoREG>"(" RET1(LPAREN); ! 109: <A,MEMoREG>":" RET1(COLON); ! 110: <A,MEMoREG>";" RET1(SEMICOL); ! 111: <A,MEMoREG>"-" RET1(MINUS); ! 112: <A,MEMoREG>"=" RET1(EQ); ! 113: <A,MEMoREG>">" RET1(GT); ! 114: <A,MEMoREG>"," RET1(COMMA); ! 115: <A,MEMoREG>"&" RET1(AND); ! 116: <A,MEMoREG>"&&" RET1(ANDAND); ! 117: <A,MEMoREG>"|" RET1(OR); ! 118: <A,MEMoREG>"||" RET1(OROR); ! 119: <A,MEMoREG>"==" RET1(EQEQ); ! 120: <A,MEMoREG>"!=" RET1(NE); ! 121: <A,MEMoREG>"~" RET1(BNOT); ! 122: <A,MEMoREG>"!" RET1(NOT); ! 123: <A,MEMoREG>"/" RET1(DIV); ! 124: <A,MEMoREG>"*" RET1(MULT); ! 125: <A,MEMoREG>"%" RET1(PC); ! 126: <A,MEMoREG>"<" RET1(LT); ! 127: <A,MEMoREG>">=" RET1(GE); ! 128: <A,MEMoREG>"<=" RET1(LE); ! 129: <A,MEMoREG>"<<" RET1(LSHIFT); ! 130: <A,MEMoREG>">>" RET1(RSHIFT); ! 131: <A,MEMoREG>"+" RET1(PLUS); ! 132: <A,MEMoREG>"+=" RET1(PLUSEQ); ! 133: <A,MEMoREG>"-=" RET1(MINUSEQ); ! 134: <A,MEMoREG>"*=" RET1(MULTEQ); ! 135: <A,MEMoREG>"/=" RET1(DIVEQ); ! 136: <A,MEMoREG>ALIGN|align RET1(ALIGN); ! 137: <A,MEMoREG>BLOCK|block RET1(BLOCK); ! 138: <A,MEMoREG>GROUP|group RET1(GROUP); ! 139: <A,MEMoREG>PHY|phy RET1(PHY); ! 140: ! 141: ! 142: "\n" { ! 143: lineno++; ! 144: inptr = &inline[0]; ! 145: } ! 146: [ \t]+ { ! 147: *inptr++ = ' '; ! 148: *inptr = '\0'; ! 149: } ! 150: ! 151: ! 152: <A,MEMoREG>[0][0-7]* { ! 153: longint = 0L; ! 154: for(p=yytext+1; *p != '\0'; p++) { ! 155: longint = longint * 8 + (*p-'0'); ! 156: } ! 157: RET3(savelng(longint), LONGINT); ! 158: } ! 159: <A,MEMoREG>[0-9]+ { ! 160: longint = 0L; ! 161: for(p=yytext; *p != '\0'; p++) { ! 162: longint = longint * 10 + (*p-'0'); ! 163: } ! 164: RET3(savelng(longint), LONGINT); ! 165: } ! 166: <A,MEMoREG>0[Xx][0-9a-fA-F]+ { ! 167: longint = 0L; ! 168: for(p=yytext+2; *p != '\0'; p++) { ! 169: longint = longint << 4; ! 170: if (*p >= '0' && *p <= '9') ! 171: longint += *p-'0'; ! 172: else if (*p >= 'a' && *p <= 'f') ! 173: longint += *p-'a'+10; ! 174: else longint += *p-'A'+10; ! 175: } ! 176: RET3(savelng(longint), LONGINT); ! 177: } ! 178: ! 179: <A,MEMoREG>[a-zA-Z0-9$._]+"/"("*"|"=") { ! 180: yyless(yyleng-2); ! 181: RET2(savestr(yytext), NAME); ! 182: } ! 183: ! 184: <A,MEMoREG>[a-zA-Z0-9$._/]+"/"("*"|"=") { ! 185: if ( in_y_exp ) ! 186: REJECT; ! 187: yyless(yyleng-2); ! 188: RET2(savestr(yytext), FILENAME); ! 189: } ! 190: ! 191: <A,MEMoREG>[a-zA-Z0-9$._]+ { ! 192: RET2(savestr(yytext), NAME); ! 193: } ! 194: ! 195: <A,MEMoREG>[a-zA-Z0-9$._/]+ { ! 196: if ( in_y_exp ) ! 197: REJECT; ! 198: RET2(savestr(yytext), FILENAME); ! 199: } ! 200: %% ! 201: /*eject*/ ! 202: main(argc,argv) ! 203: int argc; ! 204: char *argv[]; ! 205: { ! 206: ! 207: /* ! 208: * This is the MAIN procdure for PASS 1 of ld ! 209: * ! 210: * PASS 1 is the parsing pass: ! 211: * 1. The ld command line, and any specified ifiles, are ! 212: * scanned for good syntax. ! 213: * 2. Control blocks are constructed, containing the information ! 214: * extracted from the input. ! 215: * 3. If there are no errors, the control blocks are written out ! 216: * to a "transfer file", for reading by PASS 2. ! 217: * 4. If there are no errors, PASS 2 is called via a system ! 218: * "execl" call. ! 219: */ ! 220: ! 221: /* ! 222: * Initialize PASS 1 ! 223: */ ! 224: ! 225: initpass1(); ! 226: argptr = argv; ! 227: argcnt = argc; ! 228: if ( argcnt <= 1 ) ! 229: { ! 230: fprintf( stderr, "Usage: %sld [ options ] file ...\n", SGS ); ! 231: exit(1); ! 232: } ! 233: ! 234: /* ! 235: * Process the command-line arguments to ld ! 236: */ ! 237: ! 238: lineno = 0; ! 239: curfilnm = savefn("*command line*"); ! 240: ! 241: while( --argcnt ) ! 242: if( **++argptr == '-' ) ! 243: /* ! 244: * The argument is a flag ! 245: */ ! 246: pflags( ++(*argptr), FALSE ); ! 247: else { ! 248: /* ! 249: * The argument is a file name ! 250: */ ! 251: BEGIN A; ! 252: filespec(*argptr); ! 253: } ! 254: ! 255: /* ! 256: * Perform a consistency check among the ld flags: ! 257: * 1. "-h" and "-X" flags ! 258: * 2. "-ild", "-r", and "-a" flags ! 259: * 3. "-r" and "-s" flags ! 260: * 4. "-p" and "-B" flags ! 261: * ! 262: * Assign default values to the ld flags ! 263: * 1. "-h" flag ! 264: * 2. "-a" flag ! 265: * 3. "-p" flag ! 266: */ ! 267: ! 268: if( Xflag ) ! 269: if( hflag > 0 ) { ! 270: if( hflag < sizeof(AOUTHDR) ) ! 271: lderror(1, 0,NULL, "optional header size (%d bytes) is too small to contain the UNIX a.out header (%d bytes)", ! 272: hflag, sizeof(AOUTHDR) ); ! 273: } ! 274: else ! 275: hflag = sizeof(AOUTHDR); ! 276: #if ILDOPT ! 277: if (ildflag) { ! 278: rflag = 1; ! 279: if (sflag) { ! 280: lderror (0, 0, NULL, "both -ild and -s flags are set. -s flag turned off"); ! 281: sflag = 0; ! 282: } ! 283: } ! 284: #endif ! 285: if( rflag && sflag ) { ! 286: lderror(0, 0,NULL, "both -r and -s flags are set. -s flag turned off" ); ! 287: sflag = 0; ! 288: } ! 289: if ( Bflag && (pflag > 0) && (pflag < Bflag)) { ! 290: lderror(0, 0, NULL, "pflag(%d) less than Bflag, set to value of Bflag(%d)\n", ! 291: pflag, Bflag); ! 292: pflag = Bflag; ! 293: } ! 294: if( ! rflag ) ! 295: aflag = 1; ! 296: ! 297: /* ! 298: * Supply version information ! 299: */ ! 300: ! 301: if( Vflag ) { ! 302: fprintf( stderr, "\n%sld : %s : Version %s", ! 303: SGSNAME, RELEASE, version ); ! 304: if( Vflag == 2 ) { ! 305: #if AR16WR ! 306: fprintf( stderr, " : PDP 11/70-45 : " ); ! 307: #endif ! 308: #if AR32WR ! 309: fprintf( stderr, " : VAX 11/780 : " ); ! 310: #endif ! 311: #if ! AR16WR && ! AR32WR ! 312: #ifdef u3b ! 313: fprintf( stderr, " : 3B-20 : " ); ! 314: #else ! 315: fprintf( stderr, " : non-DEC : "); ! 316: #endif ! 317: #endif ! 318: #if TS ! 319: fprintf( stderr, "UN*X TS" ); ! 320: #else ! 321: fprintf( stderr, "UN*X" ); ! 322: #endif ! 323: } ! 324: fprintf( stderr, "\n" ); ! 325: } ! 326: ! 327: /* ! 328: * Exit if any errors were found, or if this is a "parse only" ! 329: * run ! 330: */ ! 331: ! 332: if( (errlev != 0) || (cflag == 1) ) { ! 333: #if !ONEPROC ! 334: unlink( trnname ); ! 335: #endif ! 336: exit(errlev); ! 337: } ! 338: ! 339: /* ! 340: * Call PASS 2 ! 341: */ ! 342: ! 343: #if ONEPROC ! 344: pass2(); ! 345: } ! 346: #else ! 347: callpass2(); ! 348: ! 349: unlink( trnname ); ! 350: lderror(2, 0,NULL, "failure to load pass 2 of %sld", SGS); ! 351: } ! 352: /*eject*/ ! 353: ldexit() ! 354: { ! 355: ! 356: /* ! 357: * PASS 1: clean up and exit after a fatal error ! 358: */ ! 359: ! 360: signal(SIGINT, SIG_IGN); ! 361: signal(SIGQUIT, SIG_DFL); ! 362: signal(SIGTERM, SIG_IGN); ! 363: signal(SIGHUP, SIG_DFL); ! 364: ! 365: exit(13); /* unlucky break */ ! 366: } ! 367: /*eject*/ ! 368: #endif ! 369: long * ! 370: savelng(l) ! 371: long l; ! 372: { ! 373: ! 374: /* ! 375: * Copy a long token into local save area and return a pointer to it. ! 376: * ! 377: * The save area is used as a circular buffer ! 378: */ ! 379: ! 380: lsavndx++; ! 381: lsavndx %= LSAVSIZE; ! 382: lsavarea[lsavndx] = l; ! 383: ! 384: return( &lsavarea[lsavndx] ); ! 385: } ! 386: ! 387: ! 388: ! 389: ! 390: char * ! 391: savestr(p) ! 392: char *p; ! 393: { ! 394: ! 395: /* ! 396: * Copy a string into local save area and return a pointer to it ! 397: * ! 398: * The save area is used as a circular buffer ! 399: */ ! 400: ! 401: register char *saveptr; ! 402: ! 403: if( csavptr > (csavarea + CSAVSIZE - 256) ) ! 404: csavptr = csavarea; ! 405: saveptr = csavptr; ! 406: ! 407: while( *csavptr++ = *p++ ); ! 408: ! 409: return( saveptr ); ! 410: } ! 411: ! 412: ! 413: ! 414: ! 415: moveit(type, value) ! 416: int type, value; ! 417: { ! 418: register char *p; ! 419: ! 420: p = &yytext[0]; ! 421: ! 422: while( *inptr++ = *p++ ); ! 423: inptr--; ! 424: ! 425: #if DEBUG ! 426: if( dflag > 3 ) { ! 427: fprintf(stderr, "line: <%s> return: <", inline); ! 428: switch( type ) { ! 429: case 1: ! 430: fprintf(stderr, "%d>\n", value); ! 431: break; ! 432: case 2: ! 433: fprintf(stderr, "%s>\n", (char *) value); ! 434: break; ! 435: case 3: ! 436: fprintf(stderr, "%08lx>\n", * (long *) value); ! 437: break; ! 438: } ! 439: } ! 440: #endif ! 441: } ! 442: /*eject*/ ! 443: initpass1() ! 444: { ! 445: register int oldmode; ! 446: int ldexit(); ! 447: #if ONEPROC ! 448: long times(); ! 449: #endif ! 450: ! 451: /* ! 452: * Set the following signals to be caught, unless ld is running in the ! 453: * background. In this case, leave them set at "ignore" ! 454: */ ! 455: ! 456: if( signal(SIGINT, ldexit) == SIG_IGN ) ! 457: signal(SIGINT, SIG_IGN); ! 458: if( signal(SIGHUP, ldexit) == SIG_IGN ) ! 459: signal(SIGHUP, SIG_IGN); ! 460: if( signal(SIGQUIT, ldexit) == SIG_IGN ) ! 461: signal(SIGQUIT, SIG_IGN); ! 462: ! 463: ! 464: #if ONEPROC ! 465: ttime = times(&ptimes); ! 466: #else ! 467: /* ! 468: * Create the "transfer file" used to pass information to PASS 2 ! 469: */ ! 470: ! 471: sprintf(trnname, "%s/%s", TMPDIR, "ldXXXXX"); ! 472: mktemp(trnname); ! 473: ! 474: oldmode = umask( 0 ); ! 475: if( close( creat(trnname,0644) ) == -1 ) { ! 476: umask( oldmode ); ! 477: lderror(2, 0,NULL, "can't create intermediate %sld file %s", ! 478: SGS, trnname); ! 479: } ! 480: umask( oldmode ); ! 481: #endif ! 482: ! 483: /* ! 484: * Allocate the global file name save area ! 485: */ ! 486: ! 487: strbase = myalloc(STRBASE); ! 488: strnext = strbase; ! 489: strlimit = strbase + STRBASE; ! 490: ! 491: #if ONEPROC && (!NOSDP) ! 492: /* ! 493: * Initialize the Software Demand Paging System ! 494: */ ! 495: syminit(); ! 496: #endif ! 497: } ! 498: /*eject*/ ! 499: #if !ONEPROC ! 500: callpass2() ! 501: { ! 502: ! 503: /* ! 504: * Output PASS 1 information to the "transfer file" ! 505: * ! 506: * 1. reserve space for flags and list headers ! 507: * 2. output lists ! 508: * 3. output flags and list headers ! 509: */ ! 510: ! 511: trnfdes = fopen(trnname, "w"); ! 512: skp_tf_hdr(); ! 513: wrt_tf(); ! 514: wrt_tf_hdr(); ! 515: fclose( trnfdes ); ! 516: ! 517: /* ! 518: * Exit, if this is a "generate transfer file run" only ! 519: */ ! 520: ! 521: if( cflag == 2 ) { ! 522: fprintf( stderr, "ld transfer file name: %s\n", trnname ); ! 523: exit(0); ! 524: } ! 525: #if DEBUG ! 526: if( dflag > 2 ) ! 527: fprintf( stderr, "ld transfer file name: %s\n", trnname ); ! 528: #endif ! 529: ! 530: /* ! 531: * Execute PASS 2 ! 532: */ ! 533: ! 534: execl(LD2, LD2, trnname, 0); ! 535: ! 536: } ! 537: /*eject*/ ! 538: skp_tf_hdr() ! 539: { ! 540: ! 541: /* ! 542: * Reserve space for control and descriptor information collected during ! 543: * PASS 1 ! 544: * ! 545: * This information is of fixed length, and comes at the very beginning ! 546: * of the transfer file ! 547: */ ! 548: ! 549: register long length; ! 550: ! 551: length = ! 552: 7 * sizeof(int) + /* list sizes */ ! 553: 13 * sizeof(char) + /* flags */ ! 554: #if UNIX || XL ! 555: 1 * sizeof(char) + /* xflag */ ! 556: #endif ! 557: #if ILDOPT ! 558: 1 * sizeof(char) + /* ildflag */ ! 559: #endif ! 560: #if PAGING ! 561: 1 * sizeof(char) + /* Fflag */ ! 562: #endif ! 563: #if PAGING ! 564: 1 * sizeof(char) + /* zflag */ ! 565: #endif ! 566: #if COMMON ! 567: 2 * sizeof(char) + /* tflag and Mflag */ ! 568: #endif ! 569: 3 * sizeof(int) + /* control values */ ! 570: 3 * sizeof(short) + /* VStamp, fill and magic */ ! 571: 128 + /* output file name */ ! 572: 8 + /* program entry pt */ ! 573: sizeof(TVINFO) + /* tv information */ ! 574: 1 * sizeof(int); /* flags + counts */ ! 575: ! 576: fseek( trnfdes, length, 0 ); ! 577: } ! 578: /*eject*/ ! 579: wrt_tf() ! 580: { ! 581: ! 582: /* ! 583: * Output the bulk of the information extracted from PASS 1: ! 584: * ! 585: * 1. The names of input ifiles, input *.o and archive files, and ! 586: * output sections ! 587: * 2. The data structures describing the ld directives ! 588: */ ! 589: ! 590: MEMTYPE *outds1(); ! 591: REGION *outds2(); ! 592: ACTITEM *outds3(), *outds4(), *outds6(); ! 593: TVASSIGN *outds8(); ! 594: ! 595: /* ! 596: * 1. Output saved strings ! 597: */ ! 598: ! 599: fwrite( strbase, 1, (strnext - strbase), trnfdes ); ! 600: ! 601: ! 602: /* ! 603: * 2a. Output DEFSYM data structures ! 604: */ ! 605: ! 606: symcnt = 0; ! 607: if( symlist.head ) { ! 608: register ACTITEM *a; ! 609: a = (ACTITEM *) symlist.head; ! 610: while( a ) { ! 611: a = outds3(a); ! 612: symcnt++; ! 613: } ! 614: } ! 615: ! 616: /* ! 617: * 2b. Output MEMTYPE data structures ! 618: */ ! 619: ! 620: memcnt = 0; ! 621: if( memlist.head ) { ! 622: register MEMTYPE *m; ! 623: m = (MEMTYPE *) memlist.head; ! 624: while( m ) { ! 625: m = outds1(m); ! 626: memcnt++; ! 627: } ! 628: } ! 629: ! 630: /* ! 631: * 2c. Output REGION data structures ! 632: */ ! 633: ! 634: regcnt = 0; ! 635: if( reglist.head ) { ! 636: register REGION *r; ! 637: r = (REGION *) reglist.head; ! 638: while( r ) { ! 639: r = outds2(r); ! 640: regcnt++; ! 641: } ! 642: } ! 643: ! 644: /* ! 645: * 2d. Output information on input *.o and archive library files ! 646: */ ! 647: ! 648: ldfcnt = 0; ! 649: if( ldfilist.head ) { ! 650: register ACTITEM *a; ! 651: a = (ACTITEM *) ldfilist.head; ! 652: while( a ) { ! 653: a = outds3(a); ! 654: ldfcnt++; ! 655: } ! 656: } ! 657: ! 658: ! 659: /* ! 660: * 2e. Output information on output sections ! 661: */ ! 662: ! 663: bldcnt = 0; ! 664: if( bldoutsc.head ) { ! 665: register ACTITEM *a; ! 666: a = (ACTITEM *) bldoutsc.head; ! 667: while( a ) { ! 668: a = outds4(a); ! 669: bldcnt++; ! 670: } ! 671: } ! 672: ! 673: ! 674: /* ! 675: * 2f. Output information on assignments ! 676: */ ! 677: ! 678: expcnt = 0; ! 679: if( explist.head ) { ! 680: register ACTITEM *a; ! 681: a = (ACTITEM *) explist.head; ! 682: while( a ) { ! 683: a = outds6(a); ! 684: expcnt++; ! 685: } ! 686: } ! 687: ! 688: /* ! 689: * 2g. Output information on slot assignments ! 690: */ ! 691: ! 692: tvslotcnt = 0; ! 693: if (tvslot1 != NULL) { ! 694: register TVASSIGN *s; ! 695: s = tvslot1; ! 696: while (s != NULL) { ! 697: s = outds8(s); ! 698: ++tvslotcnt; ! 699: } ! 700: } ! 701: } ! 702: /*eject*/ ! 703: wrt_tf_hdr() ! 704: { ! 705: ! 706: /* ! 707: * Output control and descriptor information obtained during PASS 1 ! 708: * ! 709: * This information is of fixed length, and comes at the very beginning ! 710: * of the transfer file ! 711: */ ! 712: ! 713: int length; ! 714: ! 715: fseek( trnfdes, 0L, 0 ); ! 716: ! 717: /* ! 718: * Output the sizes of the lists built during PASS 1 ! 719: * ! 720: * 1. symbol definition/undefinition ! 721: * 2. MEMORY directives ! 722: * 3. REGIONS directives ! 723: * 4. input *.o and archive library files ! 724: * 5. output sections ! 725: * 6. assignment directives ! 726: * 7. tv slot assignment directives ! 727: */ ! 728: ! 729: fwrite( &symcnt, sizeof(int), 1, trnfdes ); ! 730: fwrite( &memcnt, sizeof(int), 1, trnfdes ); ! 731: fwrite( ®cnt, sizeof(int), 1, trnfdes ); ! 732: fwrite( &ldfcnt, sizeof(int), 1, trnfdes ); ! 733: fwrite( &bldcnt, sizeof(int), 1, trnfdes ); ! 734: fwrite( &expcnt, sizeof(int), 1, trnfdes ); ! 735: fwrite(&tvslotcnt, sizeof(int), 1, trnfdes); ! 736: ! 737: /* ! 738: * Output the ld control flags ! 739: */ ! 740: ! 741: fwrite( &aflag, sizeof(char), 1, trnfdes ); ! 742: fwrite( &cflag, sizeof(char), 1, trnfdes ); ! 743: fwrite( &dflag, sizeof(char), 1, trnfdes ); ! 744: fwrite( &iflag, sizeof(char), 1, trnfdes ); ! 745: fwrite( &mflag, sizeof(char), 1, trnfdes ); ! 746: fwrite( &rflag, sizeof(char), 1, trnfdes ); ! 747: fwrite( &sflag, sizeof(char), 1, trnfdes ); ! 748: fwrite( &tvflag, sizeof(char), 1, trnfdes ); ! 749: fwrite( &Hflag, sizeof(char), 1, trnfdes ); ! 750: fwrite( &Nflag, sizeof(char), 1, trnfdes ); ! 751: fwrite( &Sflag, sizeof(char), 1, trnfdes ); ! 752: fwrite( &Vflag, sizeof(char), 1, trnfdes ); ! 753: fwrite( &Xflag, sizeof(char), 1, trnfdes ); ! 754: fwrite( &hflag, sizeof(int), 1, trnfdes ); ! 755: fwrite( &pflag, sizeof(int), 1, trnfdes ); ! 756: fwrite( &Bflag, sizeof(int), 1, trnfdes ); ! 757: fwrite( &VSflag, sizeof(short), 1, trnfdes); ! 758: #if UNIX || XL ! 759: fwrite( &xflag, sizeof(char), 1, trnfdes ); ! 760: #endif ! 761: #if COMMON ! 762: fwrite( &tflag, sizeof(char), 1, trnfdes ); ! 763: fwrite( &Mflag, sizeof(char), 1, trnfdes ); ! 764: #endif ! 765: #if PAGING ! 766: fwrite( &Fflag, sizeof(char), 1, trnfdes ); ! 767: #endif ! 768: #if PAGING ! 769: fwrite( &zflag, sizeof(char), 1, trnfdes ); ! 770: #endif ! 771: #if ILDOPT ! 772: fwrite( &ildflag, sizeof(char), 1, trnfdes ); ! 773: #endif ! 774: ! 775: /* ! 776: * Output various values extracted from the parse ! 777: */ ! 778: ! 779: fwrite( &globfill, sizeof(short), 1, trnfdes ); ! 780: fwrite( &magic, sizeof(unsigned short), 1, trnfdes ); ! 781: ! 782: fwrite( outfilnm, 128, 1, trnfdes ); ! 783: fwrite( epsymbol, 8, 1, trnfdes ); ! 784: ! 785: /* convert filename from ptr to index */ ! 786: if (tvspec.tvinflnm != NULL) ! 787: tvspec.tvinflnm = (char *) ((int) tvspec.tvinflnm - (int) strbase); ! 788: fwrite( &tvspec, sizeof(TVINFO), 1, trnfdes ); ! 789: ! 790: /* ! 791: * Output the size of the saved strings ! 792: */ ! 793: ! 794: length = strnext - strbase; ! 795: fwrite( &length, sizeof(int), 1, trnfdes ); ! 796: } ! 797: /*eject*/ ! 798: MEMTYPE * ! 799: outds1(m) ! 800: MEMTYPE *m; ! 801: { ! 802: ! 803: /* ! 804: * Output one MEMTYPE data structure ! 805: */ ! 806: ! 807: fwrite( m, 1, sizeof(MEMTYPE), trnfdes ); ! 808: ! 809: return( m->mtnext ); ! 810: } ! 811: ! 812: ! 813: ! 814: REGION * ! 815: outds2(r) ! 816: REGION *r; ! 817: { ! 818: ! 819: /* ! 820: * Output one REGION data structure ! 821: */ ! 822: ! 823: fwrite( r, 1, sizeof(REGION), trnfdes ); ! 824: ! 825: return( r->rgnext ); ! 826: } ! 827: /*eject*/ ! 828: ACTITEM * ! 829: outds3(a) ! 830: ACTITEM *a; ! 831: { ! 832: ! 833: /* ! 834: * Output one AILDFILE, AILDLBRY, AIADFILE, or AIDFNSYM data structure ! 835: * ! 836: * Convert a "pointer to a string" to a "index to a string" ! 837: */ ! 838: ! 839: a->ldlbry.aiinflnm = (char *) ((int) a->ldlbry.aiinflnm - (int) strbase); ! 840: a->ldlbry.aifilnam = (char *) ((int) a->ldlbry.aifilnam - (int) strbase); ! 841: ! 842: fwrite( a, 1, sizeof(ACTITEM), trnfdes ); ! 843: ! 844: return( a->ldlbry.ainext ); ! 845: } ! 846: ! 847: ! 848: ! 849: ACTITEM * ! 850: outds4(a) ! 851: ACTITEM *a; ! 852: { ! 853: ! 854: /* ! 855: * Output one AIDFNSCN or AIDFNGRP data structure ! 856: * ! 857: * Convert a "pointer to a string" to a "index to a string" ! 858: */ ! 859: ! 860: register ACTITEM *anext, *b; ! 861: ACTITEM *outds5(); ! 862: ! 863: anext = a->dfnscn.ainext; ! 864: a->dfnscn.aiinflnm = (char *) ((int) a->dfnscn.aiinflnm - (int) strbase); ! 865: ! 866: fwrite( a, 1, sizeof(ACTITEM), trnfdes ); ! 867: ! 868: b = (ACTITEM *) a->dfnscn.sectspec.head; ! 869: switch( a->dfnscn.aitype ) { ! 870: case AIDFNSCN: ! 871: while( b ) ! 872: switch( b->addscn.aitype ) { ! 873: case AIADDSCN: ! 874: b = outds5(b); ! 875: break; ! 876: case AIADFILE: ! 877: b = outds3(b); ! 878: break; ! 879: case AIEVEXPR: ! 880: b = outds6(b); ! 881: break; ! 882: } ! 883: break; ! 884: case AIDFNGRP: ! 885: while( b ) ! 886: b = outds4(b); ! 887: break; ! 888: default: ! 889: lderror(2,0,NULL,"failure dumping an AIDFNxxx data structure\n"); ! 890: } ! 891: ! 892: return( a->dfnscn.ainext ); ! 893: } ! 894: ! 895: ! 896: ! 897: ACTITEM * ! 898: outds5(a) ! 899: ACTITEM *a; ! 900: { ! 901: ! 902: /* ! 903: * Output one AIADDSCN data structure ! 904: * ! 905: * Convert a "pointer to a string" to a "index to a string" ! 906: */ ! 907: ! 908: a->addscn.aiinflnm = (char *) ((int) a->addscn.aiinflnm - (int) strbase); ! 909: a->addscn.aiscfile = (char *) ((int) a->addscn.aiscfile - (int) strbase); ! 910: ! 911: fwrite( a, 1, sizeof(ACTITEM), trnfdes ); ! 912: ! 913: return( a->addscn.ainext ); ! 914: } ! 915: ! 916: ! 917: ! 918: ACTITEM * ! 919: outds6(a) ! 920: ACTITEM *a; ! 921: { ! 922: ! 923: /* ! 924: * Output one AIEVEXPR data structure ! 925: * ! 926: * Convert a "pointer to a string" to a "index to a string" ! 927: */ ! 928: ! 929: a->evexpr.aiinflnm = (char *) ((int) a->evexpr.aiinflnm - (int) strbase); ! 930: ! 931: fwrite( a, 1, sizeof(ACTITEM), trnfdes ); ! 932: ! 933: outds7( a->evexpr.aiexptr ); ! 934: ! 935: return( a->evexpr.ainext ); ! 936: } ! 937: ! 938: ! 939: ! 940: outds7(e) ! 941: ENODE *e; ! 942: { ! 943: ! 944: /* ! 945: * Output one ENODE data structure ! 946: */ ! 947: ! 948: switch( (unsigned) e->gnode.exop ) { ! 949: case INT: ! 950: case DOT: ! 951: fwrite( e, 1, sizeof(ENODE), trnfdes ); ! 952: break; ! 953: case NAME: ! 954: fwrite( e, 1, sizeof(ENODE), trnfdes ); ! 955: break; ! 956: default: ! 957: fwrite( e, 1, sizeof(ENODE), trnfdes ); ! 958: if( e->gnode.exleft ) ! 959: outds7(e->gnode.exleft); ! 960: if( e->gnode.exright ) ! 961: outds7(e->gnode.exright); ! 962: } ! 963: ! 964: } ! 965: ! 966: ! 967: ! 968: TVASSIGN * ! 969: outds8(s) ! 970: TVASSIGN *s; ! 971: { ! 972: ! 973: /* ! 974: * Output one tv slot assignment (TVASSIGN) structure ! 975: */ ! 976: ! 977: fwrite( s, sizeof(TVASSIGN), 1, trnfdes); ! 978: return( s->nxtslot ); ! 979: } ! 980: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.