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             {
 169               /* If the compiler is relocated, and this is a configured
 170                  prefix relative path, then we use gcc_exec_prefix instead
 171                  of the configured prefix.  */
 172               gcc_assert (strncmp (p->fname, cpp_PREFIX,
 173                                      cpp_PREFIX_len) == 0);
 174               str = concat (gcc_exec_prefix, p->fname
 175                               + cpp_PREFIX_len, NULL);
 176               str = update_path (str, p->component);
 177             }
 178           else
 179             str = update_path (p->fname, p->component);
 180
 181           if (p->multilib && imultilib)
 182             str = concat (str, dir_separator_str, imultilib, NULL);
 183
 184           add_path (str, SYSTEM, p->cxx_aware, false);
 185         }
 186     }
 187 }
 188
 189 /* For each duplicate path in chain HEAD, keep just the first one.
 190    Remove each path in chain HEAD that also exists in chain SYSTEM.
 191    Set the NEXT pointer of the last path in the resulting chain to
 192    JOIN, unless it duplicates JOIN in which case the last path is
 193    removed.  Return the head of the resulting chain.  Any of HEAD,
 194    JOIN and SYSTEM can be NULL.  */
 195
 196 static struct cpp_dir *
 197 remove_duplicates (cpp_reader *pfile, struct cpp_dir *head,
 198                    struct cpp_dir *system, struct cpp_dir *join,
 199                    int verbose)
 200 {
 201   struct cpp_dir **pcur, *tmp, *cur;
 202   struct stat st;
 203
 204   for (pcur = &head; *pcur; )
 205     {
 206       int reason = REASON_QUIET;
 207
 208       cur = *pcur;
 209
 210       if (stat (cur->name, &st))
 211         {
 212           /* Dirs that don't exist are silently ignored, unless verbose.  */
 213           if (errno != ENOENT)
 214             cpp_errno (pfile, CPP_DL_ERROR, cur->name);
 215           else
 216             {
 217               /* If -Wmissing-include-dirs is given, warn.  */
 218               cpp_options *opts = cpp_get_options (pfile);
 219               if (opts->warn_missing_include_dirs && cur->user_supplied_p)
 220                 cpp_errno (pfile, CPP_DL_WARNING, cur->name);
 221               reason = REASON_NOENT;
 222             }
 223         }
 224       else if (!S_ISDIR (st.st_mode))
 225         cpp_error_with_line (pfile, CPP_DL_ERROR, 0, 0,
 226                              "%s: not a directory", cur->name);
 227       else
 228         {
 229           INO_T_COPY (cur->ino, st.st_ino);
 230           cur->dev  = st.st_dev;
 231
 232           /* Remove this one if it is in the system chain.  */
 233           reason = REASON_DUP_SYS;
 234           for (tmp = system; tmp; tmp = tmp->next)
 235            if (INO_T_EQ (tmp->ino, cur->ino) && tmp->dev == cur->dev
 236                && cur->construct == tmp->construct)
 237               break;
 238
 239           if (!tmp)
 240             {
 241               /* Duplicate of something earlier in the same chain?  */
 242               reason = REASON_DUP;
 243               for (tmp = head; tmp != cur; tmp = tmp->next)
 244                if (INO_T_EQ (cur->ino, tmp->ino) && cur->dev == tmp->dev
 245                    && cur->construct == tmp->construct)
 246                   break;
 247
 248               if (tmp == cur
 249                   /* Last in the chain and duplicate of JOIN?  */
 250                   && !(cur->next == NULL && join
 251                        && INO_T_EQ (cur->ino, join->ino)
 252                       && cur->dev == join->dev
 253                       && cur->construct == join->construct))
 254                 {
 255                   /* Unique, so keep this directory.  */
 256                   pcur = &cur->next;
 257                   continue;
 258                 }
 259             }
 260         }
 261
 262       /* Remove this entry from the chain.  */
 263       *pcur = cur->next;
 264       free_path (cur, verbose ? reason: REASON_QUIET);
 265     }
 266
 267   *pcur = join;
 268   return head;
 269 }
 270
 271 /* Merge the four include chains together in the order quote, bracket,
 272    system, after.  Remove duplicate dirs (as determined by
 273    INO_T_EQ()).
 274
 275    We can't just merge the lists and then uniquify them because then
 276    we may lose directories from the <> search path that should be
 277    there; consider -iquote foo -iquote bar -Ifoo -Iquux.  It is
 278    however safe to treat -iquote bar -iquote foo -Ifoo -Iquux as if
 279    written -iquote bar -Ifoo -Iquux.  */
 280
 281 static void
 282 merge_include_chains (cpp_reader *pfile, int verbose)
 283 {
 284   /* Join the SYSTEM and AFTER chains.  Remove duplicates in the
 285      resulting SYSTEM chain.  */
 286   if (heads[SYSTEM])
 287     tails[SYSTEM]->next = heads[AFTER];
 288   else
 289     heads[SYSTEM] = heads[AFTER];
 290   heads[SYSTEM] = remove_duplicates (pfile, heads[SYSTEM], 0, 0, verbose);
 291
 292   /* Remove duplicates from BRACKET that are in itself or SYSTEM, and
 293      join it to SYSTEM.  */
 294   heads[BRACKET] = remove_duplicates (pfile, heads[BRACKET], heads[SYSTEM],
 295                                       heads[SYSTEM], verbose);
 296
 297   /* Remove duplicates from QUOTE that are in itself or SYSTEM, and
 298      join it to BRACKET.  */
 299   heads[QUOTE] = remove_duplicates (pfile, heads[QUOTE], heads[SYSTEM],
 300                                     heads[BRACKET], verbose);
 301
 302   /* If verbose, print the list of dirs to search.  */
 303   if (verbose)
 304     {
 305       struct cpp_dir *p;
 306
 307       fprintf (stderr, _("#include \"...\" search starts here:\n"));
 308       for (p = heads[QUOTE];; p = p->next)
 309         {
 310           if (p == heads[BRACKET])
 311             fprintf (stderr, _("#include <...> search starts here:\n"));
 312           if (!p)
 313             break;
 314           fprintf (stderr, " %s\n", p->name);
 315         }
 316       fprintf (stderr, _("End of search list.\n"));
 317     }
 318 }
 319
 320 /* Use given -I paths for #include "..." but not #include <...>, and
 321    don't search the directory of the present file for #include "...".
 322    (Note that -I. -I- is not the same as the default setup; -I. uses
 323    the compiler's working dir.)  */
 324 void
 325 split_quote_chain (void)
 326 {
 327   heads[QUOTE] = heads[BRACKET];
 328   tails[QUOTE] = tails[BRACKET];
 329   heads[BRACKET] = NULL;
 330   tails[BRACKET] = NULL;
 331   /* This is NOT redundant.  */
 332   quote_ignores_source_dir = true;
 333 }
 334
 335 /* Add P to the chain specified by CHAIN.  */
 336
 337 void
 338 add_cpp_dir_path (cpp_dir *p, int chain)
 339 {
 340   if (tails[chain])
 341     tails[chain]->next = p;
 342   else
 343     heads[chain] = p;
 344   tails[chain] = p;
 345 }
 346
 347 /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and
 348    NUL-terminated.  */
 349 void
 350 add_path (char *path, int chain, int cxx_aware, bool user_supplied_p)
 351 {
 352   cpp_dir *p;
 353
 354 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 355   /* Convert all backslashes to slashes.  The native CRT stat()
 356      function does not recognize a directory that ends in a backslash
 357      (unless it is a drive root dir, such "c:\").  Forward slashes,
 358      trailing or otherwise, cause no problems for stat().  */
 359   char* c;
 360   for (c = path; *c; c++)
 361     if (*c == '\\') *c = '/';
 362 #endif
 363
 364   p = XNEW (cpp_dir);
 365   p->next = NULL;
 366   p->name = path;
 367   if (chain == SYSTEM || chain == AFTER)
 368     p->sysp = 1 + !cxx_aware;
 369   else
 370     p->sysp = 0;
 371   p->construct = 0;
 372   p->user_supplied_p = user_supplied_p;
 373
 374   add_cpp_dir_path (p, chain);
 375 }
 376
 377 /* Exported function to handle include chain merging, duplicate
 378    removal, and registration with cpplib.  */
 379 void
 380 register_include_chains (cpp_reader *pfile, const char *sysroot,
 381                          const char *iprefix, const char *imultilib,
 382                          int stdinc, int cxx_stdinc, int verbose)
 383 {
 384   static const char *const lang_env_vars[] =
 385     { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH",
 386       "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" };
 387   cpp_options *cpp_opts = cpp_get_options (pfile);
 388   size_t idx = (cpp_opts->objc ? 2: 0);
 389
 390   if (cpp_opts->cplusplus)
 391     idx++;
 392   else
 393     cxx_stdinc = false;
 394
 395   /* CPATH and language-dependent environment variables may add to the
 396      include chain.  */
 397   add_env_var_paths ("CPATH", BRACKET);
 398   add_env_var_paths (lang_env_vars[idx], SYSTEM);
 399
 400   target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc);
 401
 402   /* Finally chain on the standard directories.  */
 403   if (stdinc)
 404     add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc);
 405
 406   target_c_incpath.extra_includes (sysroot, iprefix, stdinc);
 407
 408   merge_include_chains (pfile, verbose);
 409
 410   cpp_set_include_chains (pfile, heads[QUOTE], heads[BRACKET],
 411                           quote_ignores_source_dir);
 412 }
 413 #if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES)
 414 static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED,
 415                                            const char *iprefix ATTRIBUTE_UNUSED,
 416                                            int stdinc ATTRIBUTE_UNUSED)
 417 {
 418 }
 419 #endif
 420
 421 #ifndef TARGET_EXTRA_INCLUDES
 422 #define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int
 423 #endif
 424 #ifndef TARGET_EXTRA_PRE_INCLUDES
 425 #define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int
 426 #endif
 427
 428 struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES };
 429