Mercurial > hg > CbC > CbC_gcc
annotate gcc/incpath.c @ 158:494b0b89df80 default tip
...
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 25 May 2020 18:13:55 +0900 |
| parents | 1830386684a0 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* Set up combined include path chain for the preprocessor. |
| 145 | 2 Copyright (C) 1986-2020 Free Software Foundation, Inc. |
| 0 | 3 |
| 4 Broken out of cppinit.c and cppfiles.c and rewritten Mar 2003. | |
| 5 | |
| 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. | |
| 10 | |
| 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. | |
| 15 | |
| 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/>. */ | |
| 19 | |
| 20 #include "config.h" | |
| 21 #include "system.h" | |
| 22 #include "coretypes.h" | |
| 23 #include "target.h" | |
| 24 #include "cpplib.h" | |
| 25 #include "prefix.h" | |
| 26 #include "intl.h" | |
| 27 #include "incpath.h" | |
| 28 #include "cppdefault.h" | |
| 29 | |
| 30 /* Microsoft Windows does not natively support inodes. | |
| 31 VMS has non-numeric inodes. */ | |
| 32 #ifdef VMS | |
| 33 # define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A))) | |
| 111 | 34 # define INO_T_COPY(DEST, SRC) memcpy (&(DEST), &(SRC), sizeof (SRC)) |
| 0 | 35 #elif !defined (HOST_LACKS_INODE_NUMBERS) |
| 36 # define INO_T_EQ(A, B) ((A) == (B)) | |
| 37 # define INO_T_COPY(DEST, SRC) (DEST) = (SRC) | |
| 38 #endif | |
| 39 | |
| 40 #if defined INO_T_EQ | |
| 41 #define DIRS_EQ(A, B) ((A)->dev == (B)->dev \ | |
| 111 | 42 && INO_T_EQ ((A)->ino, (B)->ino)) |
| 0 | 43 #else |
| 111 | 44 #define DIRS_EQ(A, B) (!filename_cmp ((A)->canonical_name, (B)->canonical_name)) |
| 0 | 45 #endif |
| 46 | |
| 47 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 }; | |
| 48 | |
| 111 | 49 static void add_env_var_paths (const char *, incpath_kind); |
| 0 | 50 static void add_standard_paths (const char *, const char *, const char *, int); |
| 51 static void free_path (struct cpp_dir *, int); | |
| 52 static void merge_include_chains (const char *, cpp_reader *, int); | |
| 53 static void add_sysroot_to_chain (const char *, int); | |
| 54 static struct cpp_dir *remove_duplicates (cpp_reader *, struct cpp_dir *, | |
| 55 struct cpp_dir *, | |
| 56 struct cpp_dir *, int); | |
| 57 | |
| 58 /* Include chains heads and tails. */ | |
| 111 | 59 static struct cpp_dir *heads[INC_MAX]; |
| 60 static struct cpp_dir *tails[INC_MAX]; | |
| 61 | |
| 0 | 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 | |
| 111 | 96 add_env_var_paths (const char *env_var, incpath_kind chain) |
| 0 | 97 { |
| 98 char *p, *q, *path; | |
| 99 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
100 q = getenv (env_var); |
| 0 | 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 | |
| 111 | 120 add_path (path, chain, chain == INC_SYSTEM, false); |
| 0 | 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; | |
| 111 | 130 int relocated = cpp_relocated (); |
| 0 | 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; | |
| 111 | 147 if (!filename_ncmp (p->fname, cpp_GCC_INCLUDE_DIR, len)) |
| 0 | 148 { |
| 149 char *str = concat (iprefix, p->fname + len, NULL); | |
| 111 | 150 if (p->multilib == 1 && imultilib) |
| 151 str = reconcat (str, str, dir_separator_str, | |
| 152 imultilib, NULL); | |
| 153 else if (p->multilib == 2) | |
| 154 { | |
| 155 if (!imultiarch) | |
| 156 { | |
| 157 free (str); | |
| 158 continue; | |
| 159 } | |
| 160 str = reconcat (str, str, dir_separator_str, | |
| 161 imultiarch, NULL); | |
| 162 } | |
| 163 add_path (str, INC_SYSTEM, p->cxx_aware, false); | |
| 0 | 164 } |
| 165 } | |
| 166 } | |
| 167 } | |
| 168 | |
| 169 for (p = cpp_include_defaults; p->fname; p++) | |
| 170 { | |
| 171 if (!p->cplusplus || cxx_stdinc) | |
| 172 { | |
| 173 char *str; | |
| 174 | |
| 175 /* Should this directory start with the sysroot? */ | |
| 176 if (sysroot && p->add_sysroot) | |
| 111 | 177 { |
| 178 char *sysroot_no_trailing_dir_separator = xstrdup (sysroot); | |
| 179 size_t sysroot_len = strlen (sysroot); | |
| 180 | |
| 181 if (sysroot_len > 0 && sysroot[sysroot_len - 1] == DIR_SEPARATOR) | |
| 182 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0'; | |
| 183 str = concat (sysroot_no_trailing_dir_separator, p->fname, NULL); | |
| 184 free (sysroot_no_trailing_dir_separator); | |
| 185 } | |
| 0 | 186 else if (!p->add_sysroot && relocated |
| 111 | 187 && !filename_ncmp (p->fname, cpp_PREFIX, cpp_PREFIX_len)) |
| 0 | 188 { |
| 189 static const char *relocated_prefix; | |
| 111 | 190 char *ostr; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
191 /* If this path starts with the configure-time prefix, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
192 but the compiler has been relocated, replace it |
| 0 | 193 with the run-time prefix. The run-time exec prefix |
| 194 is GCC_EXEC_PREFIX. Compute the path from there back | |
| 195 to the toplevel prefix. */ | |
| 196 if (!relocated_prefix) | |
| 197 { | |
| 198 char *dummy; | |
| 199 /* Make relative prefix expects the first argument | |
| 200 to be a program, not a directory. */ | |
| 201 dummy = concat (gcc_exec_prefix, "dummy", NULL); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
202 relocated_prefix |
| 0 | 203 = make_relative_prefix (dummy, |
| 204 cpp_EXEC_PREFIX, | |
| 205 cpp_PREFIX); | |
| 111 | 206 free (dummy); |
| 0 | 207 } |
| 111 | 208 ostr = concat (relocated_prefix, |
| 209 p->fname + cpp_PREFIX_len, | |
| 210 NULL); | |
| 211 str = update_path (ostr, p->component); | |
| 212 free (ostr); | |
| 0 | 213 } |
| 214 else | |
| 215 str = update_path (p->fname, p->component); | |
| 216 | |
| 111 | 217 if (p->multilib == 1 && imultilib) |
| 218 str = reconcat (str, str, dir_separator_str, imultilib, NULL); | |
| 219 else if (p->multilib == 2) | |
| 220 { | |
| 221 if (!imultiarch) | |
| 222 { | |
| 223 free (str); | |
| 224 continue; | |
| 225 } | |
| 226 str = reconcat (str, str, dir_separator_str, imultiarch, NULL); | |
| 227 } | |
| 0 | 228 |
| 111 | 229 add_path (str, INC_SYSTEM, p->cxx_aware, false); |
| 0 | 230 } |
| 231 } | |
| 232 } | |
| 233 | |
| 234 /* For each duplicate path in chain HEAD, keep just the first one. | |
| 235 Remove each path in chain HEAD that also exists in chain SYSTEM. | |
| 236 Set the NEXT pointer of the last path in the resulting chain to | |
| 237 JOIN, unless it duplicates JOIN in which case the last path is | |
| 238 removed. Return the head of the resulting chain. Any of HEAD, | |
| 239 JOIN and SYSTEM can be NULL. */ | |
| 240 | |
| 241 static struct cpp_dir * | |
| 242 remove_duplicates (cpp_reader *pfile, struct cpp_dir *head, | |
| 243 struct cpp_dir *system, struct cpp_dir *join, | |
| 244 int verbose) | |
| 245 { | |
| 246 struct cpp_dir **pcur, *tmp, *cur; | |
| 247 struct stat st; | |
| 248 | |
| 249 for (pcur = &head; *pcur; ) | |
| 250 { | |
| 251 int reason = REASON_QUIET; | |
| 252 | |
| 253 cur = *pcur; | |
| 254 | |
| 255 if (stat (cur->name, &st)) | |
| 256 { | |
| 111 | 257 /* Dirs that don't exist or have denied permissions are |
| 258 silently ignored, unless verbose. */ | |
| 259 if ((errno != ENOENT) && (errno != EPERM)) | |
| 0 | 260 cpp_errno (pfile, CPP_DL_ERROR, cur->name); |
| 261 else | |
| 262 { | |
| 263 /* If -Wmissing-include-dirs is given, warn. */ | |
| 264 cpp_options *opts = cpp_get_options (pfile); | |
| 265 if (opts->warn_missing_include_dirs && cur->user_supplied_p) | |
| 111 | 266 cpp_warning (pfile, CPP_W_MISSING_INCLUDE_DIRS, "%s: %s", |
| 267 cur->name, xstrerror (errno)); | |
| 0 | 268 reason = REASON_NOENT; |
| 269 } | |
| 270 } | |
| 271 else if (!S_ISDIR (st.st_mode)) | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
272 cpp_error_with_line (pfile, CPP_DL_WARNING, 0, 0, |
| 0 | 273 "%s: not a directory", cur->name); |
| 274 else | |
| 275 { | |
| 276 #if defined (INO_T_COPY) | |
| 277 INO_T_COPY (cur->ino, st.st_ino); | |
| 278 cur->dev = st.st_dev; | |
| 279 #endif | |
| 280 | |
| 281 /* Remove this one if it is in the system chain. */ | |
| 282 reason = REASON_DUP_SYS; | |
| 283 for (tmp = system; tmp; tmp = tmp->next) | |
| 284 if (DIRS_EQ (tmp, cur) && cur->construct == tmp->construct) | |
| 285 break; | |
| 286 | |
| 287 if (!tmp) | |
| 288 { | |
| 289 /* Duplicate of something earlier in the same chain? */ | |
| 290 reason = REASON_DUP; | |
| 291 for (tmp = head; tmp != cur; tmp = tmp->next) | |
| 292 if (DIRS_EQ (cur, tmp) && cur->construct == tmp->construct) | |
| 293 break; | |
| 294 | |
| 295 if (tmp == cur | |
| 296 /* Last in the chain and duplicate of JOIN? */ | |
| 297 && !(cur->next == NULL && join | |
| 298 && DIRS_EQ (cur, join) | |
| 299 && cur->construct == join->construct)) | |
| 300 { | |
| 301 /* Unique, so keep this directory. */ | |
| 302 pcur = &cur->next; | |
| 303 continue; | |
| 304 } | |
| 305 } | |
| 306 } | |
| 307 | |
| 308 /* Remove this entry from the chain. */ | |
| 309 *pcur = cur->next; | |
| 310 free_path (cur, verbose ? reason: REASON_QUIET); | |
| 311 } | |
| 312 | |
| 313 *pcur = join; | |
| 314 return head; | |
| 315 } | |
| 316 | |
| 317 /* Add SYSROOT to any user-supplied paths in CHAIN starting with | |
| 111 | 318 "=" or "$SYSROOT". */ |
| 0 | 319 |
| 320 static void | |
| 321 add_sysroot_to_chain (const char *sysroot, int chain) | |
| 322 { | |
| 323 struct cpp_dir *p; | |
| 324 | |
| 325 for (p = heads[chain]; p != NULL; p = p->next) | |
| 111 | 326 { |
| 327 if (p->user_supplied_p) | |
| 328 { | |
| 329 if (p->name[0] == '=') | |
| 330 p->name = concat (sysroot, p->name + 1, NULL); | |
| 331 if (strncmp (p->name, "$SYSROOT", strlen ("$SYSROOT")) == 0) | |
| 332 p->name = concat (sysroot, p->name + strlen ("$SYSROOT"), NULL); | |
| 333 } | |
| 334 } | |
| 0 | 335 } |
| 336 | |
| 337 /* Merge the four include chains together in the order quote, bracket, | |
| 338 system, after. Remove duplicate dirs (determined in | |
| 339 system-specific manner). | |
| 340 | |
| 341 We can't just merge the lists and then uniquify them because then | |
| 342 we may lose directories from the <> search path that should be | |
| 343 there; consider -iquote foo -iquote bar -Ifoo -Iquux. It is | |
| 344 however safe to treat -iquote bar -iquote foo -Ifoo -Iquux as if | |
| 345 written -iquote bar -Ifoo -Iquux. */ | |
| 346 | |
| 347 static void | |
| 348 merge_include_chains (const char *sysroot, cpp_reader *pfile, int verbose) | |
| 349 { | |
| 350 /* Add the sysroot to user-supplied paths starting with "=". */ | |
| 351 if (sysroot) | |
| 352 { | |
| 111 | 353 add_sysroot_to_chain (sysroot, INC_QUOTE); |
| 354 add_sysroot_to_chain (sysroot, INC_BRACKET); | |
| 355 add_sysroot_to_chain (sysroot, INC_SYSTEM); | |
| 356 add_sysroot_to_chain (sysroot, INC_AFTER); | |
| 0 | 357 } |
| 358 | |
| 359 /* Join the SYSTEM and AFTER chains. Remove duplicates in the | |
| 360 resulting SYSTEM chain. */ | |
| 111 | 361 if (heads[INC_SYSTEM]) |
| 362 tails[INC_SYSTEM]->next = heads[INC_AFTER]; | |
| 0 | 363 else |
| 111 | 364 heads[INC_SYSTEM] = heads[INC_AFTER]; |
| 365 heads[INC_SYSTEM] | |
| 366 = remove_duplicates (pfile, heads[INC_SYSTEM], 0, 0, verbose); | |
| 0 | 367 |
| 368 /* Remove duplicates from BRACKET that are in itself or SYSTEM, and | |
| 369 join it to SYSTEM. */ | |
| 111 | 370 heads[INC_BRACKET] |
| 371 = remove_duplicates (pfile, heads[INC_BRACKET], heads[INC_SYSTEM], | |
| 372 heads[INC_SYSTEM], verbose); | |
| 0 | 373 |
| 374 /* Remove duplicates from QUOTE that are in itself or SYSTEM, and | |
| 375 join it to BRACKET. */ | |
| 111 | 376 heads[INC_QUOTE] |
| 377 = remove_duplicates (pfile, heads[INC_QUOTE], heads[INC_SYSTEM], | |
| 378 heads[INC_BRACKET], verbose); | |
| 0 | 379 |
| 380 /* If verbose, print the list of dirs to search. */ | |
| 381 if (verbose) | |
| 382 { | |
| 383 struct cpp_dir *p; | |
| 384 | |
| 385 fprintf (stderr, _("#include \"...\" search starts here:\n")); | |
| 111 | 386 for (p = heads[INC_QUOTE];; p = p->next) |
| 0 | 387 { |
| 111 | 388 if (p == heads[INC_BRACKET]) |
| 0 | 389 fprintf (stderr, _("#include <...> search starts here:\n")); |
| 390 if (!p) | |
| 391 break; | |
| 392 fprintf (stderr, " %s\n", p->name); | |
| 393 } | |
| 394 fprintf (stderr, _("End of search list.\n")); | |
| 395 } | |
| 396 } | |
| 397 | |
| 398 /* Use given -I paths for #include "..." but not #include <...>, and | |
| 399 don't search the directory of the present file for #include "...". | |
| 400 (Note that -I. -I- is not the same as the default setup; -I. uses | |
| 401 the compiler's working dir.) */ | |
| 402 void | |
| 403 split_quote_chain (void) | |
| 404 { | |
| 111 | 405 if (heads[INC_QUOTE]) |
| 406 free_path (heads[INC_QUOTE], REASON_QUIET); | |
| 407 if (tails[INC_QUOTE]) | |
| 408 free_path (tails[INC_QUOTE], REASON_QUIET); | |
| 409 heads[INC_QUOTE] = heads[INC_BRACKET]; | |
| 410 tails[INC_QUOTE] = tails[INC_BRACKET]; | |
| 411 heads[INC_BRACKET] = NULL; | |
| 412 tails[INC_BRACKET] = NULL; | |
| 0 | 413 /* This is NOT redundant. */ |
| 414 quote_ignores_source_dir = true; | |
| 415 } | |
| 416 | |
| 417 /* Add P to the chain specified by CHAIN. */ | |
| 418 | |
| 419 void | |
| 111 | 420 add_cpp_dir_path (cpp_dir *p, incpath_kind chain) |
| 0 | 421 { |
| 422 if (tails[chain]) | |
| 423 tails[chain]->next = p; | |
| 424 else | |
| 425 heads[chain] = p; | |
| 426 tails[chain] = p; | |
| 427 } | |
| 428 | |
| 429 /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and | |
| 430 NUL-terminated. */ | |
| 431 void | |
| 111 | 432 add_path (char *path, incpath_kind chain, int cxx_aware, bool user_supplied_p) |
| 0 | 433 { |
| 434 cpp_dir *p; | |
| 435 | |
| 436 #if defined (HAVE_DOS_BASED_FILE_SYSTEM) | |
| 437 /* Remove unnecessary trailing slashes. On some versions of MS | |
| 438 Windows, trailing _forward_ slashes cause no problems for stat(). | |
| 439 On newer versions, stat() does not recognize a directory that ends | |
| 440 in a '\\' or '/', unless it is a drive root dir, such as "c:/", | |
| 441 where it is obligatory. */ | |
| 442 int pathlen = strlen (path); | |
| 443 char* end = path + pathlen - 1; | |
| 444 /* Preserve the lead '/' or lead "c:/". */ | |
| 445 char* start = path + (pathlen > 2 && path[1] == ':' ? 3 : 1); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
446 |
| 0 | 447 for (; end > start && IS_DIR_SEPARATOR (*end); end--) |
| 448 *end = 0; | |
| 449 #endif | |
| 450 | |
| 451 p = XNEW (cpp_dir); | |
| 452 p->next = NULL; | |
| 453 p->name = path; | |
| 454 #ifndef INO_T_EQ | |
| 455 p->canonical_name = lrealpath (path); | |
| 456 #endif | |
| 111 | 457 if (chain == INC_SYSTEM || chain == INC_AFTER) |
| 0 | 458 p->sysp = 1 + !cxx_aware; |
| 459 else | |
| 460 p->sysp = 0; | |
| 461 p->construct = 0; | |
| 462 p->user_supplied_p = user_supplied_p; | |
| 463 | |
| 464 add_cpp_dir_path (p, chain); | |
| 465 } | |
| 466 | |
| 467 /* Exported function to handle include chain merging, duplicate | |
| 468 removal, and registration with cpplib. */ | |
| 469 void | |
| 470 register_include_chains (cpp_reader *pfile, const char *sysroot, | |
| 471 const char *iprefix, const char *imultilib, | |
| 472 int stdinc, int cxx_stdinc, int verbose) | |
| 473 { | |
| 474 static const char *const lang_env_vars[] = | |
| 475 { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH", | |
| 476 "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" }; | |
| 477 cpp_options *cpp_opts = cpp_get_options (pfile); | |
| 478 size_t idx = (cpp_opts->objc ? 2: 0); | |
| 479 | |
| 480 if (cpp_opts->cplusplus) | |
| 481 idx++; | |
| 482 else | |
| 483 cxx_stdinc = false; | |
| 484 | |
| 485 /* CPATH and language-dependent environment variables may add to the | |
| 486 include chain. */ | |
| 111 | 487 add_env_var_paths ("CPATH", INC_BRACKET); |
| 488 add_env_var_paths (lang_env_vars[idx], INC_SYSTEM); | |
| 0 | 489 |
| 490 target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc); | |
| 491 | |
| 492 /* Finally chain on the standard directories. */ | |
| 493 if (stdinc) | |
| 494 add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc); | |
| 495 | |
| 496 target_c_incpath.extra_includes (sysroot, iprefix, stdinc); | |
| 497 | |
| 498 merge_include_chains (sysroot, pfile, verbose); | |
| 499 | |
| 111 | 500 cpp_set_include_chains (pfile, heads[INC_QUOTE], heads[INC_BRACKET], |
| 0 | 501 quote_ignores_source_dir); |
| 502 } | |
| 111 | 503 |
| 504 /* Return the current chain of cpp dirs. */ | |
| 505 | |
| 506 struct cpp_dir * | |
| 507 get_added_cpp_dirs (incpath_kind chain) | |
| 508 { | |
| 509 return heads[chain]; | |
| 510 } | |
| 511 | |
| 0 | 512 #if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES) |
| 513 static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED, | |
| 514 const char *iprefix ATTRIBUTE_UNUSED, | |
| 515 int stdinc ATTRIBUTE_UNUSED) | |
| 516 { | |
| 517 } | |
| 518 #endif | |
| 519 | |
| 520 #ifndef TARGET_EXTRA_INCLUDES | |
| 521 #define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int | |
| 522 #endif | |
| 523 #ifndef TARGET_EXTRA_PRE_INCLUDES | |
| 524 #define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int | |
| 525 #endif | |
| 526 | |
| 527 struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES }; | |
| 528 |