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