#include "config.h"
#include "system.h"
#include "cpplib.h"
#include "internal.h"
#include "hashtab.h"
#include "mkdeps.h"
static int write_macdef (cpp_reader *, cpp_hashnode *, void *);
static int save_idents (cpp_reader *, cpp_hashnode *, void *);
static hashval_t hashmem (const void *, size_t);
static hashval_t cpp_string_hash (const void *);
static int cpp_string_eq (const void *, const void *);
static int count_defs (cpp_reader *, cpp_hashnode *, void *);
static int comp_hashnodes (const void *, const void *);
static int collect_ht_nodes (cpp_reader *, cpp_hashnode *, void *);
static int write_defs (cpp_reader *, cpp_hashnode *, void *);
static int save_macros (cpp_reader *, cpp_hashnode *, void *);
struct macrodef_struct
{
unsigned int definition_length;
unsigned short name_length;
unsigned short flags;
};
static int
write_macdef (cpp_reader *pfile, cpp_hashnode *hn, void *file_p)
{
FILE *f = (FILE *) file_p;
switch (hn->type)
{
case NT_VOID:
if (! (hn->flags & NODE_POISONED))
return 1;
case NT_MACRO:
if ((hn->flags & NODE_BUILTIN))
return 1;
{
struct macrodef_struct s;
const unsigned char *defn;
s.name_length = NODE_LEN (hn);
s.flags = hn->flags & NODE_POISONED;
if (hn->type == NT_MACRO)
{
defn = cpp_macro_definition (pfile, hn);
s.definition_length = ustrlen (defn);
}
else
{
defn = NODE_NAME (hn);
s.definition_length = s.name_length;
}
if (fwrite (&s, sizeof (s), 1, f) != 1
|| fwrite (defn, 1, s.definition_length, f) != s.definition_length)
{
cpp_errno (pfile, CPP_DL_ERROR,
"while writing precompiled header");
return 0;
}
}
return 1;
case NT_ASSERTION:
return 1;
default:
abort ();
}
}
struct cpp_savedstate
{
htab_t definedhash;
size_t hashsize;
size_t n_defs;
cpp_hashnode **defs;
unsigned char *definedstrs;
};
static int
save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
{
struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
if (hn->type != NT_VOID)
{
struct cpp_string news;
void **slot;
news.len = NODE_LEN (hn);
news.text= NODE_NAME (hn);
slot = htab_find_slot (ss->definedhash, &news, INSERT);
if (*slot == NULL)
{
struct cpp_string *sp;
unsigned char *text;
sp = xmalloc (sizeof (struct cpp_string));
*slot = sp;
sp->len = NODE_LEN (hn);
sp->text = text = xmalloc (NODE_LEN (hn));
memcpy (text, NODE_NAME (hn), NODE_LEN (hn));
}
}
return 1;
}
static hashval_t
hashmem (const void *p_p, size_t sz)
{
const unsigned char *p = (const unsigned char *)p_p;
size_t i;
hashval_t h;
h = 0;
for (i = 0; i < sz; i++)
h = h * 67 - (*p++ - 113);
return h;
}
static hashval_t
cpp_string_hash (const void *a_p)
{
const struct cpp_string *a = (const struct cpp_string *) a_p;
return hashmem (a->text, a->len);
}
static int
cpp_string_eq (const void *a_p, const void *b_p)
{
const struct cpp_string *a = (const struct cpp_string *) a_p;
const struct cpp_string *b = (const struct cpp_string *) b_p;
return (a->len == b->len
&& memcmp (a->text, b->text, a->len) == 0);
}
int
cpp_save_state (cpp_reader *r, FILE *f)
{
r->savedstate = xmalloc (sizeof (struct cpp_savedstate));
r->savedstate->definedhash = htab_create (100, cpp_string_hash,
cpp_string_eq, NULL);
cpp_forall_identifiers (r, save_idents, r->savedstate);
cpp_forall_identifiers (r, write_macdef, f);
return 0;
}
static int
count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
{
struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
switch (hn->type)
{
case NT_MACRO:
if (hn->flags & NODE_BUILTIN)
return 1;
case NT_VOID:
{
struct cpp_string news;
void **slot;
if (pfile->cinfo_state == CINFO_WRITE && pfile->cb.is_builtin_identifier)
if (pfile->cb.is_builtin_identifier (hn))
return 1;
news.len = NODE_LEN (hn);
news.text = NODE_NAME (hn);
slot = htab_find (ss->definedhash, &news);
if (slot == NULL)
{
ss->hashsize += NODE_LEN (hn) + 1;
ss->n_defs += 1;
}
}
return 1;
case NT_ASSERTION:
return 1;
default:
abort ();
}
}
static int
write_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
{
struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
switch (hn->type)
{
case NT_MACRO:
if (hn->flags & NODE_BUILTIN)
return 1;
case NT_VOID:
{
struct cpp_string news;
void **slot;
if (pfile->cinfo_state == CINFO_WRITE && pfile->cb.is_builtin_identifier)
if (pfile->cb.is_builtin_identifier (hn))
return 1;
news.len = NODE_LEN (hn);
news.text = NODE_NAME (hn);
slot = htab_find (ss->definedhash, &news);
if (slot == NULL)
{
ss->defs[ss->n_defs] = hn;
ss->n_defs += 1;
}
}
return 1;
case NT_ASSERTION:
return 1;
default:
abort ();
}
}
static int
comp_hashnodes (const void *px, const void *py)
{
cpp_hashnode *x = *(cpp_hashnode **) px;
cpp_hashnode *y = *(cpp_hashnode **) py;
return ustrcmp (NODE_NAME (x), NODE_NAME (y));
}
int
cpp_write_pch_deps (cpp_reader *r, FILE *f)
{
struct macrodef_struct z;
struct cpp_savedstate *const ss = r->savedstate;
unsigned char *definedstrs;
size_t i;
ss->hashsize = 0;
ss->n_defs = 0;
cpp_forall_identifiers (r, count_defs, ss);
ss->defs = xmalloc (ss->n_defs * sizeof (cpp_hashnode *));
ss->n_defs = 0;
cpp_forall_identifiers (r, write_defs, ss);
qsort (ss->defs, ss->n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
definedstrs = ss->definedstrs = xmalloc (ss->hashsize);
for (i = 0; i < ss->n_defs; ++i)
{
size_t len = NODE_LEN (ss->defs[i]);
memcpy (definedstrs, NODE_NAME (ss->defs[i]), len + 1);
definedstrs += len + 1;
}
memset (&z, 0, sizeof (z));
z.definition_length = ss->hashsize;
if (fwrite (&z, sizeof (z), 1, f) != 1
|| fwrite (ss->definedstrs, ss->hashsize, 1, f) != 1)
{
cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
return -1;
}
free (ss->definedstrs);
free (ss);
r->savedstate = NULL;
return 0;
}
int
cpp_write_pch_state (cpp_reader *r, FILE *f)
{
struct macrodef_struct z;
cpp_forall_identifiers (r, write_macdef, f);
memset (&z, 0, sizeof (z));
if (fwrite (&z, sizeof (z), 1, f) != 1)
{
cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
return -1;
}
if (!r->deps)
r->deps = deps_init ();
if (deps_save (r->deps, f) != 0)
{
cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
return -1;
}
if (! _cpp_save_file_entries (r, f))
{
cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
return -1;
}
return 0;
}
struct ht_node_list
{
cpp_hashnode **defs;
size_t n_defs;
size_t asize;
};
static int
collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
void *nl_p)
{
struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
{
if (nl->n_defs == nl->asize)
{
nl->asize *= 2;
nl->defs = xrealloc (nl->defs, nl->asize * sizeof (cpp_hashnode *));
}
nl->defs[nl->n_defs] = hn;
++nl->n_defs;
}
return 1;
}
int
cpp_valid_state (cpp_reader *r, const char *name, int fd)
{
struct macrodef_struct m;
size_t namebufsz = 256;
unsigned char *namebuf = xmalloc (namebufsz);
unsigned char *undeftab = NULL;
struct ht_node_list nl = { 0, 0, 0 };
unsigned char *first, *last;
unsigned int i;
int skip_validation;
skip_validation = CPP_OPTION (r, pch_preprocess)
&& CPP_OPTION (r, preprocessed);
for (;;)
{
cpp_hashnode *h;
const unsigned char *newdefn;
if (read (fd, &m, sizeof (m)) != sizeof (m))
goto error;
if (m.name_length == 0)
break;
if (m.definition_length > namebufsz)
{
free (namebuf);
namebufsz = m.definition_length + 256;
namebuf = xmalloc (namebufsz);
}
if ((size_t)read (fd, namebuf, m.definition_length)
!= m.definition_length)
goto error;
if (skip_validation)
continue;
h = cpp_lookup (r, namebuf, m.name_length);
if (m.flags & NODE_POISONED
|| h->type != NT_MACRO
|| h->flags & NODE_POISONED)
{
if (CPP_OPTION (r, warn_invalid_pch) || CPP_OPTION (r, warn_invalid_sr))
cpp_error (r, CPP_DL_WARNING_SYSHDR,
"%s: not used because `%.*s' not defined",
name, m.name_length, namebuf);
goto fail;
}
newdefn = cpp_macro_definition (r, h);
if (m.definition_length != ustrlen (newdefn)
|| memcmp (namebuf, newdefn, m.definition_length) != 0)
{
if (CPP_OPTION (r, warn_invalid_pch) || CPP_OPTION (r, warn_invalid_sr))
cpp_error (r, CPP_DL_WARNING_SYSHDR,
"%s: not used because `%.*s' defined as `%s' not `%.*s'",
name, m.name_length, namebuf, newdefn + m.name_length,
m.definition_length - m.name_length,
namebuf + m.name_length);
goto fail;
}
}
free (namebuf);
namebuf = NULL;
undeftab = xmalloc (m.definition_length);
if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
goto error;
if (skip_validation)
{
free (undeftab);
return 0;
}
nl.n_defs = 0;
nl.asize = 10;
nl.defs = xmalloc (nl.asize * sizeof (cpp_hashnode *));
cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
first = undeftab;
last = undeftab + m.definition_length;
i = 0;
while (first < last && i < nl.n_defs)
{
int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
if (cmp < 0)
first += ustrlen (first) + 1;
else if (cmp > 0)
++i;
else
{
if (CPP_OPTION (r, warn_invalid_pch) || CPP_OPTION (r, warn_invalid_sr))
cpp_error (r, CPP_DL_WARNING_SYSHDR,
"%s: not used because `%s' is defined",
name, first);
goto fail;
}
}
free(nl.defs);
free (undeftab);
return 0;
error:
cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
return -1;
fail:
if (namebuf != NULL)
free (namebuf);
if (undeftab != NULL)
free (undeftab);
if (nl.defs != NULL)
free (nl.defs);
return 1;
}
struct save_macro_item {
struct save_macro_item *next;
struct cpp_hashnode macs[64];
};
struct save_macro_data
{
struct save_macro_item *macros;
size_t count;
char **saved_pragmas;
};
static int
save_macros (cpp_reader *r ATTRIBUTE_UNUSED, cpp_hashnode *h, void *data_p)
{
struct save_macro_data *data = (struct save_macro_data *)data_p;
if (h->type != NT_VOID
&& (h->flags & NODE_BUILTIN) == 0)
{
cpp_hashnode *save;
if (data->count == ARRAY_SIZE (data->macros->macs))
{
struct save_macro_item *d = data->macros;
data->macros = xmalloc (sizeof (struct save_macro_item));
data->macros->next = d;
data->count = 0;
}
save = data->macros->macs + data->count;
data->count++;
memcpy (save, h, sizeof (struct cpp_hashnode));
HT_STR (&save->ident) = xmemdup (HT_STR (HT_NODE (save)),
HT_LEN (HT_NODE (save)),
HT_LEN (HT_NODE (save)) + 1);
}
return 1;
}
void
cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
{
struct save_macro_data *d = xmalloc (sizeof (struct save_macro_data));
d->macros = NULL;
d->count = ARRAY_SIZE (d->macros->macs);
cpp_forall_identifiers (r, save_macros, d);
d->saved_pragmas = _cpp_save_pragma_names (r);
*data = d;
}
int
cpp_read_state (cpp_reader *r, const char *name, FILE *f,
struct save_macro_data *data)
{
struct macrodef_struct m;
size_t defnlen = 256;
unsigned char *defn = xmalloc (defnlen);
struct lexer_state old_state;
struct save_macro_item *d;
size_t i, mac_count;
void (*saved_line_change) PARAMS ((cpp_reader *, const cpp_token *, int));
saved_line_change = r->cb.line_change;
{
struct spec_nodes *s = &r->spec_nodes;
s->n_defined = cpp_lookup (r, DSC("defined"));
s->n_true = cpp_lookup (r, DSC("true"));
s->n_false = cpp_lookup (r, DSC("false"));
s->n__VA_ARGS__ = cpp_lookup (r, DSC("__VA_ARGS__"));
}
d = data->macros;
mac_count = data->count;
while (d)
{
struct save_macro_item *nextd;
for (i = 0; i < mac_count; i++)
{
cpp_hashnode *h;
h = cpp_lookup (r, HT_STR (HT_NODE (&d->macs[i])),
HT_LEN (HT_NODE (&d->macs[i])));
h->type = d->macs[i].type;
h->flags = d->macs[i].flags;
h->value = d->macs[i].value;
free ((void *)HT_STR (HT_NODE (&d->macs[i])));
}
nextd = d->next;
free (d);
d = nextd;
mac_count = ARRAY_SIZE (d->macs);
}
_cpp_restore_pragma_names (r, data->saved_pragmas);
free (data);
old_state = r->state;
r->state.in_directive = 1;
r->state.prevent_expansion = 1;
r->state.angled_headers = 0;
r->cb.line_change = 0;
for (;;)
{
cpp_hashnode *h;
if (fread (&m, sizeof (m), 1, f) != 1)
goto error;
if (m.name_length == 0)
break;
if (defnlen < m.definition_length + 1)
{
defnlen = m.definition_length + 256;
defn = xrealloc (defn, defnlen);
}
if (fread (defn, 1, m.definition_length, f) != m.definition_length)
goto error;
defn[m.definition_length] = '\n';
h = cpp_lookup (r, defn, m.name_length);
if (h->type == NT_MACRO)
_cpp_free_definition (h);
if (m.flags & NODE_POISONED)
h->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
else if (m.name_length != m.definition_length)
{
if (cpp_push_buffer (r, defn + m.name_length,
m.definition_length - m.name_length, true)
!= NULL)
{
_cpp_clean_line (r);
if (!_cpp_create_definition (r, h))
abort ();
_cpp_pop_buffer (r);
}
else
abort ();
}
}
r->state = old_state;
r->cb.line_change = saved_line_change;
free (defn);
defn = NULL;
if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
!= 0)
goto error;
if (! _cpp_read_file_entries (r, f))
goto error;
return 0;
error:
cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
return -1;
}