OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [libcpp/] [files.c] - Blame information for rev 816

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.