gcc/cppfiles.c

   1 /* Part of CPP library.  (include file handling)
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
   3    1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   4    Written by Per Bothner, 1994.
   5    Based on CCCP program by Paul Rubin, June 1986
   6    Adapted to ANSI C, Richard Stallman, Jan 1987
   7    Split out of cpplib.c, Zack Weinberg, Oct 1998
   8
   9 This program is free software; you can redistribute it and/or modify it
  10 under the terms of the GNU General Public License as published by the
  11 Free Software Foundation; either version 2, or (at your option) any
  12 later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "cpplib.h"
  26 #include "cpphash.h"
  27 #include "intl.h"
  28 #include "mkdeps.h"
  29 #include "splay-tree.h"
  30
  31 #ifdef HAVE_MMAP_FILE
  32 # include <sys/mman.h>
  33 # ifndef MMAP_THRESHOLD
  34 #  define MMAP_THRESHOLD 3 /* Minimum page count to mmap the file.  */
  35 # endif
  36 # if MMAP_THRESHOLD
  37 #  define TEST_THRESHOLD(size, pagesize) \
  38      (size / pagesize >= MMAP_THRESHOLD && (size % pagesize) != 0)
  39    /* Use mmap if the file is big enough to be worth it (controlled
  40       by MMAP_THRESHOLD) and if we can safely count on there being
  41       at least one readable NUL byte after the end of the file's
  42       contents.  This is true for all tested operating systems when
  43       the file size is not an exact multiple of the page size.  */
  44 #  ifndef __CYGWIN__
  45 #   define SHOULD_MMAP(size, pagesize) TEST_THRESHOLD (size, pagesize)
  46 #  else
  47 #   define WIN32_LEAN_AND_MEAN
  48 #   include <windows.h>
  49     /* Cygwin can't correctly emulate mmap under Windows 9x style systems so
  50        disallow use of mmap on those systems.  Windows 9x does not zero fill
  51        memory at EOF and beyond, as required.  */
  52 #   define SHOULD_MMAP(size, pagesize) ((GetVersion() & 0x80000000) \
  53                                         ? 0 : TEST_THRESHOLD (size, pagesize))
  54 #  endif
  55 # endif
  56
  57 #else  /* No MMAP_FILE */
  58 #  undef MMAP_THRESHOLD
  59 #  define MMAP_THRESHOLD 0
  60 #endif
  61
  62 #ifndef O_BINARY
  63 # define O_BINARY 0
  64 #endif
  65
  66 /* If errno is inspected immediately after a system call fails, it will be
  67    nonzero, and no error number will ever be zero.  */
  68 #ifndef ENOENT
  69 # define ENOENT 0
  70 #endif
  71 #ifndef ENOTDIR
  72 # define ENOTDIR 0
  73 #endif
  74
  75 /* Suppress warning about function macros used w/o arguments in traditional
  76    C.  It is unlikely that glibc's strcmp macro helps this file at all.  */
  77 #undef strcmp
  78
  79 /* This structure is used for the table of all includes.  */
  80 struct include_file
  81 {
  82   const char *name;             /* actual path name of file */
  83   const cpp_hashnode *cmacro;   /* macro, if any, preventing reinclusion.  */
  84   const struct search_path *foundhere;
  85                                 /* location in search path where file was
  86                                    found, for #include_next and sysp.  */
  87   const unsigned char *buffer;  /* pointer to cached file contents */
  88   struct stat st;               /* copy of stat(2) data for file */
  89   int fd;                       /* fd open on file (short term storage only) */
  90   int err_no;                   /* errno obtained if opening a file failed */
  91   unsigned short include_count; /* number of times file has been read */
  92   unsigned short refcnt;        /* number of stacked buffers using this file */
  93   unsigned char mapped;         /* file buffer is mmapped */
  94 };
  95
  96 /* Variable length record files on VMS will have a stat size that includes
  97    record control characters that won't be included in the read size.  */
  98 #ifdef VMS
  99 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
 100 # define STAT_SIZE_TOO_BIG(ST) ((ST).st_fab_rfm == FAB_C_VAR)
 101 #else
 102 # define STAT_SIZE_TOO_BIG(ST) 0
 103 #endif
 104
 105 /* The cmacro works like this: If it's NULL, the file is to be
 106    included again.  If it's NEVER_REREAD, the file is never to be
 107    included again.  Otherwise it is a macro hashnode, and the file is
 108    to be included again if the macro is defined.  */
 109 #define NEVER_REREAD ((const cpp_hashnode *)-1)
 110 #define DO_NOT_REREAD(inc) \
 111 ((inc)->cmacro && ((inc)->cmacro == NEVER_REREAD \
 112                    || (inc)->cmacro->type == NT_MACRO))
 113 #define NO_INCLUDE_PATH ((struct include_file *) -1)
 114
 115 static struct file_name_map *read_name_map
 116                                 PARAMS ((cpp_reader *, const char *));
 117 static char *read_filename_string PARAMS ((int, FILE *));
 118 static char *remap_filename     PARAMS ((cpp_reader *, char *,
 119                                          struct search_path *));
 120 static struct search_path *search_from PARAMS ((cpp_reader *,
 121                                                 enum include_type));
 122 static struct include_file *
 123         find_include_file PARAMS ((cpp_reader *, const cpp_token *,
 124                                    enum include_type));
 125 static struct include_file *open_file PARAMS ((cpp_reader *, const char *));
 126 static int read_include_file    PARAMS ((cpp_reader *, struct include_file *));
 127 static bool stack_include_file  PARAMS ((cpp_reader *, struct include_file *));
 128 static void purge_cache         PARAMS ((struct include_file *));
 129 static void destroy_node        PARAMS ((splay_tree_value));
 130 static int report_missing_guard         PARAMS ((splay_tree_node, void *));
 131 static splay_tree_node find_or_create_entry PARAMS ((cpp_reader *,
 132                                                      const char *));
 133 static void handle_missing_header PARAMS ((cpp_reader *, const char *, int));
 134 static int remove_component_p   PARAMS ((const char *));
 135
 136 /* Set up the splay tree we use to store information about all the
 137    file names seen in this compilation.  We also have entries for each
 138    file we tried to open but failed; this saves system calls since we
 139    don't try to open it again in future.
 140
 141    The key of each node is the file name, after processing by
 142    _cpp_simplify_pathname.  The path name may or may not be absolute.
 143    The path string has been malloced, as is automatically freed by
 144    registering free () as the splay tree key deletion function.
 145
 146    A node's value is a pointer to a struct include_file, and is never
 147    NULL.  */
 148 void
 149 _cpp_init_includes (pfile)
 150      cpp_reader *pfile;
 151 {
 152   pfile->all_include_files
 153     = splay_tree_new ((splay_tree_compare_fn) strcmp,
 154                       (splay_tree_delete_key_fn) free,
 155                       destroy_node);
 156 }
 157
 158 /* Tear down the splay tree.  */
 159 void
 160 _cpp_cleanup_includes (pfile)
 161      cpp_reader *pfile;
 162 {
 163   splay_tree_delete (pfile->all_include_files);
 164 }
 165
 166 /* Free a node.  The path string is automatically freed.  */
 167 static void
 168 destroy_node (v)
 169      splay_tree_value v;
 170 {
 171   struct include_file *f = (struct include_file *)v;
 172
 173   if (f)
 174     {
 175       purge_cache (f);
 176       free (f);
 177     }
 178 }
 179
 180 /* Mark a file to not be reread (e.g. #import, read failure).  */
 181 void
 182 _cpp_never_reread (file)
 183      struct include_file *file;
 184 {
 185   file->cmacro = NEVER_REREAD;
 186 }
 187
 188 /* Lookup a filename, which is simplified after making a copy, and
 189    create an entry if none exists.  errno is nonzero iff a (reported)
 190    stat() error occurred during simplification.  */
 191 static splay_tree_node
 192 find_or_create_entry (pfile, fname)
 193      cpp_reader *pfile;
 194      const char *fname;
 195 {
 196   splay_tree_node node;
 197   struct include_file *file;
 198   char *name = xstrdup (fname);
 199
 200   _cpp_simplify_pathname (name);
 201   node = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) name);
 202   if (node)
 203     free (name);
 204   else
 205     {
 206       file = xcnew (struct include_file);
 207       file->name = name;
 208       file->err_no = errno;
 209       node = splay_tree_insert (pfile->all_include_files,
 210                                 (splay_tree_key) file->name,
 211                                 (splay_tree_value) file);
 212     }
 213
 214   return node;
 215 }
 216
 217 /* Enter a file name in the splay tree, for the sake of cpp_included.  */
 218 void
 219 _cpp_fake_include (pfile, fname)
 220      cpp_reader *pfile;
 221      const char *fname;
 222 {
 223   find_or_create_entry (pfile, fname);
 224 }
 225
 226 /* Given a file name, look it up in the cache; if there is no entry,
 227    create one with a non-NULL value (regardless of success in opening
 228    the file).  If the file doesn't exist or is inaccessible, this
 229    entry is flagged so we don't attempt to open it again in the
 230    future.  If the file isn't open, open it.  The empty string is
 231    interpreted as stdin.
 232
 233    Returns an include_file structure with an open file descriptor on
 234    success, or NULL on failure.  */
 235 static struct include_file *
 236 open_file (pfile, filename)
 237      cpp_reader *pfile;
 238      const char *filename;
 239 {
 240   splay_tree_node nd = find_or_create_entry (pfile, filename);
 241   struct include_file *file = (struct include_file *) nd->value;
 242
 243   if (file->err_no)
 244     {
 245       /* Ugh.  handle_missing_header () needs errno to be set.  */
 246       errno = file->err_no;
 247       return 0;
 248     }
 249
 250   /* Don't reopen an idempotent file.  */
 251   if (DO_NOT_REREAD (file))
 252     return file;
 253
 254   /* Don't reopen one which is already loaded.  */
 255   if (file->buffer != NULL)
 256     return file;
 257
 258   /* We used to open files in nonblocking mode, but that caused more
 259      problems than it solved.  Do take care not to acquire a
 260      controlling terminal by mistake (this can't happen on sane
 261      systems, but paranoia is a virtue).
 262
 263      Use the three-argument form of open even though we aren't
 264      specifying O_CREAT, to defend against broken system headers.
 265
 266      O_BINARY tells some runtime libraries (notably DJGPP) not to do
 267      newline translation; we can handle DOS line breaks just fine
 268      ourselves.
 269
 270      Special case: the empty string is translated to stdin.  */
 271
 272   if (filename[0] == '\0')
 273     file->fd = 0;
 274   else
 275     file->fd = open (file->name, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
 276
 277   if (file->fd != -1 && fstat (file->fd, &file->st) == 0)
 278     {
 279       if (!S_ISDIR (file->st.st_mode))
 280         return file;
 281
 282       /* If it's a directory, we return null and continue the search
 283          as the file we're looking for may appear elsewhere in the
 284          search path.  */
 285       errno = ENOENT;
 286       close (file->fd);
 287       file->fd = -1;
 288     }
 289
 290   file->err_no = errno;
 291   return 0;
 292 }
 293
 294 /* Place the file referenced by INC into a new buffer on the buffer
 295    stack, unless there are errors, or the file is not re-included
 296    because of e.g. multiple-include guards.  Returns true if a buffer
 297    is stacked.  */
 298 static bool
 299 stack_include_file (pfile, inc)
 300      cpp_reader *pfile;
 301      struct include_file *inc;
 302 {
 303   cpp_buffer *fp;
 304   int sysp;
 305   const char *filename;
 306
 307   if (DO_NOT_REREAD (inc))
 308     return false;
 309
 310   sysp = MAX ((pfile->map ? pfile->map->sysp : 0),
 311               (inc->foundhere ? inc->foundhere->sysp : 0));
 312
 313   /* For -M, add the file to the dependencies on its first inclusion.  */
 314   if (CPP_OPTION (pfile, print_deps) > sysp && !inc->include_count)
 315     deps_add_dep (pfile->deps, inc->name);
 316
 317   /* Not in cache?  */
 318   if (! inc->buffer)
 319     {
 320       if (read_include_file (pfile, inc))
 321         {
 322           /* If an error occurs, do not try to read this file again.  */
 323           _cpp_never_reread (inc);
 324           return false;
 325         }
 326       /* Mark a regular, zero-length file never-reread.  We read it,
 327          NUL-terminate it, and stack it once, so preprocessing a main
 328          file of zero length does not raise an error.  */
 329       if (S_ISREG (inc->st.st_mode) && inc->st.st_size == 0)
 330         _cpp_never_reread (inc);
 331       close (inc->fd);
 332       inc->fd = -1;
 333     }
 334
 335   if (pfile->buffer)
 336     /* We don't want MI guard advice for the main file.  */
 337     inc->include_count++;
 338
 339   /* Push a buffer.  */
 340   fp = cpp_push_buffer (pfile, inc->buffer, inc->st.st_size,
 341                         /* from_stage3 */ CPP_OPTION (pfile, preprocessed), 0);
 342   fp->inc = inc;
 343   fp->inc->refcnt++;
 344
 345   /* Initialise controlling macro state.  */
 346   pfile->mi_valid = true;
 347   pfile->mi_cmacro = 0;
 348
 349   /* Generate the call back.  */
 350   filename = inc->name;
 351   if (*filename == '\0')
 352     filename = "<stdin>";
 353   _cpp_do_file_change (pfile, LC_ENTER, filename, 1, sysp);
 354
 355   return true;
 356 }
 357
 358 /* Read the file referenced by INC into the file cache.
 359
 360    If fd points to a plain file, we might be able to mmap it; we can
 361    definitely allocate the buffer all at once.  If fd is a pipe or
 362    terminal, we can't do either.  If fd is something weird, like a
 363    block device, we don't want to read it at all.
 364
 365    Unfortunately, different systems use different st.st_mode values
 366    for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
 367    zero the entire struct stat except a couple fields.  Hence we don't
 368    even try to figure out what something is, except for plain files
 369    and block devices.
 370
 371    FIXME: Flush file cache and try again if we run out of memory.  */
 372 static int
 373 read_include_file (pfile, inc)
 374      cpp_reader *pfile;
 375      struct include_file *inc;
 376 {
 377   ssize_t size, offset, count;
 378   uchar *buf;
 379 #if MMAP_THRESHOLD
 380   static int pagesize = -1;
 381 #endif
 382
 383   if (S_ISREG (inc->st.st_mode))
 384     {
 385       /* off_t might have a wider range than ssize_t - in other words,
 386          the max size of a file might be bigger than the address
 387          space.  We can't handle a file that large.  (Anyone with
 388          a single source file bigger than 2GB needs to rethink
 389          their coding style.)  Some systems (e.g. AIX 4.1) define
 390          SSIZE_MAX to be much smaller than the actual range of the
 391          type.  Use INTTYPE_MAXIMUM unconditionally to ensure this
 392          does not bite us.  */
 393       if (inc->st.st_size > INTTYPE_MAXIMUM (ssize_t))
 394         {
 395           cpp_error (pfile, DL_ERROR, "%s is too large", inc->name);
 396           goto fail;
 397         }
 398       size = inc->st.st_size;
 399
 400       inc->mapped = 0;
 401 #if MMAP_THRESHOLD
 402       if (pagesize == -1)
 403         pagesize = getpagesize ();
 404
 405       if (SHOULD_MMAP (size, pagesize))
 406         {
 407           buf = (uchar *) mmap (0, size, PROT_READ, MAP_PRIVATE, inc->fd, 0);
 408           if (buf == (uchar *)-1)
 409             goto perror_fail;
 410           inc->mapped = 1;
 411         }
 412       else
 413 #endif
 414         {
 415           buf = (uchar *) xmalloc (size + 1);
 416           offset = 0;
 417           while (offset < size)
 418             {
 419               count = read (inc->fd, buf + offset, size - offset);
 420               if (count < 0)
 421                 goto perror_fail;
 422               if (count == 0)
 423                 {
 424                   if (!STAT_SIZE_TOO_BIG (inc->st))
 425                     cpp_error (pfile, DL_WARNING,
 426                                "%s is shorter than expected", inc->name);
 427                   size = offset;
 428                   buf = xrealloc (buf, size + 1);
 429                   inc->st.st_size = size;
 430                   break;
 431                 }
 432               offset += count;
 433             }
 434           /* The lexer requires that the buffer be NUL-terminated.  */
 435           buf[size] = '\0';
 436         }
 437     }
 438   else if (S_ISBLK (inc->st.st_mode))
 439     {
 440       cpp_error (pfile, DL_ERROR, "%s is a block device", inc->name);
 441       goto fail;
 442     }
 443   else
 444     {
 445       /* 8 kilobytes is a sensible starting size.  It ought to be
 446          bigger than the kernel pipe buffer, and it's definitely
 447          bigger than the majority of C source files.  */
 448       size = 8 * 1024;
 449
 450       buf = (uchar *) xmalloc (size + 1);
 451       offset = 0;
 452       while ((count = read (inc->fd, buf + offset, size - offset)) > 0)
 453         {
 454           offset += count;
 455           if (offset == size)
 456             {
 457               size *= 2;
 458               buf = xrealloc (buf, size + 1);
 459             }
 460         }
 461       if (count < 0)
 462         goto perror_fail;
 463
 464       if (offset + 1 < size)
 465         buf = xrealloc (buf, offset + 1);
 466
 467       /* The lexer requires that the buffer be NUL-terminated.  */
 468       buf[offset] = '\0';
 469       inc->st.st_size = offset;
 470     }
 471
 472   inc->buffer = buf;
 473   return 0;
 474
 475  perror_fail:
 476   cpp_errno (pfile, DL_ERROR, inc->name);
 477  fail:
 478   return 1;
 479 }
 480
 481 /* Drop INC's buffer from memory, if we are unlikely to need it again.  */
 482 static void
 483 purge_cache (inc)
 484      struct include_file *inc;
 485 {
 486   if (inc->buffer)
 487     {
 488 #if MMAP_THRESHOLD
 489       if (inc->mapped)
 490         munmap ((PTR) inc->buffer, inc->st.st_size);
 491       else
 492 #endif
 493         free ((PTR) inc->buffer);
 494       inc->buffer = NULL;
 495     }
 496 }
 497
 498 /* Return 1 if the file named by FNAME has been included before in
 499    any context, 0 otherwise.  */
 500 int
 501 cpp_included (pfile, fname)
 502      cpp_reader *pfile;
 503      const char *fname;
 504 {
 505   struct search_path *path;
 506   char *name, *n;
 507   splay_tree_node nd;
 508
 509   if (IS_ABSOLUTE_PATHNAME (fname))
 510     {
 511       /* Just look it up.  */
 512       nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) fname);
 513       return (nd && nd->value);
 514     }
 515
 516   /* Search directory path for the file.  */
 517   name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
 518   for (path = CPP_OPTION (pfile, quote_include); path; path = path->next)
 519     {
 520       memcpy (name, path->name, path->len);
 521       name[path->len] = '/';
 522       strcpy (&name[path->len + 1], fname);
 523       if (CPP_OPTION (pfile, remap))
 524         n = remap_filename (pfile, name, path);
 525       else
 526         n = name;
 527
 528       nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) n);
 529       if (nd && nd->value)
 530         return 1;
 531     }
 532   return 0;
 533 }
 534
 535 /* Search for HEADER.  Return 0 if there is no such file (or it's
 536    un-openable), in which case an error code will be in errno.  If
 537    there is no include path to use it returns NO_INCLUDE_PATH,
 538    otherwise an include_file structure.  If this request originates
 539    from a directive of TYPE #include_next, set INCLUDE_NEXT to true.  */
 540 static struct include_file *
 541 find_include_file (pfile, header, type)
 542      cpp_reader *pfile;
 543      const cpp_token *header;
 544      enum include_type type;
 545 {
 546   const char *fname = (const char *) header->val.str.text;
 547   struct search_path *path;
 548   struct include_file *file;
 549   char *name, *n;
 550
 551   if (IS_ABSOLUTE_PATHNAME (fname))
 552     return open_file (pfile, fname);
 553
 554   /* For #include_next, skip in the search path past the dir in which
 555      the current file was found, but if it was found via an absolute
 556      path use the normal search logic.  */
 557   if (type == IT_INCLUDE_NEXT && pfile->buffer->inc->foundhere)
 558     path = pfile->buffer->inc->foundhere->next;
 559   else if (header->type == CPP_HEADER_NAME)
 560     path = CPP_OPTION (pfile, bracket_include);
 561   else
 562     path = search_from (pfile, type);
 563
 564   if (path == NULL)
 565     {
 566       cpp_error (pfile, DL_ERROR, "no include path in which to find %s",
 567                  fname);
 568       return NO_INCLUDE_PATH;
 569     }
 570
 571   /* Search directory path for the file.  */
 572   name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
 573   for (; path; path = path->next)
 574     {
 575       int len = path->len;
 576       memcpy (name, path->name, len);
 577       /* Don't turn / into // or // into ///; // may be a namespace
 578          escape.  */
 579       if (name[len-1] == '/')
 580         len--;
 581       name[len] = '/';
 582       strcpy (&name[len + 1], fname);
 583       if (CPP_OPTION (pfile, remap))
 584         n = remap_filename (pfile, name, path);
 585       else
 586         n = name;
 587
 588       file = open_file (pfile, n);
 589       if (file)
 590         {
 591           file->foundhere = path;
 592           return file;
 593         }
 594     }
 595
 596   return 0;
 597 }
 598
 599 /* Not everyone who wants to set system-header-ness on a buffer can
 600    see the details of a buffer.  This is an exported interface because
 601    fix-header needs it.  */
 602 void
 603 cpp_make_system_header (pfile, syshdr, externc)
 604      cpp_reader *pfile;
 605      int syshdr, externc;
 606 {
 607   int flags = 0;
 608
 609   /* 1 = system header, 2 = system header to be treated as C.  */
 610   if (syshdr)
 611     flags = 1 + (externc != 0);
 612   _cpp_do_file_change (pfile, LC_RENAME, pfile->map->to_file,
 613                        SOURCE_LINE (pfile->map, pfile->line), flags);
 614 }
 615
 616 /* Report on all files that might benefit from a multiple include guard.
 617    Triggered by -H.  */
 618 void
 619 _cpp_report_missing_guards (pfile)
 620      cpp_reader *pfile;
 621 {
 622   int banner = 0;
 623   splay_tree_foreach (pfile->all_include_files, report_missing_guard,
 624                       (PTR) &banner);
 625 }
 626
 627 /* Callback function for splay_tree_foreach().  */
 628 static int
 629 report_missing_guard (n, b)
 630      splay_tree_node n;
 631      void *b;
 632 {
 633   struct include_file *f = (struct include_file *) n->value;
 634   int *bannerp = (int *)b;
 635
 636   if (f && f->cmacro == 0 && f->include_count == 1)
 637     {
 638       if (*bannerp == 0)
 639         {
 640           fputs (_("Multiple include guards may be useful for:\n"), stderr);
 641           *bannerp = 1;
 642         }
 643       fputs (f->name, stderr);
 644       putc ('\n', stderr);
 645     }
 646   return 0;
 647 }
 648
 649 /* Create a dependency for file FNAME, or issue an error message as
 650    appropriate.  ANGLE_BRACKETS is non-zero if the file was bracketed
 651    like <..>.  */
 652 static void
 653 handle_missing_header (pfile, fname, angle_brackets)
 654      cpp_reader *pfile;
 655      const char *fname;
 656      int angle_brackets;
 657 {
 658   int print_dep = CPP_PRINT_DEPS(pfile) > (angle_brackets || pfile->map->sysp);
 659
 660   if (CPP_OPTION (pfile, print_deps_missing_files) && print_dep)
 661     {
 662       if (!angle_brackets || IS_ABSOLUTE_PATHNAME (fname))
 663         deps_add_dep (pfile->deps, fname);
 664       else
 665         {
 666           /* If requested as a system header, assume it belongs in
 667              the first system header directory.  */
 668           struct search_path *ptr = CPP_OPTION (pfile, bracket_include);
 669           char *p;
 670           int len = 0, fname_len = strlen (fname);
 671
 672           if (ptr)
 673             len = ptr->len;
 674
 675           p = (char *) alloca (len + fname_len + 2);
 676           if (len)
 677             {
 678               memcpy (p, ptr->name, len);
 679               p[len++] = '/';
 680             }
 681           memcpy (p + len, fname, fname_len + 1);
 682           deps_add_dep (pfile->deps, p);
 683         }
 684     }
 685   /* If -M was specified, then don't count this as an error, because
 686      we can still produce correct output.  Otherwise, we can't produce
 687      correct output, because there may be dependencies we need inside
 688      the missing file, and we don't know what directory this missing
 689      file exists in.  */
 690   else
 691     cpp_errno (pfile, CPP_PRINT_DEPS (pfile) && ! print_dep
 692                ? DL_WARNING: DL_ERROR, fname);
 693 }
 694
 695 /* Handles #include-family directives (distinguished by TYPE),
 696    including HEADER, and the command line -imacros and -include.
 697    Returns true if a buffer was stacked.  */
 698 bool
 699 _cpp_execute_include (pfile, header, type)
 700      cpp_reader *pfile;
 701      const cpp_token *header;
 702      enum include_type type;
 703 {
 704   bool stacked = false;
 705   struct include_file *inc = find_include_file (pfile, header, type);
 706
 707   if (inc == 0)
 708     handle_missing_header (pfile, (const char *) header->val.str.text,
 709                            header->type == CPP_HEADER_NAME);
 710   else if (inc != NO_INCLUDE_PATH)
 711     {
 712       stacked = stack_include_file (pfile, inc);
 713
 714       if (type == IT_IMPORT)
 715         _cpp_never_reread (inc);
 716     }
 717
 718   return stacked;
 719 }
 720
 721 /* Locate HEADER, and determine whether it is newer than the current
 722    file.  If it cannot be located or dated, return -1, if it is newer
 723    newer, return 1, otherwise 0.  */
 724 int
 725 _cpp_compare_file_date (pfile, header)
 726      cpp_reader *pfile;
 727      const cpp_token *header;
 728 {
 729   struct include_file *inc = find_include_file (pfile, header, 0);
 730
 731   if (inc == NULL || inc == NO_INCLUDE_PATH)
 732     return -1;
 733
 734   if (inc->fd > 0)
 735     {
 736       close (inc->fd);
 737       inc->fd = -1;
 738     }
 739
 740   return inc->st.st_mtime > pfile->buffer->inc->st.st_mtime;
 741 }
 742
 743
 744 /* Push an input buffer and load it up with the contents of FNAME.  If
 745    FNAME is "", read standard input.  Return true if a buffer was
 746    stacked.  */
 747 bool
 748 _cpp_read_file (pfile, fname)
 749      cpp_reader *pfile;
 750      const char *fname;
 751 {
 752   struct include_file *f = open_file (pfile, fname);
 753
 754   if (f == NULL)
 755     {
 756       cpp_errno (pfile, DL_ERROR, fname);
 757       return false;
 758     }
 759
 760   return stack_include_file (pfile, f);
 761 }
 762
 763 /* Do appropriate cleanup when a file INC's buffer is popped off the
 764    input stack.  Push the next -include file, if any remain.  */
 765 bool
 766 _cpp_pop_file_buffer (pfile, inc)
 767      cpp_reader *pfile;
 768      struct include_file *inc;
 769 {
 770   bool pushed = false;
 771
 772   /* Record the inclusion-preventing macro, which could be NULL
 773      meaning no controlling macro.  */
 774   if (pfile->mi_valid && inc->cmacro == NULL)
 775     inc->cmacro = pfile->mi_cmacro;
 776
 777   /* Invalidate control macros in the #including file.  */
 778   pfile->mi_valid = false;
 779
 780   inc->refcnt--;
 781   if (inc->refcnt == 0 && DO_NOT_REREAD (inc))
 782     purge_cache (inc);
 783
 784   /* Don't generate a callback for popping the main file.  */
 785   if (pfile->buffer)
 786     {
 787       _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
 788
 789       /* Finally, push the next -included file, if any.  */
 790       if (!pfile->buffer->prev)
 791         pushed = _cpp_push_next_buffer (pfile);
 792     }
 793
 794   return pushed;
 795 }
 796
 797 /* Returns the first place in the include chain to start searching for
 798    "" includes.  This involves stripping away the basename of the
 799    current file, unless -I- was specified.
 800
 801    If we're handling -include or -imacros, use the "" chain, but with
 802    the preprocessor's cwd prepended.  */
 803 static struct search_path *
 804 search_from (pfile, type)
 805      cpp_reader *pfile;
 806      enum include_type type;
 807 {
 808   cpp_buffer *buffer = pfile->buffer;
 809   unsigned int dlen;
 810
 811   /* Command line uses the cwd, and does not cache the result.  */
 812   if (type == IT_CMDLINE)
 813     goto use_cwd;
 814
 815   /* Ignore the current file's directory if -I- was given.  */
 816   if (CPP_OPTION (pfile, ignore_srcdir))
 817     return CPP_OPTION (pfile, quote_include);
 818
 819   if (! buffer->search_cached)
 820     {
 821       buffer->search_cached = 1;
 822
 823       dlen = lbasename (buffer->inc->name) - buffer->inc->name;
 824
 825       if (dlen)
 826         {
 827           /* We don't guarantee NAME is null-terminated.  This saves
 828              allocating and freeing memory.  Drop a trailing '/'.  */
 829           buffer->dir.name = buffer->inc->name;
 830           if (dlen > 1)
 831             dlen--;
 832         }
 833       else
 834         {
 835         use_cwd:
 836           buffer->dir.name = ".";
 837           dlen = 1;
 838         }
 839
 840       if (dlen > pfile->max_include_len)
 841         pfile->max_include_len = dlen;
 842
 843       buffer->dir.len = dlen;
 844       buffer->dir.next = CPP_OPTION (pfile, quote_include);
 845       buffer->dir.sysp = pfile->map->sysp;
 846     }
 847
 848   return &buffer->dir;
 849 }
 850
 851 /* The file_name_map structure holds a mapping of file names for a
 852    particular directory.  This mapping is read from the file named
 853    FILE_NAME_MAP_FILE in that directory.  Such a file can be used to
 854    map filenames on a file system with severe filename restrictions,
 855    such as DOS.  The format of the file name map file is just a series
 856    of lines with two tokens on each line.  The first token is the name
 857    to map, and the second token is the actual name to use.  */
 858 struct file_name_map
 859 {
 860   struct file_name_map *map_next;
 861   char *map_from;
 862   char *map_to;
 863 };
 864
 865 #define FILE_NAME_MAP_FILE "header.gcc"
 866
 867 /* Read a space delimited string of unlimited length from a stdio
 868    file F.  */
 869 static char *
 870 read_filename_string (ch, f)
 871      int ch;
 872      FILE *f;
 873 {
 874   char *alloc, *set;
 875   int len;
 876
 877   len = 20;
 878   set = alloc = xmalloc (len + 1);
 879   if (! is_space(ch))
 880     {
 881       *set++ = ch;
 882       while ((ch = getc (f)) != EOF && ! is_space(ch))
 883         {
 884           if (set - alloc == len)
 885             {
 886               len *= 2;
 887               alloc = xrealloc (alloc, len + 1);
 888               set = alloc + len / 2;
 889             }
 890           *set++ = ch;
 891         }
 892     }
 893   *set = '\0';
 894   ungetc (ch, f);
 895   return alloc;
 896 }
 897
 898 /* This structure holds a linked list of file name maps, one per directory.  */
 899 struct file_name_map_list
 900 {
 901   struct file_name_map_list *map_list_next;
 902   char *map_list_name;
 903   struct file_name_map *map_list_map;
 904 };
 905
 906 /* Read the file name map file for DIRNAME.  */
 907 static struct file_name_map *
 908 read_name_map (pfile, dirname)
 909      cpp_reader *pfile;
 910      const char *dirname;
 911 {
 912   struct file_name_map_list *map_list_ptr;
 913   char *name;
 914   FILE *f;
 915
 916   /* Check the cache of directories, and mappings in their remap file.  */
 917   for (map_list_ptr = CPP_OPTION (pfile, map_list); map_list_ptr;
 918        map_list_ptr = map_list_ptr->map_list_next)
 919     if (! strcmp (map_list_ptr->map_list_name, dirname))
 920       return map_list_ptr->map_list_map;
 921
 922   map_list_ptr = ((struct file_name_map_list *)
 923                   xmalloc (sizeof (struct file_name_map_list)));
 924   map_list_ptr->map_list_name = xstrdup (dirname);
 925
 926   /* The end of the list ends in NULL.  */
 927   map_list_ptr->map_list_map = NULL;
 928
 929   name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
 930   strcpy (name, dirname);
 931   if (*dirname)
 932     strcat (name, "/");
 933   strcat (name, FILE_NAME_MAP_FILE);
 934   f = fopen (name, "r");
 935
 936   /* Silently return NULL if we cannot open.  */
 937   if (f)
 938     {
 939       int ch;
 940       int dirlen = strlen (dirname);
 941
 942       while ((ch = getc (f)) != EOF)
 943         {
 944           char *from, *to;
 945           struct file_name_map *ptr;
 946
 947           if (is_space(ch))
 948             continue;
 949           from = read_filename_string (ch, f);
 950           while ((ch = getc (f)) != EOF && is_hspace(ch))
 951             ;
 952           to = read_filename_string (ch, f);
 953
 954           ptr = ((struct file_name_map *)
 955                  xmalloc (sizeof (struct file_name_map)));
 956           ptr->map_from = from;
 957
 958           /* Make the real filename absolute.  */
 959           if (IS_ABSOLUTE_PATHNAME (to))
 960             ptr->map_to = to;
 961           else
 962             {
 963               ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
 964               strcpy (ptr->map_to, dirname);
 965               ptr->map_to[dirlen] = '/';
 966               strcpy (ptr->map_to + dirlen + 1, to);
 967               free (to);
 968             }
 969
 970           ptr->map_next = map_list_ptr->map_list_map;
 971           map_list_ptr->map_list_map = ptr;
 972
 973           while ((ch = getc (f)) != '\n')
 974             if (ch == EOF)
 975               break;
 976         }
 977       fclose (f);
 978     }
 979
 980   /* Add this information to the cache.  */
 981   map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
 982   CPP_OPTION (pfile, map_list) = map_list_ptr;
 983
 984   return map_list_ptr->map_list_map;
 985 }
 986
 987 /* Remap an unsimplified path NAME based on the file_name_map (if any)
 988    for LOC.  */
 989 static char *
 990 remap_filename (pfile, name, loc)
 991      cpp_reader *pfile;
 992      char *name;
 993      struct search_path *loc;
 994 {
 995   struct file_name_map *map;
 996   const char *from, *p;
 997   char *dir;
 998
 999   if (! loc->name_map)
1000     {
1001       /* Get a null-terminated path.  */
1002       char *dname = alloca (loc->len + 1);
1003       memcpy (dname, loc->name, loc->len);
1004       dname[loc->len] = '\0';
1005
1006       loc->name_map = read_name_map (pfile, dname);
1007       if (! loc->name_map)
1008         return name;
1009     }
1010
1011   /* This works since NAME has not been simplified yet.  */
1012   from = name + loc->len + 1;
1013
1014   for (map = loc->name_map; map; map = map->map_next)
1015     if (!strcmp (map->map_from, from))
1016       return map->map_to;
1017
1018   /* Try to find a mapping file for the particular directory we are
1019      looking in.  Thus #include <sys/types.h> will look up sys/types.h
1020      in /usr/include/header.gcc and look up types.h in
1021      /usr/include/sys/header.gcc.  */
1022   p = strrchr (name, '/');
1023   if (!p)
1024     return name;
1025
1026   /* We know p != name as absolute paths don't call remap_filename.  */
1027   if (p == name)
1028     cpp_error (pfile, DL_ICE, "absolute file name in remap_filename");
1029
1030   dir = (char *) alloca (p - name + 1);
1031   memcpy (dir, name, p - name);
1032   dir[p - name] = '\0';
1033   from = p + 1;
1034
1035   for (map = read_name_map (pfile, dir); map; map = map->map_next)
1036     if (! strcmp (map->map_from, from))
1037       return map->map_to;
1038
1039   return name;
1040 }
1041
1042 /* Returns true if it is safe to remove the final component of path,
1043    when it is followed by a ".." component.  We use lstat to avoid
1044    symlinks if we have it.  If not, we can still catch errors with
1045    stat ().  */
1046 static int
1047 remove_component_p (path)
1048      const char *path;
1049 {
1050   struct stat s;
1051   int result;
1052
1053 #ifdef HAVE_LSTAT
1054   result = lstat (path, &s);
1055 #else
1056   result = stat (path, &s);
1057 #endif
1058
1059   /* There's no guarantee that errno will be unchanged, even on
1060      success.  Cygwin's lstat(), for example, will often set errno to
1061      ENOSYS.  In case of success, reset errno to zero.  */
1062   if (result == 0)
1063     errno = 0;
1064
1065   return result == 0 && S_ISDIR (s.st_mode);
1066 }
1067
1068 /* Simplify a path name in place, deleting redundant components.  This
1069    reduces OS overhead and guarantees that equivalent paths compare
1070    the same (modulo symlinks).
1071
1072    Transforms made:
1073    foo/bar/../quux      foo/quux
1074    foo/./bar            foo/bar
1075    foo//bar             foo/bar
1076    /../quux             /quux
1077    //quux               //quux  (POSIX allows leading // as a namespace escape)
1078
1079    Guarantees no trailing slashes.  All transforms reduce the length
1080    of the string.  Returns PATH.  errno is 0 if no error occurred;
1081    nonzero if an error occurred when using stat () or lstat ().  */
1082 char *
1083 _cpp_simplify_pathname (path)
1084     char *path;
1085 {
1086 #ifndef VMS
1087   char *from, *to;
1088   char *base, *orig_base;
1089   int absolute = 0;
1090
1091   errno = 0;
1092   /* Don't overflow the empty path by putting a '.' in it below.  */
1093   if (*path == '\0')
1094     return path;
1095
1096 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1097   /* Convert all backslashes to slashes.  */
1098   for (from = path; *from; from++)
1099     if (*from == '\\') *from = '/';
1100
1101   /* Skip over leading drive letter if present.  */
1102   if (ISALPHA (path[0]) && path[1] == ':')
1103     from = to = &path[2];
1104   else
1105     from = to = path;
1106 #else
1107   from = to = path;
1108 #endif
1109
1110   /* Remove redundant leading /s.  */
1111   if (*from == '/')
1112     {
1113       absolute = 1;
1114       to++;
1115       from++;
1116       if (*from == '/')
1117         {
1118           if (*++from == '/')
1119             /* 3 or more initial /s are equivalent to 1 /.  */
1120             while (*++from == '/');
1121           else
1122             /* On some hosts // differs from /; Posix allows this.  */
1123             to++;
1124         }
1125     }
1126
1127   base = orig_base = to;
1128   for (;;)
1129     {
1130       int move_base = 0;
1131
1132       while (*from == '/')
1133         from++;
1134
1135       if (*from == '\0')
1136         break;
1137
1138       if (*from == '.')
1139         {
1140           if (from[1] == '\0')
1141             break;
1142           if (from[1] == '/')
1143             {
1144               from += 2;
1145               continue;
1146             }
1147           else if (from[1] == '.' && (from[2] == '/' || from[2] == '\0'))
1148             {
1149               /* Don't simplify if there was no previous component.  */
1150               if (absolute && orig_base == to)
1151                 {
1152                   from += 2;
1153                   continue;
1154                 }
1155               /* Don't simplify if the previous component was "../",
1156                  or if an error has already occurred with (l)stat.  */
1157               if (base != to && errno == 0)
1158                 {
1159                   /* We don't back up if it's a symlink.  */
1160                   *to = '\0';
1161                   if (remove_component_p (path))
1162                     {
1163                       while (to > base && *to != '/')
1164                         to--;
1165                       from += 2;
1166                       continue;
1167                     }
1168                 }
1169               move_base = 1;
1170             }
1171         }
1172
1173       /* Add the component separator.  */
1174       if (to > orig_base)
1175         *to++ = '/';
1176
1177       /* Copy this component until the trailing null or '/'.  */
1178       while (*from != '\0' && *from != '/')
1179         *to++ = *from++;
1180
1181       if (move_base)
1182         base = to;
1183     }
1184
1185   /* Change the empty string to "." so that it is not treated as stdin.
1186      Null terminate.  */
1187   if (to == path)
1188     *to++ = '.';
1189   *to = '\0';
1190
1191   return path;
1192 #else /* VMS  */
1193   errno = 0;
1194   return path;
1195 #endif /* !VMS  */
1196 }