Implement color profile handles.
[wine] / tools / makedep.c
1 /*
2  * Generate include file dependencies
3  *
4  * Copyright 1996 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include "config.h"
22 #define NO_LIBWINE_PORT
23 #include "wine/port.h"
24
25 #include <ctype.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <stdarg.h>
29 #include <string.h>
30 #ifdef HAVE_UNISTD_H
31 # include <unistd.h>
32 #endif
33
34 /* Max first-level includes per file */
35 #define MAX_INCLUDES 200
36
37 typedef struct _INCL_FILE
38 {
39     struct _INCL_FILE *next;
40     char              *name;
41     char              *filename;
42     struct _INCL_FILE *included_by;   /* file that included this one */
43     int                included_line; /* line where this file was included */
44     int                system;        /* is it a system include (#include <name>) */
45     struct _INCL_FILE *owner;
46     struct _INCL_FILE *files[MAX_INCLUDES];
47 } INCL_FILE;
48
49 static INCL_FILE *firstSrc;
50 static INCL_FILE *firstInclude;
51
52 typedef struct _INCL_PATH
53 {
54     struct _INCL_PATH *next;
55     const char        *name;
56 } INCL_PATH;
57
58 static INCL_PATH *firstPath;
59
60 static const char *SrcDir = NULL;
61 static const char *OutputFileName = "Makefile";
62 static const char *Separator = "### Dependencies";
63 static const char *ProgramName;
64
65 static const char Usage[] =
66     "Usage: %s [options] [files]\n"
67     "Options:\n"
68     "   -Idir   Search for include files in directory 'dir'\n"
69     "   -Cdir   Search for source files in directory 'dir'\n"
70     "   -fxxx   Store output in file 'xxx' (default: Makefile)\n"
71     "   -sxxx   Use 'xxx' as separator (default: \"### Dependencies\")\n";
72
73
74 /*******************************************************************
75  *         fatal_error
76  */
77 static void fatal_error( const char *msg, ... )
78 {
79     va_list valist;
80     va_start( valist, msg );
81     vfprintf( stderr, msg, valist );
82     va_end( valist );
83     exit(1);
84 }
85
86
87 /*******************************************************************
88  *         xmalloc
89  */
90 static void *xmalloc( int size )
91 {
92     void *res;
93     if (!(res = malloc (size ? size : 1)))
94         fatal_error( "%s: Virtual memory exhausted.\n", ProgramName );
95     return res;
96 }
97
98
99 /*******************************************************************
100  *         xstrdup
101  */
102 static char *xstrdup( const char *str )
103 {
104     char *res = strdup( str );
105     if (!res) fatal_error( "%s: Virtual memory exhausted.\n", ProgramName );
106     return res;
107 }
108
109
110 /*******************************************************************
111  *         get_extension
112  */
113 static char *get_extension( char *filename )
114 {
115     char *ext = strrchr( filename, '.' );
116     if (ext && strchr( ext, '/' )) ext = NULL;
117     return ext;
118 }
119
120
121 /*******************************************************************
122  *         is_generated
123  *
124  * Test if a given file type is generated during the make process
125  */
126 static int is_generated( const char *name )
127 {
128     static const char * const extensions[] = { ".tab.h", ".mc.rc" };
129     size_t i, len = strlen(name);
130     for (i = 0; i < sizeof(extensions)/sizeof(extensions[0]); i++)
131     {
132         if (len <= strlen(extensions[i])) continue;
133         if (!strcmp( name + len - strlen(extensions[i]), extensions[i] )) return 1;
134     }
135     return 0;
136 }
137
138 /*******************************************************************
139  *         add_include_path
140  *
141  * Add a directory to the include path.
142  */
143 static void add_include_path( const char *name )
144 {
145     INCL_PATH *path = xmalloc( sizeof(*path) );
146     INCL_PATH **p = &firstPath;
147     while (*p) p = &(*p)->next;
148     *p = path;
149     path->next = NULL;
150     path->name = name;
151 }
152
153
154 /*******************************************************************
155  *         add_src_file
156  *
157  * Add a source file to the list.
158  */
159 static INCL_FILE *add_src_file( const char *name )
160 {
161     INCL_FILE **p = &firstSrc;
162     INCL_FILE *file = xmalloc( sizeof(*file) );
163     memset( file, 0, sizeof(*file) );
164     file->name = xstrdup(name);
165     while (*p) p = &(*p)->next;
166     *p = file;
167     return file;
168 }
169
170
171 /*******************************************************************
172  *         add_include
173  *
174  * Add an include file if it doesn't already exists.
175  */
176 static INCL_FILE *add_include( INCL_FILE *pFile, const char *name, int line, int system )
177 {
178     INCL_FILE **p = &firstInclude;
179     char *ext;
180     int pos;
181
182     for (pos = 0; pos < MAX_INCLUDES; pos++) if (!pFile->files[pos]) break;
183     if (pos >= MAX_INCLUDES)
184         fatal_error( "%s: %s: too many included files, please fix MAX_INCLUDES\n",
185                      ProgramName, pFile->name );
186
187     /* enforce some rules for the Wine tree */
188
189     if (!memcmp( name, "../", 3 ))
190         fatal_error( "%s:%d: #include directive with relative path not allowed\n",
191                      pFile->filename, line );
192
193     if (!strcmp( name, "config.h" ))
194     {
195         if ((ext = strrchr( pFile->filename, '.' )) && !strcmp( ext, ".h" ))
196             fatal_error( "%s:%d: config.h must not be included by a header file\n",
197                          pFile->filename, line );
198         if (pos)
199             fatal_error( "%s:%d: config.h must be included before anything else\n",
200                          pFile->filename, line );
201     }
202     else if (!strcmp( name, "wine/port.h" ))
203     {
204         if ((ext = strrchr( pFile->filename, '.' )) && !strcmp( ext, ".h" ))
205             fatal_error( "%s:%d: wine/port.h must not be included by a header file\n",
206                          pFile->filename, line );
207         if (!pos) fatal_error( "%s:%d: config.h must be included before wine/port.h\n",
208                                pFile->filename, line );
209         if (pos > 1)
210             fatal_error( "%s:%d: wine/port.h must be included before everything except config.h\n",
211                          pFile->filename, line );
212         if (strcmp( pFile->files[0]->name, "config.h" ))
213             fatal_error( "%s:%d: config.h must be included before wine/port.h\n",
214                          pFile->filename, line );
215     }
216
217     while (*p && strcmp( name, (*p)->name )) p = &(*p)->next;
218     if (!*p)
219     {
220         *p = xmalloc( sizeof(INCL_FILE) );
221         memset( *p, 0, sizeof(INCL_FILE) );
222         (*p)->name = xstrdup(name);
223         (*p)->included_by = pFile;
224         (*p)->included_line = line;
225         (*p)->system = system || pFile->system;
226     }
227     pFile->files[pos] = *p;
228     return *p;
229 }
230
231
232 /*******************************************************************
233  *         open_src_file
234  */
235 static FILE *open_src_file( INCL_FILE *pFile )
236 {
237     FILE *file;
238
239     /* first try name as is */
240     if ((file = fopen( pFile->name, "r" )))
241     {
242         pFile->filename = xstrdup( pFile->name );
243         return file;
244     }
245     /* now try in source dir */
246     if (SrcDir)
247     {
248         pFile->filename = xmalloc( strlen(SrcDir) + strlen(pFile->name) + 2 );
249         strcpy( pFile->filename, SrcDir );
250         strcat( pFile->filename, "/" );
251         strcat( pFile->filename, pFile->name );
252         file = fopen( pFile->filename, "r" );
253     }
254     if (!file)
255     {
256         perror( pFile->name );
257         exit(1);
258     }
259     return file;
260 }
261
262
263 /*******************************************************************
264  *         open_include_file
265  */
266 static FILE *open_include_file( INCL_FILE *pFile )
267 {
268     FILE *file = NULL;
269     INCL_PATH *path;
270
271     for (path = firstPath; path; path = path->next)
272     {
273         char *filename = xmalloc(strlen(path->name) + strlen(pFile->name) + 2);
274         strcpy( filename, path->name );
275         strcat( filename, "/" );
276         strcat( filename, pFile->name );
277         if ((file = fopen( filename, "r" )))
278         {
279             pFile->filename = filename;
280             break;
281         }
282         free( filename );
283     }
284     if (!file && pFile->system) return NULL;  /* ignore system files we cannot find */
285
286     /* try in src file directory */
287     if (!file)
288     {
289         char *p = strrchr(pFile->included_by->filename, '/');
290         if (p)
291         {
292             int l = p - pFile->included_by->filename + 1;
293             char *filename = xmalloc(l + strlen(pFile->name) + 1);
294             memcpy( filename, pFile->included_by->filename, l );
295             strcpy( filename + l, pFile->name );
296             if ((file = fopen( filename, "r" ))) pFile->filename = filename;
297             else free( filename );
298         }
299     }
300
301     if (!file)
302     {
303         if (pFile->included_by->system) return NULL;  /* ignore if included by a system file */
304         if (firstPath) perror( pFile->name );
305         else fprintf( stderr, "%s: %s: File not found\n",
306                       ProgramName, pFile->name );
307         while (pFile->included_by)
308         {
309             fprintf( stderr, "  %s was first included from %s:%d\n",
310                      pFile->name, pFile->included_by->name, pFile->included_line );
311             pFile = pFile->included_by;
312         }
313         exit(1);
314     }
315     return file;
316 }
317
318
319 /*******************************************************************
320  *         parse_idl_file
321  */
322 static void parse_idl_file( INCL_FILE *pFile, FILE *file )
323 {
324     char buffer[1024];
325     char *include;
326     int line = 0;
327
328     while (fgets( buffer, sizeof(buffer)-1, file ))
329     {
330         char quote;
331         char *p = buffer;
332         line++;
333         while (*p && isspace(*p)) p++;
334
335         if (!strncmp( p, "import", 6 ))
336         {
337             p += 6;
338             while (*p && isspace(*p)) p++;
339             if (*p != '\"') continue;
340         }
341         else
342         {
343             if (*p++ != '#') continue;
344             while (*p && isspace(*p)) p++;
345             if (strncmp( p, "include", 7 )) continue;
346             p += 7;
347             while (*p && isspace(*p)) p++;
348             if (*p != '\"' && *p != '<' ) continue;
349         }
350
351         quote = *p++;
352         if (quote == '<') quote = '>';
353         include = p;
354         while (*p && (*p != quote)) p++;
355         if (!*p) fatal_error( "%s:%d: Malformed #include or import directive\n",
356                               pFile->filename, line );
357         *p = 0;
358         add_include( pFile, include, line, (quote == '>') );
359     }
360 }
361
362 /*******************************************************************
363  *         parse_c_file
364  */
365 static void parse_c_file( INCL_FILE *pFile, FILE *file )
366 {
367     char buffer[1024];
368     char *include;
369     int line = 0;
370
371     while (fgets( buffer, sizeof(buffer)-1, file ))
372     {
373         char quote;
374         char *p = buffer;
375         line++;
376         while (*p && isspace(*p)) p++;
377         if (*p++ != '#') continue;
378         while (*p && isspace(*p)) p++;
379         if (strncmp( p, "include", 7 )) continue;
380         p += 7;
381         while (*p && isspace(*p)) p++;
382         if (*p != '\"' && *p != '<' ) continue;
383         quote = *p++;
384         if (quote == '<') quote = '>';
385         include = p;
386         while (*p && (*p != quote)) p++;
387         if (!*p) fatal_error( "%s:%d: Malformed #include directive\n",
388                               pFile->filename, line );
389         *p = 0;
390         add_include( pFile, include, line, (quote == '>') );
391     }
392 }
393
394
395 /*******************************************************************
396  *         parse_file
397  */
398 static void parse_file( INCL_FILE *pFile, int src )
399 {
400     char *ext;
401     FILE *file;
402
403     if (is_generated( pFile->name ))
404     {
405         /* file is generated during make, don't try to open it */
406         pFile->filename = xstrdup( pFile->name );
407         return;
408     }
409
410     file = src ? open_src_file( pFile ) : open_include_file( pFile );
411     if (!file) return;
412     ext = get_extension( pFile->name );
413     if (ext && !strcmp( ext, ".idl" )) parse_idl_file( pFile, file );
414     else parse_c_file( pFile, file );
415     fclose(file);
416 }
417
418
419 /*******************************************************************
420  *         output_include
421  */
422 static void output_include( FILE *file, INCL_FILE *pFile,
423                             INCL_FILE *owner, int *column )
424 {
425     int i;
426
427     if (pFile->owner == owner) return;
428     if (!pFile->filename) return;
429     pFile->owner = owner;
430     if (*column + strlen(pFile->filename) + 1 > 70)
431     {
432         fprintf( file, " \\\n" );
433         *column = 0;
434     }
435     fprintf( file, " %s", pFile->filename );
436     *column += strlen(pFile->filename) + 1;
437     for (i = 0; i < MAX_INCLUDES; i++)
438         if (pFile->files[i]) output_include( file, pFile->files[i],
439                                              owner, column );
440 }
441
442
443 /*******************************************************************
444  *         output_src
445  */
446 static void output_src( FILE *file, INCL_FILE *pFile, int *column )
447 {
448     char *obj = xstrdup( pFile->name );
449     char *ext = get_extension( obj );
450     if (ext)
451     {
452         *ext++ = 0;
453         if (!strcmp( ext, "y" ))  /* yacc file */
454         {
455             *column += fprintf( file, "y.tab.o: y.tab.c" );
456         }
457         else if (!strcmp( ext, "l" ))  /* lex file */
458         {
459             *column += fprintf( file, "%s.o: %s.c", LEX_OUTPUT_ROOT, LEX_OUTPUT_ROOT );
460         }
461         else if (!strcmp( ext, "rc" ))  /* resource file */
462         {
463             *column += fprintf( file, "%s.res: %s", obj, pFile->filename );
464         }
465         else if (!strcmp( ext, "mc" ))  /* message file */
466         {
467             *column += fprintf( file, "%s.mc.rc: %s", obj, pFile->filename );
468         }
469         else if (!strcmp( ext, "idl" ))  /* IDL file */
470         {
471             *column += fprintf( file, "%s.h: %s", obj, pFile->filename );
472         }
473         else
474         {
475             *column += fprintf( file, "%s.o: %s", obj, pFile->filename );
476         }
477     }
478     free( obj );
479 }
480
481
482 /*******************************************************************
483  *         output_dependencies
484  */
485 static void output_dependencies(void)
486 {
487     INCL_FILE *pFile;
488     int i, column;
489     FILE *file = NULL;
490     char buffer[1024];
491
492     if (Separator && ((file = fopen( OutputFileName, "r+" ))))
493     {
494         while (fgets( buffer, sizeof(buffer), file ))
495             if (!strncmp( buffer, Separator, strlen(Separator) )) break;
496         ftruncate( fileno(file), ftell(file) );
497         fseek( file, 0L, SEEK_END );
498     }
499     if (!file)
500     {
501         if (!(file = fopen( OutputFileName, Separator ? "a" : "w" )))
502         {
503             perror( OutputFileName );
504             exit(1);
505         }
506     }
507     for( pFile = firstSrc; pFile; pFile = pFile->next)
508     {
509         column = 0;
510         output_src( file, pFile, &column );
511         for (i = 0; i < MAX_INCLUDES; i++)
512             if (pFile->files[i]) output_include( file, pFile->files[i],
513                                                  pFile, &column );
514         fprintf( file, "\n" );
515     }
516     fclose(file);
517 }
518
519
520 /*******************************************************************
521  *         parse_option
522  */
523 static void parse_option( const char *opt )
524 {
525     switch(opt[1])
526     {
527     case 'I':
528         if (opt[2]) add_include_path( opt + 2 );
529         break;
530     case 'C':
531         if (opt[2]) SrcDir = opt + 2;
532         else SrcDir = NULL;
533         break;
534     case 'f':
535         if (opt[2]) OutputFileName = opt + 2;
536         break;
537     case 's':
538         if (opt[2]) Separator = opt + 2;
539         else Separator = NULL;
540         break;
541     default:
542         fprintf( stderr, "Unknown option '%s'\n", opt );
543         fprintf( stderr, Usage, ProgramName );
544         exit(1);
545     }
546 }
547
548
549 /*******************************************************************
550  *         main
551  */
552 int main( int argc, char *argv[] )
553 {
554     INCL_FILE *pFile;
555
556     ProgramName = argv[0];
557     while (argc > 1)
558     {
559         if (*argv[1] == '-') parse_option( argv[1] );
560         else
561         {
562             pFile = add_src_file( argv[1] );
563             parse_file( pFile, 1 );
564         }
565         argc--;
566         argv++;
567     }
568     for (pFile = firstInclude; pFile; pFile = pFile->next)
569         parse_file( pFile, 0 );
570     if( firstSrc ) output_dependencies();
571     return 0;
572 }