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