- clean-up of texture 'loading'
[wine] / 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 *name = strrchr( pFile->name, '/' );
265     char *obj = xstrdup( name ? name + 1 : pFile->name );
266     char *ext = strrchr( obj, '.' );
267     if (ext)
268     {
269         if (!strcmp( ext, ".y" ))  /* yacc file */
270         {
271             fprintf( file, "y.tab.o: y.tab.c" );
272             *column += 16;
273         }
274         else if (!strcmp( ext, ".l" ))  /* lex file */
275         {
276             fprintf( file, "lex.yy.o: lex.yy.c" );
277             *column += 18;
278         }
279         else if (!strcmp( ext, ".rc" ))  /* resource file */
280         {
281             *ext = '\0';
282             fprintf( file, "%s.s: %s", obj, pFile->filename );
283             *column += 2 * strlen(obj) + strlen(pFile->filename) + 7;
284         }
285         else
286         {
287             strcpy( ext, ".o" );
288             fprintf( file, "%s: %s", obj, pFile->filename );
289             *column += strlen(obj) + strlen(pFile->filename) + 2;
290         }
291     }
292     free( obj );
293 }
294
295
296 /*******************************************************************
297  *         output_dependencies
298  */
299 static void output_dependencies(void)
300 {
301     INCL_FILE *pFile;
302     int i, column;
303     FILE *file = NULL;
304     char buffer[1024];
305
306     if (Separator && ((file = fopen( OutputFileName, "r+" ))))
307     {
308         while (fgets( buffer, sizeof(buffer), file ))
309             if (!strncmp( buffer, Separator, strlen(Separator) )) break;
310         ftruncate( fileno(file), ftell(file) );
311         fseek( file, 0L, SEEK_END );
312     }
313     if (!file)
314     {
315         if (!(file = fopen( OutputFileName, "a" )))
316         {
317             perror( OutputFileName );
318             exit(1);
319         }
320     }
321     for( pFile = firstSrc; pFile; pFile = pFile->next)
322     {
323         column = 0;
324         output_src( file, pFile, &column );
325         for (i = 0; i < MAX_INCLUDES; i++)
326             if (pFile->files[i]) output_include( file, pFile->files[i],
327                                                  pFile, &column );
328         fprintf( file, "\n" );
329     }
330     fclose(file);
331 }
332
333
334 /*******************************************************************
335  *         parse_option
336  */
337 static void parse_option( const char *opt )
338 {
339     switch(opt[1])
340     {
341     case 'I':
342         if (opt[2]) add_include_path( opt + 2 );
343         break;
344     case 'C':
345         if (opt[2]) SrcDir = opt + 2;
346         else SrcDir = NULL;
347         break;
348     case 'f':
349         if (opt[2]) OutputFileName = opt + 2;
350         break;
351     case 's':
352         if (opt[2]) Separator = opt + 2;
353         else Separator = NULL;
354         break;
355     default:
356         fprintf( stderr, "Unknown option '%s'\n", opt );
357         fprintf( stderr, Usage, ProgramName );
358         exit(1);
359     }
360 }
361
362
363 /*******************************************************************
364  *         main
365  */
366 int main( int argc, char *argv[] )
367 {
368     INCL_FILE *pFile;
369
370     ProgramName = argv[0];
371     while (argc > 1)
372     {
373         if (*argv[1] == '-') parse_option( argv[1] );
374         else
375         {
376             pFile = add_src_file( argv[1] );
377             parse_file( pFile, 1 );
378         }
379         argc--;
380         argv++;
381     }
382     for (pFile = firstInclude; pFile; pFile = pFile->next)
383         parse_file( pFile, 0 );
384     output_dependencies();
385     return 0;
386 }