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