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 }