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