OSDN Git Service

7f6cbdf63f048503b8a321950871f865a7a8b98c
[pf3gnuchains/gcc-fork.git] / 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 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 static struct cpp_dir *
175 remove_duplicates (cpp_reader *pfile, struct cpp_dir *head,
176                    struct cpp_dir *system, struct cpp_dir *join,
177                    int verbose)
178 {
179   struct cpp_dir **pcur, *tmp, *cur;
180   struct stat st;
181
182   for (pcur = &head; *pcur; )
183     {
184       int reason = REASON_QUIET;
185
186       cur = *pcur;
187
188       if (stat (cur->name, &st))
189         {
190           /* Dirs that don't exist are silently ignored, unless verbose.  */
191           if (errno != ENOENT)
192             cpp_errno (pfile, CPP_DL_ERROR, cur->name);
193           else
194             reason = REASON_NOENT;
195         }
196       else if (!S_ISDIR (st.st_mode))
197         cpp_error_with_line (pfile, CPP_DL_ERROR, 0, 0,
198                              "%s: not a directory", cur->name);
199       else
200         {
201           INO_T_COPY (cur->ino, st.st_ino);
202           cur->dev  = st.st_dev;
203
204           /* Remove this one if it is in the system chain.  */
205           reason = REASON_DUP_SYS;
206           for (tmp = system; tmp; tmp = tmp->next)
207             if (INO_T_EQ (tmp->ino, cur->ino) && tmp->dev == cur->dev)
208               break;
209
210           if (!tmp)
211             {
212               /* Duplicate of something earlier in the same chain?  */
213               reason = REASON_DUP;
214               for (tmp = head; tmp != cur; tmp = tmp->next)
215                 if (INO_T_EQ (cur->ino, tmp->ino) && cur->dev == tmp->dev)
216                   break;
217
218               if (tmp == cur
219                   /* Last in the chain and duplicate of JOIN?  */
220                   && !(cur->next == NULL && join
221                        && INO_T_EQ (cur->ino, join->ino)
222                        && cur->dev == join->dev))
223                 {
224                   /* Unique, so keep this directory.  */
225                   pcur = &cur->next;
226                   continue;
227                 }
228             }
229         }
230
231       /* Remove this entry from the chain.  */
232       *pcur = cur->next;
233       free_path (cur, verbose ? reason: REASON_QUIET);
234     }
235
236   *pcur = join;
237   return head;
238 }
239
240 /* Merge the four include chains together in the order quote, bracket,
241    system, after.  Remove duplicate dirs (as determined by
242    INO_T_EQ()).
243
244    We can't just merge the lists and then uniquify them because then
245    we may lose directories from the <> search path that should be
246    there; consider -Ifoo -Ibar -I- -Ifoo -Iquux.  It is however safe
247    to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written -Ibar -I- -Ifoo
248    -Iquux.  */
249 static void
250 merge_include_chains (cpp_reader *pfile, int verbose)
251 {
252   /* Join the SYSTEM and AFTER chains.  Remove duplicates in the
253      resulting SYSTEM chain.  */
254   if (heads[SYSTEM])
255     tails[SYSTEM]->next = heads[AFTER];
256   else
257     heads[SYSTEM] = heads[AFTER];
258   heads[SYSTEM] = remove_duplicates (pfile, heads[SYSTEM], 0, 0, verbose);
259
260   /* Remove duplicates from BRACKET that are in itself or SYSTEM, and
261      join it to SYSTEM.  */
262   heads[BRACKET] = remove_duplicates (pfile, heads[BRACKET], heads[SYSTEM],
263                                       heads[SYSTEM], verbose);
264
265   /* Remove duplicates from QUOTE that are in itself or SYSTEM, and
266      join it to BRACKET.  */
267   heads[QUOTE] = remove_duplicates (pfile, heads[QUOTE], heads[SYSTEM],
268                                     heads[BRACKET], verbose);
269
270   /* If verbose, print the list of dirs to search.  */
271   if (verbose)
272     {
273       struct cpp_dir *p;
274
275       fprintf (stderr, _("#include \"...\" search starts here:\n"));
276       for (p = heads[QUOTE];; p = p->next)
277         {
278           if (p == heads[BRACKET])
279             fprintf (stderr, _("#include <...> search starts here:\n"));
280           if (!p)
281             break;
282           fprintf (stderr, " %s\n", p->name);
283         }
284       fprintf (stderr, _("End of search list.\n"));
285     }
286 }
287
288 /* Use given -I paths for #include "..." but not #include <...>, and
289    don't search the directory of the present file for #include "...".
290    (Note that -I. -I- is not the same as the default setup; -I. uses
291    the compiler's working dir.)  */
292 void
293 split_quote_chain (void)
294 {
295   heads[QUOTE] = heads[BRACKET];
296   tails[QUOTE] = tails[BRACKET];
297   heads[BRACKET] = NULL;
298   tails[BRACKET] = NULL;
299   /* This is NOT redundant.  */
300   quote_ignores_source_dir = true;
301 }
302
303 /* Add P to the chain specified by CHAIN.  */
304
305 void
306 add_cpp_dir_path (cpp_dir *p, int chain)
307 {
308   if (tails[chain])
309     tails[chain]->next = p;
310   else
311     heads[chain] = p;
312   tails[chain] = p;
313 }
314
315 /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and
316    NUL-terminated.  */
317 void
318 add_path (char *path, int chain, int cxx_aware)
319 {
320   cpp_dir *p;
321
322   p = xmalloc (sizeof (cpp_dir));
323   p->next = NULL;
324   p->name = path;
325   if (chain == SYSTEM || chain == AFTER)
326     p->sysp = 1 + !cxx_aware;
327   else
328     p->sysp = 0;
329   p->construct = 0;
330
331   if (tails[chain])
332     tails[chain]->next = p;
333   else
334     heads[chain] = p;
335   tails[chain] = p;
336 }
337
338 /* Exported function to handle include chain merging, duplicate
339    removal, and registration with cpplib.  */
340 void
341 register_include_chains (cpp_reader *pfile, const char *sysroot,
342                          const char *iprefix, int stdinc, int cxx_stdinc,
343                          int verbose)
344 {
345   static const char *const lang_env_vars[] =
346     { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH",
347       "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" };
348   cpp_options *cpp_opts = cpp_get_options (pfile);
349   size_t idx = (cpp_opts->objc ? 2: 0);
350
351   if (cpp_opts->cplusplus)
352     idx++;
353   else
354     cxx_stdinc = false;
355
356   /* CPATH and language-dependent environment variables may add to the
357      include chain.  */
358   add_env_var_paths ("CPATH", BRACKET);
359   add_env_var_paths (lang_env_vars[idx], SYSTEM);
360
361   /* Finally chain on the standard directories.  */
362   if (stdinc)
363     add_standard_paths (sysroot, iprefix, cxx_stdinc);
364
365   target_c_incpath.extra_includes (stdinc);
366
367   merge_include_chains (pfile, verbose);
368
369   cpp_set_include_chains (pfile, heads[QUOTE], heads[BRACKET],
370                           quote_ignores_source_dir);
371 }
372
373 #ifndef TARGET_EXTRA_INCLUDES
374 static void hook_void_int(int u ATTRIBUTE_UNUSED) { }
375
376 struct target_c_incpath_s target_c_incpath = { hook_void_int };
377 #endif