secur32: Check for actual return value on invalid QuerySecurityPackageInfo call.
[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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #define NO_LIBWINE_PORT
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <ctype.h>
27 #include <errno.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <stdarg.h>
31 #include <string.h>
32 #ifdef HAVE_UNISTD_H
33 # include <unistd.h>
34 #endif
35 #include "wine/list.h"
36
37 /* Max first-level includes per file */
38 #define MAX_INCLUDES 200
39
40 typedef struct _INCL_FILE
41 {
42     struct list        entry;
43     char              *name;
44     char              *filename;
45     char              *sourcename;    /* source file name for generated headers */
46     struct _INCL_FILE *included_by;   /* file that included this one */
47     int                included_line; /* line where this file was included */
48     int                system;        /* is it a system include (#include <name>) */
49     struct _INCL_FILE *owner;
50     struct _INCL_FILE *files[MAX_INCLUDES];
51 } INCL_FILE;
52
53 static struct list sources = LIST_INIT(sources);
54 static struct list includes = LIST_INIT(includes);
55
56 typedef struct _INCL_PATH
57 {
58     struct list entry;
59     const char *name;
60 } INCL_PATH;
61
62 static struct list paths = LIST_INIT(paths);
63
64 static const char *src_dir;
65 static const char *top_src_dir;
66 static const char *top_obj_dir;
67 static const char *OutputFileName = "Makefile";
68 static const char *Separator = "### Dependencies";
69 static const char *ProgramName;
70 static int input_line;
71
72 static const char Usage[] =
73     "Usage: %s [options] [files]\n"
74     "Options:\n"
75     "   -Idir   Search for include files in directory 'dir'\n"
76     "   -Cdir   Search for source files in directory 'dir'\n"
77     "   -Sdir   Set the top source directory\n"
78     "   -Sdir   Set the top object directory\n"
79     "   -fxxx   Store output in file 'xxx' (default: Makefile)\n"
80     "   -sxxx   Use 'xxx' as separator (default: \"### Dependencies\")\n";
81
82
83 /*******************************************************************
84  *         fatal_error
85  */
86 static void fatal_error( const char *msg, ... )
87 {
88     va_list valist;
89     va_start( valist, msg );
90     vfprintf( stderr, msg, valist );
91     va_end( valist );
92     exit(1);
93 }
94
95
96 /*******************************************************************
97  *         xmalloc
98  */
99 static void *xmalloc( size_t size )
100 {
101     void *res;
102     if (!(res = malloc (size ? size : 1)))
103         fatal_error( "%s: Virtual memory exhausted.\n", ProgramName );
104     return res;
105 }
106
107
108 /*******************************************************************
109  *         xrealloc
110  */
111 static void *xrealloc (void *ptr, size_t size)
112 {
113     void *res;
114     assert( size );
115     if (!(res = realloc( ptr, size )))
116         fatal_error( "%s: Virtual memory exhausted.\n", ProgramName );
117     return res;
118 }
119
120 /*******************************************************************
121  *         xstrdup
122  */
123 static char *xstrdup( const char *str )
124 {
125     char *res = strdup( str );
126     if (!res) fatal_error( "%s: Virtual memory exhausted.\n", ProgramName );
127     return res;
128 }
129
130
131 /*******************************************************************
132  *         strmake
133  */
134 static char *strmake( const char* fmt, ... )
135 {
136     int n;
137     size_t size = 100;
138     va_list ap;
139
140     for (;;)
141     {
142         char *p = xmalloc (size);
143         va_start(ap, fmt);
144         n = vsnprintf (p, size, fmt, ap);
145         va_end(ap);
146         if (n == -1) size *= 2;
147         else if ((size_t)n >= size) size = n + 1;
148         else return p;
149         free(p);
150     }
151 }
152
153
154 /*******************************************************************
155  *         strendswith
156  */
157 static int strendswith( const char* str, const char* end )
158 {
159     int l = strlen(str);
160     int m = strlen(end);
161
162     return l >= m && strcmp(str + l - m, end) == 0;
163 }
164
165 /*******************************************************************
166  *         get_extension
167  */
168 static char *get_extension( char *filename )
169 {
170     char *ext = strrchr( filename, '.' );
171     if (ext && strchr( ext, '/' )) ext = NULL;
172     return ext;
173 }
174
175
176 /*******************************************************************
177  *         get_line
178  */
179 static char *get_line( FILE *file )
180 {
181     static char *buffer;
182     static unsigned int size;
183
184     if (!size)
185     {
186         size = 1024;
187         buffer = xmalloc( size );
188     }
189     if (!fgets( buffer, size, file )) return NULL;
190     input_line++;
191
192     for (;;)
193     {
194         char *p = buffer + strlen(buffer);
195         /* if line is larger than buffer, resize buffer */
196         while (p == buffer + size - 1 && p[-1] != '\n')
197         {
198             buffer = xrealloc( buffer, size * 2 );
199             fgets( buffer + size - 1, size + 1, file );
200             p = buffer + strlen(buffer);
201             size *= 2;
202         }
203         if (p > buffer && p[-1] == '\n')
204         {
205             *(--p) = 0;
206             if (p > buffer && p[-1] == '\r') *(--p) = 0;
207             if (p > buffer && p[-1] == '\\')
208             {
209                 *(--p) = 0;
210                 /* line ends in backslash, read continuation line */
211                 fgets( p, size - (p - buffer), file );
212                 input_line++;
213                 continue;
214             }
215         }
216         return buffer;
217     }
218 }
219
220 /*******************************************************************
221  *         add_include_path
222  *
223  * Add a directory to the include path.
224  */
225 static void add_include_path( const char *name )
226 {
227     INCL_PATH *path = xmalloc( sizeof(*path) );
228     list_add_tail( &paths, &path->entry );
229     path->name = name;
230 }
231
232 /*******************************************************************
233  *         find_src_file
234  */
235 static INCL_FILE *find_src_file( const char *name )
236 {
237     INCL_FILE *file;
238
239     LIST_FOR_EACH_ENTRY( file, &sources, INCL_FILE, entry )
240         if (!strcmp( name, file->name )) return file;
241     return NULL;
242 }
243
244 /*******************************************************************
245  *         add_src_file
246  *
247  * Add a source file to the list.
248  */
249 static INCL_FILE *add_src_file( const char *name )
250 {
251     INCL_FILE *file;
252
253     if (find_src_file( name )) return NULL;  /* we already have it */
254     file = xmalloc( sizeof(*file) );
255     memset( file, 0, sizeof(*file) );
256     file->name = xstrdup(name);
257     list_add_tail( &sources, &file->entry );
258     return file;
259 }
260
261
262 /*******************************************************************
263  *         add_include
264  *
265  * Add an include file if it doesn't already exists.
266  */
267 static INCL_FILE *add_include( INCL_FILE *pFile, const char *name, int line, int system )
268 {
269     INCL_FILE *include;
270     char *ext;
271     int pos;
272
273     for (pos = 0; pos < MAX_INCLUDES; pos++) if (!pFile->files[pos]) break;
274     if (pos >= MAX_INCLUDES)
275         fatal_error( "%s: %s: too many included files, please fix MAX_INCLUDES\n",
276                      ProgramName, pFile->name );
277
278     /* enforce some rules for the Wine tree */
279
280     if (!memcmp( name, "../", 3 ))
281         fatal_error( "%s:%d: #include directive with relative path not allowed\n",
282                      pFile->filename, line );
283
284     if (!strcmp( name, "config.h" ))
285     {
286         if ((ext = strrchr( pFile->filename, '.' )) && !strcmp( ext, ".h" ))
287             fatal_error( "%s:%d: config.h must not be included by a header file\n",
288                          pFile->filename, line );
289         if (pos)
290             fatal_error( "%s:%d: config.h must be included before anything else\n",
291                          pFile->filename, line );
292     }
293     else if (!strcmp( name, "wine/port.h" ))
294     {
295         if ((ext = strrchr( pFile->filename, '.' )) && !strcmp( ext, ".h" ))
296             fatal_error( "%s:%d: wine/port.h must not be included by a header file\n",
297                          pFile->filename, line );
298         if (!pos) fatal_error( "%s:%d: config.h must be included before wine/port.h\n",
299                                pFile->filename, line );
300         if (pos > 1)
301             fatal_error( "%s:%d: wine/port.h must be included before everything except config.h\n",
302                          pFile->filename, line );
303         if (strcmp( pFile->files[0]->name, "config.h" ))
304             fatal_error( "%s:%d: config.h must be included before wine/port.h\n",
305                          pFile->filename, line );
306     }
307
308     LIST_FOR_EACH_ENTRY( include, &includes, INCL_FILE, entry )
309         if (!strcmp( name, include->name )) goto found;
310
311     include = xmalloc( sizeof(INCL_FILE) );
312     memset( include, 0, sizeof(INCL_FILE) );
313     include->name = xstrdup(name);
314     include->included_by = pFile;
315     include->included_line = line;
316     include->system = system;
317     list_add_tail( &includes, &include->entry );
318 found:
319     pFile->files[pos] = include;
320     return include;
321 }
322
323
324 /*******************************************************************
325  *         open_src_file
326  */
327 static FILE *open_src_file( INCL_FILE *pFile )
328 {
329     FILE *file;
330
331     /* first try name as is */
332     if ((file = fopen( pFile->name, "r" )))
333     {
334         pFile->filename = xstrdup( pFile->name );
335         return file;
336     }
337     /* now try in source dir */
338     if (src_dir)
339     {
340         pFile->filename = strmake( "%s/%s", src_dir, pFile->name );
341         file = fopen( pFile->filename, "r" );
342     }
343     if (!file)
344     {
345         perror( pFile->name );
346         exit(1);
347     }
348     return file;
349 }
350
351
352 /*******************************************************************
353  *         open_include_file
354  */
355 static FILE *open_include_file( INCL_FILE *pFile )
356 {
357     FILE *file = NULL;
358     char *filename, *p;
359     INCL_PATH *path;
360
361     errno = ENOENT;
362
363     /* check for generated bison header */
364
365     if (strendswith( pFile->name, ".tab.h" ))
366     {
367         if (src_dir)
368             filename = strmake( "%s/%.*s.y", src_dir, strlen(pFile->name) - 6, pFile->name );
369         else
370             filename = strmake( "%.*s.y", strlen(pFile->name) - 6, pFile->name );
371
372         if ((file = fopen( filename, "r" )))
373         {
374             pFile->sourcename = filename;
375             pFile->filename = xstrdup( pFile->name );
376             /* don't bother to parse it */
377             fclose( file );
378             return NULL;
379         }
380         free( filename );
381     }
382
383     /* check for generated message resource */
384
385     if (strendswith( pFile->name, ".mc.rc" ))
386     {
387         if (src_dir)
388             filename = strmake( "%s/%s", src_dir, pFile->name );
389         else
390             filename = xstrdup( pFile->name );
391
392         filename[strlen(filename) - 3] = 0;
393
394         if ((file = fopen( filename, "r" )))
395         {
396             pFile->sourcename = filename;
397             pFile->filename = xstrdup( pFile->name );
398             /* don't bother to parse it */
399             fclose( file );
400             return NULL;
401         }
402         free( filename );
403     }
404
405     /* check for corresponding idl file in source dir */
406
407     if (strendswith( pFile->name, ".h" ))
408     {
409         if (src_dir)
410             filename = strmake( "%s/%.*s.idl", src_dir, strlen(pFile->name) - 2, pFile->name );
411         else
412             filename = strmake( "%.*s.idl", strlen(pFile->name) - 2, pFile->name );
413
414         if ((file = fopen( filename, "r" )))
415         {
416             pFile->sourcename = filename;
417             pFile->filename = xstrdup( pFile->name );
418             return file;
419         }
420         free( filename );
421     }
422
423     /* first try name as is */
424     if ((file = fopen( pFile->name, "r" )))
425     {
426         pFile->filename = xstrdup( pFile->name );
427         return file;
428     }
429
430     /* now try in source dir */
431     if (src_dir)
432     {
433         filename = strmake( "%s/%s", src_dir, pFile->name );
434         if ((file = fopen( filename, "r" ))) goto found;
435         free( filename );
436     }
437
438     /* check for corresponding idl file in global includes */
439
440     if (strendswith( pFile->name, ".h" ))
441     {
442         if (top_src_dir)
443             filename = strmake( "%s/include/%.*s.idl",
444                                 top_src_dir, strlen(pFile->name) - 2, pFile->name );
445         else if (top_obj_dir)
446             filename = strmake( "%s/include/%.*s.idl",
447                                 top_obj_dir, strlen(pFile->name) - 2, pFile->name );
448         else
449             filename = NULL;
450
451         if (filename && (file = fopen( filename, "r" )))
452         {
453             pFile->sourcename = filename;
454             pFile->filename = strmake( "%s/include/%s", top_obj_dir, pFile->name );
455             return file;
456         }
457         free( filename );
458     }
459
460     /* now try in global includes */
461     if (top_obj_dir)
462     {
463         filename = strmake( "%s/include/%s", top_obj_dir, pFile->name );
464         if ((file = fopen( filename, "r" ))) goto found;
465         free( filename );
466     }
467     if (top_src_dir)
468     {
469         filename = strmake( "%s/include/%s", top_src_dir, pFile->name );
470         if ((file = fopen( filename, "r" ))) goto found;
471         free( filename );
472     }
473
474     /* now search in include paths */
475     LIST_FOR_EACH_ENTRY( path, &paths, INCL_PATH, entry )
476     {
477         filename = strmake( "%s/%s", path->name, pFile->name );
478         if ((file = fopen( filename, "r" ))) goto found;
479         free( filename );
480     }
481     if (pFile->system) return NULL;  /* ignore system files we cannot find */
482
483     /* try in src file directory */
484     if ((p = strrchr(pFile->included_by->filename, '/')))
485     {
486         int l = p - pFile->included_by->filename + 1;
487         filename = xmalloc(l + strlen(pFile->name) + 1);
488         memcpy( filename, pFile->included_by->filename, l );
489         strcpy( filename + l, pFile->name );
490         if ((file = fopen( filename, "r" ))) goto found;
491         free( filename );
492     }
493
494     perror( pFile->name );
495     while (pFile->included_by)
496     {
497         const char *parent = pFile->included_by->sourcename;
498         if (!parent) parent = pFile->included_by->name;
499         fprintf( stderr, "  %s was first included from %s:%d\n",
500                  pFile->name, parent, pFile->included_line );
501         pFile = pFile->included_by;
502     }
503     exit(1);
504
505 found:
506     pFile->filename = filename;
507     return file;
508 }
509
510
511 /*******************************************************************
512  *         parse_idl_file
513  *
514  * If for_h_file is non-zero, it means we are not interested in the idl file
515  * itself, but only in the contents of the .h file that will be generated from it.
516  */
517 static void parse_idl_file( INCL_FILE *pFile, FILE *file, int for_h_file )
518 {
519     char *buffer, *include;
520
521     if (for_h_file)
522     {
523         /* generated .h file always includes these */
524         add_include( pFile, "rpc.h", 0, 1 );
525         add_include( pFile, "rpcndr.h", 0, 1 );
526     }
527
528     input_line = 0;
529     while ((buffer = get_line( file )))
530     {
531         char quote;
532         char *p = buffer;
533         while (*p && isspace(*p)) p++;
534
535         if (!strncmp( p, "import", 6 ))
536         {
537             p += 6;
538             while (*p && isspace(*p)) p++;
539             if (*p != '"') continue;
540             include = ++p;
541             while (*p && (*p != '"')) p++;
542             if (!*p) fatal_error( "%s:%d: Malformed import directive\n", pFile->filename, input_line );
543             *p = 0;
544             if (for_h_file && strendswith( include, ".idl" )) strcpy( p - 4, ".h" );
545             add_include( pFile, include, input_line, 0 );
546             continue;
547         }
548
549         if (for_h_file)  /* only check for #include inside cpp_quote */
550         {
551             if (strncmp( p, "cpp_quote", 9 )) continue;
552             p += 9;
553             while (*p && isspace(*p)) p++;
554             if (*p++ != '(') continue;
555             while (*p && isspace(*p)) p++;
556             if (*p++ != '"') continue;
557             if (*p++ != '#') continue;
558             while (*p && isspace(*p)) p++;
559             if (strncmp( p, "include", 7 )) continue;
560             p += 7;
561             while (*p && isspace(*p)) p++;
562             if (*p == '\\' && p[1] == '"')
563             {
564                 p += 2;
565                 quote = '"';
566             }
567             else
568             {
569                 if (*p++ != '<' ) continue;
570                 quote = '>';
571             }
572             include = p;
573             while (*p && (*p != quote)) p++;
574             if (!*p || (quote == '"' && p[-1] != '\\'))
575                 fatal_error( "%s:%d: Malformed #include directive inside cpp_quote\n",
576                              pFile->filename, input_line );
577             if (quote == '"') p--;  /* remove backslash */
578             *p = 0;
579             add_include( pFile, include, input_line, (quote == '>') );
580             continue;
581         }
582
583         /* check for normal #include */
584         if (*p++ != '#') continue;
585         while (*p && isspace(*p)) p++;
586         if (strncmp( p, "include", 7 )) continue;
587         p += 7;
588         while (*p && isspace(*p)) p++;
589         if (*p != '\"' && *p != '<' ) continue;
590         quote = *p++;
591         if (quote == '<') quote = '>';
592         include = p;
593         while (*p && (*p != quote)) p++;
594         if (!*p) fatal_error( "%s:%d: Malformed #include directive\n", pFile->filename, input_line );
595         *p = 0;
596         add_include( pFile, include, input_line, (quote == '>') );
597     }
598 }
599
600 /*******************************************************************
601  *         parse_c_file
602  */
603 static void parse_c_file( INCL_FILE *pFile, FILE *file )
604 {
605     char *buffer, *include;
606
607     input_line = 0;
608     while ((buffer = get_line( file )))
609     {
610         char quote;
611         char *p = buffer;
612         while (*p && isspace(*p)) p++;
613         if (*p++ != '#') continue;
614         while (*p && isspace(*p)) p++;
615         if (strncmp( p, "include", 7 )) continue;
616         p += 7;
617         while (*p && isspace(*p)) p++;
618         if (*p != '\"' && *p != '<' ) continue;
619         quote = *p++;
620         if (quote == '<') quote = '>';
621         include = p;
622         while (*p && (*p != quote)) p++;
623         if (!*p) fatal_error( "%s:%d: Malformed #include directive\n",
624                               pFile->filename, input_line );
625         *p = 0;
626         add_include( pFile, include, input_line, (quote == '>') );
627     }
628 }
629
630
631 /*******************************************************************
632  *         parse_rc_file
633  */
634 static void parse_rc_file( INCL_FILE *pFile, FILE *file )
635 {
636     char *buffer, *include;
637
638     input_line = 0;
639     while ((buffer = get_line( file )))
640     {
641         char quote;
642         char *p = buffer;
643         while (*p && isspace(*p)) p++;
644
645         if (p[0] == '/' && p[1] == '*')  /* check for magic makedep comment */
646         {
647             p += 2;
648             while (*p && isspace(*p)) p++;
649             if (strncmp( p, "@makedep:", 9 )) continue;
650             p += 9;
651             while (*p && isspace(*p)) p++;
652             quote = '"';
653             if (*p == quote)
654             {
655                 include = ++p;
656                 while (*p && *p != quote) p++;
657             }
658             else
659             {
660                 include = p;
661                 while (*p && !isspace(*p) && *p != '*') p++;
662             }
663             if (!*p)
664                 fatal_error( "%s:%d: Malformed makedep comment\n", pFile->filename, input_line );
665             *p = 0;
666         }
667         else  /* check for #include */
668         {
669             if (*p++ != '#') continue;
670             while (*p && isspace(*p)) p++;
671             if (strncmp( p, "include", 7 )) continue;
672             p += 7;
673             while (*p && isspace(*p)) p++;
674             if (*p != '\"' && *p != '<' ) continue;
675             quote = *p++;
676             if (quote == '<') quote = '>';
677             include = p;
678             while (*p && (*p != quote)) p++;
679             if (!*p) fatal_error( "%s:%d: Malformed #include directive\n",
680                                   pFile->filename, input_line );
681             *p = 0;
682         }
683         add_include( pFile, include, input_line, (quote == '>') );
684     }
685 }
686
687
688 /*******************************************************************
689  *         parse_generated_idl
690  */
691 static void parse_generated_idl( INCL_FILE *source )
692 {
693     char *header, *basename;
694
695     basename = xstrdup( source->name );
696     basename[strlen(basename) - 4] = 0;
697     header = strmake( "%s.h", basename );
698     source->filename = xstrdup( source->name );
699
700     if (strendswith( source->name, "_c.c" ))
701     {
702         add_include( source, header, 0, 0 );
703     }
704     else if (strendswith( source->name, "_i.c" ))
705     {
706         add_include( source, "rpc.h", 0, 1 );
707         add_include( source, "rpcndr.h", 0, 1 );
708         add_include( source, "guiddef.h", 0, 1 );
709     }
710     else if (strendswith( source->name, "_p.c" ))
711     {
712         add_include( source, "objbase.h", 0, 1 );
713         add_include( source, "rpcproxy.h", 0, 1 );
714         add_include( source, header, 0, 0 );
715     }
716     else if (strendswith( source->name, "_s.c" ))
717     {
718         add_include( source, header, 0, 0 );
719     }
720
721     free( header );
722     free( basename );
723 }
724
725 /*******************************************************************
726  *         parse_file
727  */
728 static void parse_file( INCL_FILE *pFile, int src )
729 {
730     FILE *file;
731
732     /* special case for source files generated from idl */
733     if (strendswith( pFile->name, "_c.c" ) ||
734         strendswith( pFile->name, "_i.c" ) ||
735         strendswith( pFile->name, "_p.c" ) ||
736         strendswith( pFile->name, "_s.c" ))
737     {
738         parse_generated_idl( pFile );
739         return;
740     }
741
742     file = src ? open_src_file( pFile ) : open_include_file( pFile );
743     if (!file) return;
744
745     if (pFile->sourcename && strendswith( pFile->sourcename, ".idl" ))
746         parse_idl_file( pFile, file, 1 );
747     else if (strendswith( pFile->filename, ".idl" ))
748         parse_idl_file( pFile, file, 0 );
749     else if (strendswith( pFile->filename, ".c" ) ||
750              strendswith( pFile->filename, ".h" ) ||
751              strendswith( pFile->filename, ".l" ) ||
752              strendswith( pFile->filename, ".y" ))
753         parse_c_file( pFile, file );
754     else if (strendswith( pFile->filename, ".rc" ))
755         parse_rc_file( pFile, file );
756     fclose(file);
757 }
758
759
760 /*******************************************************************
761  *         output_include
762  */
763 static void output_include( FILE *file, INCL_FILE *pFile,
764                             INCL_FILE *owner, int *column )
765 {
766     int i;
767
768     if (pFile->owner == owner) return;
769     if (!pFile->filename) return;
770     pFile->owner = owner;
771     if (*column + strlen(pFile->filename) + 1 > 70)
772     {
773         fprintf( file, " \\\n" );
774         *column = 0;
775     }
776     fprintf( file, " %s", pFile->filename );
777     *column += strlen(pFile->filename) + 1;
778     for (i = 0; i < MAX_INCLUDES; i++)
779         if (pFile->files[i]) output_include( file, pFile->files[i],
780                                              owner, column );
781 }
782
783
784 /*******************************************************************
785  *         output_src
786  */
787 static void output_src( FILE *file, INCL_FILE *pFile, int *column )
788 {
789     char *obj = xstrdup( pFile->name );
790     char *ext = get_extension( obj );
791     if (ext)
792     {
793         *ext++ = 0;
794         if (!strcmp( ext, "y" ))  /* yacc file */
795         {
796             *column += fprintf( file, "%s.tab.o: %s.tab.c", obj, obj );
797         }
798         else if (!strcmp( ext, "l" ))  /* lex file */
799         {
800             *column += fprintf( file, "%s.yy.o: %s.yy.c", obj, obj );
801         }
802         else if (!strcmp( ext, "rc" ))  /* resource file */
803         {
804             *column += fprintf( file, "%s.res: %s", obj, pFile->filename );
805         }
806         else if (!strcmp( ext, "mc" ))  /* message file */
807         {
808             *column += fprintf( file, "%s.mc.rc: %s", obj, pFile->filename );
809         }
810         else if (!strcmp( ext, "idl" ))  /* IDL file */
811         {
812             char *name;
813
814             *column += fprintf( file, "%s.h", obj );
815
816             name = strmake( "%s_c.c", obj );
817             if (find_src_file( name )) *column += fprintf( file, " %s", name );
818             free( name );
819             name = strmake( "%s_i.c", obj );
820             if (find_src_file( name )) *column += fprintf( file, " %s", name );
821             free( name );
822             name = strmake( "%s_p.c", obj );
823             if (find_src_file( name )) *column += fprintf( file, " %s", name );
824             free( name );
825             name = strmake( "%s_s.c", obj );
826             if (find_src_file( name )) *column += fprintf( file, " %s", name );
827             free( name );
828
829             *column += fprintf( file, ": %s", pFile->filename );
830         }
831         else
832         {
833             *column += fprintf( file, "%s.o: %s", obj, pFile->filename );
834         }
835     }
836     free( obj );
837 }
838
839
840 /*******************************************************************
841  *         output_dependencies
842  */
843 static void output_dependencies(void)
844 {
845     INCL_FILE *pFile;
846     int i, column;
847     FILE *file = NULL;
848     char *buffer;
849
850     if (Separator && ((file = fopen( OutputFileName, "r+" ))))
851     {
852         while ((buffer = get_line( file )))
853         {
854             if (strncmp( buffer, Separator, strlen(Separator) )) continue;
855             ftruncate( fileno(file), ftell(file) );
856             fseek( file, 0L, SEEK_END );
857             break;
858         }
859     }
860     if (!file)
861     {
862         if (!(file = fopen( OutputFileName, Separator ? "a" : "w" )))
863         {
864             perror( OutputFileName );
865             exit(1);
866         }
867     }
868     LIST_FOR_EACH_ENTRY( pFile, &sources, INCL_FILE, entry )
869     {
870         column = 0;
871         output_src( file, pFile, &column );
872         for (i = 0; i < MAX_INCLUDES; i++)
873             if (pFile->files[i]) output_include( file, pFile->files[i],
874                                                  pFile, &column );
875         fprintf( file, "\n" );
876     }
877     fclose(file);
878 }
879
880
881 /*******************************************************************
882  *         parse_option
883  */
884 static void parse_option( const char *opt )
885 {
886     switch(opt[1])
887     {
888     case 'I':
889         if (opt[2]) add_include_path( opt + 2 );
890         break;
891     case 'C':
892         src_dir = opt + 2;
893         break;
894     case 'S':
895         top_src_dir = opt + 2;
896         break;
897     case 'T':
898         top_obj_dir = opt + 2;
899         break;
900     case 'f':
901         if (opt[2]) OutputFileName = opt + 2;
902         break;
903     case 's':
904         if (opt[2]) Separator = opt + 2;
905         else Separator = NULL;
906         break;
907     default:
908         fprintf( stderr, "Unknown option '%s'\n", opt );
909         fprintf( stderr, Usage, ProgramName );
910         exit(1);
911     }
912 }
913
914
915 /*******************************************************************
916  *         main
917  */
918 int main( int argc, char *argv[] )
919 {
920     INCL_FILE *pFile;
921     INCL_PATH *path, *next;
922     int i, j;
923
924     ProgramName = argv[0];
925
926     i = 1;
927     while (i < argc)
928     {
929         if (argv[i][0] == '-')
930         {
931             parse_option( argv[i] );
932             for (j = i; j < argc; j++) argv[j] = argv[j+1];
933             argc--;
934         }
935         else i++;
936     }
937
938     /* ignore redundant source paths */
939     if (src_dir && !strcmp( src_dir, "." )) src_dir = NULL;
940     if (top_src_dir && top_obj_dir && !strcmp( top_src_dir, top_obj_dir )) top_src_dir = NULL;
941
942     /* get rid of absolute paths that don't point into the source dir */
943     LIST_FOR_EACH_ENTRY_SAFE( path, next, &paths, INCL_PATH, entry )
944     {
945         if (path->name[0] != '/') continue;
946         if (top_src_dir)
947         {
948             if (!strncmp( path->name, top_src_dir, strlen(top_src_dir) ) &&
949                 path->name[strlen(top_src_dir)] == '/') continue;
950         }
951         list_remove( &path->entry );
952         free( path );
953     }
954
955     for (i = 1; i < argc; i++)
956     {
957         if ((pFile = add_src_file( argv[i] ))) parse_file( pFile, 1 );
958     }
959     LIST_FOR_EACH_ENTRY( pFile, &includes, INCL_FILE, entry ) parse_file( pFile, 0 );
960     output_dependencies();
961     return 0;
962 }