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_include_directive
 619  */
 620 static void parse_include_directive( struct incl_file *source, char *str )
 621 {
 622     char quote, *include, *p = str;
 623
 624     while (*p && isspace(*p)) p++;
 625     if (*p != '\"' && *p != '<' ) return;
 626     quote = *p++;
 627     if (quote == '<') quote = '>';
 628     include = p;
 629     while (*p && (*p != quote)) p++;
 630     if (!*p) fatal_error( "malformed include directive '%s'\n", str );
 631     *p = 0;
 632     add_include( source, include, (quote == '>') );
 633 }
 634
 635
 636 /*******************************************************************
 637  *         parse_pragma_directive
 638  */
 639 static void parse_pragma_directive( struct incl_file *source, char *str )
 640 {
 641     char *flag, *p = str;
 642
 643     if (!isspace( *p )) return;
 644     while (*p && isspace(*p)) p++;
 645     p = strtok( p, " \t" );
 646     if (strcmp( p, "makedep" )) return;
 647
 648     while ((flag = strtok( NULL, " \t" )))
 649     {
 650         if (!strcmp( flag, "depend" ))
 651         {
 652             while ((p = strtok( NULL, " \t" ))) add_include( source, p, 0 );
 653             return;
 654         }
 655         if (strendswith( source->name, ".idl" ))
 656         {
 657             if (!strcmp( flag, "header" )) source->flags |= FLAG_IDL_HEADER;
 658             else if (!strcmp( flag, "proxy" )) source->flags |= FLAG_IDL_PROXY;
 659             else if (!strcmp( flag, "client" )) source->flags |= FLAG_IDL_CLIENT;
 660             else if (!strcmp( flag, "server" )) source->flags |= FLAG_IDL_SERVER;
 661             else if (!strcmp( flag, "ident" )) source->flags |= FLAG_IDL_IDENT;
 662             else if (!strcmp( flag, "typelib" )) source->flags |= FLAG_IDL_TYPELIB;
 663             else if (!strcmp( flag, "register" )) source->flags |= FLAG_IDL_REGISTER;
 664         }
 665         else if (strendswith( source->name, ".rc" ))
 666         {
 667             if (!strcmp( flag, "po" )) source->flags |= FLAG_RC_PO;
 668         }
 669     }
 670 }
 671
 672
 673 /*******************************************************************
 674  *         parse_cpp_directive
 675  */
 676 static void parse_cpp_directive( struct incl_file *source, char *str )
 677 {
 678     while (*str && isspace(*str)) str++;
 679     if (*str++ != '#') return;
 680     while (*str && isspace(*str)) str++;
 681
 682     if (!strncmp( str, "include", 7 ))
 683         parse_include_directive( source, str + 7 );
 684     else if (!strncmp( str, "import", 6 ) && strendswith( source->name, ".m" ))
 685         parse_include_directive( source, str + 6 );
 686     else if (!strncmp( str, "pragma", 6 ))
 687         parse_pragma_directive( source, str + 6 );
 688 }
 689
 690
 691 /*******************************************************************
 692  *         parse_idl_file
 693  *
 694  * If for_h_file is non-zero, it means we are not interested in the idl file
 695  * itself, but only in the contents of the .h file that will be generated from it.
 696  */
 697 static void parse_idl_file( struct incl_file *pFile, FILE *file, int for_h_file )
 698 {
 699     char *buffer, *include;
 700
 701     input_line = 0;
 702     if (for_h_file)
 703     {
 704         /* generated .h file always includes these */
 705         add_include( pFile, "rpc.h", 1 );
 706         add_include( pFile, "rpcndr.h", 1 );
 707     }
 708
 709     while ((buffer = get_line( file )))
 710     {
 711         char quote;
 712         char *p = buffer;
 713         while (*p && isspace(*p)) p++;
 714
 715         if (!strncmp( p, "import", 6 ))
 716         {
 717             p += 6;
 718             while (*p && isspace(*p)) p++;
 719             if (*p != '"') continue;
 720             include = ++p;
 721             while (*p && (*p != '"')) p++;
 722             if (!*p) fatal_error( "malformed import directive\n" );
 723             *p = 0;
 724             if (for_h_file && strendswith( include, ".idl" )) strcpy( p - 4, ".h" );
 725             add_include( pFile, include, 0 );
 726             continue;
 727         }
 728
 729         if (for_h_file)  /* only check for #include inside cpp_quote */
 730         {
 731             if (strncmp( p, "cpp_quote", 9 )) continue;
 732             p += 9;
 733             while (*p && isspace(*p)) p++;
 734             if (*p++ != '(') continue;
 735             while (*p && isspace(*p)) p++;
 736             if (*p++ != '"') continue;
 737             if (*p++ != '#') continue;
 738             while (*p && isspace(*p)) p++;
 739             if (strncmp( p, "include", 7 )) continue;
 740             p += 7;
 741             while (*p && isspace(*p)) p++;
 742             if (*p == '\\' && p[1] == '"')
 743             {
 744                 p += 2;
 745                 quote = '"';
 746             }
 747             else
 748             {
 749                 if (*p++ != '<' ) continue;
 750                 quote = '>';
 751             }
 752             include = p;
 753             while (*p && (*p != quote)) p++;
 754             if (!*p || (quote == '"' && p[-1] != '\\'))
 755                 fatal_error( "malformed #include directive inside cpp_quote\n" );
 756             if (quote == '"') p--;  /* remove backslash */
 757             *p = 0;
 758             add_include( pFile, include, (quote == '>') );
 759             continue;
 760         }
 761
 762         parse_cpp_directive( pFile, p );
 763     }
 764 }
 765
 766 /*******************************************************************
 767  *         parse_c_file
 768  */
 769 static void parse_c_file( struct incl_file *pFile, FILE *file )
 770 {
 771     char *buffer;
 772
 773     input_line = 0;
 774     while ((buffer = get_line( file )))
 775     {
 776         parse_cpp_directive( pFile, buffer );
 777     }
 778 }
 779
 780
 781 /*******************************************************************
 782  *         parse_rc_file
 783  */
 784 static void parse_rc_file( struct incl_file *pFile, FILE *file )
 785 {
 786     char *buffer, *include;
 787
 788     input_line = 0;
 789     while ((buffer = get_line( file )))
 790     {
 791         char quote;
 792         char *p = buffer;
 793         while (*p && isspace(*p)) p++;
 794
 795         if (p[0] == '/' && p[1] == '*')  /* check for magic makedep comment */
 796         {
 797             p += 2;
 798             while (*p && isspace(*p)) p++;
 799             if (strncmp( p, "@makedep:", 9 )) continue;
 800             p += 9;
 801             while (*p && isspace(*p)) p++;
 802             quote = '"';
 803             if (*p == quote)
 804             {
 805                 include = ++p;
 806                 while (*p && *p != quote) p++;
 807             }
 808             else
 809             {
 810                 include = p;
 811                 while (*p && !isspace(*p) && *p != '*') p++;
 812             }
 813             if (!*p)
 814                 fatal_error( "malformed makedep comment\n" );
 815             *p = 0;
 816             add_include( pFile, include, (quote == '>') );
 817             continue;
 818         }
 819
 820         parse_cpp_directive( pFile, buffer );
 821     }
 822 }
 823
 824
 825 /*******************************************************************
 826  *         parse_generated_idl
 827  */
 828 static void parse_generated_idl( struct incl_file *source )
 829 {
 830     char *header = replace_extension( source->name, 4, ".h" );
 831
 832     source->filename = xstrdup( source->name );
 833
 834     if (strendswith( source->name, "_c.c" ))
 835     {
 836         add_include( source, header, 0 );
 837     }
 838     else if (strendswith( source->name, "_i.c" ))
 839     {
 840         add_include( source, "rpc.h", 1 );
 841         add_include( source, "rpcndr.h", 1 );
 842         add_include( source, "guiddef.h", 1 );
 843     }
 844     else if (strendswith( source->name, "_p.c" ))
 845     {
 846         add_include( source, "objbase.h", 1 );
 847         add_include( source, "rpcproxy.h", 1 );
 848         add_include( source, "wine/exception.h", 1 );
 849         add_include( source, header, 0 );
 850     }
 851     else if (strendswith( source->name, "_s.c" ))
 852     {
 853         add_include( source, "wine/exception.h", 1 );
 854         add_include( source, header, 0 );
 855     }
 856
 857     free( header );
 858 }
 859
 860 /*******************************************************************
 861  *         is_generated_idl
 862  */
 863 static int is_generated_idl( struct incl_file *source )
 864 {
 865     return (strendswith( source->name, "_c.c" ) ||
 866             strendswith( source->name, "_i.c" ) ||
 867             strendswith( source->name, "_p.c" ) ||
 868             strendswith( source->name, "_s.c" ));
 869 }
 870
 871 /*******************************************************************
 872  *         parse_file
 873  */
 874 static void parse_file( struct incl_file *source, int src )
 875 {
 876     FILE *file;
 877
 878     /* don't try to open certain types of files */
 879     if (strendswith( source->name, ".tlb" ) ||
 880         strendswith( source->name, ".x" ))
 881     {
 882         source->filename = xstrdup( source->name );
 883         return;
 884     }
 885
 886     file = src ? open_src_file( source ) : open_include_file( source );
 887     if (!file) return;
 888     input_file_name = source->filename;
 889
 890     if (source->sourcename && strendswith( source->sourcename, ".idl" ))
 891         parse_idl_file( source, file, 1 );
 892     else if (strendswith( source->filename, ".idl" ))
 893         parse_idl_file( source, file, 0 );
 894     else if (strendswith( source->filename, ".c" ) ||
 895              strendswith( source->filename, ".m" ) ||
 896              strendswith( source->filename, ".h" ) ||
 897              strendswith( source->filename, ".l" ) ||
 898              strendswith( source->filename, ".y" ))
 899         parse_c_file( source, file );
 900     else if (strendswith( source->filename, ".rc" ))
 901         parse_rc_file( source, file );
 902     fclose(file);
 903     input_file_name = NULL;
 904 }
 905
 906
 907 /*******************************************************************
 908  *         add_src_file
 909  *
 910  * Add a source file to the list.
 911  */
 912 static struct incl_file *add_src_file( const char *name )
 913 {
 914     struct incl_file *file;
 915
 916     if ((file = find_src_file( name ))) return file;  /* we already have it */
 917     file = xmalloc( sizeof(*file) );
 918     memset( file, 0, sizeof(*file) );
 919     file->name = xstrdup(name);
 920     list_add_tail( &sources, &file->entry );
 921
 922     /* special cases for generated files */
 923
 924     if (is_generated_idl( file ))
 925     {
 926         parse_generated_idl( file );
 927         return file;
 928     }
 929
 930     if (!strcmp( file->name, "dlldata.o" ))
 931     {
 932         file->filename = xstrdup( "dlldata.c" );
 933         add_include( file, "objbase.h", 1 );
 934         add_include( file, "rpcproxy.h", 1 );
 935         return file;
 936     }
 937
 938     if (!strcmp( file->name, "testlist.o" ))
 939     {
 940         file->filename = xstrdup( "testlist.c" );
 941         add_include( file, "wine/test.h", 1 );
 942         return file;
 943     }
 944
 945     if (strendswith( file->name, ".o" ))
 946     {
 947         /* default to .c for unknown extra object files */
 948         file->filename = replace_extension( file->name, 2, ".c" );
 949         return file;
 950     }
 951
 952     if (strendswith( file->name, ".tlb" ) ||
 953         strendswith( file->name, ".res" ) ||
 954         strendswith( file->name, ".pot" ) ||
 955         strendswith( file->name, ".x" ))
 956     {
 957         file->filename = xstrdup( file->name );
 958         return file;
 959     }
 960
 961     parse_file( file, 1 );
 962     return file;
 963 }
 964
 965
 966 /*******************************************************************
 967  *         add_generated_sources
 968  */
 969 static void add_generated_sources(void)
 970 {
 971     unsigned int i;
 972     struct incl_file *source, *next;
 973
 974     LIST_FOR_EACH_ENTRY_SAFE( source, next, &sources, struct incl_file, entry )
 975     {
 976         if (!source->flags) continue;
 977         for (i = 0; i < sizeof(idl_outputs) / sizeof(idl_outputs[0]); i++)
 978         {
 979             if (!(source->flags & idl_outputs[i].flag)) continue;
 980             if (!strendswith( idl_outputs[i].ext, ".c" )) continue;
 981             add_src_file( replace_extension( source->name, 4, idl_outputs[i].ext ));
 982         }
 983         if (source->flags & FLAG_IDL_PROXY) add_src_file( "dlldata.o" );
 984     }
 985
 986     LIST_FOR_EACH_ENTRY_SAFE( source, next, &sources, struct incl_file, entry )
 987     {
 988         if (strendswith( source->name, "_c.c" ) ||
 989             strendswith( source->name, "_i.c" ) ||
 990             strendswith( source->name, "_p.c" ) ||
 991             strendswith( source->name, "_s.c" ) ||
 992             strendswith( source->name, ".tlb" ))
 993         {
 994             char *idl = replace_extension( source->name, 4, ".idl" );
 995             struct incl_file *file = add_src_file( idl );
 996             if (strendswith( source->name, "_c.c" )) file->flags |= FLAG_IDL_CLIENT;
 997             else if (strendswith( source->name, "_i.c" )) file->flags |= FLAG_IDL_IDENT;
 998             else if (strendswith( source->name, "_p.c" )) file->flags |= FLAG_IDL_PROXY;
 999             else if (strendswith( source->name, "_s.c" )) file->flags |= FLAG_IDL_SERVER;
1000             else if (strendswith( source->name, ".tlb" )) file->flags |= FLAG_IDL_TYPELIB;
1001             continue;
1002         }
1003         if (strendswith( source->name, "_r.res" ) ||
1004             strendswith( source->name, "_t.res" ))
1005         {
1006             char *idl = replace_extension( source->name, 6, ".idl" );
1007             struct incl_file *file = add_src_file( idl );
1008             if (strendswith( source->name, "_r.res" )) file->flags |= FLAG_IDL_REGISTER;
1009             else if (strendswith( source->name, "_t.res" )) file->flags |= FLAG_IDL_TYPELIB;
1010             continue;
1011         }
1012         if (strendswith( source->name, ".pot" ))
1013         {
1014             char *rc = replace_extension( source->name, 4, ".rc" );
1015             struct incl_file *file = add_src_file( rc );
1016             file->flags |= FLAG_RC_PO;
1017         }
1018     }
1019 }
1020
1021
1022 /*******************************************************************
1023  *         output_include
1024  */
1025 static void output_include( struct incl_file *pFile, struct incl_file *owner, int *column )
1026 {
1027     int i;
1028
1029     if (pFile->owner == owner) return;
1030     if (!pFile->filename) return;
1031     pFile->owner = owner;
1032     output_filename( pFile->filename, column );
1033     for (i = 0; i < MAX_INCLUDES; i++)
1034         if (pFile->files[i]) output_include( pFile->files[i], owner, column );
1035 }
1036
1037
1038 /*******************************************************************
1039  *         output_sources
1040  */
1041 static void output_sources(void)
1042 {
1043     struct incl_file *source;
1044     int i, column, po_srcs = 0, mc_srcs = 0;
1045
1046     LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1047     {
1048         char *obj = xstrdup( source->name );
1049         char *ext = get_extension( obj );
1050
1051         if (!ext) fatal_error( "unsupported file type %s\n", source->name );
1052         *ext++ = 0;
1053         column = 0;
1054
1055         if (!strcmp( ext, "y" ))  /* yacc file */
1056         {
1057             /* add source file dependency for parallel makes */
1058             char *header = strmake( "%s.tab.h", obj );
1059             if (find_include_file( header ))
1060             {
1061                 output( "%s.tab.h: %s\n", obj, source->filename );
1062                 output( "\t$(BISON) $(BISONFLAGS) -p %s_ -o %s.tab.c -d %s\n",
1063                         obj, obj, source->filename );
1064                 output( "%s.tab.c: %s %s\n", obj, source->filename, header );
1065             }
1066             else output( "%s.tab.c: %s\n", obj, source->filename );
1067
1068             output( "\t$(BISON) $(BISONFLAGS) -p %s_ -o $@ %s\n", obj, source->filename );
1069             output( "%s.tab.o: %s.tab.c\n", obj, obj );
1070             output( "\t$(CC) -c $(ALLCFLAGS) -o $@ %s.tab.c\n", obj );
1071             column += output( "%s.tab.o:", obj );
1072             free( header );
1073         }
1074         else if (!strcmp( ext, "l" ))  /* lex file */
1075         {
1076             output( "%s.yy.c: %s\n", obj, source->filename );
1077             output( "\t$(FLEX) $(LEXFLAGS) -o$@ %s\n", source->filename );
1078             output( "%s.yy.o: %s.yy.c\n", obj, obj );
1079             output( "\t$(CC) -c $(ALLCFLAGS) -o $@ %s.yy.c\n", obj );
1080             column += output( "%s.yy.o:", obj );
1081         }
1082         else if (!strcmp( ext, "rc" ))  /* resource file */
1083         {
1084             if (source->flags & FLAG_RC_PO)
1085             {
1086                 output( "%s.res: $(WRC) $(ALL_MO_FILES) %s\n", obj, source->filename );
1087                 output( "\t$(WRC) $(RCFLAGS) -o $@ %s\n", source->filename );
1088                 column += output( "%s.res rsrc.pot:", obj );
1089                 po_srcs++;
1090             }
1091             else
1092             {
1093                 output( "%s.res: $(WRC) %s\n", obj, source->filename );
1094                 output( "\t$(WRC) $(RCFLAGS) -o $@ %s\n", source->filename );
1095                 column += output( "%s.res:", obj );
1096             }
1097         }
1098         else if (!strcmp( ext, "mc" ))  /* message file */
1099         {
1100             output( "%s.res: $(WMC) $(ALL_MO_FILES) %s\n", obj, source->filename );
1101             output( "\t$(WMC) -U -O res $(PORCFLAGS) -o $@ %s\n", source->filename );
1102             mc_srcs++;
1103             column += output( "msg.pot %s.res:", obj );
1104         }
1105         else if (!strcmp( ext, "idl" ))  /* IDL file */
1106         {
1107             char *targets[8];
1108             unsigned int i, nb_targets = 0;
1109
1110             if (!source->flags || find_include_file( strmake( "%s.h", obj )))
1111                 source->flags |= FLAG_IDL_HEADER;
1112
1113             for (i = 0; i < sizeof(idl_outputs) / sizeof(idl_outputs[0]); i++)
1114             {
1115                 if (!(source->flags & idl_outputs[i].flag)) continue;
1116                 output( "%s%s: $(WIDL)\n", obj, idl_outputs[i].ext );
1117                 output( "\t$(WIDL) %s -o $@ %s\n", idl_outputs[i].widl_arg, source->filename );
1118                 targets[nb_targets++] = strmake( "%s%s", obj, idl_outputs[i].ext );
1119             }
1120             for (i = 0; i < nb_targets; i++)
1121             {
1122                 column += output( "%s%c", targets[i], i < nb_targets - 1 ? ' ' : ':' );
1123                 free( targets[i] );
1124             }
1125             column += output( " %s", source->filename );
1126         }
1127         else if (!strcmp( ext, "tlb" ) || !strcmp( ext, "res" ) || !strcmp( ext, "pot" ))
1128         {
1129             continue;  /* nothing to do for typelib files */
1130         }
1131         else
1132         {
1133             struct object_extension *ext;
1134             LIST_FOR_EACH_ENTRY( ext, &object_extensions, struct object_extension, entry )
1135             {
1136                 if (strstr( ext->extension, "cross" ))
1137                 {
1138                     output( "%s.%s: %s\n", obj, ext->extension, source->filename );
1139                     output( "\t$(CROSSCC) -c $(ALLCROSSCFLAGS) -o $@ %s\n", source->filename );
1140                 }
1141                 else
1142                 {
1143                     output( "%s.%s: %s\n", obj, ext->extension, source->filename );
1144                     output( "\t$(CC) -c $(ALLCFLAGS) -o $@ %s\n", source->filename );
1145                 }
1146             }
1147             LIST_FOR_EACH_ENTRY( ext, &object_extensions, struct object_extension, entry )
1148                 column += output( "%s.%s ", obj, ext->extension );
1149             column += output( ":" );
1150         }
1151         free( obj );
1152
1153         for (i = 0; i < MAX_INCLUDES; i++)
1154             if (source->files[i]) output_include( source->files[i], source, &column );
1155         output( "\n" );
1156     }
1157
1158     /* rules for files that depend on multiple sources */
1159
1160     if (po_srcs)
1161     {
1162         column = output( "rsrc.pot: $(WRC)" );
1163         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1164             if (source->flags & FLAG_RC_PO) output_filename( source->filename, &column );
1165         output( "\n" );
1166         column = output( "\t$(WRC) $(RCFLAGS) -O pot -o $@" );
1167         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1168             if (source->flags & FLAG_RC_PO) output_filename( source->filename, &column );
1169         output( "\n" );
1170     }
1171
1172     if (mc_srcs)
1173     {
1174         column = output( "msg.pot: $(WMC)" );
1175         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1176             if (strendswith( source->name, ".mc" )) output_filename( source->filename, &column );
1177         output( "\n" );
1178         column = output( "\t$(WMC) -O pot -o $@" );
1179         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1180             if (strendswith( source->name, ".mc" )) output_filename( source->filename, &column );
1181         output( "\n" );
1182     }
1183
1184     if (find_src_file( "dlldata.o" ))
1185     {
1186         output( "dlldata.c: $(WIDL) Makefile.in\n" );
1187         column = output( "\t$(WIDL) $(IDLFLAGS) --dlldata-only -o $@" );
1188         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1189             if (source->flags & FLAG_IDL_PROXY) output_filename( source->filename, &column );
1190         output( "\n" );
1191     }
1192
1193     if (find_src_file( "testlist.o" ))
1194     {
1195         output( "testlist.c: $(MAKECTESTS) Makefile.in\n" );
1196         column = output( "\t$(MAKECTESTS) -o $@" );
1197         LIST_FOR_EACH_ENTRY( source, &sources, struct incl_file, entry )
1198             if (strendswith( source->name, ".c" ) && !is_generated_idl( source ))
1199                 output_filename( source->filename, &column );
1200         output( "\n" );
1201     }
1202 }
1203
1204
1205 /*******************************************************************
1206  *         create_temp_file
1207  */
1208 static FILE *create_temp_file( char **tmp_name )
1209 {
1210     char *name = xmalloc( strlen(OutputFileName) + 13 );
1211     unsigned int i, id = getpid();
1212     int fd;
1213     FILE *ret = NULL;
1214
1215     for (i = 0; i < 100; i++)
1216     {
1217         sprintf( name, "%s.tmp%08x", OutputFileName, id );
1218         if ((fd = open( name, O_RDWR | O_CREAT | O_EXCL, 0666 )) != -1)
1219         {
1220             ret = fdopen( fd, "w" );
1221             break;
1222         }
1223         if (errno != EEXIST) break;
1224         id += 7777;
1225     }
1226     if (!ret) fatal_error( "failed to create output file for '%s'\n", OutputFileName );
1227     *tmp_name = name;
1228     return ret;
1229 }
1230
1231
1232 /*******************************************************************
1233  *         output_dependencies
1234  */
1235 static void output_dependencies(void)
1236 {
1237     char *tmp_name = NULL;
1238
1239     if (Separator && ((output_file = fopen( OutputFileName, "r" ))))
1240     {
1241         char buffer[1024];
1242         FILE *tmp_file = create_temp_file( &tmp_name );
1243         int found = 0;
1244
1245         while (fgets( buffer, sizeof(buffer), output_file ) && !found)
1246         {
1247             if (fwrite( buffer, 1, strlen(buffer), tmp_file ) != strlen(buffer))
1248                 fatal_error( "failed to write to %s\n", tmp_name );
1249             found = !strncmp( buffer, Separator, strlen(Separator) );
1250         }
1251         fclose( output_file );
1252         output_file = tmp_file;
1253         if (!found && list_head(&sources)) output( "\n%s\n", Separator );
1254     }
1255     else
1256     {
1257         if (!(output_file = fopen( OutputFileName, Separator ? "a" : "w" )))
1258             fatal_perror( "%s", OutputFileName );
1259     }
1260
1261     output_sources();
1262
1263     fclose( output_file );
1264     output_file = NULL;
1265
1266     if (tmp_name)
1267     {
1268         int ret = rename( tmp_name, OutputFileName );
1269         if (ret == -1 && errno == EEXIST)
1270         {
1271             /* rename doesn't overwrite on windows */
1272             unlink( OutputFileName );
1273             ret = rename( tmp_name, OutputFileName );
1274         }
1275         if (ret == -1)
1276         {
1277             unlink( tmp_name );
1278             fatal_error( "failed to rename output file to '%s'\n", OutputFileName );
1279         }
1280         free( tmp_name );
1281     }
1282 }
1283
1284
1285 /*******************************************************************
1286  *         parse_option
1287  */
1288 static void parse_option( const char *opt )
1289 {
1290     switch(opt[1])
1291     {
1292     case 'I':
1293         if (opt[2]) add_include_path( opt + 2 );
1294         break;
1295     case 'C':
1296         src_dir = opt + 2;
1297         break;
1298     case 'S':
1299         top_src_dir = opt + 2;
1300         break;
1301     case 'T':
1302         top_obj_dir = opt + 2;
1303         break;
1304     case 'f':
1305         if (opt[2]) OutputFileName = opt + 2;
1306         break;
1307     case 's':
1308         if (opt[2]) Separator = opt + 2;
1309         else Separator = NULL;
1310         break;
1311     case 'x':
1312         if (opt[2]) add_object_extension( opt + 2 );
1313         break;
1314     default:
1315         fprintf( stderr, "Unknown option '%s'\n%s", opt, Usage );
1316         exit(1);
1317     }
1318 }
1319
1320
1321 /*******************************************************************
1322  *         main
1323  */
1324 int main( int argc, char *argv[] )
1325 {
1326     struct incl_file *pFile;
1327     struct incl_path *path, *next;
1328     int i, j;
1329
1330     i = 1;
1331     while (i < argc)
1332     {
1333         if (argv[i][0] == '-')
1334         {
1335             parse_option( argv[i] );
1336             for (j = i; j < argc; j++) argv[j] = argv[j+1];
1337             argc--;
1338         }
1339         else i++;
1340     }
1341
1342     /* ignore redundant source paths */
1343     if (src_dir && !strcmp( src_dir, "." )) src_dir = NULL;
1344     if (top_src_dir && top_obj_dir && !strcmp( top_src_dir, top_obj_dir )) top_src_dir = NULL;
1345
1346     /* set the default extension list for object files */
1347     if (list_empty( &object_extensions ))
1348         add_object_extension( "o" );
1349
1350     /* get rid of absolute paths that don't point into the source dir */
1351     LIST_FOR_EACH_ENTRY_SAFE( path, next, &paths, struct incl_path, entry )
1352     {
1353         if (path->name[0] != '/') continue;
1354         if (top_src_dir)
1355         {
1356             if (!strncmp( path->name, top_src_dir, strlen(top_src_dir) ) &&
1357                 path->name[strlen(top_src_dir)] == '/') continue;
1358         }
1359         list_remove( &path->entry );
1360         free( path );
1361     }
1362
1363     for (i = 1; i < argc; i++) add_src_file( argv[i] );
1364     add_generated_sources();
1365
1366     LIST_FOR_EACH_ENTRY( pFile, &includes, struct incl_file, entry ) parse_file( pFile, 0 );
1367     output_dependencies();
1368     return 0;
1369 }