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