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