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     "   -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, "wine/exception.h", 0, 1 );
 697         add_include( source, header, 0, 0 );
 698     }
 699     else if (strendswith( source->name, "_s.c" ))
 700     {
 701         add_include( source, "wine/exception.h", 0, 1 );
 702         add_include( source, header, 0, 0 );
 703     }
 704     else if (!strcmp( source->name, "dlldata.c" ))
 705     {
 706         add_include( source, "objbase.h", 0, 1 );
 707         add_include( source, "rpcproxy.h", 0, 1 );
 708     }
 709
 710     free( header );
 711     free( basename );
 712 }
 713
 714 /*******************************************************************
 715  *         parse_file
 716  */
 717 static void parse_file( INCL_FILE *pFile, int src )
 718 {
 719     FILE *file;
 720
 721     /* special case for source files generated from idl */
 722     if (strendswith( pFile->name, "_c.c" ) ||
 723         strendswith( pFile->name, "_i.c" ) ||
 724         strendswith( pFile->name, "_p.c" ) ||
 725         strendswith( pFile->name, "_s.c" ) ||
 726         !strcmp( pFile->name, "dlldata.c" ))
 727     {
 728         parse_generated_idl( pFile );
 729         return;
 730     }
 731
 732     /* don't try to open .tlb files */
 733     if (strendswith( pFile->name, ".tlb" ))
 734     {
 735         pFile->filename = xstrdup( pFile->name );
 736         return;
 737     }
 738
 739     file = src ? open_src_file( pFile ) : open_include_file( pFile );
 740     if (!file) return;
 741
 742     if (pFile->sourcename && strendswith( pFile->sourcename, ".idl" ))
 743         parse_idl_file( pFile, file, 1 );
 744     else if (strendswith( pFile->filename, ".idl" ))
 745         parse_idl_file( pFile, file, 0 );
 746     else if (strendswith( pFile->filename, ".c" ) ||
 747              strendswith( pFile->filename, ".h" ) ||
 748              strendswith( pFile->filename, ".l" ) ||
 749              strendswith( pFile->filename, ".y" ))
 750         parse_c_file( pFile, file );
 751     else if (strendswith( pFile->filename, ".rc" ))
 752         parse_rc_file( pFile, file );
 753     fclose(file);
 754 }
 755
 756
 757 /*******************************************************************
 758  *         add_src_file
 759  *
 760  * Add a source file to the list.
 761  */
 762 static INCL_FILE *add_src_file( const char *name )
 763 {
 764     INCL_FILE *file;
 765
 766     if (find_src_file( name )) return NULL;  /* we already have it */
 767     file = xmalloc( sizeof(*file) );
 768     memset( file, 0, sizeof(*file) );
 769     file->name = xstrdup(name);
 770     list_add_tail( &sources, &file->entry );
 771     parse_file( file, 1 );
 772     return file;
 773 }
 774
 775
 776 /*******************************************************************
 777  *         output_include
 778  */
 779 static void output_include( FILE *file, INCL_FILE *pFile,
 780                             INCL_FILE *owner, int *column )
 781 {
 782     int i;
 783
 784     if (pFile->owner == owner) return;
 785     if (!pFile->filename) return;
 786     pFile->owner = owner;
 787     if (*column + strlen(pFile->filename) + 1 > 70)
 788     {
 789         fprintf( file, " \\\n" );
 790         *column = 0;
 791     }
 792     fprintf( file, " %s", pFile->filename );
 793     *column += strlen(pFile->filename) + 1;
 794     for (i = 0; i < MAX_INCLUDES; i++)
 795         if (pFile->files[i]) output_include( file, pFile->files[i],
 796                                              owner, column );
 797 }
 798
 799
 800 /*******************************************************************
 801  *         output_src
 802  */
 803 static int output_src( FILE *file, INCL_FILE *pFile, int *column )
 804 {
 805     char *obj = xstrdup( pFile->name );
 806     char *ext = get_extension( obj );
 807     if (ext)
 808     {
 809         *ext++ = 0;
 810         if (!strcmp( ext, "y" ))  /* yacc file */
 811         {
 812             *column += fprintf( file, "%s.tab.o: %s.tab.c", obj, obj );
 813         }
 814         else if (!strcmp( ext, "l" ))  /* lex file */
 815         {
 816             *column += fprintf( file, "%s.yy.o: %s.yy.c", obj, obj );
 817         }
 818         else if (!strcmp( ext, "rc" ))  /* resource file */
 819         {
 820             *column += fprintf( file, "%s.res: %s", obj, pFile->filename );
 821         }
 822         else if (!strcmp( ext, "mc" ))  /* message file */
 823         {
 824             *column += fprintf( file, "%s.mc.rc: %s", obj, pFile->filename );
 825         }
 826         else if (!strcmp( ext, "idl" ))  /* IDL file */
 827         {
 828             char *name;
 829             int got_header = 0;
 830             const char *suffix = "cips";
 831
 832             name = strmake( "%s.tlb", obj );
 833             if (find_src_file( name )) *column += fprintf( file, "%s", name );
 834             else
 835             {
 836                 got_header = 1;
 837                 *column += fprintf( file, "%s.h", obj );
 838             }
 839             free( name );
 840
 841             while (*suffix)
 842             {
 843                 name = strmake( "%s_%c.c", obj, *suffix );
 844                 if (find_src_file( name ))
 845                 {
 846                     if (!got_header++) *column += fprintf( file, " %s.h", obj );
 847                     *column += fprintf( file, " %s", name );
 848                 }
 849                 free( name );
 850                 suffix++;
 851             }
 852             *column += fprintf( file, ": %s", pFile->filename );
 853         }
 854         else if (!strcmp( ext, "tlb" ))
 855         {
 856             return 0;  /* nothing to do for typelib files */
 857         }
 858         else
 859         {
 860             *column += fprintf( file, "%s.o: %s", obj, pFile->filename );
 861         }
 862     }
 863     free( obj );
 864     return 1;
 865 }
 866
 867
 868 /*******************************************************************
 869  *         output_dependencies
 870  */
 871 static void output_dependencies(void)
 872 {
 873     INCL_FILE *pFile;
 874     int i, column;
 875     FILE *file = NULL;
 876     char *buffer;
 877
 878     if (Separator && ((file = fopen( OutputFileName, "r+" ))))
 879     {
 880         while ((buffer = get_line( file )))
 881         {
 882             if (strncmp( buffer, Separator, strlen(Separator) )) continue;
 883             ftruncate( fileno(file), ftell(file) );
 884             fseek( file, 0L, SEEK_END );
 885             break;
 886         }
 887     }
 888     if (!file)
 889     {
 890         if (!(file = fopen( OutputFileName, Separator ? "a" : "w" )))
 891         {
 892             perror( OutputFileName );
 893             exit(1);
 894         }
 895     }
 896     LIST_FOR_EACH_ENTRY( pFile, &sources, INCL_FILE, entry )
 897     {
 898         column = 0;
 899         if (!output_src( file, pFile, &column )) continue;
 900         for (i = 0; i < MAX_INCLUDES; i++)
 901             if (pFile->files[i]) output_include( file, pFile->files[i],
 902                                                  pFile, &column );
 903         fprintf( file, "\n" );
 904     }
 905     fclose(file);
 906 }
 907
 908
 909 /*******************************************************************
 910  *         parse_option
 911  */
 912 static void parse_option( const char *opt )
 913 {
 914     switch(opt[1])
 915     {
 916     case 'I':
 917         if (opt[2]) add_include_path( opt + 2 );
 918         break;
 919     case 'C':
 920         src_dir = opt + 2;
 921         break;
 922     case 'S':
 923         top_src_dir = opt + 2;
 924         break;
 925     case 'T':
 926         top_obj_dir = opt + 2;
 927         break;
 928     case 'f':
 929         if (opt[2]) OutputFileName = opt + 2;
 930         break;
 931     case 's':
 932         if (opt[2]) Separator = opt + 2;
 933         else Separator = NULL;
 934         break;
 935     default:
 936         fprintf( stderr, "Unknown option '%s'\n", opt );
 937         fprintf( stderr, Usage, ProgramName );
 938         exit(1);
 939     }
 940 }
 941
 942
 943 /*******************************************************************
 944  *         main
 945  */
 946 int main( int argc, char *argv[] )
 947 {
 948     INCL_FILE *pFile;
 949     INCL_PATH *path, *next;
 950     int i, j;
 951
 952     ProgramName = argv[0];
 953
 954     i = 1;
 955     while (i < argc)
 956     {
 957         if (argv[i][0] == '-')
 958         {
 959             parse_option( argv[i] );
 960             for (j = i; j < argc; j++) argv[j] = argv[j+1];
 961             argc--;
 962         }
 963         else i++;
 964     }
 965
 966     /* ignore redundant source paths */
 967     if (src_dir && !strcmp( src_dir, "." )) src_dir = NULL;
 968     if (top_src_dir && top_obj_dir && !strcmp( top_src_dir, top_obj_dir )) top_src_dir = NULL;
 969
 970     /* get rid of absolute paths that don't point into the source dir */
 971     LIST_FOR_EACH_ENTRY_SAFE( path, next, &paths, INCL_PATH, entry )
 972     {
 973         if (path->name[0] != '/') continue;
 974         if (top_src_dir)
 975         {
 976             if (!strncmp( path->name, top_src_dir, strlen(top_src_dir) ) &&
 977                 path->name[strlen(top_src_dir)] == '/') continue;
 978         }
 979         list_remove( &path->entry );
 980         free( path );
 981     }
 982
 983     for (i = 1; i < argc; i++)
 984     {
 985         add_src_file( argv[i] );
 986         if (strendswith( argv[i], "_p.c" )) add_src_file( "dlldata.c" );
 987     }
 988     LIST_FOR_EACH_ENTRY( pFile, &includes, INCL_FILE, entry ) parse_file( pFile, 0 );
 989     output_dependencies();
 990     return 0;
 991 }