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 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 "hashtab.h"
  26 #include "cpplib.h"
  27 #include "cpphash.h"
  28 #include "intl.h"
  29 #include "mkdeps.h"
  30
  31 static IHASH *redundant_include_p PARAMS ((cpp_reader *, IHASH *,
  32                                            struct file_name_list *));
  33 static IHASH *make_IHASH        PARAMS ((const char *, const char *,
  34                                          struct file_name_list *,
  35                                          unsigned int, IHASH **));
  36 static struct file_name_map *read_name_map
  37                                 PARAMS ((cpp_reader *, const char *));
  38 static char *read_filename_string PARAMS ((int, FILE *));
  39 static char *remap_filename     PARAMS ((cpp_reader *, char *,
  40                                          struct file_name_list *));
  41 static struct file_name_list *actual_directory
  42                                 PARAMS ((cpp_reader *, const char *));
  43 static unsigned int hash_IHASH  PARAMS ((const void *));
  44 static int eq_IHASH             PARAMS ((const void *, const void *));
  45 static int file_cleanup         PARAMS ((cpp_buffer *, cpp_reader *));
  46 static int find_include_file    PARAMS ((cpp_reader *, const char *,
  47                                         struct file_name_list *,
  48                                         IHASH **, int *));
  49 static int read_include_file    PARAMS ((cpp_reader *, int, IHASH *));
  50 static inline int open_include_file PARAMS ((cpp_reader *, const char *));
  51
  52 #if 0
  53 static void hack_vms_include_specification PARAMS ((char *));
  54 #endif
  55
  56 /* Initial size of include hash table.  */
  57 #define IHASHSIZE 50
  58
  59 #ifndef INCLUDE_LEN_FUDGE
  60 #define INCLUDE_LEN_FUDGE 0
  61 #endif
  62
  63 /* Calculate hash of an IHASH entry.  */
  64 static unsigned int
  65 hash_IHASH (x)
  66      const void *x;
  67 {
  68   const IHASH *i = (const IHASH *)x;
  69   return i->hash;
  70 }
  71
  72 /* Compare an existing IHASH structure with a potential one.  */
  73 static int
  74 eq_IHASH (x, y)
  75      const void *x;
  76      const void *y;
  77 {
  78   const U_CHAR *a = ((const IHASH *)x)->nshort;
  79   const U_CHAR *b = ((const IHASH *)y)->nshort;
  80   return !strcmp (a, b);
  81 }
  82
  83 /* Init the hash table.  In here so it can see the hash and eq functions.  */
  84 void
  85 _cpp_init_include_hash (pfile)
  86      cpp_reader *pfile;
  87 {
  88   pfile->all_include_files
  89     = htab_create (IHASHSIZE, hash_IHASH, eq_IHASH, free);
  90 }
  91
  92 /* Return 0 if the file pointed to by IHASH has never been included before,
  93          -1 if it has been included before and need not be again,
  94          or a pointer to an IHASH entry which is the file to be reread.
  95    "Never before" is with respect to the position in ILIST.
  96
  97    This will not detect redundancies involving odd uses of the
  98    `current directory' rule for "" includes.  They aren't quite
  99    pathological, but I think they are rare enough not to worry about.
 100    The simplest example is:
 101
 102    top.c:
 103    #include "a/a.h"
 104    #include "b/b.h"
 105
 106    a/a.h:
 107    #include "../b/b.h"
 108
 109    and the problem is that for `current directory' includes,
 110    ihash->foundhere is not on any of the global include chains,
 111    so the test below (i->foundhere == l) may be false even when
 112    the directories are in fact the same.  */
 113
 114 static IHASH *
 115 redundant_include_p (pfile, ihash, ilist)
 116      cpp_reader *pfile;
 117      IHASH *ihash;
 118      struct file_name_list *ilist;
 119 {
 120   struct file_name_list *l;
 121   IHASH *i;
 122
 123   if (! ihash->foundhere)
 124     return 0;
 125
 126   for (i = ihash; i; i = i->next_this_file)
 127     for (l = ilist; l; l = l->next)
 128        if (i->foundhere == l)
 129          /* The control_macro works like this: If it's NULL, the file
 130             is to be included again.  If it's "", the file is never to
 131             be included again.  If it's a string, the file is not to be
 132             included again if the string is the name of a defined macro. */
 133          return (i->control_macro
 134                  && (i->control_macro[0] == '\0'
 135                      || cpp_defined (pfile, i->control_macro, -1)))
 136              ? (IHASH *)-1 : i;
 137
 138   return 0;
 139 }
 140
 141 /* Return 1 if the file named by FNAME has been included before in
 142    any context, 0 otherwise.  */
 143 int
 144 cpp_included (pfile, fname)
 145      cpp_reader *pfile;
 146      const char *fname;
 147 {
 148   IHASH dummy, *ptr;
 149   dummy.nshort = fname;
 150   dummy.hash = _cpp_calc_hash (fname, strlen (fname));
 151   ptr = htab_find_with_hash (pfile->all_include_files,
 152                              (const void *)&dummy, dummy.hash);
 153   return (ptr != NULL);
 154 }
 155
 156 /* Create an IHASH entry and insert it in SLOT.  */
 157 static IHASH *
 158 make_IHASH (name, fname, path, hash, slot)
 159      const char *name, *fname;
 160      struct file_name_list *path;
 161      unsigned int hash;
 162      IHASH **slot;
 163 {
 164   IHASH *ih;
 165   if (path == ABSOLUTE_PATH)
 166     {
 167       ih = (IHASH *) xmalloc (sizeof (IHASH) + strlen (name));
 168       ih->nshort = ih->name;
 169     }
 170   else
 171     {
 172       char *s;
 173
 174       if ((s = strstr (name, fname)) != NULL)
 175         {
 176           ih = (IHASH *) xmalloc (sizeof (IHASH) + strlen (name));
 177           ih->nshort = ih->name + (s - name);
 178         }
 179       else
 180         {
 181           ih = (IHASH *) xmalloc (sizeof (IHASH) + strlen (name)
 182                                   + strlen (fname) + 1);
 183           ih->nshort = ih->name + strlen (name) + 1;
 184           strcpy ((char *)ih->nshort, fname);
 185         }
 186     }
 187   strcpy ((char *)ih->name, name);
 188   ih->foundhere = path;
 189   ih->control_macro = NULL;
 190   ih->hash = hash;
 191   ih->next_this_file = *slot;
 192   *slot = ih;
 193   return ih;
 194 }
 195
 196 static int
 197 file_cleanup (pbuf, pfile)
 198      cpp_buffer *pbuf;
 199      cpp_reader *pfile;
 200 {
 201   if (pbuf->buf)
 202     free ((PTR) pbuf->buf);
 203   if (pfile->system_include_depth)
 204     pfile->system_include_depth--;
 205   if (pfile->potential_control_macro)
 206     {
 207       pbuf->ihash->control_macro = pfile->potential_control_macro;
 208       pfile->potential_control_macro = 0;
 209     }
 210   pfile->input_stack_listing_current = 0;
 211   return 0;
 212 }
 213
 214 /* Centralize calls to open(2) here.  This provides a hook for future
 215    changes which might, e.g. look for and open a precompiled version
 216    of the header.  It also means all the magic currently associated
 217    with calling open is in one place, and if we ever need more, it'll
 218    be in one place too.
 219
 220    Open files in nonblocking mode, so we don't get stuck if someone
 221    clever has asked cpp to process /dev/rmt0.  read_include_file
 222    will check that we have a real file to work with.  Also take care
 223    not to acquire a controlling terminal by mistake (this can't happen
 224    on sane systems, but paranoia is a virtue).
 225
 226    Use the three-argument form of open even though we aren't
 227    specifying O_CREAT, to defend against broken system headers.  */
 228
 229 static inline int
 230 open_include_file (pfile, filename)
 231      cpp_reader *pfile ATTRIBUTE_UNUSED;
 232      const char *filename;
 233 {
 234   return open (filename, O_RDONLY|O_NONBLOCK|O_NOCTTY, 0666);
 235 }
 236
 237 /* Search for include file FNAME in the include chain starting at
 238    SEARCH_START.  Return -2 if this file doesn't need to be included
 239    (because it was included already and it's marked idempotent),
 240    -1 if an error occurred, or a file descriptor open on the file.
 241    *IHASH is set to point to the include hash entry for this file, and
 242    *BEFORE is set to 1 if the file was included before (but needs to be read
 243    again). */
 244 static int
 245 find_include_file (pfile, fname, search_start, ihash, before)
 246      cpp_reader *pfile;
 247      const char *fname;
 248      struct file_name_list *search_start;
 249      IHASH **ihash;
 250      int *before;
 251 {
 252   struct file_name_list *path;
 253   IHASH *ih, **slot;
 254   IHASH dummy;
 255   int f;
 256   char *name;
 257
 258   dummy.nshort = fname;
 259   dummy.hash = _cpp_calc_hash (fname, strlen (fname));
 260   path = (fname[0] == '/') ? ABSOLUTE_PATH : search_start;
 261   slot = (IHASH **) htab_find_slot_with_hash (pfile->all_include_files,
 262                                               (const void *) &dummy,
 263                                               dummy.hash, INSERT);
 264
 265   if (*slot && (ih = redundant_include_p (pfile, *slot, path)))
 266     {
 267       if (ih == (IHASH *)-1)
 268         return -2;
 269
 270       *before = 1;
 271       *ihash = ih;
 272       return open_include_file (pfile, ih->name);
 273     }
 274
 275   if (path == ABSOLUTE_PATH)
 276     {
 277       name = (char *) fname;
 278       f = open_include_file (pfile, name);
 279     }
 280   else
 281     {
 282       /* Search directory path, trying to open the file.  */
 283       name = (char *) alloca (strlen (fname) + pfile->max_include_len
 284                      + 2 + INCLUDE_LEN_FUDGE);
 285       do
 286         {
 287           memcpy (name, path->name, path->nlen);
 288           name[path->nlen] = '/';
 289           strcpy (&name[path->nlen+1], fname);
 290           _cpp_simplify_pathname (name);
 291           if (CPP_OPTION (pfile, remap))
 292             name = remap_filename (pfile, name, path);
 293
 294           f = open_include_file (pfile, name);
 295 #ifdef EACCES
 296           if (f == -1 && errno == EACCES)
 297             {
 298               cpp_error (pfile,
 299                          "included file `%s' exists but is not readable",
 300                          name);
 301               return -1;
 302             }
 303 #endif
 304           if (f >= 0)
 305             break;
 306           path = path->next;
 307         }
 308       while (path);
 309     }
 310   if (f == -1)
 311     return -1;
 312
 313   ih = make_IHASH (name, fname, path, dummy.hash, slot);
 314   *before = 0;
 315   *ihash = ih;
 316   return f;
 317 }
 318
 319 /* Create a dummy IHASH entry for FNAME, and return its name pointer.
 320    This is used by #line.  */
 321 const char *
 322 _cpp_fake_ihash (pfile, fname)
 323      cpp_reader *pfile;
 324      const char *fname;
 325 {
 326   IHASH *ih, **slot;
 327   IHASH dummy;
 328
 329   dummy.nshort = fname;
 330   dummy.hash = _cpp_calc_hash (fname, strlen (fname));
 331   slot = (IHASH **) htab_find_slot_with_hash (pfile->all_include_files,
 332                                               (const void *) &dummy,
 333                                               dummy.hash, INSERT);
 334   if (*slot)
 335     return (*slot)->name;
 336   ih = make_IHASH (fname, 0, ABSOLUTE_PATH, dummy.hash, slot);
 337   return ih->name;
 338 }
 339
 340
 341 /* The file_name_map structure holds a mapping of file names for a
 342    particular directory.  This mapping is read from the file named
 343    FILE_NAME_MAP_FILE in that directory.  Such a file can be used to
 344    map filenames on a file system with severe filename restrictions,
 345    such as DOS.  The format of the file name map file is just a series
 346    of lines with two tokens on each line.  The first token is the name
 347    to map, and the second token is the actual name to use.  */
 348
 349 struct file_name_map
 350 {
 351   struct file_name_map *map_next;
 352   char *map_from;
 353   char *map_to;
 354 };
 355
 356 #define FILE_NAME_MAP_FILE "header.gcc"
 357
 358 /* Read a space delimited string of unlimited length from a stdio
 359    file.  */
 360
 361 static char *
 362 read_filename_string (ch, f)
 363      int ch;
 364      FILE *f;
 365 {
 366   char *alloc, *set;
 367   int len;
 368
 369   len = 20;
 370   set = alloc = xmalloc (len + 1);
 371   if (! is_space(ch))
 372     {
 373       *set++ = ch;
 374       while ((ch = getc (f)) != EOF && ! is_space(ch))
 375         {
 376           if (set - alloc == len)
 377             {
 378               len *= 2;
 379               alloc = xrealloc (alloc, len + 1);
 380               set = alloc + len / 2;
 381             }
 382           *set++ = ch;
 383         }
 384     }
 385   *set = '\0';
 386   ungetc (ch, f);
 387   return alloc;
 388 }
 389
 390 /* This structure holds a linked list of file name maps, one per directory.  */
 391
 392 struct file_name_map_list
 393 {
 394   struct file_name_map_list *map_list_next;
 395   char *map_list_name;
 396   struct file_name_map *map_list_map;
 397 };
 398
 399 /* Read the file name map file for DIRNAME.  */
 400
 401 static struct file_name_map *
 402 read_name_map (pfile, dirname)
 403      cpp_reader *pfile;
 404      const char *dirname;
 405 {
 406   register struct file_name_map_list *map_list_ptr;
 407   char *name;
 408   FILE *f;
 409
 410   for (map_list_ptr = CPP_OPTION (pfile, map_list); map_list_ptr;
 411        map_list_ptr = map_list_ptr->map_list_next)
 412     if (! strcmp (map_list_ptr->map_list_name, dirname))
 413       return map_list_ptr->map_list_map;
 414
 415   map_list_ptr = ((struct file_name_map_list *)
 416                   xmalloc (sizeof (struct file_name_map_list)));
 417   map_list_ptr->map_list_name = xstrdup (dirname);
 418
 419   name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
 420   strcpy (name, dirname);
 421   if (*dirname)
 422     strcat (name, "/");
 423   strcat (name, FILE_NAME_MAP_FILE);
 424   f = fopen (name, "r");
 425   if (!f)
 426     map_list_ptr->map_list_map = (struct file_name_map *)-1;
 427   else
 428     {
 429       int ch;
 430       int dirlen = strlen (dirname);
 431
 432       while ((ch = getc (f)) != EOF)
 433         {
 434           char *from, *to;
 435           struct file_name_map *ptr;
 436
 437           if (is_space(ch))
 438             continue;
 439           from = read_filename_string (ch, f);
 440           while ((ch = getc (f)) != EOF && is_hspace(ch))
 441             ;
 442           to = read_filename_string (ch, f);
 443
 444           ptr = ((struct file_name_map *)
 445                  xmalloc (sizeof (struct file_name_map)));
 446           ptr->map_from = from;
 447
 448           /* Make the real filename absolute.  */
 449           if (*to == '/')
 450             ptr->map_to = to;
 451           else
 452             {
 453               ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
 454               strcpy (ptr->map_to, dirname);
 455               ptr->map_to[dirlen] = '/';
 456               strcpy (ptr->map_to + dirlen + 1, to);
 457               free (to);
 458             }
 459
 460           ptr->map_next = map_list_ptr->map_list_map;
 461           map_list_ptr->map_list_map = ptr;
 462
 463           while ((ch = getc (f)) != '\n')
 464             if (ch == EOF)
 465               break;
 466         }
 467       fclose (f);
 468     }
 469
 470   map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
 471   CPP_OPTION (pfile, map_list) = map_list_ptr;
 472
 473   return map_list_ptr->map_list_map;
 474 }
 475
 476 /* Remap NAME based on the file_name_map (if any) for LOC. */
 477
 478 static char *
 479 remap_filename (pfile, name, loc)
 480      cpp_reader *pfile;
 481      char *name;
 482      struct file_name_list *loc;
 483 {
 484   struct file_name_map *map;
 485   const char *from, *p, *dir;
 486
 487   if (! loc->name_map)
 488     loc->name_map = read_name_map (pfile,
 489                                    loc->name
 490                                    ? loc->name : ".");
 491
 492   if (loc->name_map == (struct file_name_map *)-1)
 493     return name;
 494
 495   from = name + strlen (loc->name) + 1;
 496
 497   for (map = loc->name_map; map; map = map->map_next)
 498     if (!strcmp (map->map_from, from))
 499       return map->map_to;
 500
 501   /* Try to find a mapping file for the particular directory we are
 502      looking in.  Thus #include <sys/types.h> will look up sys/types.h
 503      in /usr/include/header.gcc and look up types.h in
 504      /usr/include/sys/header.gcc.  */
 505   p = strrchr (name, '/');
 506   if (!p)
 507     p = name;
 508   if (loc && loc->name
 509       && strlen (loc->name) == (size_t) (p - name)
 510       && !strncmp (loc->name, name, p - name))
 511     /* FILENAME is in SEARCHPTR, which we've already checked.  */
 512     return name;
 513
 514   if (p == name)
 515     {
 516       dir = ".";
 517       from = name;
 518     }
 519   else
 520     {
 521       char * newdir = (char *) alloca (p - name + 1);
 522       memcpy (newdir, name, p - name);
 523       newdir[p - name] = '\0';
 524       dir = newdir;
 525       from = p + 1;
 526     }
 527
 528   for (map = read_name_map (pfile, dir); map; map = map->map_next)
 529     if (! strcmp (map->map_from, name))
 530       return map->map_to;
 531
 532   return name;
 533 }
 534
 535
 536 void
 537 _cpp_execute_include (pfile, fname, len, no_reinclude, search_start)
 538      cpp_reader *pfile;
 539      char *fname;
 540      unsigned int len;
 541      int no_reinclude;
 542      struct file_name_list *search_start;
 543 {
 544   IHASH *ihash;
 545   int fd;
 546   int angle_brackets = fname[0] == '<';
 547   int before;
 548
 549   if (!search_start)
 550     {
 551       if (angle_brackets)
 552         search_start = CPP_OPTION (pfile, bracket_include);
 553       else if (CPP_OPTION (pfile, ignore_srcdir))
 554         search_start = CPP_OPTION (pfile, quote_include);
 555       else
 556         search_start = CPP_BUFFER (pfile)->actual_dir;
 557     }
 558
 559   if (!search_start)
 560     {
 561       cpp_error (pfile, "No include path in which to find %s", fname);
 562       return;
 563     }
 564
 565   /* Remove quote marks.  */
 566   fname++;
 567   len -= 2;
 568   fname[len] = '\0';
 569
 570   fd = find_include_file (pfile, fname, search_start, &ihash, &before);
 571
 572   if (fd == -2)
 573     return;
 574
 575   if (fd == -1)
 576     {
 577       if (CPP_OPTION (pfile, print_deps_missing_files)
 578           && CPP_PRINT_DEPS (pfile) > (angle_brackets ||
 579                                        (pfile->system_include_depth > 0)))
 580         {
 581           if (!angle_brackets)
 582             deps_add_dep (pfile->deps, fname);
 583           else
 584             {
 585               char *p;
 586               struct file_name_list *ptr;
 587               /* If requested as a system header, assume it belongs in
 588                  the first system header directory. */
 589               if (CPP_OPTION (pfile, bracket_include))
 590                 ptr = CPP_OPTION (pfile, bracket_include);
 591               else
 592                 ptr = CPP_OPTION (pfile, quote_include);
 593
 594               p = (char *) alloca (strlen (ptr->name)
 595                                    + strlen (fname) + 2);
 596               if (*ptr->name != '\0')
 597                 {
 598                   strcpy (p, ptr->name);
 599                   strcat (p, "/");
 600                 }
 601               strcat (p, fname);
 602               deps_add_dep (pfile->deps, p);
 603             }
 604         }
 605       /* If -M was specified, and this header file won't be added to
 606          the dependency list, then don't count this as an error,
 607          because we can still produce correct output.  Otherwise, we
 608          can't produce correct output, because there may be
 609          dependencies we need inside the missing file, and we don't
 610          know what directory this missing file exists in. */
 611       else if (CPP_PRINT_DEPS (pfile)
 612                && (CPP_PRINT_DEPS (pfile)
 613                    <= (angle_brackets || (pfile->system_include_depth > 0))))
 614         cpp_warning (pfile, "No include path in which to find %s", fname);
 615       else
 616         cpp_error_from_errno (pfile, fname);
 617
 618       return;
 619     }
 620
 621   /* For -M, add the file to the dependencies on its first inclusion. */
 622   if (!before && (CPP_PRINT_DEPS (pfile)
 623                   > (angle_brackets || (pfile->system_include_depth > 0))))
 624     deps_add_dep (pfile->deps, ihash->name);
 625
 626   /* Handle -H option.  */
 627   if (CPP_OPTION (pfile, print_include_names))
 628     {
 629       cpp_buffer *fp = CPP_BUFFER (pfile);
 630       while ((fp = CPP_PREV_BUFFER (fp)) != NULL)
 631         putc ('.', stderr);
 632       fprintf (stderr, " %s\n", ihash->name);
 633     }
 634
 635   /* Actually process the file.  */
 636   if (no_reinclude)
 637     ihash->control_macro = (const U_CHAR *) "";
 638
 639   if (read_include_file (pfile, fd, ihash))
 640     {
 641       if (angle_brackets)
 642         pfile->system_include_depth++;   /* Decremented in file_cleanup. */
 643     }
 644 }
 645
 646
 647 /* Push an input buffer and load it up with the contents of FNAME.
 648    If FNAME is "" or NULL, read standard input.  */
 649 int
 650 cpp_read_file (pfile, fname)
 651      cpp_reader *pfile;
 652      const char *fname;
 653 {
 654   IHASH *ih, **slot;
 655   IHASH dummy;
 656   int f;
 657
 658   if (fname == NULL)
 659     fname = "";
 660
 661   dummy.nshort = fname;
 662   /* _cpp_calc_hash doesn't like zero-length strings.  */
 663   if (*fname == 0)
 664     dummy.hash = 0;
 665   else
 666     dummy.hash = _cpp_calc_hash (fname, strlen (fname));
 667   slot = (IHASH **) htab_find_slot_with_hash (pfile->all_include_files,
 668                                               (const void *) &dummy,
 669                                               dummy.hash, INSERT);
 670   if (*slot && (ih = redundant_include_p (pfile, *slot, ABSOLUTE_PATH)))
 671     {
 672       if (ih == (IHASH *) -1)
 673         return 1;  /* Already included.  */
 674     }
 675   else
 676     ih = make_IHASH (fname, 0, ABSOLUTE_PATH, dummy.hash, slot);
 677
 678   if (*fname == '\0')
 679     f = 0;
 680   else
 681     f = open_include_file (pfile, fname);
 682
 683   return read_include_file (pfile, f, ih);
 684 }
 685
 686 /* Read the contents of FD into the buffer on the top of PFILE's stack.
 687    IHASH points to the include hash entry for the file associated with
 688    FD.
 689
 690    The caller is responsible for the cpp_push_buffer.  */
 691
 692 static int
 693 read_include_file (pfile, fd, ihash)
 694      cpp_reader *pfile;
 695      int fd;
 696      IHASH *ihash;
 697 {
 698   struct stat st;
 699   size_t st_size;
 700   long length;
 701   cpp_buffer *fp;
 702
 703   fp = cpp_push_buffer (pfile, NULL, 0);
 704
 705   if (fp == 0)
 706     goto push_fail;
 707
 708   if (fstat (fd, &st) < 0)
 709     goto perror_fail;
 710   if (fcntl (fd, F_SETFL, 0) == -1)  /* turn off nonblocking mode */
 711     goto perror_fail;
 712
 713   /* If fd points to a plain file, we know how big it is, so we can
 714      allocate the buffer all at once.  If fd is a pipe or terminal, we
 715      can't.  Most C source files are 4k or less, so we guess that.  If
 716      fd is something weird, like a block device or a directory, we
 717      don't want to read it at all.
 718
 719      Unfortunately, different systems use different st.st_mode values
 720      for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
 721      zero the entire struct stat except a couple fields.  Hence the
 722      mess below.
 723
 724      In all cases, read_and_prescan will resize the buffer if it
 725      turns out there's more data than we thought.  */
 726
 727   if (S_ISREG (st.st_mode))
 728     {
 729       /* off_t might have a wider range than size_t - in other words,
 730          the max size of a file might be bigger than the address
 731          space.  We can't handle a file that large.  (Anyone with
 732          a single source file bigger than 4GB needs to rethink
 733          their coding style.)  */
 734       st_size = (size_t) st.st_size;
 735       if ((unsigned HOST_WIDEST_INT) st_size
 736           != (unsigned HOST_WIDEST_INT) st.st_size)
 737         {
 738           cpp_error (pfile, "file `%s' is too large", ihash->name);
 739           goto fail;
 740         }
 741     }
 742   else if (S_ISFIFO (st.st_mode) || S_ISSOCK (st.st_mode)
 743            /* Permit any kind of character device: the sensible ones are
 744               ttys and /dev/null, but weeding out the others is too hard.  */
 745            || S_ISCHR (st.st_mode)
 746            /* Some 4.x (x<4) derivatives have a bug that makes fstat() of a
 747               socket or pipe return a stat struct with most fields zeroed.  */
 748            || (st.st_mode == 0 && st.st_nlink == 0 && st.st_size == 0))
 749     {
 750       /* Cannot get its file size before reading.  4k is a decent
 751          first guess. */
 752       st_size = 4096;
 753     }
 754   else
 755     {
 756       cpp_error (pfile, "`%s' is not a file, pipe, or tty", ihash->name);
 757       goto fail;
 758     }
 759
 760   /* Read the file, converting end-of-line characters and trigraphs
 761      (if enabled). */
 762   fp->ihash = ihash;
 763   fp->nominal_fname = ihash->name;
 764   length = _cpp_read_and_prescan (pfile, fp, fd, st_size);
 765   if (length < 0)
 766     goto fail;
 767   if (length == 0)
 768     ihash->control_macro = (const U_CHAR *) "";  /* never re-include */
 769
 770   close (fd);
 771   fp->rlimit = fp->buf + length;
 772   fp->cur = fp->buf;
 773   if (ihash->foundhere != ABSOLUTE_PATH)
 774       fp->system_header_p = ihash->foundhere->sysp;
 775   fp->lineno = 1;
 776   fp->line_base = fp->buf;
 777   fp->cleanup = file_cleanup;
 778
 779   /* The ->actual_dir field is only used when ignore_srcdir is not in effect;
 780      see do_include */
 781   if (!CPP_OPTION (pfile, ignore_srcdir))
 782     fp->actual_dir = actual_directory (pfile, ihash->name);
 783
 784   pfile->input_stack_listing_current = 0;
 785   pfile->only_seen_white = 2;
 786   return 1;
 787
 788  perror_fail:
 789   cpp_error_from_errno (pfile, ihash->name);
 790  fail:
 791   cpp_pop_buffer (pfile);
 792  push_fail:
 793   close (fd);
 794   return 0;
 795 }
 796
 797 /* Given a path FNAME, extract the directory component and place it
 798    onto the actual_dirs list.  Return a pointer to the allocated
 799    file_name_list structure.  These structures are used to implement
 800    current-directory "" include searching. */
 801
 802 static struct file_name_list *
 803 actual_directory (pfile, fname)
 804      cpp_reader *pfile;
 805      const char *fname;
 806 {
 807   char *last_slash, *dir;
 808   size_t dlen;
 809   struct file_name_list *x;
 810
 811   dir = xstrdup (fname);
 812   last_slash = strrchr (dir, '/');
 813   if (last_slash)
 814     {
 815       if (last_slash == dir)
 816         {
 817           dlen = 1;
 818           last_slash[1] = '\0';
 819         }
 820       else
 821         {
 822           dlen = last_slash - dir;
 823           *last_slash = '\0';
 824         }
 825     }
 826   else
 827     {
 828       dir[0] = '.';
 829       dir[1] = '\0';
 830       dlen = 1;
 831     }
 832
 833   if (dlen > pfile->max_include_len)
 834     pfile->max_include_len = dlen;
 835
 836   for (x = pfile->actual_dirs; x; x = x->alloc)
 837     if (!strcmp (x->name, dir))
 838       {
 839         free (dir);
 840         return x;
 841       }
 842
 843   /* Not found, make a new one. */
 844   x = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
 845   x->name = dir;
 846   x->nlen = dlen;
 847   x->next = CPP_OPTION (pfile, quote_include);
 848   x->alloc = pfile->actual_dirs;
 849   x->sysp = CPP_BUFFER (pfile)->system_header_p;
 850   x->name_map = NULL;
 851
 852   pfile->actual_dirs = x;
 853   return x;
 854 }
 855
 856 /* Simplify a path name in place, deleting redundant components.  This
 857    reduces OS overhead and guarantees that equivalent paths compare
 858    the same (modulo symlinks).
 859
 860    Transforms made:
 861    foo/bar/../quux      foo/quux
 862    foo/./bar            foo/bar
 863    foo//bar             foo/bar
 864    /../quux             /quux
 865    //quux               //quux  (POSIX allows leading // as a namespace escape)
 866
 867    Guarantees no trailing slashes. All transforms reduce the length
 868    of the string.
 869  */
 870 void
 871 _cpp_simplify_pathname (path)
 872     char *path;
 873 {
 874     char *from, *to;
 875     char *base;
 876     int absolute = 0;
 877
 878 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 879     /* Convert all backslashes to slashes. */
 880     for (from = path; *from; from++)
 881         if (*from == '\\') *from = '/';
 882
 883     /* Skip over leading drive letter if present. */
 884     if (ISALPHA (path[0]) && path[1] == ':')
 885         from = to = &path[2];
 886     else
 887         from = to = path;
 888 #else
 889     from = to = path;
 890 #endif
 891
 892     /* Remove redundant initial /s.  */
 893     if (*from == '/')
 894     {
 895         absolute = 1;
 896         to++;
 897         from++;
 898         if (*from == '/')
 899         {
 900             if (*++from == '/')
 901                 /* 3 or more initial /s are equivalent to 1 /.  */
 902                 while (*++from == '/');
 903             else
 904                 /* On some hosts // differs from /; Posix allows this.  */
 905                 to++;
 906         }
 907     }
 908     base = to;
 909
 910     for (;;)
 911     {
 912         while (*from == '/')
 913             from++;
 914
 915         if (from[0] == '.' && from[1] == '/')
 916             from += 2;
 917         else if (from[0] == '.' && from[1] == '\0')
 918             goto done;
 919         else if (from[0] == '.' && from[1] == '.' && from[2] == '/')
 920         {
 921             if (base == to)
 922             {
 923                 if (absolute)
 924                     from += 3;
 925                 else
 926                 {
 927                     *to++ = *from++;
 928                     *to++ = *from++;
 929                     *to++ = *from++;
 930                     base = to;
 931                 }
 932             }
 933             else
 934             {
 935                 to -= 2;
 936                 while (to > base && *to != '/') to--;
 937                 if (*to == '/')
 938                     to++;
 939                 from += 3;
 940             }
 941         }
 942         else if (from[0] == '.' && from[1] == '.' && from[2] == '\0')
 943         {
 944             if (base == to)
 945             {
 946                 if (!absolute)
 947                 {
 948                     *to++ = *from++;
 949                     *to++ = *from++;
 950                 }
 951             }
 952             else
 953             {
 954                 to -= 2;
 955                 while (to > base && *to != '/') to--;
 956                 if (*to == '/')
 957                     to++;
 958             }
 959             goto done;
 960         }
 961         else
 962             /* Copy this component and trailing /, if any.  */
 963             while ((*to++ = *from++) != '/')
 964             {
 965                 if (!to[-1])
 966                 {
 967                     to--;
 968                     goto done;
 969                 }
 970             }
 971
 972     }
 973
 974  done:
 975     /* Trim trailing slash */
 976     if (to[0] == '/' && (!absolute || to > path+1))
 977         to--;
 978
 979     /* Change the empty string to "." so that stat() on the result
 980        will always work. */
 981     if (to == path)
 982       *to++ = '.';
 983
 984     *to = '\0';
 985
 986     return;
 987 }
 988
 989 /* It is not clear when this should be used if at all, so I've
 990    disabled it until someone who understands VMS can look at it. */
 991 #if 0
 992
 993 /* Under VMS we need to fix up the "include" specification filename.
 994
 995    Rules for possible conversions
 996
 997         fullname                tried paths
 998
 999         name                    name
1000         ./dir/name              [.dir]name
1001         /dir/name               dir:name
1002         /name                   [000000]name, name
1003         dir/name                dir:[000000]name, dir:name, dir/name
1004         dir1/dir2/name          dir1:[dir2]name, dir1:[000000.dir2]name
1005         path:/name              path:[000000]name, path:name
1006         path:/dir/name          path:[000000.dir]name, path:[dir]name
1007         path:dir/name           path:[dir]name
1008         [path]:[dir]name        [path.dir]name
1009         path/[dir]name          [path.dir]name
1010
1011    The path:/name input is constructed when expanding <> includes. */
1012
1013
1014 static void
1015 hack_vms_include_specification (fullname)
1016      char *fullname;
1017 {
1018   register char *basename, *unixname, *local_ptr, *first_slash;
1019   int f, check_filename_before_returning, must_revert;
1020   char Local[512];
1021
1022   check_filename_before_returning = 0;
1023   must_revert = 0;
1024   /* See if we can find a 1st slash. If not, there's no path information.  */
1025   first_slash = strchr (fullname, '/');
1026   if (first_slash == 0)
1027     return 0;                           /* Nothing to do!!! */
1028
1029   /* construct device spec if none given.  */
1030
1031   if (strchr (fullname, ':') == 0)
1032     {
1033
1034       /* If fullname has a slash, take it as device spec.  */
1035
1036       if (first_slash == fullname)
1037         {
1038           first_slash = strchr (fullname + 1, '/');     /* 2nd slash ? */
1039           if (first_slash)
1040             *first_slash = ':';                         /* make device spec  */
1041           for (basename = fullname; *basename != 0; basename++)
1042             *basename = *(basename+1);                  /* remove leading slash  */
1043         }
1044       else if ((first_slash[-1] != '.')         /* keep ':/', './' */
1045             && (first_slash[-1] != ':')
1046             && (first_slash[-1] != ']'))        /* or a vms path  */
1047         {
1048           *first_slash = ':';
1049         }
1050       else if ((first_slash[1] == '[')          /* skip './' in './[dir'  */
1051             && (first_slash[-1] == '.'))
1052         fullname += 2;
1053     }
1054
1055   /* Get part after first ':' (basename[-1] == ':')
1056      or last '/' (basename[-1] == '/').  */
1057
1058   basename = base_name (fullname);
1059
1060   local_ptr = Local;                    /* initialize */
1061
1062   /* We are trying to do a number of things here.  First of all, we are
1063      trying to hammer the filenames into a standard format, such that later
1064      processing can handle them.
1065
1066      If the file name contains something like [dir.], then it recognizes this
1067      as a root, and strips the ".]".  Later processing will add whatever is
1068      needed to get things working properly.
1069
1070      If no device is specified, then the first directory name is taken to be
1071      a device name (or a rooted logical).  */
1072
1073   /* Point to the UNIX filename part (which needs to be fixed!)
1074      but skip vms path information.
1075      [basename != fullname since first_slash != 0].  */
1076
1077   if ((basename[-1] == ':')             /* vms path spec.  */
1078       || (basename[-1] == ']')
1079       || (basename[-1] == '>'))
1080     unixname = basename;
1081   else
1082     unixname = fullname;
1083
1084   if (*unixname == '/')
1085     unixname++;
1086
1087   /* If the directory spec is not rooted, we can just copy
1088      the UNIX filename part and we are done.  */
1089
1090   if (((basename - fullname) > 1)
1091      && (  (basename[-1] == ']')
1092         || (basename[-1] == '>')))
1093     {
1094       if (basename[-2] != '.')
1095         {
1096
1097         /* The VMS part ends in a `]', and the preceding character is not a `.'.
1098            -> PATH]:/name (basename = '/name', unixname = 'name')
1099            We strip the `]', and then splice the two parts of the name in the
1100            usual way.  Given the default locations for include files,
1101            we will only use this code if the user specifies alternate locations
1102            with the /include (-I) switch on the command line.  */
1103
1104           basename -= 1;        /* Strip "]" */
1105           unixname--;           /* backspace */
1106         }
1107       else
1108         {
1109
1110         /* The VMS part has a ".]" at the end, and this will not do.  Later
1111            processing will add a second directory spec, and this would be a syntax
1112            error.  Thus we strip the ".]", and thus merge the directory specs.
1113            We also backspace unixname, so that it points to a '/'.  This inhibits the
1114            generation of the 000000 root directory spec (which does not belong here
1115            in this case).  */
1116
1117           basename -= 2;        /* Strip ".]" */
1118           unixname--;           /* backspace */
1119         }
1120     }
1121
1122   else
1123
1124     {
1125
1126       /* We drop in here if there is no VMS style directory specification yet.
1127          If there is no device specification either, we make the first dir a
1128          device and try that.  If we do not do this, then we will be essentially
1129          searching the users default directory (as if they did a #include "asdf.h").
1130
1131          Then all we need to do is to push a '[' into the output string. Later
1132          processing will fill this in, and close the bracket.  */
1133
1134       if ((unixname != fullname)        /* vms path spec found.  */
1135          && (basename[-1] != ':'))
1136         *local_ptr++ = ':';             /* dev not in spec.  take first dir */
1137
1138       *local_ptr++ = '[';               /* Open the directory specification */
1139     }
1140
1141     if (unixname == fullname)           /* no vms dir spec.  */
1142       {
1143         must_revert = 1;
1144         if ((first_slash != 0)          /* unix dir spec.  */
1145             && (*unixname != '/')       /* not beginning with '/'  */
1146             && (*unixname != '.'))      /* or './' or '../'  */
1147           *local_ptr++ = '.';           /* dir is local !  */
1148       }
1149
1150   /* at this point we assume that we have the device spec, and (at least
1151      the opening "[" for a directory specification.  We may have directories
1152      specified already.
1153
1154      If there are no other slashes then the filename will be
1155      in the "root" directory.  Otherwise, we need to add
1156      directory specifications.  */
1157
1158   if (strchr (unixname, '/') == 0)
1159     {
1160       /* if no directories specified yet and none are following.  */
1161       if (local_ptr[-1] == '[')
1162         {
1163           /* Just add "000000]" as the directory string */
1164           strcpy (local_ptr, "000000]");
1165           local_ptr += strlen (local_ptr);
1166           check_filename_before_returning = 1; /* we might need to fool with this later */
1167         }
1168     }
1169   else
1170     {
1171
1172       /* As long as there are still subdirectories to add, do them.  */
1173       while (strchr (unixname, '/') != 0)
1174         {
1175           /* If this token is "." we can ignore it
1176                if it's not at the beginning of a path.  */
1177           if ((unixname[0] == '.') && (unixname[1] == '/'))
1178             {
1179               /* remove it at beginning of path.  */
1180               if (  ((unixname == fullname)             /* no device spec  */
1181                     && (fullname+2 != basename))        /* starts with ./ */
1182                                                         /* or  */
1183                  || ((basename[-1] == ':')              /* device spec  */
1184                     && (unixname-1 == basename)))       /* and ./ afterwards  */
1185                 *local_ptr++ = '.';                     /* make '[.' start of path.  */
1186               unixname += 2;
1187               continue;
1188             }
1189
1190           /* Add a subdirectory spec. Do not duplicate "." */
1191           if (  local_ptr[-1] != '.'
1192              && local_ptr[-1] != '['
1193              && local_ptr[-1] != '<')
1194             *local_ptr++ = '.';
1195
1196           /* If this is ".." then the spec becomes "-" */
1197           if (  (unixname[0] == '.')
1198              && (unixname[1] == '.')
1199              && (unixname[2] == '/'))
1200             {
1201               /* Add "-" and skip the ".." */
1202               if ((local_ptr[-1] == '.')
1203                   && (local_ptr[-2] == '['))
1204                 local_ptr--;                    /* prevent [.-  */
1205               *local_ptr++ = '-';
1206               unixname += 3;
1207               continue;
1208             }
1209
1210           /* Copy the subdirectory */
1211           while (*unixname != '/')
1212             *local_ptr++= *unixname++;
1213
1214           unixname++;                   /* Skip the "/" */
1215         }
1216
1217       /* Close the directory specification */
1218       if (local_ptr[-1] == '.')         /* no trailing periods */
1219         local_ptr--;
1220
1221       if (local_ptr[-1] == '[')         /* no dir needed */
1222         local_ptr--;
1223       else
1224         *local_ptr++ = ']';
1225     }
1226
1227   /* Now add the filename.  */
1228
1229   while (*unixname)
1230     *local_ptr++ = *unixname++;
1231   *local_ptr = 0;
1232
1233   /* Now append it to the original VMS spec.  */
1234
1235   strcpy ((must_revert==1)?fullname:basename, Local);
1236
1237   /* If we put a [000000] in the filename, try to open it first. If this fails,
1238      remove the [000000], and return that name.  This provides flexibility
1239      to the user in that they can use both rooted and non-rooted logical names
1240      to point to the location of the file.  */
1241
1242   if (check_filename_before_returning)
1243     {
1244       f = open (fullname, O_RDONLY|O_NONBLOCK);
1245       if (f >= 0)
1246         {
1247           /* The file name is OK as it is, so return it as is.  */
1248           close (f);
1249           return 1;
1250         }
1251
1252       /* The filename did not work.  Try to remove the [000000] from the name,
1253          and return it.  */
1254
1255       basename = strchr (fullname, '[');
1256       local_ptr = strchr (fullname, ']') + 1;
1257       strcpy (basename, local_ptr);             /* this gets rid of it */
1258
1259     }
1260
1261   return 1;
1262 }
1263 #endif  /* VMS */