liblist.c File Reference

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>

Go to the source code of this file.

Macros
#define	BUFSIZE   1000000
#define	NLIBMAX   200
#define	TRIGSIZE   1000

Functions
int	main (int argc, char **argv)
char **	parsedir (char *directory, int *argc)

Variables
char *	optarg
int	opterr
int	optind
int	optopt

Macro Definition Documentation

BUFSIZE

#define BUFSIZE   1000000

Definition at line 40 of file liblist.c.

NLIBMAX

#define NLIBMAX   200

Definition at line 42 of file liblist.c.

TRIGSIZE

#define TRIGSIZE   1000

Definition at line 41 of file liblist.c.

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 126 of file liblist.c.

                                 {
 
  char static buffer[BUFSIZE],*bufferPtr,workbuf[256];
  char *ptr,*p,**pp,**pp1,**pp2,*directory=0,*libpath=0;
  char **rargv;
  char *libname=0;
  int i,optl=0,optm=0,swapping,c,rargc;
  FILE *fp;
 
#if defined ( _WIN32 ) || defined ( __CYGWIN__ ) || defined ( __CYGWIN32__ )
  char *ntg4tmp=0,*ntg4tmp1=0;
  int nti; 
#endif
 
  struct libmap_
    {
      char *lib;      /* Library name, e.g., G4run. */
      char *trigger;  /* Source directory, e.g., source/run/.  */
      int used;       /* True if used by these dependency files.  */
      char **uses;    /* List of library names which this library uses.  */
      struct libmap_ *next;
  };
 
  struct libmap_ *libmap=0,*libmapPtr=0,*libmapPtr1=0,*libmapPtr2=0,
    *prevPtr1,*prevPtr2,*tmpp,*userLibmapPtr;
 
  while((c=getopt(argc,argv,"ld: m:"))!=EOF)
    {
      switch(c)
    {
    case 'l':
      optl=1;
      break;
    case 'd':
      directory=strdup(optarg);
      break;
        case 'm':
          optm=1;
      libpath=strdup(optarg);
          break;
    }
    }
      
  /*Adjust parameters after parsing options */
 
  if(optind<argc)
    {
      rargv=&argv[optind];
      rargc=argc-optind;
    }
  else
    {
      rargv=0;
      rargc=0;
    }
 
  if(directory)
    {
      if(rargc==0)
    {
      rargv=parsedir(directory,&rargc);
    }
      else
    {
      fprintf
        (stderr,
         "  ERROR: If you specify a directory don't also specify files\n");
      exit(1);
    }
    }
 
  if(optl)fprintf(stderr,"  Reading library name map file...\n");
  while (!feof(stdin))
    {
      /* Get library name... */
      fgets(buffer,BUFSIZE,stdin);
      if(feof(stdin)) break;
      if (strlen(buffer) >= BUFSIZE-1)
      {
         fprintf(stderr,
       " Internal ERROR: BUFSIZE too small to read library name map file\n");
     exit(1);
      }
           /* discarded trailing \n, as gets() was doing */
      if ( buffer[strlen(buffer)-1] == '\n') 
        {   buffer[strlen(buffer)-1]='\0'; }  
 
      ptr=strtok(buffer,":\n");
 
      /* Check for duplicate names... */
      for(libmapPtr1=libmap;libmapPtr1;libmapPtr1=libmapPtr1->next)
    {
      if(strcmp(libmapPtr1->lib,ptr)==0)
        {
          fprintf(stderr,"  ERROR: Duplicate library name: %s\n",ptr);
          fprintf(stderr,
              "  Perhaps a duplicate subdirectory with"
              " a GNUmakefile with the same library name.\n"
              );
          exit(1);
        }
    }
 
      if(libmap)
    {
      libmapPtr->next=(struct libmap_*) malloc(sizeof(struct libmap_));
      libmapPtr=libmapPtr->next;
    }
      else /* First time through anchor libmapPtr to libmap. */
    {
      libmap=(struct libmap_*) malloc(sizeof(struct libmap_));
      libmapPtr=libmap;
    }
      libmapPtr->next=0;      
      libmapPtr->lib=strdup(ptr);
      libmapPtr->used=0;
      libmapPtr->uses=(char**)calloc(NLIBMAX,sizeof(char*));
 
      /* If option -l not specified, fill uses list... */
      if(!optl && !optm)
    {
      pp=libmapPtr->uses;
      if(ptr)
        {
          ptr=strtok(NULL," \n");
          while (ptr)
        {
          *pp=strdup(ptr);
          pp++;
          ptr=strtok(NULL," \n");
        }
        }
    }
 
      if(!optm)
        {
          /* Get directory name... */
          fgets(buffer,BUFSIZE,stdin);
      if (strlen(buffer) >= BUFSIZE-1)
      {
             fprintf(stderr,
           " Internal ERROR: BUFSIZE too small to read directory name\n");
         exit(1);
      }
           /* discarded trailing \n, as gets() was doing */
          if ( buffer[strlen(buffer)-1] == '\n') 
             {   buffer[strlen(buffer)-1]='\0'; }  
 
          ptr=strtok(buffer,"/");
          if(!ptr)
        {
          fprintf(stderr,"  ERROR: \"/\" before \"source\" expected.\n");
          exit(1);
        }
          while(ptr&&strcmp (ptr,"source"))ptr=strtok(NULL,"/");
          ptr=strtok(NULL,"/");
          if(!ptr)
        {
          fprintf(stderr,"  ERROR: \"source\" expected.\n");
          exit(1);
        }
          libmapPtr->trigger=(char*)malloc(TRIGSIZE);
      if(strlen(ptr)>TRIGSIZE)
          {
            fprintf(stderr,"  ERROR: String overflow for: %s\n", ptr);
            exit(1);
          }
          strcpy(libmapPtr->trigger,ptr);
          ptr=strtok(NULL,"/");
          while(ptr&&strcmp(ptr,"GNUmakefile"))
        {
          strncat(libmapPtr->trigger,"/",1);
          strcat(libmapPtr->trigger,ptr);
          ptr=strtok(NULL,"/");
        }
          if(!ptr)
        {
          fprintf
            (stderr,
             "  ERROR: \"source/<unique-sub-path>/GNUmakefile\" expected.\n");
          exit(1);
        }
    }
    }
 
  if(optl)fprintf(stderr,"  Reading dependency files...\n");
 
#if defined ( _WIN32 ) || defined ( __CYGWIN__ ) || defined ( __CYGWIN32__ )
      ntg4tmp=getenv("G4TMP");
      if ( ! ntg4tmp ) 
        {
           fprintf(stderr,"  ERROR: Cannot find environment variable G4TMP\n");
           exit(1);
        }
      ntg4tmp1=strdup(ntg4tmp);
#endif
 
  for(i=0;i<rargc;i++)
    {
      fp=fopen(rargv[i],"r");
      fgets(buffer,BUFSIZE,fp);
 
#if defined ( _WIN32 ) || defined ( __CYGWIN__ ) || defined ( __CYGWIN32__ )
      ptr=strchr(ntg4tmp1,':');
 
      while ( ptr=strchr(buffer,'\\') ) *ptr='/';
 
      while (ntg4tmp1!=NULL &&  (ptr=strstr(buffer,ntg4tmp1))!=NULL )
        {
          for(nti=0;nti<strlen(ntg4tmp1);nti++) ptr[nti]=' ';
        }
#endif
     
      /* Clip target out of dependency file... */
      ptr=strtok(buffer,":");
      
      /* Look for a "user" library... */
      for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next)
    {
      if(strlen(libmapPtr->lib)>256)
          {
            fprintf(stderr,"  ERROR: String overflow for: %s\n", libmapPtr->lib);
            exit(1);
          }
          strcpy(workbuf,libmapPtr->lib);
      /* Add trailing "/" to distinguish track/ and tracking/, etc. */
      strncat(workbuf,"/",1);
      if(strstr(ptr,workbuf)) break;
    }
      if(libmapPtr)
    {
      userLibmapPtr=libmapPtr;
    }
      else
    {
      userLibmapPtr=0;
    }
 
      if(!optm)
    {
      /* Look for a "used" library and add it to the "user" uses list... */
      bufferPtr=strtok(NULL,"\n");  /* Start *after* ":". */
      if (!bufferPtr) 
        {
          fprintf(stderr,"  WARNING: It seems there is nothing after \':\' in dependency file %s.\n", rargv[i]);
        }
      else {
      do
        {
          for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next)
            {
          /* Look for trigger string. */
              if(strlen(libmapPtr->trigger)>256)
                  {
                    fprintf(stderr,"  ERROR: String overflow for: %s\n", libmapPtr->trigger);
                    exit(1);
                  }
                  strcpy(workbuf,libmapPtr->trigger);
          strncat(workbuf,"/include",8);
          ptr=strstr(bufferPtr,workbuf);
          if(ptr && (userLibmapPtr != libmapPtr))
            {
              libmapPtr->used=1;
              if(userLibmapPtr)
                {
              for(pp=userLibmapPtr->uses;*pp;pp++)
                {
                  if(strcmp(*pp,libmapPtr->lib)==0)break;
                }
              if(!*pp)*pp=libmapPtr->lib;
                }
            }
          /* Also look for library name in case header files are
             placed in temporary directories under a subdirectory
             with the same name as the library name.  This can
             happen with Objectivity which makes header files
             from .ddl files and places them in a temporary
             directory. */
              if(strlen(libmapPtr->lib)>256)
                  {
                    fprintf(stderr,"  ERROR: String overflow for: %s\n", libmapPtr->lib);
                    exit(1);
                  }
          strcpy(workbuf,libmapPtr->lib);
          strncat(workbuf,"/",1);
          ptr=strstr(bufferPtr,workbuf);
          if(ptr && (userLibmapPtr != libmapPtr))
            {
              libmapPtr->used=1;
              if(userLibmapPtr)
                {
              for(pp=userLibmapPtr->uses;*pp;pp++)
                {
                  if(strcmp(*pp,libmapPtr->lib)==0)break;
                }
              if(!*pp)*pp=libmapPtr->lib;
                }
            }
            }
          fgets(buffer,BUFSIZE,fp);
          bufferPtr=buffer;
 
#if defined ( _WIN32 ) || defined ( __CYGWIN__ ) || defined ( __CYGWIN32__ )
          while ( ptr=strchr(buffer,'\\') ) *ptr='/';
 
          while (ntg4tmp1 &&  (ptr=strstr(buffer,ntg4tmp1)) )
            {
          for(nti=0;nti<strlen(ntg4tmp1);nti++) ptr[nti]=' ';
            }
#endif
 
        } while(!feof(fp));
      fclose(fp);
        }
      }
    }
 
