gcc/c-incpath.c

   1 /* Set up combined include path chain for the preprocessor.
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   4    Free Software Foundation, Inc.
   5
   6    Broken out of cppinit.c and cppfiles.c and rewritten Mar 2003.
   7
   8 This program is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 2, or (at your option) any
  11 later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "machmode.h"
  26 #include "target.h"
  27 #include "tm.h"
  28 #include "cpplib.h"
  29 #include "prefix.h"
  30 #include "intl.h"
  31 #include "c-incpath.h"
  32 #include "cppdefault.h"
  33
  34 /* Windows does not natively support inodes, and neither does MSDOS.
  35    Cygwin's emulation can generate non-unique inodes, so don't use it.
  36    VMS has non-numeric inodes.  */
  37 #ifdef VMS
  38 # define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A)))
  39 # define INO_T_COPY(DEST, SRC) memcpy(&(DEST), &(SRC), sizeof (SRC))
  40 #else
  41 # if (defined _WIN32 && !defined (_UWIN)) || defined __MSDOS__
  42 #  define INO_T_EQ(A, B) 0
  43 # else
  44 #  define INO_T_EQ(A, B) ((A) == (B))
  45 # endif
  46 # define INO_T_COPY(DEST, SRC) (DEST) = (SRC)
  47 #endif
  48
  49 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
  50
  51 static void add_env_var_paths (const char *, int);
  52 static void add_standard_paths (const char *, const char *, const char *, int);
  53 static void free_path (struct cpp_dir *, int);
  54 static void merge_include_chains (cpp_reader *, int);
  55 static struct cpp_dir *remove_duplicates (cpp_reader *, struct cpp_dir *,
  56                                            struct cpp_dir *,
  57                                            struct cpp_dir *, int);
  58
  59 /* Include chains heads and tails.  */
  60 static struct cpp_dir *heads[4];
  61 static struct cpp_dir *tails[4];
  62 static bool quote_ignores_source_dir;
  63 enum { REASON_QUIET = 0, REASON_NOENT, REASON_DUP, REASON_DUP_SYS };
  64
  65 /* Free an element of the include chain, possibly giving a reason.  */
  66 static void
  67 free_path (struct cpp_dir *path, int reason)
  68 {
  69   switch (reason)
  70     {
  71     case REASON_DUP:
  72     case REASON_DUP_SYS:
  73       fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), path->name);
  74       if (reason == REASON_DUP_SYS)
  75         fprintf (stderr,
  76  _("  as it is a non-system directory that duplicates a system directory\n"));
  77       break;
  78
  79     case REASON_NOENT:
  80       fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"),
  81                path->name);
  82       break;
  83
  84     case REASON_QUIET:
  85     default:
  86       break;
  87     }
  88
  89   free (path->name);
  90   free (path);
  91 }
  92
  93 /* Read ENV_VAR for a PATH_SEPARATOR-separated list of file names; and
  94    append all the names to the search path CHAIN.  */
  95 static void
  96 add_env_var_paths (const char *env_var, int chain)
  97 {
  98   char *p, *q, *path;
  99
 100   GET_ENVIRONMENT (q, env_var);
 101
 102   if (!q)
 103     return;
 104
 105   for (p = q; *q; p = q + 1)
 106     {
 107       q = p;
 108       while (*q != 0 && *q != PATH_SEPARATOR)
 109         q++;
 110
 111       if (p == q)
 112         path = xstrdup (".");
 113       else
 114         {
 115           path = XNEWVEC (char, q - p + 1);
 116           memcpy (path, p, q - p);
 117           path[q - p] = '\0';
 118         }
 119
 120       add_path (path, chain, chain == SYSTEM, false);
 121     }
 122 }
 123
 124 /* Append the standard include chain defined in cppdefault.c.  */
 125 static void
 126 add_standard_paths (const char *sysroot, const char *iprefix,
 127                     const char *imultilib, int cxx_stdinc)
 128 {
 129   const struct default_include *p;
 130   int relocated = cpp_relocated();
 131   size_t len;
 132
 133   if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0)
 134     {
 135       /* Look for directories that start with the standard prefix.
 136          "Translate" them, i.e. replace /usr/local/lib/gcc... with
 137          IPREFIX and search them first.  */
 138       for (p = cpp_include_defaults; p->fname; p++)
 139         {
 140           if (!p->cplusplus || cxx_stdinc)
 141             {
 142               /* Should we be translating sysrooted dirs too?  Assume
 143                  that iprefix and sysroot are mutually exclusive, for
 144                  now.  */
 145               if (sysroot && p->add_sysroot)
 146                 continue;
 147               if (!strncmp (p->fname, cpp_GCC_INCLUDE_DIR, len))
 148                 {
 149                   char *str = concat (iprefix, p->fname + len, NULL);
 150                   if (p->multilib && imultilib)
 151                     str = concat (str, dir_separator_str, imultilib, NULL);
 152                   add_path (str, SYSTEM, p->cxx_aware, false);
 153                 }
 154             }
 155         }
 156     }
 157
 158   for (p = cpp_include_defaults; p->fname; p++)
 159     {
 160       if (!p->cplusplus || cxx_stdinc)
 161         {
 162           char *str;
 163
 164           /* Should this directory start with the sysroot?  */
 165           if (sysroot && p->add_sysroot)
 166             str = concat (sysroot, p->fname, NULL);
 167           else if (!p->add_sysroot && relocated
 168                    && strncmp (p->fname, cpp_PREFIX, cpp_PREFIX_len) == 0)
 169             {
 170               static const char *relocated_prefix;
 171               /* If this path starts with the configure-time prefix,
 172                  but the compiler has been relocated, replace it
 173                  with the run-time prefix.  The run-time exec prefix
 174                  is GCC_EXEC_PREFIX.  Compute the path from there back
 175                  to the toplevel prefix.  */
 176               if (!relocated_prefix)
 177                 {
 178                   char *dummy;
 179                   /* Make relative prefix expects the first argument
 180                      to be a program, not a directory.  */
 181                   dummy = concat (gcc_exec_prefix, "dummy", NULL);
 182                   relocated_prefix
 183                     = make_relative_prefix (dummy,
 184                                             cpp_EXEC_PREFIX,
 185                                             cpp_PREFIX);
 186                 }
 187               str = concat (relocated_prefix,
 188                             p->fname + cpp_PREFIX_len,
 189                             NULL);
 190               str = update_path (str, p->component);
 191             }
 192           else
 193             str = update_path (p->fname, p->component);
 194
 195           if (p->multilib && imultilib)
 196             str = concat (str, dir_separator_str, imultilib, NULL);
 197
 198           add_path (str, SYSTEM, p->cxx_aware, false);
 199         }
 200     }
 201 }
 202
 203 /* For each duplicate path in chain HEAD, keep just the first one.
 204    Remove each path in chain HEAD that also exists in chain SYSTEM.
 205    Set the NEXT pointer of the last path in the resulting chain to
 206    JOIN, unless it duplicates JOIN in which case the last path is
 207    removed.  Return the head of the resulting chain.  Any of HEAD,
 208    JOIN and SYSTEM can be NULL.  */
 209
 210 static struct cpp_dir *
 211 remove_duplicates (cpp_reader *pfile, struct cpp_dir *head,
 212                    struct cpp_dir *system, struct cpp_dir *join,
 213                    int verbose)
 214 {
 215   struct cpp_dir **pcur, *tmp, *cur;
 216   struct stat st;
 217
 218   for (pcur = &head; *pcur; )
 219     {
 220       int reason = REASON_QUIET;
 221
 222       cur = *pcur;
 223
 224       if (stat (cur->name, &st))
 225         {
 226           /* Dirs that don't exist are silently ignored, unless verbose.  */
 227           if (errno != ENOENT)
 228             cpp_errno (pfile, CPP_DL_ERROR, cur->name);
 229           else
 230             {
 231               /* If -Wmissing-include-dirs is given, warn.  */
 232               cpp_options *opts = cpp_get_options (pfile);
 233               if (opts->warn_missing_include_dirs && cur->user_supplied_p)
 234                 cpp_errno (pfile, CPP_DL_WARNING, cur->name);
 235               reason = REASON_NOENT;
 236             }
 237         }
 238       else if (!S_ISDIR (st.st_mode))
 239         cpp_error_with_line (pfile, CPP_DL_ERROR, 0, 0,
 240                              "%s: not a directory", cur->name);
 241       else
 242         {
 243           INO_T_COPY (cur->ino, st.st_ino);
 244           cur->dev  = st.st_dev;
 245
 246           /* Remove this one if it is in the system chain.  */
 247           reason = REASON_DUP_SYS;
 248           for (tmp = system; tmp; tmp = tmp->next)
 249            if (INO_T_EQ (tmp->ino, cur->ino) && tmp->dev == cur->dev
 250                && cur->construct == tmp->construct)
 251               break;
 252
 253           if (!tmp)
 254             {
 255               /* Duplicate of something earlier in the same chain?  */
 256               reason = REASON_DUP;
 257               for (tmp = head; tmp != cur; tmp = tmp->next)
 258                if (INO_T_EQ (cur->ino, tmp->ino) && cur->dev == tmp->dev
 259                    && cur->construct == tmp->construct)
 260                   break;
 261
 262               if (tmp == cur
 263                   /* Last in the chain and duplicate of JOIN?  */
 264                   && !(cur->next == NULL && join
 265                        && INO_T_EQ (cur->ino, join->ino)
 266                       && cur->dev == join->dev
 267                       && cur->construct == join->construct))
 268                 {
 269                   /* Unique, so keep this directory.  */
 270                   pcur = &cur->next;
 271                   continue;
 272                 }
 273             }
 274         }
 275
 276       /* Remove this entry from the chain.  */
 277       *pcur = cur->next;
 278       free_path (cur, verbose ? reason: REASON_QUIET);
 279     }
 280
 281   *pcur = join;
 282   return head;
 283 }
 284
 285 /* Merge the four include chains together in the order quote, bracket,
 286    system, after.  Remove duplicate dirs (as determined by
 287    INO_T_EQ()).
 288
 289    We can't just merge the lists and then uniquify them because then
 290    we may lose directories from the <> search path that should be
 291    there; consider -iquote foo -iquote bar -Ifoo -Iquux.  It is
 292    however safe to treat -iquote bar -iquote foo -Ifoo -Iquux as if
 293    written -iquote bar -Ifoo -Iquux.  */
 294
 295 static void
 296 merge_include_chains (cpp_reader *pfile, int verbose)
 297 {
 298   /* Join the SYSTEM and AFTER chains.  Remove duplicates in the
 299      resulting SYSTEM chain.  */
 300   if (heads[SYSTEM])
 301     tails[SYSTEM]->next = heads[AFTER];
 302   else
 303     heads[SYSTEM] = heads[AFTER];
 304   heads[SYSTEM] = remove_duplicates (pfile, heads[SYSTEM], 0, 0, verbose);
 305
 306   /* Remove duplicates from BRACKET that are in itself or SYSTEM, and
 307      join it to SYSTEM.  */
 308   heads[BRACKET] = remove_duplicates (pfile, heads[BRACKET], heads[SYSTEM],
 309                                       heads[SYSTEM], verbose);
 310
 311   /* Remove duplicates from QUOTE that are in itself or SYSTEM, and
 312      join it to BRACKET.  */
 313   heads[QUOTE] = remove_duplicates (pfile, heads[QUOTE], heads[SYSTEM],
 314                                     heads[BRACKET], verbose);
 315
 316   /* If verbose, print the list of dirs to search.  */
 317   if (verbose)
 318     {
 319       struct cpp_dir *p;
 320
 321       fprintf (stderr, _("#include \"...\" search starts here:\n"));
 322       for (p = heads[QUOTE];; p = p->next)
 323         {
 324           if (p == heads[BRACKET])
 325             fprintf (stderr, _("#include <...> search starts here:\n"));
 326           if (!p)
 327             break;
 328           fprintf (stderr, " %s\n", p->name);
 329         }
 330       fprintf (stderr, _("End of search list.\n"));
 331     }
 332 }
 333
 334 /* Use given -I paths for #include "..." but not #include <...>, and
 335    don't search the directory of the present file for #include "...".
 336    (Note that -I. -I- is not the same as the default setup; -I. uses
 337    the compiler's working dir.)  */
 338 void
 339 split_quote_chain (void)
 340 {
 341   heads[QUOTE] = heads[BRACKET];
 342   tails[QUOTE] = tails[BRACKET];
 343   heads[BRACKET] = NULL;
 344   tails[BRACKET] = NULL;
 345   /* This is NOT redundant.  */
 346   quote_ignores_source_dir = true;
 347 }
 348
 349 /* Add P to the chain specified by CHAIN.  */
 350
 351 void
 352 add_cpp_dir_path (cpp_dir *p, int chain)
 353 {
 354   if (tails[chain])
 355     tails[chain]->next = p;
 356   else
 357     heads[chain] = p;
 358   tails[chain] = p;
 359 }
 360
 361 /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and
 362    NUL-terminated.  */
 363 void
 364 add_path (char *path, int chain, int cxx_aware, bool user_supplied_p)
 365 {
 366   cpp_dir *p;
 367
 368 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 369   /* Convert all backslashes to slashes.  The native CRT stat()
 370      function does not recognize a directory that ends in a backslash
 371      (unless it is a drive root dir, such "c:\").  Forward slashes,
 372      trailing or otherwise, cause no problems for stat().  */
 373   char* c;
 374   for (c = path; *c; c++)
 375     if (*c == '\\') *c = '/';
 376 #endif
 377
 378   p = XNEW (cpp_dir);
 379   p->next = NULL;
 380   p->name = path;
 381   if (chain == SYSTEM || chain == AFTER)
 382     p->sysp = 1 + !cxx_aware;
 383   else
 384     p->sysp = 0;
 385   p->construct = 0;
 386   p->user_supplied_p = user_supplied_p;
 387
 388   add_cpp_dir_path (p, chain);
 389 }
 390
 391 /* Exported function to handle include chain merging, duplicate
 392    removal, and registration with cpplib.  */
 393 void
 394 register_include_chains (cpp_reader *pfile, const char *sysroot,
 395                          const char *iprefix, const char *imultilib,
 396                          int stdinc, int cxx_stdinc, int verbose)
 397 {
 398   static const char *const lang_env_vars[] =
 399     { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH",
 400       "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" };
 401   cpp_options *cpp_opts = cpp_get_options (pfile);
 402   size_t idx = (cpp_opts->objc ? 2: 0);
 403
 404   if (cpp_opts->cplusplus)
 405     idx++;
 406   else
 407     cxx_stdinc = false;
 408
 409   /* CPATH and language-dependent environment variables may add to the
 410      include chain.  */
 411   add_env_var_paths ("CPATH", BRACKET);
 412   add_env_var_paths (lang_env_vars[idx], SYSTEM);
 413
 414   target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc);
 415
 416   /* Finally chain on the standard directories.  */
 417   if (stdinc)
 418     add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc);
 419
 420   target_c_incpath.extra_includes (sysroot, iprefix, stdinc);
 421
 422   merge_include_chains (pfile, verbose);
 423
 424   cpp_set_include_chains (pfile, heads[QUOTE], heads[BRACKET],
 425                           quote_ignores_source_dir);
 426 }
 427 #if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES)
 428 static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED,
 429                                            const char *iprefix ATTRIBUTE_UNUSED,
 430                                            int stdinc ATTRIBUTE_UNUSED)
 431 {
 432 }
 433 #endif
 434
 435 #ifndef TARGET_EXTRA_INCLUDES
 436 #define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int
 437 #endif
 438 #ifndef TARGET_EXTRA_PRE_INCLUDES
 439 #define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int
 440 #endif
 441
 442 struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES };
 443