OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [c-incpath.c] - Blame information for rev 841

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* 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
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 "c-incpath.h"
32
#include "cppdefault.h"
33
 
34
/* Windows does not natively support inodes, and neither does MSDOS.
35
   Cygwin's emulation can generate non-unique inodes, so don't use it.
36
   VMS has non-numeric inodes.  */
37
#ifdef VMS
38
# define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A)))
39
# define INO_T_COPY(DEST, SRC) memcpy(&(DEST), &(SRC), sizeof (SRC))
40
#else
41
# if (defined _WIN32 && !defined (_UWIN)) || defined __MSDOS__
42
#  define INO_T_EQ(A, B) 0
43
# else
44
#  define INO_T_EQ(A, B) ((A) == (B))
45
# endif
46
# define INO_T_COPY(DEST, SRC) (DEST) = (SRC)
47
#endif
48
 
49
static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
50
 
51
static void add_env_var_paths (const char *, int);
52
static void add_standard_paths (const char *, const char *, const char *, int);
53
static void free_path (struct cpp_dir *, int);
54
static void merge_include_chains (cpp_reader *, int);
55
static struct cpp_dir *remove_duplicates (cpp_reader *, struct cpp_dir *,
56
                                           struct cpp_dir *,
57
                                           struct cpp_dir *, int);
58
 
59
/* Include chains heads and tails.  */
60
static struct cpp_dir *heads[4];
61
static struct cpp_dir *tails[4];
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
96
add_env_var_paths (const char *env_var, int chain)
97
{
98
  char *p, *q, *path;
99
 
100
  GET_ENVIRONMENT (q, env_var);
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
 
120
      add_path (path, chain, chain == SYSTEM, false);
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;
130
  size_t len;
131
 
132
  if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0)
133
    {
134
      /* Look for directories that start with the standard prefix.
135
         "Translate" them, i.e. replace /usr/local/lib/gcc... with
136
         IPREFIX and search them first.  */
137
      for (p = cpp_include_defaults; p->fname; p++)
138
        {
139
          if (!p->cplusplus || cxx_stdinc)
140
            {
141
              /* Should we be translating sysrooted dirs too?  Assume
142
                 that iprefix and sysroot are mutually exclusive, for
143
                 now.  */
144
              if (sysroot && p->add_sysroot)
145
                continue;
146
              if (!strncmp (p->fname, cpp_GCC_INCLUDE_DIR, len))
147
                {
148
                  char *str = concat (iprefix, p->fname + len, NULL);
149
                  if (p->multilib && imultilib)
150
                    str = concat (str, dir_separator_str, imultilib, NULL);
151
                  add_path (str, SYSTEM, p->cxx_aware, false);
152
                }
153
            }
154
        }
155
    }
156
 
157
  for (p = cpp_include_defaults; p->fname; p++)
158
    {
159
      if (!p->cplusplus || cxx_stdinc)
160
        {
161
          char *str;
162
 
163
          /* Should this directory start with the sysroot?  */
164
          if (sysroot && p->add_sysroot)
165
            str = concat (sysroot, p->fname, NULL);
166
          else
167
            str = update_path (p->fname, p->component);
168
 
169
          if (p->multilib && imultilib)
170
            str = concat (str, dir_separator_str, imultilib, NULL);
171
 
172
          add_path (str, SYSTEM, p->cxx_aware, false);
173
        }
174
    }
175
}
176
 
177
/* For each duplicate path in chain HEAD, keep just the first one.
178
   Remove each path in chain HEAD that also exists in chain SYSTEM.
179
   Set the NEXT pointer of the last path in the resulting chain to
180
   JOIN, unless it duplicates JOIN in which case the last path is
181
   removed.  Return the head of the resulting chain.  Any of HEAD,
182
   JOIN and SYSTEM can be NULL.  */
183
 
184
static struct cpp_dir *
185
remove_duplicates (cpp_reader *pfile, struct cpp_dir *head,
186
                   struct cpp_dir *system, struct cpp_dir *join,
187
                   int verbose)
