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