git.gag.com Git - fw/sdcc/blob - as/mcs51/lklibr.c

   1 /* lklibr.c */
   2
   3 /*
   4  * (C) Copyright 1989-1995
   5  * All Rights Reserved
   6  *
   7  * Alan R. Baldwin
   8  * 721 Berkeley St.
   9  * Kent, Ohio  44240
  10  *
  11  * With contributions for the
  12  * object libraries from
  13  * Ken Hornstein
  14  * kenh@cmf.nrl.navy.mil
  15  *
  16  */
  17
  18 #define EQ(A,B) !strcmp((A),(B))
  19 #define MAXLINE 254 /*when using fgets*/
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <ctype.h>
  25 #include "aslink.h"
  26
  27 /*)Module       lklibr.c
  28  *
  29  *  The module lklibr.c contains the functions which
  30  *  (1) specify the path(s) to library files [.LIB]
  31  *  (2) specify the library file(s) [.LIB] to search
  32  *  (3) search the library files for specific symbols
  33  *      and link the module containing this symbol
  34  *
  35  *  lklibr.c contains the following functions:
  36  *      VOID    addpath()
  37  *      VOID    addlib()
  38  *      VOID    addfile()
  39  *      VOID    search()
  40  *      VOID    fndsym()
  41  *      VOID    library()
  42  *      VOID    loadfile()
  43  *
  44  */
  45
  46 #ifdef INDEXLIB
  47 typedef struct slibrarysymbol mlibrarysymbol;
  48 typedef struct slibrarysymbol *pmlibrarysymbol;
  49
  50 struct slibrarysymbol {
  51     char * name; /*Warning: allocate memory before using*/
  52     pmlibrarysymbol next;
  53 };
  54
  55 typedef struct slibraryfile mlibraryfile;
  56 typedef struct slibraryfile *pmlibraryfile;
  57
  58 struct slibraryfile {
  59     int loaded;
  60     char * libspc;
  61     char * relfil; /*Warning: allocate memory before using*/
  62     char * filename; /*Warning: allocate memory before using*/
  63     long offset; //if > 0, the embedded file offset in the library file libspc
  64     pmlibrarysymbol symbols;
  65     pmlibraryfile next;
  66 };
  67
  68 /* First entry in the library object symbol cache */
  69 pmlibraryfile libr=NULL;
  70
  71 int buildlibraryindex();
  72 void freelibraryindex (void);
  73 #endif /* INDEXLIB */
  74
  75 /*)Function VOID    addpath()
  76  *
  77  *  The function addpath() creates a linked structure containing
  78  *  the paths to various object module library files.
  79  *
  80  *  local variables:
  81  *      lbpath  *lbph       pointer to new path structure
  82  *      lbpath  *lbp        temporary pointer
  83  *
  84  *  global variables:
  85  *      lbpath  *lbphead    The pointer to the first
  86  *                          path structure
  87  *
  88  *   functions called:
  89  *      char    getnb()     lklex.c
  90  *      VOID *  new()       lksym.c
  91  *      int     strlen()    c_library
  92  *      char *  strcpy()    c_library
  93  *      VOID    unget()     lklex.c
  94  *
  95  *  side effects:
  96  *      An lbpath structure may be created.
  97  */
  98
  99 VOID
 100 addpath()
 101 {
 102     struct lbpath *lbph, *lbp;
 103
 104     lbph = (struct lbpath *) new (sizeof(struct lbpath));
 105     if (lbphead == NULL) {
 106         lbphead = lbph;
 107     } else {
 108         lbp = lbphead;
 109         while (lbp->next)
 110             lbp = lbp->next;
 111         lbp->next = lbph;
 112     }
 113     unget(getnb());
 114     lbph->path = (char *) new (strlen(ip)+1);
 115     strcpy(lbph->path, ip);
 116 }
 117
 118 /*)Function VOID    addlib()
 119  *
 120  *  The function addlib() tests for the existance of a
 121  *  library path structure to determine the method of
 122  *  adding this library file to the library search structure.
 123  *
 124  *  This function calls the function addfile() to actually
 125  *  add the library file to the search list.
 126  *
 127  *  local variables:
 128  *      lbpath  *lbph       pointer to path structure
 129  *
 130  *  global variables:
 131  *      lbpath  *lbphead    The pointer to the first
 132  *                          path structure
 133  *      ip a pointer to the library name
 134  *
 135  *   functions called:
 136  *      VOID    addfile()   lklibr.c
 137  *      char    getnb()     lklex.c
 138  *      VOID    unget()     lklex.c
 139  *
 140  *  side effects:
 141  *      The function addfile() may add the file to
 142  *      the library search list.
 143  */
 144
 145 VOID
 146 addlib()
 147 {
 148     struct lbpath *lbph;
 149     int foundcount=0;
 150
 151     unget(getnb());
 152
 153     if (lbphead == NULL)
 154     {
 155         foundcount=addfile(NULL, ip);
 156     }
 157     else
 158     {
 159         for (lbph=lbphead; lbph; lbph=lbph->next)
 160         {
 161             foundcount+=addfile(lbph->path, ip);
 162         }
 163     }
 164     if(foundcount == 0)
 165     {
 166         fprintf(stderr, "?ASlink-Warning-Couldn't find library '%s'\n", ip);
 167     }
 168 }
 169
 170 /*)Function int addfile(path,libfil)
 171  *
 172  *      char    *path       library path specification
 173  *      char    *libfil     library file specification
 174  *
 175  *  The function addfile() searches for the library file
 176  *  by concatenating the path and libfil specifications.
 177  *  if the library is found, an lbname structure is created
 178  *  and linked to any previously defined structures.  This
 179  *  linked list is used by the function fndsym() to attempt
 180  *  to find any undefined symbols.
 181  *
 182  *  The function does not give report an error on invalid
 183  *  path / file specifications or if the file is not found.
 184  *
 185  *  local variables:
 186  *      lbname  *lbnh       pointer to new name structure
 187  *      lbname  *lbn        temporary pointer
 188  *
 189  *  global variables:
 190  *      lbname  *lbnhead    The pointer to the first
 191  *                          path structure
 192  *
 193  *   functions called:
 194  *      char    getnb()     lklex.c
 195  *      VOID *  new()       lksym.c
 196  *      int     strlen()    c_library
 197  *      char *  strcpy()    c_library
 198  *      VOID    unget()     lklex.c
 199  *
 200  *  side effects:
 201  *      An lbname structure may be created.
 202  *
 203  *  return:
 204  *      1: the library was found
 205  *      0: the library was not found
 206  */
 207
 208 int addfile(char * path, char * libfil)
 209 {
 210     FILE *fp;
 211     char *str;
 212     struct lbname *lbnh, *lbn;
 213 #ifdef  OTHERSYSTEM
 214     int libfilinc=0;
 215 #endif
 216
 217     if (path != NULL)
 218     {
 219         str = (char *) new (strlen(path) + strlen(libfil) + 6);
 220         strcpy(str,path);
 221 #ifdef  OTHERSYSTEM
 222         if (strlen(str) && (str[strlen(str)-1] != '/') && (str[strlen(str)-1] != '\\'))
 223         {
 224             strcat(str,"/");
 225         }
 226 #endif
 227     }
 228     else
 229     {
 230         str = (char *) new (strlen(libfil) + 5);
 231     }
 232
 233 #ifdef  OTHERSYSTEM
 234     if ((libfil[0] == '/') || (libfil[0] == '\\'))
 235     {
 236         libfil++;
 237         libfilinc=1;
 238     }
 239 #endif
 240
 241     strcat(str, libfil);
 242     if(strchr(libfil, FSEPX) == NULL)
 243     {
 244         sprintf(&str[strlen(str)], "%clib", FSEPX);
 245     }
 246
 247     fp=fopen(str, "r");
 248     if(fp == NULL)
 249     {
 250         /*Ok, that didn't work.  Try with the 'libfil' name only*/
 251 #ifdef  OTHERSYSTEM
 252         if(libfilinc) libfil--;
 253 #endif
 254         fp=fopen(libfil, "r");
 255         if(fp != NULL)
 256         {
 257             /*Bingo!  'libfil' is the absolute path of the library*/
 258            strcpy(str, libfil);
 259             path=NULL;/*This way 'libfil' and 'path' will be rebuilt from 'str'*/
 260         }
 261     }
 262
 263     if(path==NULL)
 264     {
 265         /*'path' can not be null since it is needed to find the '.rel' files associated with
 266         the library.  So, get 'path' from 'str' and then chop it off and recreate 'libfil'.
 267         That way putting 'path' and 'libfil' together will result into the original filepath
 268         as contained in 'str'.*/
 269         int j;
 270         path = (char *) new (strlen(str) + 1);
 271         strcpy(path, str);
 272         for(j=strlen(path)-1; j>=0; j--)
 273         {
 274             if((path[j] == '/') || (path[j] == '\\'))
 275             {
 276                 strcpy(libfil, &path[j+1]);
 277                 path[j+1]=0;
 278                 break;
 279             }
 280         }
 281         if(j<=0) path[0]=0;
 282     }
 283
 284     if (fp != NULL)
 285     {
 286         fclose(fp);
 287         lbnh = (struct lbname *) new (sizeof(struct lbname));
 288         if (lbnhead == NULL)
 289         {
 290             lbnhead = lbnh;
 291         }
 292         else
 293         {
 294             lbn = lbnhead;
 295             while (lbn->next)
 296                 lbn = lbn->next;
 297             lbn->next = lbnh;
 298         }
 299
 300         lbnh->path = path;
 301         lbnh->libfil = (char *) new (strlen(libfil) + 1);
 302         strcpy(lbnh->libfil,libfil);
 303         lbnh->libspc = str;
 304         return 1;
 305     }
 306     else
 307     {
 308         free(str);
 309         return 0;
 310     }
 311 }
 312
 313 /*)Function VOID    search()
 314  *
 315  *  The function search() looks through all the symbol tables
 316  *  at the end of pass 1.  If any undefined symbols are found
 317  *  then the function fndsym() is called. Function fndsym()
 318  *  searches any specified library files to automagically
 319  *  import the object modules containing the needed symbol.
 320  *
 321  *  After a symbol is found and imported by the function
 322  *  fndsym() the symbol tables are again searched.  The
 323  *  symbol tables are search until no more symbols can be
 324  *  resolved within the library files.  This ensures that
 325  *  back references from one library module to another are
 326  *  also resolved.
 327  *
 328  *  local variables:
 329  *      int     i           temporary counter
 330  *      sym     *sp         pointer to a symbol structure
 331  *      int     symfnd      found a symbol flag
 332  *
 333  *  global variables:
 334  *      sym     *symhash[]  array of pointers to symbol tables
 335  *
 336  *   functions called:
 337  *      int     fndsym()    lklibr.c
 338  *
 339  *  side effects:
 340  *      If a symbol is found then the library object module
 341  *      containing the symbol will be imported and linked.
 342  */
 343
 344 VOID
 345 search()
 346 {
 347     register struct sym *sp;
 348     register int i,symfnd;
 349
 350     /*
 351      * Look for undefined symbols.  Keep
 352      * searching until no more symbols are resolved.
 353      */
 354     symfnd = 1;
 355     while (symfnd) {
 356         symfnd = 0;
 357         /*
 358          * Look through all the symbols
 359          */
 360         for (i=0; i<NHASH; ++i) {
 361             sp = symhash[i];
 362             while (sp) {
 363                 /* If we find an undefined symbol
 364                  * (one where S_DEF is not set), then
 365                  * try looking for it.  If we find it
 366                  * in any of the libraries then
 367                  * increment symfnd.  This will force
 368                  * another pass of symbol searching and
 369                  * make sure that back references work.
 370                  */
 371                 if ((sp->s_type & S_DEF) == 0) {
 372                     if (fndsym(sp->s_id)) {
 373                         symfnd++;
 374                     }
 375                 }
 376                 sp = sp->s_sp;
 377             }
 378         }
 379     }
 380 }
 381
 382 /*Load a .rel file embedded in a sdcclib file*/
 383 void LoadRel(char * libfname, FILE * libfp, char * ModName)
 384 {
 385     char str[NINPUT+2];
 386     int state=0;
 387
 388     while (fgets(str, NINPUT, libfp) != NULL)
 389     {
 390         str[NINPUT+1] = '\0';
 391         chop_crlf(str);
 392         switch(state)
 393         {
 394             case 0:
 395                 if(EQ(str, "<FILE>"))
 396                 {
 397                     fgets(str, NINPUT, libfp);
 398                     str[NINPUT+1] = '\0';
 399                     chop_crlf(str);
 400                     if(EQ(str, ModName)) state=1;
 401                     else
 402                     {
 403                         fprintf(stderr, "?Aslink-Error-Bad offset in library file %s(%s)\n",
 404                             libfname, ModName);
 405                         lkexit(1);
 406                     }
 407                 }
 408             break;
 409             case 1:
 410                 if(EQ(str, "<REL>")) state=2;
 411             break;
 412             case 2:
 413                 if(EQ(str, "</REL>")) return;
 414                 ip = str;
 415                 link_main();
 416             break;
 417         }
 418     }
 419 }
 420
 421 /*Load an .adb file embedded in a sdcclib file.  If there is
 422 something between <ADB> and </ADB> returns 1, otherwise returns 0.
 423 This way the aomf51 will not have uselless empty modules. */
 424
 425 int LoadAdb(FILE * libfp)
 426 {
 427     char str[MAXLINE+1];
 428     int state=0;
 429     int ToReturn=0;
 430
 431     while (fgets(str, MAXLINE, libfp) != NULL)
 432     {
 433         str[NINPUT+1] = '\0';
 434         chop_crlf(str);
 435         switch(state)
 436         {
 437             case 0:
 438                 if(EQ(str, "<ADB>")) state=1;
 439             break;
 440             case 1:
 441                 if(EQ(str, "</ADB>")) return ToReturn;
 442                 fprintf(dfp, "%s\n", str);
 443                 ToReturn=1;
 444             break;
 445         }
 446     }
 447     return ToReturn;
 448 }
 449
 450 /*Check for a symbol in a SDCC library.  If found, add the embedded .rel and
 451 .adb files from the library.  The library must be created with the SDCC
 452 librarian 'sdcclib' since the linking process depends on the correct file offsets
 453 embedded in the library file.*/
 454
 455 int SdccLib(char * PathLib, FILE * libfp, char * DirLib, char * SymName)
 456 {
 457     struct lbfile *lbfh, *lbf;
 458     char ModName[NCPS]="";
 459     char FLine[MAXLINE+1];
 460     int state=0;
 461     long IndexOffset=0, FileOffset;
 462
 463     while(!feof(libfp))
 464     {
 465         FLine[0]=0;
 466         fgets(FLine, MAXLINE, libfp);
 467         chop_crlf(FLine);
 468
 469         switch(state)
 470         {
 471             case 0:
 472                 if(EQ(FLine, "<INDEX>"))
 473                 {
 474                     /*The next line has the size of the index*/
 475                     FLine[0]=0;
 476                     fgets(FLine, MAXLINE, libfp);
 477                     chop_crlf(FLine);
 478                     IndexOffset=atol(FLine);
 479                     state=1;
 480                 }
 481             break;
 482             case 1:
 483                 if(EQ(FLine, "<MODULE>"))
 484                 {
 485                     /*The next line has the name of the module and the offset
 486                     of the corresponding embedded file in the library*/
 487                     FLine[0]=0;
 488                     fgets(FLine, MAXLINE, libfp);
 489                     chop_crlf(FLine);
 490                     sscanf(FLine, "%s %ld", ModName, &FileOffset);
 491                     state=2;
 492                 }
 493                 else if(EQ(FLine, "</INDEX>"))
 494                 {
 495                     /*Reached the end of the index.  The symbol is not in this library.*/
 496                     return 0;
 497                 }
 498             break;
 499             case 2:
 500                 if(EQ(FLine, "</MODULE>"))
 501                 {
 502                     /*The symbol is not in this module, try the next one*/
 503                     state=1;
 504                 }
 505                 else
 506                 {
 507                     /*Check if this is the symbol we are looking for.*/
 508                     if (strncmp(SymName, FLine, NCPS)==0)
 509                     {
 510                         /*The symbol is in this module.*/
 511
 512                         /*As in the original library format, it is assumed that the .rel
 513                         files reside in the same directory as the lib files.*/
 514                         strcat(DirLib, ModName);
 515                         sprintf(&DirLib[strlen(DirLib)], "%crel", FSEPX);
 516
 517                         /*If this module has been loaded already don't load it again.*/
 518                         lbf = lbfhead;
 519                         while (lbf)
 520                         {
 521                             if(EQ(DirLib, lbf->filspc)) return 1;/*Already loaded*/
 522                             lbf=lbf->next;
 523                         }
 524
 525                         /*Add the embedded file to the list of files to be loaded in
 526                         the second pass.  That is performed latter by the function
 527                         library() below.*/
 528                         lbfh = (struct lbfile *) new (sizeof(struct lbfile));
 529                         if (lbfhead == NULL)
 530                         {
 531                             lbfhead = lbfh;
 532                         }
 533                         else
 534                         {
 535                             lbf = lbfhead;
 536                             while (lbf->next)
 537                             lbf = lbf->next;
 538                             lbf->next = lbfh;
 539                         }
 540
 541                         lbfh->libspc = PathLib;
 542                         lbfh->filspc = DirLib;
 543                         lbfh->relfil = (char *) new (strlen(ModName) + 1);
 544                         strcpy(lbfh->relfil, ModName);
 545                         /*Library embedded file, so lbfh->offset must be >=0*/
 546                         lbfh->offset = IndexOffset+FileOffset;
 547
 548                         /*Jump to where the .rel begins and load it.*/
 549                         fseek(libfp, lbfh->offset, SEEK_SET);
 550                         LoadRel(PathLib, libfp, ModName);
 551
 552                         /* if cdb information required & .adb file present */
 553                         if (dflag && dfp)
 554                         {
 555                             if(LoadAdb(libfp))
 556                                 SaveLinkedFilePath(DirLib);
 557                         }
 558                         return 1; /*Found the symbol, so success!*/
 559                     }
 560                 }
 561             break;
 562
 563             default:
 564                 return 0; /*It should never reach this point, but just in case...*/
 565             break;
 566         }
 567     }
 568
 569     return 0; /*The symbol is not in this library*/
 570 }
 571
 572 /*)Function VOID    fndsym(name)
 573  *
 574  *      char    *name       symbol name to find
 575  *
 576  *  The function fndsym() searches through all combinations of the
 577  *  library path specifications (input by the -k option) and the
 578  *  library file specifications (input by the -l option) that
 579  *  lead to an existing file.
 580  *
 581  *  The file specicifation may be formed in one of two ways:
 582  *
 583  *  (1) If the library file contained an absolute
 584  *      path/file specification then this becomes filspc.
 585  *      (i.e. C:\...)
 586  *
 587  *  (2) If the library file contains a relative path/file
 588  *      specification then the concatenation of the path
 589  *      and this file specification becomes filspc.
 590  *      (i.e. \...)
 591  *
 592  *  The structure lbfile is created for the first library
 593  *  object file which contains the definition for the
 594  *  specified undefined symbol.
 595  *
 596  *  If the library file [.LIB] contains file specifications for
 597  *  non existant files, no errors are returned.
 598  *
 599  *  local variables:
 600  *      char    buf[]       [.REL] file input line
 601  *      char    c           [.REL] file input character
 602  *      FILE    *fp         file handle for object file
 603  *      lbfile  *lbf        temporary pointer
 604  *      lbfile  *lbfh       pointer to lbfile structure
 605  *      FILE    *libfp      file handle for library file
 606  *      lbname  *lbnh       pointer to lbname structure
 607  *      char    *path       file specification path
 608  *      char    relfil[]    [.REL] file specification
 609  *      char    *str        combined path and file specification
 610  *      char    symname[]   [.REL] file symbol string
 611  *
 612  *  global variables:
 613  *      lbname  *lbnhead    The pointer to the first
 614  *                          name structure
 615  *      lbfile  *lbfhead    The pointer to the first
 616  *                          file structure
 617  *
 618  *   functions called:
 619  *      int     fclose()    c_library
 620  *      int     fgets()     c_library
 621  *      FILE    *fopen()    c_library
 622  *      VOID    free()      c_library
 623  *      char    getnb()     lklex.c
 624  *      VOID    lkexit()    lkmain.c
 625  *      VOID    loadfile()  lklibr.c
 626  *      VOID *  new()       lksym.c
 627  *      char *  sprintf()   c_library
 628  *      int     sscanf()    c_library
 629  *      char *  strcat()    c_library
 630  *      char *  strchr()    c_library
 631  *      char *  strcpy()    c_library
 632  *      int     strlen()    c_library
 633  *      int     strncmp()   c_library
 634  *      VOID    unget()     lklex.c
 635  *
 636  *  side effects:
 637  *      If the symbol is found then a new lbfile structure
 638  *      is created and added to the linked list of lbfile
 639  *      structures.  The file containing the found symbol
 640  *      is linked.
 641  */
 642
 643 #ifdef INDEXLIB
 644
 645 int fndsym( char *name )
 646 {
 647     struct lbfile *lbfh, *lbf;
 648     pmlibraryfile ThisLibr;
 649     pmlibrarysymbol ThisSym = NULL;
 650
 651     pmlibraryfile FirstFound;
 652     int numfound=0;
 653
 654     /* Build the index if this is the first call to fndsym */
 655     if (libr==NULL) buildlibraryindex();
 656
 657     /* Iterate through all library object files */
 658     ThisLibr = libr;
 659     FirstFound = libr; /*So gcc stops whining*/
 660     while (ThisLibr)
 661     {
 662         /* Iterate through all symbols in an object file */
 663         ThisSym = ThisLibr->symbols;
 664
 665         while (ThisSym)
 666         {
 667             if (!strcmp(ThisSym->name, name))
 668             {
 669                 if ((!ThisLibr->loaded) && (numfound==0))
 670                 {
 671                     /* Object file is not loaded - add it to the list */
 672                     lbfh = (struct lbfile *) new (sizeof(struct lbfile));
 673                     if (lbfhead == NULL)
 674                     {
 675                         lbfhead = lbfh;
 676                     }
 677                     else
 678                     {
 679                         lbf = lbfhead;
 680                         while (lbf->next)
 681                         lbf = lbf->next;
 682                         lbf->next = lbfh;
 683                     }
 684                     lbfh->libspc = ThisLibr->libspc;
 685                     lbfh->filspc = ThisLibr->filename;
 686                     lbfh->relfil = (char *) new (strlen(ThisLibr->relfil) + 1);
 687                     strcpy(lbfh->relfil, ThisLibr->relfil);
 688                     lbfh->offset = ThisLibr->offset;
 689                     if(lbfh->offset>0)
 690                     { /*For an embedded object file in a library*/
 691                         void loadfile_SdccLib(char * libspc, char * module, long offset);
 692                         loadfile_SdccLib(lbfh->libspc, lbfh->relfil, lbfh->offset);
 693                     }
 694                     else
 695                     { /*For a stand alone object file*/
 696                         /* if cdb information required & adb file present */
 697                         if (dflag && dfp)
 698                         {
 699                             FILE *xfp = afile(lbfh->filspc, "adb",0);
 700                             if (xfp)
 701                             {
 702                                 SaveLinkedFilePath(lbfh->filspc);
 703                                 copyfile(dfp, xfp);
 704                                 fclose(xfp);
 705                             }
 706                         }
 707                         loadfile(lbfh->filspc);
 708                     }
 709                     ThisLibr->loaded=1;
 710                 }
 711
 712                 if(numfound==0)
 713                 {
 714                     numfound++;
 715                     FirstFound=ThisLibr;
 716                 }
 717                 else
 718                 {
 719                     char absPath1[PATH_MAX];
 720                     char absPath2[PATH_MAX];
 721 #if defined(__BORLANDC__) || defined(_MSC_VER) || defined(__MINGW32__)
 722                     int j;
 723
 724                     _fullpath(absPath1, FirstFound->libspc, PATH_MAX);
 725                     _fullpath(absPath2, ThisLibr->libspc, PATH_MAX);
 726                     for(j=0; absPath1[j]!=0; j++) absPath1[j]=tolower((unsigned char)absPath1[j]);
 727                     for(j=0; absPath2[j]!=0; j++) absPath2[j]=tolower((unsigned char)absPath2[j]);
 728 #else
 729                     realpath(FirstFound->libspc, absPath1);
 730                     realpath(ThisLibr->libspc, absPath2);
 731 #endif
 732                     if( !( EQ(absPath1, absPath2) && EQ(FirstFound->relfil, ThisLibr->relfil) ) )
 733                     {
 734                         if(numfound==1)
 735                         {
 736                             fprintf(stderr, "?Aslink-Warning-Definition of public symbol '%s'"
 737                                    " found more than once:\n", name);
 738                             fprintf(stderr, "   Library: '%s', Module: '%s'\n",
 739                                     FirstFound->libspc, FirstFound->relfil);
 740                         }
 741                         fprintf(stderr, "   Library: '%s', Module: '%s'\n",
 742                                 ThisLibr->libspc, ThisLibr->relfil);
 743                         numfound++;
 744                     }
 745                 }
 746             }
 747             ThisSym=ThisSym->next;  /* Next sym in library */
 748         }
 749         ThisLibr=ThisLibr->next; /* Next library in list */
 750     }
 751     return numfound;
 752 }
 753
 754 pmlibraryfile buildlibraryindex_SdccLib(char * PathLib, FILE * libfp, char * DirLib, pmlibraryfile This)
 755 {
 756     char ModName[NCPS]="";
 757     char FLine[MAXLINE+1];
 758     char buff[PATH_MAX];
 759     int state=0;
 760     long IndexOffset=0, FileOffset;
 761     pmlibrarysymbol ThisSym = NULL;
 762
 763     while(!feof(libfp))
 764     {
 765         FLine[0]=0;
 766         fgets(FLine, MAXLINE, libfp);
 767         chop_crlf(FLine);
 768
 769         switch(state)
 770         {
 771             case 0:
 772                 if(EQ(FLine, "<INDEX>"))
 773                 {
 774                     /*The next line has the size of the index*/
 775                     FLine[0]=0;
 776                     fgets(FLine, MAXLINE, libfp);
 777                     chop_crlf(FLine);
 778                     IndexOffset=atol(FLine);
 779                     state=1;
 780                 }
 781             break;
 782             case 1:
 783                 if(EQ(FLine, "<MODULE>"))
 784                 {
 785                     /*The next line has the name of the module and the offset
 786                     of the corresponding embedded file in the library*/
 787                     FLine[0]=0;
 788                     fgets(FLine, MAXLINE, libfp);
 789                     chop_crlf(FLine);
 790                     sscanf(FLine, "%s %ld", ModName, &FileOffset);
 791                     state=2;
 792
 793                     /*Create a new libraryfile object for this module*/
 794                     if(libr==NULL)
 795                     {
 796                         libr=This=(pmlibraryfile)new( sizeof( mlibraryfile ));
 797                     }
 798                     else
 799                     {
 800                         This->next=(pmlibraryfile)new( sizeof( mlibraryfile ));
 801                         This=This->next;
 802                     }
 803                     This->next = NULL;
 804                     This->loaded=-1;
 805                     This->offset=FileOffset+IndexOffset;
 806                     This->libspc=PathLib;
 807
 808                     This->relfil=(char *)new(strlen(ModName)+1);
 809                     strcpy(This->relfil, ModName);
 810
 811                     sprintf(buff, "%s%s%crel", DirLib, ModName, FSEPX);
 812                     This->filename=(char *)new(strlen(buff)+1);
 813                     strcpy(This->filename, buff);
 814
 815                     This->symbols=ThisSym=NULL; /*Start a new linked list of symbols*/
 816                 }
 817                 else if(EQ(FLine, "</INDEX>"))
 818                 {
 819                     return This; /*Finish, get out of here*/
 820                 }
 821             break;
 822             case 2:
 823                 if(EQ(FLine, "</MODULE>"))
 824                 {
 825                     This->loaded=0;
 826                     /*Create the index for the next module*/
 827                     state=1;
 828                 }
 829                 else
 830                 {
 831                     /*Add the symbols*/
 832                     if(ThisSym==NULL) /*First symbol of the current module*/
 833                     {
 834                         ThisSym=This->symbols=(pmlibrarysymbol)new(sizeof(mlibrarysymbol));
 835                     }
 836                     else
 837                     {
 838                         ThisSym->next = (pmlibrarysymbol)new(sizeof(mlibrarysymbol));
 839                         ThisSym=ThisSym->next;
 840                     }
 841                     ThisSym->next=NULL;
 842                     ThisSym->name=(char *)new(strlen(FLine)+1);
 843                     strcpy(ThisSym->name, FLine);
 844                 }
 845             break;
 846
 847             default:
 848                 return This; /*State machine should never reach this point, but just in case...*/
 849             break;
 850         }
 851     }
 852
 853     return This; /*State machine should never reach this point, but just in case...*/
 854 }
 855
 856
 857 /* buildlibraryindex - build an in-memory cache of the symbols contained in
 858  *                     the libraries
 859  */
 860 int buildlibraryindex(void)
 861 {
 862     FILE *libfp, *fp;
 863     struct lbname *lbnh;
 864     char relfil[NINPUT+2], str[PATH_MAX], *path;
 865     char buf[NINPUT+2], c;
 866     char symname[NINPUT+2];
 867     pmlibraryfile This=NULL;
 868     pmlibrarysymbol ThisSym;
 869
 870     /*
 871      * Search through every library in the linked list "lbnhead".
 872      */
 873
 874     for (lbnh=lbnhead; lbnh; lbnh=lbnh->next)
 875     {
 876         if ((libfp = fopen(lbnh->libspc, "r")) == NULL)
 877         {
 878             fprintf(stderr, "?Aslink-Error-Cannot open library file %s\n",
 879                 lbnh->libspc);
 880             lkexit(1);
 881         }
 882         path = lbnh->path;
 883
 884         /*
 885          * Read in a line from the library file.
 886          * This is the relative file specification
 887          * for a .REL file in this library.
 888          */
 889
 890         while (fgets(relfil, NINPUT, libfp) != NULL)
 891         {
 892             relfil[NINPUT+1] = '\0';
 893             chop_crlf(relfil);
 894             if (path != NULL)
 895             {
 896                 strcpy(str, path);
 897 #ifdef  OTHERSYSTEM
 898                 if (strlen(str) && (str[strlen(str)-1] != '/') && (str[strlen(str)-1] != '\\'))
 899                 {
 900                     strcat(str,"/");
 901                 }
 902 #endif
 903             }
 904             else
 905             {
 906                 strcpy(str, "");
 907             }
 908
 909             if(strcmp(relfil, "<SDCCLIB>")==0)
 910             {
 911                 /*Get the built in index of this library*/
 912                 This=buildlibraryindex_SdccLib(lbnh->libspc, libfp, str, This);
 913                 break; /*get the index for next library*/
 914             }
 915
 916             /*From here down, build the index for the original library format*/
 917
 918             if (relfil[0] == '\\')
 919             {
 920                 strcat(str,relfil+1);
 921             }
 922             else
 923             {
 924                 strcat(str,relfil);
 925             }
 926
 927             if(strchr(relfil, FSEPX) == NULL)
 928             {
 929                 sprintf(&str[strlen(str)], "%crel", FSEPX);
 930             }
 931
 932             if ((fp = fopen(str, "r")) != NULL)
 933             {
 934                 /* Opened OK - create a new libraryfile object for it */
 935                 if(libr==NULL)
 936                 {
 937                     libr=This=(pmlibraryfile)new( sizeof( mlibraryfile ));
 938                 }
 939                 else
 940                 {
 941                     This->next=(pmlibraryfile)new( sizeof( mlibraryfile ));
 942                     This=This->next;
 943                 }
 944                 This->next = NULL;
 945                 This->loaded=-1;
 946                 This->offset=-1; /*We have a stand alone .rel file*/
 947                 This->libspc = lbnh->libspc;
 948
 949                 This->relfil=(char *)new(strlen(relfil)+1);
 950                 strcpy(This->relfil, relfil);
 951
 952                 This->filename=(char *)new(strlen(str)+1);
 953                 strcpy(This->filename, str);
 954
 955                 /*Start a new linked list of symbols for this module:*/
 956                 This->symbols=ThisSym=NULL;
 957
 958                 /*
 959                  * Read in the object file.  Look for lines that
 960                  * begin with "S" and end with "D".  These are
 961                  * symbol table definitions.  If we find one, see
 962                  * if it is our symbol.  Make sure we only read in
 963                  * our object file and don't go into the next one.
 964                  */
 965
 966                 while (fgets(buf, NINPUT, fp) != NULL)
 967                 {
 968                     buf[NINPUT+1] = '\0';
 969                     buf[strlen(buf) - 1] = '\0';
 970
 971                     /*
 972                      * Skip everything that's not a symbol record.
 973                      */
 974                     if (buf[0] != 'S') continue;
 975
 976                     /*
 977                      * When a 'T line' is found terminate file scan.
 978                      * All 'S line's preceed 'T line's in .REL files.
 979                      */
 980                     if (buf[0] == 'T') break;
 981
 982                     sscanf(buf, "S %s %c", symname, &c);
 983
 984                     /* If it's an actual symbol, record it */
 985                     if (c == 'D')
 986                     {
 987                         if(ThisSym==NULL)
 988                         {
 989                             ThisSym=This->symbols=(pmlibrarysymbol)new(sizeof(mlibrarysymbol));
 990                         }
 991                         else
 992                         {
 993                             ThisSym->next=(pmlibrarysymbol)new(sizeof(mlibrarysymbol));
 994                             ThisSym=ThisSym->next;
 995                         }
 996                         This->loaded=0;
 997                         ThisSym->next=NULL;
 998                         ThisSym->name=(char *)new(strlen(symname)+1);
 999                         strcpy(ThisSym->name, symname);
1000                     }
1001                 } /* Closes while - read object file */
1002                 fclose(fp);
1003             } /* Closes if object file opened OK */
1004             else
1005             {
1006                 fprintf(stderr, "?Aslink-Warning-Cannot open library module %s\n", str);
1007             }
1008         } /* Ends while - processing all in libr */
1009         fclose(libfp);
1010     } /* Ends good open of libr file */
1011     return 0;
1012 }
1013
1014 /*Release all memory allocated for the in-memory library index*/
1015 void freelibraryindex (void)
1016 {
1017     pmlibraryfile ThisLibr, ThisLibr2Free;
1018     pmlibrarysymbol ThisSym, ThisSym2Free;
1019
1020     ThisLibr = libr;
1021
1022     while (ThisLibr)
1023     {
1024         ThisSym = ThisLibr->symbols;
1025
1026         while (ThisSym)
1027         {
1028             free(ThisSym->name);
1029             ThisSym2Free=ThisSym;
1030             ThisSym=ThisSym->next;
1031             free(ThisSym2Free);
1032         }
1033         free(ThisLibr->filename);
1034         free(ThisLibr->relfil);
1035         ThisLibr2Free=ThisLibr;
1036         ThisLibr=ThisLibr->next;
1037         free(ThisLibr2Free);
1038     }
1039
1040     libr=NULL;
1041 }
1042
1043 #else /* INDEXLIB */
1044
1045 int
1046 fndsym(name)
1047 char *name;
1048 {
1049     FILE *libfp, *fp;
1050     struct lbname *lbnh;
1051     struct lbfile *lbfh, *lbf;
1052     char relfil[NINPUT+2];
1053     char buf[NINPUT+2];
1054     char symname[NINPUT];
1055     char *path,*str;
1056     char c;
1057     int result;
1058
1059     /*
1060      * Search through every library in the linked list "lbnhead".
1061      */
1062
1063     for (lbnh=lbnhead; lbnh; lbnh=lbnh->next)
1064     {
1065         if ((libfp = fopen(lbnh->libspc, "r")) == NULL)
1066         {
1067             fprintf(stderr, "?Aslink-Error-Cannot open library file %s\n",
1068                 lbnh->libspc);
1069             lkexit(1);
1070         }
1071         path = lbnh->path;
1072
1073         /*
1074          * Read in a line from the library file.
1075          * This is the relative file specification
1076          * for a .REL file in this library.
1077          */
1078
1079         while (fgets(relfil, NINPUT, libfp) != NULL)
1080         {
1081             relfil[NINPUT+1] = '\0';
1082             chop_crlf(relfil);
1083             if (path != NULL)
1084             {
1085                 str = (char *) new (strlen(path)+strlen(relfil)+6);
1086                 strcpy(str,path);
1087 #ifdef  OTHERSYSTEM
1088                 if (strlen(str) && (str[strlen(str)-1] != '/') && (str[strlen(str)-1] != '\\'))
1089                 {
1090                     strcat(str,"/");
1091                 }
1092 #endif
1093             }
1094             else
1095             {
1096                 str = (char *) new (strlen(relfil) + 5);
1097             }
1098
1099             if(strcmp(relfil, "<SDCCLIB>")==0)
1100             {
1101                 result=SdccLib(lbnh->libspc, libfp, str, name);
1102                 if(result) return(1); /*Found the symbol*/
1103                 free(str);
1104                 /*The symbol is not in the current library,
1105                 check the next library in the list*/
1106                 break;
1107             }
1108
1109             /*From here down is the support for libraries in the original format*/
1110             if (relfil[0] == '\\')
1111             {
1112                 strcat(str,relfil+1);
1113             }
1114             else
1115             {
1116                 strcat(str,relfil);
1117             }
1118
1119             if(strchr(relfil, FSEPX) == NULL)
1120             {
1121                 sprintf(&str[strlen(str)], "%crel", FSEPX);
1122             }
1123
1124             if ((fp = fopen(str, "r")) != NULL)
1125             {
1126
1127                 /*
1128                  * Read in the object file.  Look for lines that
1129                  * begin with "S" and end with "D".  These are
1130                  * symbol table definitions.  If we find one, see
1131                  * if it is our symbol.  Make sure we only read in
1132                  * our object file and don't go into the next one.
1133                  */
1134
1135                 while (fgets(buf, NINPUT, fp) != NULL)
1136                 {
1137                     buf[NINPUT+1] = '\0';
1138                     chop_crlf(buf);
1139                     /*
1140                      * Skip everything that's not a symbol record.
1141                      */
1142                     if (buf[0] != 'S') continue;
1143
1144                     /*
1145                     * When a 'T line' is found terminate file scan.
1146                     * All 'S line's preceed 'T line's in .REL files.
1147                     */
1148                     if (buf[0] == 'T') break;
1149
1150                     sscanf(buf, "S %s %c", symname, &c);
1151
1152                     /*
1153                     * If we find a symbol definition for the
1154                     * symbol we're looking for, load in the
1155                     * file and add it to lbfhead so it gets
1156                     * loaded on pass number 2.
1157                     */
1158                     if (strncmp(symname, name, NCPS) == 0 && c == 'D')
1159                     {
1160                         lbfh = (struct lbfile *) new (sizeof(struct lbfile));
1161                         if (lbfhead == NULL)
1162                         {
1163                             lbfhead = lbfh;
1164                         }
1165                         else
1166                         {
1167                             lbf = lbfhead;
1168                             while (lbf->next)
1169                             lbf = lbf->next;
1170                             lbf->next = lbfh;
1171                         }
1172
1173                         lbfh->libspc = lbnh->libspc;
1174                         lbfh->filspc = str;
1175                         lbfh->relfil = (char *) new (strlen(relfil) + 1);
1176                         lbfh->offset = -1; /*Stand alone rel file*/
1177                         strcpy(lbfh->relfil,relfil);
1178                         fclose(fp);
1179                         fclose(libfp);
1180
1181                         /* if cdb information required & adb file present */
1182                         if (dflag && dfp)
1183                         {
1184                             FILE *xfp = afile(str,"adb",0); //JCF: Nov 30, 2002
1185                             if (xfp)
1186                             {
1187                                 SaveLinkedFilePath(str);
1188                                 copyfile(dfp,xfp);
1189                                 fclose(xfp);
1190                             }
1191                         }
1192                         loadfile(str);
1193                         return (1);
1194                     }
1195                 }
1196                 fclose(fp);
1197             }
1198             free(str);
1199         }
1200         fclose(libfp);
1201     }
1202     return(0);
1203 }
1204
1205 #endif /*INDEXLIB*/
1206
1207 void loadfile_SdccLib(char * libspc, char * module, long offset)
1208 {
1209     FILE *fp;
1210
1211     if ((fp = fopen(libspc,"r")) != NULL)
1212     {
1213         fseek(fp, offset, SEEK_SET);
1214         LoadRel(libspc, fp, module);
1215         fclose(fp);
1216     }
1217 }
1218
1219 /*)Function VOID    library()
1220  *
1221  *  The function library() links all the library object files
1222  *  contained in the lbfile structures.
1223  *
1224  *  local variables:
1225  *      lbfile  *lbfh       pointer to lbfile structure
1226  *
1227  *  global variables:
1228  *      lbfile  *lbfhead    pointer to first lbfile structure
1229  *
1230  *   functions called:
1231  *      VOID    loadfile    lklibr.c
1232  *
1233  *  side effects:
1234  *      Links all files contained in the lbfile structures.
1235  */
1236
1237 VOID
1238 library()
1239 {
1240     struct lbfile *lbfh;
1241
1242     for (lbfh=lbfhead; lbfh; lbfh=lbfh->next)
1243     {
1244         if(lbfh->offset<0)
1245         {
1246             /*Stand alone rel file (original lib format)*/
1247             loadfile(lbfh->filspc);
1248         }
1249         else
1250         {
1251             /*rel file embedded in lib (new lib format)*/
1252             loadfile_SdccLib(lbfh->libspc, lbfh->relfil, lbfh->offset);
1253         }
1254     }
1255 #ifdef INDEXLIB
1256     freelibraryindex();
1257 #endif
1258 }
1259
1260 /*)Function VOID    loadfile(filspc)
1261  *
1262  *      char    *filspc     library object file specification
1263  *
1264  *  The function loadfile() links the library object module.
1265  *
1266  *  local variables:
1267  *      FILE    *fp         file handle
1268  *      int     i           input line length
1269  *      char    str[]       file input line
1270  *
1271  *  global variables:
1272  *      char    *ip     pointer to linker input string
1273  *
1274  *   functions called:
1275  *      int     fclose()    c_library
1276  *      int     fgets()     c_library
1277  *      FILE *  fopen()     c_library
1278  *      VOID    link_main() lkmain.c
1279  *      int     strlen()    c_library
1280  *
1281  *  side effects:
1282  *      If file exists it is linked.
1283  */
1284
1285 VOID
1286 loadfile(filspc)
1287 char *filspc;
1288 {
1289     FILE *fp;
1290     char str[NINPUT+2];
1291
1292     if ((fp = fopen(filspc,"r")) != NULL) {
1293         while (fgets(str, NINPUT, fp) != NULL) {
1294             str[NINPUT+1] = '\0';
1295             chop_crlf(str);
1296             ip = str;
1297             link_main();
1298         }
1299         fclose(fp);
1300     }
1301 }