Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly
[dragonfly.git] / contrib / gcc-3.4 / gcc / cppfiles.c
CommitLineData
003757ed
MD
1/* Part of CPP library. File handling.
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4 Written by Per Bothner, 1994.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
7 Split out of cpplib.c, Zack Weinberg, Oct 1998
8 Reimplemented, Neil Booth, Jul 2003
9
10This program is free software; you can redistribute it and/or modify it
11under the terms of the GNU General Public License as published by the
12Free Software Foundation; either version 2, or (at your option) any
13later version.
14
15This program is distributed in the hope that it will be useful,
16but WITHOUT ANY WARRANTY; without even the implied warranty of
17MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18GNU General Public License for more details.
19
20You should have received a copy of the GNU General Public License
21along with this program; if not, write to the Free Software
22Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23
24#include "config.h"
25#include "system.h"
26#include "cpplib.h"
27#include "cpphash.h"
28#include "intl.h"
29#include "mkdeps.h"
30#include "hashtab.h"
31#include <dirent.h>
32
33/* Variable length record files on VMS will have a stat size that includes
34 record control characters that won't be included in the read size. */
35#ifdef VMS
36# define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
37# define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
38#else
39# define STAT_SIZE_RELIABLE(ST) true
40#endif
41
42#ifdef __DJGPP__
43 /* For DJGPP redirected input is opened in text mode. */
44# define set_stdin_to_binary_mode() \
45 if (! isatty (0)) setmode (0, O_BINARY)
46#else
47# define set_stdin_to_binary_mode() /* Nothing */
48#endif
49
50#ifndef O_BINARY
51# define O_BINARY 0
52#endif
53
54/* This structure represents a file searched for by CPP, whether it
55 exists or not. An instance may be pointed to by more than one
56 file_hash_entry; at present no reference count is kept. */
57struct _cpp_file
58{
59 /* Filename as given to #include or command line switch. */
60 const char *name;
61
62 /* The full path used to find the file. */
63 const char *path;
64
65 /* The full path of the pch file. */
66 const char *pchname;
67
68 /* The file's path with the basename stripped. NULL if it hasn't
69 been calculated yet. */
70 const char *dir_name;
71
72 /* Chain through all files. */
73 struct _cpp_file *next_file;
74
75 /* The contents of NAME after calling read_file(). */
76 const uchar *buffer;
77
78 /* The macro, if any, preventing re-inclusion. */
79 const cpp_hashnode *cmacro;
80
81 /* The directory in the search path where FILE was found. Used for
82 #include_next and determining whether a header is a system
83 header. */
84 cpp_dir *dir;
85
86 /* As filled in by stat(2) for the file. */
87 struct stat st;
88
89 /* File descriptor. Invalid if -1, otherwise open. */
90 int fd;
91
92 /* Zero if this file was successfully opened and stat()-ed,
93 otherwise errno obtained from failure. */
94 int err_no;
95
96 /* Number of times the file has been stacked for preprocessing. */
97 unsigned short stack_count;
98
99 /* If opened with #import or contains #pragma once. */
100 bool once_only;
101
102 /* If read() failed before. */
103 bool dont_read;
104
105 /* If this file is the main file. */
106 bool main_file;
107
108 /* If BUFFER above contains the true contents of the file. */
109 bool buffer_valid;
110
111 /* 0: file not known to be a PCH.
112 1: file is a PCH (on return from find_include_file).
113 2: file is not and never will be a valid precompiled header.
114 3: file is always a valid precompiled header. */
115 uchar pch;
116};
117
118/* A singly-linked list for all searches for a given file name, with
119 its head pointed to by a slot in FILE_HASH. The file name is what
120 appeared between the quotes in a #include directive; it can be
121 determined implicitly from the hash table location or explicitly
122 from FILE->name.
123
124 FILE is a structure containing details about the file that was
125 found with that search, or details of how the search failed.
126
127 START_DIR is the starting location of the search in the include
128 chain. The current directories for "" includes are also hashed in
129 the hash table and therefore unique. Files that are looked up
130 without using a search path, such as absolute filenames and file
131 names from the command line share a special starting directory so
132 they don't cause cache hits with normal include-chain lookups.
133
134 If START_DIR is NULL then the entry is for a directory, not a file,
135 and the directory is in DIR. Since the starting point in a file
136 lookup chain is never NULL, this means that simple pointer
137 comparisons against START_DIR can be made to determine cache hits
138 in file lookups.
139
140 If a cache lookup fails because of e.g. an extra "./" in the path,
141 then nothing will break. It is just less efficient as CPP will
142 have to do more work re-preprocessing the file, and/or comparing
143 its contents against earlier once-only files.
144*/
145struct file_hash_entry
146{
147 struct file_hash_entry *next;
148 cpp_dir *start_dir;
149 union
150 {
151 _cpp_file *file;
152 cpp_dir *dir;
153 } u;
154};
155
156static bool open_file (_cpp_file *file);
157static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
158 bool *invalid_pch);
159static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
160 bool *invalid_pch);
161static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
162static bool read_file (cpp_reader *pfile, _cpp_file *file);
163static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
164static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
165 int angle_brackets, enum include_type);
166static const char *dir_name_of_file (_cpp_file *file);
1378ea41 167static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int);
003757ed
MD
168static struct file_hash_entry *search_cache (struct file_hash_entry *head,
169 const cpp_dir *start_dir);
170static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
1c1138ce 171static void destroy_cpp_file (_cpp_file *);
003757ed
MD
172static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
173static void allocate_file_hash_entries (cpp_reader *pfile);
174static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
175static int report_missing_guard (void **slot, void *b);
176static hashval_t file_hash_hash (const void *p);
177static int file_hash_eq (const void *p, const void *q);
178static char *read_filename_string (int ch, FILE *f);
179static void read_name_map (cpp_dir *dir);
180static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
181static char *append_file_to_dir (const char *fname, cpp_dir *dir);
182static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
183static bool include_pch_p (_cpp_file *file);
184
185/* Given a filename in FILE->PATH, with the empty string interpreted
186 as <stdin>, open it.
187
188 On success FILE contains an open file descriptor and stat
189 information for the file. On failure the file descriptor is -1 and
190 the appropriate errno is also stored in FILE. Returns TRUE iff
191 successful.
192
193 We used to open files in nonblocking mode, but that caused more
194 problems than it solved. Do take care not to acquire a controlling
195 terminal by mistake (this can't happen on sane systems, but
196 paranoia is a virtue).
197
198 Use the three-argument form of open even though we aren't
199 specifying O_CREAT, to defend against broken system headers.
200
201 O_BINARY tells some runtime libraries (notably DJGPP) not to do
202 newline translation; we can handle DOS line breaks just fine
203 ourselves. */
204static bool
205open_file (_cpp_file *file)
206{
207 if (file->path[0] == '\0')
208 {
209 file->fd = 0;
210 set_stdin_to_binary_mode ();
211 }
212 else
213 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
214
215 if (file->fd != -1)
216 {
217 if (fstat (file->fd, &file->st) == 0)
218 {
219 if (!S_ISDIR (file->st.st_mode))
220 {
221 file->err_no = 0;
222 return true;
223 }
224
225 /* Ignore a directory and continue the search. The file we're
226 looking for may be elsewhere in the search path. */
227 errno = ENOENT;
228 }
229
230 close (file->fd);
231 file->fd = -1;
232 }
233 else if (errno == ENOTDIR)
234 errno = ENOENT;
235
236 file->err_no = errno;
237
238 return false;
239}
240
241/* Temporary PCH intercept of opening a file. Try to find a PCH file
242 based on FILE->name and FILE->dir, and test those found for
243 validity using PFILE->cb.valid_pch. Return true iff a valid file is
244 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
245
246static bool
247pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
248{
249 static const char extension[] = ".gch";
250 const char *path = file->path;
251 size_t len, flen;
252 char *pchname;
253 struct stat st;
254 bool valid = false;
255
256 /* No PCH on <stdin> or if not requested. */
257 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
258 return false;
259
260 flen = strlen (path);
261 len = flen + sizeof (extension);
262 pchname = xmalloc (len);
263 memcpy (pchname, path, flen);
264 memcpy (pchname + flen, extension, sizeof (extension));
265
266 if (stat (pchname, &st) == 0)
267 {
268 DIR *pchdir;
269 struct dirent *d;
270 size_t dlen, plen = len;
271
272 if (!S_ISDIR (st.st_mode))
273 valid = validate_pch (pfile, file, pchname);
274 else if ((pchdir = opendir (pchname)) != NULL)
275 {
276 pchname[plen - 1] = '/';
277 while ((d = readdir (pchdir)) != NULL)
278 {
279 dlen = strlen (d->d_name) + 1;
280 if ((strcmp (d->d_name, ".") == 0)
281 || (strcmp (d->d_name, "..") == 0))
282 continue;
283 if (dlen + plen > len)
284 {
285 len += dlen + 64;
286 pchname = xrealloc (pchname, len);
287 }
288 memcpy (pchname + plen, d->d_name, dlen);
289 valid = validate_pch (pfile, file, pchname);
290 if (valid)
291 break;
292 }
293 closedir (pchdir);
294 }
295 if (valid)
296 file->pch = true;
297 else
298 *invalid_pch = true;
299 }
300
301 if (valid)
302 file->pchname = pchname;
303 else
304 free (pchname);
305
306 return valid;
307}
308
309/* Try to open the path FILE->name appended to FILE->dir. This is
310 where remap and PCH intercept the file lookup process. Return true
311 if the file was found, whether or not the open was successful.
312 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
313
314static bool
315find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
316{
317 char *path;
318
319 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
320 ;
321 else
322 path = append_file_to_dir (file->name, file->dir);
323
324 file->path = path;
325 if (pch_open_file (pfile, file, invalid_pch))
326 return true;
327
328 if (open_file (file))
329 return true;
330
331 if (file->err_no != ENOENT)
332 {
1378ea41 333 open_file_failed (pfile, file, 0);
003757ed
MD
334 return true;
335 }
336
337 free (path);
338 file->path = file->name;
339 return false;
340}
341
342bool
343_cpp_find_failed (_cpp_file *file)
344{
345 return file->err_no != 0;
346}
347
348/* Given a filename FNAME search for such a file in the include path
349 starting from START_DIR. If FNAME is the empty string it is
350 interpreted as STDIN if START_DIR is PFILE->no_seach_path.
351
352 If the file is not found in the file cache fall back to the O/S and
353 add the result to our cache.
354
355 If the file was not found in the filesystem, or there was an error
356 opening it, then ERR_NO is nonzero and FD is -1. If the file was
357 found, then ERR_NO is zero and FD could be -1 or an open file
358 descriptor. FD can be -1 if the file was found in the cache and
359 had previously been closed. To open it again pass the return value
360 to open_file().
361*/
362_cpp_file *
1378ea41 363_cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake, int angle_brackets)
003757ed
MD
364{
365 struct file_hash_entry *entry, **hash_slot;
366 _cpp_file *file;
367 bool invalid_pch = false;
368
369 /* Ensure we get no confusion between cached files and directories. */
370 if (start_dir == NULL)
371 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
372
373 hash_slot = (struct file_hash_entry **)
374 htab_find_slot_with_hash (pfile->file_hash, fname,
375 htab_hash_string (fname),
376 INSERT);
377
378 /* First check the cache before we resort to memory allocation. */
379 entry = search_cache (*hash_slot, start_dir);
380 if (entry)
381 return entry->u.file;
382
383 file = make_cpp_file (pfile, start_dir, fname);
384
385 /* Try each path in the include chain. */
386 for (; !fake ;)
387 {
388 if (find_file_in_dir (pfile, file, &invalid_pch))
389 break;
390
391 file->dir = file->dir->next;
392 if (file->dir == NULL)
393 {
1378ea41 394 open_file_failed (pfile, file, angle_brackets);
003757ed
MD
395 if (invalid_pch)
396 {
397 cpp_error (pfile, CPP_DL_ERROR,
398 "one or more PCH files were found, but they were invalid");
399 if (!cpp_get_options (pfile)->warn_invalid_pch)
400 cpp_error (pfile, CPP_DL_ERROR,
401 "use -Winvalid-pch for more information");
402 }
403 break;
404 }
405
406 /* Only check the cache for the starting location (done above)
407 and the quote and bracket chain heads because there are no
408 other possible starting points for searches. */
409 if (file->dir != pfile->bracket_include
410 && file->dir != pfile->quote_include)
411 continue;
412
413 entry = search_cache (*hash_slot, file->dir);
414 if (entry)
415 break;
416 }
417
418 if (entry)
419 {
420 /* Cache for START_DIR too, sharing the _cpp_file structure. */
421 free ((char *) file->name);
422 free (file);
423 file = entry->u.file;
424 }
425 else
426 {
427 /* This is a new file; put it in the list. */
428 file->next_file = pfile->all_files;
429 pfile->all_files = file;
430 }
431
432 /* Store this new result in the hash table. */
433 entry = new_file_hash_entry (pfile);
434 entry->next = *hash_slot;
435 entry->start_dir = start_dir;
436 entry->u.file = file;
437 *hash_slot = entry;
438
439 return file;
440}
441
442/* Read a file into FILE->buffer, returning true on success.
443
444 If FILE->fd is something weird, like a block device, we don't want
445 to read it at all. Don't even try to figure out what something is,
446 except for plain files and block devices, since there is no
447 reliable portable way of doing this.
448
449 FIXME: Flush file cache and try again if we run out of memory. */
450static bool
451read_file_guts (cpp_reader *pfile, _cpp_file *file)
452{
453 ssize_t size, total, count;
454 uchar *buf;
455 bool regular;
456
457 if (S_ISBLK (file->st.st_mode))
458 {
459 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
460 return false;
461 }
462
463 regular = S_ISREG (file->st.st_mode);
464 if (regular)
465 {
466 /* off_t might have a wider range than ssize_t - in other words,
467 the max size of a file might be bigger than the address
468 space. We can't handle a file that large. (Anyone with
469 a single source file bigger than 2GB needs to rethink
470 their coding style.) Some systems (e.g. AIX 4.1) define
471 SSIZE_MAX to be much smaller than the actual range of the
472 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
473 does not bite us. */
474 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
475 {
476 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
477 return false;
478 }
479
480 size = file->st.st_size;
481 }
482 else
483 /* 8 kilobytes is a sensible starting size. It ought to be bigger
484 than the kernel pipe buffer, and it's definitely bigger than
485 the majority of C source files. */
486 size = 8 * 1024;
487
488 buf = xmalloc (size + 1);
489 total = 0;
490 while ((count = read (file->fd, buf + total, size - total)) > 0)
491 {
492 total += count;
493
494 if (total == size)
495 {
496 if (regular)
497 break;
498 size *= 2;
499 buf = xrealloc (buf, size + 1);
500 }
501 }
502
503 if (count < 0)
504 {
505 cpp_errno (pfile, CPP_DL_ERROR, file->path);
506 return false;
507 }
508
509 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
510 cpp_error (pfile, CPP_DL_WARNING,
511 "%s is shorter than expected", file->path);
512
513 file->buffer = _cpp_convert_input (pfile, CPP_OPTION (pfile, input_charset),
514 buf, size, total, &file->st.st_size);
515 file->buffer_valid = true;
516
517 return true;
518}
519
520/* Convenience wrapper around read_file_guts that opens the file if
521 necessary and closes the file descriptor after reading. FILE must
522 have been passed through find_file() at some stage. */
523static bool
524read_file (cpp_reader *pfile, _cpp_file *file)
525{
526 /* If we already have its contents in memory, succeed immediately. */
527 if (file->buffer_valid)
528 return true;
529
530 /* If an earlier read failed for some reason don't try again. */
531 if (file->dont_read || file->err_no)
532 return false;
533
534 if (file->fd == -1 && !open_file (file))
535 {
1378ea41 536 open_file_failed (pfile, file, 0);
003757ed
MD
537 return false;
538 }
539
540 file->dont_read = !read_file_guts (pfile, file);
541 close (file->fd);
542 file->fd = -1;
543
544 return !file->dont_read;
545}
546
547/* Returns TRUE if FILE's contents have been successfully placed in
548 FILE->buffer and the file should be stacked, otherwise false. */
549static bool
550should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
551{
552 _cpp_file *f;
553
554 /* Skip once-only files. */
555 if (file->once_only)
556 return false;
557
558 /* We must mark the file once-only if #import now, before header
559 guard checks. Otherwise, undefining the header guard might
560 cause the file to be re-stacked. */
561 if (import)
562 {
563 _cpp_mark_file_once_only (pfile, file);
564
565 /* Don't stack files that have been stacked before. */
566 if (file->stack_count)
567 return false;
568 }
569
570 /* Skip if the file had a header guard and the macro is defined.
571 PCH relies on this appearing before the PCH handler below. */
572 if (file->cmacro && file->cmacro->type == NT_MACRO)
573 return false;
574
575 /* Handle PCH files immediately; don't stack them. */
576 if (include_pch_p (file))
577 {
578 pfile->cb.read_pch (pfile, file->path, file->fd, file->pchname);
579 close (file->fd);
580 file->fd = -1;
581 return false;
582 }
583
584 if (!read_file (pfile, file))
585 return false;
586
587 /* Now we've read the file's contents, we can stack it if there
588 are no once-only files. */
589 if (!pfile->seen_once_only)
590 return true;
591
592 /* We may have read the file under a different name. Look
593 for likely candidates and compare file contents to be sure. */
594 for (f = pfile->all_files; f; f = f->next_file)
595 {
596 if (f == file)
597 continue;
598
599 if ((import || f->once_only)
600 && f->err_no == 0
601 && f->st.st_mtime == file->st.st_mtime
1c1138ce
JS
602 && f->st.st_size == file->st.st_size)
603 {
604 _cpp_file *ref_file;
605 bool same_file_p = false;
606
607 if (f->buffer && !f->buffer_valid)
608 {
609 /* We already have a buffer but it is not valid, because
610 the file is still stacked. Make a new one. */
611 ref_file = make_cpp_file (pfile, f->dir, f->name);
612 ref_file->path = f->path;
613 }
614 else
615 /* The file is not stacked anymore. We can reuse it. */
616 ref_file = f;
617
618 same_file_p = read_file (pfile, ref_file)
619 /* Size might have changed in read_file(). */
620 && ref_file->st.st_size == file->st.st_size
621 && !memcmp (ref_file->buffer,
622 file->buffer,
623 file->st.st_size);
624
625 if (f->buffer && !f->buffer_valid)
626 {
627 ref_file->path = 0;
628 destroy_cpp_file (ref_file);
629 }
630
631 if (same_file_p)
632 break;
633 }
003757ed
MD
634 }
635
636 return f == NULL;
637}
638
639/* Place the file referenced by FILE into a new buffer on the buffer
640 stack if possible. IMPORT is true if this stacking attempt is
641 because of a #import directive. Returns true if a buffer is
642 stacked. */
643bool
644_cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
645{
646 cpp_buffer *buffer;
647 int sysp;
648
649 if (!should_stack_file (pfile, file, import))
650 return false;
651
652 sysp = MAX ((pfile->map ? pfile->map->sysp : 0),
653 (file->dir ? file->dir->sysp : 0));
654
655 /* Add the file to the dependencies on its first inclusion. */
656 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
657 {
658 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
659 deps_add_dep (pfile->deps, file->path);
660 }
661
662 /* Clear buffer_valid since _cpp_clean_line messes it up. */
663 file->buffer_valid = false;
664 file->stack_count++;
665
666 /* Stack the buffer. */
667 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
668 CPP_OPTION (pfile, preprocessed));
669 buffer->file = file;
670
671 /* Initialize controlling macro state. */
672 pfile->mi_valid = true;
673 pfile->mi_cmacro = 0;
674
675 /* Generate the call back. */
676 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
677
678 return true;
679}
680
681/* Mark FILE to be included once only. */
682void
683_cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
684{
685 pfile->seen_once_only = true;
686 file->once_only = true;
687}
688
689/* Return the directory from which searching for FNAME should start,
690 considering the directive TYPE and ANGLE_BRACKETS. If there is
691 nothing left in the path, returns NULL. */
692static struct cpp_dir *
693search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
694 enum include_type type)
695{
696 cpp_dir *dir;
697 _cpp_file *file;
698
699 if (IS_ABSOLUTE_PATH (fname))
700 return &pfile->no_search_path;
701
702 /* pfile->buffer is NULL when processing an -include command-line flag. */
703 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
704
705 /* For #include_next, skip in the search path past the dir in which
706 the current file was found, but if it was found via an absolute
707 path use the normal search logic. */
708 if (type == IT_INCLUDE_NEXT && file->dir)
709 dir = file->dir->next;
710 else if (angle_brackets)
711 dir = pfile->bracket_include;
712 else if (type == IT_CMDLINE)
713 /* -include and -imacros use the #include "" chain with the
714 preprocessor's cwd prepended. */
715 return make_cpp_dir (pfile, "./", false);
716 else if (pfile->quote_ignores_source_dir)
717 dir = pfile->quote_include;
718 else
719 return make_cpp_dir (pfile, dir_name_of_file (file), pfile->map->sysp);
720
721 if (dir == NULL)
722 cpp_error (pfile, CPP_DL_ERROR,
723 "no include path in which to search for %s", fname);
724
725 return dir;
726}
727
728/* Strip the basename from the file's path. It ends with a slash if
729 of nonzero length. Note that this procedure also works for
730 <stdin>, which is represented by the empty string. */
731static const char *
732dir_name_of_file (_cpp_file *file)
733{
734 if (!file->dir_name)
735 {
736 size_t len = lbasename (file->path) - file->path;
737 char *dir_name = xmalloc (len + 1);
738
739 memcpy (dir_name, file->path, len);
740 dir_name[len] = '\0';
741 file->dir_name = dir_name;
742 }
743
744 return file->dir_name;
745}
746
747/* Handles #include-family directives (distinguished by TYPE),
748 including HEADER, and the command line -imacros and -include.
749 Returns true if a buffer was stacked. */
750bool
751_cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
752 enum include_type type)
753{
754 struct cpp_dir *dir;
755
756 dir = search_path_head (pfile, fname, angle_brackets, type);
757 if (!dir)
758 return false;
759
1378ea41
SS
760 return _cpp_stack_file (pfile, _cpp_find_file (pfile, fname, dir, false,
761 angle_brackets),
003757ed
MD
762 type == IT_IMPORT);
763}
764
765/* Could not open FILE. The complication is dependency output. */
766static void
1378ea41 767open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
003757ed
MD
768{
769 int sysp = pfile->map ? pfile->map->sysp: 0;
1378ea41 770 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
003757ed
MD
771
772 errno = file->err_no;
773 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
774 deps_add_dep (pfile->deps, file->name);
775 else
776 {
777 /* If we are outputting dependencies but not for this file then
778 don't error because we can still produce correct output. */
779 if (CPP_OPTION (pfile, deps.style) && ! print_dep)
780 cpp_errno (pfile, CPP_DL_WARNING, file->path);
781 else
782 cpp_errno (pfile, CPP_DL_ERROR, file->path);
783 }
784}
785
786/* Search in the chain beginning at HEAD for a file whose search path
787 started at START_DIR != NULL. */
788static struct file_hash_entry *
789search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
790{
791 while (head && head->start_dir != start_dir)
792 head = head->next;
793
794 return head;
795}
796
797/* Allocate a new _cpp_file structure. */
798static _cpp_file *
799make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
800{
801 _cpp_file *file;
802
803 file = xcalloc (1, sizeof (_cpp_file));
804 file->main_file = !pfile->buffer;
805 file->fd = -1;
806 file->dir = dir;
807 file->name = xstrdup (fname);
808
809 return file;
810}
811
1c1138ce
JS
812/* Release a _cpp_file structure. */
813static void
814destroy_cpp_file (_cpp_file *file)
815{
816 if (file->buffer)
817 free ((void *) file->buffer);
818 free ((void *) file->name);
819 free (file);
820}
821
003757ed
MD
822/* A hash of directory names. The directory names are the path names
823 of files which contain a #include "", the included file name is
824 appended to this directories.
825
826 To avoid duplicate entries we follow the convention that all
827 non-empty directory names should end in a '/'. DIR_NAME must be
828 stored in permanently allocated memory. */
829static cpp_dir *
830make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
831{
832 struct file_hash_entry *entry, **hash_slot;
833 cpp_dir *dir;
834
835 hash_slot = (struct file_hash_entry **)
3a327f56 836 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
003757ed
MD
837 htab_hash_string (dir_name),
838 INSERT);
839
840 /* Have we already hashed this directory? */
841 for (entry = *hash_slot; entry; entry = entry->next)
842 if (entry->start_dir == NULL)
843 return entry->u.dir;
844
845 dir = xcalloc (1, sizeof (cpp_dir));
846 dir->next = pfile->quote_include;
847 dir->name = (char *) dir_name;
848 dir->len = strlen (dir_name);
849 dir->sysp = sysp;
850
851 /* Store this new result in the hash table. */
852 entry = new_file_hash_entry (pfile);
853 entry->next = *hash_slot;
854 entry->start_dir = NULL;
855 entry->u.dir = dir;
856 *hash_slot = entry;
857
858 return dir;
859}
860
861/* Create a new block of memory for file hash entries. */
862static void
863allocate_file_hash_entries (cpp_reader *pfile)
864{
865 pfile->file_hash_entries_used = 0;
866 pfile->file_hash_entries_allocated = 127;
867 pfile->file_hash_entries = xmalloc
868 (pfile->file_hash_entries_allocated * sizeof (struct file_hash_entry));
869}
870
871/* Return a new file hash entry. */
872static struct file_hash_entry *
873new_file_hash_entry (cpp_reader *pfile)
874{
875 if (pfile->file_hash_entries_used == pfile->file_hash_entries_allocated)
876 allocate_file_hash_entries (pfile);
877
878 return &pfile->file_hash_entries[pfile->file_hash_entries_used++];
879}
880
881/* Returns TRUE if a file FNAME has ever been successfully opened.
882 This routine is not intended to correctly handle filenames aliased
883 by links or redundant . or .. traversals etc. */
884bool
885cpp_included (cpp_reader *pfile, const char *fname)
886{
887 struct file_hash_entry *entry;
888
889 entry = htab_find_with_hash (pfile->file_hash, fname,
890 htab_hash_string (fname));
891
892 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
893 entry = entry->next;
894
895 return entry != NULL;
896}
897
898/* Calculate the hash value of a file hash entry P. */
899
900static hashval_t
901file_hash_hash (const void *p)
902{
903 struct file_hash_entry *entry = (struct file_hash_entry *) p;
904 const char *hname;
905 if (entry->start_dir)
906 hname = entry->u.file->name;
907 else
908 hname = entry->u.dir->name;
909
910 return htab_hash_string (hname);
911}
912
913/* Compare a string Q against a file hash entry P. */
914static int
915file_hash_eq (const void *p, const void *q)
916{
917 struct file_hash_entry *entry = (struct file_hash_entry *) p;
918 const char *fname = (const char *) q;
919 const char *hname;
920
921 if (entry->start_dir)
922 hname = entry->u.file->name;
923 else
924 hname = entry->u.dir->name;
925
926 return strcmp (hname, fname) == 0;
927}
928
929/* Initialize everything in this source file. */
930void
931_cpp_init_files (cpp_reader *pfile)
932{
933 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
934 NULL, xcalloc, free);
3a327f56
JS
935 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
936 NULL, xcalloc, free);
003757ed
MD
937 allocate_file_hash_entries (pfile);
938}
939
940/* Finalize everything in this source file. */
941void
942_cpp_cleanup_files (cpp_reader *pfile)
943{
944 htab_delete (pfile->file_hash);
3a327f56 945 htab_delete (pfile->dir_hash);
003757ed
MD
946}
947
948/* Enter a file name in the hash for the sake of cpp_included. */
949void
950_cpp_fake_include (cpp_reader *pfile, const char *fname)
951{
1378ea41 952 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
003757ed
MD
953}
954
955/* Not everyone who wants to set system-header-ness on a buffer can
956 see the details of a buffer. This is an exported interface because
957 fix-header needs it. */
958void
959cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
960{
961 int flags = 0;
962
963 /* 1 = system header, 2 = system header to be treated as C. */
964 if (syshdr)
965 flags = 1 + (externc != 0);
966 _cpp_do_file_change (pfile, LC_RENAME, pfile->map->to_file,
967 SOURCE_LINE (pfile->map, pfile->line), flags);
968}
969
970/* Allow the client to change the current file. Used by the front end
971 to achieve pseudo-file names like <built-in>.
972 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
973void
974cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
975 const char *new_name)
976{
977 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
978}
979
980/* Callback function for htab_traverse. */
981static int
982report_missing_guard (void **slot, void *b)
983{
984 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
985 int *bannerp = (int *) b;
986
987 /* Skip directories. */
988 if (entry->start_dir != NULL)
989 {
990 _cpp_file *file = entry->u.file;
991
992 /* We don't want MI guard advice for the main file. */
993 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
994 {
995 if (*bannerp == 0)
996 {
997 fputs (_("Multiple include guards may be useful for:\n"),
998 stderr);
999 *bannerp = 1;
1000 }
1001
1002 fputs (entry->u.file->path, stderr);
1003 putc ('\n', stderr);
1004 }
1005 }
1006
1007 return 0;
1008}
1009
1010/* Report on all files that might benefit from a multiple include guard.
1011 Triggered by -H. */
1012void
1013_cpp_report_missing_guards (cpp_reader *pfile)
1014{
1015 int banner = 0;
1016
1017 htab_traverse (pfile->file_hash, report_missing_guard, &banner);
1018}
1019
1020/* Locate HEADER, and determine whether it is newer than the current
1021 file. If it cannot be located or dated, return -1, if it is
1022 newer, return 1, otherwise 0. */
1023int
1024_cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1025 int angle_brackets)
1026{
1027 _cpp_file *file;
1028 struct cpp_dir *dir;
1029
1030 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1031 if (!dir)
1032 return -1;
1033
1378ea41 1034 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
003757ed
MD
1035 if (file->err_no)
1036 return -1;
1037
1038 if (file->fd != -1)
1039 {
1040 close (file->fd);
1041 file->fd = -1;
1042 }
1043
1044 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1045}
1046
1047/* Pushes the given file onto the buffer stack. Returns nonzero if
1048 successful. */
1049bool
1050cpp_push_include (cpp_reader *pfile, const char *fname)
1051{
1052 /* Make the command line directive take up a line. */
1053 pfile->line++;
1054 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1055}
1056
1057/* Do appropriate cleanup when a file INC's buffer is popped off the
1058 input stack. */
1059void
1060_cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1061{
1062 /* Record the inclusion-preventing macro, which could be NULL
1063 meaning no controlling macro. */
1064 if (pfile->mi_valid && file->cmacro == NULL)
1065 file->cmacro = pfile->mi_cmacro;
1066
1067 /* Invalidate control macros in the #including file. */
1068 pfile->mi_valid = false;
1069
1070 if (file->buffer)
1071 {
1072 free ((void *) file->buffer);
1073 file->buffer = NULL;
1378ea41 1074 file->buffer_valid = false;
003757ed
MD
1075 }
1076}
1077
1078/* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1079 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1080 directory of the including file.
1081
1082 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1083void
1084cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1085 int quote_ignores_source_dir)
1086{
1087 pfile->quote_include = quote;
1088 pfile->bracket_include = quote;
1089 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1090
1091 for (; quote; quote = quote->next)
1092 {
1093 quote->name_map = NULL;
1094 quote->len = strlen (quote->name);
1095 if (quote == bracket)
1096 pfile->bracket_include = bracket;
1097 }
1098}
1099
1100/* Append the file name to the directory to create the path, but don't
1101 turn / into // or // into ///; // may be a namespace escape. */
1102static char *
1103append_file_to_dir (const char *fname, cpp_dir *dir)
1104{
1105 size_t dlen, flen;
1106 char *path;
1107
1108 dlen = dir->len;
1109 flen = strlen (fname);
1110 path = xmalloc (dlen + 1 + flen + 1);
1111 memcpy (path, dir->name, dlen);
1112 if (dlen && path[dlen - 1] != '/')
1113 path[dlen++] = '/';
1114 memcpy (&path[dlen], fname, flen + 1);
1115
1116 return path;
1117}
1118
1119/* Read a space delimited string of unlimited length from a stdio
1120 file F. */
1121static char *
1122read_filename_string (int ch, FILE *f)
1123{
1124 char *alloc, *set;
1125 int len;
1126
1127 len = 20;
1128 set = alloc = xmalloc (len + 1);
1129 if (! is_space (ch))
1130 {
1131 *set++ = ch;
1132 while ((ch = getc (f)) != EOF && ! is_space (ch))
1133 {
1134 if (set - alloc == len)
1135 {
1136 len *= 2;
1137 alloc = xrealloc (alloc, len + 1);
1138 set = alloc + len / 2;
1139 }
1140 *set++ = ch;
1141 }
1142 }
1143 *set = '\0';
1144 ungetc (ch, f);
1145 return alloc;
1146}
1147
1148/* Read the file name map file for DIR. */
1149static void
1150read_name_map (cpp_dir *dir)
1151{
1152 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1153 char *name;
1154 FILE *f;
1155 size_t len, count = 0, room = 9;
1156
1157 len = dir->len;
1158 name = alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1159 memcpy (name, dir->name, len);
1160 if (len && name[len - 1] != '/')
1161 name[len++] = '/';
1162 strcpy (name + len, FILE_NAME_MAP_FILE);
1163 f = fopen (name, "r");
1164
1165 dir->name_map = xmalloc (room * sizeof (char *));
1166
1167 /* Silently return NULL if we cannot open. */
1168 if (f)
1169 {
1170 int ch;
1171
1172 while ((ch = getc (f)) != EOF)
1173 {
1174 char *to;
1175
1176 if (is_space (ch))
1177 continue;
1178
1179 if (count + 2 > room)
1180 {
1181 room += 8;
1182 dir->name_map = xrealloc (dir->name_map, room * sizeof (char *));
1183 }
1184
1185 dir->name_map[count] = read_filename_string (ch, f);
1186 while ((ch = getc (f)) != EOF && is_hspace (ch))
1187 ;
1188
1189 to = read_filename_string (ch, f);
1190 if (IS_ABSOLUTE_PATH (to))
1191 dir->name_map[count + 1] = to;
1192 else
1193 {
1194 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1195 free (to);
1196 }
1197
1198 count += 2;
1199 while ((ch = getc (f)) != '\n')
1200 if (ch == EOF)
1201 break;
1202 }
1203
1204 fclose (f);
1205 }
1206
1207 /* Terminate the list of maps. */
1208 dir->name_map[count] = NULL;
1209}
1210
1211/* Remap a FILE's name based on the file_name_map, if any, for
1212 FILE->dir. If the file name has any directory separators,
1213 recursively check those directories too. */
1214static char *
1215remap_filename (cpp_reader *pfile, _cpp_file *file)
1216{
1217 const char *fname, *p;
1218 char *new_dir;
1219 cpp_dir *dir;
1220 size_t index, len;
1221
1222 dir = file->dir;
1223 fname = file->name;
1224
1225 for (;;)
1226 {
1227 if (!dir->name_map)
1228 read_name_map (dir);
1229
1230 for (index = 0; dir->name_map[index]; index += 2)
1231 if (!strcmp (dir->name_map[index], fname))
1232 return xstrdup (dir->name_map[index + 1]);
1233
1234 p = strchr (fname, '/');
1235 if (!p || p == fname)
1236 return NULL;
1237
1238 len = dir->len + (p - fname + 1);
1239 new_dir = xmalloc (len + 1);
1240 memcpy (new_dir, dir->name, dir->len);
1241 memcpy (new_dir + dir->len, fname, p - fname + 1);
1242 new_dir[len] = '\0';
1243
1244 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1245 fname = p + 1;
1246 }
1247}
1248
1249/* Return true if FILE is usable by PCH. */
1250static bool
1251include_pch_p (_cpp_file *file)
1252{
1253 return file->pch & 1;
1254}
1255
1256/* Returns true if PCHNAME is a valid PCH file for FILE. */
1257static bool
1258validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1259{
1260 const char *saved_path = file->path;
1261 bool valid = false;
1262
1263 file->path = pchname;
1264 if (open_file (file))
1265 {
1266 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1267
1268 if (!valid)
1269 {
1270 close (file->fd);
1271 file->fd = -1;
1272 }
1273
1274 if (CPP_OPTION (pfile, print_include_names))
1275 {
1276 unsigned int i;
1277 for (i = 1; i < pfile->line_maps.depth; i++)
1278 putc ('.', stderr);
1279 fprintf (stderr, "%c %s\n",
1280 valid ? '!' : 'x', pchname);
1281 }
1282 }
1283
1284 file->path = saved_path;
1285 return valid;
1286}