git.oblomov.eu Git - wine/blob - tools/makedep.c

   1 /*
   2  * Generate include file dependencies
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #include <ctype.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <unistd.h>
  12
  13 /* Max first-level includes per file */
  14 #define MAX_INCLUDES 124
  15
  16 typedef struct _INCL_FILE
  17 {
  18     struct _INCL_FILE *next;
  19     char              *name;
  20     char              *filename;
  21     struct _INCL_FILE *owner;
  22     struct _INCL_FILE *files[MAX_INCLUDES];
  23 } INCL_FILE;
  24
  25 static INCL_FILE *firstSrc;
  26 static INCL_FILE *firstInclude;
  27
  28 typedef struct _INCL_PATH
  29 {
  30     struct _INCL_PATH *next;
  31     const char        *name;
  32 } INCL_PATH;
  33
  34 static INCL_PATH *firstPath;
  35
  36 static const char *SrcDir = NULL;
  37 static const char *OutputFileName = "Makefile";
  38 static const char *Separator = "### Dependencies";
  39 static const char *ProgramName;
  40
  41 static const char Usage[] =
  42     "Usage: %s [options] [files]\n"
  43     "Options:\n"
  44     "   -Idir   Search for include files in directory 'dir'\n"
  45     "   -Cdir   Search for source files in directory 'dir'\n"
  46     "   -fxxx   Store output in file 'xxx' (default: Makefile)\n"
  47     "   -sxxx   Use 'xxx' as separator (default: \"### Dependencies\")\n";
  48
  49
  50 /*******************************************************************
  51  *         xmalloc
  52  */
  53 static void *xmalloc( int size )
  54 {
  55     void *res;
  56     if (!(res = malloc (size ? size : 1)))
  57     {
  58         fprintf( stderr, "%s: Virtual memory exhausted.\n", ProgramName );
  59         exit(1);
  60     }
  61     return res;
  62 }
  63
  64
  65 /*******************************************************************
  66  *         xstrdup
  67  */
  68 static char *xstrdup( const char *str )
  69 {
  70     char *res = strdup( str );
  71     if (!res)
  72     {
  73         fprintf( stderr, "%s: Virtual memory exhausted.\n", ProgramName );
  74         exit(1);
  75     }
  76     return res;
  77 }
  78
  79
  80 /*******************************************************************
  81  *         add_include_path
  82  *
  83  * Add a directory to the include path.
  84  */
  85 static void add_include_path( const char *name )
  86 {
  87     INCL_PATH *path = xmalloc( sizeof(*path) );
  88     INCL_PATH **p = &firstPath;
  89     while (*p) p = &(*p)->next;
  90     *p = path;
  91     path->next = NULL;
  92     path->name = name;
  93 }
  94
  95
  96 /*******************************************************************
  97  *         add_src_file
  98  *
  99  * Add a source file to the list.
 100  */
 101 static INCL_FILE *add_src_file( const char *name )
 102 {
 103     INCL_FILE **p = &firstSrc;
 104     INCL_FILE *file = xmalloc( sizeof(*file) );
 105     memset( file, 0, sizeof(*file) );
 106     file->name = xstrdup(name);
 107     while (*p) p = &(*p)->next;
 108     *p = file;
 109     return file;
 110 }
 111
 112
 113 /*******************************************************************
 114  *         add_include
 115  *
 116  * Add an include file if it doesn't already exists.
 117  */
 118 static INCL_FILE *add_include( INCL_FILE *pFile, const char *name )
 119 {
 120     INCL_FILE **p = &firstInclude;
 121     int pos;
 122
 123     for (pos = 0; pos < MAX_INCLUDES; pos++) if (!pFile->files[pos]) break;
 124     if (pos >= MAX_INCLUDES)
 125     {
 126         fprintf( stderr, "%s: %s: too many included files, please fix MAX_INCLUDES\n",
 127                  ProgramName, pFile->name );
 128         exit(1);
 129     }
 130
 131     while (*p && strcmp( name, (*p)->name )) p = &(*p)->next;
 132     if (!*p)
 133     {
 134         *p = xmalloc( sizeof(INCL_FILE) );
 135         memset( *p, 0, sizeof(INCL_FILE) );
 136         (*p)->name = xstrdup(name);
 137     }
 138     pFile->files[pos] = *p;
 139     return *p;
 140 }
 141
 142
 143 /*******************************************************************
 144  *         open_src_file
 145  */
 146 static FILE *open_src_file( INCL_FILE *pFile )
 147 {
 148     FILE *file;
 149
 150     if (SrcDir)
 151     {
 152         pFile->filename = xmalloc( strlen(SrcDir) + strlen(pFile->name) + 2 );
 153         strcpy( pFile->filename, SrcDir );
 154         strcat( pFile->filename, "/" );
 155         strcat( pFile->filename, pFile->name );
 156     }
 157     else pFile->filename = xstrdup( pFile->name );
 158
 159     if (!(file = fopen( pFile->filename, "r" )))
 160     {
 161         perror( pFile->filename );
 162         exit(1);
 163     }
 164     return file;
 165 }
 166
 167
 168 /*******************************************************************
 169  *         open_include_file
 170  */
 171 static FILE *open_include_file( INCL_FILE *pFile )
 172 {
 173     FILE *file = NULL;
 174     INCL_PATH *path;
 175
 176     for (path = firstPath; path; path = path->next)
 177     {
 178         char *filename = xmalloc(strlen(path->name) + strlen(pFile->name) + 2);
 179         strcpy( filename, path->name );
 180         strcat( filename, "/" );
 181         strcat( filename, pFile->name );
 182         if ((file = fopen( filename, "r" )))
 183         {
 184             pFile->filename = filename;
 185             break;
 186         }
 187         free( filename );
 188     }
 189     if (!file)
 190     {
 191         if (firstPath) perror( pFile->name );
 192         else fprintf( stderr, "%s: %s: File not found\n",
 193                       ProgramName, pFile->name );
 194         exit(1);
 195     }
 196     return file;
 197 }
 198
 199
 200 /*******************************************************************
 201  *         parse_file
 202  */
 203 static void parse_file( INCL_FILE *pFile, int src )
 204 {
 205     char buffer[1024];
 206     char *include;
 207     int line = 0;
 208
 209     FILE *file = src ? open_src_file( pFile ) : open_include_file( pFile );
 210     while (fgets( buffer, sizeof(buffer)-1, file ))
 211     {
 212         char *p = buffer;
 213         line++;
 214         while (*p && isspace(*p)) p++;
 215         if (*p++ != '#') continue;
 216         while (*p && isspace(*p)) p++;
 217         if (strncmp( p, "include", 7 )) continue;
 218         p += 7;
 219         while (*p && isspace(*p)) p++;
 220         if (*p++ != '\"') continue;
 221         include = p;
 222         while (*p && (*p != '\"')) p++;
 223         if (!*p)
 224         {
 225             fprintf( stderr, "%s:%d: Malformed #include directive\n",
 226                      pFile->filename, line );
 227             exit(1);
 228         }
 229         *p = 0;
 230         add_include( pFile, include );
 231     }
 232     fclose(file);
 233 }
 234
 235
 236 /*******************************************************************
 237  *         output_include
 238  */
 239 static void output_include( FILE *file, INCL_FILE *pFile,
 240                             INCL_FILE *owner, int *column )
 241 {
 242     int i;
 243
 244     if (pFile->owner == owner) return;
 245     pFile->owner = owner;
 246     if (*column + strlen(pFile->filename) + 1 > 70)
 247     {
 248         fprintf( file, " \\\n" );
 249         *column = 0;
 250     }
 251     fprintf( file, " %s", pFile->filename );
 252     *column += strlen(pFile->filename) + 1;
 253     for (i = 0; i < MAX_INCLUDES; i++)
 254         if (pFile->files[i]) output_include( file, pFile->files[i],
 255                                              owner, column );
 256 }
 257
 258
 259 /*******************************************************************
 260  *         output_src
 261  */
 262 static void output_src( FILE *file, INCL_FILE *pFile, int *column )
 263 {
 264     char *obj = xstrdup( pFile->name );
 265     char *ext = strrchr( obj, '.' );
 266     if (ext)
 267     {
 268         *ext++ = 0;
 269         if (!strcmp( ext, "y" ))  /* yacc file */
 270         {
 271             *column += fprintf( file, "y.tab.o: y.tab.c" );
 272         }
 273         else if (!strcmp( ext, "l" ))  /* lex file */
 274         {
 275             *column += fprintf( file, "lex.yy.o: lex.yy.c" );
 276         }
 277         else if (!strcmp( ext, "rc" ))  /* resource file */
 278         {
 279             *column += fprintf( file, "%s.res: %s", obj, pFile->filename );
 280         }
 281         else if (!strcmp( ext, "rc16" ))  /* Win16 resource file */
 282         {
 283             *column += fprintf( file, "%s.s: %s", obj, pFile->filename );
 284         }
 285         else
 286         {
 287             *column += fprintf( file, "%s.o: %s", obj, pFile->filename );
 288         }
 289     }
 290     free( obj );
 291 }
 292
 293
 294 /*******************************************************************
 295  *         output_dependencies
 296  */
 297 static void output_dependencies(void)
 298 {
 299     INCL_FILE *pFile;
 300     int i, column;
 301     FILE *file = NULL;
 302     char buffer[1024];
 303
 304     if (Separator && ((file = fopen( OutputFileName, "r+" ))))
 305     {
 306         while (fgets( buffer, sizeof(buffer), file ))
 307             if (!strncmp( buffer, Separator, strlen(Separator) )) break;
 308         ftruncate( fileno(file), ftell(file) );
 309         fseek( file, 0L, SEEK_END );
 310     }
 311     if (!file)
 312     {
 313         if (!(file = fopen( OutputFileName, "a" )))
 314         {
 315             perror( OutputFileName );
 316             exit(1);
 317         }
 318     }
 319     for( pFile = firstSrc; pFile; pFile = pFile->next)
 320     {
 321         column = 0;
 322         output_src( file, pFile, &column );
 323         for (i = 0; i < MAX_INCLUDES; i++)
 324             if (pFile->files[i]) output_include( file, pFile->files[i],
 325                                                  pFile, &column );
 326         fprintf( file, "\n" );
 327     }
 328     fclose(file);
 329 }
 330
 331
 332 /*******************************************************************
 333  *         parse_option
 334  */
 335 static void parse_option( const char *opt )
 336 {
 337     switch(opt[1])
 338     {
 339     case 'I':
 340         if (opt[2]) add_include_path( opt + 2 );
 341         break;
 342     case 'C':
 343         if (opt[2]) SrcDir = opt + 2;
 344         else SrcDir = NULL;
 345         break;
 346     case 'f':
 347         if (opt[2]) OutputFileName = opt + 2;
 348         break;
 349     case 's':
 350         if (opt[2]) Separator = opt + 2;
 351         else Separator = NULL;
 352         break;
 353     default:
 354         fprintf( stderr, "Unknown option '%s'\n", opt );
 355         fprintf( stderr, Usage, ProgramName );
 356         exit(1);
 357     }
 358 }
 359
 360
 361 /*******************************************************************
 362  *         main
 363  */
 364 int main( int argc, char *argv[] )
 365 {
 366     INCL_FILE *pFile;
 367
 368     ProgramName = argv[0];
 369     while (argc > 1)
 370     {
 371         if (*argv[1] == '-') parse_option( argv[1] );
 372         else
 373         {
 374             pFile = add_src_file( argv[1] );
 375             parse_file( pFile, 1 );
 376         }
 377         argc--;
 378         argv++;
 379     }
 380     for (pFile = firstInclude; pFile; pFile = pFile->next)
 381         parse_file( pFile, 0 );
 382     output_dependencies();
 383     return 0;
 384 }