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 " -Tdir 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_include
246 *
247 * Add an include file if it doesn't already exists.
248 */
249 static INCL_FILE *add_include( INCL_FILE *pFile, const char *name, int line, int system )
250 {
251 INCL_FILE *include;
252 char *ext;
253 int pos;
254
255 for (pos = 0; pos < MAX_INCLUDES; pos++) if (!pFile->files[pos]) break;
256 if (pos >= MAX_INCLUDES)
257 fatal_error( "%s: %s: too many included files, please fix MAX_INCLUDES\n",
258 ProgramName, pFile->name );
259
260 /* enforce some rules for the Wine tree */
261
262 if (!memcmp( name, "../", 3 ))
263 fatal_error( "%s:%d: #include directive with relative path not allowed\n",
264 pFile->filename, line );
265
266 if (!strcmp( name, "config.h" ))
267 {
268 if ((ext = strrchr( pFile->filename, '.' )) && !strcmp( ext, ".h" ))
269 fatal_error( "%s:%d: config.h must not be included by a header file\n",
270 pFile->filename, line );
271 if (pos)
272 fatal_error( "%s:%d: config.h must be included before anything else\n",
273 pFile->filename, line );
274 }
275 else if (!strcmp( name, "wine/port.h" ))
276 {
277 if ((ext = strrchr( pFile->filename, '.' )) && !strcmp( ext, ".h" ))
278 fatal_error( "%s:%d: wine/port.h must not be included by a header file\n",
279 pFile->filename, line );
280 if (!pos) fatal_error( "%s:%d: config.h must be included before wine/port.h\n",
281 pFile->filename, line );
282 if (pos > 1)
283 fatal_error( "%s:%d: wine/port.h must be included before everything except config.h\n",
284 pFile->filename, line );
285 if (strcmp( pFile->files[0]->name, "config.h" ))
286 fatal_error( "%s:%d: config.h must be included before wine/port.h\n",
287 pFile->filename, line );
288 }
289
290 LIST_FOR_EACH_ENTRY( include, &includes, INCL_FILE, entry )
291 if (!strcmp( name, include->name )) goto found;
292
293 include = xmalloc( sizeof(INCL_FILE) );
294 memset( include, 0, sizeof(INCL_FILE) );
295 include->name = xstrdup(name);
296 include->included_by = pFile;
297 include->included_line = line;
298 include->system = system;
299 list_add_tail( &includes, &include->entry );
300 found:
301 pFile->files[pos] = include;
302 return include;
303 }
304
305
306 /*******************************************************************
307 * open_src_file
308 */
309 static FILE *open_src_file( INCL_FILE *pFile )
310 {
311 FILE *file;
312
313 /* first try name as is */
314 if ((file = fopen( pFile->name, "r" )))
315 {
316 pFile->filename = xstrdup( pFile->name );
317 return file;
318 }
319 /* now try in source dir */
320 if (src_dir)
321 {
322 pFile->filename = strmake( "%s/%s", src_dir, pFile->name );
323 file = fopen( pFile->filename, "r" );
324 }
325 if (!file)
326 {
327 perror( pFile->name );
328 exit(1);
329 }
330 return file;
331 }
332
333
334 /*******************************************************************
335 * open_include_file
336 */
337 static FILE *open_include_file( INCL_FILE *pFile )
338 {
339 FILE *file = NULL;
340 char *filename, *p;
341 INCL_PATH *path;
342
343 errno = ENOENT;
344
345 /* check for generated bison header */
346
347 if (strendswith( pFile->name, ".tab.h" ))
348 {
349 if (src_dir)
350 filename = strmake( "%s/%.*s.y", src_dir, strlen(pFile->name) - 6, pFile->name );
351 else
352 filename = strmake( "%.*s.y", strlen(pFile->name) - 6, pFile->name );
353
354 if ((file = fopen( filename, "r" )))
355 {
356 pFile->sourcename = filename;
357 pFile->filename = xstrdup( pFile->name );
358 /* don't bother to parse it */
359 fclose( file );
360 return NULL;
361 }
362 free( filename );
363 }
364
365 /* check for generated message resource */
366
367 if (strendswith( pFile->name, ".mc.rc" ))
368 {
369 if (src_dir)
370 filename = strmake( "%s/%s", src_dir, pFile->name );
371 else
372 filename = xstrdup( pFile->name );
373
374 filename[strlen(filename) - 3] = 0;
375
376 if ((file = fopen( filename, "r" )))
377 {
378 pFile->sourcename = filename;
379 pFile->filename = xstrdup( pFile->name );
380 /* don't bother to parse it */
381 fclose( file );
382 return NULL;
383 }
384 free( filename );
385 }
386
387 /* check for corresponding idl file in source dir */
388
389 if (strendswith( pFile->name, ".h" ))
390 {
391 if (src_dir)
392 filename = strmake( "%s/%.*s.idl", src_dir, strlen(pFile->name) - 2, pFile->name );
393 else
394 filename = strmake( "%.*s.idl", strlen(pFile->name) - 2, pFile->name );
395
396 if ((file = fopen( filename, "r" )))
397 {
398 pFile->sourcename = filename;
399 pFile->filename = xstrdup( pFile->name );
400 return file;
401 }
402 free( filename );
403 }
404
405 /* first try name as is */
406 if ((file = fopen( pFile->name, "r" )))
407 {
408 pFile->filename = xstrdup( pFile->name );
409 return file;
410 }
411
412 /* now try in source dir */
413 if (src_dir)
414 {
415 filename = strmake( "%s/%s", src_dir, pFile->name );
416 if ((file = fopen( filename, "r" ))) goto found;
417 free( filename );
418 }
419
420 /* check for corresponding idl file in global includes */
421
422 if (strendswith( pFile->name, ".h" ))
423 {
424 if (top_src_dir)
425 filename = strmake( "%s/include/%.*s.idl",
426 top_src_dir, strlen(pFile->name) - 2, pFile->name );
427 else if (top_obj_dir)
428 filename = strmake( "%s/include/%.*s.idl",
429 top_obj_dir, strlen(pFile->name) - 2, pFile->name );
430 else
431 filename = NULL;
432
433 if (filename && (file = fopen( filename, "r" )))
434 {
435 pFile->sourcename = filename;
436 pFile->filename = strmake( "%s/include/%s", top_obj_dir, pFile->name );
437 return file;
438 }
439 free( filename );
440 }
441
442 /* now try in global includes */
443 if (top_obj_dir)
444 {
445 filename = strmake( "%s/include/%s", top_obj_dir, pFile->name );
446 if ((file = fopen( filename, "r" ))) goto found;
447 free( filename );
448 }
449 if (top_src_dir)
450 {
451 filename = strmake( "%s/include/%s", top_src_dir, pFile->name );
452 if ((file = fopen( filename, "r" ))) goto found;
453 free( filename );
454 }
455
456 /* now search in include paths */
457 LIST_FOR_EACH_ENTRY( path, &paths, INCL_PATH, entry )
458 {
459 filename = strmake( "%s/%s", path->name, pFile->name );
460 if ((file = fopen( filename, "r" ))) goto found;
461 free( filename );
462 }
463 if (pFile->system) return NULL; /* ignore system files we cannot find */
464
465 /* try in src file directory */
466 if ((p = strrchr(pFile->included_by->filename, '/')))
467 {
468 int l = p - pFile->included_by->filename + 1;
469 filename = xmalloc(l + strlen(pFile->name) + 1);
470 memcpy( filename, pFile->included_by->filename, l );
471 strcpy( filename + l, pFile->name );
472 if ((file = fopen( filename, "r" ))) goto found;
473 free( filename );
474 }
475
476 perror( pFile->name );
477 while (pFile->included_by)
478 {
479 const char *parent = pFile->included_by->sourcename;
480 if (!parent) parent = pFile->included_by->name;
481 fprintf( stderr, " %s was first included from %s:%d\n",
482 pFile->name, parent, pFile->included_line );
483 pFile = pFile->included_by;
484 }
485 exit(1);
486
487 found:
488 pFile->filename = filename;
489 return file;
490 }
491
492
493 /*******************************************************************
494 * parse_idl_file
495 *
496 * If for_h_file is non-zero, it means we are not interested in the idl file
497 * itself, but only in the contents of the .h file that will be generated from it.
498 */
499 static void parse_idl_file( INCL_FILE *pFile, FILE *file, int for_h_file )
500 {
501 char *buffer, *include;
502
503 if (for_h_file)
504 {
505 /* generated .h file always includes these */
506 add_include( pFile, "rpc.h", 0, 1 );
507 add_include( pFile, "rpcndr.h", 0, 1 );
508 }
509
510 input_line = 0;
511 while ((buffer = get_line( file )))
512 {
513 char quote;
514 char *p = buffer;
515 while (*p && isspace(*p)) p++;
516
517 if (!strncmp( p, "import", 6 ))
518 {
519 p += 6;
520 while (*p && isspace(*p)) p++;
521 if (*p != '"') continue;
522 include = ++p;
523 while (*p && (*p != '"')) p++;
524 if (!*p) fatal_error( "%s:%d: Malformed import directive\n", pFile->filename, input_line );
525 *p = 0;
526 if (for_h_file && strendswith( include, ".idl" )) strcpy( p - 4, ".h" );
527 add_include( pFile, include, input_line, 0 );
528 continue;
529 }
530
531 if (for_h_file) /* only check for #include inside cpp_quote */
532 {
533 if (strncmp( p, "cpp_quote", 9 )) continue;
534 p += 9;
535 while (*p && isspace(*p)) p++;
536 if (*p++ != '(') continue;
537 while (*p && isspace(*p)) p++;
538 if (*p++ != '"') continue;
539 if (*p++ != '#') continue;
540 while (*p && isspace(*p)) p++;
541 if (strncmp( p, "include", 7 )) continue;
542 p += 7;
543 while (*p && isspace(*p)) p++;
544 if (*p == '\\' && p[1] == '"')
545 {
546 p += 2;
547 quote = '"';
548 }
549 else
550 {
551 if (*p++ != '<' ) continue;
552 quote = '>';
553 }
554 include = p;
555 while (*p && (*p != quote)) p++;
556 if (!*p || (quote == '"' && p[-1] != '\\'))
557 fatal_error( "%s:%d: Malformed #include directive inside cpp_quote\n",
558 pFile->filename, input_line );
559 if (quote == '"') p--; /* remove backslash */
560 *p = 0;
561 add_include( pFile, include, input_line, (quote == '>') );
562 continue;
563 }
564
565 /* check for normal #include */
566 if (*p++ != '#') continue;
567 while (*p && isspace(*p)) p++;
568 if (strncmp( p, "include", 7 )) continue;
569 p += 7;
570 while (*p && isspace(*p)) p++;
571 if (*p != '\"' && *p != '<' ) continue;
572 quote = *p++;
573 if (quote == '<') quote = '>';
574 include = p;
575 while (*p && (*p != quote)) p++;
576 if (!*p) fatal_error( "%s:%d: Malformed #include directive\n", pFile->filename, input_line );
577 *p = 0;
578 add_include( pFile, include, input_line, (quote == '>') );
579 }
580 }
581
582 /*******************************************************************
583 * parse_c_file
584 */
585 static void parse_c_file( INCL_FILE *pFile, FILE *file )
586 {
587 char *buffer, *include;
588
589 input_line = 0;
590 while ((buffer = get_line( file )))
591 {
592 char quote;
593 char *p = buffer;
594 while (*p && isspace(*p)) p++;
595 if (*p++ != '#') continue;
596 while (*p && isspace(*p)) p++;
597 if (strncmp( p, "include", 7 )) continue;
598 p += 7;
599 while (*p && isspace(*p)) p++;
600 if (*p != '\"' && *p != '<' ) continue;
601 quote = *p++;
602 if (quote == '<') quote = '>';
603 include = p;
604 while (*p && (*p != quote)) p++;
605 if (!*p) fatal_error( "%s:%d: Malformed #include directive\n",
606 pFile->filename, input_line );
607 *p = 0;
608 add_include( pFile, include, input_line, (quote == '>') );
609 }
610 }
611
612
613 /*******************************************************************
614 * parse_rc_file
615 */
616 static void parse_rc_file( INCL_FILE *pFile, FILE *file )
617 {
618 char *buffer, *include;
619
620 input_line = 0;
621 while ((buffer = get_line( file )))
622 {
623 char quote;
624 char *p = buffer;
625 while (*p && isspace(*p)) p++;
626
627 if (p[0] == '/' && p[1] == '*') /* check for magic makedep comment */
628 {
629 p += 2;
630 while (*p && isspace(*p)) p++;
631 if (strncmp( p, "@makedep:", 9 )) continue;
632 p += 9;
633 while (*p && isspace(*p)) p++;
634 quote = '"';
635 if (*p == quote)
636 {
637 include = ++p;
638 while (*p && *p != quote) p++;
639 }
640 else
641 {
642 include = p;
643 while (*p && !isspace(*p) && *p != '*') p++;
644 }
645 if (!*p)
646 fatal_error( "%s:%d: Malformed makedep comment\n", pFile->filename, input_line );
647 *p = 0;
648 }
649 else /* check for #include */
650 {
651 if (*p++ != '#') continue;
652 while (*p && isspace(*p)) p++;
653 if (strncmp( p, "include", 7 )) continue;
654 p += 7;
655 while (*p && isspace(*p)) p++;
656 if (*p != '\"' && *p != '<' ) continue;
657 quote = *p++;
658 if (quote == '<') quote = '>';
659 include = p;
660 while (*p && (*p != quote)) p++;
661 if (!*p) fatal_error( "%s:%d: Malformed #include directive\n",
662 pFile->filename, input_line );
663 *p = 0;
664 }
665 add_include( pFile, include, input_line, (quote == '>') );
666 }
667 }
668
669
670 /*******************************************************************
671 * parse_generated_idl
672 */
673 static void parse_generated_idl( INCL_FILE *source )
674 {
675 char *header, *basename;
676
677 basename = xstrdup( source->name );
678 basename[strlen(basename) - 4] = 0;
679 header = strmake( "%s.h", basename );
680 source->filename = xstrdup( source->name );
681
682 if (strendswith( source->name, "_c.c" ))
683 {
684 add_include( source, header, 0, 0 );
685 }
686 else if (strendswith( source->name, "_i.c" ))
687 {
688 add_include( source, "rpc.h", 0, 1 );
689 add_include( source, "rpcndr.h", 0, 1 );
690 add_include( source, "guiddef.h", 0, 1 );
691 }
692 else if (strendswith( source->name, "_p.c" ))
693 {
694 add_include( source, "objbase.h", 0, 1 );
695 add_include( source, "rpcproxy.h", 0, 1 );
696 add_include( source, header, 0, 0 );
697 }
698 else if (strendswith( source->name, "_s.c" ))
699 {
700 add_include( source, header, 0, 0 );
701 }
702 else if (!strcmp( source->name, "dlldata.c" ))
703 {
704 add_include( source, "objbase.h", 0, 1 );
705 add_include( source, "rpcproxy.h", 0, 1 );
706 }
707
708 free( header );
709 free( basename );
710 }
711
712 /*******************************************************************
713 * parse_file
714 */
715 static void parse_file( INCL_FILE *pFile, int src )
716 {
717 FILE *file;
718
719 /* special case for source files generated from idl */
720 if (strendswith( pFile->name, "_c.c" ) ||
721 strendswith( pFile->name, "_i.c" ) ||
722 strendswith( pFile->name, "_p.c" ) ||
723 strendswith( pFile->name, "_s.c" ) ||
724 !strcmp( pFile->name, "dlldata.c" ))
725 {
726 parse_generated_idl( pFile );
727 return;
728 }
729
730 /* don't try to open .tlb files */
731 if (strendswith( pFile->name, ".tlb" ))
732 {
733 pFile->filename = xstrdup( pFile->name );
734 return;
735 }
736
737 file = src ? open_src_file( pFile ) : open_include_file( pFile );
738 if (!file) return;
739
740 if (pFile->sourcename && strendswith( pFile->sourcename, ".idl" ))
741 parse_idl_file( pFile, file, 1 );
742 else if (strendswith( pFile->filename, ".idl" ))
743 parse_idl_file( pFile, file, 0 );
744 else if (strendswith( pFile->filename, ".c" ) ||
745 strendswith( pFile->filename, ".h" ) ||
746 strendswith( pFile->filename, ".l" ) ||
747 strendswith( pFile->filename, ".y" ))
748 parse_c_file( pFile, file );
749 else if (strendswith( pFile->filename, ".rc" ))
750 parse_rc_file( pFile, file );
751 fclose(file);
752 }
753
754
755 /*******************************************************************
756 * add_src_file
757 *
758 * Add a source file to the list.
759 */
760 static INCL_FILE *add_src_file( const char *name )
761 {
762 INCL_FILE *file;
763
764 if (find_src_file( name )) return NULL; /* we already have it */
765 file = xmalloc( sizeof(*file) );
766 memset( file, 0, sizeof(*file) );
767 file->name = xstrdup(name);
768 list_add_tail( &sources, &file->entry );
769 parse_file( file, 1 );
770 return file;
771 }
772
773
774 /*******************************************************************
775 * output_include
776 */
777 static void output_include( FILE *file, INCL_FILE *pFile,
778 INCL_FILE *owner, int *column )
779 {
780 int i;
781
782 if (pFile->owner == owner) return;
783 if (!pFile->filename) return;
784 pFile->owner = owner;
785 if (*column + strlen(pFile->filename) + 1 > 70)
786 {
787 fprintf( file, " \\\n" );
788 *column = 0;
789 }
790 fprintf( file, " %s", pFile->filename );
791 *column += strlen(pFile->filename) + 1;
792 for (i = 0; i < MAX_INCLUDES; i++)
793 if (pFile->files[i]) output_include( file, pFile->files[i],
794 owner, column );
795 }
796
797
798 /*******************************************************************
799 * output_src
800 */
801 static int output_src( FILE *file, INCL_FILE *pFile, int *column )
802 {
803 char *obj = xstrdup( pFile->name );
804 char *ext = get_extension( obj );
805 if (ext)
806 {
807 *ext++ = 0;
808 if (!strcmp( ext, "y" )) /* yacc file */
809 {
810 *column += fprintf( file, "%s.tab.o: %s.tab.c", obj, obj );
811 }
812 else if (!strcmp( ext, "l" )) /* lex file */
813 {
814 *column += fprintf( file, "%s.yy.o: %s.yy.c", obj, obj );
815 }
816 else if (!strcmp( ext, "rc" )) /* resource file */
817 {
818 *column += fprintf( file, "%s.res: %s", obj, pFile->filename );
819 }
820 else if (!strcmp( ext, "mc" )) /* message file */
821 {
822 *column += fprintf( file, "%s.mc.rc: %s", obj, pFile->filename );
823 }
824 else if (!strcmp( ext, "idl" )) /* IDL file */
825 {
826 char *name;
827 int got_header = 0;
828 const char *suffix = "cips";
829
830 name = strmake( "%s.tlb", obj );
831 if (find_src_file( name )) *column += fprintf( file, "%s", name );
832 else
833 {
834 got_header = 1;
835 *column += fprintf( file, "%s.h", obj );
836 }
837 free( name );
838
839 while (*suffix)
840 {
841 name = strmake( "%s_%c.c", obj, *suffix );
842 if (find_src_file( name ))
843 {
844 if (!got_header++) *column += fprintf( file, " %s.h", obj );
845 *column += fprintf( file, " %s", name );
846 }
847 free( name );
848 suffix++;
849 }
850 *column += fprintf( file, ": %s", pFile->filename );
851 }
852 else if (!strcmp( ext, "tlb" ))
853 {
854 return 0; /* nothing to do for typelib files */
855 }
856 else
857 {
858 *column += fprintf( file, "%s.o: %s", obj, pFile->filename );
859 }
860 }
861 free( obj );
862 return 1;
863 }
864
865
866 /*******************************************************************
867 * output_dependencies
868 */
869 static void output_dependencies(void)
870 {
871 INCL_FILE *pFile;
872 int i, column;
873 FILE *file = NULL;
874 char *buffer;
875
876 if (Separator && ((file = fopen( OutputFileName, "r+" ))))
877 {
878 while ((buffer = get_line( file )))
879 {
880 if (strncmp( buffer, Separator, strlen(Separator) )) continue;
881 ftruncate( fileno(file), ftell(file) );
882 fseek( file, 0L, SEEK_END );
883 break;
884 }
885 }
886 if (!file)
887 {
888 if (!(file = fopen( OutputFileName, Separator ? "a" : "w" )))
889 {
890 perror( OutputFileName );
891 exit(1);
892 }
893 }
894 LIST_FOR_EACH_ENTRY( pFile, &sources, INCL_FILE, entry )
895 {
896 column = 0;
897 if (!output_src( file, pFile, &column )) continue;
898 for (i = 0; i < MAX_INCLUDES; i++)
899 if (pFile->files[i]) output_include( file, pFile->files[i],
900 pFile, &column );
901 fprintf( file, "\n" );
902 }
903 fclose(file);
904 }
905
906
907 /*******************************************************************
908 * parse_option
909 */
910 static void parse_option( const char *opt )
911 {
912 switch(opt[1])
913 {
914 case 'I':
915 if (opt[2]) add_include_path( opt + 2 );
916 break;
917 case 'C':
918 src_dir = opt + 2;
919 break;
920 case 'S':
921 top_src_dir = opt + 2;
922 break;
923 case 'T':
924 top_obj_dir = opt + 2;
925 break;
926 case 'f':
927 if (opt[2]) OutputFileName = opt + 2;
928 break;
929 case 's':
930 if (opt[2]) Separator = opt + 2;
931 else Separator = NULL;
932 break;
933 default:
934 fprintf( stderr, "Unknown option '%s'\n", opt );
935 fprintf( stderr, Usage, ProgramName );
936 exit(1);
937 }
938 }
939
940
941 /*******************************************************************
942 * main
943 */
944 int main( int argc, char *argv[] )
945 {
946 INCL_FILE *pFile;
947 INCL_PATH *path, *next;
948 int i, j;
949
950 ProgramName = argv[0];
951
952 i = 1;
953 while (i < argc)
954 {
955 if (argv[i][0] == '-')
956 {
957 parse_option( argv[i] );
958 for (j = i; j < argc; j++) argv[j] = argv[j+1];
959 argc--;
960 }
961 else i++;
962 }
963
964 /* ignore redundant source paths */
965 if (src_dir && !strcmp( src_dir, "." )) src_dir = NULL;
966 if (top_src_dir && top_obj_dir && !strcmp( top_src_dir, top_obj_dir )) top_src_dir = NULL;
967
968 /* get rid of absolute paths that don't point into the source dir */
969 LIST_FOR_EACH_ENTRY_SAFE( path, next, &paths, INCL_PATH, entry )
970 {
971 if (path->name[0] != '/') continue;
972 if (top_src_dir)
973 {
974 if (!strncmp( path->name, top_src_dir, strlen(top_src_dir) ) &&
975 path->name[strlen(top_src_dir)] == '/') continue;
976 }
977 list_remove( &path->entry );
978 free( path );
979 }
980
981 for (i = 1; i < argc; i++)
982 {
983 add_src_file( argv[i] );
984 if (strendswith( argv[i], "_p.c" )) add_src_file( "dlldata.c" );
985 }
986 LIST_FOR_EACH_ENTRY( pFile, &includes, INCL_FILE, entry ) parse_file( pFile, 0 );
987 output_dependencies();
988 return 0;
989 }
990
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.