Geant4 Cross Reference |
1 1 2 /* 2 /* 3 Given a "libname.map" file on standard input a 3 Given a "libname.map" file on standard input and a list or directory 4 of .d dependency files liblist produces: 4 of .d dependency files liblist produces: 5 a) without -l option, a library list ordered 5 a) without -l option, a library list ordered according to the libname.map, 6 giving a warning if conflicting dependenc 6 giving a warning if conflicting dependencies are found in the .d files. 7 b) with -l option, another libname.map, orde 7 b) with -l option, another libname.map, ordered according firstly to the 8 original libname.map file, then reordered 8 original libname.map file, then reordered according to the dependencies 9 found in the .d files. This option is us 9 found in the .d files. This option is used for compiling the file 10 libname.map from all the dependencies. 10 libname.map from all the dependencies. 11 c) with -m <lpath> option, the whole existin 11 c) with -m <lpath> option, the whole existing libraries list ordered 12 according to the libname.map, where libra 12 according to the libname.map, where libraries are placed in <lpath>. 13 The .d files are specified in the argument(s). 13 The .d files are specified in the argument(s). 14 The libname.map is on standard input. 14 The libname.map is on standard input. 15 15 16 Usage: 16 Usage: 17 liblist *.d < libname.map 17 liblist *.d < libname.map 18 liblist -d <ddir> < libname.map 18 liblist -d <ddir> < libname.map 19 liblist -l *.d < libname.map 19 liblist -l *.d < libname.map 20 liblist -ld <ddir> < libname.map 20 liblist -ld <ddir> < libname.map 21 liblist -l -d <ddir> < libname.map 21 liblist -l -d <ddir> < libname.map 22 liblist -m <lpath> < libname.map 22 liblist -m <lpath> < libname.map 23 where: 23 where: 24 <ddir> is a directory name of a directory w 24 <ddir> is a directory name of a directory which is recursively 25 searched for dependency files 25 searched for dependency files 26 <lpath> is the path where libraries are loca 26 <lpath> is the path where libraries are located 27 27 28 Frank Behner, John Allison 13th February 1999. 28 Frank Behner, John Allison 13th February 1999. 29 */ 29 */ 30 30 31 #include <stdio.h> 31 #include <stdio.h> 32 #include <string.h> 32 #include <string.h> 33 #include <unistd.h> 33 #include <unistd.h> 34 #include <dirent.h> 34 #include <dirent.h> 35 #include <sys/stat.h> 35 #include <sys/stat.h> 36 #include <unistd.h> 36 #include <unistd.h> 37 #include <errno.h> 37 #include <errno.h> 38 #include <stdlib.h> 38 #include <stdlib.h> 39 39 40 #define BUFSIZE 1000000 40 #define BUFSIZE 1000000 41 #define TRIGSIZE 1000 41 #define TRIGSIZE 1000 42 #define NLIBMAX 200 42 #define NLIBMAX 200 43 43 44 extern char *optarg; 44 extern char *optarg; 45 extern int optind, opterr, optopt; 45 extern int optind, opterr, optopt; 46 46 47 char** parsedir(char *directory,int *argc) 47 char** parsedir(char *directory,int *argc) 48 { 48 { 49 DIR *actualdir; 49 DIR *actualdir; 50 FILE *actualfile; 50 FILE *actualfile; 51 struct dirent *entry; 51 struct dirent *entry; 52 char *buffer=0; 52 char *buffer=0; 53 struct stat status; 53 struct stat status; 54 char **targv=0,**ptr,**phelp; 54 char **targv=0,**ptr,**phelp; 55 int len,targc,s; 55 int len,targc,s; 56 56 57 /*Open the actual directory*/ 57 /*Open the actual directory*/ 58 actualdir=opendir(directory); 58 actualdir=opendir(directory); 59 59 60 if(!actualdir) return targv; 60 if(!actualdir) return targv; 61 61 62 /*Loop over all entries */ 62 /*Loop over all entries */ 63 for(entry=readdir(actualdir);entry!=NULL;ent 63 for(entry=readdir(actualdir);entry!=NULL;entry=readdir(actualdir)) 64 { 64 { 65 /* Throw away . and .. */ 65 /* Throw away . and .. */ 66 if(strcmp(entry->d_name,".")==0 || 66 if(strcmp(entry->d_name,".")==0 || 67 strcmp(entry->d_name,"..")==0) continue; 67 strcmp(entry->d_name,"..")==0) continue; 68 /* Obtain the status information of that 68 /* Obtain the status information of that entry */ 69 if(buffer) free(buffer); 69 if(buffer) free(buffer); 70 buffer=(char*) malloc((strlen(directory) 70 buffer=(char*) malloc((strlen(directory)+ 71 strlen(entry->d_name)+2)*sizeof(cha 71 strlen(entry->d_name)+2)*sizeof(char)); 72 strcpy(buffer,directory); 72 strcpy(buffer,directory); 73 strcat(buffer,"/"); << 73 strncat(buffer,"/",1); 74 strcat(buffer,entry->d_name); << 74 strncat(buffer,entry->d_name,strlen(entry->d_name)); 75 s=stat(buffer,&status); 75 s=stat(buffer,&status); 76 if(s==0) 76 if(s==0) 77 { 77 { 78 if(S_ISDIR(status.st_mode)) 78 if(S_ISDIR(status.st_mode)) 79 { 79 { 80 /* a directory, so we are going recurs 80 /* a directory, so we are going recursive*/ 81 targc=0; 81 targc=0; 82 ptr=parsedir(buffer,&targc); 82 ptr=parsedir(buffer,&targc); 83 if(targc) 83 if(targc) 84 { 84 { 85 phelp=targv; 85 phelp=targv; 86 targv=(char**) malloc((*argc+targc)*size 86 targv=(char**) malloc((*argc+targc)*sizeof(char*)); 87 memcpy(targv,phelp,*argc*sizeof(char*)); 87 memcpy(targv,phelp,*argc*sizeof(char*)); 88 memcpy(&targv[*argc],ptr,targc*sizeof(ch 88 memcpy(&targv[*argc],ptr,targc*sizeof(char*)); 89 *argc+=targc; 89 *argc+=targc; 90 free(phelp); 90 free(phelp); 91 free(ptr); 91 free(ptr); 92 } 92 } 93 } 93 } 94 else if(S_ISREG(status.st_mode)) 94 else if(S_ISREG(status.st_mode)) 95 { 95 { 96 /* a regular file is it .d? */ 96 /* a regular file is it .d? */ 97 len=strlen(entry->d_name); 97 len=strlen(entry->d_name); 98 if(entry->d_name[len-2]=='.' && entry- 98 if(entry->d_name[len-2]=='.' && entry->d_name[len-1]=='d') 99 { 99 { 100 phelp=targv; 100 phelp=targv; 101 targv=(char**) malloc((*argc+1)*sizeof(c 101 targv=(char**) malloc((*argc+1)*sizeof(char*)); 102 memcpy(targv,phelp,*argc*sizeof(char*)); 102 memcpy(targv,phelp,*argc*sizeof(char*)); 103 targv[*argc]=strdup(buffer); 103 targv[*argc]=strdup(buffer); 104 (*argc)++; 104 (*argc)++; 105 free(phelp); 105 free(phelp); 106 } 106 } 107 } 107 } 108 } 108 } 109 else 109 else 110 { 110 { 111 fprintf 111 fprintf 112 (stderr, 112 (stderr, 113 " No status - perhaps file %s does not 113 " No status - perhaps file %s does not exist.\n", 114 directory); 114 directory); 115 exit(1); 115 exit(1); 116 } 116 } 117 } 117 } 118 118 119 if(buffer) free(buffer); 119 if(buffer) free(buffer); 120 closedir(actualdir); 120 closedir(actualdir); 121 121 122 return targv; 122 return targv; 123 } 123 } 124 124 125 125 126 int main (int argc, char** argv) { 126 int main (int argc, char** argv) { 127 127 128 char static buffer[BUFSIZE],*bufferPtr,workb 128 char static buffer[BUFSIZE],*bufferPtr,workbuf[256]; 129 char *ptr,*p,**pp,**pp1,**pp2,*directory=0,* 129 char *ptr,*p,**pp,**pp1,**pp2,*directory=0,*libpath=0; 130 char **rargv; 130 char **rargv; 131 char *libname=0; 131 char *libname=0; 132 int i,optl=0,optm=0,swapping,c,rargc; 132 int i,optl=0,optm=0,swapping,c,rargc; 133 FILE *fp; 133 FILE *fp; 134 134 135 #if defined ( _WIN32 ) || defined ( __CYGWIN__ 135 #if defined ( _WIN32 ) || defined ( __CYGWIN__ ) || defined ( __CYGWIN32__ ) 136 char *ntg4tmp=0,*ntg4tmp1=0; 136 char *ntg4tmp=0,*ntg4tmp1=0; 137 int nti; 137 int nti; 138 #endif 138 #endif 139 139 140 struct libmap_ 140 struct libmap_ 141 { 141 { 142 char *lib; /* Library name, e.g., G 142 char *lib; /* Library name, e.g., G4run. */ 143 char *trigger; /* Source directory, e.g 143 char *trigger; /* Source directory, e.g., source/run/. */ 144 int used; /* True if used by these 144 int used; /* True if used by these dependency files. */ 145 char **uses; /* List of library names 145 char **uses; /* List of library names which this library uses. */ 146 struct libmap_ *next; 146 struct libmap_ *next; 147 }; 147 }; 148 148 149 struct libmap_ *libmap=0,*libmapPtr=0,*libma 149 struct libmap_ *libmap=0,*libmapPtr=0,*libmapPtr1=0,*libmapPtr2=0, 150 *prevPtr1,*prevPtr2,*tmpp,*userLibmapPtr; 150 *prevPtr1,*prevPtr2,*tmpp,*userLibmapPtr; 151 151 152 while((c=getopt(argc,argv,"ld: m:"))!=EOF) 152 while((c=getopt(argc,argv,"ld: m:"))!=EOF) 153 { 153 { 154 switch(c) 154 switch(c) 155 { 155 { 156 case 'l': 156 case 'l': 157 optl=1; 157 optl=1; 158 break; 158 break; 159 case 'd': 159 case 'd': 160 directory=strdup(optarg); 160 directory=strdup(optarg); 161 break; 161 break; 162 case 'm': 162 case 'm': 163 optm=1; 163 optm=1; 164 libpath=strdup(optarg); 164 libpath=strdup(optarg); 165 break; 165 break; 166 } 166 } 167 } 167 } 168 168 169 /*Adjust parameters after parsing options */ 169 /*Adjust parameters after parsing options */ 170 170 171 if(optind<argc) 171 if(optind<argc) 172 { 172 { 173 rargv=&argv[optind]; 173 rargv=&argv[optind]; 174 rargc=argc-optind; 174 rargc=argc-optind; 175 } 175 } 176 else 176 else 177 { 177 { 178 rargv=0; 178 rargv=0; 179 rargc=0; 179 rargc=0; 180 } 180 } 181 181 182 if(directory) 182 if(directory) 183 { 183 { 184 if(rargc==0) 184 if(rargc==0) 185 { 185 { 186 rargv=parsedir(directory,&rargc); 186 rargv=parsedir(directory,&rargc); 187 } 187 } 188 else 188 else 189 { 189 { 190 fprintf 190 fprintf 191 (stderr, 191 (stderr, 192 " ERROR: If you specify a directory do 192 " ERROR: If you specify a directory don't also specify files\n"); 193 exit(1); 193 exit(1); 194 } 194 } 195 } 195 } 196 196 197 if(optl)fprintf(stderr," Reading library na 197 if(optl)fprintf(stderr," Reading library name map file...\n"); 198 while (!feof(stdin)) 198 while (!feof(stdin)) 199 { 199 { 200 /* Get library name... */ 200 /* Get library name... */ 201 fgets(buffer,BUFSIZE,stdin); 201 fgets(buffer,BUFSIZE,stdin); 202 if(feof(stdin)) break; 202 if(feof(stdin)) break; 203 if (strlen(buffer) >= BUFSIZE-1) 203 if (strlen(buffer) >= BUFSIZE-1) 204 { 204 { 205 fprintf(stderr, 205 fprintf(stderr, 206 " Internal ERROR: BUFSIZE too small to re 206 " Internal ERROR: BUFSIZE too small to read library name map file\n"); 207 exit(1); 207 exit(1); 208 } 208 } 209 /* discarded trailing \n, as gets() w 209 /* discarded trailing \n, as gets() was doing */ 210 if ( buffer[strlen(buffer)-1] == '\n') 210 if ( buffer[strlen(buffer)-1] == '\n') 211 { buffer[strlen(buffer)-1]='\0'; } 211 { buffer[strlen(buffer)-1]='\0'; } 212 212 213 ptr=strtok(buffer,":\n"); 213 ptr=strtok(buffer,":\n"); 214 214 215 /* Check for duplicate names... */ 215 /* Check for duplicate names... */ 216 for(libmapPtr1=libmap;libmapPtr1;libmapP 216 for(libmapPtr1=libmap;libmapPtr1;libmapPtr1=libmapPtr1->next) 217 { 217 { 218 if(strcmp(libmapPtr1->lib,ptr)==0) 218 if(strcmp(libmapPtr1->lib,ptr)==0) 219 { 219 { 220 fprintf(stderr," ERROR: Duplicate lib 220 fprintf(stderr," ERROR: Duplicate library name: %s\n",ptr); 221 fprintf(stderr, 221 fprintf(stderr, 222 " Perhaps a duplicate subdirectory 222 " Perhaps a duplicate subdirectory with" 223 " a GNUmakefile with the same librar 223 " a GNUmakefile with the same library name.\n" 224 ); 224 ); 225 exit(1); 225 exit(1); 226 } 226 } 227 } 227 } 228 228 229 if(libmap) 229 if(libmap) 230 { 230 { 231 libmapPtr->next=(struct libmap_*) malloc(s 231 libmapPtr->next=(struct libmap_*) malloc(sizeof(struct libmap_)); 232 libmapPtr=libmapPtr->next; 232 libmapPtr=libmapPtr->next; 233 } 233 } 234 else /* First time through anchor libmap 234 else /* First time through anchor libmapPtr to libmap. */ 235 { 235 { 236 libmap=(struct libmap_*) malloc(sizeof(str 236 libmap=(struct libmap_*) malloc(sizeof(struct libmap_)); 237 libmapPtr=libmap; 237 libmapPtr=libmap; 238 } 238 } 239 libmapPtr->next=0; 239 libmapPtr->next=0; 240 libmapPtr->lib=strdup(ptr); 240 libmapPtr->lib=strdup(ptr); 241 libmapPtr->used=0; 241 libmapPtr->used=0; 242 libmapPtr->uses=(char**)calloc(NLIBMAX,s 242 libmapPtr->uses=(char**)calloc(NLIBMAX,sizeof(char*)); 243 243 244 /* If option -l not specified, fill uses 244 /* If option -l not specified, fill uses list... */ 245 if(!optl && !optm) 245 if(!optl && !optm) 246 { 246 { 247 pp=libmapPtr->uses; 247 pp=libmapPtr->uses; 248 if(ptr) 248 if(ptr) 249 { 249 { 250 ptr=strtok(NULL," \n"); 250 ptr=strtok(NULL," \n"); 251 while (ptr) 251 while (ptr) 252 { 252 { 253 *pp=strdup(ptr); 253 *pp=strdup(ptr); 254 pp++; 254 pp++; 255 ptr=strtok(NULL," \n"); 255 ptr=strtok(NULL," \n"); 256 } 256 } 257 } 257 } 258 } 258 } 259 259 260 if(!optm) 260 if(!optm) 261 { 261 { 262 /* Get directory name... */ 262 /* Get directory name... */ 263 fgets(buffer,BUFSIZE,stdin); 263 fgets(buffer,BUFSIZE,stdin); 264 if (strlen(buffer) >= BUFSIZE-1) 264 if (strlen(buffer) >= BUFSIZE-1) 265 { 265 { 266 fprintf(stderr, 266 fprintf(stderr, 267 " Internal ERROR: BUFSIZE too small t 267 " Internal ERROR: BUFSIZE too small to read directory name\n"); 268 exit(1); 268 exit(1); 269 } 269 } 270 /* discarded trailing \n, as gets() w 270 /* discarded trailing \n, as gets() was doing */ 271 if ( buffer[strlen(buffer)-1] == '\n 271 if ( buffer[strlen(buffer)-1] == '\n') 272 { buffer[strlen(buffer)-1]='\0' 272 { buffer[strlen(buffer)-1]='\0'; } 273 273 274 ptr=strtok(buffer,"/"); 274 ptr=strtok(buffer,"/"); 275 if(!ptr) 275 if(!ptr) 276 { 276 { 277 fprintf(stderr," ERROR: \"/\" before 277 fprintf(stderr," ERROR: \"/\" before \"source\" expected.\n"); 278 exit(1); 278 exit(1); 279 } 279 } 280 while(ptr&&strcmp (ptr,"source"))ptr 280 while(ptr&&strcmp (ptr,"source"))ptr=strtok(NULL,"/"); 281 ptr=strtok(NULL,"/"); 281 ptr=strtok(NULL,"/"); 282 if(!ptr) 282 if(!ptr) 283 { 283 { 284 fprintf(stderr," ERROR: \"source\" ex 284 fprintf(stderr," ERROR: \"source\" expected.\n"); 285 exit(1); 285 exit(1); 286 } 286 } 287 libmapPtr->trigger=(char*)malloc(TRI 287 libmapPtr->trigger=(char*)malloc(TRIGSIZE); 288 if(strlen(ptr)>TRIGSIZE) 288 if(strlen(ptr)>TRIGSIZE) 289 { 289 { 290 fprintf(stderr," ERROR: String ov 290 fprintf(stderr," ERROR: String overflow for: %s\n", ptr); 291 exit(1); 291 exit(1); 292 } 292 } 293 strcpy(libmapPtr->trigger,ptr); 293 strcpy(libmapPtr->trigger,ptr); 294 ptr=strtok(NULL,"/"); 294 ptr=strtok(NULL,"/"); 295 while(ptr&&strcmp(ptr,"GNUmakefile") 295 while(ptr&&strcmp(ptr,"GNUmakefile")) 296 { 296 { 297 strcat(libmapPtr->trigger,"/"); << 297 strncat(libmapPtr->trigger,"/",1); 298 strcat(libmapPtr->trigger,ptr); << 298 strncat(libmapPtr->trigger,ptr,strlen(ptr)); 299 ptr=strtok(NULL,"/"); 299 ptr=strtok(NULL,"/"); 300 } 300 } 301 if(!ptr) 301 if(!ptr) 302 { 302 { 303 fprintf 303 fprintf 304 (stderr, 304 (stderr, 305 " ERROR: \"source/<unique-sub-path 305 " ERROR: \"source/<unique-sub-path>/GNUmakefile\" expected.\n"); 306 exit(1); 306 exit(1); 307 } 307 } 308 } 308 } 309 } 309 } 310 310 311 if(optl)fprintf(stderr," Reading dependency 311 if(optl)fprintf(stderr," Reading dependency files...\n"); 312 312 313 #if defined ( _WIN32 ) || defined ( __CYGWIN__ 313 #if defined ( _WIN32 ) || defined ( __CYGWIN__ ) || defined ( __CYGWIN32__ ) 314 ntg4tmp=getenv("G4TMP"); 314 ntg4tmp=getenv("G4TMP"); 315 if ( ! ntg4tmp ) 315 if ( ! ntg4tmp ) 316 { 316 { 317 fprintf(stderr," ERROR: Cannot fin 317 fprintf(stderr," ERROR: Cannot find environment variable G4TMP\n"); 318 exit(1); 318 exit(1); 319 } 319 } 320 ntg4tmp1=strdup(ntg4tmp); 320 ntg4tmp1=strdup(ntg4tmp); 321 #endif 321 #endif 322 322 323 for(i=0;i<rargc;i++) 323 for(i=0;i<rargc;i++) 324 { 324 { 325 fp=fopen(rargv[i],"r"); 325 fp=fopen(rargv[i],"r"); 326 fgets(buffer,BUFSIZE,fp); 326 fgets(buffer,BUFSIZE,fp); 327 327 328 #if defined ( _WIN32 ) || defined ( __CYGWIN__ 328 #if defined ( _WIN32 ) || defined ( __CYGWIN__ ) || defined ( __CYGWIN32__ ) 329 ptr=strchr(ntg4tmp1,':'); 329 ptr=strchr(ntg4tmp1,':'); 330 330 331 while ( ptr=strchr(buffer,'\\') ) *ptr=' 331 while ( ptr=strchr(buffer,'\\') ) *ptr='/'; 332 332 333 while (ntg4tmp1!=NULL && (ptr=strstr(bu 333 while (ntg4tmp1!=NULL && (ptr=strstr(buffer,ntg4tmp1))!=NULL ) 334 { 334 { 335 for(nti=0;nti<strlen(ntg4tmp1);nti++ 335 for(nti=0;nti<strlen(ntg4tmp1);nti++) ptr[nti]=' '; 336 } 336 } 337 #endif 337 #endif 338 338 339 /* Clip target out of dependency file... 339 /* Clip target out of dependency file... */ 340 ptr=strtok(buffer,":"); 340 ptr=strtok(buffer,":"); 341 341 342 /* Look for a "user" library... */ 342 /* Look for a "user" library... */ 343 for(libmapPtr=libmap;libmapPtr;libmapPtr 343 for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next) 344 { 344 { 345 if(strlen(libmapPtr->lib)>256) 345 if(strlen(libmapPtr->lib)>256) 346 { 346 { 347 fprintf(stderr," ERROR: String ov 347 fprintf(stderr," ERROR: String overflow for: %s\n", libmapPtr->lib); 348 exit(1); 348 exit(1); 349 } 349 } 350 strcpy(workbuf,libmapPtr->lib); 350 strcpy(workbuf,libmapPtr->lib); 351 /* Add trailing "/" to distinguish track/ 351 /* Add trailing "/" to distinguish track/ and tracking/, etc. */ 352 strcat(workbuf,"/"); << 352 strncat(workbuf,"/",1); 353 if(strstr(ptr,workbuf)) break; 353 if(strstr(ptr,workbuf)) break; 354 } 354 } 355 if(libmapPtr) 355 if(libmapPtr) 356 { 356 { 357 userLibmapPtr=libmapPtr; 357 userLibmapPtr=libmapPtr; 358 } 358 } 359 else 359 else 360 { 360 { 361 userLibmapPtr=0; 361 userLibmapPtr=0; 362 } 362 } 363 363 364 if(!optm) 364 if(!optm) 365 { 365 { 366 /* Look for a "used" library and add it to 366 /* Look for a "used" library and add it to the "user" uses list... */ 367 bufferPtr=strtok(NULL,"\n"); /* Start *af 367 bufferPtr=strtok(NULL,"\n"); /* Start *after* ":". */ 368 if (!bufferPtr) 368 if (!bufferPtr) 369 { 369 { 370 fprintf(stderr," WARNING: It seems th 370 fprintf(stderr," WARNING: It seems there is nothing after \':\' in dependency file %s.\n", rargv[i]); 371 } 371 } 372 else { 372 else { 373 do 373 do 374 { 374 { 375 for(libmapPtr=libmap;libmapPtr;libmapP 375 for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next) 376 { 376 { 377 /* Look for trigger string. */ 377 /* Look for trigger string. */ 378 if(strlen(libmapPtr->trigger)>256) 378 if(strlen(libmapPtr->trigger)>256) 379 { 379 { 380 fprintf(stderr," ERROR: S 380 fprintf(stderr," ERROR: String overflow for: %s\n", libmapPtr->trigger); 381 exit(1); 381 exit(1); 382 } 382 } 383 strcpy(workbuf,libmapPtr->tr 383 strcpy(workbuf,libmapPtr->trigger); 384 strcat(workbuf,"/include"); << 384 strncat(workbuf,"/include",8); 385 ptr=strstr(bufferPtr,workbuf); 385 ptr=strstr(bufferPtr,workbuf); 386 if(ptr && (userLibmapPtr != libmapPtr)) 386 if(ptr && (userLibmapPtr != libmapPtr)) 387 { 387 { 388 libmapPtr->used=1; 388 libmapPtr->used=1; 389 if(userLibmapPtr) 389 if(userLibmapPtr) 390 { 390 { 391 for(pp=userLibmapPtr->uses;*pp;pp++) 391 for(pp=userLibmapPtr->uses;*pp;pp++) 392 { 392 { 393 if(strcmp(*pp,libmapPtr->lib)==0)b 393 if(strcmp(*pp,libmapPtr->lib)==0)break; 394 } 394 } 395 if(!*pp)*pp=libmapPtr->lib; 395 if(!*pp)*pp=libmapPtr->lib; 396 } 396 } 397 } 397 } 398 /* Also look for library name in case he 398 /* Also look for library name in case header files are 399 placed in temporary directories under 399 placed in temporary directories under a subdirectory 400 with the same name as the library nam 400 with the same name as the library name. This can 401 happen with Objectivity which makes h 401 happen with Objectivity which makes header files 402 from .ddl files and places them in a 402 from .ddl files and places them in a temporary 403 directory. */ 403 directory. */ 404 if(strlen(libmapPtr->lib)>256) 404 if(strlen(libmapPtr->lib)>256) 405 { 405 { 406 fprintf(stderr," ERROR: S 406 fprintf(stderr," ERROR: String overflow for: %s\n", libmapPtr->lib); 407 exit(1); 407 exit(1); 408 } 408 } 409 strcpy(workbuf,libmapPtr->lib); 409 strcpy(workbuf,libmapPtr->lib); 410 strcat(workbuf,"/"); << 410 strncat(workbuf,"/",1); 411 ptr=strstr(bufferPtr,workbuf); 411 ptr=strstr(bufferPtr,workbuf); 412 if(ptr && (userLibmapPtr != libmapPtr)) 412 if(ptr && (userLibmapPtr != libmapPtr)) 413 { 413 { 414 libmapPtr->used=1; 414 libmapPtr->used=1; 415 if(userLibmapPtr) 415 if(userLibmapPtr) 416 { 416 { 417 for(pp=userLibmapPtr->uses;*pp;pp++) 417 for(pp=userLibmapPtr->uses;*pp;pp++) 418 { 418 { 419 if(strcmp(*pp,libmapPtr->lib)==0)b 419 if(strcmp(*pp,libmapPtr->lib)==0)break; 420 } 420 } 421 if(!*pp)*pp=libmapPtr->lib; 421 if(!*pp)*pp=libmapPtr->lib; 422 } 422 } 423 } 423 } 424 } 424 } 425 fgets(buffer,BUFSIZE,fp); 425 fgets(buffer,BUFSIZE,fp); 426 bufferPtr=buffer; 426 bufferPtr=buffer; 427 427 428 #if defined ( _WIN32 ) || defined ( __CYGWIN__ 428 #if defined ( _WIN32 ) || defined ( __CYGWIN__ ) || defined ( __CYGWIN32__ ) 429 while ( ptr=strchr(buffer,'\\') ) *ptr 429 while ( ptr=strchr(buffer,'\\') ) *ptr='/'; 430 430 431 while (ntg4tmp1 && (ptr=strstr(buffer 431 while (ntg4tmp1 && (ptr=strstr(buffer,ntg4tmp1)) ) 432 { 432 { 433 for(nti=0;nti<strlen(ntg4tmp1);nti++) pt 433 for(nti=0;nti<strlen(ntg4tmp1);nti++) ptr[nti]=' '; 434 } 434 } 435 #endif 435 #endif 436 436 437 } while(!feof(fp)); 437 } while(!feof(fp)); 438 fclose(fp); 438 fclose(fp); 439 } 439 } 440 } 440 } 441 } 441 } 442 442 443 #if defined ( _WIN32 ) || defined ( __CYGWIN__ 443 #if defined ( _WIN32 ) || defined ( __CYGWIN__ ) || defined ( __CYGWIN32__ ) 444 free(ntg4tmp1); 444 free(ntg4tmp1); 445 #endif 445 #endif 446 446 447 if(optl) /* This option is used for compilin 447 if(optl) /* This option is used for compiling the file libname.map 448 from all the dependencies. */ 448 from all the dependencies. */ 449 { 449 { 450 fprintf(stderr," Checking for circular 450 fprintf(stderr," Checking for circular dependencies...\n"); 451 for(libmapPtr=libmap;libmapPtr;libmapPtr 451 for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next) 452 { 452 { 453 for(pp=libmapPtr->uses;*pp;pp++) 453 for(pp=libmapPtr->uses;*pp;pp++) 454 { 454 { 455 for(libmapPtr1=libmap;libmapPtr1!=libm 455 for(libmapPtr1=libmap;libmapPtr1!=libmapPtr; 456 libmapPtr1=libmapPtr1->next) 456 libmapPtr1=libmapPtr1->next) 457 { 457 { 458 if(strcmp(libmapPtr1->lib,*pp)==0) 458 if(strcmp(libmapPtr1->lib,*pp)==0) 459 { 459 { 460 for(pp1=libmapPtr1->uses;*pp1;pp1++) 460 for(pp1=libmapPtr1->uses;*pp1;pp1++) 461 { 461 { 462 if(strcmp(*pp1,libmapPtr->lib)==0)brea 462 if(strcmp(*pp1,libmapPtr->lib)==0)break; 463 } 463 } 464 if(*pp1) 464 if(*pp1) 465 { 465 { 466 fprintf 466 fprintf 467 (stderr, 467 (stderr, 468 " WARNING: %s and %s use each othe 468 " WARNING: %s and %s use each other.\n", 469 libmapPtr->lib, 469 libmapPtr->lib, 470 libmapPtr1->lib); 470 libmapPtr1->lib); 471 } 471 } 472 } 472 } 473 else 473 else 474 { 474 { 475 /* Not right yet... 475 /* Not right yet... 476 for(pp1=libmapPtr1->uses;*pp1;pp1++) 476 for(pp1=libmapPtr1->uses;*pp1;pp1++) 477 { 477 { 478 for(libmapPtr0=libmap;libmapPtr0!=libm 478 for(libmapPtr0=libmap;libmapPtr0!=libmapPtr1; 479 libmapPtr0=libmapPtr0->next) 479 libmapPtr0=libmapPtr0->next) 480 { 480 { 481 if(libmapPtr0==*pp) 481 if(libmapPtr0==*pp) 482 { 482 { 483 fprintf 483 fprintf 484 (stderr, 484 (stderr, 485 " WARNING: triangular dependecy: 485 " WARNING: triangular dependecy:\n" 486 " %s uses %s uses %s uses %s.\n" 486 " %s uses %s uses %s uses %s.\n", 487 libmapPtr->lib, 487 libmapPtr->lib, 488 libmapPtr1->lib, 488 libmapPtr1->lib, 489 libmapPtr0->lib, 489 libmapPtr0->lib, 490 libmapPtr->lib); 490 libmapPtr->lib); 491 } 491 } 492 } 492 } 493 } 493 } 494 */ 494 */ 495 } 495 } 496 } 496 } 497 } 497 } 498 } 498 } 499 499 500 fprintf(stderr," Reordering according t 500 fprintf(stderr," Reordering according to dependencies...\n"); 501 do 501 do 502 { 502 { 503 swapping=0; 503 swapping=0; 504 prevPtr2=0; 504 prevPtr2=0; 505 for(libmapPtr=libmap;libmapPtr;libmapPtr=l 505 for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next) 506 { 506 { 507 for(pp=libmapPtr->uses;*pp;pp++) 507 for(pp=libmapPtr->uses;*pp;pp++) 508 { 508 { 509 prevPtr1=0; 509 prevPtr1=0; 510 for(libmapPtr1=libmap;libmapPtr1!=libmap 510 for(libmapPtr1=libmap;libmapPtr1!=libmapPtr; 511 libmapPtr1=libmapPtr1->next) 511 libmapPtr1=libmapPtr1->next) 512 { 512 { 513 if(strcmp(libmapPtr1->lib,*pp)==0) 513 if(strcmp(libmapPtr1->lib,*pp)==0) 514 { 514 { 515 /* Check that 1st doesn't use 2nd... * 515 /* Check that 1st doesn't use 2nd... */ 516 for(pp1=libmapPtr1->uses;*pp1;pp1++) 516 for(pp1=libmapPtr1->uses;*pp1;pp1++) 517 { 517 { 518 if(strcmp(*pp1,libmapPtr->lib)==0) 518 if(strcmp(*pp1,libmapPtr->lib)==0)break; 519 } 519 } 520 if(!*pp1) /* If not... */ 520 if(!*pp1) /* If not... */ 521 { 521 { 522 swapping=1; 522 swapping=1; 523 /* Make previous of 1st now point 523 /* Make previous of 1st now point to 2nd... */ 524 if(prevPtr1) 524 if(prevPtr1) 525 { 525 { 526 prevPtr1->next=libmapPtr; 526 prevPtr1->next=libmapPtr; 527 } 527 } 528 else 528 else 529 { 529 { 530 libmap=libmapPtr; 530 libmap=libmapPtr; 531 } 531 } 532 /* Make 2nd now point to what 1st 532 /* Make 2nd now point to what 1st did, unless 533 it's adjacent, in which case make it 533 it's adjacent, in which case make it point 534 to 1st itself... */ 534 to 1st itself... */ 535 tmpp=libmapPtr->next; 535 tmpp=libmapPtr->next; 536 if(libmapPtr1->next==libmapPtr) 536 if(libmapPtr1->next==libmapPtr) 537 { 537 { 538 libmapPtr->next=libmapPtr1; 538 libmapPtr->next=libmapPtr1; 539 } 539 } 540 else 540 else 541 { 541 { 542 libmapPtr->next=libmapPtr1->next; 542 libmapPtr->next=libmapPtr1->next; 543 } 543 } 544 /* Make previous of 2nd point to 1 544 /* Make previous of 2nd point to 1st, unless 545 it's adjacent, in which case leave it 545 it's adjacent, in which case leave it... */ 546 if(libmapPtr1->next!=libmapPtr) 546 if(libmapPtr1->next!=libmapPtr) 547 { 547 { 548 prevPtr2->next=libmapPtr1; 548 prevPtr2->next=libmapPtr1; 549 } 549 } 550 /* Make 1st now point to what 2nd 550 /* Make 1st now point to what 2nd did... */ 551 libmapPtr1->next=tmpp; 551 libmapPtr1->next=tmpp; 552 break; 552 break; 553 } 553 } 554 } 554 } 555 prevPtr1=libmapPtr1; 555 prevPtr1=libmapPtr1; 556 } 556 } 557 if(swapping)break; 557 if(swapping)break; 558 } 558 } 559 prevPtr2=libmapPtr; 559 prevPtr2=libmapPtr; 560 if(swapping)break; 560 if(swapping)break; 561 } 561 } 562 }while(swapping); 562 }while(swapping); 563 563 564 fprintf(stderr," Writing new library ma 564 fprintf(stderr," Writing new library map file...\n"); 565 for(libmapPtr=libmap;libmapPtr;libmapPtr 565 for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next) 566 { 566 { 567 printf("%s:",libmapPtr->lib); 567 printf("%s:",libmapPtr->lib); 568 for(pp=libmapPtr->uses;*pp;pp++) 568 for(pp=libmapPtr->uses;*pp;pp++) 569 { 569 { 570 printf(" %s",*pp); 570 printf(" %s",*pp); 571 } 571 } 572 printf("\n"); 572 printf("\n"); 573 printf("source/%s/GNUmakefile\n",libmapPtr 573 printf("source/%s/GNUmakefile\n",libmapPtr->trigger); 574 } 574 } 575 } 575 } 576 else if (optm) 576 else if (optm) 577 { 577 { 578 /* create tmp. string libname */ 578 /* create tmp. string libname */ 579 int libname_usable_size=24; 579 int libname_usable_size=24; 580 if ( ! libname ) libname=malloc(libname_ 580 if ( ! libname ) libname=malloc(libname_usable_size+16); 581 581 582 /* Write out full library list... */ 582 /* Write out full library list... */ 583 for(libmapPtr=libmap;libmapPtr;libmapPtr 583 for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next) 584 { 584 { 585 if ( strlen(libpath)+strlen(libmapPtr->lib) 585 if ( strlen(libpath)+strlen(libmapPtr->lib) > libname_usable_size ) { 586 libname_usable_size=(strlen(libpath)+strle 586 libname_usable_size=(strlen(libpath)+strlen(libmapPtr->lib))*2; 587 free(libname); 587 free(libname); 588 libname=malloc(libname_usable_size+16); 588 libname=malloc(libname_usable_size+16); 589 } 589 } 590 /* Check existance of libraries and pr 590 /* Check existance of libraries and print out only installed ones */ 591 591 592 592 593 snprintf(libname, libname_usable_size+16, "% << 593 sprintf(libname, "%s/lib%s.a", libpath, libmapPtr->lib); 594 if (access(libname,R_OK)) 594 if (access(libname,R_OK)) 595 { 595 { 596 snprintf(libname, libname_usable_size+16, << 596 sprintf(libname, "%s/lib%s.so", libpath, libmapPtr->lib); 597 if (!access(libname,R_OK)) 597 if (!access(libname,R_OK)) 598 { 598 { 599 printf("-l%s ",libmapPtr->lib); 599 printf("-l%s ",libmapPtr->lib); 600 } 600 } 601 else /* case MacOS .dylib */ 601 else /* case MacOS .dylib */ 602 { 602 { 603 snprintf(libname, libname_usable_size+16 << 603 sprintf(libname, "%s/lib%s.dylib", libpath, libmapPtr->lib); 604 if (!access(libname,R_OK)) 604 if (!access(libname,R_OK)) 605 { 605 { 606 printf("-l%s ",libmapPtr->lib); 606 printf("-l%s ",libmapPtr->lib); 607 } 607 } 608 } 608 } 609 } 609 } 610 else 610 else 611 { 611 { 612 printf("-l%s ",libmapPtr->lib); 612 printf("-l%s ",libmapPtr->lib); 613 } 613 } 614 libmapPtr=libmapPtr->next; 614 libmapPtr=libmapPtr->next; 615 } 615 } 616 } 616 } 617 else 617 else 618 { 618 { 619 /* Add dependent libraries... */ 619 /* Add dependent libraries... */ 620 for(libmapPtr=libmap;libmapPtr;libmapPtr 620 for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next) 621 { 621 { 622 if(libmapPtr->used) 622 if(libmapPtr->used) 623 { 623 { 624 for(pp=libmapPtr->uses;*pp;pp++) 624 for(pp=libmapPtr->uses;*pp;pp++) 625 { 625 { 626 for(libmapPtr1=libmap;libmapPtr1;libmapP 626 for(libmapPtr1=libmap;libmapPtr1;libmapPtr1=libmapPtr1->next) 627 { 627 { 628 if(strcmp(libmapPtr1->lib,*pp)==0) 628 if(strcmp(libmapPtr1->lib,*pp)==0) 629 { 629 { 630 libmapPtr1->used=1; 630 libmapPtr1->used=1; 631 } 631 } 632 } 632 } 633 } 633 } 634 } 634 } 635 } 635 } 636 636 637 /* Write out library list... */ 637 /* Write out library list... */ 638 for(libmapPtr=libmap;libmapPtr;libmapPtr 638 for(libmapPtr=libmap;libmapPtr;libmapPtr=libmapPtr->next) 639 { 639 { 640 if(libmapPtr->used) 640 if(libmapPtr->used) 641 { 641 { 642 printf("-l%s ",libmapPtr->lib); 642 printf("-l%s ",libmapPtr->lib); 643 } 643 } 644 } 644 } 645 } 645 } 646 646 647 exit(0); 647 exit(0); 648 648 649 } 649 } 650 650