188
{
189
  struct cpp_dir **pcur, *tmp, *cur;
190
  struct stat st;
191
 
192
  for (pcur = &head; *pcur; )
193
    {
194
      int reason = REASON_QUIET;
195
 
196
      cur = *pcur;
197
 
198
      if (stat (cur->name, &st))
199
        {
200
          /* Dirs that don't exist are silently ignored, unless verbose.  */
201
          if (errno != ENOENT)
202
            cpp_errno (pfile, CPP_DL_ERROR, cur->name);
203
          else
204
            {
205
              /* If -Wmissing-include-dirs is given, warn.  */
206
              cpp_options *opts = cpp_get_options (pfile);
207
              if (opts->warn_missing_include_dirs && cur->user_supplied_p)
208
                cpp_errno (pfile, CPP_DL_WARNING, cur->name);
209
              reason = REASON_NOENT;
210
            }
211
        }
212
      else if (!S_ISDIR (st.st_mode))
213
        cpp_error_with_line (pfile, CPP_DL_ERROR, 0, 0,
214
                             "%s: not a directory", cur->name);
215
      else
216
        {
217
          INO_T_COPY (cur->ino, st.st_ino);
218
          cur->dev  = st.st_dev;
219
 
220
          /* Remove this one if it is in the system chain.  */
221
          reason = REASON_DUP_SYS;
222
          for (tmp = system; tmp; tmp = tmp->next)
223
           if (INO_T_EQ (tmp->ino, cur->ino) && tmp->dev == cur->dev
224
               && cur->construct == tmp->construct)
225
              break;
226
 
227
          if (!tmp)
228
            {
229
              /* Duplicate of something earlier in the same chain?  */
230
              reason = REASON_DUP;
231
              for (tmp = head; tmp != cur; tmp = tmp->next)
232
               if (INO_T_EQ (cur->ino, tmp->ino) && cur->dev == tmp->dev
233
                   && cur->construct == tmp->construct)
234
                  break;
235
 
236
              if (tmp == cur
237
                  /* Last in the chain and duplicate of JOIN?  */
238
                  && !(cur->next == NULL && join
239
                       && INO_T_EQ (cur->ino, join->ino)
240
                      && cur->dev == join->dev
241
                      && cur->construct == join->construct))
242
                {
243
                  /* Unique, so keep this directory.  */
244
                  pcur = &cur->next;
245
                  continue;
246
                }
247
            }
248
        }
249
 
250
      /* Remove this entry from the chain.  */
251
      *pcur = cur->next;
252
      free_path (cur, verbose ? reason: REASON_QUIET);
253
    }
254
 
255
  *pcur = join;
256
  return head;
257
}
258
 
259
/* Merge the four include chains together in the order quote, bracket,
260
   system, after.  Remove duplicate dirs (as determined by
261
   INO_T_EQ()).
262
 
263
   We can't just merge the lists and then uniquify them because then
264
   we may lose directories from the <> search path that should be
265
   there; consider -iquote foo -iquote bar -Ifoo -Iquux.  It is
266
   however safe to treat -iquote bar -iquote foo -Ifoo -Iquux as if
267
   written -iquote bar -Ifoo -Iquux.  */
268
 
269
static void
270
merge_include_chains (cpp_reader *pfile, int verbose)
271
{
272
  /* Join the SYSTEM and AFTER chains.  Remove duplicates in the
273
     resulting SYSTEM chain.  */
274
  if (heads[SYSTEM])
275
    tails[SYSTEM]->next = heads[AFTER];
276
  else
277
    heads[SYSTEM] = heads[AFTER];
278
  heads[SYSTEM] = remove_duplicates (pfile, heads[SYSTEM], 0, 0, verbose);
279
 
280
  /* Remove duplicates from BRACKET that are in itself or SYSTEM, and
281
     join it to SYSTEM.  */
282
  heads[BRACKET] = remove_duplicates (pfile, heads[BRACKET], heads[SYSTEM],
283
                                      heads[SYSTEM], verbose);
284
 
285
  /* Remove duplicates from QUOTE that are in itself or SYSTEM, and
286
     join it to BRACKET.  */
287
  heads[QUOTE] = remove_duplicates (pfile, heads[QUOTE], heads[SYSTEM],
288
                                    heads[BRACKET], verbose);
289
 
290
  /* If verbose, print the list of dirs to search.  */
291
  if (verbose)
292
    {
293
      struct cpp_dir *p;
294
 
295
      fprintf (stderr, _("#include \"...\" search starts here:\n"));
296
      for (p = heads[QUOTE];; p = p->next)
297
        {
298
          if (p == heads[BRACKET])
299
            fprintf (stderr, _("#include <...> search starts here:\n"));
300
          if (!p)
301
            break;
302
          fprintf (stderr, " %s\n", p->name);
303
        }
304
      fprintf (stderr, _("End of search list.\n"));
305
    }
306
}
307
 
