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