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