308
/* Use given -I paths for #include "..." but not #include <...>, and
309
   don't search the directory of the present file for #include "...".
310
   (Note that -I. -I- is not the same as the default setup; -I. uses
311
   the compiler's working dir.)  */
312
void
313
split_quote_chain (void)
314
{
315
  heads[QUOTE] = heads[BRACKET];
316
  tails[QUOTE] = tails[BRACKET];
317
  heads[BRACKET] = NULL;
318
  tails[BRACKET] = NULL;
319
  /* This is NOT redundant.  */
320
  quote_ignores_source_dir = true;
321
}
322
 
323
/* Add P to the chain specified by CHAIN.  */
324
 
325
void
326
add_cpp_dir_path (cpp_dir *p, int chain)
327
{
328
  if (tails[chain])
329
    tails[chain]->next = p;
330
  else
331
    heads[chain] = p;
332
  tails[chain] = p;
333
}
334
 
335
/* Add PATH to the include chain CHAIN. PATH must be malloc-ed and
336
   NUL-terminated.  */
337
void
338
add_path (char *path, int chain, int cxx_aware, bool user_supplied_p)
339
{
340
  cpp_dir *p;
341
 
342
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
343
  /* Convert all backslashes to slashes.  The native CRT stat()
344
     function does not recognize a directory that ends in a backslash
345
     (unless it is a drive root dir, such "c:\").  Forward slashes,
346
     trailing or otherwise, cause no problems for stat().  */
347
  char* c;
348
  for (c = path; *c; c++)
349
    if (*c == '\\') *c = '/';
350
#endif
351
 
352
  p = XNEW (cpp_dir);
353
  p->next = NULL;
354
  p->name = path;
355
  if (chain == SYSTEM || chain == AFTER)
356
    p->sysp = 1 + !cxx_aware;
357
  else
358
    p->sysp = 0;
359
  p->construct = 0;
360
  p->user_supplied_p = user_supplied_p;
361
 
362
  add_cpp_dir_path (p, chain);
363
}
364
 
365
/* Exported function to handle include chain merging, duplicate
366
   removal, and registration with cpplib.  */
367
void
368
register_include_chains (cpp_reader *pfile, const char *sysroot,
369
                         const char *iprefix, const char *imultilib,
370
                         int stdinc, int cxx_stdinc, int verbose)
371
{
372
  static const char *const lang_env_vars[] =
373
    { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH",
374
      "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" };
375
  cpp_options *cpp_opts = cpp_get_options (pfile);
376
  size_t idx = (cpp_opts->objc ? 2: 0);
377
 
378
  if (cpp_opts->cplusplus)
379
    idx++;
380
  else
381
    cxx_stdinc = false;
382
 
383
  /* CPATH and language-dependent environment variables may add to the
384
     include chain.  */
385
  add_env_var_paths ("CPATH", BRACKET);
386
  add_env_var_paths (lang_env_vars[idx], SYSTEM);
387
 
388
  target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc);
389
 
390
  /* Finally chain on the standard directories.  */
391
  if (stdinc)
392
    add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc);
393
 
394
  target_c_incpath.extra_includes (sysroot, iprefix, stdinc);
395
 
396
  merge_include_chains (pfile, verbose);
397
 
398
  cpp_set_include_chains (pfile, heads[QUOTE], heads[BRACKET],
399
                          quote_ignores_source_dir);
400
}
401
#if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES)
402
static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED,
403
                                           const char *iprefix ATTRIBUTE_UNUSED,
404
                                           int stdinc ATTRIBUTE_UNUSED)
405
{
406
}
407
#endif
408
 
409
#ifndef TARGET_EXTRA_INCLUDES
410
#define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int
411
#endif
412
#ifndef TARGET_EXTRA_PRE_INCLUDES
413
#define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int
414
#endif
415
 
416
struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES };
417
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.