Mercurial > hg > CbC > CbC_gcc

comparison gcc/incpath.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 77e2b8dfacca
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
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, 2007, 2008
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 3, 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; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
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 "incpath.h"
32 #include "cppdefault.h"
33
34 /* Microsoft Windows does not natively support inodes.
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 #elif !defined (HOST_LACKS_INODE_NUMBERS)
40 # define INO_T_EQ(A, B) ((A) == (B))
41 # define INO_T_COPY(DEST, SRC) (DEST) = (SRC)
42 #endif
43
44 #if defined INO_T_EQ
45 #define DIRS_EQ(A, B) ((A)->dev == (B)->dev \
46 && INO_T_EQ((A)->ino, (B)->ino))
47 #else
48 #define DIRS_EQ(A, B) (!strcmp ((A)->canonical_name, (B)->canonical_name))
49 #endif
50
51 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
52
53 static void add_env_var_paths (const char *, int);
54 static void add_standard_paths (const char *, const char *, const char *, int);
55 static void free_path (struct cpp_dir *, int);
56 static void merge_include_chains (const char *, cpp_reader *, int);
57 static void add_sysroot_to_chain (const char *, int);
58 static struct cpp_dir *remove_duplicates (cpp_reader *, struct cpp_dir *,
59 struct cpp_dir *,
60 struct cpp_dir *, int);
61
62 /* Include chains heads and tails. */
63 static struct cpp_dir *heads[4];
64 static struct cpp_dir *tails[4];
65 static bool quote_ignores_source_dir;
66 enum { REASON_QUIET = 0, REASON_NOENT, REASON_DUP, REASON_DUP_SYS };
67
68 /* Free an element of the include chain, possibly giving a reason. */
69 static void
70 free_path (struct cpp_dir *path, int reason)
71 {
72 switch (reason)
73 {
74 case REASON_DUP:
75 case REASON_DUP_SYS:
76 fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), path->name);
77 if (reason == REASON_DUP_SYS)
78 fprintf (stderr,
79 _(" as it is a non-system directory that duplicates a system directory\n"));
80 break;
81
82 case REASON_NOENT:
83 fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"),
84 path->name);
85 break;
86
87 case REASON_QUIET:
88 default:
89 break;
90 }
91
92 free (path->name);
93 free (path);
94 }
95
96 /* Read ENV_VAR for a PATH_SEPARATOR-separated list of file names; and
97 append all the names to the search path CHAIN. */
98 static void
99 add_env_var_paths (const char *env_var, int chain)
100 {
101 char *p, *q, *path;
102
103 GET_ENVIRONMENT (q, env_var);
104
105 if (!q)
106 return;
107
108 for (p = q; *q; p = q + 1)
109 {
110 q = p;
111 while (*q != 0 && *q != PATH_SEPARATOR)
112 q++;
113
114 if (p == q)
115 path = xstrdup (".");
116 else
117 {
118 path = XNEWVEC (char, q - p + 1);
119 memcpy (path, p, q - p);
120 path[q - p] = '\0';
121 }
122
123 add_path (path, chain, chain == SYSTEM, false);
124 }
125 }
126
127 /* Append the standard include chain defined in cppdefault.c. */
128 static void
129 add_standard_paths (const char *sysroot, const char *iprefix,
130 const char *imultilib, int cxx_stdinc)
131 {
132 const struct default_include *p;
133 int relocated = cpp_relocated();
134 size_t len;
135
136 if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0)
137 {
138 /* Look for directories that start with the standard prefix.
139 "Translate" them, i.e. replace /usr/local/lib/gcc... with
140 IPREFIX and search them first. */
141 for (p = cpp_include_defaults; p->fname; p++)
142 {
143 if (!p->cplusplus || cxx_stdinc)
144 {
145 /* Should we be translating sysrooted dirs too? Assume
146 that iprefix and sysroot are mutually exclusive, for
147 now. */
148 if (sysroot && p->add_sysroot)
149 continue;
150 if (!strncmp (p->fname, cpp_GCC_INCLUDE_DIR, len))
151 {
152 char *str = concat (iprefix, p->fname + len, NULL);
153 if (p->multilib && imultilib)
154 str = concat (str, dir_separator_str, imultilib, NULL);
155 add_path (str, SYSTEM, p->cxx_aware, false);
156 }
157 }
158 }
159 }
160
161 for (p = cpp_include_defaults; p->fname; p++)
162 {
163 if (!p->cplusplus || cxx_stdinc)
164 {
165 char *str;
166
167 /* Should this directory start with the sysroot? */
168 if (sysroot && p->add_sysroot)
169 str = concat (sysroot, p->fname, NULL);
170 else if (!p->add_sysroot && relocated
171 && strncmp (p->fname, cpp_PREFIX, cpp_PREFIX_len) == 0)
172 {
173 static const char *relocated_prefix;
174 /* If this path starts with the configure-time prefix,
175 but the compiler has been relocated, replace it
176 with the run-time prefix. The run-time exec prefix
177 is GCC_EXEC_PREFIX. Compute the path from there back
178 to the toplevel prefix. */
179 if (!relocated_prefix)
180 {
181 char *dummy;
182 /* Make relative prefix expects the first argument
183 to be a program, not a directory. */
184 dummy = concat (gcc_exec_prefix, "dummy", NULL);
185 relocated_prefix
186 = make_relative_prefix (dummy,
187 cpp_EXEC_PREFIX,
188 cpp_PREFIX);
189 }
190 str = concat (relocated_prefix,
191 p->fname + cpp_PREFIX_len,
192 NULL);
193 str = update_path (str, p->component);
194 }
195 else
196 str = update_path (p->fname, p->component);
197
198 if (p->multilib && imultilib)
199 str = concat (str, dir_separator_str, imultilib, NULL);
200
201 add_path (str, SYSTEM, p->cxx_aware, false);
202 }
203 }
204 }
205
206 /* For each duplicate path in chain HEAD, keep just the first one.
207 Remove each path in chain HEAD that also exists in chain SYSTEM.
208 Set the NEXT pointer of the last path in the resulting chain to
209 JOIN, unless it duplicates JOIN in which case the last path is
210 removed. Return the head of the resulting chain. Any of HEAD,
211 JOIN and SYSTEM can be NULL. */
212
213 static struct cpp_dir *
214 remove_duplicates (cpp_reader *pfile, struct cpp_dir *head,
215 struct cpp_dir *system, struct cpp_dir *join,
216 int verbose)
217 {
218 struct cpp_dir **pcur, *tmp, *cur;
219 struct stat st;
220
221 for (pcur = &head; *pcur; )
222 {
223 int reason = REASON_QUIET;
224
225 cur = *pcur;
226
227 if (stat (cur->name, &st))
228 {
229 /* Dirs that don't exist are silently ignored, unless verbose. */
230 if (errno != ENOENT)
231 cpp_errno (pfile, CPP_DL_ERROR, cur->name);
232 else
233 {
234 /* If -Wmissing-include-dirs is given, warn. */
235 cpp_options *opts = cpp_get_options (pfile);
236 if (opts->warn_missing_include_dirs && cur->user_supplied_p)
237 cpp_errno (pfile, CPP_DL_WARNING, cur->name);
238 reason = REASON_NOENT;
239 }
240 }
241 else if (!S_ISDIR (st.st_mode))
242 cpp_error_with_line (pfile, CPP_DL_ERROR, 0, 0,
243 "%s: not a directory", cur->name);
244 else
245 {
246 #if defined (INO_T_COPY)
247 INO_T_COPY (cur->ino, st.st_ino);
248 cur->dev = st.st_dev;
249 #endif
250
251 /* Remove this one if it is in the system chain. */
252 reason = REASON_DUP_SYS;
253 for (tmp = system; tmp; tmp = tmp->next)
254 if (DIRS_EQ (tmp, cur) && cur->construct == tmp->construct)
255 break;
256
257 if (!tmp)
258 {
259 /* Duplicate of something earlier in the same chain? */
260 reason = REASON_DUP;
261 for (tmp = head; tmp != cur; tmp = tmp->next)
262 if (DIRS_EQ (cur, tmp) && cur->construct == tmp->construct)
263 break;
264
265 if (tmp == cur
266 /* Last in the chain and duplicate of JOIN? */
267 && !(cur->next == NULL && join
268 && DIRS_EQ (cur, join)
269 && cur->construct == join->construct))
270 {
271 /* Unique, so keep this directory. */
272 pcur = &cur->next;
273 continue;
274 }
275 }
276 }
277
278 /* Remove this entry from the chain. */
279 *pcur = cur->next;
280 free_path (cur, verbose ? reason: REASON_QUIET);
281 }
282
283 *pcur = join;
284 return head;
285 }
286
287 /* Add SYSROOT to any user-supplied paths in CHAIN starting with
288 "=". */
289
290 static void
291 add_sysroot_to_chain (const char *sysroot, int chain)
292 {
293 struct cpp_dir *p;
294
295 for (p = heads[chain]; p != NULL; p = p->next)
296 if (p->name[0] == '=' && p->user_supplied_p)
297 p->name = concat (sysroot, p->name + 1, NULL);
298 }
299
300 /* Merge the four include chains together in the order quote, bracket,
301 system, after. Remove duplicate dirs (determined in
302 system-specific manner).
303
304 We can't just merge the lists and then uniquify them because then
305 we may lose directories from the <> search path that should be
306 there; consider -iquote foo -iquote bar -Ifoo -Iquux. It is
307 however safe to treat -iquote bar -iquote foo -Ifoo -Iquux as if
308 written -iquote bar -Ifoo -Iquux. */
309
310 static void
311 merge_include_chains (const char *sysroot, cpp_reader *pfile, int verbose)
312 {
313 /* Add the sysroot to user-supplied paths starting with "=". */
314 if (sysroot)
315 {
316 add_sysroot_to_chain (sysroot, QUOTE);
317 add_sysroot_to_chain (sysroot, BRACKET);
318 add_sysroot_to_chain (sysroot, SYSTEM);
319 add_sysroot_to_chain (sysroot, AFTER);
320 }
321
322 /* Join the SYSTEM and AFTER chains. Remove duplicates in the
323 resulting SYSTEM chain. */
324 if (heads[SYSTEM])
325 tails[SYSTEM]->next = heads[AFTER];
326 else
327 heads[SYSTEM] = heads[AFTER];
328 heads[SYSTEM] = remove_duplicates (pfile, heads[SYSTEM], 0, 0, verbose);
329
330 /* Remove duplicates from BRACKET that are in itself or SYSTEM, and
331 join it to SYSTEM. */
332 heads[BRACKET] = remove_duplicates (pfile, heads[BRACKET], heads[SYSTEM],
333 heads[SYSTEM], verbose);
334
335 /* Remove duplicates from QUOTE that are in itself or SYSTEM, and
336 join it to BRACKET. */
337 heads[QUOTE] = remove_duplicates (pfile, heads[QUOTE], heads[SYSTEM],
338 heads[BRACKET], verbose);
339
340 /* If verbose, print the list of dirs to search. */
341 if (verbose)
342 {
343 struct cpp_dir *p;
344
345 fprintf (stderr, _("#include \"...\" search starts here:\n"));
346 for (p = heads[QUOTE];; p = p->next)
347 {
348 if (p == heads[BRACKET])
349 fprintf (stderr, _("#include <...> search starts here:\n"));
350 if (!p)
351 break;
352 fprintf (stderr, " %s\n", p->name);
353 }
354 fprintf (stderr, _("End of search list.\n"));
355 }
356 }
357
358 /* Use given -I paths for #include "..." but not #include <...>, and
359 don't search the directory of the present file for #include "...".
360 (Note that -I. -I- is not the same as the default setup; -I. uses
361 the compiler's working dir.) */
362 void
363 split_quote_chain (void)
364 {
365 heads[QUOTE] = heads[BRACKET];
366 tails[QUOTE] = tails[BRACKET];
367 heads[BRACKET] = NULL;
368 tails[BRACKET] = NULL;
369 /* This is NOT redundant. */
370 quote_ignores_source_dir = true;
371 }
372
373 /* Add P to the chain specified by CHAIN. */
374
375 void
376 add_cpp_dir_path (cpp_dir *p, int chain)
377 {
378 if (tails[chain])
379 tails[chain]->next = p;
380 else
381 heads[chain] = p;
382 tails[chain] = p;
383 }
384
385 /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and
386 NUL-terminated. */
387 void
388 add_path (char *path, int chain, int cxx_aware, bool user_supplied_p)
389 {
390 cpp_dir *p;
391
392 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
393 /* Remove unnecessary trailing slashes. On some versions of MS
394 Windows, trailing _forward_ slashes cause no problems for stat().
395 On newer versions, stat() does not recognize a directory that ends
396 in a '\\' or '/', unless it is a drive root dir, such as "c:/",
397 where it is obligatory. */
398 int pathlen = strlen (path);
399 char* end = path + pathlen - 1;
400 /* Preserve the lead '/' or lead "c:/". */
401 char* start = path + (pathlen > 2 && path[1] == ':' ? 3 : 1);
402
403 for (; end > start && IS_DIR_SEPARATOR (*end); end--)
404 *end = 0;
405 #endif
406
407 p = XNEW (cpp_dir);
408 p->next = NULL;
409 p->name = path;
410 #ifndef INO_T_EQ
411 p->canonical_name = lrealpath (path);
412 #endif
413 if (chain == SYSTEM || chain == AFTER)
414 p->sysp = 1 + !cxx_aware;
415 else
416 p->sysp = 0;
417 p->construct = 0;
418 p->user_supplied_p = user_supplied_p;
419
420 add_cpp_dir_path (p, chain);
421 }
422
423 /* Exported function to handle include chain merging, duplicate
424 removal, and registration with cpplib. */
425 void
426 register_include_chains (cpp_reader *pfile, const char *sysroot,
427 const char *iprefix, const char *imultilib,
428 int stdinc, int cxx_stdinc, int verbose)
429 {
430 static const char *const lang_env_vars[] =
431 { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH",
432 "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" };
433 cpp_options *cpp_opts = cpp_get_options (pfile);
434 size_t idx = (cpp_opts->objc ? 2: 0);
435
436 if (cpp_opts->cplusplus)
437 idx++;
438 else
439 cxx_stdinc = false;
440
441 /* CPATH and language-dependent environment variables may add to the
442 include chain. */
443 add_env_var_paths ("CPATH", BRACKET);
444 add_env_var_paths (lang_env_vars[idx], SYSTEM);
445
446 target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc);
447
448 /* Finally chain on the standard directories. */
449 if (stdinc)
450 add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc);
451
452 target_c_incpath.extra_includes (sysroot, iprefix, stdinc);
453
454 merge_include_chains (sysroot, pfile, verbose);
455
456 cpp_set_include_chains (pfile, heads[QUOTE], heads[BRACKET],
457 quote_ignores_source_dir);
458 }
459 #if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES)
460 static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED,
461 const char *iprefix ATTRIBUTE_UNUSED,
462 int stdinc ATTRIBUTE_UNUSED)
463 {
464 }
465 #endif
466
467 #ifndef TARGET_EXTRA_INCLUDES
468 #define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int
469 #endif
470 #ifndef TARGET_EXTRA_PRE_INCLUDES
471 #define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int
472 #endif
473
474 struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES };
475