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 Free Software Foundation, Inc.
4
5   Broken out of cppinit.c and cppfiles.c and rewritten Mar 2003.
6
7This program is free software; you can redistribute it and/or modify it
8under the terms of the GNU General Public License as published by the
9Free Software Foundation; either version 2, or (at your option) any
10later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
48static void add_env_var_paths (const char *, int);
49static void add_standard_paths (const char *, const char *, int);
50static void free_path (struct cpp_dir *, int);
51static void merge_include_chains (cpp_reader *, int);
52static 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.  */
57static struct cpp_dir *heads[4];
58static struct cpp_dir *tails[4];
59static bool quote_ignores_source_dir;
60enum { REASON_QUIET = 0, REASON_NOENT, REASON_DUP, REASON_DUP_SYS };
61
62/* Free an element of the include chain, possibly giving a reason.  */
63static void
64free_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.  */
92static void
93add_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, false);
118    }
119}
120
121/* Append the standard include chain defined in cppdefault.c.  */
122static void
123add_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, i.e. 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, false);
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, false);
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
175static struct cpp_dir *
176remove_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	    {
196	      /* If -Wmissing-include-dirs is given, warn.  */
197	      cpp_options *opts = cpp_get_options (pfile);
198	      if (opts->warn_missing_include_dirs && cur->user_supplied_p)
199		cpp_errno (pfile, CPP_DL_WARNING, cur->name);
200	      reason = REASON_NOENT;
201	    }
202	}
203      else if (!S_ISDIR (st.st_mode))
204	cpp_error_with_line (pfile, CPP_DL_ERROR, 0, 0,
205			     "%s: not a directory", cur->name);
206      else
207	{
208	  INO_T_COPY (cur->ino, st.st_ino);
209	  cur->dev  = st.st_dev;
210
211	  /* Remove this one if it is in the system chain.  */
212	  reason = REASON_DUP_SYS;
213	  for (tmp = system; tmp; tmp = tmp->next)
214           if (INO_T_EQ (tmp->ino, cur->ino) && tmp->dev == cur->dev
215               && cur->construct == tmp->construct)
216	      break;
217
218	  if (!tmp)
219	    {
220	      /* Duplicate of something earlier in the same chain?  */
221	      reason = REASON_DUP;
222	      for (tmp = head; tmp != cur; tmp = tmp->next)
223               if (INO_T_EQ (cur->ino, tmp->ino) && cur->dev == tmp->dev
224                   && cur->construct == tmp->construct)
225		  break;
226
227	      if (tmp == cur
228		  /* Last in the chain and duplicate of JOIN?  */
229		  && !(cur->next == NULL && join
230		       && INO_T_EQ (cur->ino, join->ino)
231                      && cur->dev == join->dev
232                      && cur->construct == join->construct))
233		{
234		  /* Unique, so keep this directory.  */
235		  pcur = &cur->next;
236		  continue;
237		}
238	    }
239	}
240
241      /* Remove this entry from the chain.  */
242      *pcur = cur->next;
243      free_path (cur, verbose ? reason: REASON_QUIET);
244    }
245
246  *pcur = join;
247  return head;
248}
249
250/* Merge the four include chains together in the order quote, bracket,
251   system, after.  Remove duplicate dirs (as determined by
252   INO_T_EQ()).
253
254   We can't just merge the lists and then uniquify them because then
255   we may lose directories from the <> search path that should be
256   there; consider -iquote foo -iquote bar -Ifoo -Iquux.  It is
257   however safe to treat -iquote bar -iquote foo -Ifoo -Iquux as if
258   written -iquote bar -Ifoo -Iquux.  */
259
260static void
261merge_include_chains (cpp_reader *pfile, int verbose)
262{
263  /* Join the SYSTEM and AFTER chains.  Remove duplicates in the
264     resulting SYSTEM chain.  */
265  if (heads[SYSTEM])
266    tails[SYSTEM]->next = heads[AFTER];
267  else
268    heads[SYSTEM] = heads[AFTER];
269  heads[SYSTEM] = remove_duplicates (pfile, heads[SYSTEM], 0, 0, verbose);
270
271  /* Remove duplicates from BRACKET that are in itself or SYSTEM, and
272     join it to SYSTEM.  */
273  heads[BRACKET] = remove_duplicates (pfile, heads[BRACKET], heads[SYSTEM],
274				      heads[SYSTEM], verbose);
275
276  /* Remove duplicates from QUOTE that are in itself or SYSTEM, and
277     join it to BRACKET.  */
278  heads[QUOTE] = remove_duplicates (pfile, heads[QUOTE], heads[SYSTEM],
279				    heads[BRACKET], verbose);
280
281  /* If verbose, print the list of dirs to search.  */
282  if (verbose)
283    {
284      struct cpp_dir *p;
285
286      fprintf (stderr, _("#include \"...\" search starts here:\n"));
287      for (p = heads[QUOTE];; p = p->next)
288	{
289	  if (p == heads[BRACKET])
290	    fprintf (stderr, _("#include <...> search starts here:\n"));
291	  if (!p)
292	    break;
293	  fprintf (stderr, " %s\n", p->name);
294	}
295      fprintf (stderr, _("End of search list.\n"));
296    }
297}
298
299/* Use given -I paths for #include "..." but not #include <...>, and
300   don't search the directory of the present file for #include "...".
301   (Note that -I. -I- is not the same as the default setup; -I. uses
302   the compiler's working dir.)  */
303void
304split_quote_chain (void)
305{
306  heads[QUOTE] = heads[BRACKET];
307  tails[QUOTE] = tails[BRACKET];
308  heads[BRACKET] = NULL;
309  tails[BRACKET] = NULL;
310  /* This is NOT redundant.  */
311  quote_ignores_source_dir = true;
312}
313
314/* Add P to the chain specified by CHAIN.  */
315
316void
317add_cpp_dir_path (cpp_dir *p, int chain)
318{
319  if (tails[chain])
320    tails[chain]->next = p;
321  else
322    heads[chain] = p;
323  tails[chain] = p;
324}
325
326/* Add PATH to the include chain CHAIN. PATH must be malloc-ed and
327   NUL-terminated.  */
328void
329add_path (char *path, int chain, int cxx_aware, bool user_supplied_p)
330{
331  cpp_dir *p;
332
333#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
334  /* Convert all backslashes to slashes.  The native CRT stat()
335     function does not recognize a directory that ends in a backslash
336     (unless it is a drive root dir, such "c:\").  Forward slashes,
337     trailing or otherwise, cause no problems for stat().  */
338  char* c;
339  for (c = path; *c; c++)
340    if (*c == '\\') *c = '/';
341#endif
342
343  p = xmalloc (sizeof (cpp_dir));
344  p->next = NULL;
345  p->name = path;
346  if (chain == SYSTEM || chain == AFTER)
347    p->sysp = 1 + !cxx_aware;
348  else
349    p->sysp = 0;
350  p->construct = 0;
351  p->user_supplied_p = user_supplied_p;
352
353  add_cpp_dir_path (p, chain);
354}
355
356/* Exported function to handle include chain merging, duplicate
357   removal, and registration with cpplib.  */
358void
359register_include_chains (cpp_reader *pfile, const char *sysroot,
360			 const char *iprefix, int stdinc, int cxx_stdinc,
361			 int verbose)
362{
363  static const char *const lang_env_vars[] =
364    { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH",
365      "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" };
366  cpp_options *cpp_opts = cpp_get_options (pfile);
367  size_t idx = (cpp_opts->objc ? 2: 0);
368
369  if (cpp_opts->cplusplus)
370    idx++;
371  else
372    cxx_stdinc = false;
373
374  /* CPATH and language-dependent environment variables may add to the
375     include chain.  */
376  add_env_var_paths ("CPATH", BRACKET);
377  add_env_var_paths (lang_env_vars[idx], SYSTEM);
378
379  target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc);
380
381  /* Finally chain on the standard directories.  */
382  if (stdinc)
383    add_standard_paths (sysroot, iprefix, cxx_stdinc);
384
385  target_c_incpath.extra_includes (sysroot, iprefix, stdinc);
386
387  merge_include_chains (pfile, verbose);
388
389  cpp_set_include_chains (pfile, heads[QUOTE], heads[BRACKET],
390			  quote_ignores_source_dir);
391}
392#if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES)
393static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED,
394					   const char *iprefix ATTRIBUTE_UNUSED,
395					   int stdinc ATTRIBUTE_UNUSED)
396{
397}
398#endif
399
400#ifndef TARGET_EXTRA_INCLUDES
401#define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int
402#endif
403#ifndef TARGET_EXTRA_PRE_INCLUDES
404#define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int
405#endif
406
407struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES };
408
409