libcpp/files.c

   1 /* Part of CPP library.  File handling.
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   4    Free Software Foundation, Inc.
   5    Written by Per Bothner, 1994.
   6    Based on CCCP program by Paul Rubin, June 1986
   7    Adapted to ANSI C, Richard Stallman, Jan 1987
   8    Split out of cpplib.c, Zack Weinberg, Oct 1998
   9    Reimplemented, Neil Booth, Jul 2003
  10
  11 This program is free software; you can redistribute it and/or modify it
  12 under the terms of the GNU General Public License as published by the
  13 Free Software Foundation; either version 2, or (at your option) any
  14 later version.
  15
  16 This program is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with this program; if not, write to the Free Software
  23 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "cpplib.h"
  28 #include "internal.h"
  29 #include "mkdeps.h"
  30 #include "obstack.h"
  31 #include "hashtab.h"
  32 #include "md5.h"
  33 #include <dirent.h>
  34
  35 /* Variable length record files on VMS will have a stat size that includes
  36    record control characters that won't be included in the read size.  */
  37 #ifdef VMS
  38 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
  39 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
  40 #else
  41 # define STAT_SIZE_RELIABLE(ST) true
  42 #endif
  43
  44 #ifdef __DJGPP__
  45 #include <io.h>
  46   /* For DJGPP redirected input is opened in text mode.  */
  47 #  define set_stdin_to_binary_mode() \
  48      if (! isatty (0)) setmode (0, O_BINARY)
  49 #else
  50 #  define set_stdin_to_binary_mode() /* Nothing */
  51 #endif
  52
  53 /* This structure represents a file searched for by CPP, whether it
  54    exists or not.  An instance may be pointed to by more than one
  55    file_hash_entry; at present no reference count is kept.  */
  56 struct _cpp_file
  57 {
  58   /* Filename as given to #include or command line switch.  */
  59   const char *name;
  60
  61   /* The full path used to find the file.  */
  62   const char *path;
  63
  64   /* The full path of the pch file.  */
  65   const char *pchname;
  66
  67   /* The file's path with the basename stripped.  NULL if it hasn't
  68      been calculated yet.  */
  69   const char *dir_name;
  70
  71   /* Chain through all files.  */
  72   struct _cpp_file *next_file;
  73
  74   /* The contents of NAME after calling read_file().  */
  75   const uchar *buffer;
  76
  77   /* The macro, if any, preventing re-inclusion.  */
  78   const cpp_hashnode *cmacro;
  79
  80   /* The directory in the search path where FILE was found.  Used for
  81      #include_next and determining whether a header is a system
  82      header.  */
  83   cpp_dir *dir;
  84
  85   /* As filled in by stat(2) for the file.  */
  86   struct stat st;
  87
  88   /* File descriptor.  Invalid if -1, otherwise open.  */
  89   int fd;
  90
  91   /* Zero if this file was successfully opened and stat()-ed,
  92      otherwise errno obtained from failure.  */
  93   int err_no;
  94
  95   /* Number of times the file has been stacked for preprocessing.  */
  96   unsigned short stack_count;
  97
  98   /* If opened with #import or contains #pragma once.  */
  99   bool once_only;
 100
 101   /* If read() failed before.  */
 102   bool dont_read;
 103
 104   /* If this file is the main file.  */
 105   bool main_file;
 106
 107   /* If BUFFER above contains the true contents of the file.  */
 108   bool buffer_valid;
 109
 110   /* File is a PCH (on return from find_include_file).  */
 111   bool pch;
 112 };
 113
 114 /* A singly-linked list for all searches for a given file name, with
 115    its head pointed to by a slot in FILE_HASH.  The file name is what
 116    appeared between the quotes in a #include directive; it can be
 117    determined implicitly from the hash table location or explicitly
 118    from FILE->name.
 119
 120    FILE is a structure containing details about the file that was
 121    found with that search, or details of how the search failed.
 122
 123    START_DIR is the starting location of the search in the include
 124    chain.  The current directories for "" includes are also hashed in
 125    the hash table and therefore unique.  Files that are looked up
 126    without using a search path, such as absolute filenames and file
 127    names from the command line share a special starting directory so
 128    they don't cause cache hits with normal include-chain lookups.
 129
 130    If START_DIR is NULL then the entry is for a directory, not a file,
 131    and the directory is in DIR.  Since the starting point in a file
 132    lookup chain is never NULL, this means that simple pointer
 133    comparisons against START_DIR can be made to determine cache hits
 134    in file lookups.
 135
 136    If a cache lookup fails because of e.g. an extra "./" in the path,
 137    then nothing will break.  It is just less efficient as CPP will
 138    have to do more work re-preprocessing the file, and/or comparing
 139    its contents against earlier once-only files.
 140 */
 141 struct file_hash_entry
 142 {
 143   struct file_hash_entry *next;
 144   cpp_dir *start_dir;
 145   source_location location;
 146   union
 147   {
 148     _cpp_file *file;
 149     cpp_dir *dir;
 150   } u;
 151 };
 152
 153 /* Number of entries to put in a file_hash_entry pool.  */
 154 #define FILE_HASH_POOL_SIZE 127
 155
 156 /* A file hash entry pool.  We allocate file_hash_entry object from
 157    one of these.  */
 158 struct file_hash_entry_pool
 159 {
 160   /* Number of entries used from this pool.  */
 161   unsigned int file_hash_entries_used;
 162   /* Next pool in the chain; used when freeing.  */
 163   struct file_hash_entry_pool *next;
 164   /* The memory pool.  */
 165   struct file_hash_entry pool[FILE_HASH_POOL_SIZE];
 166 };
 167
 168 static bool open_file (_cpp_file *file);
 169 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
 170                            bool *invalid_pch);
 171 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
 172                               bool *invalid_pch);
 173 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
 174 static bool read_file (cpp_reader *pfile, _cpp_file *file);
 175 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
 176 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
 177                                  int angle_brackets, enum include_type);
 178 static const char *dir_name_of_file (_cpp_file *file);
 179 static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int);
 180 static struct file_hash_entry *search_cache (struct file_hash_entry *head,
 181                                              const cpp_dir *start_dir);
 182 static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
 183 static void destroy_cpp_file (_cpp_file *);
 184 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
 185 static void allocate_file_hash_entries (cpp_reader *pfile);
 186 static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
 187 static int report_missing_guard (void **slot, void *b);
 188 static hashval_t file_hash_hash (const void *p);
 189 static int file_hash_eq (const void *p, const void *q);
 190 static char *read_filename_string (int ch, FILE *f);
 191 static void read_name_map (cpp_dir *dir);
 192 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
 193 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
 194 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
 195 static int pchf_save_compare (const void *e1, const void *e2);
 196 static int pchf_compare (const void *d_p, const void *e_p);
 197 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
 198
 199 /* Given a filename in FILE->PATH, with the empty string interpreted
 200    as <stdin>, open it.
 201
 202    On success FILE contains an open file descriptor and stat
 203    information for the file.  On failure the file descriptor is -1 and
 204    the appropriate errno is also stored in FILE.  Returns TRUE iff
 205    successful.
 206
 207    We used to open files in nonblocking mode, but that caused more
 208    problems than it solved.  Do take care not to acquire a controlling
 209    terminal by mistake (this can't happen on sane systems, but
 210    paranoia is a virtue).
 211
 212    Use the three-argument form of open even though we aren't
 213    specifying O_CREAT, to defend against broken system headers.
 214
 215    O_BINARY tells some runtime libraries (notably DJGPP) not to do
 216    newline translation; we can handle DOS line breaks just fine
 217    ourselves.  */
 218 static bool
 219 open_file (_cpp_file *file)
 220 {
 221   if (file->path[0] == '\0')
 222     {
 223       file->fd = 0;
 224       set_stdin_to_binary_mode ();
 225     }
 226   else
 227     file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
 228
 229   if (file->fd != -1)
 230     {
 231       if (fstat (file->fd, &file->st) == 0)
 232         {
 233           if (!S_ISDIR (file->st.st_mode))
 234             {
 235               file->err_no = 0;
 236               return true;
 237             }
 238
 239           /* Ignore a directory and continue the search.  The file we're
 240              looking for may be elsewhere in the search path.  */
 241           errno = ENOENT;
 242         }
 243
 244       close (file->fd);
 245       file->fd = -1;
 246     }
 247 #if defined(_WIN32) && !defined(__CYGWIN__)
 248   else if (errno == EACCES)
 249     {
 250       /* On most UNIX systems, open succeeds on a directory.  Above,
 251          we check if we have opened a directory and if so, set errno
 252          to ENOENT.  However, on Windows, opening a directory
 253          fails with EACCES.  We want to return ENOENT in that
 254          case too.  */
 255       if (stat (file->path, &file->st) == 0
 256           && S_ISDIR (file->st.st_mode))
 257         errno = ENOENT;
 258       else
 259         /* The call to stat may have reset errno.  */
 260         errno = EACCES;
 261     }
 262 #endif
 263   else if (errno == ENOTDIR)
 264     errno = ENOENT;
 265
 266   file->err_no = errno;
 267
 268   return false;
 269 }
 270
 271 /* Temporary PCH intercept of opening a file.  Try to find a PCH file
 272    based on FILE->name and FILE->dir, and test those found for
 273    validity using PFILE->cb.valid_pch.  Return true iff a valid file is
 274    found.  Set *INVALID_PCH if a PCH file is found but wasn't valid.  */
 275
 276 static bool
 277 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
 278 {
 279   static const char extension[] = ".gch";
 280   const char *path = file->path;
 281   size_t len, flen;
 282   char *pchname;
 283   struct stat st;
 284   bool valid = false;
 285
 286   /* No PCH on <stdin> or if not requested.  */
 287   if (file->name[0] == '\0' || !pfile->cb.valid_pch)
 288     return false;
 289
 290   flen = strlen (path);
 291   len = flen + sizeof (extension);
 292   pchname = XNEWVEC (char, len);
 293   memcpy (pchname, path, flen);
 294   memcpy (pchname + flen, extension, sizeof (extension));
 295
 296   if (stat (pchname, &st) == 0)
 297     {
 298       DIR *pchdir;
 299       struct dirent *d;
 300       size_t dlen, plen = len;
 301
 302       if (!S_ISDIR (st.st_mode))
 303         valid = validate_pch (pfile, file, pchname);
 304       else if ((pchdir = opendir (pchname)) != NULL)
 305         {
 306           pchname[plen - 1] = '/';
 307           while ((d = readdir (pchdir)) != NULL)
 308             {
 309               dlen = strlen (d->d_name) + 1;
 310               if ((strcmp (d->d_name, ".") == 0)
 311                   || (strcmp (d->d_name, "..") == 0))
 312                 continue;
 313               if (dlen + plen > len)
 314                 {
 315                   len += dlen + 64;
 316                   pchname = XRESIZEVEC (char, pchname, len);
 317                 }
 318               memcpy (pchname + plen, d->d_name, dlen);
 319               valid = validate_pch (pfile, file, pchname);
 320               if (valid)
 321                 break;
 322             }
 323           closedir (pchdir);
 324         }
 325       if (valid)
 326         file->pch = true;
 327       else
 328         *invalid_pch = true;
 329     }
 330
 331   if (valid)
 332     file->pchname = pchname;
 333   else
 334     free (pchname);
 335
 336   return valid;
 337 }
 338
 339 /* Try to open the path FILE->name appended to FILE->dir.  This is
 340    where remap and PCH intercept the file lookup process.  Return true
 341    if the file was found, whether or not the open was successful.
 342    Set *INVALID_PCH to true if a PCH file is found but wasn't valid.  */
 343
 344 static bool
 345 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
 346 {
 347   char *path;
 348
 349   if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
 350     ;
 351   else
 352     if (file->dir->construct)
 353       path = file->dir->construct (file->name, file->dir);
 354     else
 355       path = append_file_to_dir (file->name, file->dir);
 356
 357   if (path)
 358     {
 359       hashval_t hv = htab_hash_string (path);
 360       char *copy;
 361       void **pp;
 362
 363       if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
 364         {
 365           file->err_no = ENOENT;
 366           return false;
 367         }
 368
 369       file->path = path;
 370       if (pch_open_file (pfile, file, invalid_pch))
 371         return true;
 372
 373       if (open_file (file))
 374         return true;
 375
 376       if (file->err_no != ENOENT)
 377         {
 378           open_file_failed (pfile, file, 0);
 379           return true;
 380         }
 381
 382       /* We copy the path name onto an obstack partly so that we don't
 383          leak the memory, but mostly so that we don't fragment the
 384          heap.  */
 385       copy = obstack_copy0 (&pfile->nonexistent_file_ob, path,
 386                             strlen (path));
 387       free (path);
 388       pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
 389                                      copy, hv, INSERT);
 390       *pp = copy;
 391
 392       file->path = file->name;
 393     }
 394   else
 395     {
 396       file->err_no = ENOENT;
 397       file->path = NULL;
 398     }
 399
 400   return false;
 401 }
 402
 403 /* Return tue iff the missing_header callback found the given HEADER.  */
 404 static bool
 405 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
 406 {
 407   missing_header_cb func = pfile->cb.missing_header;
 408
 409   /* When the regular search path doesn't work, try context dependent
 410      headers search paths.  */
 411   if (func
 412       && file->dir == NULL)
 413     {
 414       if ((file->path = func (pfile, header, &file->dir)) != NULL)
 415         {
 416           if (open_file (file))
 417             return true;
 418           free ((void *)file->path);
 419         }
 420       file->path = file->name;
 421     }
 422
 423   return false;
 424 }
 425
 426 bool
 427 _cpp_find_failed (_cpp_file *file)
 428 {
 429   return file->err_no != 0;
 430 }
 431
 432 /* Given a filename FNAME search for such a file in the include path
 433    starting from START_DIR.  If FNAME is the empty string it is
 434    interpreted as STDIN if START_DIR is PFILE->no_search_path.
 435
 436    If the file is not found in the file cache fall back to the O/S and
 437    add the result to our cache.
 438
 439    If the file was not found in the filesystem, or there was an error
 440    opening it, then ERR_NO is nonzero and FD is -1.  If the file was
 441    found, then ERR_NO is zero and FD could be -1 or an open file
 442    descriptor.  FD can be -1 if the file was found in the cache and
 443    had previously been closed.  To open it again pass the return value
 444    to open_file().
 445 */
 446 _cpp_file *
 447 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake, int angle_brackets)
 448 {
 449   struct file_hash_entry *entry, **hash_slot;
 450   _cpp_file *file;
 451   bool invalid_pch = false;
 452   bool saw_bracket_include = false;
 453   bool saw_quote_include = false;
 454   struct cpp_dir *found_in_cache = NULL;
 455
 456   /* Ensure we get no confusion between cached files and directories.  */
 457   if (start_dir == NULL)
 458     cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
 459
 460   hash_slot = (struct file_hash_entry **)
 461     htab_find_slot_with_hash (pfile->file_hash, fname,
 462                               htab_hash_string (fname),
 463                               INSERT);
 464
 465   /* First check the cache before we resort to memory allocation.  */
 466   entry = search_cache (*hash_slot, start_dir);
 467   if (entry)
 468     return entry->u.file;
 469
 470   file = make_cpp_file (pfile, start_dir, fname);
 471
 472   /* Try each path in the include chain.  */
 473   for (; !fake ;)
 474     {
 475       if (find_file_in_dir (pfile, file, &invalid_pch))
 476         break;
 477
 478       file->dir = file->dir->next;
 479       if (file->dir == NULL)
 480         {
 481           if (search_path_exhausted (pfile, fname, file))
 482             {
 483               /* Although this file must not go in the cache, because
 484                  the file found might depend on things (like the current file)
 485                  that aren't represented in the cache, it still has to go in
 486                  the list of all files so that #import works.  */
 487               file->next_file = pfile->all_files;
 488               pfile->all_files = file;
 489               return file;
 490             }
 491
 492           open_file_failed (pfile, file, angle_brackets);
 493           if (invalid_pch)
 494             {
 495               cpp_error (pfile, CPP_DL_ERROR,
 496                "one or more PCH files were found, but they were invalid");
 497               if (!cpp_get_options (pfile)->warn_invalid_pch)
 498                 cpp_error (pfile, CPP_DL_ERROR,
 499                            "use -Winvalid-pch for more information");
 500             }
 501           break;
 502         }
 503
 504       /* Only check the cache for the starting location (done above)
 505          and the quote and bracket chain heads because there are no
 506          other possible starting points for searches.  */
 507       if (file->dir == pfile->bracket_include)
 508         saw_bracket_include = true;
 509       else if (file->dir == pfile->quote_include)
 510         saw_quote_include = true;
 511       else
 512         continue;
 513
 514       entry = search_cache (*hash_slot, file->dir);
 515       if (entry)
 516         {
 517           found_in_cache = file->dir;
 518           break;
 519         }
 520     }
 521
 522   if (entry)
 523     {
 524       /* Cache for START_DIR too, sharing the _cpp_file structure.  */
 525       free ((char *) file->name);
 526       free (file);
 527       file = entry->u.file;
 528     }
 529   else
 530     {
 531       /* This is a new file; put it in the list.  */
 532       file->next_file = pfile->all_files;
 533       pfile->all_files = file;
 534     }
 535
 536   /* Store this new result in the hash table.  */
 537   entry = new_file_hash_entry (pfile);
 538   entry->next = *hash_slot;
 539   entry->start_dir = start_dir;
 540   entry->location = pfile->line_table->highest_location;
 541   entry->u.file = file;
 542   *hash_slot = entry;
 543
 544   /* If we passed the quote or bracket chain heads, cache them also.
 545      This speeds up processing if there are lots of -I options.  */
 546   if (saw_bracket_include
 547       && pfile->bracket_include != start_dir
 548       && found_in_cache != pfile->bracket_include)
 549     {
 550       entry = new_file_hash_entry (pfile);
 551       entry->next = *hash_slot;
 552       entry->start_dir = pfile->bracket_include;
 553       entry->location = pfile->line_table->highest_location;
 554       entry->u.file = file;
 555       *hash_slot = entry;
 556     }
 557   if (saw_quote_include
 558       && pfile->quote_include != start_dir
 559       && found_in_cache != pfile->quote_include)
 560     {
 561       entry = new_file_hash_entry (pfile);
 562       entry->next = *hash_slot;
 563       entry->start_dir = pfile->quote_include;
 564       entry->location = pfile->line_table->highest_location;
 565       entry->u.file = file;
 566       *hash_slot = entry;
 567     }
 568
 569   return file;
 570 }
 571
 572 /* Read a file into FILE->buffer, returning true on success.
 573
 574    If FILE->fd is something weird, like a block device, we don't want
 575    to read it at all.  Don't even try to figure out what something is,
 576    except for plain files and block devices, since there is no
 577    reliable portable way of doing this.
 578
 579    FIXME: Flush file cache and try again if we run out of memory.  */
 580 static bool
 581 read_file_guts (cpp_reader *pfile, _cpp_file *file)
 582 {
 583   ssize_t size, total, count;
 584   uchar *buf;
 585   bool regular;
 586
 587   if (S_ISBLK (file->st.st_mode))
 588     {
 589       cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
 590       return false;
 591     }
 592
 593   regular = S_ISREG (file->st.st_mode);
 594   if (regular)
 595     {
 596       /* off_t might have a wider range than ssize_t - in other words,
 597          the max size of a file might be bigger than the address
 598          space.  We can't handle a file that large.  (Anyone with
 599          a single source file bigger than 2GB needs to rethink
 600          their coding style.)  Some systems (e.g. AIX 4.1) define
 601          SSIZE_MAX to be much smaller than the actual range of the
 602          type.  Use INTTYPE_MAXIMUM unconditionally to ensure this
 603          does not bite us.  */
 604       if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
 605         {
 606           cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
 607           return false;
 608         }
 609
 610       size = file->st.st_size;
 611     }
 612   else
 613     /* 8 kilobytes is a sensible starting size.  It ought to be bigger
 614        than the kernel pipe buffer, and it's definitely bigger than
 615        the majority of C source files.  */
 616     size = 8 * 1024;
 617
 618   buf = XNEWVEC (uchar, size + 1);
 619   total = 0;
 620   while ((count = read (file->fd, buf + total, size - total)) > 0)
 621     {
 622       total += count;
 623
 624       if (total == size)
 625         {
 626           if (regular)
 627             break;
 628           size *= 2;
 629           buf = XRESIZEVEC (uchar, buf, size + 1);
 630         }
 631     }
 632
 633   if (count < 0)
 634     {
 635       cpp_errno (pfile, CPP_DL_ERROR, file->path);
 636       return false;
 637     }
 638
 639   if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
 640     cpp_error (pfile, CPP_DL_WARNING,
 641                "%s is shorter than expected", file->path);
 642
 643   file->buffer = _cpp_convert_input (pfile, CPP_OPTION (pfile, input_charset),
 644                                      buf, size, total, &file->st.st_size);
 645   file->buffer_valid = true;
 646
 647   return true;
 648 }
 649
 650 /* Convenience wrapper around read_file_guts that opens the file if
 651    necessary and closes the file descriptor after reading.  FILE must
 652    have been passed through find_file() at some stage.  */
 653 static bool
 654 read_file (cpp_reader *pfile, _cpp_file *file)
 655 {
 656   /* If we already have its contents in memory, succeed immediately.  */
 657   if (file->buffer_valid)
 658     return true;
 659
 660   /* If an earlier read failed for some reason don't try again.  */
 661   if (file->dont_read || file->err_no)
 662     return false;
 663
 664   if (file->fd == -1 && !open_file (file))
 665     {
 666       open_file_failed (pfile, file, 0);
 667       return false;
 668     }
 669
 670   file->dont_read = !read_file_guts (pfile, file);
 671   close (file->fd);
 672   file->fd = -1;
 673
 674   return !file->dont_read;
 675 }
 676
 677 /* Returns TRUE if FILE's contents have been successfully placed in
 678    FILE->buffer and the file should be stacked, otherwise false.  */
 679 static bool
 680 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
 681 {
 682   _cpp_file *f;
 683
 684   /* Skip once-only files.  */
 685   if (file->once_only)
 686     return false;
 687
 688   /* We must mark the file once-only if #import now, before header
 689      guard checks.  Otherwise, undefining the header guard might
 690      cause the file to be re-stacked.  */
 691   if (import)
 692     {
 693       _cpp_mark_file_once_only (pfile, file);
 694
 695       /* Don't stack files that have been stacked before.  */
 696       if (file->stack_count)
 697         return false;
 698     }
 699
 700   /* Skip if the file had a header guard and the macro is defined.
 701      PCH relies on this appearing before the PCH handler below.  */
 702   if (file->cmacro && file->cmacro->type == NT_MACRO)
 703     return false;
 704
 705   /* Handle PCH files immediately; don't stack them.  */
 706   if (file->pch)
 707     {
 708       pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
 709       close (file->fd);
 710       file->fd = -1;
 711       return false;
 712     }
 713
 714   if (!read_file (pfile, file))
 715     return false;
 716
 717   /* Check the file against the PCH file.  This is done before
 718      checking against files we've already seen, since it may save on
 719      I/O.  */
 720   if (check_file_against_entries (pfile, file, import))
 721     {
 722       /* If this isn't a #import, but yet we can't include the file,
 723          that means that it was #import-ed in the PCH file,
 724          so we can never include it again.  */
 725       if (! import)
 726         _cpp_mark_file_once_only (pfile, file);
 727       return false;
 728     }
 729
 730   /* Now we've read the file's contents, we can stack it if there
 731      are no once-only files.  */
 732   if (!pfile->seen_once_only)
 733     return true;
 734
 735   /* We may have read the file under a different name.  Look
 736      for likely candidates and compare file contents to be sure.  */
 737   for (f = pfile->all_files; f; f = f->next_file)
 738     {
 739       if (f == file)
 740         continue;
 741
 742       if ((import || f->once_only)
 743           && f->err_no == 0
 744           && f->st.st_mtime == file->st.st_mtime
 745           && f->st.st_size == file->st.st_size)
 746         {
 747           _cpp_file *ref_file;
 748           bool same_file_p = false;
 749
 750           if (f->buffer && !f->buffer_valid)
 751             {
 752               /* We already have a buffer but it is not valid, because
 753                  the file is still stacked.  Make a new one.  */
 754               ref_file = make_cpp_file (pfile, f->dir, f->name);
 755               ref_file->path = f->path;
 756             }
 757           else
 758             /* The file is not stacked anymore.  We can reuse it.  */
 759             ref_file = f;
 760
 761           same_file_p = read_file (pfile, ref_file)
 762                         /* Size might have changed in read_file().  */
 763                         && ref_file->st.st_size == file->st.st_size
 764                         && !memcmp (ref_file->buffer,
 765                                     file->buffer,
 766                                     file->st.st_size);
 767
 768           if (f->buffer && !f->buffer_valid)
 769             {
 770               ref_file->path = 0;
 771               destroy_cpp_file (ref_file);
 772             }
 773
 774           if (same_file_p)
 775             break;
 776         }
 777     }
 778
 779   return f == NULL;
 780 }
 781
 782 /* Place the file referenced by FILE into a new buffer on the buffer
 783    stack if possible.  IMPORT is true if this stacking attempt is
 784    because of a #import directive.  Returns true if a buffer is
 785    stacked.  */
 786 bool
 787 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
 788 {
 789   cpp_buffer *buffer;
 790   int sysp;
 791
 792   if (!should_stack_file (pfile, file, import))
 793       return false;
 794
 795   if (pfile->buffer == NULL || file->dir == NULL)
 796     sysp = 0;
 797   else
 798     sysp = MAX (pfile->buffer->sysp,  file->dir->sysp);
 799
 800   /* Add the file to the dependencies on its first inclusion.  */
 801   if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
 802     {
 803       if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
 804         deps_add_dep (pfile->deps, file->path);
 805     }
 806
 807   /* Clear buffer_valid since _cpp_clean_line messes it up.  */
 808   file->buffer_valid = false;
 809   file->stack_count++;
 810
 811   /* Stack the buffer.  */
 812   buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
 813                             CPP_OPTION (pfile, preprocessed)
 814                             && !CPP_OPTION (pfile, directives_only));
 815   buffer->file = file;
 816   buffer->sysp = sysp;
 817
 818   /* Initialize controlling macro state.  */
 819   pfile->mi_valid = true;
 820   pfile->mi_cmacro = 0;
 821
 822   /* Generate the call back.  */
 823   _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
 824
 825   return true;
 826 }
 827
 828 /* Mark FILE to be included once only.  */
 829 void
 830 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
 831 {
 832   pfile->seen_once_only = true;
 833   file->once_only = true;
 834 }
 835
 836 /* Return the directory from which searching for FNAME should start,
 837    considering the directive TYPE and ANGLE_BRACKETS.  If there is
 838    nothing left in the path, returns NULL.  */
 839 static struct cpp_dir *
 840 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
 841                   enum include_type type)
 842 {
 843   cpp_dir *dir;
 844   _cpp_file *file;
 845
 846   if (IS_ABSOLUTE_PATH (fname))
 847     return &pfile->no_search_path;
 848
 849   /* pfile->buffer is NULL when processing an -include command-line flag.  */
 850   file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
 851
 852   /* For #include_next, skip in the search path past the dir in which
 853      the current file was found, but if it was found via an absolute
 854      path use the normal search logic.  */
 855   if (type == IT_INCLUDE_NEXT && file->dir
 856       && file->dir != &pfile->no_search_path)
 857     dir = file->dir->next;
 858   else if (angle_brackets)
 859     dir = pfile->bracket_include;
 860   else if (type == IT_CMDLINE)
 861     /* -include and -imacros use the #include "" chain with the
 862        preprocessor's cwd prepended.  */
 863     return make_cpp_dir (pfile, "./", false);
 864   else if (pfile->quote_ignores_source_dir)
 865     dir = pfile->quote_include;
 866   else
 867     return make_cpp_dir (pfile, dir_name_of_file (file),
 868                          pfile->buffer ? pfile->buffer->sysp : 0);
 869
 870   if (dir == NULL)
 871     cpp_error (pfile, CPP_DL_ERROR,
 872                "no include path in which to search for %s", fname);
 873
 874   return dir;
 875 }
 876
 877 /* Strip the basename from the file's path.  It ends with a slash if
 878    of nonzero length.  Note that this procedure also works for
 879    <stdin>, which is represented by the empty string.  */
 880 static const char *
 881 dir_name_of_file (_cpp_file *file)
 882 {
 883   if (!file->dir_name)
 884     {
 885       size_t len = lbasename (file->path) - file->path;
 886       char *dir_name = XNEWVEC (char, len + 1);
 887
 888       memcpy (dir_name, file->path, len);
 889       dir_name[len] = '\0';
 890       file->dir_name = dir_name;
 891     }
 892
 893   return file->dir_name;
 894 }
 895
 896 /* Handles #include-family directives (distinguished by TYPE),
 897    including HEADER, and the command line -imacros and -include.
 898    Returns true if a buffer was stacked.  */
 899 bool
 900 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
 901                     enum include_type type)
 902 {
 903   struct cpp_dir *dir;
 904   _cpp_file *file;
 905
 906   dir = search_path_head (pfile, fname, angle_brackets, type);
 907   if (!dir)
 908     return false;
 909
 910   file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
 911
 912   /* Compensate for the increment in linemap_add.  In the case of a
 913      normal #include, we're currently at the start of the line
 914      *following* the #include.  A separate source_location for this
 915      location makes no sense (until we do the LC_LEAVE), and
 916      complicates LAST_SOURCE_LINE_LOCATION.  This does not apply if we
 917      found a PCH file (in which case linemap_add is not called) or we
 918      were included from the command-line.  */
 919   if (! file->pch && file->err_no == 0 && type != IT_CMDLINE)
 920     pfile->line_table->highest_location--;
 921
 922   return _cpp_stack_file (pfile, file, type == IT_IMPORT);
 923 }
 924
 925 /* Could not open FILE.  The complication is dependency output.  */
 926 static void
 927 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
 928 {
 929   int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
 930   bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
 931
 932   errno = file->err_no;
 933   if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
 934     deps_add_dep (pfile->deps, file->name);
 935   else
 936     {
 937       /* If we are outputting dependencies but not for this file then
 938          don't error because we can still produce correct output.  */
 939       if (CPP_OPTION (pfile, deps.style) && ! print_dep)
 940         cpp_errno (pfile, CPP_DL_WARNING, file->path);
 941       else
 942         cpp_errno (pfile, CPP_DL_ERROR, file->path);
 943     }
 944 }
 945
 946 /* Search in the chain beginning at HEAD for a file whose search path
 947    started at START_DIR != NULL.  */
 948 static struct file_hash_entry *
 949 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
 950 {
 951   while (head && head->start_dir != start_dir)
 952     head = head->next;
 953
 954   return head;
 955 }
 956
 957 /* Allocate a new _cpp_file structure.  */
 958 static _cpp_file *
 959 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
 960 {
 961   _cpp_file *file;
 962
 963   file = XCNEW (_cpp_file);
 964   file->main_file = !pfile->buffer;
 965   file->fd = -1;
 966   file->dir = dir;
 967   file->name = xstrdup (fname);
 968
 969   return file;
 970 }
 971
 972 /* Release a _cpp_file structure.  */
 973 static void
 974 destroy_cpp_file (_cpp_file *file)
 975 {
 976   if (file->buffer)
 977     free ((void *) file->buffer);
 978   free ((void *) file->name);
 979   free (file);
 980 }
 981
 982 /* Release all the files allocated by this reader.  */
 983 static void
 984 destroy_all_cpp_files (cpp_reader *pfile)
 985 {
 986   _cpp_file *iter = pfile->all_files;
 987   while (iter)
 988     {
 989       _cpp_file *next = iter->next_file;
 990       destroy_cpp_file (iter);
 991       iter = next;
 992     }
 993 }
 994
 995 /* A hash of directory names.  The directory names are the path names
 996    of files which contain a #include "", the included file name is
 997    appended to this directories.
 998
 999    To avoid duplicate entries we follow the convention that all
1000    non-empty directory names should end in a '/'.  DIR_NAME must be
1001    stored in permanently allocated memory.  */
1002 static cpp_dir *
1003 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1004 {
1005   struct file_hash_entry *entry, **hash_slot;
1006   cpp_dir *dir;
1007
1008   hash_slot = (struct file_hash_entry **)
1009     htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1010                               htab_hash_string (dir_name),
1011                               INSERT);
1012
1013   /* Have we already hashed this directory?  */
1014   for (entry = *hash_slot; entry; entry = entry->next)
1015     if (entry->start_dir == NULL)
1016       return entry->u.dir;
1017
1018   dir = XCNEW (cpp_dir);
1019   dir->next = pfile->quote_include;
1020   dir->name = (char *) dir_name;
1021   dir->len = strlen (dir_name);
1022   dir->sysp = sysp;
1023   dir->construct = 0;
1024
1025   /* Store this new result in the hash table.  */
1026   entry = new_file_hash_entry (pfile);
1027   entry->next = *hash_slot;
1028   entry->start_dir = NULL;
1029   entry->location = pfile->line_table->highest_location;
1030   entry->u.dir = dir;
1031   *hash_slot = entry;
1032
1033   return dir;
1034 }
1035
1036 /* Create a new block of memory for file hash entries.  */
1037 static void
1038 allocate_file_hash_entries (cpp_reader *pfile)
1039 {
1040   struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1041   pool->file_hash_entries_used = 0;
1042   pool->next = pfile->file_hash_entries;
1043   pfile->file_hash_entries = pool;
1044 }
1045
1046 /* Return a new file hash entry.  */
1047 static struct file_hash_entry *
1048 new_file_hash_entry (cpp_reader *pfile)
1049 {
1050   unsigned int idx;
1051   if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1052     allocate_file_hash_entries (pfile);
1053
1054   idx = pfile->file_hash_entries->file_hash_entries_used++;
1055   return &pfile->file_hash_entries->pool[idx];
1056 }
1057
1058 /* Free the file hash entry pools.  */
1059 static void
1060 free_file_hash_entries (cpp_reader *pfile)
1061 {
1062   struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1063   while (iter)
1064     {
1065       struct file_hash_entry_pool *next = iter->next;
1066       free (iter);
1067       iter = next;
1068     }
1069 }
1070
1071 /* Returns TRUE if a file FNAME has ever been successfully opened.
1072    This routine is not intended to correctly handle filenames aliased
1073    by links or redundant . or .. traversals etc.  */
1074 bool
1075 cpp_included (cpp_reader *pfile, const char *fname)
1076 {
1077   struct file_hash_entry *entry;
1078
1079   entry = (struct file_hash_entry *)
1080      htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1081
1082   while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1083     entry = entry->next;
1084
1085   return entry != NULL;
1086 }
1087
1088 /* Returns TRUE if a file FNAME has ever been successfully opened
1089    before LOCATION.  This routine is not intended to correctly handle
1090    filenames aliased by links or redundant . or .. traversals etc.  */
1091 bool
1092 cpp_included_before (cpp_reader *pfile, const char *fname,
1093                      source_location location)
1094 {
1095   struct file_hash_entry *entry;
1096
1097   entry = (struct file_hash_entry *)
1098      htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1099
1100   while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1101                    || entry->location > location))
1102     entry = entry->next;
1103
1104   return entry != NULL;
1105 }
1106
1107 /* Calculate the hash value of a file hash entry P.  */
1108
1109 static hashval_t
1110 file_hash_hash (const void *p)
1111 {
1112   struct file_hash_entry *entry = (struct file_hash_entry *) p;
1113   const char *hname;
1114   if (entry->start_dir)
1115     hname = entry->u.file->name;
1116   else
1117     hname = entry->u.dir->name;
1118
1119   return htab_hash_string (hname);
1120 }
1121
1122 /* Compare a string Q against a file hash entry P.  */
1123 static int
1124 file_hash_eq (const void *p, const void *q)
1125 {
1126   struct file_hash_entry *entry = (struct file_hash_entry *) p;
1127   const char *fname = (const char *) q;
1128   const char *hname;
1129
1130   if (entry->start_dir)
1131     hname = entry->u.file->name;
1132   else
1133     hname = entry->u.dir->name;
1134
1135   return strcmp (hname, fname) == 0;
1136 }
1137
1138 /* Compare entries in the nonexistent file hash table.  These are just
1139    strings.  */
1140 static int
1141 nonexistent_file_hash_eq (const void *p, const void *q)
1142 {
1143   return strcmp (p, q) == 0;
1144 }
1145
1146 /* Initialize everything in this source file.  */
1147 void
1148 _cpp_init_files (cpp_reader *pfile)
1149 {
1150   pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1151                                         NULL, xcalloc, free);
1152   pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1153                                         NULL, xcalloc, free);
1154   allocate_file_hash_entries (pfile);
1155   pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1156                                                     nonexistent_file_hash_eq,
1157                                                     NULL, xcalloc, free);
1158   _obstack_begin (&pfile->nonexistent_file_ob, 0, 0,
1159                   (void *(*) (long)) xmalloc,
1160                   (void (*) (void *)) free);
1161 }
1162
1163 /* Finalize everything in this source file.  */
1164 void
1165 _cpp_cleanup_files (cpp_reader *pfile)
1166 {
1167   htab_delete (pfile->file_hash);
1168   htab_delete (pfile->dir_hash);
1169   htab_delete (pfile->nonexistent_file_hash);
1170   obstack_free (&pfile->nonexistent_file_ob, 0);
1171   free_file_hash_entries (pfile);
1172   destroy_all_cpp_files (pfile);
1173 }
1174
1175 /* Make the parser forget about files it has seen.  This can be useful
1176    for resetting the parser to start another run.  */
1177 void
1178 cpp_clear_file_cache (cpp_reader *pfile)
1179 {
1180   _cpp_cleanup_files (pfile);
1181   pfile->file_hash_entries = NULL;
1182   pfile->all_files = NULL;
1183   _cpp_init_files (pfile);
1184 }
1185
1186 /* Enter a file name in the hash for the sake of cpp_included.  */
1187 void
1188 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1189 {
1190   _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
1191 }
1192
1193 /* Not everyone who wants to set system-header-ness on a buffer can
1194    see the details of a buffer.  This is an exported interface because
1195    fix-header needs it.  */
1196 void
1197 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1198 {
1199   int flags = 0;
1200   const struct line_maps *line_table = pfile->line_table;
1201   const struct line_map *map = &line_table->maps[line_table->used-1];
1202
1203   /* 1 = system header, 2 = system header to be treated as C.  */
1204   if (syshdr)
1205     flags = 1 + (externc != 0);
1206   pfile->buffer->sysp = flags;
1207   _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
1208                        SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1209 }
1210
1211 /* Allow the client to change the current file.  Used by the front end
1212    to achieve pseudo-file names like <built-in>.
1213    If REASON is LC_LEAVE, then NEW_NAME must be NULL.  */
1214 void
1215 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1216                  const char *new_name)
1217 {
1218   _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1219 }
1220
1221 /* Callback function for htab_traverse.  */
1222 static int
1223 report_missing_guard (void **slot, void *b)
1224 {
1225   struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1226   int *bannerp = (int *) b;
1227
1228   /* Skip directories.  */
1229   if (entry->start_dir != NULL)
1230     {
1231       _cpp_file *file = entry->u.file;
1232
1233       /* We don't want MI guard advice for the main file.  */
1234       if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1235         {
1236           if (*bannerp == 0)
1237             {
1238               fputs (_("Multiple include guards may be useful for:\n"),
1239                      stderr);
1240               *bannerp = 1;
1241             }
1242
1243           fputs (entry->u.file->path, stderr);
1244           putc ('\n', stderr);
1245         }
1246     }
1247
1248   return 0;
1249 }
1250
1251 /* Report on all files that might benefit from a multiple include guard.
1252    Triggered by -H.  */
1253 void
1254 _cpp_report_missing_guards (cpp_reader *pfile)
1255 {
1256   int banner = 0;
1257
1258   htab_traverse (pfile->file_hash, report_missing_guard, &banner);
1259 }
1260
1261 /* Locate HEADER, and determine whether it is newer than the current
1262    file.  If it cannot be located or dated, return -1, if it is
1263    newer, return 1, otherwise 0.  */
1264 int
1265 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1266                         int angle_brackets)
1267 {
1268   _cpp_file *file;
1269   struct cpp_dir *dir;
1270
1271   dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1272   if (!dir)
1273     return -1;
1274
1275   file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1276   if (file->err_no)
1277     return -1;
1278
1279   if (file->fd != -1)
1280     {
1281       close (file->fd);
1282       file->fd = -1;
1283     }
1284
1285   return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1286 }
1287
1288 /* Pushes the given file onto the buffer stack.  Returns nonzero if
1289    successful.  */
1290 bool
1291 cpp_push_include (cpp_reader *pfile, const char *fname)
1292 {
1293   return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1294 }
1295
1296 /* Do appropriate cleanup when a file INC's buffer is popped off the
1297    input stack.  */
1298 void
1299 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1300 {
1301   /* Record the inclusion-preventing macro, which could be NULL
1302      meaning no controlling macro.  */
1303   if (pfile->mi_valid && file->cmacro == NULL)
1304     file->cmacro = pfile->mi_cmacro;
1305
1306   /* Invalidate control macros in the #including file.  */
1307   pfile->mi_valid = false;
1308
1309   if (file->buffer)
1310     {
1311       free ((void *) file->buffer);
1312       file->buffer = NULL;
1313       file->buffer_valid = false;
1314     }
1315 }
1316
1317 /* Inteface to file statistics record in _cpp_file structure. */
1318 struct stat *
1319 _cpp_get_file_stat (_cpp_file *file)
1320 {
1321     return &file->st;
1322 }
1323
1324 /* Set the include chain for "" to QUOTE, for <> to BRACKET.  If
1325    QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1326    directory of the including file.
1327
1328    If BRACKET does not lie in the QUOTE chain, it is set to QUOTE.  */
1329 void
1330 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1331                         int quote_ignores_source_dir)
1332 {
1333   pfile->quote_include = quote;
1334   pfile->bracket_include = quote;
1335   pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1336
1337   for (; quote; quote = quote->next)
1338     {
1339       quote->name_map = NULL;
1340       quote->len = strlen (quote->name);
1341       if (quote == bracket)
1342         pfile->bracket_include = bracket;
1343     }
1344 }
1345
1346 /* Append the file name to the directory to create the path, but don't
1347    turn / into // or // into ///; // may be a namespace escape.  */
1348 static char *
1349 append_file_to_dir (const char *fname, cpp_dir *dir)
1350 {
1351   size_t dlen, flen;
1352   char *path;
1353
1354   dlen = dir->len;
1355   flen = strlen (fname);
1356   path = XNEWVEC (char, dlen + 1 + flen + 1);
1357   memcpy (path, dir->name, dlen);
1358   if (dlen && path[dlen - 1] != '/')
1359     path[dlen++] = '/';
1360   memcpy (&path[dlen], fname, flen + 1);
1361
1362   return path;
1363 }
1364
1365 /* Read a space delimited string of unlimited length from a stdio
1366    file F.  */
1367 static char *
1368 read_filename_string (int ch, FILE *f)
1369 {
1370   char *alloc, *set;
1371   int len;
1372
1373   len = 20;
1374   set = alloc = XNEWVEC (char, len + 1);
1375   if (! is_space (ch))
1376     {
1377       *set++ = ch;
1378       while ((ch = getc (f)) != EOF && ! is_space (ch))
1379         {
1380           if (set - alloc == len)
1381             {
1382               len *= 2;
1383               alloc = XRESIZEVEC (char, alloc, len + 1);
1384               set = alloc + len / 2;
1385             }
1386           *set++ = ch;
1387         }
1388     }
1389   *set = '\0';
1390   ungetc (ch, f);
1391   return alloc;
1392 }
1393
1394 /* Read the file name map file for DIR.  */
1395 static void
1396 read_name_map (cpp_dir *dir)
1397 {
1398   static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1399   char *name;
1400   FILE *f;
1401   size_t len, count = 0, room = 9;
1402
1403   len = dir->len;
1404   name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1405   memcpy (name, dir->name, len);
1406   if (len && name[len - 1] != '/')
1407     name[len++] = '/';
1408   strcpy (name + len, FILE_NAME_MAP_FILE);
1409   f = fopen (name, "r");
1410
1411   dir->name_map = XNEWVEC (const char *, room);
1412
1413   /* Silently return NULL if we cannot open.  */
1414   if (f)
1415     {
1416       int ch;
1417
1418       while ((ch = getc (f)) != EOF)
1419         {
1420           char *to;
1421
1422           if (is_space (ch))
1423             continue;
1424
1425           if (count + 2 > room)
1426             {
1427               room += 8;
1428               dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1429             }
1430
1431           dir->name_map[count] = read_filename_string (ch, f);
1432           while ((ch = getc (f)) != EOF && is_hspace (ch))
1433             ;
1434
1435           to = read_filename_string (ch, f);
1436           if (IS_ABSOLUTE_PATH (to))
1437             dir->name_map[count + 1] = to;
1438           else
1439             {
1440               dir->name_map[count + 1] = append_file_to_dir (to, dir);
1441               free (to);
1442             }
1443
1444           count += 2;
1445           while ((ch = getc (f)) != '\n')
1446             if (ch == EOF)
1447               break;
1448         }
1449
1450       fclose (f);
1451     }
1452
1453   /* Terminate the list of maps.  */
1454   dir->name_map[count] = NULL;
1455 }
1456
1457 /* Remap a FILE's name based on the file_name_map, if any, for
1458    FILE->dir.  If the file name has any directory separators,
1459    recursively check those directories too.  */
1460 static char *
1461 remap_filename (cpp_reader *pfile, _cpp_file *file)
1462 {
1463   const char *fname, *p;
1464   char *new_dir;
1465   cpp_dir *dir;
1466   size_t index, len;
1467
1468   dir = file->dir;
1469   fname = file->name;
1470
1471   for (;;)
1472     {
1473       if (!dir->name_map)
1474         read_name_map (dir);
1475
1476       for (index = 0; dir->name_map[index]; index += 2)
1477         if (!strcmp (dir->name_map[index], fname))
1478             return xstrdup (dir->name_map[index + 1]);
1479
1480       p = strchr (fname, '/');
1481       if (!p || p == fname)
1482         return NULL;
1483
1484       len = dir->len + (p - fname + 1);
1485       new_dir = XNEWVEC (char, len + 1);
1486       memcpy (new_dir, dir->name, dir->len);
1487       memcpy (new_dir + dir->len, fname, p - fname + 1);
1488       new_dir[len] = '\0';
1489
1490       dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1491       fname = p + 1;
1492     }
1493 }
1494
1495 /* Returns true if PCHNAME is a valid PCH file for FILE.  */
1496 static bool
1497 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1498 {
1499   const char *saved_path = file->path;
1500   bool valid = false;
1501
1502   file->path = pchname;
1503   if (open_file (file))
1504     {
1505       valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1506
1507       if (!valid)
1508         {
1509           close (file->fd);
1510           file->fd = -1;
1511         }
1512
1513       if (CPP_OPTION (pfile, print_include_names))
1514         {
1515           unsigned int i;
1516           for (i = 1; i < pfile->line_table->depth; i++)
1517             putc ('.', stderr);
1518           fprintf (stderr, "%c %s\n",
1519                    valid ? '!' : 'x', pchname);
1520         }
1521     }
1522
1523   file->path = saved_path;
1524   return valid;
1525 }
1526
1527 /* Get the path associated with the _cpp_file F.  The path includes
1528    the base name from the include directive and the directory it was
1529    found in via the search path.  */
1530
1531 const char *
1532 cpp_get_path (struct _cpp_file *f)
1533 {
1534   return f->path;
1535 }
1536
1537 /* Get the directory associated with the _cpp_file F.  */
1538
1539 cpp_dir *
1540 cpp_get_dir (struct _cpp_file *f)
1541 {
1542   return f->dir;
1543 }
1544
1545 /* Get the cpp_buffer currently associated with the cpp_reader
1546    PFILE.  */
1547
1548 cpp_buffer *
1549 cpp_get_buffer (cpp_reader *pfile)
1550 {
1551   return pfile->buffer;
1552 }
1553
1554 /* Get the _cpp_file associated with the cpp_buffer B.  */
1555
1556 _cpp_file *
1557 cpp_get_file (cpp_buffer *b)
1558 {
1559   return b->file;
1560 }
1561
1562 /* Get the previous cpp_buffer given a cpp_buffer B.  The previous
1563    buffer is the buffer that included the given buffer.  */
1564
1565 cpp_buffer *
1566 cpp_get_prev (cpp_buffer *b)
1567 {
1568   return b->prev;
1569 }
1570 \f
1571 /* This data structure holds the list of header files that were seen
1572    while the PCH was being built.  The 'entries' field is kept sorted
1573    in memcmp() order; yes, this means that on little-endian systems,
1574    it's sorted initially by the least-significant byte of 'size', but
1575    that's OK.  The code does rely on having entries with the same size
1576    next to each other.  */
1577
1578 struct pchf_entry {
1579   /* The size of this file.  This is used to save running a MD5 checksum
1580      if the sizes don't match.  */
1581   off_t size;
1582   /* The MD5 checksum of this file.  */
1583   unsigned char sum[16];
1584   /* Is this file to be included only once?  */
1585   bool once_only;
1586 };
1587
1588 struct pchf_data {
1589   /* Number of pchf_entry structures.  */
1590   size_t count;
1591
1592   /* Are there any values with once_only set?
1593      This is used as an optimisation, it means we don't have to search
1594      the structure if we're processing a regular #include.  */
1595   bool have_once_only;
1596
1597   struct pchf_entry entries[1];
1598 };
1599
1600 static struct pchf_data *pchf;
1601
1602 /* A qsort ordering function for pchf_entry structures.  */
1603
1604 static int
1605 pchf_save_compare (const void *e1, const void *e2)
1606 {
1607   return memcmp (e1, e2, sizeof (struct pchf_entry));
1608 }
1609
1610 /* Create and write to F a pchf_data structure.  */
1611
1612 bool
1613 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1614 {
1615   size_t count = 0;
1616   struct pchf_data *result;
1617   size_t result_size;
1618   _cpp_file *f;
1619
1620   for (f = pfile->all_files; f; f = f->next_file)
1621     ++count;
1622
1623   result_size = (sizeof (struct pchf_data)
1624                  + sizeof (struct pchf_entry) * (count - 1));
1625   result = XCNEWVAR (struct pchf_data, result_size);
1626
1627   result->count = 0;
1628   result->have_once_only = false;
1629
1630   for (f = pfile->all_files; f; f = f->next_file)
1631     {
1632       size_t count;
1633
1634       /* This should probably never happen, since if a read error occurred
1635          the PCH file shouldn't be written...  */
1636       if (f->dont_read || f->err_no)
1637         continue;
1638
1639       if (f->stack_count == 0)
1640         continue;
1641
1642       count = result->count++;
1643
1644       result->entries[count].once_only = f->once_only;
1645       /* |= is avoided in the next line because of an HP C compiler bug */
1646       result->have_once_only = result->have_once_only | f->once_only;
1647       if (f->buffer_valid)
1648         md5_buffer ((const char *)f->buffer,
1649                     f->st.st_size, result->entries[count].sum);
1650       else
1651         {
1652           FILE *ff;
1653           int oldfd = f->fd;
1654
1655           if (!open_file (f))
1656             {
1657               open_file_failed (pfile, f, 0);
1658               return false;
1659             }
1660           ff = fdopen (f->fd, "rb");
1661           md5_stream (ff, result->entries[count].sum);
1662           fclose (ff);
1663           f->fd = oldfd;
1664         }
1665       result->entries[count].size = f->st.st_size;
1666     }
1667
1668   result_size = (sizeof (struct pchf_data)
1669                  + sizeof (struct pchf_entry) * (result->count - 1));
1670
1671   qsort (result->entries, result->count, sizeof (struct pchf_entry),
1672          pchf_save_compare);
1673
1674   return fwrite (result, result_size, 1, fp) == 1;
1675 }
1676
1677 /* Read the pchf_data structure from F.  */
1678
1679 bool
1680 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1681 {
1682   struct pchf_data d;
1683
1684   if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1685        != 1)
1686     return false;
1687
1688   pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1689                   + sizeof (struct pchf_entry) * (d.count - 1));
1690   memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1691   if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1692       != d.count)
1693     return false;
1694   return true;
1695 }
1696
1697 /* The parameters for pchf_compare.  */
1698
1699 struct pchf_compare_data
1700 {
1701   /* The size of the file we're looking for.  */
1702   off_t size;
1703
1704   /* The MD5 checksum of the file, if it's been computed.  */
1705   unsigned char sum[16];
1706
1707   /* Is SUM valid?  */
1708   bool sum_computed;
1709
1710   /* Do we need to worry about entries that don't have ONCE_ONLY set?  */
1711   bool check_included;
1712
1713   /* The file that we're searching for.  */
1714   _cpp_file *f;
1715 };
1716
1717 /* bsearch comparison function; look for D_P in E_P.  */
1718
1719 static int
1720 pchf_compare (const void *d_p, const void *e_p)
1721 {
1722   const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1723   struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1724   int result;
1725
1726   result = memcmp (&d->size, &e->size, sizeof (off_t));
1727   if (result != 0)
1728     return result;
1729
1730   if (! d->sum_computed)
1731     {
1732       _cpp_file *const f = d->f;
1733
1734       md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1735       d->sum_computed = true;
1736     }
1737
1738   result = memcmp (d->sum, e->sum, 16);
1739   if (result != 0)
1740     return result;
1741
1742   if (d->check_included || e->once_only)
1743     return 0;
1744   else
1745     return 1;
1746 }
1747
1748 /* Check that F is not in a list read from a PCH file (if any).
1749    Assumes that f->buffer_valid is true.  Return TRUE if the file
1750    should not be read.  */
1751
1752 static bool
1753 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1754                             _cpp_file *f,
1755                             bool check_included)
1756 {
1757   struct pchf_compare_data d;
1758
1759   if (pchf == NULL
1760       || (! check_included && ! pchf->have_once_only))
1761     return false;
1762
1763   d.size = f->st.st_size;
1764   d.sum_computed = false;
1765   d.f = f;
1766   d.check_included = check_included;
1767   return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1768                   pchf_compare) != NULL;
1769 }