#include "config.h"
#include "system.h"
#include "cpplib.h"
#include "internal.h"
#include "mkdeps.h"
#include "hashtab.h"
#include "md5.h"
#include <dirent.h>
#ifdef VMS
# define FAB_C_VAR 2
# define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
#else
# define STAT_SIZE_RELIABLE(ST) (!CPP_OPTION (pfile, predictive_compilation))
#endif
#ifdef __DJGPP__
# define set_stdin_to_binary_mode() \
if (! isatty (0)) setmode (0, O_BINARY)
#else
# define set_stdin_to_binary_mode()
#endif
struct _cpp_file
{
const char *name;
const char *path;
const char *pchname;
const char *dir_name;
struct _cpp_file *next_file;
const uchar *buffer;
const cpp_hashnode *cmacro;
cpp_dir *dir;
struct stat st;
int fd;
int err_no;
unsigned short stack_count;
bool once_only;
bool dont_read;
bool main_file;
bool buffer_valid;
bool pch;
};
struct file_hash_entry
{
struct file_hash_entry *next;
cpp_dir *start_dir;
union
{
_cpp_file *file;
cpp_dir *dir;
} u;
};
static bool open_file (_cpp_file *file);
static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
bool *invalid_pch);
static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
bool *invalid_pch);
static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
static bool read_file (cpp_reader *pfile, _cpp_file *file);
static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
int angle_brackets, enum include_type);
static const char *dir_name_of_file (_cpp_file *file);
static void open_file_failed (cpp_reader *pfile, _cpp_file *file);
static struct file_hash_entry *search_cache (struct file_hash_entry *head,
const cpp_dir *start_dir);
static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
static void destroy_cpp_file (_cpp_file *);
static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
static void allocate_file_hash_entries (cpp_reader *pfile);
static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
static int report_missing_guard (void **slot, void *b);
static hashval_t file_hash_hash (const void *p);
static int file_hash_eq (const void *p, const void *q);
static char *read_filename_string (int ch, FILE *f);
static void read_name_map (cpp_dir *dir);
static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
static char *append_file_to_dir (const char *fname, cpp_dir *dir);
static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
static int pchf_save_compare (const void *e1, const void *e2);
static int pchf_compare (const void *d_p, const void *e_p);
static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
#include <sys/param.h>
char *indirect_file (char *, const int);
static bool
open_file (_cpp_file *file)
{
if (file->path[0] == '\0')
{
file->fd = 0;
set_stdin_to_binary_mode ();
}
else
file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
if (file->fd != -1)
{
if (fstat (file->fd, &file->st) == 0)
{
if (!S_ISDIR (file->st.st_mode))
{
file->err_no = 0;
return true;
}
errno = ENOENT;
}
close (file->fd);
file->fd = -1;
}
else if (errno == ENOTDIR)
errno = ENOENT;
file->err_no = errno;
return false;
}
static bool
pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
{
static const char extension[] = ".gch";
const char *path = file->path;
size_t len, flen;
char *pchname;
struct stat st;
bool valid = false;
if (pfile->is_main_file || file->name[0] == '\0' || !pfile->cb.valid_pch)
return false;
flen = strlen (path);
len = flen + sizeof (extension);
pchname = xmalloc (len);
memcpy (pchname, path, flen);
memcpy (pchname + flen, extension, sizeof (extension));
if (! file->main_file)
pchname = indirect_file (pchname, 0);
if (stat (pchname, &st) == 0)
{
DIR *pchdir;
struct dirent *d;
size_t dlen, plen = len;
if (!S_ISDIR (st.st_mode))
valid = validate_pch (pfile, file, pchname);
else if ((pchdir = opendir (pchname)) != NULL)
{
pchname[plen - 1] = '/';
while ((d = readdir (pchdir)) != NULL)
{
dlen = strlen (d->d_name) + 1;
if ((strcmp (d->d_name, ".") == 0)
|| (strcmp (d->d_name, "..") == 0))
continue;
if (dlen + plen > len)
{
len += dlen + 64;
pchname = xrealloc (pchname, len);
}
memcpy (pchname + plen, d->d_name, dlen);
valid = validate_pch (pfile, file, pchname);
if (valid)
break;
}
closedir (pchdir);
}
if (valid)
file->pch = true;
else
*invalid_pch = true;
}
if (valid)
file->pchname = pchname;
else
free (pchname);
return valid;
}
static bool
find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
{
char *path;
if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
;
else
if (file->dir->construct)
path = file->dir->construct (file->name, file->dir);
else
path = append_file_to_dir (file->name, file->dir);
if (path)
{
bool res_open_file;
file->path = path;
if (pch_open_file (pfile, file, invalid_pch))
return true;
if (pfile->is_main_file)
file->path = "";
res_open_file = open_file (file);
file->path = path;
if (res_open_file)
return true;
if (file->err_no != ENOENT)
{
open_file_failed (pfile, file);
return true;
}
free (path);
file->path = file->name;
}
else
{
file->err_no = ENOENT;
file->path = NULL;
}
return false;
}
static bool
search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
{
missing_header_cb func = pfile->cb.missing_header;
if (func
&& file->dir == NULL)
{
if ((file->path = func (pfile, header, &file->dir)) != NULL)
{
if (open_file (file))
return true;
free ((void *)file->path);
}
file->path = file->name;
}
return false;
}
bool
_cpp_find_failed (_cpp_file *file)
{
return file->err_no != 0;
}
_cpp_file *
_cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake)
{
struct file_hash_entry *entry, **hash_slot;
_cpp_file *file;
bool invalid_pch = false;
if (start_dir == NULL)
cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
hash_slot = (struct file_hash_entry **)
htab_find_slot_with_hash (pfile->file_hash, fname,
htab_hash_string (fname),
INSERT);
entry = search_cache (*hash_slot, start_dir);
if (entry)
return entry->u.file;
file = make_cpp_file (pfile, start_dir, fname);
for (; !fake ;)
{
if (file->dir == pfile->quote_include
|| file->dir == pfile->bracket_include)
{
entry = search_cache (*hash_slot, file->dir);
if (entry)
{
free ((char *) file->name);
free (file);
file = entry->u.file;
goto found;
}
}
if (find_file_in_dir (pfile, file, &invalid_pch))
break;
file->dir = file->dir->next;
if (file->dir == NULL)
{
if (search_path_exhausted (pfile, fname, file))
{
file->next_file = pfile->all_files;
pfile->all_files = file;
return file;
}
open_file_failed (pfile, file);
if (invalid_pch)
{
cpp_error (pfile, CPP_DL_ERROR,
"one or more PCH files were found, but they were invalid");
if (!cpp_get_options (pfile)->warn_invalid_pch)
cpp_error (pfile, CPP_DL_ERROR,
"use -Winvalid-pch for more information");
}
break;
}
}
file->next_file = pfile->all_files;
pfile->all_files = file;
if (file->dir && start_dir->next == pfile->quote_include)
{
cpp_dir *d;
cpp_dir *proper_start_dir = pfile->quote_include;
for (d = proper_start_dir;; d = d->next)
{
if (d == pfile->bracket_include)
proper_start_dir = d;
if (d == 0)
{
proper_start_dir = 0;
break;
}
if (!strncmp (d->name, file->dir->name, file->dir->len - 1))
break;
}
if (proper_start_dir)
start_dir = proper_start_dir;
}
found:
entry = new_file_hash_entry (pfile);
entry->next = *hash_slot;
entry->start_dir = start_dir;
entry->u.file = file;
*hash_slot = entry;
return file;
}
static bool
read_file_guts (cpp_reader *pfile, _cpp_file *file)
{
ssize_t size, total, count;
uchar *buf;
bool regular;
if (S_ISBLK (file->st.st_mode))
{
cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
return false;
}
regular = S_ISREG (file->st.st_mode);
if (regular)
{
if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
{
cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
return false;
}
size = file->st.st_size;
}
else
if (CPP_OPTION (pfile, predictive_compilation))
{
size = CPP_OPTION (pfile, predictive_compilation_size);
regular = size >= 0;
if (size < 0)
size = 8 * 1024;
CPP_OPTION(pfile, predictive_compilation_size) = -1;
}
else
size = 8 * 1024;
buf = xmalloc (size + 1);
total = 0;
while ((count = read (file->fd, buf + total, size - total)) > 0)
{
total += count;
if (total == size)
{
if (regular)
break;
size *= 2;
buf = xrealloc (buf, size + 1);
}
}
if (count < 0)
{
cpp_errno (pfile, CPP_DL_ERROR, file->path);
return false;
}
if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
cpp_error (pfile, CPP_DL_WARNING,
"%s is shorter than expected", file->path);
file->buffer = _cpp_convert_input (pfile, CPP_OPTION (pfile, input_charset),
buf, size, total, &file->st.st_size);
file->buffer_valid = true;
return true;
}
static bool
read_file (cpp_reader *pfile, _cpp_file *file)
{
if (file->buffer_valid)
return true;
if (file->dont_read || file->err_no)
return false;
if (file->fd == -1 && !open_file (file))
{
open_file_failed (pfile, file);
return false;
}
file->dont_read = !read_file_guts (pfile, file);
if (file->fd != 0)
{
close (file->fd);
file->fd = -1;
}
return !file->dont_read;
}
static bool
should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
{
_cpp_file *f;
if (file->once_only)
return false;
if (import)
{
_cpp_mark_file_once_only (pfile, file);
if (file->stack_count)
return false;
}
if (file->cmacro && file->cmacro->type == NT_MACRO)
return false;
if (file->pch)
{
pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
close (file->fd);
file->fd = -1;
return false;
}
if (!read_file (pfile, file))
return false;
if (check_file_against_entries (pfile, file, import))
{
if (! import)
_cpp_mark_file_once_only (pfile, file);
return false;
}
if (!pfile->seen_once_only)
return true;
for (f = pfile->all_files; f; f = f->next_file)
{
if (f == file)
continue;
if ((import || f->once_only)
&& f->err_no == 0
&& f->st.st_mtime == file->st.st_mtime
&& f->st.st_size == file->st.st_size)
{
_cpp_file *ref_file;
bool same_file_p = false;
if (f->buffer && !f->buffer_valid)
{
ref_file = make_cpp_file (pfile, f->dir, f->name);
ref_file->path = f->path;
}
else
ref_file = f;
same_file_p = read_file (pfile, ref_file)
&& ref_file->st.st_size == file->st.st_size
&& !memcmp (ref_file->buffer,
file->buffer,
file->st.st_size);
if (f->buffer && !f->buffer_valid)
{
ref_file->path = 0;
destroy_cpp_file (ref_file);
}
if (same_file_p)
break;
}
}
return f == NULL;
}
bool
_cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
{
cpp_buffer *buffer;
int sysp;
if (!should_stack_file (pfile, file, import))
return false;
if (pfile->buffer == NULL || file->dir == NULL)
sysp = 0;
else
sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
{
if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
deps_add_dep (pfile->deps, file->path);
}
file->buffer_valid = false;
file->stack_count++;
buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
CPP_OPTION (pfile, preprocessed));
buffer->file = file;
buffer->sysp = sysp;
pfile->mi_valid = true;
pfile->mi_cmacro = 0;
_cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
return true;
}
void
_cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
{
pfile->seen_once_only = true;
file->once_only = true;
}
static struct cpp_dir *
search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
enum include_type type)
{
cpp_dir *dir;
_cpp_file *file;
if (IS_ABSOLUTE_PATH (fname))
return &pfile->no_search_path;
file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
if (type == IT_INCLUDE_NEXT && file->dir)
dir = file->dir->next;
else if (angle_brackets)
dir = pfile->bracket_include;
else if (type == IT_CMDLINE)
return make_cpp_dir (pfile, "./", false);
else if (pfile->quote_ignores_source_dir)
dir = pfile->quote_include;
else
return make_cpp_dir (pfile, dir_name_of_file (file),
pfile->buffer ? pfile->buffer->sysp : 0);
if (dir == NULL)
cpp_error (pfile, CPP_DL_ERROR,
"no include path in which to search for %s", fname);
return dir;
}
static const char *
dir_name_of_file (_cpp_file *file)
{
if (!file->dir_name)
{
size_t len = lbasename (file->path) - file->path;
char *dir_name = xmalloc (len + 1);
memcpy (dir_name, file->path, len);
dir_name[len] = '\0';
file->dir_name = dir_name;
}
return file->dir_name;
}
bool
_cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
enum include_type type)
{
struct cpp_dir *dir;
_cpp_file *file;
dir = search_path_head (pfile, fname, angle_brackets, type);
if (!dir)
return false;
file = _cpp_find_file (pfile, fname, dir, false);
if (! file->pch && file->err_no == 0 && type != IT_CMDLINE)
pfile->line_table->highest_location--;
return _cpp_stack_file (pfile, file, type == IT_IMPORT);
}
static void
open_file_failed (cpp_reader *pfile, _cpp_file *file)
{
int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
bool print_dep = CPP_OPTION (pfile, deps.style) > !!sysp;
errno = file->err_no;
if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
deps_add_dep (pfile->deps, file->name);
else
{
if (CPP_OPTION (pfile, deps.style) && ! print_dep)
cpp_errno (pfile, CPP_DL_WARNING, file->path);
else
cpp_errno (pfile, CPP_DL_ERROR, file->path);
}
}
static struct file_hash_entry *
search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
{
struct file_hash_entry *p;
for (p = head; p; p = p->next)
if (p->start_dir == start_dir)
return p;
return 0;
}
static _cpp_file *
make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
{
_cpp_file *file;
file = xcalloc (1, sizeof (_cpp_file));
file->main_file = !pfile->buffer;
file->fd = -1;
file->dir = dir;
file->name = xstrdup (fname);
return file;
}
static void
destroy_cpp_file (_cpp_file *file)
{
if (file->buffer)
free ((void *) file->buffer);
free ((void *) file->name);
free (file);
}
static cpp_dir *
make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
{
struct file_hash_entry *entry, **hash_slot;
cpp_dir *dir;
hash_slot = (struct file_hash_entry **)
htab_find_slot_with_hash (pfile->dir_hash, dir_name,
htab_hash_string (dir_name),
INSERT);
for (entry = *hash_slot; entry; entry = entry->next)
if (entry->start_dir == NULL)
return entry->u.dir;
dir = xcalloc (1, sizeof (cpp_dir));
dir->next = pfile->quote_include;
dir->name = (char *) dir_name;
dir->len = strlen (dir_name);
dir->sysp = sysp;
dir->construct = 0;
entry = new_file_hash_entry (pfile);
entry->next = *hash_slot;
entry->start_dir = NULL;
entry->u.dir = dir;
*hash_slot = entry;
return dir;
}
static void
allocate_file_hash_entries (cpp_reader *pfile)
{
pfile->file_hash_entries_used = 0;
pfile->file_hash_entries_allocated = 127;
pfile->file_hash_entries = xmalloc
(pfile->file_hash_entries_allocated * sizeof (struct file_hash_entry));
}
static struct file_hash_entry *
new_file_hash_entry (cpp_reader *pfile)
{
if (pfile->file_hash_entries_used == pfile->file_hash_entries_allocated)
allocate_file_hash_entries (pfile);
return &pfile->file_hash_entries[pfile->file_hash_entries_used++];
}
bool read_from_stdin (cpp_reader *pfile)
{
_cpp_file *file;
if (pfile->buffer->file->fd != 0)
return false;
file = pfile->main_file;
file->dont_read = !read_file_guts (pfile, file);
pfile->buffer->next_line = file->buffer;
pfile->buffer->rlimit = file->buffer + file->st.st_size;
return !file->dont_read;
}
bool
cpp_included (cpp_reader *pfile, const char *fname)
{
struct file_hash_entry *entry;
entry = htab_find_with_hash (pfile->file_hash, fname,
htab_hash_string (fname));
while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
entry = entry->next;
return entry != NULL;
}
static hashval_t
file_hash_hash (const void *p)
{
struct file_hash_entry *entry = (struct file_hash_entry *) p;
const char *hname;
if (entry->start_dir)
hname = entry->u.file->name;
else
hname = entry->u.dir->name;
return htab_hash_string (hname);
}
static int
file_hash_eq (const void *p, const void *q)
{
struct file_hash_entry *entry = (struct file_hash_entry *) p;
const char *fname = (const char *) q;
const char *hname;
if (entry->start_dir)
hname = entry->u.file->name;
else
hname = entry->u.dir->name;
return strcmp (hname, fname) == 0;
}
void
_cpp_init_files (cpp_reader *pfile)
{
pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
NULL, xcalloc, free);
pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
NULL, xcalloc, free);
allocate_file_hash_entries (pfile);
}
void
_cpp_cleanup_files (cpp_reader *pfile)
{
htab_delete (pfile->file_hash);
htab_delete (pfile->dir_hash);
}
void
_cpp_fake_include (cpp_reader *pfile, const char *fname)
{
_cpp_find_file (pfile, fname, pfile->buffer->file->dir, true);
}
void
cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
{
int flags = 0;
const struct line_maps *line_table = pfile->line_table;
const struct line_map *map = &line_table->maps[line_table->used-1];
if (syshdr)
flags = 1 + (externc != 0);
pfile->buffer->sysp = flags;
_cpp_do_file_change (pfile, LC_RENAME, map->to_file,
SOURCE_LINE (map, pfile->line_table->highest_line), flags);
}
void
cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
const char *new_name)
{
_cpp_do_file_change (pfile, reason, new_name, 1, 0);
}
static int
report_missing_guard (void **slot, void *b)
{
struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
int *bannerp = (int *) b;
if (entry->start_dir != NULL)
{
_cpp_file *file = entry->u.file;
if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
{
if (*bannerp == 0)
{
fputs (_("Multiple include guards may be useful for:\n"),
stderr);
*bannerp = 1;
}
fputs (entry->u.file->path, stderr);
putc ('\n', stderr);
}
}
return 0;
}
void
_cpp_report_missing_guards (cpp_reader *pfile)
{
int banner = 0;
htab_traverse (pfile->file_hash, report_missing_guard, &banner);
}
int
_cpp_compare_file_date (cpp_reader *pfile, const char *fname,
int angle_brackets)
{
_cpp_file *file;
struct cpp_dir *dir;
dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
if (!dir)
return -1;
file = _cpp_find_file (pfile, fname, dir, false);
if (file->err_no)
return -1;
if (file->fd != -1)
{
close (file->fd);
file->fd = -1;
}
return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
}
bool
cpp_push_include (cpp_reader *pfile, const char *fname)
{
return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
}
void
_cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
{
if (pfile->mi_valid && file->cmacro == NULL)
file->cmacro = pfile->mi_cmacro;
pfile->mi_valid = false;
if (file->buffer)
{
free ((void *) file->buffer);
file->buffer = NULL;
}
}
void
cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
int quote_ignores_source_dir)
{
pfile->quote_include = quote;
pfile->bracket_include = quote;
pfile->quote_ignores_source_dir = quote_ignores_source_dir;
for (; quote; quote = quote->next)
{
quote->name_map = NULL;
quote->len = strlen (quote->name);
if (quote == bracket)
pfile->bracket_include = bracket;
}
}
static char *
append_file_to_dir (const char *fname, cpp_dir *dir)
{
size_t dlen, flen;
char *path;
dlen = dir->len;
flen = strlen (fname);
path = xmalloc (dlen + 1 + flen + 1);
memcpy (path, dir->name, dlen);
if (dlen && path[dlen - 1] != '/')
path[dlen++] = '/';
memcpy (&path[dlen], fname, flen + 1);
return path;
}
static char *
read_filename_string (int ch, FILE *f)
{
char *alloc, *set;
int len;
len = 20;
set = alloc = xmalloc (len + 1);
if (! is_space (ch))
{
*set++ = ch;
while ((ch = getc (f)) != EOF && ! is_space (ch))
{
if (set - alloc == len)
{
len *= 2;
alloc = xrealloc (alloc, len + 1);
set = alloc + len / 2;
}
*set++ = ch;
}
}
*set = '\0';
ungetc (ch, f);
return alloc;
}
static void
read_name_map (cpp_dir *dir)
{
static const char FILE_NAME_MAP_FILE[] = "header.gcc";
char *name;
FILE *f;
size_t len, count = 0, room = 9;
len = dir->len;
name = alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
memcpy (name, dir->name, len);
if (len && name[len - 1] != '/')
name[len++] = '/';
strcpy (name + len, FILE_NAME_MAP_FILE);
f = fopen (name, "r");
dir->name_map = xmalloc (room * sizeof (char *));
if (f)
{
int ch;
while ((ch = getc (f)) != EOF)
{
char *to;
if (is_space (ch))
continue;
if (count + 2 > room)
{
room += 8;
dir->name_map = xrealloc (dir->name_map, room * sizeof (char *));
}
dir->name_map[count] = read_filename_string (ch, f);
while ((ch = getc (f)) != EOF && is_hspace (ch))
;
to = read_filename_string (ch, f);
if (IS_ABSOLUTE_PATH (to))
dir->name_map[count + 1] = to;
else
{
dir->name_map[count + 1] = append_file_to_dir (to, dir);
free (to);
}
count += 2;
while ((ch = getc (f)) != '\n')
if (ch == EOF)
break;
}
fclose (f);
}
dir->name_map[count] = NULL;
}
static char *
remap_filename (cpp_reader *pfile, _cpp_file *file)
{
const char *fname, *p;
char *new_dir;
cpp_dir *dir;
size_t index, len;
dir = file->dir;
fname = file->name;
for (;;)
{
if (!dir->name_map)
read_name_map (dir);
for (index = 0; dir->name_map[index]; index += 2)
if (!strcmp (dir->name_map[index], fname))
return xstrdup (dir->name_map[index + 1]);
p = strchr (fname, '/');
if (!p || p == fname)
return NULL;
len = dir->len + (p - fname + 1);
new_dir = xmalloc (len + 1);
memcpy (new_dir, dir->name, dir->len);
memcpy (new_dir + dir->len, fname, p - fname + 1);
new_dir[len] = '\0';
dir = make_cpp_dir (pfile, new_dir, dir->sysp);
fname = p + 1;
}
}
static bool
validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
{
const char *saved_path = file->path;
bool valid = false;
file->path = pchname;
if (open_file (file))
{
valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
if (!valid)
{
close (file->fd);
file->fd = -1;
}
if (CPP_OPTION (pfile, print_include_names))
{
unsigned int i;
for (i = 1; i < pfile->line_table->depth; i++)
putc ('.', stderr);
fprintf (stderr, "%c %s\n",
valid ? '!' : 'x', pchname);
}
}
file->path = saved_path;
return valid;
}
const char *
cpp_get_path (struct _cpp_file *f)
{
return f->path;
}
cpp_dir *
cpp_get_dir (struct _cpp_file *f)
{
return f->dir;
}
cpp_buffer *
cpp_get_buffer (cpp_reader *pfile)
{
return pfile->buffer;
}
_cpp_file *
cpp_get_file (cpp_buffer *b)
{
return b->file;
}
cpp_buffer *
cpp_get_prev (cpp_buffer *b)
{
return b->prev;
}
struct pchf_data {
size_t count;
bool have_once_only;
struct pchf_entry {
off_t size;
unsigned char sum[16];
bool once_only;
} entries[1];
};
static struct pchf_data *pchf;
static int
pchf_save_compare (const void *e1, const void *e2)
{
return memcmp (e1, e2, sizeof (struct pchf_entry));
}
bool
_cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
{
size_t count = 0;
struct pchf_data *result;
size_t result_size;
_cpp_file *f;
for (f = pfile->all_files; f; f = f->next_file)
++count;
result_size = (sizeof (struct pchf_data)
+ sizeof (struct pchf_entry) * (count - 1));
result = xcalloc (result_size, 1);
result->count = 0;
result->have_once_only = false;
for (f = pfile->all_files; f; f = f->next_file)
{
size_t count;
if (f->dont_read || f->err_no)
continue;
if (f->stack_count == 0)
continue;
count = result->count++;
result->entries[count].once_only = f->once_only;
result->have_once_only = result->have_once_only | f->once_only;
if (f->buffer_valid)
md5_buffer ((const char *)f->buffer,
f->st.st_size, result->entries[count].sum);
else
{
FILE *ff;
int oldfd = f->fd;
if (!open_file (f))
{
open_file_failed (pfile, f);
return false;
}
ff = fdopen (f->fd, "rb");
md5_stream (ff, result->entries[count].sum);
fclose (ff);
f->fd = oldfd;
}
result->entries[count].size = f->st.st_size;
}
result_size = (sizeof (struct pchf_data)
+ sizeof (struct pchf_entry) * (result->count - 1));
qsort (result->entries, result->count, sizeof (struct pchf_entry),
pchf_save_compare);
return fwrite (result, result_size, 1, fp) == 1;
}
bool
_cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
{
struct pchf_data d;
if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
!= 1)
return false;
pchf = xmalloc (sizeof (struct pchf_data)
+ sizeof (struct pchf_entry) * (d.count - 1));
memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
!= d.count)
return false;
return true;
}
struct pchf_compare_data
{
off_t size;
unsigned char sum[16];
bool sum_computed;
bool check_included;
_cpp_file *f;
};
static int
pchf_compare (const void *d_p, const void *e_p)
{
const struct pchf_entry *e = (const struct pchf_entry *)e_p;
struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
int result;
result = memcmp (&d->size, &e->size, sizeof (off_t));
if (result != 0)
return result;
if (! d->sum_computed)
{
_cpp_file *const f = d->f;
md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
d->sum_computed = true;
}
result = memcmp (d->sum, e->sum, 16);
if (result != 0)
return result;
if (d->check_included || e->once_only)
return 0;
else
return 1;
}
static bool
check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
_cpp_file *f,
bool check_included)
{
struct pchf_compare_data d;
if (pchf == NULL
|| (! check_included && ! pchf->have_once_only))
return false;
d.size = f->st.st_size;
d.sum_computed = false;
d.f = f;
d.check_included = check_included;
return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
pchf_compare) != NULL;
}
static const char message_terminator = '\n';
static int
read_from_parent (int fd, char *buffer, int size)
{
int index = 0;
int result;
if (size <= 0)
return 0;
do {
result = read (fd, &buffer[index], size - index);
if (result <= 0 || index >= size )
return 0;
else
index += result;
} while (buffer[index - 1] != message_terminator);
buffer[index - 1] = '\0';
return 1;
}
static int
write_to_parent (int fd, const char *message)
{
int result;
if (message) {
const int length = strlen (message);
int index = 0;
while (index < length) {
result = write (fd, &message[index], length - index);
if (result < 0)
return 0;
else
index += result;
}
}
result = write (fd, &message_terminator, 1);
if (result < 0)
return 0;
return 1;
}
static int
init_indirect_pipes (int *read_fd, int *write_fd)
{
const char *file_indirect_pipes = getenv ("GCC_INDIRECT_FILES");
const char *protocol_operation = "VERS";
const char *protocol_version = "1";
char response[MAXPATHLEN];
if (!file_indirect_pipes)
return -1;
if (sscanf (file_indirect_pipes, "%d, %d", read_fd, write_fd) != 2)
return -1;
if (write_to_parent (*write_fd, protocol_operation))
if (write_to_parent (*write_fd, protocol_version))
if (read_from_parent (*read_fd, response, MAXPATHLEN))
if (strcmp ("OK", response) == 0)
return 1;
return -1;
}
char *
indirect_file (char *fname, int operation)
{
static int indirection_initialized;
static int read_fd;
static int write_fd;
const char *operation_identifier = NULL;
if (!indirection_initialized)
indirection_initialized = init_indirect_pipes (&read_fd, &write_fd);
if (indirection_initialized != 1)
return fname;
switch (operation)
{
case 0:
operation_identifier = "PULL";
break;
case 1:
operation_identifier = "PUSH";
break;
case 2:
operation_identifier = "BOTH";
break;
default:
return fname;
}
if (write_to_parent (write_fd, operation_identifier))
if (write_to_parent (write_fd, fname))
{
char response[MAXPATHLEN];
if (read_from_parent (read_fd, response, MAXPATHLEN))
fname = xstrdup (response);
}
return fname;
}