![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ld00.c 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 ld00.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / ld |
1.1 ! root 1: static char ID[] = "@(#) ld00.c: 1.17 8/18/83"; ! 2: #include "system.h" ! 3: ! 4: #include <stdio.h> ! 5: ! 6: #if TS || RT ! 7: #include <ar.h> ! 8: #else ! 9: #include <archive.h> ! 10: #endif ! 11: ! 12: #include "structs.h" ! 13: #include "extrns.h" ! 14: #include "list.h" ! 15: #include "ldfcn.h" ! 16: #include "sgs.h" ! 17: #include "sgsmacros.h" ! 18: #include "paths.h" ! 19: #include "y.tab.h" ! 20: ! 21: extern FILE *yyin; /* current lex input file */ ! 22: extern char inline[]; /* current input line up to current token */ ! 23: extern int yychar; /* current yacc lookahead token number */ ! 24: ! 25: extern int in_y_exp; /* ! 26: * See explanation in ld.yac. ! 27: * We must initialize this var. to zero ! 28: * before parsing an ifile. ! 29: */ ! 30: ! 31: #if FLEXNAMES ! 32: # define STRINCRE 2048 ! 33: #else ! 34: # define STRINCRE 1024 ! 35: #endif ! 36: #define MAXINFLS 16 ! 37: #define MAXDLEN 64 /* maximum lib search directory length*/ ! 38: ! 39: #ifndef LLIBDIR ! 40: #define LLIBDIR LIBDIR ! 41: #endif ! 42: #ifndef NDELDIRS ! 43: #define NDELDIRS 1 ! 44: #endif ! 45: ! 46: extern char *realloc(); ! 47: ! 48: static int nldirs = NDELDIRS; /* number of -L options used */ ! 49: static char *libdirs[MAXLDIRS] = { /* directories searched for libraries */ ! 50: LLIBDIR ! 51: #ifdef LLIBDIR1 ! 52: ,LLIBDIR1 ! 53: #endif ! 54: }; ! 55: ! 56: ! 57: /* ! 58: * A stack is kept of input ifile discriptors so that ! 59: * ifiles may include other ifiles. ! 60: * ! 61: * NOTE: currently, this only works if the ifile name ! 62: * is the last statement in an ifile, because YACC does ! 63: * not return from a recursive call properly. ! 64: */ ! 65: typedef struct instr INSTR; ! 66: struct instr { ! 67: FILE *infildes; /* file descriptor */ ! 68: char *infilnm; /* ptr to file name */ ! 69: int lastlnno; /* last line number read in the file */ ! 70: }; ! 71: char whichin = 0; /* index int instack */ ! 72: INSTR instack[MAXINFLS+1]; /* stack of input ifiles */ ! 73: /*eject*/ ! 74: filespec(filename) ! 75: char *filename; ! 76: { ! 77: ! 78: /* ! 79: * This routine is called when there is an input directive to load a ! 80: * file. It checks the type of file, to distinguish between an ifile ! 81: * and an object file ! 82: */ ! 83: ! 84: FILE *filedes; ! 85: #if PORTAR || PORT5AR ! 86: unsigned short firstword; ! 87: char atype[SARMAG]; ! 88: #else ! 89: unsigned short firstword, ! 90: atype; ! 91: #endif ! 92: ! 93: #if DEBUG ! 94: if (dflag > 1) ! 95: fprintf(stderr, "filespec : %s\n", filename); ! 96: #endif ! 97: ! 98: if ((filedes = fopen(filename,"r")) == NULL) { ! 99: lderror(2,0,sname(curfilnm),"Can't open file %s for input", filename); ! 100: return; ! 101: } ! 102: ! 103: in_y_exp = 0; ! 104: ! 105: if (fread( (char *) &firstword, sizeof(firstword), 1, filedes) != 1) ! 106: lderror(2,0,NULL,"Can't read 1st word of file %s",filename); ! 107: #if PORTAR || PORT5AR ! 108: fseek(filedes,0L,0); ! 109: if (fread(atype,SARMAG,1,filedes) != 1) ! 110: atype[0] = '\0'; ! 111: #else ! 112: if ( sizeof(firstword) != sizeof(ARMAG) ) ! 113: if ( fread( (char *)&atype, sizeof(atype), 1, filedes) != 1) ! 114: atype = firstword; ! 115: #endif ! 116: ! 117: if (ISMAGIC(firstword)) { ! 118: bldldfil( savefn(filename), 0 ); ! 119: fclose(filedes); ! 120: } ! 121: #if PORTAR || PORT5AR ! 122: else if (strncmp(atype,ARMAG,SARMAG) == 0) { ! 123: #else ! 124: else if ( (firstword == (unsigned short) ARMAG) || ! 125: ((sizeof(firstword) != sizeof(ARMAG)) && ! 126: (atype == (unsigned short) ARMAG)) ) { ! 127: #endif ! 128: bldldfil( savefn(filename), 1 ); ! 129: fclose(filedes); ! 130: } ! 131: else if (BADMAGIC(firstword)) { ! 132: yyerror("file %s is of unknown type: magic number = %6.2x", ! 133: filename, firstword); ! 134: fclose(filedes); ! 135: } ! 136: else { ! 137: /* ! 138: * Assume that the file is an ifile ! 139: */ ! 140: instack[whichin].infilnm = curfilnm; ! 141: instack[whichin].lastlnno = lineno; ! 142: instack[whichin].infildes = filedes; ! 143: curfilnm = savefn(filename); ! 144: lineno = 1; ! 145: if( ++whichin == MAXINFLS ) { ! 146: yyerror("ifile nesting limit exceeded with file %s", filename); ! 147: fclose(filedes); ! 148: curfilnm = instack[--whichin].infilnm; ! 149: lineno = instack[whichin].lastlnno++; ! 150: return; ! 151: } ! 152: ! 153: if (fseek(filedes, 0L, 0) != 0) ! 154: lderror(2,0,NULL,"Can't seek to the beginning of file %s", ! 155: filename); ! 156: yyin = filedes; ! 157: ! 158: #if DEBUG ! 159: if( dflag ) ! 160: fprintf(stderr, "reading cmds from file %s (%.2o)\n", ! 161: filename, filedes); ! 162: #endif ! 163: ! 164: yyparse(); ! 165: close(filedes); ! 166: ! 167: yyin = instack[--whichin].infildes; ! 168: curfilnm = instack[whichin].infilnm; ! 169: lineno = instack[whichin].lastlnno++; ! 170: yychar = -1; ! 171: ! 172: #if DEBUG ! 173: if( dflag ) ! 174: fprintf(stderr, "returning input to fildes %s (%.2o)\n", ! 175: curfilnm, yyin); ! 176: #endif ! 177: ! 178: } ! 179: } ! 180: /*eject*/ ! 181: bldldfil(fname, typflag) ! 182: char *fname; ! 183: int typflag; ! 184: { ! 185: ! 186: /* ! 187: * Build a LDFILE action item ! 188: */ ! 189: ! 190: ACTITEM *p; ! 191: ! 192: p = (ACTITEM *) myalloc(sizeof(ACTITEM)); ! 193: ! 194: p->ldlbry.aiinflnm = curfilnm; ! 195: p->ldlbry.aiinlnno = lineno; ! 196: p->ldlbry.aitype = typflag ? AILDLBRY : AILDFILE; ! 197: p->ldlbry.aifilnam = fname; ! 198: ! 199: listadd(l_AI, &ldfilist, p); ! 200: } ! 201: ! 202: ! 203: ! 204: ! 205: bldadscn(scname, fname, sp) ! 206: char *scname; ! 207: char *fname; ! 208: ACTITEM *sp; /* ptr to DFNSCN act_item */ ! 209: { ! 210: ! 211: /* ! 212: * Build a ADDSCN action item ! 213: */ ! 214: ! 215: ACTITEM *p; ! 216: ! 217: p = (ACTITEM *) myalloc(sizeof(ACTITEM)); ! 218: ! 219: p->addscn.aitype = AIADDSCN; ! 220: p->addscn.aiinflnm = curfilnm; ! 221: p->addscn.aiinlnno = lineno; ! 222: copy(p->addscn.ainame, scname, sizeof(p->addscn.ainame)); ! 223: p->addscn.aiscfile = fname; ! 224: ! 225: listadd(l_AI, &(sp->dfnscn.sectspec), p); ! 226: } ! 227: ! 228: ! 229: ! 230: ! 231: ACTITEM * ! 232: bldadfil(fname, sp) ! 233: char *fname; ! 234: ACTITEM *sp; /* ptr to DFNSCN act_item */ ! 235: { ! 236: ! 237: /* ! 238: * Build a ADFILE action item ! 239: */ ! 240: ! 241: ACTITEM *p; ! 242: ! 243: p = (ACTITEM *) myalloc(sizeof(ACTITEM)); ! 244: ! 245: p->adfile.aitype = AIADFILE; ! 246: p->adfile.aiinflnm = curfilnm; ! 247: p->adfile.aiinlnno = lineno; ! 248: p->adfile.aifilnam = fname; ! 249: ! 250: listadd(l_AI, &(sp->dfnscn.sectspec), p); ! 251: ! 252: return (p); ! 253: } ! 254: ! 255: ! 256: ! 257: ! 258: bldexp(ep, lp) ! 259: ENODE *ep; ! 260: LISTOWN *lp; ! 261: { ! 262: ! 263: /* ! 264: * Build an EVEXPR action item ! 265: */ ! 266: ! 267: ACTITEM *p; ! 268: ! 269: p = (ACTITEM *) myalloc(sizeof(ACTITEM)); ! 270: ! 271: p->evexpr.aitype = AIEVEXPR; ! 272: p->evexpr.aiinlnno = lineno; ! 273: p->evexpr.aiinflnm = curfilnm; ! 274: p->evexpr.aiexptr = ep; ! 275: ! 276: listadd(l_AI, lp, p); ! 277: } ! 278: ! 279: ! 280: ! 281: ! 282: bldsym(sym, value, op) ! 283: char *sym; ! 284: long value; ! 285: int op; ! 286: { ! 287: ! 288: /* ! 289: * Build an DFNSYM action item ! 290: */ ! 291: ! 292: ACTITEM *p; ! 293: ! 294: p = (ACTITEM *) myalloc(sizeof(ACTITEM)); ! 295: ! 296: p->dfnsym.aitype = AIDFNSYM; ! 297: p->dfnsym.aiinlnno = lineno; ! 298: p->dfnsym.aiinflnm = curfilnm; ! 299: p->dfnsym.aisymbol = savefn(sym); ! 300: p->dfnsym.aideflag = op; ! 301: p->dfnsym.aidefval = value; ! 302: ! 303: listadd(l_AI, &symlist, p); ! 304: } ! 305: /*eject*/ ! 306: pflags(flgname, ifile) ! 307: char *flgname; /* ptr to x, extracted from -x */ ! 308: int ifile; /* set TRUE iff the flag comes from an ifile */ ! 309: { ! 310: ! 311: /* ! 312: * Process flag specifications ! 313: * ! 314: * Note that flags can come from two sources: ! 315: * command line : everything is character strings ! 316: * ifile : parser has already converted tokens to binary ! 317: */ ! 318: ! 319: register int type; ! 320: ! 321: ! 322: /* ! 323: * -a : make the output file "executable": ! 324: * 1. complain about unresolved references ! 325: * 2. define several "_xxxx" symbols ! 326: * ! 327: * -cn : increment the partial execution flag. 'n' ! 328: * defaults to 1: ! 329: * 0 : normal, complete ld execution ! 330: * 1 : execute parser of PASS 1 only ! 331: * 2 : execute PASS 1 only ! 332: * 3 : execute through allocation (up ! 333: * to output()) ! 334: * 4 : complete ld execution, with ! 335: * /dev/null as the output ! 336: * file name ! 337: * ! 338: * -dn (-b for u3b): increment the internal ld debug flag. 'n' ! 339: * defaults to 1 ! 340: * ! 341: * -e name : generate a UNIX a.out header in the optional ! 342: * header field of the output file, and ! 343: * set the "entry point" entry to the ! 344: * address of the symbol "name". This ! 345: * flag forces the flag -X ! 346: * ! 347: * -f 0xaabb : use the two-byte value aabb to: ! 348: * 1. fill "holes" between sections ! 349: * 2. fill uninitialized .bss sections ! 350: * ! 351: * -h nnn : make the optional header field nnn bytes in ! 352: * size. Zero fill any unused bytes of this ! 353: * header ! 354: * ! 355: * -i : ***** b16ld and x86ld only ***** ! 356: * use two regions, to give separate I and ! 357: * D space (64 K each) ! 358: * ! 359: * -lx : search the library libx.a in directory ! 360: * libdirs[n] for any symbols which can ! 361: * satisfy outstanding unresolved references. ! 362: * ! 363: * -m : generate a memory map ! 364: * ! 365: * -o name : use "name" as the name of the output file. ! 366: * The default value is given by the ! 367: * constant A.OUT, defined in the include ! 368: * file paths.h ! 369: * ! 370: * -p[nnn] : generate a patch list. The size of the ! 371: * optional header is increased by the ! 372: * size of the patch list ! 373: * the output section size is set to nnn ! 374: * after allocation and patch list ! 375: * construction to save physical memory ! 376: * ! 377: * -r : keep relocation information in the output file ! 378: * ! 379: * -s : strip all relocation and symbol table ! 380: * information from the output file ! 381: * ! 382: * -t : ****** UNIX only ****** ! 383: * do type checking ! 384: ! 385: * -tv : ***** b16ld/x86ld/n3bld only ***** ! 386: * generate TV function linkage ! 387: * ! 388: * -x (only u3b) : do not preserve symbols in the output symbol ! 389: * table except static or external symbols ! 390: * ! 391: * -u name : add "name" to ld's symbol table, as an ! 392: * undefined symbol ! 393: * ! 394: * -z : ****** UNIX only ****** ! 395: * leave memory around zero unconfigured ro catch ! 396: * null pointers ! 397: * ! 398: * -B nn : generate "padding" output sections of nn bytes ! 399: * of zero following any output section ! 400: * which is either: ! 401: * 1. of zero length ! 402: * 2. all of uninitialzed .bss ! 403: * ! 404: * -F : ****** UNIX only ****** ! 405: * indicate in header file for paging, block ! 406: * for paging, memory configure for paging, etc. ! 407: * ! 408: * -H : change the type of all global symbol table ! 409: * entries to "static" ! 410: * ! 411: * -L<path> : provides alternate directories and orders ! 412: * search path for libraries (equivalent to ! 413: * -I flag for cpp includes). -L must precede ! 414: * -l to be effective. ! 415: * ! 416: * -M : ****** UNIX only ***** ! 417: * output message if external variables are ! 418: * multiply defined ! 419: * ! 420: * -N : squash text and data together ! 421: * ! 422: * -S : "silent" mode: only fatal errors will be ! 423: * listed - not warnings or diagnostics ! 424: * ! 425: * -V : output current ld environment definition. '-V' ! 426: * flags are cumulative: ! 427: * 1 : describe the ld version ! 428: * 2 : describe the machine and os version ! 429: * ! 430: * -VS nn : put nn as version stamp in the optional header ! 431: * ! 432: * -X : generate, in the optional header field, a ! 433: * standard UNIX a.out header ! 434: * (except for u3b, where it means ! 435: * elimate compiler generated labels) ! 436: * ! 437: * -ild : generate an "extra" output section for each ! 438: * unallocated area of configured memory ! 439: * ! 440: */ ! 441: ! 442: switch (flgname[0]) { ! 443: #if !UNIX || M32 ! 444: case 'a': ! 445: aflag++; ! 446: break; ! 447: #endif ! 448: #if !ONEPROC ! 449: case 'c': ! 450: type = 1; ! 451: if( flgname[1] ) ! 452: if( (type = stoi(&flgname[1])) == 0x8000 ) { ! 453: yyerror("-c flag does not specify a number: %s", &flgname[1]); ! 454: type = 1; ! 455: } ! 456: cflag += type; ! 457: break; ! 458: #endif ! 459: #if DEBUG ! 460: case 'd': ! 461: #if UNIX ! 462: lderror(0,0,NULL,"-d flag is not implemented"); ! 463: break; ! 464: case 'b': ! 465: #endif ! 466: type = 1; ! 467: if( flgname[1] ) ! 468: if( (type = stoi(&flgname[1])) == 0x8000 ) { ! 469: yyerror("-%c flag does not specify a number: %s", flgname[0],flgname[1]); ! 470: type = 1; ! 471: } ! 472: dflag += type; ! 473: break; ! 474: #endif ! 475: case 'e': ! 476: if( ifile ) ! 477: if (yylex() != NAME) ! 478: yyerror("-e flag does not specify a legal symbol name: %s", inline); ! 479: else ! 480: #if FLEXNAMES ! 481: strcpy(epsymbol, yylval.sptr); ! 482: #else ! 483: copy(epsymbol, yylval.sptr, 8); ! 484: #endif ! 485: else { ! 486: #if FLEXNAMES ! 487: strcpy(epsymbol, *++argptr); ! 488: #else ! 489: copy(epsymbol, *++argptr, 8); ! 490: #endif ! 491: argcnt--; ! 492: } ! 493: Xflag++; ! 494: #if DEBUG ! 495: if (dflag) ! 496: fprintf(stderr, "a.out entry point symbol: %s\n", ! 497: epsymbol); ! 498: #endif ! 499: break; ! 500: case 'f': ! 501: if( ifile ) ! 502: if (yylex() != LONGINT) ! 503: yyerror("-f flag does not specify a two-byte number: %s", inline); ! 504: else ! 505: globfill = (short) *yylval.lptr; ! 506: else { ! 507: if( (globfill = (short) stoi(*++argptr)) == (short) 0x8000 ) { ! 508: yyerror("-f flag does not specify a two-byte number: %s", *argptr); ! 509: globfill = 0; ! 510: } ! 511: argcnt--; ! 512: } ! 513: #if DEBUG ! 514: if (dflag) ! 515: fprintf(stderr, "global fill: %.2x\n", ! 516: globfill); ! 517: #endif ! 518: break; ! 519: #if !UNIX ! 520: case 'h': ! 521: if( ifile ) ! 522: if (yylex() != LONGINT) ! 523: yyerror("-h flag does not specify a numeric value: %s", inline); ! 524: else ! 525: hflag = *yylval.lptr; ! 526: else { ! 527: if( (hflag = stoi(*++argptr)) == 0x8000 ) { ! 528: yyerror("-h flag does not specify a numeric value: %s", *argptr); ! 529: hflag = 0; ! 530: } ! 531: argcnt--; ! 532: } ! 533: if( hflag < 0 ) { ! 534: yyerror("invalid value on -h flag: %.2x", hflag); ! 535: hflag = 0; ! 536: } ! 537: #if DEBUG ! 538: if(dflag) ! 539: fprintf(stderr, "optional header size: %d\n", ! 540: hflag); ! 541: #endif ! 542: break; ! 543: #endif ! 544: case 'i': ! 545: #if IANDD ! 546: if (flgname [1] == '\0') ! 547: { ! 548: iflag++; ! 549: break; ! 550: } ! 551: #endif ! 552: #if ILDOPT ! 553: if (flgname [1] == 'l' && flgname [2] == 'd') ! 554: { ! 555: ildflag++; ! 556: break; ! 557: } ! 558: ! 559: yyerror("%s is an invalid flag",flgname); ! 560: #endif ! 561: break; ! 562: case 'l': ! 563: if( flgname[1] != '\0' ) { ! 564: library(flgname); ! 565: } ! 566: else { ! 567: specflags(flgname, argptr); ! 568: } ! 569: break; ! 570: case 'm': ! 571: mflag++; ! 572: break; ! 573: #if !UNIX ! 574: case 'p': ! 575: pflag = -1; /* use default patch size */ ! 576: if( flgname[1] ) { ! 577: if( (pflag = stoi(&flgname[1])) == 0x8000 ) { ! 578: yyerror("-p flag does not specify a number: %s", &flgname[1]); ! 579: pflag = -1; ! 580: } else { ! 581: if (pflag <= 0) { ! 582: yyerror("-p flag size out of range: %s", &flgname[1]); ! 583: pflag = -1; ! 584: } ! 585: } /* else */ ! 586: } /* if flgname */ ! 587: break; ! 588: #endif ! 589: case 'o': ! 590: if( ifile ) { ! 591: type = yylex(); ! 592: if( (type == FILENAME) || (type == NAME) ) ! 593: copy(outfilnm, yylval.sptr, 128); ! 594: else ! 595: yyerror("-o flag does not specify a valid file name: %s", inline); ! 596: } ! 597: else { ! 598: copy(outfilnm, *++argptr, 128); ! 599: argcnt--; ! 600: } ! 601: if( outfilnm[127] != '\0' ) { ! 602: outfilnm[127] = '\0'; ! 603: yyerror("-o file name too large (> 128 char); truncated to (%s)", outfilnm); ! 604: } ! 605: #if DEBUG ! 606: if(dflag) ! 607: fprintf(stderr, "output file name: %s\n", ! 608: outfilnm); ! 609: #endif ! 610: break; ! 611: case 'r': ! 612: rflag++; ! 613: break; ! 614: case 's': ! 615: sflag++; ! 616: break; ! 617: case 't': ! 618: #if TRVEC ! 619: if (flgname[1] == 'v') { ! 620: tvflag = 1; ! 621: magic = (unsigned short) TVMAGIC; ! 622: break; ! 623: } ! 624: #endif ! 625: #if COMMON ! 626: tflag++; ! 627: #endif ! 628: break; ! 629: case 'u': ! 630: if( ifile ) ! 631: if( yylex() != NAME ) ! 632: yyerror("-u flag does not specify a legal symbol name: %s", inline); ! 633: else ! 634: bldsym(yylval.sptr, 0L, 0); ! 635: else { ! 636: bldsym(*++argptr, 0L, 0); ! 637: argcnt--; ! 638: } ! 639: break; ! 640: #if PAGING ! 641: case 'z': ! 642: zflag++; ! 643: break; ! 644: #endif ! 645: #if !UNIX ! 646: case 'B': ! 647: if( ifile ) ! 648: if (yylex() != LONGINT) ! 649: yyerror("-B flag does not specify a number: %s", inline); ! 650: else ! 651: Bflag = *yylval.lptr; ! 652: else { ! 653: if( (Bflag = stoi(*++argptr)) == 0x8000 ) { ! 654: yyerror("-B flag does not specify a number: %s", *argptr); ! 655: Bflag = 0; ! 656: } ! 657: argcnt--; ! 658: } ! 659: #if DEBUG ! 660: if (dflag) ! 661: fprintf(stderr, "pad-section size: %.2x\n", ! 662: Bflag); ! 663: #endif ! 664: break; ! 665: case 'H': ! 666: Hflag++; ! 667: break; ! 668: #endif ! 669: #if PAGING ! 670: case 'F': ! 671: Fflag++; ! 672: break; ! 673: #endif ! 674: #if COMMON ! 675: case 'M': ! 676: Mflag++; ! 677: break; ! 678: #endif ! 679: case 'N': ! 680: Nflag++; ! 681: break; ! 682: case 'L': ! 683: if ( nldirs >= MAXLDIRS ) ! 684: yyerror("too many -L options, %d allowed", MAXLDIRS-1); ! 685: else if ( flgname[1] == NULL ) ! 686: yyerror("no directory given with -L"); ! 687: else if ( strlen(&flgname[1]) > MAXDLEN ) ! 688: yyerror("-L path too long(%s)", &flgname[1]); ! 689: else { ! 690: libdirs[nldirs] = myalloc(size(&flgname[1])); ! 691: strcpy(libdirs[nldirs++], &flgname[1]); ! 692: } ! 693: break; ! 694: case 'S': ! 695: Sflag++; ! 696: break; ! 697: case 'V': ! 698: if (flgname[1] == 'S') { ! 699: if( ifile ) ! 700: if (yylex() != LONGINT) ! 701: yyerror("-VS flag does not specify a numeric value: %s", inline); ! 702: else ! 703: VSflag = *yylval.lptr; ! 704: else { ! 705: if( (VSflag = stoi(*++argptr)) == 0x8000 ) { ! 706: yyerror("-VS flag does not specify a numeric value: %s", *argptr); ! 707: VSflag = 0; ! 708: } ! 709: argcnt--; ! 710: } ! 711: } ! 712: else { ! 713: Vflag++; ! 714: } ! 715: break; ! 716: #if !UNIX ! 717: case 'X': ! 718: Xflag++; ! 719: break; ! 720: #endif ! 721: default: ! 722: specflags(flgname, argptr); ! 723: } ! 724: } ! 725: /*eject*/ ! 726: library(fname) ! 727: char *fname; ! 728: { ! 729: ! 730: /* ! 731: * For a library flag of the form "-lx", build a file name of the form ! 732: * ! 733: * "libdirs[n]/libx.a" ! 734: * ! 735: * where libdirs[0] is LIBDIR (defined in paths.h) and libdirs[n>0] ! 736: * are defined using the -L option. Then build a LDFILE action item. ! 737: */ ! 738: ! 739: static char libname[MAXDLEN+16]; /* -lx file name */ ! 740: int dndx; ! 741: char *p; ! 742: FILE *lfd; ! 743: ! 744: if ( *(++fname) == '\0' ) { ! 745: yyerror("the -l flag (specifying a default library) is not supported"); ! 746: return; ! 747: } ! 748: else ! 749: p = fname; ! 750: ! 751: /* ! 752: * Loop thru libdir[NDELDIRS] thru libdir[nldirs-1] ! 753: */ ! 754: for ( dndx = NDELDIRS; dndx < nldirs; dndx++) { ! 755: sprintf(libname, "%s%s%.8s%s", libdirs[dndx], "/lib", p, ".a"); ! 756: if ( (lfd = fopen(libname,"r")) != NULL) ! 757: goto liblab; ! 758: } ! 759: ! 760: /* ! 761: * loop thru libdirs[0] thru libdirs[NDELDIRS-1] ! 762: */ ! 763: for ( dndx = 0; dndx < NDELDIRS; dndx++) { ! 764: sprintf(libname, "%s%s%.8s%s", libdirs[dndx], "/lib", p, ".a"); ! 765: if ( (lfd = fopen(libname,"r")) != NULL) ! 766: goto liblab; ! 767: } ! 768: ! 769: yyerror("can't find library lib%s.a", p); ! 770: return; ! 771: ! 772: liblab: ! 773: fclose(lfd); ! 774: bldldfil(savefn(libname), 1); ! 775: } ! 776: /*eject*/ ! 777: char * ! 778: savefn(name) ! 779: char *name; ! 780: { ! 781: ! 782: /* ! 783: * Save the name of an ifile or input *.o or archive file ! 784: */ ! 785: ! 786: char *strbeg; ! 787: int length; ! 788: ! 789: length = strlen(name) + 1; ! 790: if (strnext + length > strlimit) ! 791: { ! 792: #if ONEPROC ! 793: strbase = myalloc( STRINCRE ); ! 794: strnext = strbase; ! 795: strlimit = strbase + STRINCRE; ! 796: #else ! 797: lderror( 0, 0, NULL, "too many strings, out of space" ); ! 798: lderror( 2, 0, NULL, "%sld run is too large and complex", SGS ); ! 799: #endif ! 800: } ! 801: strbeg = strnext; ! 802: strncpy( strbeg, name, length ); ! 803: strnext += length; ! 804: ! 805: return( strbeg ); ! 806: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.