#if defined ( _WIN32 ) || defined ( __CYGWIN__ ) || defined ( __CYGWIN32__ )
      free(ntg4tmp1);
#endif
 
  if(optl) /* This option is used for compiling the file libname.map
          from all the dependencies. */
    {
      fprintf(stderr,"  Checking for circular dependencies...\n");
      for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next)
    {
      for(pp=libmapPtr->uses;*pp;pp++)
        {
          for(libmapPtr1=libmap;libmapPtr1!=libmapPtr;
          libmapPtr1=libmapPtr1->next)
        {
          if(strcmp(libmapPtr1->lib,*pp)==0)
            {
              for(pp1=libmapPtr1->uses;*pp1;pp1++)
            {
              if(strcmp(*pp1,libmapPtr->lib)==0)break;
            }
              if(*pp1)
            {
              fprintf
                (stderr,
                 "  WARNING: %s and %s use each other.\n",
                 libmapPtr->lib,
                 libmapPtr1->lib);
            }
            }
          else 
            {
              /* Not right yet...
              for(pp1=libmapPtr1->uses;*pp1;pp1++)
            {
              for(libmapPtr0=libmap;libmapPtr0!=libmapPtr1;
                  libmapPtr0=libmapPtr0->next)
                {
                  if(libmapPtr0==*pp)
                {
                  fprintf
                    (stderr,
                     "  WARNING: triangular dependecy:\n"
                     "  %s uses %s uses %s uses %s.\n",
                     libmapPtr->lib,
                     libmapPtr1->lib,
                     libmapPtr0->lib,
                     libmapPtr->lib);
                }
                }
            }
              */
            }
        }
        }
    }
 
      fprintf(stderr,"  Reordering according to dependencies...\n");
      do
    {
      swapping=0;
      prevPtr2=0;
      for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next)
        {
          for(pp=libmapPtr->uses;*pp;pp++)
        {
          prevPtr1=0;
          for(libmapPtr1=libmap;libmapPtr1!=libmapPtr;
              libmapPtr1=libmapPtr1->next)
            {
              if(strcmp(libmapPtr1->lib,*pp)==0)
            {
              /* Check that 1st doesn't use 2nd... */
              for(pp1=libmapPtr1->uses;*pp1;pp1++)
                {
                  if(strcmp(*pp1,libmapPtr->lib)==0)break;
                }
              if(!*pp1) /* If not... */
                {
                  swapping=1;
                  /* Make previous of 1st now point to 2nd... */
                  if(prevPtr1)
                {
                  prevPtr1->next=libmapPtr;
                }
                  else
                {
                  libmap=libmapPtr;
                }
                  /* Make 2nd now point to what 1st did, unless
                 it's adjacent, in which case make it point
                 to 1st itself... */
                  tmpp=libmapPtr->next;
                  if(libmapPtr1->next==libmapPtr)
                {
                  libmapPtr->next=libmapPtr1;
                }
                  else
                {
                  libmapPtr->next=libmapPtr1->next;
                }
                  /* Make previous of 2nd point to 1st, unless
                 it's adjacent, in which case leave it... */
                  if(libmapPtr1->next!=libmapPtr)
                {
                  prevPtr2->next=libmapPtr1;
                }
                  /* Make 1st now point to what 2nd did... */
                  libmapPtr1->next=tmpp;
                  break;
                }
            }
              prevPtr1=libmapPtr1;
            }
          if(swapping)break;
        }
          prevPtr2=libmapPtr;
          if(swapping)break;
        }
    }while(swapping);
 
      fprintf(stderr,"  Writing new library map file...\n");
      for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next)
    {
      printf("%s:",libmapPtr->lib);
      for(pp=libmapPtr->uses;*pp;pp++)
        {
          printf(" %s",*pp);
        }
      printf("\n");
      printf("source/%s/GNUmakefile\n",libmapPtr->trigger);
    }
    }
  else if (optm)
    {
      /* create tmp. string libname */ 
      int libname_usable_size=24;
      if ( ! libname ) libname=malloc(libname_usable_size+16);
 
      /* Write out full library list... */      
      for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next)
      {
    if ( strlen(libpath)+strlen(libmapPtr->lib) > libname_usable_size ) {
      libname_usable_size=(strlen(libpath)+strlen(libmapPtr->lib))*2;
      free(libname);
      libname=malloc(libname_usable_size+16);
    }
        /* Check existance of libraries and print out only installed ones */
      
    
    sprintf(libname, "%s/lib%s.a", libpath, libmapPtr->lib);
        if (access(libname,R_OK))
    {
      sprintf(libname, "%s/lib%s.so", libpath, libmapPtr->lib);
          if (!access(libname,R_OK))
      {
            printf("-l%s ",libmapPtr->lib);
      }
          else  /* case MacOS .dylib */
          {
        sprintf(libname, "%s/lib%s.dylib", libpath, libmapPtr->lib);
            if (!access(libname,R_OK))
        {
              printf("-l%s ",libmapPtr->lib);
        }
          }
    }
        else
    {
          printf("-l%s ",libmapPtr->lib);
    }
    libmapPtr=libmapPtr->next;
      }
    }
  else
    {
      /* Add dependent libraries... */
      for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next)
    {
      if(libmapPtr->used)
        {
          for(pp=libmapPtr->uses;*pp;pp++)
        {
          for(libmapPtr1=libmap;libmapPtr1;libmapPtr1=libmapPtr1->next)
            {
              if(strcmp(libmapPtr1->lib,*pp)==0)
            {
              libmapPtr1->used=1;
            }
            }
        }         
        }
    }
 
      /* Write out library list... */
      for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next)
    {
      if(libmapPtr->used)
        {
          printf("-l%s ",libmapPtr->lib);
        }
    }
    }
      
  exit(0);
  
}

