static hashval_t cpp_string_hash PARAMS ((const void *));
static int cpp_string_eq PARAMS ((const void *, const void *));
static int count_defs PARAMS ((cpp_reader *, cpp_hashnode *, void *));
+static int comp_hashnodes PARAMS ((const void *, const void *));
+static int collect_ht_nodes PARAMS ((cpp_reader *, cpp_hashnode *, void *));
static int write_defs PARAMS ((cpp_reader *, cpp_hashnode *, void *));
static int save_macros PARAMS ((cpp_reader *, cpp_hashnode *, void *));
-static int reset_ht PARAMS ((cpp_reader *, cpp_hashnode *, void *));
/* This structure represents a macro definition on disk. */
struct macrodef_struct
/* The size of the definitions of those identifiers (the size of
'definedstrs'). */
size_t hashsize;
+ /* Number of definitions */
+ size_t n_defs;
+ /* Array of definitions. In cpp_write_pch_deps it is used for sorting. */
+ cpp_hashnode **defs;
/* Space for the next definition. Definitions are null-terminated
strings. */
unsigned char *definedstrs;
news.text = NODE_NAME (hn);
slot = htab_find (ss->definedhash, &news);
if (slot == NULL)
- ss->hashsize += NODE_LEN (hn) + 1;
+ {
+ ss->hashsize += NODE_LEN (hn) + 1;
+ ss->n_defs += 1;
+ }
}
return 1;
}
}
-/* Write the identifiers into 'definedstrs' of the state. */
-
+/* Collect the identifiers into the state's string table. */
static int
write_defs (pfile, hn, ss_p)
cpp_reader *pfile ATTRIBUTE_UNUSED;
slot = htab_find (ss->definedhash, &news);
if (slot == NULL)
{
- memcpy (ss->definedstrs, NODE_NAME (hn), NODE_LEN (hn));
- ss->definedstrs[NODE_LEN (hn)] = 0;
- ss->definedstrs += NODE_LEN (hn) + 1;
+ ss->defs[ss->n_defs] = hn;
+ ss->n_defs += 1;
}
}
return 1;
}
}
+/* Comparison function for qsort. The arguments point to pointers of
+ type ht_hashnode *. */
+static int
+comp_hashnodes (px, py)
+ 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));
+}
+
/* Write out the remainder of the dependency information. This should be
called after the PCH is ready to be saved. */
struct macrodef_struct z;
struct cpp_savedstate *const ss = r->savedstate;
unsigned char *definedstrs;
+ size_t i;
- ss->hashsize = 0;
-
- /* Write out the list of identifiers which have been seen and
+ /* Collect the list of identifiers which have been seen and
weren't defined to anything previously. */
+ ss->hashsize = 0;
+ ss->n_defs = 0;
cpp_forall_identifiers (r, count_defs, ss);
- definedstrs = ss->definedstrs = xmalloc (ss->hashsize);
+
+ ss->defs = xmalloc (ss->n_defs * sizeof (cpp_hashnode *));
+ ss->n_defs = 0;
cpp_forall_identifiers (r, write_defs, ss);
+
+ /* Sort the list, copy it into a buffer, and write it out. */
+ 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 (definedstrs, ss->hashsize, 1, f) != 1)
+ || fwrite (ss->definedstrs, ss->hashsize, 1, f) != 1)
{
cpp_errno (r, DL_ERROR, "while writing precompiled header");
return -1;
}
- free (definedstrs);
+ free (ss->definedstrs);
/* Free the saved state. */
free (ss);
return 0;
}
+
+/* Data structure to transform hash table nodes into a sorted list */
+
+struct ht_node_list
+{
+ /* Array of nodes */
+ cpp_hashnode **defs;
+ /* Number of nodes in the array */
+ size_t n_defs;
+ /* Size of the allocated array */
+ size_t asize;
+};
+
+/* Callback for collecting identifiers from hash table */
+
+static int
+collect_ht_nodes (pfile, hn, nl_p)
+ 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;
+}
+
+
/* Return nonzero if FD is a precompiled header which is consistent
with the preprocessor's current definitions. It will be consistent
when:
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;
/* Read in the list of identifiers that must be defined
undeftab = xmalloc (m.definition_length);
if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
goto error;
- for (i = 0; i < m.definition_length; )
+
+ /* Collect identifiers from the current hash table. */
+ 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);
+
+ /* Loop through nl.defs and undeftab, both of which are sorted lists.
+ There should be no matches. */
+ first = undeftab;
+ last = undeftab + m.definition_length;
+ i = 0;
+
+ while (first < last && i < nl.n_defs)
{
- int l = ustrlen (undeftab + i);
- cpp_hashnode *h;
- h = cpp_lookup (r, undeftab + i, l);
- if (h->type != NT_VOID
- || h->flags & NODE_POISONED)
- {
- if (CPP_OPTION (r, warn_invalid_pch))
- cpp_error (r, DL_WARNING_SYSHDR,
- "%s: not used because `%s' is defined",
- name, undeftab + i);
- goto fail;
- }
- i += l + 1;
+ int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
+
+ if (cmp < 0)
+ first += ustrlen (first) + 1;
+ else if (cmp > 0)
+ ++i;
+ else
+ goto fail;
}
+
+ free(nl.defs);
free (undeftab);
/* We win! */
free (namebuf);
if (undeftab != NULL)
free (undeftab);
+ if (nl.defs != NULL)
+ free (nl.defs);
return 1;
}
*data = d;
}
-/* Erase all the existing macros and assertions. */
-
-static int
-reset_ht (r, h, unused)
- cpp_reader *r ATTRIBUTE_UNUSED;
- cpp_hashnode *h;
- void *unused ATTRIBUTE_UNUSED;
-{
- if (h->type != NT_VOID
- && (h->flags & NODE_BUILTIN) == 0)
- {
- h->type = NT_VOID;
- memset (&h->value, 0, sizeof (h->value));
- }
- return 1;
-}
-
/* Given a precompiled header that was previously determined to be valid,
apply all its definitions (and undefinitions) to the current state.
DEPNAME is passed to deps_restore. */
size_t i, mac_count;
int saved_line = r->line;
- /* Erase all the existing hashtable entries for macros. At this
- point, they're all from the PCH file, and their pointers won't be
- valid. */
- cpp_forall_identifiers (r, reset_ht, NULL);
-
/* Restore spec_nodes, which will be full of references to the old
hashtable entries and so will now be invalid. */
{
if (fread (defn, 1, m.definition_length, f) != m.definition_length)
goto error;
- defn[m.definition_length] = '\0';
+ defn[m.definition_length] = '\n';
h = cpp_lookup (r, defn, m.name_length);
m.definition_length - m.name_length,
true, 1) != NULL)
{
+ _cpp_clean_line (r);
if (!_cpp_create_definition (r, h))
abort ();
_cpp_pop_buffer (r);
OSDN Git Service
