git.oblomov.eu Git - wine/blob - tools/makedep.c

   1 /*
   2  * Generate include file dependencies
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #define NO_LIBWINE_PORT
  23 #include "wine/port.h"
  24
  25 #include <assert.h>
  26 #include <ctype.h>
  27 #include <errno.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <stdarg.h>
  31 #include <string.h>
  32 #ifdef HAVE_UNISTD_H
  33 # include <unistd.h>
  34 #endif
  35 #include "wine/list.h"
  36
  37 /* Max first-level includes per file */
  38 #define MAX_INCLUDES 200
  39
  40 typedef struct _INCL_FILE
  41 {
  42     struct list        entry;
  43     char              *name;
  44     char              *filename;
  45     char              *sourcename;    /* source file name for generated headers */
  46     struct _INCL_FILE *included_by;   /* file that included this one */
  47     int                included_line; /* line where this file was included */
  48     int                system;        /* is it a system include (#include <name>) */
  49     struct _INCL_FILE *owner;
  50     struct _INCL_FILE *files[MAX_INCLUDES];
  51 } INCL_FILE;
  52
  53 static struct list sources = LIST_INIT(sources);
  54 static struct list includes = LIST_INIT(includes);
  55
  56 typedef struct _INCL_PATH
  57 {
  58     struct list entry;
  59     const char *name;
  60 } INCL_PATH;
  61
  62 static struct list paths = LIST_INIT(paths);
  63
  64 static const char *src_dir;
  65 static const char *top_src_dir;
  66 static const char *top_obj_dir;
  67 static const char *OutputFileName = "Makefile";
  68 static const char *Separator = "### Dependencies";
  69 static const char *ProgramName;
  70 static int input_line;
  71
  72 static const char Usage[] =
  73     "Usage: %s [options] [files]\n"
  74     "Options:\n"
  75     "   -Idir   Search for include files in directory 'dir'\n"
  76     "   -Cdir   Search for source files in directory 'dir'\n"
  77     "   -Sdir   Set the top source directory\n"
  78     "   -Sdir   Set the top object directory\n"
  79     "   -fxxx   Store output in file 'xxx' (default: Makefile)\n"
  80     "   -sxxx   Use 'xxx' as separator (default: \"### Dependencies\")\n";
  81
  82
  83 /*******************************************************************
  84  *         fatal_error
  85  */
  86 static void fatal_error( const char *msg, ... )
  87 {
  88     va_list valist;
  89     va_start( valist, msg );
  90     vfprintf( stderr, msg, valist );
  91     va_end( valist );
  92     exit(1);
  93 }
  94
  95
  96 /*******************************************************************
  97  *         xmalloc
  98  */
  99 static void *xmalloc( size_t size )
 100 {
 101     void *res;
 102     if (!(res = malloc (size ? size : 1)))
 103         fatal_error( "%s: Virtual memory exhausted.\n", ProgramName );
 104     return res;
 105 }
 106
 107
 108 /*******************************************************************
 109  *         xrealloc
 110  */
 111 static void *xrealloc (void *ptr, size_t size)
 112 {
 113     void *res;
 114     assert( size );
 115     if (!(res = realloc( ptr, size )))
 116         fatal_error( "%s: Virtual memory exhausted.\n", ProgramName );
 117     return res;
 118 }
 119
 120 /*******************************************************************
 121  *         xstrdup
 122  */
 123 static char *xstrdup( const char *str )
 124 {
 125     char *res = strdup( str );
 126     if (!res) fatal_error( "%s: Virtual memory exhausted.\n", ProgramName );
 127     return res;
 128 }
 129
 130
 131 /*******************************************************************
 132  *         strmake
 133  */
 134 static char *strmake( const char* fmt, ... )
 135 {
 136     int n;
 137     size_t size = 100;
 138     va_list ap;
 139
 140     for (;;)
 141     {
 142         char *p = xmalloc (size);
 143         va_start(ap, fmt);
 144         n = vsnprintf (p, size, fmt, ap);
 145         va_end(ap);
 146         if (n == -1) size *= 2;
 147         else if ((size_t)n >= size) size = n + 1;
 148         else return p;
 149         free(p);
 150     }
 151 }
 152
 153
 154 /*******************************************************************
 155  *         strendswith
 156  */
 157 static int strendswith( const char* str, const char* end )
 158 {
 159     int l = strlen(str);
 160     int m = strlen(end);
 161
 162     return l >= m && strcmp(str + l - m, end) == 0;
 163 }
 164
 165 /*******************************************************************
 166  *         get_extension
 167  */
 168 static char *get_extension( char *filename )
 169 {
 170     char *ext = strrchr( filename, '.' );
 171     if (ext && strchr( ext, '/' )) ext = NULL;
 172     return ext;
 173 }
 174
 175
 176 /*******************************************************************
 177  *         get_line
 178  */
 179 static char *get_line( FILE *file )
 180 {
 181     static char *buffer;
 182     static unsigned int size;
 183
 184     if (!size)
 185     {
 186         size = 1024;
 187         buffer = xmalloc( size );
 188     }
 189     if (!fgets( buffer, size, file )) return NULL;
 190     input_line++;
 191
 192     for (;;)
 193     {
 194         char *p = buffer + strlen(buffer);
 195         /* if line is larger than buffer, resize buffer */
 196         while (p == buffer + size - 1 && p[-1] != '\n')
 197         {
 198             buffer = xrealloc( buffer, size * 2 );
 199             fgets( buffer + size - 1, size + 1, file );
 200             p = buffer + strlen(buffer);
 201             size *= 2;
 202         }
 203         if (p > buffer && p[-1] == '\n')
 204         {
 205             *(--p) = 0;
 206             if (p > buffer && p[-1] == '\r') *(--p) = 0;
 207             if (p > buffer && p[-1] == '\\')
 208             {
 209                 *(--p) = 0;
 210                 /* line ends in backslash, read continuation line */
 211                 fgets( p, size - (p - buffer), file );
 212                 input_line++;
 213                 continue;
 214             }
 215         }
 216         return buffer;
 217     }
 218 }
 219
 220 /*******************************************************************
 221  *         add_include_path
 222  *
 223  * Add a directory to the include path.
 224  */
 225 static void add_include_path( const char *name )
 226 {
 227     INCL_PATH *path = xmalloc( sizeof(*path) );
 228     list_add_tail( &paths, &path->entry );
 229     path->name = name;
 230 }
 231
 232 /*******************************************************************
 233  *         find_src_file
 234  */
 235 static INCL_FILE *find_src_file( const char *name )
 236 {
 237     INCL_FILE *file;
 238
 239     LIST_FOR_EACH_ENTRY( file, &sources, INCL_FILE, entry )
 240         if (!strcmp( name, file->name )) return file;
 241     return NULL;
 242 }
 243
 244 /*******************************************************************
 245  *         add_src_file
 246  *
 247  * Add a source file to the list.
 248  */
 249 static INCL_FILE *add_src_file( const char *name )
 250 {
 251     INCL_FILE *file;
 252
 253     if (find_src_file( name )) return NULL;  /* we already have it */
 254     file = xmalloc( sizeof(*file) );
 255     memset( file, 0, sizeof(*file) );
 256     file->name = xstrdup(name);
 257     list_add_tail( &sources, &file->entry );
 258     return file;
 259 }
 260
 261
 262 /*******************************************************************
 263  *         add_include
 264  *
 265  * Add an include file if it doesn't already exists.
 266  */
 267 static INCL_FILE *add_include( INCL_FILE *pFile, const char *name, int line, int system )
 268 {
 269     INCL_FILE *include;
 270     char *ext;
 271     int pos;
 272
 273     for (pos = 0; pos < MAX_INCLUDES; pos++) if (!pFile->files[pos]) break;
 274     if (pos >= MAX_INCLUDES)
 275         fatal_error( "%s: %s: too many included files, please fix MAX_INCLUDES\n",
 276                      ProgramName, pFile->name );
 277
 278     /* enforce some rules for the Wine tree */
 279
 280     if (!memcmp( name, "../", 3 ))
 281         fatal_error( "%s:%d: #include directive with relative path not allowed\n",
 282                      pFile->filename, line );
 283
 284     if (!strcmp( name, "config.h" ))
 285     {
 286         if ((ext = strrchr( pFile->filename, '.' )) && !strcmp( ext, ".h" ))
 287             fatal_error( "%s:%d: config.h must not be included by a header file\n",
 288                          pFile->filename, line );
 289         if (pos)
 290             fatal_error( "%s:%d: config.h must be included before anything else\n",
 291                          pFile->filename, line );
 292     }
 293     else if (!strcmp( name, "wine/port.h" ))
 294     {
 295         if ((ext = strrchr( pFile->filename, '.' )) && !strcmp( ext, ".h" ))
 296             fatal_error( "%s:%d: wine/port.h must not be included by a header file\n",
 297                          pFile->filename, line );
 298         if (!pos) fatal_error( "%s:%d: config.h must be included before wine/port.h\n",
 299                                pFile->filename, line );
 300         if (pos > 1)
 301             fatal_error( "%s:%d: wine/port.h must be included before everything except config.h\n",
 302                          pFile->filename, line );
 303         if (strcmp( pFile->files[0]->name, "config.h" ))
 304             fatal_error( "%s:%d: config.h must be included before wine/port.h\n",
 305                          pFile->filename, line );
 306     }
 307
 308     LIST_FOR_EACH_ENTRY( include, &includes, INCL_FILE, entry )
 309         if (!strcmp( name, include->name )) goto found;
 310
 311     include = xmalloc( sizeof(INCL_FILE) );
 312     memset( include, 0, sizeof(INCL_FILE) );
 313     include->name = xstrdup(name);
 314     include->included_by = pFile;
 315     include->included_line = line;
 316     include->system = system;
 317     list_add_tail( &includes, &include->entry );
 318 found:
 319     pFile->files[pos] = include;
 320     return include;
 321 }
 322
 323
 324 /*******************************************************************
 325  *         open_src_file
 326  */
 327 static FILE *open_src_file( INCL_FILE *pFile )
 328 {
 329     FILE *file;
 330
 331     /* first try name as is */
 332     if ((file = fopen( pFile->name, "r" )))
 333     {
 334         pFile->filename = xstrdup( pFile->name );
 335         return file;
 336     }
 337     /* now try in source dir */
 338     if (src_dir)
 339     {
 340         pFile->filename = strmake( "%s/%s", src_dir, pFile->name );
 341         file = fopen( pFile->filename, "r" );
 342     }
 343     if (!file)
 344     {
 345         perror( pFile->name );
 346         exit(1);
 347     }
 348     return file;
 349 }
 350
 351
 352 /*******************************************************************
 353  *         open_include_file
 354  */
 355 static FILE *open_include_file( INCL_FILE *pFile )
 356 {
 357     FILE *file = NULL;
 358     char *filename, *p;
 359     INCL_PATH *path;
 360
 361     errno = ENOENT;
 362
 363     /* check for generated bison header */
 364
 365     if (strendswith( pFile->name, ".tab.h" ))
 366     {
 367         if (src_dir)
 368             filename = strmake( "%s/%.*s.y", src_dir, strlen(pFile->name) - 6, pFile->name );
 369         else
 370             filename = strmake( "%.*s.y", strlen(pFile->name) - 6, pFile->name );
 371
 372         if ((file = fopen( filename, "r" )))
 373         {
 374             pFile->sourcename = filename;
 375             pFile->filename = xstrdup( pFile->name );
 376             /* don't bother to parse it */
 377             fclose( file );
 378             return NULL;
 379         }
 380         free( filename );
 381     }
 382
 383     /* check for generated message resource */
 384
 385     if (strendswith( pFile->name, ".mc.rc" ))
 386     {
 387         if (src_dir)
 388             filename = strmake( "%s/%s", src_dir, pFile->name );
 389         else
 390             filename = xstrdup( pFile->name );
 391
 392         filename[strlen(filename) - 3] = 0;
 393
 394         if ((file = fopen( filename, "r" )))
 395         {
 396             pFile->sourcename = filename;
 397             pFile->filename = xstrdup( pFile->name );
 398             /* don't bother to parse it */
 399             fclose( file );
 400             return NULL;
 401         }
 402         free( filename );
 403     }
 404
 405     /* check for corresponding idl file in source dir */
 406
 407     if (strendswith( pFile->name, ".h" ))
 408     {
 409         if (src_dir)
 410             filename = strmake( "%s/%.*s.idl", src_dir, strlen(pFile->name) - 2, pFile->name );
 411         else
 412             filename = strmake( "%.*s.idl", strlen(pFile->name) - 2, pFile->name );
 413
 414         if ((file = fopen( filename, "r" )))
 415         {
 416             pFile->sourcename = filename;
 417             pFile->filename = xstrdup( pFile->name );
 418             return file;
 419         }
 420         free( filename );
 421     }
 422
 423     /* first try name as is */
 424     if ((file = fopen( pFile->name, "r" )))
 425     {
 426         pFile->filename = xstrdup( pFile->name );
 427         return file;
 428     }
 429
 430     /* now try in source dir */
 431     if (src_dir)
 432     {
 433         filename = strmake( "%s/%s", src_dir, pFile->name );
 434         if ((file = fopen( filename, "r" ))) goto found;
 435         free( filename );
 436     }
 437
 438     /* check for corresponding idl file in global includes */
 439
 440     if (strendswith( pFile->name, ".h" ))
 441     {
 442         if (top_src_dir)
 443             filename = strmake( "%s/include/%.*s.idl",
 444                                 top_src_dir, strlen(pFile->name) - 2, pFile->name );
 445         else if (top_obj_dir)
 446             filename = strmake( "%s/include/%.*s.idl",
 447                                 top_obj_dir, strlen(pFile->name) - 2, pFile->name );
 448         else
 449             filename = NULL;
 450
 451         if (filename && (file = fopen( filename, "r" )))
 452         {
 453             pFile->sourcename = filename;
 454             pFile->filename = strmake( "%s/include/%s", top_obj_dir, pFile->name );
 455             return file;
 456         }
 457         free( filename );
 458     }
 459
 460     /* now try in global includes */
 461     if (top_obj_dir)
 462     {
 463         filename = strmake( "%s/include/%s", top_obj_dir, pFile->name );
 464         if ((file = fopen( filename, "r" ))) goto found;
 465         free( filename );
 466     }
 467     if (top_src_dir)
 468     {
 469         filename = strmake( "%s/include/%s", top_src_dir, pFile->name );
 470         if ((file = fopen( filename, "r" ))) goto found;
 471         free( filename );
 472     }
 473
 474     /* now search in include paths */
 475     LIST_FOR_EACH_ENTRY( path, &paths, INCL_PATH, entry )
 476     {
 477         filename = strmake( "%s/%s", path->name, pFile->name );
 478         if ((file = fopen( filename, "r" ))) goto found;
 479         free( filename );
 480     }
 481     if (pFile->system) return NULL;  /* ignore system files we cannot find */
 482
 483     /* try in src file directory */
 484     if ((p = strrchr(pFile->included_by->filename, '/')))
 485     {
 486         int l = p - pFile->included_by->filename + 1;
 487         filename = xmalloc(l + strlen(pFile->name) + 1);
 488         memcpy( filename, pFile->included_by->filename, l );
 489         strcpy( filename + l, pFile->name );
 490         if ((file = fopen( filename, "r" ))) goto found;
 491         free( filename );
 492     }
 493
 494     perror( pFile->name );
 495     while (pFile->included_by)
 496     {
 497         const char *parent = pFile->included_by->sourcename;
 498         if (!parent) parent = pFile->included_by->name;
 499         fprintf( stderr, "  %s was first included from %s:%d\n",
 500                  pFile->name, parent, pFile->included_line );
 501         pFile = pFile->included_by;
 502     }
 503     exit(1);
 504
 505 found:
 506     pFile->filename = filename;
 507     return file;
 508 }
 509
 510
 511 /*******************************************************************
 512  *         parse_idl_file
 513  *
 514  * If for_h_file is non-zero, it means we are not interested in the idl file
 515  * itself, but only in the contents of the .h file that will be generated from it.
 516  */
 517 static void parse_idl_file( INCL_FILE *pFile, FILE *file, int for_h_file )
 518 {
 519     char *buffer, *include;
 520
 521     if (for_h_file)
 522     {
 523         /* generated .h file always includes these */
 524         add_include( pFile, "rpc.h", 0, 1 );
 525         add_include( pFile, "rpcndr.h", 0, 1 );
 526     }
 527
 528     input_line = 0;
 529     while ((buffer = get_line( file )))
 530     {
 531         char quote;
 532         char *p = buffer;
 533         while (*p && isspace(*p)) p++;
 534
 535         if (!strncmp( p, "import", 6 ))
 536         {
 537             p += 6;
 538             while (*p && isspace(*p)) p++;
 539             if (*p != '"') continue;
 540             include = ++p;
 541             while (*p && (*p != '"')) p++;
 542             if (!*p) fatal_error( "%s:%d: Malformed import directive\n", pFile->filename, input_line );
 543             *p = 0;
 544             if (for_h_file && strendswith( include, ".idl" )) strcpy( p - 4, ".h" );
 545             add_include( pFile, include, input_line, 0 );
 546             continue;
 547         }
 548
 549         if (for_h_file)  /* only check for #include inside cpp_quote */
 550         {
 551             if (strncmp( p, "cpp_quote", 9 )) continue;
 552             p += 9;
 553             while (*p && isspace(*p)) p++;
 554             if (*p++ != '(') continue;
 555             while (*p && isspace(*p)) p++;
 556             if (*p++ != '"') continue;
 557             if (*p++ != '#') continue;
 558             while (*p && isspace(*p)) p++;
 559             if (strncmp( p, "include", 7 )) continue;
 560             p += 7;
 561             while (*p && isspace(*p)) p++;
 562             if (*p == '\\' && p[1] == '"')
 563             {
 564                 p += 2;
 565                 quote = '"';
 566             }
 567             else
 568             {
 569                 if (*p++ != '<' ) continue;
 570                 quote = '>';
 571             }
 572             include = p;
 573             while (*p && (*p != quote)) p++;
 574             if (!*p || (quote == '"' && p[-1] != '\\'))
 575                 fatal_error( "%s:%d: Malformed #include directive inside cpp_quote\n",
 576                              pFile->filename, input_line );
 577             if (quote == '"') p--;  /* remove backslash */
 578             *p = 0;
 579             add_include( pFile, include, input_line, (quote == '>') );
 580             continue;
 581         }
 582
 583         /* check for normal #include */
 584         if (*p++ != '#') continue;
 585         while (*p && isspace(*p)) p++;
 586         if (strncmp( p, "include", 7 )) continue;
 587         p += 7;
 588         while (*p && isspace(*p)) p++;
 589         if (*p != '\"' && *p != '<' ) continue;
 590         quote = *p++;
 591         if (quote == '<') quote = '>';
 592         include = p;
 593         while (*p && (*p != quote)) p++;
 594         if (!*p) fatal_error( "%s:%d: Malformed #include directive\n", pFile->filename, input_line );
 595         *p = 0;
 596         add_include( pFile, include, input_line, (quote == '>') );
 597     }
 598 }
 599
 600 /*******************************************************************
 601  *         parse_c_file
 602  */
 603 static void parse_c_file( INCL_FILE *pFile, FILE *file )
 604 {
 605     char *buffer, *include;
 606
 607     input_line = 0;
 608     while ((buffer = get_line( file )))
 609     {
 610         char quote;
 611         char *p = buffer;
 612         while (*p && isspace(*p)) p++;
 613         if (*p++ != '#') continue;
 614         while (*p && isspace(*p)) p++;
 615         if (strncmp( p, "include", 7 )) continue;
 616         p += 7;
 617         while (*p && isspace(*p)) p++;
 618         if (*p != '\"' && *p != '<' ) continue;
 619         quote = *p++;
 620         if (quote == '<') quote = '>';
 621         include = p;
 622         while (*p && (*p != quote)) p++;
 623         if (!*p) fatal_error( "%s:%d: Malformed #include directive\n",
 624                               pFile->filename, input_line );
 625         *p = 0;
 626         add_include( pFile, include, input_line, (quote == '>') );
 627     }
 628 }
 629
 630
 631 /*******************************************************************
 632  *         parse_generated_idl
 633  */
 634 static void parse_generated_idl( INCL_FILE *source )
 635 {
 636     char *header, *basename;
 637
 638     basename = xstrdup( source->name );
 639     basename[strlen(basename) - 4] = 0;
 640     header = strmake( "%s.h", basename );
 641     source->filename = xstrdup( source->name );
 642
 643     if (strendswith( source->name, "_c.c" ))
 644     {
 645         add_include( source, header, 0, 0 );
 646     }
 647     else if (strendswith( source->name, "_i.c" ))
 648     {
 649         add_include( source, "rpc.h", 0, 1 );
 650         add_include( source, "rpcndr.h", 0, 1 );
 651         add_include( source, "guiddef.h", 0, 1 );
 652     }
 653     else if (strendswith( source->name, "_p.c" ))
 654     {
 655         add_include( source, "rpcproxy.h", 0, 1 );
 656         add_include( source, header, 0, 0 );
 657     }
 658     else if (strendswith( source->name, "_s.c" ))
 659     {
 660         add_include( source, header, 0, 0 );
 661     }
 662
 663     free( header );
 664     free( basename );
 665 }
 666
 667 /*******************************************************************
 668  *         parse_file
 669  */
 670 static void parse_file( INCL_FILE *pFile, int src )
 671 {
 672     FILE *file;
 673
 674     /* special case for source files generated from idl */
 675     if (strendswith( pFile->name, "_c.c" ) ||
 676         strendswith( pFile->name, "_i.c" ) ||
 677         strendswith( pFile->name, "_p.c" ) ||
 678         strendswith( pFile->name, "_s.c" ))
 679     {
 680         parse_generated_idl( pFile );
 681         return;
 682     }
 683
 684     file = src ? open_src_file( pFile ) : open_include_file( pFile );
 685     if (!file) return;
 686
 687     if (pFile->sourcename && strendswith( pFile->sourcename, ".idl" ))
 688         parse_idl_file( pFile, file, 1 );
 689     else if (strendswith( pFile->filename, ".idl" ))
 690         parse_idl_file( pFile, file, 0 );
 691     else
 692         parse_c_file( pFile, file );
 693     fclose(file);
 694 }
 695
 696
 697 /*******************************************************************
 698  *         output_include
 699  */
 700 static void output_include( FILE *file, INCL_FILE *pFile,
 701                             INCL_FILE *owner, int *column )
 702 {
 703     int i;
 704
 705     if (pFile->owner == owner) return;
 706     if (!pFile->filename) return;
 707     pFile->owner = owner;
 708     if (*column + strlen(pFile->filename) + 1 > 70)
 709     {
 710         fprintf( file, " \\\n" );
 711         *column = 0;
 712     }
 713     fprintf( file, " %s", pFile->filename );
 714     *column += strlen(pFile->filename) + 1;
 715     for (i = 0; i < MAX_INCLUDES; i++)
 716         if (pFile->files[i]) output_include( file, pFile->files[i],
 717                                              owner, column );
 718 }
 719
 720
 721 /*******************************************************************
 722  *         output_src
 723  */
 724 static void output_src( FILE *file, INCL_FILE *pFile, int *column )
 725 {
 726     char *obj = xstrdup( pFile->name );
 727     char *ext = get_extension( obj );
 728     if (ext)
 729     {
 730         *ext++ = 0;
 731         if (!strcmp( ext, "y" ))  /* yacc file */
 732         {
 733             *column += fprintf( file, "%s.tab.o: %s.tab.c", obj, obj );
 734         }
 735         else if (!strcmp( ext, "l" ))  /* lex file */
 736         {
 737             *column += fprintf( file, "%s.yy.o: %s.yy.c", obj, obj );
 738         }
 739         else if (!strcmp( ext, "rc" ))  /* resource file */
 740         {
 741             *column += fprintf( file, "%s.res: %s", obj, pFile->filename );
 742         }
 743         else if (!strcmp( ext, "mc" ))  /* message file */
 744         {
 745             *column += fprintf( file, "%s.mc.rc: %s", obj, pFile->filename );
 746         }
 747         else if (!strcmp( ext, "idl" ))  /* IDL file */
 748         {
 749             char *name;
 750
 751             *column += fprintf( file, "%s.h", obj );
 752
 753             name = strmake( "%s_c.c", obj );
 754             if (find_src_file( name )) *column += fprintf( file, " %s", name );
 755             free( name );
 756             name = strmake( "%s_i.c", obj );
 757             if (find_src_file( name )) *column += fprintf( file, " %s", name );
 758             free( name );
 759             name = strmake( "%s_p.c", obj );
 760             if (find_src_file( name )) *column += fprintf( file, " %s", name );
 761             free( name );
 762             name = strmake( "%s_s.c", obj );
 763             if (find_src_file( name )) *column += fprintf( file, " %s", name );
 764             free( name );
 765
 766             *column += fprintf( file, ": %s", pFile->filename );
 767         }
 768         else
 769         {
 770             *column += fprintf( file, "%s.o: %s", obj, pFile->filename );
 771         }
 772     }
 773     free( obj );
 774 }
 775
 776
 777 /*******************************************************************
 778  *         output_dependencies
 779  */
 780 static void output_dependencies(void)
 781 {
 782     INCL_FILE *pFile;
 783     int i, column;
 784     FILE *file = NULL;
 785     char *buffer;
 786
 787     if (Separator && ((file = fopen( OutputFileName, "r+" ))))
 788     {
 789         while ((buffer = get_line( file )))
 790         {
 791             if (strncmp( buffer, Separator, strlen(Separator) )) continue;
 792             ftruncate( fileno(file), ftell(file) );
 793             fseek( file, 0L, SEEK_END );
 794             break;
 795         }
 796     }
 797     if (!file)
 798     {
 799         if (!(file = fopen( OutputFileName, Separator ? "a" : "w" )))
 800         {
 801             perror( OutputFileName );
 802             exit(1);
 803         }
 804     }
 805     LIST_FOR_EACH_ENTRY( pFile, &sources, INCL_FILE, entry )
 806     {
 807         column = 0;
 808         output_src( file, pFile, &column );
 809         for (i = 0; i < MAX_INCLUDES; i++)
 810             if (pFile->files[i]) output_include( file, pFile->files[i],
 811                                                  pFile, &column );
 812         fprintf( file, "\n" );
 813     }
 814     fclose(file);
 815 }
 816
 817
 818 /*******************************************************************
 819  *         parse_option
 820  */
 821 static void parse_option( const char *opt )
 822 {
 823     switch(opt[1])
 824     {
 825     case 'I':
 826         if (opt[2]) add_include_path( opt + 2 );
 827         break;
 828     case 'C':
 829         src_dir = opt + 2;
 830         break;
 831     case 'S':
 832         top_src_dir = opt + 2;
 833         break;
 834     case 'T':
 835         top_obj_dir = opt + 2;
 836         break;
 837     case 'f':
 838         if (opt[2]) OutputFileName = opt + 2;
 839         break;
 840     case 's':
 841         if (opt[2]) Separator = opt + 2;
 842         else Separator = NULL;
 843         break;
 844     default:
 845         fprintf( stderr, "Unknown option '%s'\n", opt );
 846         fprintf( stderr, Usage, ProgramName );
 847         exit(1);
 848     }
 849 }
 850
 851
 852 /*******************************************************************
 853  *         main
 854  */
 855 int main( int argc, char *argv[] )
 856 {
 857     INCL_FILE *pFile;
 858     INCL_PATH *path, *next;
 859     int i, j;
 860
 861     ProgramName = argv[0];
 862
 863     i = 1;
 864     while (i < argc)
 865     {
 866         if (argv[i][0] == '-')
 867         {
 868             parse_option( argv[i] );
 869             for (j = i; j < argc; j++) argv[j] = argv[j+1];
 870             argc--;
 871         }
 872         else i++;
 873     }
 874
 875     /* ignore redundant source paths */
 876     if (src_dir && !strcmp( src_dir, "." )) src_dir = NULL;
 877     if (top_src_dir && top_obj_dir && !strcmp( top_src_dir, top_obj_dir )) top_src_dir = NULL;
 878
 879     /* get rid of absolute paths that don't point into the source dir */
 880     LIST_FOR_EACH_ENTRY_SAFE( path, next, &paths, INCL_PATH, entry )
 881     {
 882         if (path->name[0] != '/') continue;
 883         if (top_src_dir)
 884         {
 885             if (!strncmp( path->name, top_src_dir, strlen(top_src_dir) )) continue;
 886             if (path->name[strlen(top_src_dir)] == '/') continue;
 887         }
 888         list_remove( &path->entry );
 889         free( path );
 890     }
 891
 892     for (i = 1; i < argc; i++)
 893     {
 894         if ((pFile = add_src_file( argv[i] ))) parse_file( pFile, 1 );
 895     }
 896     LIST_FOR_EACH_ENTRY( pFile, &includes, INCL_FILE, entry ) parse_file( pFile, 0 );
 897     output_dependencies();
 898     return 0;
 899 }