1/* Part of CPP library. File handling. 2 Copyright (C) 1986-2015 Free Software Foundation, Inc. 3 Written by Per Bothner, 1994. 4 Based on CCCP program by Paul Rubin, June 1986 5 Adapted to ANSI C, Richard Stallman, Jan 1987 6 Split out of cpplib.c, Zack Weinberg, Oct 1998 7 Reimplemented, Neil Booth, Jul 2003 8 9This program is free software; you can redistribute it and/or modify it 10under the terms of the GNU General Public License as published by the 11Free Software Foundation; either version 3, or (at your option) any 12later version. 13 14This program is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. 18 19You should have received a copy of the GNU General Public License 20along with this program; see the file COPYING3. If not see 21<http://www.gnu.org/licenses/>. */ 22 23#include "config.h" 24#include "system.h" 25#include "cpplib.h" 26#include "internal.h" 27#include "mkdeps.h" 28#include "obstack.h" 29#include "hashtab.h" 30#include "md5.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#include <io.h> 44 /* For DJGPP redirected input is opened in text mode. */ 45# define set_stdin_to_binary_mode() \ 46 if (! isatty (0)) setmode (0, O_BINARY) 47#else 48# define set_stdin_to_binary_mode() /* Nothing */ 49#endif 50 51/* This structure represents a file searched for by CPP, whether it 52 exists or not. An instance may be pointed to by more than one 53 cpp_file_hash_entry; at present no reference count is kept. */ 54struct _cpp_file 55{ 56 /* Filename as given to #include or command line switch. */ 57 const char *name; 58 59 /* The full path used to find the file. */ 60 const char *path; 61 62 /* The full path of the pch file. */ 63 const char *pchname; 64 65 /* The file's path with the basename stripped. NULL if it hasn't 66 been calculated yet. */ 67 const char *dir_name; 68 69 /* Chain through all files. */ 70 struct _cpp_file *next_file; 71 72 /* The contents of NAME after calling read_file(). */ 73 const uchar *buffer; 74 75 /* Pointer to the real start of BUFFER. read_file() might increment 76 BUFFER; when freeing, this this pointer must be used instead. */ 77 const uchar *buffer_start; 78 79 /* The macro, if any, preventing re-inclusion. */ 80 const cpp_hashnode *cmacro; 81 82 /* The directory in the search path where FILE was found. Used for 83 #include_next and determining whether a header is a system 84 header. */ 85 cpp_dir *dir; 86 87 /* As filled in by stat(2) for the file. */ 88 struct stat st; 89 90 /* File descriptor. Invalid if -1, otherwise open. */ 91 int fd; 92 93 /* Zero if this file was successfully opened and stat()-ed, 94 otherwise errno obtained from failure. */ 95 int err_no; 96 97 /* Number of times the file has been stacked for preprocessing. */ 98 unsigned short stack_count; 99 100 /* If opened with #import or contains #pragma once. */ 101 bool once_only; 102 103 /* If read() failed before. */ 104 bool dont_read; 105 106 /* If this file is the main file. */ 107 bool main_file; 108 109 /* If BUFFER above contains the true contents of the file. */ 110 bool buffer_valid; 111 112 /* If this file is implicitly preincluded. */ 113 bool implicit_preinclude; 114}; 115 116/* A singly-linked list for all searches for a given file name, with 117 its head pointed to by a slot in FILE_HASH. The file name is what 118 appeared between the quotes in a #include directive; it can be 119 determined implicitly from the hash table location or explicitly 120 from FILE->name. 121 122 FILE is a structure containing details about the file that was 123 found with that search, or details of how the search failed. 124 125 START_DIR is the starting location of the search in the include 126 chain. The current directories for "" includes are also hashed in 127 the hash table and therefore unique. Files that are looked up 128 without using a search path, such as absolute filenames and file 129 names from the command line share a special starting directory so 130 they don't cause cache hits with normal include-chain lookups. 131 132 If START_DIR is NULL then the entry is for a directory, not a file, 133 and the directory is in DIR. Since the starting point in a file 134 lookup chain is never NULL, this means that simple pointer 135 comparisons against START_DIR can be made to determine cache hits 136 in file lookups. 137 138 If a cache lookup fails because of e.g. an extra "./" in the path, 139 then nothing will break. It is just less efficient as CPP will 140 have to do more work re-preprocessing the file, and/or comparing 141 its contents against earlier once-only files. 142*/ 143struct cpp_file_hash_entry 144{ 145 struct cpp_file_hash_entry *next; 146 cpp_dir *start_dir; 147 source_location location; 148 union 149 { 150 _cpp_file *file; 151 cpp_dir *dir; 152 } u; 153}; 154 155/* Number of entries to put in a cpp_file_hash_entry pool. */ 156#define FILE_HASH_POOL_SIZE 127 157 158/* A file hash entry pool. We allocate cpp_file_hash_entry object from 159 one of these. */ 160struct file_hash_entry_pool 161{ 162 /* Number of entries used from this pool. */ 163 unsigned int file_hash_entries_used; 164 /* Next pool in the chain; used when freeing. */ 165 struct file_hash_entry_pool *next; 166 /* The memory pool. */ 167 struct cpp_file_hash_entry pool[FILE_HASH_POOL_SIZE]; 168}; 169 170static bool open_file (_cpp_file *file); 171static bool pch_open_file (cpp_reader *pfile, _cpp_file *file, 172 bool *invalid_pch); 173static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file, 174 bool *invalid_pch); 175static bool read_file_guts (cpp_reader *pfile, _cpp_file *file); 176static bool read_file (cpp_reader *pfile, _cpp_file *file); 177static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import); 178static struct cpp_dir *search_path_head (cpp_reader *, const char *fname, 179 int angle_brackets, enum include_type); 180static const char *dir_name_of_file (_cpp_file *file); 181static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int); 182static struct cpp_file_hash_entry *search_cache (struct cpp_file_hash_entry *head, 183 const cpp_dir *start_dir); 184static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname); 185static void destroy_cpp_file (_cpp_file *); 186static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp); 187static void allocate_file_hash_entries (cpp_reader *pfile); 188static struct cpp_file_hash_entry *new_file_hash_entry (cpp_reader *pfile); 189static int report_missing_guard (void **slot, void *b); 190static hashval_t file_hash_hash (const void *p); 191static int file_hash_eq (const void *p, const void *q); 192static char *read_filename_string (int ch, FILE *f); 193static void read_name_map (cpp_dir *dir); 194static char *remap_filename (cpp_reader *pfile, _cpp_file *file); 195static char *append_file_to_dir (const char *fname, cpp_dir *dir); 196static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname); 197static int pchf_save_compare (const void *e1, const void *e2); 198static int pchf_compare (const void *d_p, const void *e_p); 199static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool); 200 201/* Given a filename in FILE->PATH, with the empty string interpreted 202 as <stdin>, open it. 203 204 On success FILE contains an open file descriptor and stat 205 information for the file. On failure the file descriptor is -1 and 206 the appropriate errno is also stored in FILE. Returns TRUE iff 207 successful. 208 209 We used to open files in nonblocking mode, but that caused more 210 problems than it solved. Do take care not to acquire a controlling 211 terminal by mistake (this can't happen on sane systems, but 212 paranoia is a virtue). 213 214 Use the three-argument form of open even though we aren't 215 specifying O_CREAT, to defend against broken system headers. 216 217 O_BINARY tells some runtime libraries (notably DJGPP) not to do 218 newline translation; we can handle DOS line breaks just fine 219 ourselves. */ 220static bool 221open_file (_cpp_file *file) 222{ 223 if (file->path[0] == '\0') 224 { 225 file->fd = 0; 226 set_stdin_to_binary_mode (); 227 } 228 else 229 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666); 230 231 if (file->fd != -1) 232 { 233 if (fstat (file->fd, &file->st) == 0) 234 { 235 if (!S_ISDIR (file->st.st_mode)) 236 { 237 file->err_no = 0; 238 return true; 239 } 240 241 /* Ignore a directory and continue the search. The file we're 242 looking for may be elsewhere in the search path. */ 243 errno = ENOENT; 244 } 245 246 close (file->fd); 247 file->fd = -1; 248 } 249#if defined(_WIN32) && !defined(__CYGWIN__) 250 else if (errno == EACCES) 251 { 252 /* On most UNIX systems, open succeeds on a directory. Above, 253 we check if we have opened a directory and if so, set errno 254 to ENOENT. However, on Windows, opening a directory 255 fails with EACCES. We want to return ENOENT in that 256 case too. */ 257 if (stat (file->path, &file->st) == 0 258 && S_ISDIR (file->st.st_mode)) 259 errno = ENOENT; 260 else 261 /* The call to stat may have reset errno. */ 262 errno = EACCES; 263 } 264#endif 265 else if (errno == ENOTDIR) 266 errno = ENOENT; 267 268 file->err_no = errno; 269 270 return false; 271} 272 273/* Temporary PCH intercept of opening a file. Try to find a PCH file 274 based on FILE->name and FILE->dir, and test those found for 275 validity using PFILE->cb.valid_pch. Return true iff a valid file is 276 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */ 277 278static bool 279pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch) 280{ 281 static const char extension[] = ".gch"; 282 const char *path = file->path; 283 size_t len, flen; 284 char *pchname; 285 struct stat st; 286 bool valid = false; 287 288 /* No PCH on <stdin> or if not requested. */ 289 if (file->name[0] == '\0' || !pfile->cb.valid_pch) 290 return false; 291 292 /* If the file is not included as first include from either the toplevel 293 file or the command-line it is not a valid use of PCH. */ 294 for (_cpp_file *f = pfile->all_files; f; f = f->next_file) 295 if (f->implicit_preinclude) 296 continue; 297 else if (f->main_file) 298 break; 299 else 300 return false; 301 302 flen = strlen (path); 303 len = flen + sizeof (extension); 304 pchname = XNEWVEC (char, len); 305 memcpy (pchname, path, flen); 306 memcpy (pchname + flen, extension, sizeof (extension)); 307 308 if (stat (pchname, &st) == 0) 309 { 310 DIR *pchdir; 311 struct dirent *d; 312 size_t dlen, plen = len; 313 314 if (!S_ISDIR (st.st_mode)) 315 valid = validate_pch (pfile, file, pchname); 316 else if ((pchdir = opendir (pchname)) != NULL) 317 { 318 pchname[plen - 1] = '/'; 319 while ((d = readdir (pchdir)) != NULL) 320 { 321 dlen = strlen (d->d_name) + 1; 322 if ((strcmp (d->d_name, ".") == 0) 323 || (strcmp (d->d_name, "..") == 0)) 324 continue; 325 if (dlen + plen > len) 326 { 327 len += dlen + 64; 328 pchname = XRESIZEVEC (char, pchname, len); 329 } 330 memcpy (pchname + plen, d->d_name, dlen); 331 valid = validate_pch (pfile, file, pchname); 332 if (valid) 333 break; 334 } 335 closedir (pchdir); 336 } 337 if (!valid) 338 *invalid_pch = true; 339 } 340 341 if (valid) 342 file->pchname = pchname; 343 else 344 free (pchname); 345 346 return valid; 347} 348 349/* Canonicalize the path to FILE. Return the canonical form if it is 350 shorter, otherwise return NULL. This function does NOT free the 351 memory pointed by FILE. */ 352 353static char * 354maybe_shorter_path (const char * file) 355{ 356 char * file2 = lrealpath (file); 357 if (file2 && strlen (file2) < strlen (file)) 358 { 359 return file2; 360 } 361 else 362 { 363 free (file2); 364 return NULL; 365 } 366} 367 368/* Try to open the path FILE->name appended to FILE->dir. This is 369 where remap and PCH intercept the file lookup process. Return true 370 if the file was found, whether or not the open was successful. 371 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */ 372 373static bool 374find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch) 375{ 376 char *path; 377 378 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file))) 379 ; 380 else 381 if (file->dir->construct) 382 path = file->dir->construct (file->name, file->dir); 383 else 384 path = append_file_to_dir (file->name, file->dir); 385 386 if (path) 387 { 388 hashval_t hv; 389 char *copy; 390 void **pp; 391 392 /* We try to canonicalize system headers. For DOS based file 393 * system, we always try to shorten non-system headers, as DOS 394 * has a tighter constraint on max path length. */ 395 if ((CPP_OPTION (pfile, canonical_system_headers) && file->dir->sysp) 396#ifdef HAVE_DOS_BASED_FILE_SYSTEM 397 || !file->dir->sysp 398#endif 399 ) 400 { 401 char * canonical_path = maybe_shorter_path (path); 402 if (canonical_path) 403 { 404 /* The canonical path was newly allocated. Let's free the 405 non-canonical one. */ 406 free (path); 407 path = canonical_path; 408 } 409 } 410 411 hv = htab_hash_string (path); 412 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL) 413 { 414 file->err_no = ENOENT; 415 return false; 416 } 417 418 file->path = path; 419 if (pch_open_file (pfile, file, invalid_pch)) 420 return true; 421 422 if (open_file (file)) 423 return true; 424 425 if (file->err_no != ENOENT) 426 { 427 open_file_failed (pfile, file, 0); 428 return true; 429 } 430 431 /* We copy the path name onto an obstack partly so that we don't 432 leak the memory, but mostly so that we don't fragment the 433 heap. */ 434 copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path, 435 strlen (path)); 436 free (path); 437 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash, 438 copy, hv, INSERT); 439 *pp = copy; 440 441 file->path = file->name; 442 } 443 else 444 { 445 file->err_no = ENOENT; 446 file->path = NULL; 447 } 448 449 return false; 450} 451 452/* Return tue iff the missing_header callback found the given HEADER. */ 453static bool 454search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file) 455{ 456 missing_header_cb func = pfile->cb.missing_header; 457 458 /* When the regular search path doesn't work, try context dependent 459 headers search paths. */ 460 if (func 461 && file->dir == NULL) 462 { 463 if ((file->path = func (pfile, header, &file->dir)) != NULL) 464 { 465 if (open_file (file)) 466 return true; 467 free ((void *)file->path); 468 } 469 file->path = file->name; 470 } 471 472 return false; 473} 474 475bool 476_cpp_find_failed (_cpp_file *file) 477{ 478 return file->err_no != 0; 479} 480 481/* Given a filename FNAME search for such a file in the include path 482 starting from START_DIR. If FNAME is the empty string it is 483 interpreted as STDIN if START_DIR is PFILE->no_search_path. 484 485 If the file is not found in the file cache fall back to the O/S and 486 add the result to our cache. 487 488 If the file was not found in the filesystem, or there was an error 489 opening it, then ERR_NO is nonzero and FD is -1. If the file was 490 found, then ERR_NO is zero and FD could be -1 or an open file 491 descriptor. FD can be -1 if the file was found in the cache and 492 had previously been closed. To open it again pass the return value 493 to open_file(). 494 495 If IMPLICIT_PREINCLUDE then it is OK for the file to be missing. 496 If present, it is OK for a precompiled header to be included after 497 it. 498*/ 499_cpp_file * 500_cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, 501 bool fake, int angle_brackets, bool implicit_preinclude) 502{ 503 struct cpp_file_hash_entry *entry; 504 void **hash_slot; 505 _cpp_file *file; 506 bool invalid_pch = false; 507 bool saw_bracket_include = false; 508 bool saw_quote_include = false; 509 struct cpp_dir *found_in_cache = NULL; 510 511 /* Ensure we get no confusion between cached files and directories. */ 512 if (start_dir == NULL) 513 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file"); 514 515 hash_slot 516 = htab_find_slot_with_hash (pfile->file_hash, fname, 517 htab_hash_string (fname), INSERT); 518 519 /* First check the cache before we resort to memory allocation. */ 520 entry = search_cache ((struct cpp_file_hash_entry *) *hash_slot, start_dir); 521 if (entry) 522 return entry->u.file; 523 524 file = make_cpp_file (pfile, start_dir, fname); 525 file->implicit_preinclude 526 = (implicit_preinclude 527 || (pfile->buffer 528 && pfile->buffer->file->implicit_preinclude)); 529 530 /* Try each path in the include chain. */ 531 for (; !fake ;) 532 { 533 if (find_file_in_dir (pfile, file, &invalid_pch)) 534 break; 535 536 file->dir = file->dir->next; 537 if (file->dir == NULL) 538 { 539 if (search_path_exhausted (pfile, fname, file)) 540 { 541 /* Although this file must not go in the cache, because 542 the file found might depend on things (like the current file) 543 that aren't represented in the cache, it still has to go in 544 the list of all files so that #import works. */ 545 file->next_file = pfile->all_files; 546 pfile->all_files = file; 547 if (*hash_slot == NULL) 548 { 549 /* If *hash_slot is NULL, the above htab_find_slot_with_hash 550 call just created the slot, but we aren't going to store 551 there anything, so need to remove the newly created entry. 552 htab_clear_slot requires that it is non-NULL, so store 553 there some non-NULL pointer, htab_clear_slot will 554 overwrite it immediately. */ 555 *hash_slot = file; 556 htab_clear_slot (pfile->file_hash, hash_slot); 557 } 558 return file; 559 } 560 561 if (invalid_pch) 562 { 563 cpp_error (pfile, CPP_DL_ERROR, 564 "one or more PCH files were found, but they were invalid"); 565 if (!cpp_get_options (pfile)->warn_invalid_pch) 566 cpp_error (pfile, CPP_DL_ERROR, 567 "use -Winvalid-pch for more information"); 568 } 569 if (implicit_preinclude) 570 { 571 free ((char *) file->name); 572 free (file); 573 if (*hash_slot == NULL) 574 { 575 /* See comment on the above htab_clear_slot call. */ 576 *hash_slot = file; 577 htab_clear_slot (pfile->file_hash, hash_slot); 578 } 579 return NULL; 580 } 581 else 582 open_file_failed (pfile, file, angle_brackets); 583 break; 584 } 585 586 /* Only check the cache for the starting location (done above) 587 and the quote and bracket chain heads because there are no 588 other possible starting points for searches. */ 589 if (file->dir == pfile->bracket_include) 590 saw_bracket_include = true; 591 else if (file->dir == pfile->quote_include) 592 saw_quote_include = true; 593 else 594 continue; 595 596 entry = search_cache ((struct cpp_file_hash_entry *) *hash_slot, file->dir); 597 if (entry) 598 { 599 found_in_cache = file->dir; 600 break; 601 } 602 } 603 604 if (entry) 605 { 606 /* Cache for START_DIR too, sharing the _cpp_file structure. */ 607 free ((char *) file->name); 608 free (file); 609 file = entry->u.file; 610 } 611 else 612 { 613 /* This is a new file; put it in the list. */ 614 file->next_file = pfile->all_files; 615 pfile->all_files = file; 616 } 617 618 /* Store this new result in the hash table. */ 619 entry = new_file_hash_entry (pfile); 620 entry->next = (struct cpp_file_hash_entry *) *hash_slot; 621 entry->start_dir = start_dir; 622 entry->location = pfile->line_table->highest_location; 623 entry->u.file = file; 624 *hash_slot = (void *) entry; 625 626 /* If we passed the quote or bracket chain heads, cache them also. 627 This speeds up processing if there are lots of -I options. */ 628 if (saw_bracket_include 629 && pfile->bracket_include != start_dir 630 && found_in_cache != pfile->bracket_include) 631 { 632 entry = new_file_hash_entry (pfile); 633 entry->next = (struct cpp_file_hash_entry *) *hash_slot; 634 entry->start_dir = pfile->bracket_include; 635 entry->location = pfile->line_table->highest_location; 636 entry->u.file = file; 637 *hash_slot = (void *) entry; 638 } 639 if (saw_quote_include 640 && pfile->quote_include != start_dir 641 && found_in_cache != pfile->quote_include) 642 { 643 entry = new_file_hash_entry (pfile); 644 entry->next = (struct cpp_file_hash_entry *) *hash_slot; 645 entry->start_dir = pfile->quote_include; 646 entry->location = pfile->line_table->highest_location; 647 entry->u.file = file; 648 *hash_slot = (void *) entry; 649 } 650 651 return file; 652} 653 654/* Read a file into FILE->buffer, returning true on success. 655 656 If FILE->fd is something weird, like a block device, we don't want 657 to read it at all. Don't even try to figure out what something is, 658 except for plain files and block devices, since there is no 659 reliable portable way of doing this. 660 661 FIXME: Flush file cache and try again if we run out of memory. */ 662static bool 663read_file_guts (cpp_reader *pfile, _cpp_file *file) 664{ 665 ssize_t size, total, count; 666 uchar *buf; 667 bool regular; 668 669 if (S_ISBLK (file->st.st_mode)) 670 { 671 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path); 672 return false; 673 } 674 675 regular = S_ISREG (file->st.st_mode) != 0; 676 if (regular) 677 { 678 /* off_t might have a wider range than ssize_t - in other words, 679 the max size of a file might be bigger than the address 680 space. We can't handle a file that large. (Anyone with 681 a single source file bigger than 2GB needs to rethink 682 their coding style.) Some systems (e.g. AIX 4.1) define 683 SSIZE_MAX to be much smaller than the actual range of the 684 type. Use INTTYPE_MAXIMUM unconditionally to ensure this 685 does not bite us. */ 686 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t)) 687 { 688 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path); 689 return false; 690 } 691 692 size = file->st.st_size; 693 } 694 else 695 /* 8 kilobytes is a sensible starting size. It ought to be bigger 696 than the kernel pipe buffer, and it's definitely bigger than 697 the majority of C source files. */ 698 size = 8 * 1024; 699 700 /* The + 16 here is space for the final '\n' and 15 bytes of padding, 701 used to quiet warnings from valgrind or Address Sanitizer, when the 702 optimized lexer accesses aligned 16-byte memory chunks, including 703 the bytes after the malloced, area, and stops lexing on '\n'. */ 704 buf = XNEWVEC (uchar, size + 16); 705 total = 0; 706 while ((count = read (file->fd, buf + total, size - total)) > 0) 707 { 708 total += count; 709 710 if (total == size) 711 { 712 if (regular) 713 break; 714 size *= 2; 715 buf = XRESIZEVEC (uchar, buf, size + 16); 716 } 717 } 718 719 if (count < 0) 720 { 721 cpp_errno_filename (pfile, CPP_DL_ERROR, file->path); 722 free (buf); 723 return false; 724 } 725 726 if (regular && total != size && STAT_SIZE_RELIABLE (file->st)) 727 cpp_error (pfile, CPP_DL_WARNING, 728 "%s is shorter than expected", file->path); 729 730 file->buffer = _cpp_convert_input (pfile, 731 CPP_OPTION (pfile, input_charset), 732 buf, size + 16, total, 733 &file->buffer_start, 734 &file->st.st_size); 735 file->buffer_valid = true; 736 737 return true; 738} 739 740/* Convenience wrapper around read_file_guts that opens the file if 741 necessary and closes the file descriptor after reading. FILE must 742 have been passed through find_file() at some stage. */ 743static bool 744read_file (cpp_reader *pfile, _cpp_file *file) 745{ 746 /* If we already have its contents in memory, succeed immediately. */ 747 if (file->buffer_valid) 748 return true; 749 750 /* If an earlier read failed for some reason don't try again. */ 751 if (file->dont_read || file->err_no) 752 return false; 753 754 if (file->fd == -1 && !open_file (file)) 755 { 756 open_file_failed (pfile, file, 0); 757 return false; 758 } 759 760 file->dont_read = !read_file_guts (pfile, file); 761 close (file->fd); 762 file->fd = -1; 763 764 return !file->dont_read; 765} 766 767/* Returns TRUE if FILE's contents have been successfully placed in 768 FILE->buffer and the file should be stacked, otherwise false. */ 769static bool 770should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import) 771{ 772 _cpp_file *f; 773 774 /* Skip once-only files. */ 775 if (file->once_only) 776 return false; 777 778 /* We must mark the file once-only if #import now, before header 779 guard checks. Otherwise, undefining the header guard might 780 cause the file to be re-stacked. */ 781 if (import) 782 { 783 _cpp_mark_file_once_only (pfile, file); 784 785 /* Don't stack files that have been stacked before. */ 786 if (file->stack_count) 787 return false; 788 } 789 790 /* Skip if the file had a header guard and the macro is defined. 791 PCH relies on this appearing before the PCH handler below. */ 792 if (file->cmacro && file->cmacro->type == NT_MACRO) 793 return false; 794 795 /* Handle PCH files immediately; don't stack them. */ 796 if (file->pchname) 797 { 798 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path); 799 file->fd = -1; 800 free ((void *) file->pchname); 801 file->pchname = NULL; 802 return false; 803 } 804 805 if (!read_file (pfile, file)) 806 return false; 807 808 /* Check the file against the PCH file. This is done before 809 checking against files we've already seen, since it may save on 810 I/O. */ 811 if (check_file_against_entries (pfile, file, import)) 812 { 813 /* If this isn't a #import, but yet we can't include the file, 814 that means that it was #import-ed in the PCH file, 815 so we can never include it again. */ 816 if (! import) 817 _cpp_mark_file_once_only (pfile, file); 818 return false; 819 } 820 821 /* Now we've read the file's contents, we can stack it if there 822 are no once-only files. */ 823 if (!pfile->seen_once_only) 824 return true; 825 826 /* We may have read the file under a different name. Look 827 for likely candidates and compare file contents to be sure. */ 828 for (f = pfile->all_files; f; f = f->next_file) 829 { 830 if (f == file) 831 continue; 832 833 if ((import || f->once_only) 834 && f->err_no == 0 835 && f->st.st_mtime == file->st.st_mtime 836 && f->st.st_size == file->st.st_size) 837 { 838 _cpp_file *ref_file; 839 bool same_file_p = false; 840 841 if (f->buffer && !f->buffer_valid) 842 { 843 /* We already have a buffer but it is not valid, because 844 the file is still stacked. Make a new one. */ 845 ref_file = make_cpp_file (pfile, f->dir, f->name); 846 ref_file->path = f->path; 847 } 848 else 849 /* The file is not stacked anymore. We can reuse it. */ 850 ref_file = f; 851 852 same_file_p = read_file (pfile, ref_file) 853 /* Size might have changed in read_file(). */ 854 && ref_file->st.st_size == file->st.st_size 855 && !memcmp (ref_file->buffer, 856 file->buffer, 857 file->st.st_size); 858 859 if (f->buffer && !f->buffer_valid) 860 { 861 ref_file->path = 0; 862 destroy_cpp_file (ref_file); 863 } 864 865 if (same_file_p) 866 break; 867 } 868 } 869 870 return f == NULL; 871} 872 873/* Place the file referenced by FILE into a new buffer on the buffer 874 stack if possible. IMPORT is true if this stacking attempt is 875 because of a #import directive. Returns true if a buffer is 876 stacked. */ 877bool 878_cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import) 879{ 880 cpp_buffer *buffer; 881 int sysp; 882 883 if (!should_stack_file (pfile, file, import)) 884 return false; 885 886 if (pfile->buffer == NULL || file->dir == NULL) 887 sysp = 0; 888 else 889 sysp = MAX (pfile->buffer->sysp, file->dir->sysp); 890 891 /* Add the file to the dependencies on its first inclusion. */ 892 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count) 893 { 894 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file)) 895 deps_add_dep (pfile->deps, file->path); 896 } 897 898 /* Clear buffer_valid since _cpp_clean_line messes it up. */ 899 file->buffer_valid = false; 900 file->stack_count++; 901 902 /* Stack the buffer. */ 903 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size, 904 CPP_OPTION (pfile, preprocessed) 905 && !CPP_OPTION (pfile, directives_only)); 906 buffer->file = file; 907 buffer->sysp = sysp; 908 buffer->to_free = file->buffer_start; 909 910 /* Initialize controlling macro state. */ 911 pfile->mi_valid = true; 912 pfile->mi_cmacro = 0; 913 914 /* Generate the call back. */ 915 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp); 916 917 return true; 918} 919 920/* Mark FILE to be included once only. */ 921void 922_cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file) 923{ 924 pfile->seen_once_only = true; 925 file->once_only = true; 926} 927 928/* Return the directory from which searching for FNAME should start, 929 considering the directive TYPE and ANGLE_BRACKETS. If there is 930 nothing left in the path, returns NULL. */ 931static struct cpp_dir * 932search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets, 933 enum include_type type) 934{ 935 cpp_dir *dir; 936 _cpp_file *file; 937 938 if (IS_ABSOLUTE_PATH (fname)) 939 return &pfile->no_search_path; 940 941 /* pfile->buffer is NULL when processing an -include command-line flag. */ 942 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file; 943 944 /* For #include_next, skip in the search path past the dir in which 945 the current file was found, but if it was found via an absolute 946 path use the normal search logic. */ 947 if (type == IT_INCLUDE_NEXT && file->dir 948 && file->dir != &pfile->no_search_path) 949 dir = file->dir->next; 950 else if (angle_brackets) 951 dir = pfile->bracket_include; 952 else if (type == IT_CMDLINE) 953 /* -include and -imacros use the #include "" chain with the 954 preprocessor's cwd prepended. */ 955 return make_cpp_dir (pfile, "./", false); 956 else if (pfile->quote_ignores_source_dir) 957 dir = pfile->quote_include; 958 else 959 return make_cpp_dir (pfile, dir_name_of_file (file), 960 pfile->buffer ? pfile->buffer->sysp : 0); 961 962 if (dir == NULL) 963 cpp_error (pfile, CPP_DL_ERROR, 964 "no include path in which to search for %s", fname); 965 966 return dir; 967} 968 969/* Strip the basename from the file's path. It ends with a slash if 970 of nonzero length. Note that this procedure also works for 971 <stdin>, which is represented by the empty string. */ 972static const char * 973dir_name_of_file (_cpp_file *file) 974{ 975 if (!file->dir_name) 976 { 977 size_t len = lbasename (file->path) - file->path; 978 char *dir_name = XNEWVEC (char, len + 1); 979 980 memcpy (dir_name, file->path, len); 981 dir_name[len] = '\0'; 982 file->dir_name = dir_name; 983 } 984 985 return file->dir_name; 986} 987 988/* Handles #include-family directives (distinguished by TYPE), 989 including HEADER, and the command line -imacros and -include. 990 Returns true if a buffer was stacked. */ 991bool 992_cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets, 993 enum include_type type) 994{ 995 struct cpp_dir *dir; 996 _cpp_file *file; 997 bool stacked; 998 999 /* For -include command-line flags we have type == IT_CMDLINE. 1000 When the first -include file is processed we have the case, where 1001 pfile->cur_token == pfile->cur_run->base, we are directly called up 1002 by the front end. However in the case of the second -include file, 1003 we are called from _cpp_lex_token -> _cpp_get_fresh_line -> 1004 cpp_push_include, with pfile->cur_token != pfile->cur_run->base, 1005 and pfile->cur_token[-1].src_loc not (yet) initialized. 1006 However, when the include file cannot be found, we need src_loc to 1007 be initialized to some safe value: 0 means UNKNOWN_LOCATION. */ 1008 if (type == IT_CMDLINE && pfile->cur_token != pfile->cur_run->base) 1009 pfile->cur_token[-1].src_loc = 0; 1010 1011 dir = search_path_head (pfile, fname, angle_brackets, type); 1012 if (!dir) 1013 return false; 1014 1015 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets, 1016 type == IT_DEFAULT); 1017 if (type == IT_DEFAULT && file == NULL) 1018 return false; 1019 1020 /* Compensate for the increment in linemap_add that occurs if 1021 _cpp_stack_file actually stacks the file. In the case of a 1022 normal #include, we're currently at the start of the line 1023 *following* the #include. A separate source_location for this 1024 location makes no sense (until we do the LC_LEAVE), and 1025 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we 1026 found a PCH file (in which case linemap_add is not called) or we 1027 were included from the command-line. */ 1028 if (file->pchname == NULL && file->err_no == 0 1029 && type != IT_CMDLINE && type != IT_DEFAULT) 1030 pfile->line_table->highest_location--; 1031 1032 stacked = _cpp_stack_file (pfile, file, type == IT_IMPORT); 1033 1034 if (!stacked) 1035 /* _cpp_stack_file didn't stack the file, so let's rollback the 1036 compensation dance we performed above. */ 1037 pfile->line_table->highest_location++; 1038 1039 return stacked; 1040} 1041 1042/* Could not open FILE. The complication is dependency output. */ 1043static void 1044open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets) 1045{ 1046 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0; 1047 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp); 1048 1049 if (pfile->state.in__has_include__) 1050 return; 1051 1052 errno = file->err_no; 1053 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT) 1054 { 1055 deps_add_dep (pfile->deps, file->name); 1056 /* If the preprocessor output (other than dependency information) is 1057 being used, we must also flag an error. */ 1058 if (CPP_OPTION (pfile, deps.need_preprocessor_output)) 1059 cpp_errno_filename (pfile, CPP_DL_FATAL, 1060 file->path ? file->path : file->name); 1061 } 1062 else 1063 { 1064 /* If we are not outputting dependencies, or if we are and dependencies 1065 were requested for this file, or if preprocessor output is needed 1066 in addition to dependency information, this is an error. 1067 1068 Otherwise (outputting dependencies but not for this file, and not 1069 using the preprocessor output), we can still produce correct output 1070 so it's only a warning. */ 1071 if (CPP_OPTION (pfile, deps.style) == DEPS_NONE 1072 || print_dep 1073 || CPP_OPTION (pfile, deps.need_preprocessor_output)) 1074 cpp_errno_filename (pfile, CPP_DL_FATAL, 1075 file->path ? file->path : file->name); 1076 else 1077 cpp_errno_filename (pfile, CPP_DL_WARNING, 1078 file->path ? file->path : file->name); 1079 } 1080} 1081 1082/* Search in the chain beginning at HEAD for a file whose search path 1083 started at START_DIR != NULL. */ 1084static struct cpp_file_hash_entry * 1085search_cache (struct cpp_file_hash_entry *head, const cpp_dir *start_dir) 1086{ 1087 while (head && head->start_dir != start_dir) 1088 head = head->next; 1089 1090 return head; 1091} 1092 1093/* Allocate a new _cpp_file structure. */ 1094static _cpp_file * 1095make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname) 1096{ 1097 _cpp_file *file; 1098 1099 file = XCNEW (_cpp_file); 1100 file->main_file = !pfile->buffer; 1101 file->fd = -1; 1102 file->dir = dir; 1103 file->name = xstrdup (fname); 1104 1105 return file; 1106} 1107 1108/* Release a _cpp_file structure. */ 1109static void 1110destroy_cpp_file (_cpp_file *file) 1111{ 1112 free ((void *) file->buffer_start); 1113 free ((void *) file->name); 1114 free (file); 1115} 1116 1117/* Release all the files allocated by this reader. */ 1118static void 1119destroy_all_cpp_files (cpp_reader *pfile) 1120{ 1121 _cpp_file *iter = pfile->all_files; 1122 while (iter) 1123 { 1124 _cpp_file *next = iter->next_file; 1125 destroy_cpp_file (iter); 1126 iter = next; 1127 } 1128} 1129 1130/* A hash of directory names. The directory names are the path names 1131 of files which contain a #include "", the included file name is 1132 appended to this directories. 1133 1134 To avoid duplicate entries we follow the convention that all 1135 non-empty directory names should end in a '/'. DIR_NAME must be 1136 stored in permanently allocated memory. */ 1137static cpp_dir * 1138make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp) 1139{ 1140 struct cpp_file_hash_entry *entry, **hash_slot; 1141 cpp_dir *dir; 1142 1143 hash_slot = (struct cpp_file_hash_entry **) 1144 htab_find_slot_with_hash (pfile->dir_hash, dir_name, 1145 htab_hash_string (dir_name), 1146 INSERT); 1147 1148 /* Have we already hashed this directory? */ 1149 for (entry = *hash_slot; entry; entry = entry->next) 1150 if (entry->start_dir == NULL) 1151 return entry->u.dir; 1152 1153 dir = XCNEW (cpp_dir); 1154 dir->next = pfile->quote_include; 1155 dir->name = (char *) dir_name; 1156 dir->len = strlen (dir_name); 1157 dir->sysp = sysp; 1158 dir->construct = 0; 1159 1160 /* Store this new result in the hash table. */ 1161 entry = new_file_hash_entry (pfile); 1162 entry->next = *hash_slot; 1163 entry->start_dir = NULL; 1164 entry->location = pfile->line_table->highest_location; 1165 entry->u.dir = dir; 1166 *hash_slot = entry; 1167 1168 return dir; 1169} 1170 1171/* Create a new block of memory for file hash entries. */ 1172static void 1173allocate_file_hash_entries (cpp_reader *pfile) 1174{ 1175 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool); 1176 pool->file_hash_entries_used = 0; 1177 pool->next = pfile->file_hash_entries; 1178 pfile->file_hash_entries = pool; 1179} 1180 1181/* Return a new file hash entry. */ 1182static struct cpp_file_hash_entry * 1183new_file_hash_entry (cpp_reader *pfile) 1184{ 1185 unsigned int idx; 1186 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE) 1187 allocate_file_hash_entries (pfile); 1188 1189 idx = pfile->file_hash_entries->file_hash_entries_used++; 1190 return &pfile->file_hash_entries->pool[idx]; 1191} 1192 1193/* Free the file hash entry pools. */ 1194static void 1195free_file_hash_entries (cpp_reader *pfile) 1196{ 1197 struct file_hash_entry_pool *iter = pfile->file_hash_entries; 1198 while (iter) 1199 { 1200 struct file_hash_entry_pool *next = iter->next; 1201 free (iter); 1202 iter = next; 1203 } 1204} 1205 1206/* Returns TRUE if a file FNAME has ever been successfully opened. 1207 This routine is not intended to correctly handle filenames aliased 1208 by links or redundant . or .. traversals etc. */ 1209bool 1210cpp_included (cpp_reader *pfile, const char *fname) 1211{ 1212 struct cpp_file_hash_entry *entry; 1213 1214 entry = (struct cpp_file_hash_entry *) 1215 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname)); 1216 1217 while (entry && (entry->start_dir == NULL || entry->u.file->err_no)) 1218 entry = entry->next; 1219 1220 return entry != NULL; 1221} 1222 1223/* Returns TRUE if a file FNAME has ever been successfully opened 1224 before LOCATION. This routine is not intended to correctly handle 1225 filenames aliased by links or redundant . or .. traversals etc. */ 1226bool 1227cpp_included_before (cpp_reader *pfile, const char *fname, 1228 source_location location) 1229{ 1230 struct cpp_file_hash_entry *entry; 1231 1232 entry = (struct cpp_file_hash_entry *) 1233 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname)); 1234 1235 while (entry && (entry->start_dir == NULL || entry->u.file->err_no 1236 || entry->location > location)) 1237 entry = entry->next; 1238 1239 return entry != NULL; 1240} 1241 1242/* Calculate the hash value of a file hash entry P. */ 1243 1244static hashval_t 1245file_hash_hash (const void *p) 1246{ 1247 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p; 1248 const char *hname; 1249 if (entry->start_dir) 1250 hname = entry->u.file->name; 1251 else 1252 hname = entry->u.dir->name; 1253 1254 return htab_hash_string (hname); 1255} 1256 1257/* Compare a string Q against a file hash entry P. */ 1258static int 1259file_hash_eq (const void *p, const void *q) 1260{ 1261 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p; 1262 const char *fname = (const char *) q; 1263 const char *hname; 1264 1265 if (entry->start_dir) 1266 hname = entry->u.file->name; 1267 else 1268 hname = entry->u.dir->name; 1269 1270 return filename_cmp (hname, fname) == 0; 1271} 1272 1273/* Compare entries in the nonexistent file hash table. These are just 1274 strings. */ 1275static int 1276nonexistent_file_hash_eq (const void *p, const void *q) 1277{ 1278 return filename_cmp ((const char *) p, (const char *) q) == 0; 1279} 1280 1281/* Initialize everything in this source file. */ 1282void 1283_cpp_init_files (cpp_reader *pfile) 1284{ 1285 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq, 1286 NULL, xcalloc, free); 1287 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq, 1288 NULL, xcalloc, free); 1289 allocate_file_hash_entries (pfile); 1290 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string, 1291 nonexistent_file_hash_eq, 1292 NULL, xcalloc, free); 1293 obstack_specify_allocation (&pfile->nonexistent_file_ob, 0, 0, 1294 xmalloc, free); 1295} 1296 1297/* Finalize everything in this source file. */ 1298void 1299_cpp_cleanup_files (cpp_reader *pfile) 1300{ 1301 htab_delete (pfile->file_hash); 1302 htab_delete (pfile->dir_hash); 1303 htab_delete (pfile->nonexistent_file_hash); 1304 obstack_free (&pfile->nonexistent_file_ob, 0); 1305 free_file_hash_entries (pfile); 1306 destroy_all_cpp_files (pfile); 1307} 1308 1309/* Make the parser forget about files it has seen. This can be useful 1310 for resetting the parser to start another run. */ 1311void 1312cpp_clear_file_cache (cpp_reader *pfile) 1313{ 1314 _cpp_cleanup_files (pfile); 1315 pfile->file_hash_entries = NULL; 1316 pfile->all_files = NULL; 1317 _cpp_init_files (pfile); 1318} 1319 1320/* Enter a file name in the hash for the sake of cpp_included. */ 1321void 1322_cpp_fake_include (cpp_reader *pfile, const char *fname) 1323{ 1324 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0, false); 1325} 1326 1327/* Not everyone who wants to set system-header-ness on a buffer can 1328 see the details of a buffer. This is an exported interface because 1329 fix-header needs it. */ 1330void 1331cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc) 1332{ 1333 int flags = 0; 1334 const struct line_maps *line_table = pfile->line_table; 1335 const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table); 1336 /* 1 = system header, 2 = system header to be treated as C. */ 1337 if (syshdr) 1338 flags = 1 + (externc != 0); 1339 pfile->buffer->sysp = flags; 1340 _cpp_do_file_change (pfile, LC_RENAME, ORDINARY_MAP_FILE_NAME (map), 1341 SOURCE_LINE (map, pfile->line_table->highest_line), flags); 1342} 1343 1344/* Allow the client to change the current file. Used by the front end 1345 to achieve pseudo-file names like <built-in>. 1346 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */ 1347void 1348cpp_change_file (cpp_reader *pfile, enum lc_reason reason, 1349 const char *new_name) 1350{ 1351 _cpp_do_file_change (pfile, reason, new_name, 1, 0); 1352} 1353 1354struct report_missing_guard_data 1355{ 1356 const char **paths; 1357 size_t count; 1358}; 1359 1360/* Callback function for htab_traverse. */ 1361static int 1362report_missing_guard (void **slot, void *d) 1363{ 1364 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) *slot; 1365 struct report_missing_guard_data *data 1366 = (struct report_missing_guard_data *) d; 1367 1368 /* Skip directories. */ 1369 if (entry->start_dir != NULL) 1370 { 1371 _cpp_file *file = entry->u.file; 1372 1373 /* We don't want MI guard advice for the main file. */ 1374 if (!file->once_only && file->cmacro == NULL 1375 && file->stack_count == 1 && !file->main_file) 1376 { 1377 if (data->paths == NULL) 1378 { 1379 data->paths = XCNEWVEC (const char *, data->count); 1380 data->count = 0; 1381 } 1382 1383 data->paths[data->count++] = file->path; 1384 } 1385 } 1386 1387 /* Keep traversing the hash table. */ 1388 return 1; 1389} 1390 1391/* Comparison function for qsort. */ 1392static int 1393report_missing_guard_cmp (const void *p1, const void *p2) 1394{ 1395 return strcmp (*(const char *const *) p1, *(const char *const *) p2); 1396} 1397 1398/* Report on all files that might benefit from a multiple include guard. 1399 Triggered by -H. */ 1400void 1401_cpp_report_missing_guards (cpp_reader *pfile) 1402{ 1403 struct report_missing_guard_data data; 1404 1405 data.paths = NULL; 1406 data.count = htab_elements (pfile->file_hash); 1407 htab_traverse (pfile->file_hash, report_missing_guard, &data); 1408 1409 if (data.paths != NULL) 1410 { 1411 size_t i; 1412 1413 /* Sort the paths to avoid outputting them in hash table 1414 order. */ 1415 qsort (data.paths, data.count, sizeof (const char *), 1416 report_missing_guard_cmp); 1417 fputs (_("Multiple include guards may be useful for:\n"), 1418 stderr); 1419 for (i = 0; i < data.count; i++) 1420 { 1421 fputs (data.paths[i], stderr); 1422 putc ('\n', stderr); 1423 } 1424 free (data.paths); 1425 } 1426} 1427 1428/* Locate HEADER, and determine whether it is newer than the current 1429 file. If it cannot be located or dated, return -1, if it is 1430 newer, return 1, otherwise 0. */ 1431int 1432_cpp_compare_file_date (cpp_reader *pfile, const char *fname, 1433 int angle_brackets) 1434{ 1435 _cpp_file *file; 1436 struct cpp_dir *dir; 1437 1438 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE); 1439 if (!dir) 1440 return -1; 1441 1442 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets, false); 1443 if (file->err_no) 1444 return -1; 1445 1446 if (file->fd != -1) 1447 { 1448 close (file->fd); 1449 file->fd = -1; 1450 } 1451 1452 return file->st.st_mtime > pfile->buffer->file->st.st_mtime; 1453} 1454 1455/* Pushes the given file onto the buffer stack. Returns nonzero if 1456 successful. */ 1457bool 1458cpp_push_include (cpp_reader *pfile, const char *fname) 1459{ 1460 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE); 1461} 1462 1463/* Pushes the given file, implicitly included at the start of a 1464 compilation, onto the buffer stack but without any errors if the 1465 file is not found. Returns nonzero if successful. */ 1466bool 1467cpp_push_default_include (cpp_reader *pfile, const char *fname) 1468{ 1469 return _cpp_stack_include (pfile, fname, true, IT_DEFAULT); 1470} 1471 1472/* Do appropriate cleanup when a file INC's buffer is popped off the 1473 input stack. */ 1474void 1475_cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file, 1476 const unsigned char *to_free) 1477{ 1478 /* Record the inclusion-preventing macro, which could be NULL 1479 meaning no controlling macro. */ 1480 if (pfile->mi_valid && file->cmacro == NULL) 1481 file->cmacro = pfile->mi_cmacro; 1482 1483 /* Invalidate control macros in the #including file. */ 1484 pfile->mi_valid = false; 1485 1486 if (to_free) 1487 { 1488 if (to_free == file->buffer_start) 1489 { 1490 file->buffer_start = NULL; 1491 file->buffer = NULL; 1492 file->buffer_valid = false; 1493 } 1494 free ((void *) to_free); 1495 } 1496} 1497 1498/* Return the file name associated with FILE. */ 1499const char * 1500_cpp_get_file_name (_cpp_file *file) 1501{ 1502 return file->name; 1503} 1504 1505/* Inteface to file statistics record in _cpp_file structure. */ 1506struct stat * 1507_cpp_get_file_stat (_cpp_file *file) 1508{ 1509 return &file->st; 1510} 1511 1512/* Set the include chain for "" to QUOTE, for <> to BRACKET. If 1513 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the 1514 directory of the including file. 1515 1516 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */ 1517void 1518cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket, 1519 int quote_ignores_source_dir) 1520{ 1521 pfile->quote_include = quote; 1522 pfile->bracket_include = quote; 1523 pfile->quote_ignores_source_dir = quote_ignores_source_dir; 1524 1525 for (; quote; quote = quote->next) 1526 { 1527 quote->name_map = NULL; 1528 quote->len = strlen (quote->name); 1529 if (quote == bracket) 1530 pfile->bracket_include = bracket; 1531 } 1532} 1533 1534/* Append the file name to the directory to create the path, but don't 1535 turn / into // or // into ///; // may be a namespace escape. */ 1536static char * 1537append_file_to_dir (const char *fname, cpp_dir *dir) 1538{ 1539 size_t dlen, flen; 1540 char *path; 1541 1542 dlen = dir->len; 1543 flen = strlen (fname); 1544 path = XNEWVEC (char, dlen + 1 + flen + 1); 1545 memcpy (path, dir->name, dlen); 1546 if (dlen && !IS_DIR_SEPARATOR (path[dlen - 1])) 1547 path[dlen++] = '/'; 1548 memcpy (&path[dlen], fname, flen + 1); 1549 1550 return path; 1551} 1552 1553/* Read a space delimited string of unlimited length from a stdio 1554 file F. */ 1555static char * 1556read_filename_string (int ch, FILE *f) 1557{ 1558 char *alloc, *set; 1559 int len; 1560 1561 len = 20; 1562 set = alloc = XNEWVEC (char, len + 1); 1563 if (! is_space (ch)) 1564 { 1565 *set++ = ch; 1566 while ((ch = getc (f)) != EOF && ! is_space (ch)) 1567 { 1568 if (set - alloc == len) 1569 { 1570 len *= 2; 1571 alloc = XRESIZEVEC (char, alloc, len + 1); 1572 set = alloc + len / 2; 1573 } 1574 *set++ = ch; 1575 } 1576 } 1577 *set = '\0'; 1578 ungetc (ch, f); 1579 return alloc; 1580} 1581 1582/* Read the file name map file for DIR. */ 1583static void 1584read_name_map (cpp_dir *dir) 1585{ 1586 static const char FILE_NAME_MAP_FILE[] = "header.gcc"; 1587 char *name; 1588 FILE *f; 1589 size_t len, count = 0, room = 9; 1590 1591 len = dir->len; 1592 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1); 1593 memcpy (name, dir->name, len); 1594 if (len && !IS_DIR_SEPARATOR (name[len - 1])) 1595 name[len++] = '/'; 1596 strcpy (name + len, FILE_NAME_MAP_FILE); 1597 f = fopen (name, "r"); 1598 1599 dir->name_map = XNEWVEC (const char *, room); 1600 1601 /* Silently return NULL if we cannot open. */ 1602 if (f) 1603 { 1604 int ch; 1605 1606 while ((ch = getc (f)) != EOF) 1607 { 1608 char *to; 1609 1610 if (is_space (ch)) 1611 continue; 1612 1613 if (count + 2 > room) 1614 { 1615 room += 8; 1616 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room); 1617 } 1618 1619 dir->name_map[count] = read_filename_string (ch, f); 1620 while ((ch = getc (f)) != EOF && is_hspace (ch)) 1621 ; 1622 1623 to = read_filename_string (ch, f); 1624 if (IS_ABSOLUTE_PATH (to)) 1625 dir->name_map[count + 1] = to; 1626 else 1627 { 1628 dir->name_map[count + 1] = append_file_to_dir (to, dir); 1629 free (to); 1630 } 1631 1632 count += 2; 1633 while ((ch = getc (f)) != '\n') 1634 if (ch == EOF) 1635 break; 1636 } 1637 1638 fclose (f); 1639 } 1640 1641 /* Terminate the list of maps. */ 1642 dir->name_map[count] = NULL; 1643} 1644 1645/* Remap a FILE's name based on the file_name_map, if any, for 1646 FILE->dir. If the file name has any directory separators, 1647 recursively check those directories too. */ 1648static char * 1649remap_filename (cpp_reader *pfile, _cpp_file *file) 1650{ 1651 const char *fname, *p; 1652 char *new_dir; 1653 cpp_dir *dir; 1654 size_t index, len; 1655 1656 dir = file->dir; 1657 fname = file->name; 1658 1659 for (;;) 1660 { 1661 if (!dir->name_map) 1662 read_name_map (dir); 1663 1664 for (index = 0; dir->name_map[index]; index += 2) 1665 if (!filename_cmp (dir->name_map[index], fname)) 1666 return xstrdup (dir->name_map[index + 1]); 1667 if (IS_ABSOLUTE_PATH (fname)) 1668 return NULL; 1669 p = strchr (fname, '/'); 1670#ifdef HAVE_DOS_BASED_FILE_SYSTEM 1671 { 1672 char *p2 = strchr (fname, '\\'); 1673 if (!p || (p > p2)) 1674 p = p2; 1675 } 1676#endif 1677 if (!p || p == fname) 1678 return NULL; 1679 1680 len = dir->len + (p - fname + 1); 1681 new_dir = XNEWVEC (char, len + 1); 1682 memcpy (new_dir, dir->name, dir->len); 1683 memcpy (new_dir + dir->len, fname, p - fname + 1); 1684 new_dir[len] = '\0'; 1685 1686 dir = make_cpp_dir (pfile, new_dir, dir->sysp); 1687 fname = p + 1; 1688 } 1689} 1690 1691/* Returns true if PCHNAME is a valid PCH file for FILE. */ 1692static bool 1693validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname) 1694{ 1695 const char *saved_path = file->path; 1696 bool valid = false; 1697 1698 file->path = pchname; 1699 if (open_file (file)) 1700 { 1701 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd); 1702 1703 if (!valid) 1704 { 1705 close (file->fd); 1706 file->fd = -1; 1707 } 1708 1709 if (CPP_OPTION (pfile, print_include_names)) 1710 { 1711 unsigned int i; 1712 for (i = 1; i < pfile->line_table->depth; i++) 1713 putc ('.', stderr); 1714 fprintf (stderr, "%c %s\n", 1715 valid ? '!' : 'x', pchname); 1716 } 1717 } 1718 1719 file->path = saved_path; 1720 return valid; 1721} 1722 1723/* Get the path associated with the _cpp_file F. The path includes 1724 the base name from the include directive and the directory it was 1725 found in via the search path. */ 1726 1727const char * 1728cpp_get_path (struct _cpp_file *f) 1729{ 1730 return f->path; 1731} 1732 1733/* Get the directory associated with the _cpp_file F. */ 1734 1735cpp_dir * 1736cpp_get_dir (struct _cpp_file *f) 1737{ 1738 return f->dir; 1739} 1740 1741/* Get the cpp_buffer currently associated with the cpp_reader 1742 PFILE. */ 1743 1744cpp_buffer * 1745cpp_get_buffer (cpp_reader *pfile) 1746{ 1747 return pfile->buffer; 1748} 1749 1750/* Get the _cpp_file associated with the cpp_buffer B. */ 1751 1752_cpp_file * 1753cpp_get_file (cpp_buffer *b) 1754{ 1755 return b->file; 1756} 1757 1758/* Get the previous cpp_buffer given a cpp_buffer B. The previous 1759 buffer is the buffer that included the given buffer. */ 1760 1761cpp_buffer * 1762cpp_get_prev (cpp_buffer *b) 1763{ 1764 return b->prev; 1765} 1766 1767/* This data structure holds the list of header files that were seen 1768 while the PCH was being built. The 'entries' field is kept sorted 1769 in memcmp() order; yes, this means that on little-endian systems, 1770 it's sorted initially by the least-significant byte of 'size', but 1771 that's OK. The code does rely on having entries with the same size 1772 next to each other. */ 1773 1774struct pchf_entry { 1775 /* The size of this file. This is used to save running a MD5 checksum 1776 if the sizes don't match. */ 1777 off_t size; 1778 /* The MD5 checksum of this file. */ 1779 unsigned char sum[16]; 1780 /* Is this file to be included only once? */ 1781 bool once_only; 1782}; 1783 1784struct pchf_data { 1785 /* Number of pchf_entry structures. */ 1786 size_t count; 1787 1788 /* Are there any values with once_only set? 1789 This is used as an optimisation, it means we don't have to search 1790 the structure if we're processing a regular #include. */ 1791 bool have_once_only; 1792 1793 struct pchf_entry entries[1]; 1794}; 1795 1796static struct pchf_data *pchf; 1797 1798/* A qsort ordering function for pchf_entry structures. */ 1799 1800static int 1801pchf_save_compare (const void *e1, const void *e2) 1802{ 1803 return memcmp (e1, e2, sizeof (struct pchf_entry)); 1804} 1805 1806/* Create and write to F a pchf_data structure. */ 1807 1808bool 1809_cpp_save_file_entries (cpp_reader *pfile, FILE *fp) 1810{ 1811 size_t count = 0; 1812 struct pchf_data *result; 1813 size_t result_size; 1814 _cpp_file *f; 1815 bool ret; 1816 1817 for (f = pfile->all_files; f; f = f->next_file) 1818 ++count; 1819 1820 result_size = (sizeof (struct pchf_data) 1821 + sizeof (struct pchf_entry) * (count - 1)); 1822 result = XCNEWVAR (struct pchf_data, result_size); 1823 1824 result->count = 0; 1825 result->have_once_only = false; 1826 1827 for (f = pfile->all_files; f; f = f->next_file) 1828 { 1829 size_t count; 1830 1831 /* This should probably never happen, since if a read error occurred 1832 the PCH file shouldn't be written... */ 1833 if (f->dont_read || f->err_no) 1834 continue; 1835 1836 if (f->stack_count == 0) 1837 continue; 1838 1839 count = result->count++; 1840 1841 result->entries[count].once_only = f->once_only; 1842 /* |= is avoided in the next line because of an HP C compiler bug */ 1843 result->have_once_only = result->have_once_only | f->once_only; 1844 if (f->buffer_valid) 1845 md5_buffer ((const char *)f->buffer, 1846 f->st.st_size, result->entries[count].sum); 1847 else 1848 { 1849 FILE *ff; 1850 int oldfd = f->fd; 1851 1852 if (!open_file (f)) 1853 { 1854 open_file_failed (pfile, f, 0); 1855 free (result); 1856 return false; 1857 } 1858 ff = fdopen (f->fd, "rb"); 1859 md5_stream (ff, result->entries[count].sum); 1860 fclose (ff); 1861 f->fd = oldfd; 1862 } 1863 result->entries[count].size = f->st.st_size; 1864 } 1865 1866 result_size = (sizeof (struct pchf_data) 1867 + sizeof (struct pchf_entry) * (result->count - 1)); 1868 1869 qsort (result->entries, result->count, sizeof (struct pchf_entry), 1870 pchf_save_compare); 1871 1872 ret = fwrite (result, result_size, 1, fp) == 1; 1873 free (result); 1874 return ret; 1875} 1876 1877/* Read the pchf_data structure from F. */ 1878 1879bool 1880_cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f) 1881{ 1882 struct pchf_data d; 1883 1884 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f) 1885 != 1) 1886 return false; 1887 1888 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data) 1889 + sizeof (struct pchf_entry) * (d.count - 1)); 1890 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry)); 1891 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f) 1892 != d.count) 1893 return false; 1894 return true; 1895} 1896 1897/* The parameters for pchf_compare. */ 1898 1899struct pchf_compare_data 1900{ 1901 /* The size of the file we're looking for. */ 1902 off_t size; 1903 1904 /* The MD5 checksum of the file, if it's been computed. */ 1905 unsigned char sum[16]; 1906 1907 /* Is SUM valid? */ 1908 bool sum_computed; 1909 1910 /* Do we need to worry about entries that don't have ONCE_ONLY set? */ 1911 bool check_included; 1912 1913 /* The file that we're searching for. */ 1914 _cpp_file *f; 1915}; 1916 1917/* bsearch comparison function; look for D_P in E_P. */ 1918 1919static int 1920pchf_compare (const void *d_p, const void *e_p) 1921{ 1922 const struct pchf_entry *e = (const struct pchf_entry *)e_p; 1923 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p; 1924 int result; 1925 1926 result = memcmp (&d->size, &e->size, sizeof (off_t)); 1927 if (result != 0) 1928 return result; 1929 1930 if (! d->sum_computed) 1931 { 1932 _cpp_file *const f = d->f; 1933 1934 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum); 1935 d->sum_computed = true; 1936 } 1937 1938 result = memcmp (d->sum, e->sum, 16); 1939 if (result != 0) 1940 return result; 1941 1942 if (d->check_included || e->once_only) 1943 return 0; 1944 else 1945 return 1; 1946} 1947 1948/* Check that F is not in a list read from a PCH file (if any). 1949 Assumes that f->buffer_valid is true. Return TRUE if the file 1950 should not be read. */ 1951 1952static bool 1953check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, 1954 _cpp_file *f, 1955 bool check_included) 1956{ 1957 struct pchf_compare_data d; 1958 1959 if (pchf == NULL 1960 || (! check_included && ! pchf->have_once_only)) 1961 return false; 1962 1963 d.size = f->st.st_size; 1964 d.sum_computed = false; 1965 d.f = f; 1966 d.check_included = check_included; 1967 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry), 1968 pchf_compare) != NULL; 1969} 1970 1971/* Return true if the file FNAME is found in the appropriate include file path 1972 as indicated by ANGLE_BRACKETS. */ 1973 1974bool 1975_cpp_has_header (cpp_reader *pfile, const char *fname, int angle_brackets, 1976 enum include_type type) 1977{ 1978 cpp_dir *start_dir = search_path_head (pfile, fname, angle_brackets, type); 1979 _cpp_file *file = _cpp_find_file (pfile, fname, start_dir, 1980 /*fake=*/false, angle_brackets, 1981 /*implicit_preinclude=*/false); 1982 return file->err_no != ENOENT; 1983} 1984 1985