files.c revision 259268
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 buffer->file = file; 780 buffer->sysp = sysp; 781 782 /* Initialize controlling macro state. */ 783 pfile->mi_valid = true; 784 pfile->mi_cmacro = 0; 785 786 /* Generate the call back. */ 787 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp); 788 789 return true; 790} 791 792/* Mark FILE to be included once only. */ 793void 794_cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file) 795{ 796 pfile->seen_once_only = true; 797 file->once_only = true; 798} 799 800/* Return the directory from which searching for FNAME should start, 801 considering the directive TYPE and ANGLE_BRACKETS. If there is 802 nothing left in the path, returns NULL. */ 803static struct cpp_dir * 804search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets, 805 enum include_type type) 806{ 807 cpp_dir *dir; 808 _cpp_file *file; 809 810 if (IS_ABSOLUTE_PATH (fname)) 811 return &pfile->no_search_path; 812 813 /* pfile->buffer is NULL when processing an -include command-line flag. */ 814 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file; 815 816 /* For #include_next, skip in the search path past the dir in which 817 the current file was found, but if it was found via an absolute 818 path use the normal search logic. */ 819 if (type == IT_INCLUDE_NEXT && file->dir) 820 dir = file->dir->next; 821 else if (angle_brackets) 822 dir = pfile->bracket_include; 823 else if (type == IT_CMDLINE) 824 /* -include and -imacros use the #include "" chain with the 825 preprocessor's cwd prepended. */ 826 return make_cpp_dir (pfile, "./", false); 827 else if (pfile->quote_ignores_source_dir) 828 dir = pfile->quote_include; 829 else 830 return make_cpp_dir (pfile, dir_name_of_file (file), 831 pfile->buffer ? pfile->buffer->sysp : 0); 832 833 if (dir == NULL) 834 cpp_error (pfile, CPP_DL_ERROR, 835 "no include path in which to search for %s", fname); 836 837 return dir; 838} 839 840/* Strip the basename from the file's path. It ends with a slash if 841 of nonzero length. Note that this procedure also works for 842 <stdin>, which is represented by the empty string. */ 843static const char * 844dir_name_of_file (_cpp_file *file) 845{ 846 if (!file->dir_name) 847 { 848 size_t len = lbasename (file->path) - file->path; 849 char *dir_name = XNEWVEC (char, len + 1); 850 851 memcpy (dir_name, file->path, len); 852 dir_name[len] = '\0'; 853 file->dir_name = dir_name; 854 } 855 856 return file->dir_name; 857} 858 859/* Handles #include-family directives (distinguished by TYPE), 860 including HEADER, and the command line -imacros and -include. 861 Returns true if a buffer was stacked. */ 862bool 863_cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets, 864 enum include_type type) 865{ 866 struct cpp_dir *dir; 867 _cpp_file *file; 868 869 dir = search_path_head (pfile, fname, angle_brackets, type); 870 if (!dir) 871 return false; 872 873 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets); 874 875 /* Compensate for the increment in linemap_add. In the case of a 876 normal #include, we're currently at the start of the line 877 *following* the #include. A separate source_location for this 878 location makes no sense (until we do the LC_LEAVE), and 879 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we 880 found a PCH file (in which case linemap_add is not called) or we 881 were included from the command-line. */ 882 if (! file->pch && file->err_no == 0 && type != IT_CMDLINE) 883 pfile->line_table->highest_location--; 884 885 return _cpp_stack_file (pfile, file, type == IT_IMPORT); 886} 887 888/* Could not open FILE. The complication is dependency output. */ 889static void 890open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets) 891{ 892 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0; 893 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp); 894 895 errno = file->err_no; 896 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT) 897 deps_add_dep (pfile->deps, file->name); 898 else 899 { 900 /* If we are outputting dependencies but not for this file then 901 don't error because we can still produce correct output. */ 902 if (CPP_OPTION (pfile, deps.style) && ! print_dep) 903 cpp_errno (pfile, CPP_DL_WARNING, file->path); 904 else 905 cpp_errno (pfile, CPP_DL_ERROR, file->path); 906 } 907} 908 909/* Search in the chain beginning at HEAD for a file whose search path 910 started at START_DIR != NULL. */ 911static struct file_hash_entry * 912search_cache (struct file_hash_entry *head, const cpp_dir *start_dir) 913{ 914 while (head && head->start_dir != start_dir) 915 head = head->next; 916 917 return head; 918} 919 920/* Allocate a new _cpp_file structure. */ 921static _cpp_file * 922make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname) 923{ 924 _cpp_file *file; 925 926 file = XCNEW (_cpp_file); 927 file->main_file = !pfile->buffer; 928 file->fd = -1; 929 file->dir = dir; 930 file->name = xstrdup (fname); 931 932 return file; 933} 934 935/* Release a _cpp_file structure. */ 936static void 937destroy_cpp_file (_cpp_file *file) 938{ 939 if (file->buffer) 940 free ((void *) file->buffer); 941 free ((void *) file->name); 942 free (file); 943} 944 945/* A hash of directory names. The directory names are the path names 946 of files which contain a #include "", the included file name is 947 appended to this directories. 948 949 To avoid duplicate entries we follow the convention that all 950 non-empty directory names should end in a '/'. DIR_NAME must be 951 stored in permanently allocated memory. */ 952static cpp_dir * 953make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp) 954{ 955 struct file_hash_entry *entry, **hash_slot; 956 cpp_dir *dir; 957 958 hash_slot = (struct file_hash_entry **) 959 htab_find_slot_with_hash (pfile->dir_hash, dir_name, 960 htab_hash_string (dir_name), 961 INSERT); 962 963 /* Have we already hashed this directory? */ 964 for (entry = *hash_slot; entry; entry = entry->next) 965 if (entry->start_dir == NULL) 966 return entry->u.dir; 967 968 dir = XCNEW (cpp_dir); 969 dir->next = pfile->quote_include; 970 dir->name = (char *) dir_name; 971 dir->len = strlen (dir_name); 972 dir->sysp = sysp; 973 dir->construct = 0; 974 975 /* Store this new result in the hash table. */ 976 entry = new_file_hash_entry (pfile); 977 entry->next = *hash_slot; 978 entry->start_dir = NULL; 979 entry->u.dir = dir; 980 *hash_slot = entry; 981 982 return dir; 983} 984 985/* Create a new block of memory for file hash entries. */ 986static void 987allocate_file_hash_entries (cpp_reader *pfile) 988{ 989 pfile->file_hash_entries_used = 0; 990 pfile->file_hash_entries_allocated = 127; 991 pfile->file_hash_entries = XNEWVEC (struct file_hash_entry, 992 pfile->file_hash_entries_allocated); 993} 994 995/* Return a new file hash entry. */ 996static struct file_hash_entry * 997new_file_hash_entry (cpp_reader *pfile) 998{ 999 if (pfile->file_hash_entries_used == pfile->file_hash_entries_allocated) 1000 allocate_file_hash_entries (pfile); 1001 1002 return &pfile->file_hash_entries[pfile->file_hash_entries_used++]; 1003} 1004 1005/* Returns TRUE if a file FNAME has ever been successfully opened. 1006 This routine is not intended to correctly handle filenames aliased 1007 by links or redundant . or .. traversals etc. */ 1008bool 1009cpp_included (cpp_reader *pfile, const char *fname) 1010{ 1011 struct file_hash_entry *entry; 1012 1013 entry = (struct file_hash_entry *) 1014 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname)); 1015 1016 while (entry && (entry->start_dir == NULL || entry->u.file->err_no)) 1017 entry = entry->next; 1018 1019 return entry != NULL; 1020} 1021 1022/* Calculate the hash value of a file hash entry P. */ 1023 1024static hashval_t 1025file_hash_hash (const void *p) 1026{ 1027 struct file_hash_entry *entry = (struct file_hash_entry *) p; 1028 const char *hname; 1029 if (entry->start_dir) 1030 hname = entry->u.file->name; 1031 else 1032 hname = entry->u.dir->name; 1033 1034 return htab_hash_string (hname); 1035} 1036 1037/* Compare a string Q against a file hash entry P. */ 1038static int 1039file_hash_eq (const void *p, const void *q) 1040{ 1041 struct file_hash_entry *entry = (struct file_hash_entry *) p; 1042 const char *fname = (const char *) q; 1043 const char *hname; 1044 1045 if (entry->start_dir) 1046 hname = entry->u.file->name; 1047 else 1048 hname = entry->u.dir->name; 1049 1050 return strcmp (hname, fname) == 0; 1051} 1052 1053/* Compare entries in the nonexistent file hash table. These are just 1054 strings. */ 1055static int 1056nonexistent_file_hash_eq (const void *p, const void *q) 1057{ 1058 return strcmp (p, q) == 0; 1059} 1060 1061/* Initialize everything in this source file. */ 1062void 1063_cpp_init_files (cpp_reader *pfile) 1064{ 1065 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq, 1066 NULL, xcalloc, free); 1067 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq, 1068 NULL, xcalloc, free); 1069 allocate_file_hash_entries (pfile); 1070 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string, 1071 nonexistent_file_hash_eq, 1072 NULL, xcalloc, free); 1073 _obstack_begin (&pfile->nonexistent_file_ob, 0, 0, 1074 (void *(*) (long)) xmalloc, 1075 (void (*) (void *)) free); 1076} 1077 1078/* Finalize everything in this source file. */ 1079void 1080_cpp_cleanup_files (cpp_reader *pfile) 1081{ 1082 htab_delete (pfile->file_hash); 1083 htab_delete (pfile->dir_hash); 1084 htab_delete (pfile->nonexistent_file_hash); 1085 obstack_free (&pfile->nonexistent_file_ob, 0); 1086} 1087 1088/* Enter a file name in the hash for the sake of cpp_included. */ 1089void 1090_cpp_fake_include (cpp_reader *pfile, const char *fname) 1091{ 1092 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0); 1093} 1094 1095/* Not everyone who wants to set system-header-ness on a buffer can 1096 see the details of a buffer. This is an exported interface because 1097 fix-header needs it. */ 1098void 1099cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc) 1100{ 1101 int flags = 0; 1102 const struct line_maps *line_table = pfile->line_table; 1103 const struct line_map *map = &line_table->maps[line_table->used-1]; 1104 1105 /* 1 = system header, 2 = system header to be treated as C. */ 1106 if (syshdr) 1107 flags = 1 + (externc != 0); 1108 pfile->buffer->sysp = flags; 1109 _cpp_do_file_change (pfile, LC_RENAME, map->to_file, 1110 SOURCE_LINE (map, pfile->line_table->highest_line), flags); 1111} 1112 1113/* Allow the client to change the current file. Used by the front end 1114 to achieve pseudo-file names like <built-in>. 1115 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */ 1116void 1117cpp_change_file (cpp_reader *pfile, enum lc_reason reason, 1118 const char *new_name) 1119{ 1120 _cpp_do_file_change (pfile, reason, new_name, 1, 0); 1121} 1122 1123/* Callback function for htab_traverse. */ 1124static int 1125report_missing_guard (void **slot, void *b) 1126{ 1127 struct file_hash_entry *entry = (struct file_hash_entry *) *slot; 1128 int *bannerp = (int *) b; 1129 1130 /* Skip directories. */ 1131 if (entry->start_dir != NULL) 1132 { 1133 _cpp_file *file = entry->u.file; 1134 1135 /* We don't want MI guard advice for the main file. */ 1136 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file) 1137 { 1138 if (*bannerp == 0) 1139 { 1140 fputs (_("Multiple include guards may be useful for:\n"), 1141 stderr); 1142 *bannerp = 1; 1143 } 1144 1145 fputs (entry->u.file->path, stderr); 1146 putc ('\n', stderr); 1147 } 1148 } 1149 1150 return 0; 1151} 1152 1153/* Report on all files that might benefit from a multiple include guard. 1154 Triggered by -H. */ 1155void 1156_cpp_report_missing_guards (cpp_reader *pfile) 1157{ 1158 int banner = 0; 1159 1160 htab_traverse (pfile->file_hash, report_missing_guard, &banner); 1161} 1162 1163/* Locate HEADER, and determine whether it is newer than the current 1164 file. If it cannot be located or dated, return -1, if it is 1165 newer, return 1, otherwise 0. */ 1166int 1167_cpp_compare_file_date (cpp_reader *pfile, const char *fname, 1168 int angle_brackets) 1169{ 1170 _cpp_file *file; 1171 struct cpp_dir *dir; 1172 1173 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE); 1174 if (!dir) 1175 return -1; 1176 1177 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets); 1178 if (file->err_no) 1179 return -1; 1180 1181 if (file->fd != -1) 1182 { 1183 close (file->fd); 1184 file->fd = -1; 1185 } 1186 1187 return file->st.st_mtime > pfile->buffer->file->st.st_mtime; 1188} 1189 1190/* Pushes the given file onto the buffer stack. Returns nonzero if 1191 successful. */ 1192bool 1193cpp_push_include (cpp_reader *pfile, const char *fname) 1194{ 1195 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE); 1196} 1197 1198/* Do appropriate cleanup when a file INC's buffer is popped off the 1199 input stack. */ 1200void 1201_cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file) 1202{ 1203 /* Record the inclusion-preventing macro, which could be NULL 1204 meaning no controlling macro. */ 1205 if (pfile->mi_valid && file->cmacro == NULL) 1206 file->cmacro = pfile->mi_cmacro; 1207 1208 /* Invalidate control macros in the #including file. */ 1209 pfile->mi_valid = false; 1210 1211 if (file->buffer) 1212 { 1213 free ((void *) file->buffer); 1214 file->buffer = NULL; 1215 file->buffer_valid = false; 1216 } 1217} 1218 1219/* Inteface to file statistics record in _cpp_file structure. */ 1220struct stat * 1221_cpp_get_file_stat (_cpp_file *file) 1222{ 1223 return &file->st; 1224} 1225 1226/* Set the include chain for "" to QUOTE, for <> to BRACKET. If 1227 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the 1228 directory of the including file. 1229 1230 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */ 1231void 1232cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket, 1233 int quote_ignores_source_dir) 1234{ 1235 pfile->quote_include = quote; 1236 pfile->bracket_include = quote; 1237 pfile->quote_ignores_source_dir = quote_ignores_source_dir; 1238 1239 for (; quote; quote = quote->next) 1240 { 1241 quote->name_map = NULL; 1242 quote->len = strlen (quote->name); 1243 if (quote == bracket) 1244 pfile->bracket_include = bracket; 1245 } 1246} 1247 1248/* Append the file name to the directory to create the path, but don't 1249 turn / into // or // into ///; // may be a namespace escape. */ 1250static char * 1251append_file_to_dir (const char *fname, cpp_dir *dir) 1252{ 1253 size_t dlen, flen; 1254 char *path; 1255 1256 dlen = dir->len; 1257 flen = strlen (fname); 1258 path = XNEWVEC (char, dlen + 1 + flen + 1); 1259 memcpy (path, dir->name, dlen); 1260 if (dlen && path[dlen - 1] != '/') 1261 path[dlen++] = '/'; 1262 memcpy (&path[dlen], fname, flen + 1); 1263 1264 return path; 1265} 1266 1267/* Read a space delimited string of unlimited length from a stdio 1268 file F. */ 1269static char * 1270read_filename_string (int ch, FILE *f) 1271{ 1272 char *alloc, *set; 1273 int len; 1274 1275 len = 20; 1276 set = alloc = XNEWVEC (char, len + 1); 1277 if (! is_space (ch)) 1278 { 1279 *set++ = ch; 1280 while ((ch = getc (f)) != EOF && ! is_space (ch)) 1281 { 1282 if (set - alloc == len) 1283 { 1284 len *= 2; 1285 alloc = XRESIZEVEC (char, alloc, len + 1); 1286 set = alloc + len / 2; 1287 } 1288 *set++ = ch; 1289 } 1290 } 1291 *set = '\0'; 1292 ungetc (ch, f); 1293 return alloc; 1294} 1295 1296/* Read the file name map file for DIR. */ 1297static void 1298read_name_map (cpp_dir *dir) 1299{ 1300 static const char FILE_NAME_MAP_FILE[] = "header.gcc"; 1301 char *name; 1302 FILE *f; 1303 size_t len, count = 0, room = 9; 1304 1305 len = dir->len; 1306 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1); 1307 memcpy (name, dir->name, len); 1308 if (len && name[len - 1] != '/') 1309 name[len++] = '/'; 1310 strcpy (name + len, FILE_NAME_MAP_FILE); 1311 f = fopen (name, "r"); 1312 1313 dir->name_map = XNEWVEC (const char *, room); 1314 1315 /* Silently return NULL if we cannot open. */ 1316 if (f) 1317 { 1318 int ch; 1319 1320 while ((ch = getc (f)) != EOF) 1321 { 1322 char *to; 1323 1324 if (is_space (ch)) 1325 continue; 1326 1327 if (count + 2 > room) 1328 { 1329 room += 8; 1330 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room); 1331 } 1332 1333 dir->name_map[count] = read_filename_string (ch, f); 1334 while ((ch = getc (f)) != EOF && is_hspace (ch)) 1335 ; 1336 1337 to = read_filename_string (ch, f); 1338 if (IS_ABSOLUTE_PATH (to)) 1339 dir->name_map[count + 1] = to; 1340 else 1341 { 1342 dir->name_map[count + 1] = append_file_to_dir (to, dir); 1343 free (to); 1344 } 1345 1346 count += 2; 1347 while ((ch = getc (f)) != '\n') 1348 if (ch == EOF) 1349 break; 1350 } 1351 1352 fclose (f); 1353 } 1354 1355 /* Terminate the list of maps. */ 1356 dir->name_map[count] = NULL; 1357} 1358 1359/* Remap a FILE's name based on the file_name_map, if any, for 1360 FILE->dir. If the file name has any directory separators, 1361 recursively check those directories too. */ 1362static char * 1363remap_filename (cpp_reader *pfile, _cpp_file *file) 1364{ 1365 const char *fname, *p; 1366 char *new_dir; 1367 cpp_dir *dir; 1368 size_t index, len; 1369 1370 dir = file->dir; 1371 fname = file->name; 1372 1373 for (;;) 1374 { 1375 if (!dir->name_map) 1376 read_name_map (dir); 1377 1378 for (index = 0; dir->name_map[index]; index += 2) 1379 if (!strcmp (dir->name_map[index], fname)) 1380 return xstrdup (dir->name_map[index + 1]); 1381 1382 p = strchr (fname, '/'); 1383 if (!p || p == fname) 1384 return NULL; 1385 1386 len = dir->len + (p - fname + 1); 1387 new_dir = XNEWVEC (char, len + 1); 1388 memcpy (new_dir, dir->name, dir->len); 1389 memcpy (new_dir + dir->len, fname, p - fname + 1); 1390 new_dir[len] = '\0'; 1391 1392 dir = make_cpp_dir (pfile, new_dir, dir->sysp); 1393 fname = p + 1; 1394 } 1395} 1396 1397/* Returns true if PCHNAME is a valid PCH file for FILE. */ 1398static bool 1399validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname) 1400{ 1401 const char *saved_path = file->path; 1402 bool valid = false; 1403 1404 file->path = pchname; 1405 if (open_file (file)) 1406 { 1407 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd); 1408 1409 if (!valid) 1410 { 1411 close (file->fd); 1412 file->fd = -1; 1413 } 1414 1415 if (CPP_OPTION (pfile, print_include_names)) 1416 { 1417 unsigned int i; 1418 for (i = 1; i < pfile->line_table->depth; i++) 1419 putc ('.', stderr); 1420 fprintf (stderr, "%c %s\n", 1421 valid ? '!' : 'x', pchname); 1422 } 1423 } 1424 1425 file->path = saved_path; 1426 return valid; 1427} 1428 1429/* Get the path associated with the _cpp_file F. The path includes 1430 the base name from the include directive and the directory it was 1431 found in via the search path. */ 1432 1433const char * 1434cpp_get_path (struct _cpp_file *f) 1435{ 1436 return f->path; 1437} 1438 1439/* Get the directory associated with the _cpp_file F. */ 1440 1441cpp_dir * 1442cpp_get_dir (struct _cpp_file *f) 1443{ 1444 return f->dir; 1445} 1446 1447/* Get the cpp_buffer currently associated with the cpp_reader 1448 PFILE. */ 1449 1450cpp_buffer * 1451cpp_get_buffer (cpp_reader *pfile) 1452{ 1453 return pfile->buffer; 1454} 1455 1456/* Get the _cpp_file associated with the cpp_buffer B. */ 1457 1458_cpp_file * 1459cpp_get_file (cpp_buffer *b) 1460{ 1461 return b->file; 1462} 1463 1464/* Get the previous cpp_buffer given a cpp_buffer B. The previous 1465 buffer is the buffer that included the given buffer. */ 1466 1467cpp_buffer * 1468cpp_get_prev (cpp_buffer *b) 1469{ 1470 return b->prev; 1471} 1472 1473/* This data structure holds the list of header files that were seen 1474 while the PCH was being built. The 'entries' field is kept sorted 1475 in memcmp() order; yes, this means that on little-endian systems, 1476 it's sorted initially by the least-significant byte of 'size', but 1477 that's OK. The code does rely on having entries with the same size 1478 next to each other. */ 1479 1480struct pchf_entry { 1481 /* The size of this file. This is used to save running a MD5 checksum 1482 if the sizes don't match. */ 1483 off_t size; 1484 /* The MD5 checksum of this file. */ 1485 unsigned char sum[16]; 1486 /* Is this file to be included only once? */ 1487 bool once_only; 1488}; 1489 1490struct pchf_data { 1491 /* Number of pchf_entry structures. */ 1492 size_t count; 1493 1494 /* Are there any values with once_only set? 1495 This is used as an optimisation, it means we don't have to search 1496 the structure if we're processing a regular #include. */ 1497 bool have_once_only; 1498 1499 struct pchf_entry entries[1]; 1500}; 1501 1502static struct pchf_data *pchf; 1503 1504/* A qsort ordering function for pchf_entry structures. */ 1505 1506static int 1507pchf_save_compare (const void *e1, const void *e2) 1508{ 1509 return memcmp (e1, e2, sizeof (struct pchf_entry)); 1510} 1511 1512/* Create and write to F a pchf_data structure. */ 1513 1514bool 1515_cpp_save_file_entries (cpp_reader *pfile, FILE *fp) 1516{ 1517 size_t count = 0; 1518 struct pchf_data *result; 1519 size_t result_size; 1520 _cpp_file *f; 1521 1522 for (f = pfile->all_files; f; f = f->next_file) 1523 ++count; 1524 1525 result_size = (sizeof (struct pchf_data) 1526 + sizeof (struct pchf_entry) * (count - 1)); 1527 result = XCNEWVAR (struct pchf_data, result_size); 1528 1529 result->count = 0; 1530 result->have_once_only = false; 1531 1532 for (f = pfile->all_files; f; f = f->next_file) 1533 { 1534 size_t count; 1535 1536 /* This should probably never happen, since if a read error occurred 1537 the PCH file shouldn't be written... */ 1538 if (f->dont_read || f->err_no) 1539 continue; 1540 1541 if (f->stack_count == 0) 1542 continue; 1543 1544 count = result->count++; 1545 1546 result->entries[count].once_only = f->once_only; 1547 /* |= is avoided in the next line because of an HP C compiler bug */ 1548 result->have_once_only = result->have_once_only | f->once_only; 1549 if (f->buffer_valid) 1550 md5_buffer ((const char *)f->buffer, 1551 f->st.st_size, result->entries[count].sum); 1552 else 1553 { 1554 FILE *ff; 1555 int oldfd = f->fd; 1556 1557 if (!open_file (f)) 1558 { 1559 open_file_failed (pfile, f, 0); 1560 return false; 1561 } 1562 ff = fdopen (f->fd, "rb"); 1563 md5_stream (ff, result->entries[count].sum); 1564 fclose (ff); 1565 f->fd = oldfd; 1566 } 1567 result->entries[count].size = f->st.st_size; 1568 } 1569 1570 result_size = (sizeof (struct pchf_data) 1571 + sizeof (struct pchf_entry) * (result->count - 1)); 1572 1573 qsort (result->entries, result->count, sizeof (struct pchf_entry), 1574 pchf_save_compare); 1575 1576 return fwrite (result, result_size, 1, fp) == 1; 1577} 1578 1579/* Read the pchf_data structure from F. */ 1580 1581bool 1582_cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f) 1583{ 1584 struct pchf_data d; 1585 1586 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f) 1587 != 1) 1588 return false; 1589 1590 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data) 1591 + sizeof (struct pchf_entry) * (d.count - 1)); 1592 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry)); 1593 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f) 1594 != d.count) 1595 return false; 1596 return true; 1597} 1598 1599/* The parameters for pchf_compare. */ 1600 1601struct pchf_compare_data 1602{ 1603 /* The size of the file we're looking for. */ 1604 off_t size; 1605 1606 /* The MD5 checksum of the file, if it's been computed. */ 1607 unsigned char sum[16]; 1608 1609 /* Is SUM valid? */ 1610 bool sum_computed; 1611 1612 /* Do we need to worry about entries that don't have ONCE_ONLY set? */ 1613 bool check_included; 1614 1615 /* The file that we're searching for. */ 1616 _cpp_file *f; 1617}; 1618 1619/* bsearch comparison function; look for D_P in E_P. */ 1620 1621static int 1622pchf_compare (const void *d_p, const void *e_p) 1623{ 1624 const struct pchf_entry *e = (const struct pchf_entry *)e_p; 1625 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p; 1626 int result; 1627 1628 result = memcmp (&d->size, &e->size, sizeof (off_t)); 1629 if (result != 0) 1630 return result; 1631 1632 if (! d->sum_computed) 1633 { 1634 _cpp_file *const f = d->f; 1635 1636 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum); 1637 d->sum_computed = true; 1638 } 1639 1640 result = memcmp (d->sum, e->sum, 16); 1641 if (result != 0) 1642 return result; 1643 1644 if (d->check_included || e->once_only) 1645 return 0; 1646 else 1647 return 1; 1648} 1649 1650/* Check that F is not in a list read from a PCH file (if any). 1651 Assumes that f->buffer_valid is true. Return TRUE if the file 1652 should not be read. */ 1653 1654static bool 1655check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, 1656 _cpp_file *f, 1657 bool check_included) 1658{ 1659 struct pchf_compare_data d; 1660 1661 if (pchf == NULL 1662 || (! check_included && ! pchf->have_once_only)) 1663 return false; 1664 1665 d.size = f->st.st_size; 1666 d.sum_computed = false; 1667 d.f = f; 1668 d.check_included = check_included; 1669 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry), 1670 pchf_compare) != NULL; 1671} 1672