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