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 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     unsigned int       flags;         /* flags (see below) */
  49     struct incl_file  *owner;
  50     struct incl_file  *files[MAX_INCLUDES];
  51 };
  52
  53 #define FLAG_SYSTEM       0x0001  /* is it a system include (#include <name>) */
  54 #define FLAG_IDL_PROXY    0x0002  /* generates a proxy (_p.c) file */
  55 #define FLAG_IDL_CLIENT   0x0004  /* generates a client (_c.c) file */
  56 #define FLAG_IDL_SERVER   0x0008  /* generates a server (_s.c) file */
  57 #define FLAG_IDL_IDENT    0x0010  /* generates an ident (_i.c) file */
  58 #define FLAG_IDL_REGISTER 0x0020  /* generates a registration (_r.res) file */
  59 #define FLAG_IDL_TYPELIB  0x0040  /* generates a typelib (.tlb) file */
  60 #define FLAG_IDL_HEADER   0x0080  /* generates a header (.h) file */
  61 #define FLAG_RC_PO        0x0100  /* rc file contains translations */
  62
  63 static const struct
  64 {
  65     unsigned int flag;
  66     const char *ext;
  67     const char *widl_arg;
  68 } idl_outputs[] =
  69 {
  70     { FLAG_IDL_TYPELIB,  ".tlb",   "$(TARGETFLAGS) $(IDLFLAGS) -t" },
  71     { FLAG_IDL_TYPELIB,  "_t.res", "$(TARGETFLAGS) $(IDLFLAGS) -t" },
  72     { FLAG_IDL_CLIENT,   "_c.c",   "$(IDLFLAGS) -c" },
  73     { FLAG_IDL_IDENT,    "_i.c",   "$(IDLFLAGS) -u" },
  74     { FLAG_IDL_PROXY,    "_p.c",   "$(IDLFLAGS) -p" },
  75     { FLAG_IDL_SERVER,   "_s.c",   "$(IDLFLAGS) -s" },
  76     { FLAG_IDL_REGISTER, "_r.res", "$(IDLFLAGS) -r" },
  77     { FLAG_IDL_HEADER,   ".h",     "$(IDLFLAGS) -h" },
  78 };
  79
  80 static struct list sources = LIST_INIT(sources);
  81 static struct list includes = LIST_INIT(includes);
  82
  83 struct object_extension
  84 {
  85     struct list entry;
  86     const char *extension;
  87 };
  88
  89 static struct list object_extensions = LIST_INIT(object_extensions);
  90
  91 struct incl_path
  92 {
  93     struct list entry;
  94     const char *name;
  95 };
  96
  97 static struct list paths = LIST_INIT(paths);
  98
  99 static const char *src_dir;
 100 static const char *top_src_dir;
 101 static const char *top_obj_dir;
 102 static const char *OutputFileName = "Makefile";
 103 static const char *Separator = "### Dependencies";
 104 static const char *input_file_name;
 105 static int input_line;
 106 static FILE *output_file;
 107
 108 static const char Usage[] =
 109     "Usage: makedep [options] [files]\n"
 110     "Options:\n"
 111     "   -Idir   Search for include files in directory 'dir'\n"
 112     "   -Cdir   Search for source files in directory 'dir'\n"
 113     "   -Sdir   Set the top source directory\n"
 114     "   -Tdir   Set the top object directory\n"
 115     "   -fxxx   Store output in file 'xxx' (default: Makefile)\n"
 116     "   -sxxx   Use 'xxx' as separator (default: \"### Dependencies\")\n";
 117
 118
 119 #ifndef __GNUC__
 120 #define __attribute__(x)
 121 #endif
 122
 123 static void fatal_error( const char *msg, ... ) __attribute__ ((__format__ (__printf__, 1, 2)));
 124 static void fatal_perror( const char *msg, ... ) __attribute__ ((__format__ (__printf__, 1, 2)));
 125 static int output( const char *format, ... ) __attribute__ ((__format__ (__printf__, 1, 2)));
 126 static char *strmake( const char* fmt, ... ) __attribute__ ((__format__ (__printf__, 1, 2)));
 127
 128 /*******************************************************************
 129  *         fatal_error
 130  */
 131 static void fatal_error( const char *msg, ... )
 132 {
 133     va_list valist;
 134     va_start( valist, msg );
 135     if (input_file_name)
 136     {
 137         fprintf( stderr, "%s:", input_file_name );
 138         if (input_line) fprintf( stderr, "%d:", input_line );
 139         fprintf( stderr, " error: " );
 140     }
 141     else fprintf( stderr, "makedep: error: " );
 142     vfprintf( stderr, msg, valist );
 143     va_end( valist );
 144     exit(1);
 145 }
 146
 147
 148 /*******************************************************************
 149  *         fatal_perror
 150  */
 151 static void fatal_perror( const char *msg, ... )
 152 {
 153     va_list valist;
 154     va_start( valist, msg );
 155     if (input_file_name)
 156     {
 157         fprintf( stderr, "%s:", input_file_name );
 158         if (input_line) fprintf( stderr, "%d:", input_line );
 159         fprintf( stderr, " error: " );
 160     }
 161     else fprintf( stderr, "makedep: error: " );
 162     vfprintf( stderr, msg, valist );
 163     perror( " " );
 164     va_end( valist );
 165     exit(1);
 166 }
 167
 168
 169 /*******************************************************************
 170  *         xmalloc
 171  */
 172 static void *xmalloc( size_t size )
 173 {
 174     void *res;
 175     if (!(res = malloc (size ? size : 1)))
 176         fatal_error( "Virtual memory exhausted.\n" );
 177     return res;
 178 }
 179
 180
 181 /*******************************************************************
 182  *         xrealloc
 183  */
 184 static void *xrealloc (void *ptr, size_t size)
 185 {
 186     void *res;
 187     assert( size );
 188     if (!(res = realloc( ptr, size )))
 189         fatal_error( "Virtual memory exhausted.\n" );
 190     return res;
 191 }
 192
 193 /*******************************************************************
 194  *         xstrdup
 195  */
 196 static char *xstrdup( const char *str )
 197 {
 198     char *res = strdup( str );
 199     if (!res) fatal_error( "Virtual memory exhausted.\n" );
 200     return res;
 201 }
 202
 203
 204 /*******************************************************************
 205  *         strmake
 206  */
 207 static char *strmake( const char* fmt, ... )
 208 {
 209     int n;
 210     size_t size = 100;
 211     va_list ap;
 212
 213     for (;;)
 214     {
 215         char *p = xmalloc (size);
 216         va_start(ap, fmt);
 217         n = vsnprintf (p, size, fmt, ap);
 218         va_end(ap);
 219         if (n == -1) size *= 2;
 220         else if ((size_t)n >= size) size = n + 1;
 221         else return p;
 222         free(p);
 223     }
 224 }
 225
 226
 227 /*******************************************************************
 228  *         strendswith
 229  */
 230 static int strendswith( const char* str, const char* end )
 231 {
 232     int l = strlen(str);
 233     int m = strlen(end);
 234
 235     return l >= m && strcmp(str + l - m, end) == 0;
 236 }
 237
 238
 239 /*******************************************************************
 240  *         output
 241  */
 242 static int output( const char *format, ... )
 243 {
 244     int ret;
 245     va_list valist;
 246
 247     va_start( valist, format );
 248     ret = vfprintf( output_file, format, valist );
 249     va_end( valist );
 250     if (ret < 0) fatal_perror( "output" );
 251     return ret;
 252 }
 253
 254
 255 /*******************************************************************
 256  *         output_filename
 257  */
 258 static void output_filename( const char *name, int *column )
 259 {
 260     if (*column + strlen(name) + 1 > 100)
 261     {
 262         output( " \\\n" );
 263         *column = 0;
 264     }
 265     *column += output( " %s", name );
 266 }
 267
 268
 269 /*******************************************************************
 270  *         get_extension
 271  */
 272 static char *get_extension( char *filename )
 273 {
 274     char *ext = strrchr( filename, '.' );
 275     if (ext && strchr( ext, '/' )) ext = NULL;
 276     return ext;
 277 }
 278
 279
 280 /*******************************************************************
 281  *         replace_extension
 282  */
 283 static char *replace_extension( const char *name, unsigned int old_len, const char *new_ext )
 284 {
 285     char *ret = xmalloc( strlen( name ) + strlen( new_ext ) + 1 );
 286     strcpy( ret, name );
 287     strcpy( ret + strlen( ret ) - old_len, new_ext );
 288     return ret;
 289 }
 290
 291
 292 /*******************************************************************
 293  *         get_line
 294  */
 295 static char *get_line( FILE *file )
 296 {
 297     static char *buffer;
 298     static unsigned int size;
 299
 300     if (!size)
 301     {
 302         size = 1024;
 303         buffer = xmalloc( size );
 304     }
 305     if (!fgets( buffer, size, file )) return NULL;
 306     input_line++;
 307
 308     for (;;)
 309     {
 310         char *p = buffer + strlen(buffer);
 311         /* if line is larger than buffer, resize buffer */
 312         while (p == buffer + size - 1 && p[-1] != '\n')
 313         {
 314             buffer = xrealloc( buffer, size * 2 );
 315             if (!fgets( buffer + size - 1, size + 1, file )) break;
 316             p = buffer + strlen(buffer);
 317             size *= 2;
 318         }
 319         if (p > buffer && p[-1] == '\n')
 320         {
 321             *(--p) = 0;
 322             if (p > buffer && p[-1] == '\r') *(--p) = 0;
 323             if (p > buffer && p[-1] == '\\')
 324             {
 325                 *(--p) = 0;
 326                 /* line ends in backslash, read continuation line */
 327                 if (!fgets( p, size - (p - buffer), file )) return buffer;
 328                 input_line++;
 329                 continue;
 330             }
 331         }
 332         return buffer;
 333     }
 334 }
 335
 336 /*******************************************************************
 337  *         add_object_extension
 338  *
 339  * Add an extension for object files.
 340  */
 341 static void add_object_extension( const char *ext )
 342 {
 343     struct object_extension *object_extension = xmalloc( sizeof(*object_extension) );
 344     list_add_tail( &object_extensions, &object_extension->entry );
 345     object_extension->extension = ext;
 346 }
 347
 348 /*******************************************************************
 349  *         add_include_path
 350  *
 351  * Add a directory to the include path.
 352  */
 353 static void add_include_path( const char *name )
 354 {
 355     struct incl_path *path = xmalloc( sizeof(*path) );
 356     list_add_tail( &paths, &path->entry );
 357     path->name = name;
 358 }
 359
 360 /*******************************************************************
 361  *         find_src_file
 362  */
 363 static struct incl_file *find_src_file( const char *name )
 364 {
 365     struct incl_file *file;
 366
 367     LIST_FOR_EACH_ENTRY( file, &sources, struct incl_file, entry )
 368         if (!strcmp( name, file->name )) return file;
 369     return NULL;
 370 }
 371
 372 /*******************************************************************
 373  *         find_include_file
 374  */
 375 static struct incl_file *find_include_file( const char *name )
 376 {
 377     struct incl_file *file;
 378
 379     LIST_FOR_EACH_ENTRY( file, &includes, struct incl_file, entry )
 380         if (!strcmp( name, file->name )) return file;
 381     return NULL;
 382 }
 383
 384 /*******************************************************************
 385  *         add_include
 386  *
 387  * Add an include file if it doesn't already exists.
 388  */
 389 static struct incl_file *add_include( struct incl_file *pFile, const char *name, int system )
 390 {
 391     struct incl_file *include;
 392     char *ext;
 393     int pos;
 394
 395     for (pos = 0; pos < MAX_INCLUDES; pos++) if (!pFile->files[pos]) break;
 396     if (pos >= MAX_INCLUDES)
 397         fatal_error( "too many included files, please fix MAX_INCLUDES\n" );
 398
 399     /* enforce some rules for the Wine tree */
 400
 401     if (!memcmp( name, "../", 3 ))
 402         fatal_error( "#include directive with relative path not allowed\n" );
 403
 404     if (!strcmp( name, "config.h" ))
 405     {
 406         if ((ext = strrchr( pFile->filename, '.' )) && !strcmp( ext, ".h" ))
 407             fatal_error( "config.h must not be included by a header file\n" );
 408         if (pos)
 409             fatal_error( "config.h must be included before anything else\n" );
 410     }
 411     else if (!strcmp( name, "wine/port.h" ))
 412     {
 413         if ((ext = strrchr( pFile->filename, '.' )) && !strcmp( ext, ".h" ))
 414             fatal_error( "wine/port.h must not be included by a header file\n" );
 415         if (!pos) fatal_error( "config.h must be included before wine/port.h\n" );
 416         if (pos > 1)
 417             fatal_error( "wine/port.h must be included before everything except config.h\n" );
 418         if (strcmp( pFile->files[0]->name, "config.h" ))
 419             fatal_error( "config.h must be included before wine/port.h\n" );
 420     }
 421
 422     LIST_FOR_EACH_ENTRY( include, &includes, struct incl_file, entry )
 423         if (!strcmp( name, include->name )) goto found;
 424
 425     include = xmalloc( sizeof(*include) );
 426     memset( include, 0, sizeof(*include) );
 427     include->name = xstrdup(name);
 428     include->included_by = pFile;
 429     include->included_line = input_line;
 430     if (system) include->flags |= FLAG_SYSTEM;
 431     list_add_tail( &includes, &include->entry );
 432 found:
 433     pFile->files[pos] = include;
 434     return include;
 435 }
 436
 437
 438 /*******************************************************************
 439  *         open_src_file
 440  */
 441 static FILE *open_src_file( struct incl_file *pFile )
 442 {
 443     FILE *file;
 444
 445     /* first try name as is */
 446     if ((file = fopen( pFile->name, "r" )))
 447     {
 448         pFile->filename = xstrdup( pFile->name );
 449         return file;
 450     }
 451     /* now try in source dir */
 452     if (src_dir)
 453     {
 454         pFile->filename = strmake( "%s/%s", src_dir, pFile->name );
 455         file = fopen( pFile->filename, "r" );
 456     }
 457     if (!file) fatal_perror( "open %s", pFile->name );
 458     return file;
 459 }
 460
 461
 462 /*******************************************************************
 463  *         open_include_file
 464  */
 465 static FILE *open_include_file( struct incl_file *pFile )
 466 {
 467     FILE *file = NULL;
 468     char *filename, *p;
 469     struct incl_path *path;
 470
 471     errno = ENOENT;
 472
 473     /* check for generated bison header */
 474
 475     if (strendswith( pFile->name, ".tab.h" ))
 476     {
 477         filename = replace_extension( pFile->name, 6, ".y" );
 478         if (src_dir) filename = strmake( "%s/%s", src_dir, filename );
 479
 480         if ((file = fopen( filename, "r" )))
 481         {
 482             pFile->sourcename = filename;
 483             pFile->filename = xstrdup( pFile->name );
 484             /* don't bother to parse it */
 485             fclose( file );
 486             return NULL;
 487         }
 488         free( filename );
 489     }
 490
 491     /* check for corresponding idl file in source dir */
 492
 493     if (strendswith( pFile->name, ".h" ))
 494     {
 495         filename = replace_extension( pFile->name, 2, ".idl" );
 496         if (src_dir) filename = strmake( "%s/%s", src_dir, filename );
 497
 498         if ((file = fopen( filename, "r" )))
 499         {
 500             pFile->sourcename = filename;
 501             pFile->filename = xstrdup( pFile->name );
 502             return file;
 503         }
 504         free( filename );
 505     }
 506
 507     /* first try name as is */
 508     if ((file = fopen( pFile->name, "r" )))
 509     {
 510         pFile->filename = xstrdup( pFile->name );
 511         return file;
 512     }
 513
 514     /* now try in source dir */
 515     if (src_dir)
 516     {
 517         filename = strmake( "%s/%s", src_dir, pFile->name );
 518         if ((file = fopen( filename, "r" ))) goto found;
 519         free( filename );
 520     }
 521
 522     /* check for corresponding idl file in global includes */
 523
 524     if (strendswith( pFile->name, ".h" ))
 525     {
 526         filename = replace_extension( pFile->name, 2, ".idl" );
 527         if (top_src_dir)
 528             filename = strmake( "%s/include/%s", top_src_dir, filename );
 529         else if (top_obj_dir)
 530             filename = strmake( "%s/include/%s", top_obj_dir, filename );
 531         else
 532             filename = NULL;
 533
 534         if (filename && (file = fopen( filename, "r" )))
 535         {
 536             pFile->sourcename = filename;
 537             pFile->filename = strmake( "%s/include/%s", top_obj_dir, pFile->name );
 538             return file;
 539         }
 540         free( filename );
 541     }
 542
 543     /* check for corresponding .x file in global includes */
 544
 545     if (strendswith( pFile->name, "tmpl.h" ))
 546     {
 547         filename = replace_extension( pFile->name, 2, ".x" );
 548         if (top_src_dir)
 549             filename = strmake( "%s/include/%s", top_src_dir, filename );
 550         else if (top_obj_dir)
 551             filename = strmake( "%s/include/%s", top_obj_dir, filename );
 552         else
 553             filename = NULL;
 554
 555         if (filename && (file = fopen( filename, "r" )))
 556         {
 557             pFile->sourcename = filename;
 558             pFile->filename = strmake( "%s/include/%s", top_obj_dir, pFile->name );
 559             return file;
 560         }
 561         free( filename );
 562     }
 563
 564     /* now try in global includes */
 565     if (top_obj_dir)
 566     {
 567         filename = strmake( "%s/include/%s", top_obj_dir, pFile->name );
 568         if ((file = fopen( filename, "r" ))) goto found;
 569         free( filename );
 570     }
 571     if (top_src_dir)
 572     {
 573         filename = strmake( "%s/include/%s", top_src_dir, pFile->name );
 574         if ((file = fopen( filename, "r" ))) goto found;
 575         free( filename );
 576     }
 577
 578     /* now search in include paths */
 579     LIST_FOR_EACH_ENTRY( path, &paths, struct incl_path, entry )
 580     {
 581         filename = strmake( "%s/%s", path->name, pFile->name );
 582         if ((file = fopen( filename, "r" ))) goto found;
 583         free( filename );
 584     }
 585     if (pFile->flags & FLAG_SYSTEM) return NULL;  /* ignore system files we cannot find */
 586
 587     /* try in src file directory */
 588     if ((p = strrchr(pFile->included_by->filename, '/')))
 589     {
 590         int l = p - pFile->included_by->filename + 1;
 591         filename = xmalloc(l + strlen(pFile->name) + 1);
 592         memcpy( filename, pFile->included_by->filename, l );
 593         strcpy( filename + l, pFile->name );
 594         if ((file = fopen( filename, "r" ))) goto found;
 595         free( filename );
 596     }
 597
 598     fprintf( stderr, "%s:%d: error: ", pFile->included_by->filename, pFile->included_line );
 599     perror( pFile->name );
 600     pFile = pFile->included_by;
 601     while (pFile && pFile->included_by)
 602     {
 603         const char *parent = pFile->included_by->sourcename;
 604         if (!parent) parent = pFile->included_by->name;
 605         fprintf( stderr, "%s:%d: note: %s was first included here\n",
 606                  parent, pFile->included_line, pFile->name );
 607         pFile = pFile->included_by;
 608     }
 609     exit(1);
 610
 611 found:
 612     pFile->filename = filename;
 613     return file;
 614 }
 615
 616
 617 /*******************************************************************
 618  *         parse_idl_file
 619  *
 620  * If for_h_file is non-zero, it means we are not interested in the idl file
 621  * itself, but only in the contents of the .h file that will be generated from it.
 622  */
 623 static void parse_idl_file( struct incl_file *pFile, FILE *file, int for_h_file )
 624 {
 625     char *buffer, *include;
 626
 627     input_line = 0;
 628     if (for_h_file)
 629     {
 630         /* generated .h file always includes these */
 631         add_include( pFile, "rpc.h", 1 );
 632         add_include( pFile, "rpcndr.h", 1 );
 633     }
 634
 635     while ((buffer = get_line( file )))
 636     {
 637         char quote;
 638         char *p = buffer;
 639         while (*p && isspace(*p)) p++;
 640
 641         if (!strncmp( p, "import", 6 ))
 642         {
 643             p += 6;
 644             while (*p && isspace(*p)) p++;
 645             if (*p != '"') continue;
 646             include = ++p;
 647             while (*p && (*p != '"')) p++;
 648             if (!*p) fatal_error( "malformed import directive\n" );
 649             *p = 0;
 650             if (for_h_file && strendswith( include, ".idl" )) strcpy( p - 4, ".h" );
 651             add_include( pFile, include, 0 );
 652             continue;
 653         }
 654
 655         if (for_h_file)  /* only check for #include inside cpp_quote */
 656         {
 657             if (strncmp( p, "cpp_quote", 9 )) continue;
 658             p += 9;
 659             while (*p && isspace(*p)) p++;
 660             if (*p++ != '(') continue;
 661             while (*p && isspace(*p)) p++;
 662             if (*p++ != '"') continue;
 663             if (*p++ != '#') continue;
 664             while (*p && isspace(*p)) p++;
 665             if (strncmp( p, "include", 7 )) continue;
 666             p += 7;
 667             while (*p && isspace(*p)) p++;
 668             if (*p == '\\' && p[1] == '"')
 669             {
 670                 p += 2;
 671                 quote = '"';
 672             }
 673             else
 674             {
 675                 if (*p++ != '<' ) continue;
 676                 quote = '>';
 677             }
 678             include = p;
 679             while (*p && (*p != quote)) p++;
 680             if (!*p || (quote == '"' && p[-1] != '\\'))
 681                 fatal_error( "malformed #include directive inside cpp_quote\n" );
 682             if (quote == '"') p--;  /* remove backslash */
 683             *p = 0;
 684             add_include( pFile, include, (quote == '>') );
 685             continue;
 686         }
 687
 688         /* check for normal #include */
 689         if (*p++ != '#') continue;
 690         while (*p && isspace(*p)) p++;
 691         if (strncmp( p, "include", 7 )) continue;
 692         p += 7;
 693         while (*p && isspace(*p)) p++;
 694         if (*p != '\"' && *p != '<' ) continue;
 695         quote = *p++;
 696         if (quote == '<') quote = '>';
 697         include = p;
 698         while (*p && (*p != quote)) p++;
 699         if (!*p) fatal_error( "malformed #include directive\n" );
 700         *p = 0;
 701         add_include( pFile, include, (quote == '>') );
 702     }
 703 }
 704
 705 /*******************************************************************
 706  *         parse_c_file
 707  */
 708 static void parse_c_file( struct incl_file *pFile, FILE *file )
 709 {
 710     char *buffer, *include;
 711
 712     input_line = 0;
 713     while ((buffer = get_line( file )))
 714     {
 715         char quote;
 716         char *p = buffer;
 717         while (*p && isspace(*p)) p++;
 718         if (*p++ != '#') continue;
 719         while (*p && isspace(*p)) p++;
 720         if (!strncmp( p, "include", 7 )) p += 7;
 721         else if (!strncmp( p, "import", 6 )) p += 6;
 722         else continue;
 723         while (*p && isspace(*p)) p++;
 724         if (*p != '\"' && *p != '<' ) continue;
 725         quote = *p++;
 726         if (quote == '<') quote = '>';
 727         include = p;
 728         while (*p && (*p != quote)) p++;
 729         if (!*p) fatal_error( "malformed #include directive\n" );
 730         *p = 0;
 731         add_include( pFile, include, (quote == '>') );
 732     }
 733 }
 734
 735
 736 /*******************************************************************
 737  *         parse_rc_file
 738  */
 739 static void parse_rc_file( struct incl_file *pFile, FILE *file )
 740 {
 741     char *buffer, *include;
 742
 743     input_line = 0;
 744     while ((buffer = get_line( file )))
 745     {
 746         char quote;
 747         char *p = buffer;
 748         while (*p && isspace(*p)) p++;
 749
 750         if (p[0] == '/' && p[1] == '*')  /* check for magic makedep comment */
 751         {
 752             p += 2;
 753             while (*p && isspace(*p)) p++;
 754             if (strncmp( p, "@makedep:", 9 )) continue;
 755             p += 9;
 756             while (*p && isspace(*p)) p++;
 757             quote = '"';
 758             if (*p == quote)
 759             {
 760                 include = ++p;
 761                 while (*p && *p != quote) p++;
 762             }
 763             else
 764             {
 765                 include = p;
 766                 while (*p && !isspace(*p) && *p != '*') p++;
 767             }
 768             if (!*p)
 769                 fatal_error( "malformed makedep comment\n" );
 770             *p = 0;
 771         }
 772         else  /* check for #include */
 773         {
 774             if (*p++ != '#') continue;
 775             while (*p && isspace(*p)) p++;
 776             if (strncmp( p, "include", 7 )) continue;
 777             p += 7;
 778             while (*p && isspace(*p)) p++;
 779             if (*p != '\"' && *p != '<' ) continue;
 780             quote = *p++;
 781             if (quote == '<') quote = '>';
 782             include = p;
 783             while (*p && (*p != quote)) p++;
 784             if (!*p) fatal_error( "malformed #include directive\n" );
 785             *p = 0;
 786         }
 787         add_include( pFile, include, (quote == '>') );
 788     }
 789 }
 790
 791
 792 /*******************************************************************
 793  *         parse_generated_idl
 794  */
 795 static void parse_generated_idl( struct incl_file *source )
 796 {
 797     char *header = replace_extension( source->name, 4, ".h" );
 798
 799     source->filename = xstrdup( source->name );
 800
 801     if (strendswith( source->name, "_c.c" ))
 802     {
 803         add_include( source, header, 0 );
 804     }
 805     else if (strendswith( source->name, "_i.c" ))
 806     {
 807         add_include( source, "rpc.h", 1 );
 808         add_include( source, "rpcndr.h", 1 );
 809         add_include( source, "guiddef.h", 1 );
 810     }
 811     else if (strendswith( source->name, "_p.c" ))
 812     {
 813         add_include( source, "objbase.h", 1 );
 814         add_include( source, "rpcproxy.h", 1 );
 815         add_include( source, "wine/exception.h", 1 );
 816         add_include( source, header, 0 );
 817     }
 818     else if (strendswith( source->name, "_s.c" ))
 819     {
 820         add_include( source, "wine/exception.h", 1 );
 821         add_include( source, header, 0 );
 822     }
 823
 824     free( header );
 825 }
 826
 827 /*******************************************************************
 828  *         is_generated_idl
 829  */
 830 static int is_generated_idl( struct incl_file *source )
 831 {
 832     return (strendswith( source->name, "_c.c" ) ||
 833             strendswith( source->name, "_i.c" ) ||
 834             strendswith( source->name, "_p.c" ) ||
 835             strendswith( source->name, "_s.c" ));
 836 }
 837
 838 /*******************************************************************
 839  *         parse_file
 840  */
 841 static void parse_file( struct incl_file *source, int src )
 842 {
 843     FILE *file;
 844
 845     /* don't try to open certain types of files */
 846     if (strendswith( source->name, ".tlb" ) ||
 847         strendswith( source->name, ".x" ))
 848     {
 849         source->filename = xstrdup( source->name );
 850         return;
 851     }
 852
 853     file = src ? open_src_file( source ) : open_include_file( source );
 854     if (!file) return;
 855     input_file_name = source->filename;
 856
 857     if (source->sourcename && strendswith( source->sourcename, ".idl" ))
 858         parse_idl_file( source, file, 1 );
 859     else if (strendswith( source->filename, ".idl" ))
 860         parse_idl_file( source, file, 0 );
 861     else if (strendswith( source->filename, ".c" ) ||
 862              strendswith( source->filename, ".m" ) ||
 863              strendswith( source->filename, ".h" ) ||
 864              strendswith( source->filename, ".l" ) ||
 865              strendswith( source->filename, ".y" ))
 866         parse_c_file( source, file );
 867     else if (strendswith( source->filename, ".rc" ))
 868         parse_rc_file( source, file );
 869     fclose(file);
 870     input_file_name = NULL;
 871 }
 872
 873
 874 /*******************************************************************
 875  *         add_src_file
 876  *
 877  * Add a source file to the list.
 878  */
 879 static struct incl_file *add_src_file( const char *name )
 880 {
 881     struct incl_file *file;
 882
 883     if ((file = find_src_file( name ))) return file;  /* we already have it */
 884     file = xmalloc( sizeof(*file) );
 885     memset( file, 0, sizeof(*file) );
 886     file->name = xstrdup(name);
 887     list_add_tail( &sources, &file->entry );
 888
 889     /* special cases for generated files */
 890
 891     if (is_generated_idl( file ))
 892     {
 893         parse_generated_idl( file );
 894         return file;
 895     }
 896
 897     if (!strcmp( file->name, "dlldata.o" ))
 898     {
 899         file->filename = xstrdup( "dlldata.c" );
 900         add_include( file, "objbase.h", 1 );
 901         add_include( file, "rpcproxy.h", 1 );
 902         return file;
 903     }
 904
 905     if (!strcmp( file->name, "testlist.o" ))
 906     {
 907         file->filename = xstrdup( "testlist.c" );
 908         add_include( file, "wine/test.h", 1 );
 909         return file;
 910     }
 911
 912     if (strendswith( file->name, ".o" ))
 913     {
 914         /* default to .c for unknown extra object files */
 915         file->filename = replace_extension( file->name, 2, ".c" );
 916         return file;
 917     }
 918
 919     if (strendswith( file->name, ".tlb" ) ||
 920         strendswith( file->name, "_r.res" ) ||
 921         strendswith( file->name, "_t.res" ))
 922     {
 923         file->filename = xstrdup( file->name );
 924         return file;
 925     }
 926
 927     if (strendswith( file->name, ".res" ) ||
 928         strendswith( file->name, ".pot" ) ||
 929         strendswith( file->name, ".x" ))
 930     {
 931         file->filename = xstrdup( file->name );
 932         return file;
 933     }
 934
 935     parse_file( file, 1 );
 936     return file;
 937 }
 938
 939
 940 /*******************************************************************
 941  *         add_generated_sources
 942  */
 943 static void add_generated_sources(void)
 944 {
 945     struct incl_file *source, *next;
 946
 947     LIST_FOR_EACH_ENTRY_SAFE( source, next, &sources, struct incl_file, entry )
 948     {
 949         if (strendswith( source->name, "_c.c" ) ||
 950             strendswith( source->name, "_i.c" ) ||
 951             strendswith( source->name, "_p.c" ) ||
 952             strendswith( source->name, "_s.c" ) ||
 953             strendswith( source->name, ".tlb" ))
 954         {
 955             char *idl = replace_extension( source->name, 4, ".idl" );
 956             struct incl_file *file = add_src_file( idl );
 957             if (strendswith( source->name, "_c.c" )) file->flags |= FLAG_IDL_CLIENT;
 958             else if (strendswith( source->name, "_i.c" )) file->flags |= FLAG_IDL_IDENT;
 959             else if (strendswith( source->name, "_p.c" )) file->flags |= FLAG_IDL_PROXY;
 960             else if (strendswith( source->name, "_s.c" )) file->flags |= FLAG_IDL_SERVER;
 961             else if (strendswith( source->name, ".tlb" )) file->flags |= FLAG_IDL_TYPELIB;
 962             continue;
 963         }
 964         if (strendswith( source->name, "_r.res" ) ||
 965             strendswith( source->name, "_t.res" ))
 966         {
 967             char *idl = replace_extension( source->name, 6, ".idl" );
 968             struct incl_file *file = add_src_file( idl );
 969             if (strendswith( source->name, "_r.res" )) file->flags |= FLAG_IDL_REGISTER;
 970             else if (strendswith( source->name, "_t.res" )) file->flags |= FLAG_IDL_TYPELIB;
 971             continue;
 972         }
 973         if (strendswith( source->name, ".pot" ))
 974         {
 975             char *rc = replace_extension( source->name, 4, ".rc" );
 976             struct incl_file *file = add_src_file( rc );
 977             file->flags |= FLAG_RC_PO;
 978         }
 979     }
 980 }
 981
 982
 983 /*******************************************************************
 984  *         output_include
 985  */
 986 static void output_include( struct incl_file *pFile, struct incl_file *owner, int *column )
 987 {
 988     int i;
 989
 990     if (pFile->owner == owner) return;
 991     if (!pFile->filename) return;
 992     pFile->owner = owner;
 993     output_filename( pFile->filename, column );
 994     for (i = 0; i < MAX_INCLUDES; i++)
 995         if (pFile->files[i]) output_include( pFile->files[i], owner, column );
 996 }
 997
 998
 999 /*******************************************************************
1000  *         output_sources
1001  */
1002 static void output_sources(void)
1003 {
1004     struct incl_file *source;
1005     int i, column, po_srcs = 0, mc_srcs = 0;
1006
1007     LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1008     {
1009         char *obj = xstrdup( source->name );
1010         char *ext = get_extension( obj );
1011
1012         if (!ext) fatal_error( "unsupported file type %s\n", source->name );
1013         *ext++ = 0;
1014         column = 0;
1015
1016         if (!strcmp( ext, "y" ))  /* yacc file */
1017         {
1018             /* add source file dependency for parallel makes */
1019             char *header = strmake( "%s.tab.h", obj );
1020             if (find_include_file( header ))
1021             {
1022                 output( "%s.tab.h: %s\n", obj, source->filename );
1023                 output( "\t$(BISON) $(BISONFLAGS) -p %s_ -o %s.tab.c -d %s\n",
1024                         obj, obj, source->filename );
1025                 output( "%s.tab.c: %s %s\n", obj, source->filename, header );
1026             }
1027             else output( "%s.tab.c: %s\n", obj, source->filename );
1028
1029             output( "\t$(BISON) $(BISONFLAGS) -p %s_ -o $@ %s\n", obj, source->filename );
1030             output( "%s.tab.o: %s.tab.c\n", obj, obj );
1031             output( "\t$(CC) -c $(ALLCFLAGS) -o $@ %s.tab.c\n", obj );
1032             column += output( "%s.tab.o:", obj );
1033             free( header );
1034         }
1035         else if (!strcmp( ext, "l" ))  /* lex file */
1036         {
1037             output( "%s.yy.c: %s\n", obj, source->filename );
1038             output( "\t$(FLEX) $(LEXFLAGS) -o$@ %s\n", source->filename );
1039             output( "%s.yy.o: %s.yy.c\n", obj, obj );
1040             output( "\t$(CC) -c $(ALLCFLAGS) -o $@ %s.yy.c\n", obj );
1041             column += output( "%s.yy.o:", obj );
1042         }
1043         else if (!strcmp( ext, "rc" ))  /* resource file */
1044         {
1045             if (source->flags & FLAG_RC_PO)
1046             {
1047                 output( "%s.res: $(WRC) $(ALL_MO_FILES) %s\n", obj, source->filename );
1048                 output( "\t$(WRC) $(RCFLAGS) -o $@ %s\n", source->filename );
1049                 column += output( "%s.res rsrc.pot:", obj );
1050                 po_srcs++;
1051             }
1052             else
1053             {
1054                 output( "%s.res: $(WRC) %s\n", obj, source->filename );
1055                 output( "\t$(WRC) $(RCFLAGS) -o $@ %s\n", source->filename );
1056                 column += output( "%s.res:", obj );
1057             }
1058         }
1059         else if (!strcmp( ext, "mc" ))  /* message file */
1060         {
1061             output( "%s.res: $(WMC) $(ALL_MO_FILES) %s\n", obj, source->filename );
1062             output( "\t$(WMC) -U -O res $(PORCFLAGS) -o $@ %s\n", source->filename );
1063             mc_srcs++;
1064             column += output( "msg.pot %s.res:", obj );
1065         }
1066         else if (!strcmp( ext, "idl" ))  /* IDL file */
1067         {
1068             char *targets[8];
1069             unsigned int i, nb_targets = 0;
1070
1071             if (!source->flags || find_include_file( strmake( "%s.h", obj )))
1072                 source->flags |= FLAG_IDL_HEADER;
1073
1074             for (i = 0; i < sizeof(idl_outputs) / sizeof(idl_outputs[0]); i++)
1075             {
1076                 if (!(source->flags & idl_outputs[i].flag)) continue;
1077                 output( "%s%s: $(WIDL)\n", obj, idl_outputs[i].ext );
1078                 output( "\t$(WIDL) %s -o $@ %s\n", idl_outputs[i].widl_arg, source->filename );
1079                 targets[nb_targets++] = strmake( "%s%s", obj, idl_outputs[i].ext );
1080             }
1081             for (i = 0; i < nb_targets; i++)
1082             {
1083                 column += output( "%s%c", targets[i], i < nb_targets - 1 ? ' ' : ':' );
1084                 free( targets[i] );
1085             }
1086             column += output( " %s", source->filename );
1087         }
1088         else if (!strcmp( ext, "tlb" ) || !strcmp( ext, "res" ) || !strcmp( ext, "pot" ))
1089         {
1090             continue;  /* nothing to do for typelib files */
1091         }
1092         else
1093         {
1094             struct object_extension *ext;
1095             LIST_FOR_EACH_ENTRY( ext, &object_extensions, struct object_extension, entry )
1096             {
1097                 if (strstr( ext->extension, "cross" ))
1098                 {
1099                     output( "%s.%s: %s\n", obj, ext->extension, source->filename );
1100                     output( "\t$(CROSSCC) -c $(ALLCROSSCFLAGS) -o $@ %s\n", source->filename );
1101                 }
1102                 else
1103                 {
1104                     output( "%s.%s: %s\n", obj, ext->extension, source->filename );
1105                     output( "\t$(CC) -c $(ALLCFLAGS) -o $@ %s\n", source->filename );
1106                 }
1107             }
1108             LIST_FOR_EACH_ENTRY( ext, &object_extensions, struct object_extension, entry )
1109                 column += output( "%s.%s ", obj, ext->extension );
1110             column += output( ":" );
1111         }
1112         free( obj );
1113
1114         for (i = 0; i < MAX_INCLUDES; i++)
1115             if (source->files[i]) output_include( source->files[i], source, &column );
1116         output( "\n" );
1117     }
1118
1119     /* rules for files that depend on multiple sources */
1120
1121     if (po_srcs)
1122     {
1123         column = output( "rsrc.pot: $(WRC)" );
1124         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1125             if (source->flags & FLAG_RC_PO) output_filename( source->filename, &column );
1126         output( "\n" );
1127         column = output( "\t$(WRC) $(RCFLAGS) -O pot -o $@" );
1128         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1129             if (source->flags & FLAG_RC_PO) output_filename( source->filename, &column );
1130         output( "\n" );
1131     }
1132
1133     if (mc_srcs)
1134     {
1135         column = output( "msg.pot: $(WMC)" );
1136         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1137             if (strendswith( source->name, ".mc" )) output_filename( source->filename, &column );
1138         output( "\n" );
1139         column = output( "\t$(WMC) -O pot -o $@" );
1140         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1141             if (strendswith( source->name, ".mc" )) output_filename( source->filename, &column );
1142         output( "\n" );
1143     }
1144
1145     if (find_src_file( "dlldata.o" ))
1146     {
1147         output( "dlldata.c: $(WIDL) Makefile.in\n" );
1148         column = output( "\t$(WIDL) $(IDLFLAGS) --dlldata-only -o $@" );
1149         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1150             if (source->flags & FLAG_IDL_PROXY) output_filename( source->filename, &column );
1151         output( "\n" );
1152     }
1153
1154     if (find_src_file( "testlist.o" ))
1155     {
1156         output( "testlist.c: $(MAKECTESTS) Makefile.in\n" );
1157         column = output( "\t$(MAKECTESTS) -o $@" );
1158         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1159             if (strendswith( source->name, ".c" ) && !is_generated_idl( source ))
1160                 output_filename( source->filename, &column );
1161         output( "\n" );
1162     }
1163 }
1164
1165
1166 /*******************************************************************
1167  *         create_temp_file
1168  */
1169 static FILE *create_temp_file( char **tmp_name )
1170 {
1171     char *name = xmalloc( strlen(OutputFileName) + 13 );
1172     unsigned int i, id = getpid();
1173     int fd;
1174     FILE *ret = NULL;
1175
1176     for (i = 0; i < 100; i++)
1177     {
1178         sprintf( name, "%s.tmp%08x", OutputFileName, id );
1179         if ((fd = open( name, O_RDWR | O_CREAT | O_EXCL, 0666 )) != -1)
1180         {
1181             ret = fdopen( fd, "w" );
1182             break;
1183         }
1184         if (errno != EEXIST) break;
1185         id += 7777;
1186     }
1187     if (!ret) fatal_error( "failed to create output file for '%s'\n", OutputFileName );
1188     *tmp_name = name;
1189     return ret;
1190 }
1191
1192
1193 /*******************************************************************
1194  *         output_dependencies
1195  */
1196 static void output_dependencies(void)
1197 {
1198     char *tmp_name = NULL;
1199
1200     if (Separator && ((output_file = fopen( OutputFileName, "r" ))))
1201     {
1202         char buffer[1024];
1203         FILE *tmp_file = create_temp_file( &tmp_name );
1204         int found = 0;
1205
1206         while (fgets( buffer, sizeof(buffer), output_file ) && !found)
1207         {
1208             if (fwrite( buffer, 1, strlen(buffer), tmp_file ) != strlen(buffer))
1209                 fatal_error( "failed to write to %s\n", tmp_name );
1210             found = !strncmp( buffer, Separator, strlen(Separator) );
1211         }
1212         fclose( output_file );
1213         output_file = tmp_file;
1214         if (!found && list_head(&sources)) output( "\n%s\n", Separator );
1215     }
1216     else
1217     {
1218         if (!(output_file = fopen( OutputFileName, Separator ? "a" : "w" )))
1219             fatal_perror( "%s", OutputFileName );
1220     }
1221
1222     output_sources();
1223
1224     fclose( output_file );
1225     output_file = NULL;
1226
1227     if (tmp_name)
1228     {
1229         int ret = rename( tmp_name, OutputFileName );
1230         if (ret == -1 && errno == EEXIST)
1231         {
1232             /* rename doesn't overwrite on windows */
1233             unlink( OutputFileName );
1234             ret = rename( tmp_name, OutputFileName );
1235         }
1236         if (ret == -1)
1237         {
1238             unlink( tmp_name );
1239             fatal_error( "failed to rename output file to '%s'\n", OutputFileName );
1240         }
1241         free( tmp_name );
1242     }
1243 }
1244
1245
1246 /*******************************************************************
1247  *         parse_option
1248  */
1249 static void parse_option( const char *opt )
1250 {
1251     switch(opt[1])
1252     {
1253     case 'I':
1254         if (opt[2]) add_include_path( opt + 2 );
1255         break;
1256     case 'C':
1257         src_dir = opt + 2;
1258         break;
1259     case 'S':
1260         top_src_dir = opt + 2;
1261         break;
1262     case 'T':
1263         top_obj_dir = opt + 2;
1264         break;
1265     case 'f':
1266         if (opt[2]) OutputFileName = opt + 2;
1267         break;
1268     case 's':
1269         if (opt[2]) Separator = opt + 2;
1270         else Separator = NULL;
1271         break;
1272     case 'x':
1273         if (opt[2]) add_object_extension( opt + 2 );
1274         break;
1275     default:
1276         fprintf( stderr, "Unknown option '%s'\n%s", opt, Usage );
1277         exit(1);
1278     }
1279 }
1280
1281
1282 /*******************************************************************
1283  *         main
1284  */
1285 int main( int argc, char *argv[] )
1286 {
1287     struct incl_file *pFile;
1288     struct incl_path *path, *next;
1289     int i, j;
1290
1291     i = 1;
1292     while (i < argc)
1293     {
1294         if (argv[i][0] == '-')
1295         {
1296             parse_option( argv[i] );
1297             for (j = i; j < argc; j++) argv[j] = argv[j+1];
1298             argc--;
1299         }
1300         else i++;
1301     }
1302
1303     /* ignore redundant source paths */
1304     if (src_dir && !strcmp( src_dir, "." )) src_dir = NULL;
1305     if (top_src_dir && top_obj_dir && !strcmp( top_src_dir, top_obj_dir )) top_src_dir = NULL;
1306
1307     /* set the default extension list for object files */
1308     if (list_empty( &object_extensions ))
1309         add_object_extension( "o" );
1310
1311     /* get rid of absolute paths that don't point into the source dir */
1312     LIST_FOR_EACH_ENTRY_SAFE( path, next, &paths, struct incl_path, entry )
1313     {
1314         if (path->name[0] != '/') continue;
1315         if (top_src_dir)
1316         {
1317             if (!strncmp( path->name, top_src_dir, strlen(top_src_dir) ) &&
1318                 path->name[strlen(top_src_dir)] == '/') continue;
1319         }
1320         list_remove( &path->entry );
1321         free( path );
1322     }
1323
1324     for (i = 1; i < argc; i++) add_src_file( argv[i] );
1325     add_generated_sources();
1326
1327     LIST_FOR_EACH_ENTRY( pFile, &includes, struct incl_file, entry ) parse_file( pFile, 0 );
1328     output_dependencies();
1329     return 0;
1330 }