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