References buffer, bufferPtr, BUFSIZE, g4zmq::exit(), free, NLIBMAX, optarg, optind, parsedir(), G4InuclParticleNames::pp, and TRIGSIZE.

parsedir()

char ** parsedir	(	char *	directory,
		int *	argc
	)

Definition at line 47 of file liblist.c.

{
  DIR *actualdir;
  FILE *actualfile;
  struct dirent *entry; 
  char *buffer=0;
  struct stat status;
  char **targv=0,**ptr,**phelp;
  int len,targc,s;
 
  /*Open the actual directory*/
  actualdir=opendir(directory);
 
  if(!actualdir) return targv;
 
  /*Loop over all entries */
  for(entry=readdir(actualdir);entry!=NULL;entry=readdir(actualdir))
    {
      /* Throw away . and .. */
      if(strcmp(entry->d_name,".")==0 ||
     strcmp(entry->d_name,"..")==0) continue;
      /* Obtain the status information of that entry */
      if(buffer) free(buffer);
      buffer=(char*) malloc((strlen(directory)+
                 strlen(entry->d_name)+2)*sizeof(char));
      strcpy(buffer,directory);
      strncat(buffer,"/",1);
      strcat(buffer,entry->d_name);
      s=stat(buffer,&status);
      if(s==0)
    {
      if(S_ISDIR(status.st_mode))
        {
          /* a directory, so we are going recursive*/
          targc=0;
          ptr=parsedir(buffer,&targc);
          if(targc)
        {
          phelp=targv;
          targv=(char**) malloc((*argc+targc)*sizeof(char*));
          memcpy(targv,phelp,*argc*sizeof(char*));
          memcpy(&targv[*argc],ptr,targc*sizeof(char*));
          *argc+=targc;
          free(phelp);
          free(ptr);
        }
        }
      else if(S_ISREG(status.st_mode))
        {
          /* a regular file is it .d? */
          len=strlen(entry->d_name);
          if(entry->d_name[len-2]=='.' && entry->d_name[len-1]=='d')
        {
          phelp=targv;
          targv=(char**) malloc((*argc+1)*sizeof(char*));
          memcpy(targv,phelp,*argc*sizeof(char*));
          targv[*argc]=strdup(buffer);
          (*argc)++;
          free(phelp);
        }
        }
    }
      else
    {
      fprintf
        (stderr,
         "  No status - perhaps file %s does not exist.\n",
         directory);
      exit(1);
    }
    }
 
  if(buffer) free(buffer);
  closedir(actualdir);
 
  return targv;
}

References buffer, g4zmq::exit(), free, parsedir(), and s.

Referenced by main(), and parsedir().

Variable Documentation

optarg

char* optarg

extern

Referenced by main().

opterr

int opterr

Definition at line 45 of file liblist.c.

optind

int optind

extern

Referenced by main().

optopt

int optopt

Definition at line 45 of file liblist.c.