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