]>
Commit | Line | Data |
---|---|---|
5793b276 | 1 | /* Set up combined include path chain for the preprocessor. |
99dee823 | 2 | Copyright (C) 1986-2021 Free Software Foundation, Inc. |
5793b276 NB |
3 | |
4 | Broken out of cppinit.c and cppfiles.c and rewritten Mar 2003. | |
5 | ||
9dcd6f09 NC |
6 | This program is free software; you can redistribute it and/or modify it |
7 | under the terms of the GNU General Public License as published by the | |
8 | Free Software Foundation; either version 3, or (at your option) any | |
9 | later version. | |
5793b276 | 10 | |
9dcd6f09 NC |
11 | This program is distributed in the hope that it will be useful, |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
5793b276 | 15 | |
9dcd6f09 NC |
16 | You should have received a copy of the GNU General Public License |
17 | along with this program; see the file COPYING3. If not see | |
18 | <http://www.gnu.org/licenses/>. */ | |
5793b276 NB |
19 | |
20 | #include "config.h" | |
21 | #include "system.h" | |
22 | #include "coretypes.h" | |
94d1613b | 23 | #include "target.h" |
5793b276 NB |
24 | #include "cpplib.h" |
25 | #include "prefix.h" | |
26 | #include "intl.h" | |
670637ee | 27 | #include "incpath.h" |
5793b276 NB |
28 | #include "cppdefault.h" |
29 | ||
c100de59 | 30 | /* Microsoft Windows does not natively support inodes. |
5793b276 NB |
31 | VMS has non-numeric inodes. */ |
32 | #ifdef VMS | |
33 | # define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A))) | |
c3284718 | 34 | # define INO_T_COPY(DEST, SRC) memcpy (&(DEST), &(SRC), sizeof (SRC)) |
c100de59 | 35 | #elif !defined (HOST_LACKS_INODE_NUMBERS) |
498f1c82 | 36 | # define INO_T_EQ(A, B) ((A) == (B)) |
5793b276 NB |
37 | # define INO_T_COPY(DEST, SRC) (DEST) = (SRC) |
38 | #endif | |
39 | ||
498f1c82 NS |
40 | #if defined INO_T_EQ |
41 | #define DIRS_EQ(A, B) ((A)->dev == (B)->dev \ | |
c3284718 | 42 | && INO_T_EQ ((A)->ino, (B)->ino)) |
498f1c82 | 43 | #else |
ba78087b | 44 | #define DIRS_EQ(A, B) (!filename_cmp ((A)->canonical_name, (B)->canonical_name)) |
498f1c82 NS |
45 | #endif |
46 | ||
2b6dd222 JM |
47 | static const char dir_separator_str[] = { DIR_SEPARATOR, 0 }; |
48 | ||
b90c9338 | 49 | static void add_env_var_paths (const char *, incpath_kind); |
2b6dd222 | 50 | static void add_standard_paths (const char *, const char *, const char *, int); |
8f9b4009 | 51 | static void free_path (struct cpp_dir *, int); |
9a200623 JM |
52 | static void merge_include_chains (const char *, cpp_reader *, int); |
53 | static void add_sysroot_to_chain (const char *, int); | |
8f9b4009 | 54 | static struct cpp_dir *remove_duplicates (cpp_reader *, struct cpp_dir *, |
18d96339 NS |
55 | struct cpp_dir *, struct cpp_dir *, |
56 | int); | |
5793b276 NB |
57 | |
58 | /* Include chains heads and tails. */ | |
b90c9338 NS |
59 | static struct cpp_dir *heads[INC_MAX]; |
60 | static struct cpp_dir *tails[INC_MAX]; | |
61 | ||
5793b276 NB |
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 | |
8f9b4009 | 67 | free_path (struct cpp_dir *path, int reason) |
5793b276 NB |
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 | ||
fad205ff | 89 | free (path->name); |
5793b276 NB |
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 | |
b90c9338 | 96 | add_env_var_paths (const char *env_var, incpath_kind chain) |
5793b276 NB |
97 | { |
98 | char *p, *q, *path; | |
99 | ||
71f3e391 | 100 | q = getenv (env_var); |
5793b276 NB |
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 | { | |
cceb1885 | 115 | path = XNEWVEC (char, q - p + 1); |
5793b276 NB |
116 | memcpy (path, p, q - p); |
117 | path[q - p] = '\0'; | |
118 | } | |
119 | ||
b90c9338 | 120 | add_path (path, chain, chain == INC_SYSTEM, false); |
5793b276 NB |
121 | } |
122 | } | |
123 | ||
124 | /* Append the standard include chain defined in cppdefault.c. */ | |
125 | static void | |
2b6dd222 JM |
126 | add_standard_paths (const char *sysroot, const char *iprefix, |
127 | const char *imultilib, int cxx_stdinc) | |
5793b276 NB |
128 | { |
129 | const struct default_include *p; | |
c3284718 | 130 | int relocated = cpp_relocated (); |
611f0729 | 131 | size_t len; |
5793b276 | 132 | |
611f0729 AM |
133 | if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0) |
134 | { | |
135 | /* Look for directories that start with the standard prefix. | |
89dbed81 | 136 | "Translate" them, i.e. replace /usr/local/lib/gcc... with |
611f0729 AM |
137 | IPREFIX and search them first. */ |
138 | for (p = cpp_include_defaults; p->fname; p++) | |
139 | { | |
662b9c55 IS |
140 | if (p->cplusplus == 0 |
141 | || (cxx_stdinc && (p->cplusplus == flag_stdlib_kind))) | |
611f0729 AM |
142 | { |
143 | /* Should we be translating sysrooted dirs too? Assume | |
144 | that iprefix and sysroot are mutually exclusive, for | |
145 | now. */ | |
146 | if (sysroot && p->add_sysroot) | |
147 | continue; | |
ba78087b | 148 | if (!filename_ncmp (p->fname, cpp_GCC_INCLUDE_DIR, len)) |
611f0729 AM |
149 | { |
150 | char *str = concat (iprefix, p->fname + len, NULL); | |
e0cdc09f | 151 | if (p->multilib == 1 && imultilib) |
0fcb564b JJ |
152 | str = reconcat (str, str, dir_separator_str, |
153 | imultilib, NULL); | |
e0cdc09f MK |
154 | else if (p->multilib == 2) |
155 | { | |
156 | if (!imultiarch) | |
0fcb564b JJ |
157 | { |
158 | free (str); | |
159 | continue; | |
160 | } | |
161 | str = reconcat (str, str, dir_separator_str, | |
162 | imultiarch, NULL); | |
e0cdc09f | 163 | } |
b90c9338 | 164 | add_path (str, INC_SYSTEM, p->cxx_aware, false); |
611f0729 AM |
165 | } |
166 | } | |
167 | } | |
168 | } | |
5793b276 NB |
169 | |
170 | for (p = cpp_include_defaults; p->fname; p++) | |
171 | { | |
662b9c55 IS |
172 | if (p->cplusplus == 0 |
173 | || (cxx_stdinc && (p->cplusplus == flag_stdlib_kind))) | |
5793b276 NB |
174 | { |
175 | char *str; | |
176 | ||
177 | /* Should this directory start with the sysroot? */ | |
178 | if (sysroot && p->add_sysroot) | |
2fda54bd MK |
179 | { |
180 | char *sysroot_no_trailing_dir_separator = xstrdup (sysroot); | |
181 | size_t sysroot_len = strlen (sysroot); | |
182 | ||
183 | if (sysroot_len > 0 && sysroot[sysroot_len - 1] == DIR_SEPARATOR) | |
184 | sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0'; | |
185 | str = concat (sysroot_no_trailing_dir_separator, p->fname, NULL); | |
186 | free (sysroot_no_trailing_dir_separator); | |
187 | } | |
0fd212e1 | 188 | else if (!p->add_sysroot && relocated |
ba78087b | 189 | && !filename_ncmp (p->fname, cpp_PREFIX, cpp_PREFIX_len)) |
76642aab | 190 | { |
6d4817e3 | 191 | static const char *relocated_prefix; |
0fcb564b | 192 | char *ostr; |
b8698a0f L |
193 | /* If this path starts with the configure-time prefix, |
194 | but the compiler has been relocated, replace it | |
6d4817e3 MM |
195 | with the run-time prefix. The run-time exec prefix |
196 | is GCC_EXEC_PREFIX. Compute the path from there back | |
197 | to the toplevel prefix. */ | |
198 | if (!relocated_prefix) | |
199 | { | |
200 | char *dummy; | |
201 | /* Make relative prefix expects the first argument | |
202 | to be a program, not a directory. */ | |
203 | dummy = concat (gcc_exec_prefix, "dummy", NULL); | |
b8698a0f | 204 | relocated_prefix |
6d4817e3 MM |
205 | = make_relative_prefix (dummy, |
206 | cpp_EXEC_PREFIX, | |
207 | cpp_PREFIX); | |
0fcb564b | 208 | free (dummy); |
6d4817e3 | 209 | } |
0fcb564b JJ |
210 | ostr = concat (relocated_prefix, |
211 | p->fname + cpp_PREFIX_len, | |
212 | NULL); | |
213 | str = update_path (ostr, p->component); | |
214 | free (ostr); | |
76642aab | 215 | } |
5793b276 NB |
216 | else |
217 | str = update_path (p->fname, p->component); | |
218 | ||
e0cdc09f | 219 | if (p->multilib == 1 && imultilib) |
0fcb564b | 220 | str = reconcat (str, str, dir_separator_str, imultilib, NULL); |
e0cdc09f MK |
221 | else if (p->multilib == 2) |
222 | { | |
223 | if (!imultiarch) | |
0fcb564b JJ |
224 | { |
225 | free (str); | |
226 | continue; | |
227 | } | |
228 | str = reconcat (str, str, dir_separator_str, imultiarch, NULL); | |
e0cdc09f | 229 | } |
2b6dd222 | 230 | |
b90c9338 | 231 | add_path (str, INC_SYSTEM, p->cxx_aware, false); |
5793b276 NB |
232 | } |
233 | } | |
234 | } | |
235 | ||
236 | /* For each duplicate path in chain HEAD, keep just the first one. | |
237 | Remove each path in chain HEAD that also exists in chain SYSTEM. | |
238 | Set the NEXT pointer of the last path in the resulting chain to | |
239 | JOIN, unless it duplicates JOIN in which case the last path is | |
240 | removed. Return the head of the resulting chain. Any of HEAD, | |
241 | JOIN and SYSTEM can be NULL. */ | |
4bed3787 | 242 | |
8f9b4009 NB |
243 | static struct cpp_dir * |
244 | remove_duplicates (cpp_reader *pfile, struct cpp_dir *head, | |
245 | struct cpp_dir *system, struct cpp_dir *join, | |
35b1a6fa | 246 | int verbose) |
5793b276 | 247 | { |
8f9b4009 | 248 | struct cpp_dir **pcur, *tmp, *cur; |
5793b276 NB |
249 | struct stat st; |
250 | ||
251 | for (pcur = &head; *pcur; ) | |
252 | { | |
253 | int reason = REASON_QUIET; | |
254 | ||
255 | cur = *pcur; | |
5793b276 NB |
256 | |
257 | if (stat (cur->name, &st)) | |
258 | { | |
68fe024e JH |
259 | /* Dirs that don't exist or have denied permissions are |
260 | silently ignored, unless verbose. */ | |
261 | if ((errno != ENOENT) && (errno != EPERM)) | |
0527bc4e | 262 | cpp_errno (pfile, CPP_DL_ERROR, cur->name); |
5793b276 | 263 | else |
b02398bd | 264 | { |
9cf737f8 | 265 | /* If -Wmissing-include-dirs is given, warn. */ |
b02398bd BE |
266 | cpp_options *opts = cpp_get_options (pfile); |
267 | if (opts->warn_missing_include_dirs && cur->user_supplied_p) | |
b4413594 MLI |
268 | cpp_warning (pfile, CPP_W_MISSING_INCLUDE_DIRS, "%s: %s", |
269 | cur->name, xstrerror (errno)); | |
b02398bd BE |
270 | reason = REASON_NOENT; |
271 | } | |
5793b276 NB |
272 | } |
273 | else if (!S_ISDIR (st.st_mode)) | |
46327e12 | 274 | cpp_error_with_line (pfile, CPP_DL_WARNING, 0, 0, |
5793b276 NB |
275 | "%s: not a directory", cur->name); |
276 | else | |
277 | { | |
498f1c82 | 278 | #if defined (INO_T_COPY) |
5793b276 NB |
279 | INO_T_COPY (cur->ino, st.st_ino); |
280 | cur->dev = st.st_dev; | |
498f1c82 | 281 | #endif |
5793b276 NB |
282 | |
283 | /* Remove this one if it is in the system chain. */ | |
284 | reason = REASON_DUP_SYS; | |
285 | for (tmp = system; tmp; tmp = tmp->next) | |
498f1c82 | 286 | if (DIRS_EQ (tmp, cur) && cur->construct == tmp->construct) |
5793b276 NB |
287 | break; |
288 | ||
289 | if (!tmp) | |
290 | { | |
4d6922ee | 291 | /* Duplicate of something earlier in the same chain? */ |
5793b276 NB |
292 | reason = REASON_DUP; |
293 | for (tmp = head; tmp != cur; tmp = tmp->next) | |
498f1c82 | 294 | if (DIRS_EQ (cur, tmp) && cur->construct == tmp->construct) |
5793b276 NB |
295 | break; |
296 | ||
297 | if (tmp == cur | |
298 | /* Last in the chain and duplicate of JOIN? */ | |
299 | && !(cur->next == NULL && join | |
498f1c82 NS |
300 | && DIRS_EQ (cur, join) |
301 | && cur->construct == join->construct)) | |
5793b276 NB |
302 | { |
303 | /* Unique, so keep this directory. */ | |
304 | pcur = &cur->next; | |
305 | continue; | |
306 | } | |
307 | } | |
308 | } | |
309 | ||
310 | /* Remove this entry from the chain. */ | |
311 | *pcur = cur->next; | |
312 | free_path (cur, verbose ? reason: REASON_QUIET); | |
313 | } | |
314 | ||
315 | *pcur = join; | |
316 | return head; | |
317 | } | |
318 | ||
9a200623 | 319 | /* Add SYSROOT to any user-supplied paths in CHAIN starting with |
a055692a | 320 | "=" or "$SYSROOT". */ |
9a200623 JM |
321 | |
322 | static void | |
323 | add_sysroot_to_chain (const char *sysroot, int chain) | |
324 | { | |
325 | struct cpp_dir *p; | |
326 | ||
327 | for (p = heads[chain]; p != NULL; p = p->next) | |
a055692a RO |
328 | { |
329 | if (p->user_supplied_p) | |
330 | { | |
331 | if (p->name[0] == '=') | |
332 | p->name = concat (sysroot, p->name + 1, NULL); | |
6ba3079d | 333 | if (startswith (p->name, "$SYSROOT")) |
a055692a RO |
334 | p->name = concat (sysroot, p->name + strlen ("$SYSROOT"), NULL); |
335 | } | |
336 | } | |
9a200623 JM |
337 | } |
338 | ||
5793b276 | 339 | /* Merge the four include chains together in the order quote, bracket, |
498f1c82 NS |
340 | system, after. Remove duplicate dirs (determined in |
341 | system-specific manner). | |
5793b276 NB |
342 | |
343 | We can't just merge the lists and then uniquify them because then | |
344 | we may lose directories from the <> search path that should be | |
4bed3787 MS |
345 | there; consider -iquote foo -iquote bar -Ifoo -Iquux. It is |
346 | however safe to treat -iquote bar -iquote foo -Ifoo -Iquux as if | |
347 | written -iquote bar -Ifoo -Iquux. */ | |
348 | ||
5793b276 | 349 | static void |
9a200623 | 350 | merge_include_chains (const char *sysroot, cpp_reader *pfile, int verbose) |
5793b276 | 351 | { |
9a200623 JM |
352 | /* Add the sysroot to user-supplied paths starting with "=". */ |
353 | if (sysroot) | |
354 | { | |
b90c9338 NS |
355 | add_sysroot_to_chain (sysroot, INC_QUOTE); |
356 | add_sysroot_to_chain (sysroot, INC_BRACKET); | |
357 | add_sysroot_to_chain (sysroot, INC_SYSTEM); | |
358 | add_sysroot_to_chain (sysroot, INC_AFTER); | |
9a200623 JM |
359 | } |
360 | ||
5793b276 NB |
361 | /* Join the SYSTEM and AFTER chains. Remove duplicates in the |
362 | resulting SYSTEM chain. */ | |
b90c9338 NS |
363 | if (heads[INC_SYSTEM]) |
364 | tails[INC_SYSTEM]->next = heads[INC_AFTER]; | |
5793b276 | 365 | else |
b90c9338 NS |
366 | heads[INC_SYSTEM] = heads[INC_AFTER]; |
367 | heads[INC_SYSTEM] | |
368 | = remove_duplicates (pfile, heads[INC_SYSTEM], 0, 0, verbose); | |
5793b276 NB |
369 | |
370 | /* Remove duplicates from BRACKET that are in itself or SYSTEM, and | |
371 | join it to SYSTEM. */ | |
b90c9338 NS |
372 | heads[INC_BRACKET] |
373 | = remove_duplicates (pfile, heads[INC_BRACKET], heads[INC_SYSTEM], | |
374 | heads[INC_SYSTEM], verbose); | |
5793b276 NB |
375 | |
376 | /* Remove duplicates from QUOTE that are in itself or SYSTEM, and | |
377 | join it to BRACKET. */ | |
b90c9338 NS |
378 | heads[INC_QUOTE] |
379 | = remove_duplicates (pfile, heads[INC_QUOTE], heads[INC_SYSTEM], | |
380 | heads[INC_BRACKET], verbose); | |
5793b276 NB |
381 | |
382 | /* If verbose, print the list of dirs to search. */ | |
383 | if (verbose) | |
384 | { | |
8f9b4009 | 385 | struct cpp_dir *p; |
5793b276 NB |
386 | |
387 | fprintf (stderr, _("#include \"...\" search starts here:\n")); | |
b90c9338 | 388 | for (p = heads[INC_QUOTE];; p = p->next) |
5793b276 | 389 | { |
b90c9338 | 390 | if (p == heads[INC_BRACKET]) |
5793b276 NB |
391 | fprintf (stderr, _("#include <...> search starts here:\n")); |
392 | if (!p) | |
393 | break; | |
394 | fprintf (stderr, " %s\n", p->name); | |
395 | } | |
396 | fprintf (stderr, _("End of search list.\n")); | |
397 | } | |
398 | } | |
399 | ||
400 | /* Use given -I paths for #include "..." but not #include <...>, and | |
401 | don't search the directory of the present file for #include "...". | |
402 | (Note that -I. -I- is not the same as the default setup; -I. uses | |
403 | the compiler's working dir.) */ | |
404 | void | |
35b1a6fa | 405 | split_quote_chain (void) |
5793b276 | 406 | { |
b90c9338 NS |
407 | if (heads[INC_QUOTE]) |
408 | free_path (heads[INC_QUOTE], REASON_QUIET); | |
409 | if (tails[INC_QUOTE]) | |
410 | free_path (tails[INC_QUOTE], REASON_QUIET); | |
411 | heads[INC_QUOTE] = heads[INC_BRACKET]; | |
412 | tails[INC_QUOTE] = tails[INC_BRACKET]; | |
413 | heads[INC_BRACKET] = NULL; | |
414 | tails[INC_BRACKET] = NULL; | |
5793b276 NB |
415 | /* This is NOT redundant. */ |
416 | quote_ignores_source_dir = true; | |
417 | } | |
418 | ||
94d1613b MS |
419 | /* Add P to the chain specified by CHAIN. */ |
420 | ||
421 | void | |
b90c9338 | 422 | add_cpp_dir_path (cpp_dir *p, incpath_kind chain) |
94d1613b MS |
423 | { |
424 | if (tails[chain]) | |
425 | tails[chain]->next = p; | |
426 | else | |
427 | heads[chain] = p; | |
428 | tails[chain] = p; | |
429 | } | |
430 | ||
5793b276 NB |
431 | /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and |
432 | NUL-terminated. */ | |
433 | void | |
b90c9338 | 434 | add_path (char *path, incpath_kind chain, int cxx_aware, bool user_supplied_p) |
5793b276 | 435 | { |
94d1613b | 436 | cpp_dir *p; |
18d96339 | 437 | size_t pathlen = strlen (path); |
5793b276 | 438 | |
421563d5 | 439 | #if defined (HAVE_DOS_BASED_FILE_SYSTEM) |
b187f5cd DS |
440 | /* Remove unnecessary trailing slashes. On some versions of MS |
441 | Windows, trailing _forward_ slashes cause no problems for stat(). | |
0d52bcc1 | 442 | On newer versions, stat() does not recognize a directory that ends |
b187f5cd DS |
443 | in a '\\' or '/', unless it is a drive root dir, such as "c:/", |
444 | where it is obligatory. */ | |
b187f5cd DS |
445 | char* end = path + pathlen - 1; |
446 | /* Preserve the lead '/' or lead "c:/". */ | |
447 | char* start = path + (pathlen > 2 && path[1] == ':' ? 3 : 1); | |
b8698a0f | 448 | |
b187f5cd DS |
449 | for (; end > start && IS_DIR_SEPARATOR (*end); end--) |
450 | *end = 0; | |
18d96339 | 451 | pathlen = end - path; |
421563d5 DS |
452 | #endif |
453 | ||
cceb1885 | 454 | p = XNEW (cpp_dir); |
5793b276 NB |
455 | p->next = NULL; |
456 | p->name = path; | |
18d96339 | 457 | p->len = pathlen; |
c100de59 DS |
458 | #ifndef INO_T_EQ |
459 | p->canonical_name = lrealpath (path); | |
460 | #endif | |
b90c9338 | 461 | if (chain == INC_SYSTEM || chain == INC_AFTER) |
82f6e3eb | 462 | p->sysp = 1 + !cxx_aware; |
5793b276 NB |
463 | else |
464 | p->sysp = 0; | |
94d1613b | 465 | p->construct = 0; |
b02398bd | 466 | p->user_supplied_p = user_supplied_p; |
5793b276 | 467 | |
b02398bd | 468 | add_cpp_dir_path (p, chain); |
5793b276 NB |
469 | } |
470 | ||
471 | /* Exported function to handle include chain merging, duplicate | |
472 | removal, and registration with cpplib. */ | |
473 | void | |
35b1a6fa | 474 | register_include_chains (cpp_reader *pfile, const char *sysroot, |
2b6dd222 JM |
475 | const char *iprefix, const char *imultilib, |
476 | int stdinc, int cxx_stdinc, int verbose) | |
5793b276 NB |
477 | { |
478 | static const char *const lang_env_vars[] = | |
479 | { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH", | |
480 | "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" }; | |
481 | cpp_options *cpp_opts = cpp_get_options (pfile); | |
482 | size_t idx = (cpp_opts->objc ? 2: 0); | |
483 | ||
484 | if (cpp_opts->cplusplus) | |
485 | idx++; | |
486 | else | |
487 | cxx_stdinc = false; | |
488 | ||
489 | /* CPATH and language-dependent environment variables may add to the | |
490 | include chain. */ | |
b90c9338 NS |
491 | add_env_var_paths ("CPATH", INC_BRACKET); |
492 | add_env_var_paths (lang_env_vars[idx], INC_SYSTEM); | |
c22cacf3 | 493 | |
3dd53121 | 494 | target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc); |
5793b276 NB |
495 | |
496 | /* Finally chain on the standard directories. */ | |
497 | if (stdinc) | |
2b6dd222 | 498 | add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc); |
5793b276 | 499 | |
3dd53121 | 500 | target_c_incpath.extra_includes (sysroot, iprefix, stdinc); |
94d1613b | 501 | |
9a200623 | 502 | merge_include_chains (sysroot, pfile, verbose); |
5793b276 | 503 | |
b90c9338 | 504 | cpp_set_include_chains (pfile, heads[INC_QUOTE], heads[INC_BRACKET], |
5793b276 NB |
505 | quote_ignores_source_dir); |
506 | } | |
0ea06912 TG |
507 | |
508 | /* Return the current chain of cpp dirs. */ | |
509 | ||
510 | struct cpp_dir * | |
b90c9338 | 511 | get_added_cpp_dirs (incpath_kind chain) |
0ea06912 TG |
512 | { |
513 | return heads[chain]; | |
514 | } | |
515 | ||
3dd53121 AP |
516 | #if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES) |
517 | static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED, | |
518 | const char *iprefix ATTRIBUTE_UNUSED, | |
519 | int stdinc ATTRIBUTE_UNUSED) | |
520 | { | |
521 | } | |
522 | #endif | |
94d1613b MS |
523 | |
524 | #ifndef TARGET_EXTRA_INCLUDES | |
3dd53121 | 525 | #define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int |
94d1613b | 526 | #endif |
3dd53121 AP |
527 | #ifndef TARGET_EXTRA_PRE_INCLUDES |
528 | #define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int | |
529 | #endif | |
530 | ||
531 | struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES }; | |
532 |