1 /* Part of CPP library. (Precompiled header reading/writing.)
2 Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify it
5 under the terms of the GNU General Public License as published by the
6 Free Software Foundation; either version 2, or (at your option) any
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 #include "coretypes.h"
27 static int write_macdef (cpp_reader
*, cpp_hashnode
*, void *);
28 static int save_idents (cpp_reader
*, cpp_hashnode
*, void *);
29 static hashval_t
hashmem (const void *, size_t);
30 static hashval_t
cpp_string_hash (const void *);
31 static int cpp_string_eq (const void *, const void *);
32 static int count_defs (cpp_reader
*, cpp_hashnode
*, void *);
33 static int comp_hashnodes (const void *, const void *);
34 static int collect_ht_nodes (cpp_reader
*, cpp_hashnode
*, void *);
35 static int write_defs (cpp_reader
*, cpp_hashnode
*, void *);
36 static int save_macros (cpp_reader
*, cpp_hashnode
*, void *);
38 /* This structure represents a macro definition on disk. */
39 struct macrodef_struct
41 unsigned int definition_length
;
42 unsigned short name_length
;
46 /* This is how we write out a macro definition.
47 Suitable for being called by cpp_forall_identifiers. */
50 write_macdef (cpp_reader
*pfile
, cpp_hashnode
*hn
, void *file_p
)
52 FILE *f
= (FILE *) file_p
;
56 if (! (hn
->flags
& NODE_POISONED
))
60 if ((hn
->flags
& NODE_BUILTIN
))
64 struct macrodef_struct s
;
65 const unsigned char *defn
;
67 s
.name_length
= NODE_LEN (hn
);
68 s
.flags
= hn
->flags
& NODE_POISONED
;
70 if (hn
->type
== NT_MACRO
)
72 defn
= cpp_macro_definition (pfile
, hn
);
73 s
.definition_length
= ustrlen (defn
);
77 defn
= NODE_NAME (hn
);
78 s
.definition_length
= s
.name_length
;
81 if (fwrite (&s
, sizeof (s
), 1, f
) != 1
82 || fwrite (defn
, 1, s
.definition_length
, f
) != s
.definition_length
)
84 cpp_errno (pfile
, DL_ERROR
, "while writing precompiled header");
91 /* Not currently implemented. */
99 /* This structure records the names of the defined macros.
100 It's also used as a callback structure for size_initial_idents
103 struct cpp_savedstate
105 /* A hash table of the defined identifiers. */
107 /* The size of the definitions of those identifiers (the size of
110 /* Number of definitions */
112 /* Array of definitions. In cpp_write_pch_deps it is used for sorting. */
114 /* Space for the next definition. Definitions are null-terminated
116 unsigned char *definedstrs
;
119 /* Save this identifier into the state: put it in the hash table,
120 put the definition in 'definedstrs'. */
123 save_idents (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
, void *ss_p
)
125 struct cpp_savedstate
*const ss
= (struct cpp_savedstate
*)ss_p
;
127 if (hn
->type
!= NT_VOID
)
129 struct cpp_string news
;
132 news
.len
= NODE_LEN (hn
);
133 news
.text
= NODE_NAME (hn
);
134 slot
= htab_find_slot (ss
->definedhash
, &news
, INSERT
);
137 struct cpp_string
*sp
;
140 sp
= xmalloc (sizeof (struct cpp_string
));
143 sp
->len
= NODE_LEN (hn
);
144 sp
->text
= text
= xmalloc (NODE_LEN (hn
));
145 memcpy (text
, NODE_NAME (hn
), NODE_LEN (hn
));
152 /* Hash some memory in a generic way. */
155 hashmem (const void *p_p
, size_t sz
)
157 const unsigned char *p
= (const unsigned char *)p_p
;
162 for (i
= 0; i
< sz
; i
++)
163 h
= h
* 67 - (*p
++ - 113);
167 /* Hash a cpp string for the hashtable machinery. */
170 cpp_string_hash (const void *a_p
)
172 const struct cpp_string
*a
= (const struct cpp_string
*) a_p
;
173 return hashmem (a
->text
, a
->len
);
176 /* Compare two cpp strings for the hashtable machinery. */
179 cpp_string_eq (const void *a_p
, const void *b_p
)
181 const struct cpp_string
*a
= (const struct cpp_string
*) a_p
;
182 const struct cpp_string
*b
= (const struct cpp_string
*) b_p
;
183 return (a
->len
== b
->len
184 && memcmp (a
->text
, b
->text
, a
->len
) == 0);
187 /* Save the current definitions of the cpp_reader for dependency
188 checking purposes. When writing a precompiled header, this should
189 be called at the same point in the compilation as cpp_valid_state
190 would be called when reading the precompiled header back in. */
193 cpp_save_state (cpp_reader
*r
, FILE *f
)
195 /* Save the list of non-void identifiers for the dependency checking. */
196 r
->savedstate
= xmalloc (sizeof (struct cpp_savedstate
));
197 r
->savedstate
->definedhash
= htab_create (100, cpp_string_hash
,
198 cpp_string_eq
, NULL
);
199 cpp_forall_identifiers (r
, save_idents
, r
->savedstate
);
201 /* Write out the list of defined identifiers. */
202 cpp_forall_identifiers (r
, write_macdef
, f
);
207 /* Calculate the 'hashsize' field of the saved state. */
210 count_defs (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
, void *ss_p
)
212 struct cpp_savedstate
*const ss
= (struct cpp_savedstate
*)ss_p
;
217 if (hn
->flags
& NODE_BUILTIN
)
220 /* else fall through. */
224 struct cpp_string news
;
227 news
.len
= NODE_LEN (hn
);
228 news
.text
= NODE_NAME (hn
);
229 slot
= htab_find (ss
->definedhash
, &news
);
232 ss
->hashsize
+= NODE_LEN (hn
) + 1;
239 /* Not currently implemented. */
247 /* Collect the identifiers into the state's string table. */
249 write_defs (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
, void *ss_p
)
251 struct cpp_savedstate
*const ss
= (struct cpp_savedstate
*)ss_p
;
256 if (hn
->flags
& NODE_BUILTIN
)
259 /* else fall through. */
263 struct cpp_string news
;
266 news
.len
= NODE_LEN (hn
);
267 news
.text
= NODE_NAME (hn
);
268 slot
= htab_find (ss
->definedhash
, &news
);
271 ss
->defs
[ss
->n_defs
] = hn
;
278 /* Not currently implemented. */
286 /* Comparison function for qsort. The arguments point to pointers of
287 type ht_hashnode *. */
289 comp_hashnodes (const void *px
, const void *py
)
291 cpp_hashnode
*x
= *(cpp_hashnode
**) px
;
292 cpp_hashnode
*y
= *(cpp_hashnode
**) py
;
293 return ustrcmp (NODE_NAME (x
), NODE_NAME (y
));
296 /* Write out the remainder of the dependency information. This should be
297 called after the PCH is ready to be saved. */
300 cpp_write_pch_deps (cpp_reader
*r
, FILE *f
)
302 struct macrodef_struct z
;
303 struct cpp_savedstate
*const ss
= r
->savedstate
;
304 unsigned char *definedstrs
;
307 /* Collect the list of identifiers which have been seen and
308 weren't defined to anything previously. */
311 cpp_forall_identifiers (r
, count_defs
, ss
);
313 ss
->defs
= xmalloc (ss
->n_defs
* sizeof (cpp_hashnode
*));
315 cpp_forall_identifiers (r
, write_defs
, ss
);
317 /* Sort the list, copy it into a buffer, and write it out. */
318 qsort (ss
->defs
, ss
->n_defs
, sizeof (cpp_hashnode
*), &comp_hashnodes
);
319 definedstrs
= ss
->definedstrs
= xmalloc (ss
->hashsize
);
320 for (i
= 0; i
< ss
->n_defs
; ++i
)
322 size_t len
= NODE_LEN (ss
->defs
[i
]);
323 memcpy (definedstrs
, NODE_NAME (ss
->defs
[i
]), len
+ 1);
324 definedstrs
+= len
+ 1;
327 memset (&z
, 0, sizeof (z
));
328 z
.definition_length
= ss
->hashsize
;
329 if (fwrite (&z
, sizeof (z
), 1, f
) != 1
330 || fwrite (ss
->definedstrs
, ss
->hashsize
, 1, f
) != 1)
332 cpp_errno (r
, DL_ERROR
, "while writing precompiled header");
335 free (ss
->definedstrs
);
337 /* Free the saved state. */
339 r
->savedstate
= NULL
;
343 /* Write out the definitions of the preprocessor, in a form suitable for
347 cpp_write_pch_state (cpp_reader
*r
, FILE *f
)
349 struct macrodef_struct z
;
351 /* Write out the list of defined identifiers. */
352 cpp_forall_identifiers (r
, write_macdef
, f
);
353 memset (&z
, 0, sizeof (z
));
354 if (fwrite (&z
, sizeof (z
), 1, f
) != 1)
356 cpp_errno (r
, DL_ERROR
, "while writing precompiled header");
361 r
->deps
= deps_init ();
363 if (deps_save (r
->deps
, f
) != 0)
365 cpp_errno (r
, DL_ERROR
, "while writing precompiled header");
373 /* Data structure to transform hash table nodes into a sorted list */
379 /* Number of nodes in the array */
381 /* Size of the allocated array */
385 /* Callback for collecting identifiers from hash table */
388 collect_ht_nodes (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
,
391 struct ht_node_list
*const nl
= (struct ht_node_list
*)nl_p
;
393 if (hn
->type
!= NT_VOID
|| hn
->flags
& NODE_POISONED
)
395 if (nl
->n_defs
== nl
->asize
)
398 nl
->defs
= xrealloc (nl
->defs
, nl
->asize
* sizeof (cpp_hashnode
*));
401 nl
->defs
[nl
->n_defs
] = hn
;
408 /* Return nonzero if FD is a precompiled header which is consistent
409 with the preprocessor's current definitions. It will be consistent
412 - anything that was defined just before the PCH was generated
413 is defined the same way now; and
414 - anything that was not defined then, but is defined now, was not
417 NAME is used to print warnings if `warn_invalid_pch' is set in the
422 cpp_valid_state (cpp_reader
*r
, const char *name
, int fd
)
424 struct macrodef_struct m
;
425 size_t namebufsz
= 256;
426 unsigned char *namebuf
= xmalloc (namebufsz
);
427 unsigned char *undeftab
= NULL
;
428 struct ht_node_list nl
= { 0, 0, 0 };
429 unsigned char *first
, *last
;
432 /* Read in the list of identifiers that must be defined
433 Check that they are defined in the same way. */
437 const unsigned char *newdefn
;
439 if (read (fd
, &m
, sizeof (m
)) != sizeof (m
))
442 if (m
.name_length
== 0)
445 if (m
.definition_length
> namebufsz
)
448 namebufsz
= m
.definition_length
+ 256;
449 namebuf
= xmalloc (namebufsz
);
452 if ((size_t)read (fd
, namebuf
, m
.definition_length
)
453 != m
.definition_length
)
456 h
= cpp_lookup (r
, namebuf
, m
.name_length
);
457 if (m
.flags
& NODE_POISONED
458 || h
->type
!= NT_MACRO
459 || h
->flags
& NODE_POISONED
)
461 if (CPP_OPTION (r
, warn_invalid_pch
))
462 cpp_error (r
, DL_WARNING_SYSHDR
,
463 "%s: not used because `%.*s' not defined",
464 name
, m
.name_length
, namebuf
);
468 newdefn
= cpp_macro_definition (r
, h
);
470 if (m
.definition_length
!= ustrlen (newdefn
)
471 || memcmp (namebuf
, newdefn
, m
.definition_length
) != 0)
473 if (CPP_OPTION (r
, warn_invalid_pch
))
474 cpp_error (r
, DL_WARNING_SYSHDR
,
475 "%s: not used because `%.*s' defined as `%s' not `%.*s'",
476 name
, m
.name_length
, namebuf
, newdefn
+ m
.name_length
,
477 m
.definition_length
- m
.name_length
,
478 namebuf
+ m
.name_length
);
485 /* Read in the list of identifiers that must not be defined.
486 Check that they really aren't. */
487 undeftab
= xmalloc (m
.definition_length
);
488 if ((size_t) read (fd
, undeftab
, m
.definition_length
) != m
.definition_length
)
491 /* Collect identifiers from the current hash table. */
494 nl
.defs
= xmalloc (nl
.asize
* sizeof (cpp_hashnode
*));
495 cpp_forall_identifiers (r
, &collect_ht_nodes
, &nl
);
496 qsort (nl
.defs
, nl
.n_defs
, sizeof (cpp_hashnode
*), &comp_hashnodes
);
498 /* Loop through nl.defs and undeftab, both of which are sorted lists.
499 There should be no matches. */
501 last
= undeftab
+ m
.definition_length
;
504 while (first
< last
&& i
< nl
.n_defs
)
506 int cmp
= ustrcmp (first
, NODE_NAME (nl
.defs
[i
]));
509 first
+= ustrlen (first
) + 1;
523 cpp_errno (r
, DL_ERROR
, "while reading precompiled header");
529 if (undeftab
!= NULL
)
536 /* Save all the existing macros and assertions.
537 This code assumes that there might be hundreds, but not thousands of
538 existing definitions. */
540 struct save_macro_item
{
541 struct save_macro_item
*next
;
542 struct cpp_hashnode macs
[64];
545 struct save_macro_data
547 struct save_macro_item
*macros
;
549 char **saved_pragmas
;
552 /* Save the definition of a single macro, so that it will persist across
556 save_macros (cpp_reader
*r ATTRIBUTE_UNUSED
, cpp_hashnode
*h
, void *data_p
)
558 struct save_macro_data
*data
= (struct save_macro_data
*)data_p
;
559 if (h
->type
!= NT_VOID
560 && (h
->flags
& NODE_BUILTIN
) == 0)
563 if (data
->count
== ARRAY_SIZE (data
->macros
->macs
))
565 struct save_macro_item
*d
= data
->macros
;
566 data
->macros
= xmalloc (sizeof (struct save_macro_item
));
567 data
->macros
->next
= d
;
570 save
= data
->macros
->macs
+ data
->count
;
572 memcpy (save
, h
, sizeof (struct cpp_hashnode
));
573 HT_STR (&save
->ident
) = xmemdup (HT_STR (HT_NODE (save
)),
574 HT_LEN (HT_NODE (save
)),
575 HT_LEN (HT_NODE (save
)) + 1);
580 /* Prepare to restore the state, by saving the currently-defined
584 cpp_prepare_state (cpp_reader
*r
, struct save_macro_data
**data
)
586 struct save_macro_data
*d
= xmalloc (sizeof (struct save_macro_data
));
589 d
->count
= ARRAY_SIZE (d
->macros
->macs
);
590 cpp_forall_identifiers (r
, save_macros
, d
);
591 d
->saved_pragmas
= _cpp_save_pragma_names (r
);
595 /* Given a precompiled header that was previously determined to be valid,
596 apply all its definitions (and undefinitions) to the current state.
597 DEPNAME is passed to deps_restore. */
600 cpp_read_state (cpp_reader
*r
, const char *name
, FILE *f
,
601 struct save_macro_data
*data
)
603 struct macrodef_struct m
;
604 size_t defnlen
= 256;
605 unsigned char *defn
= xmalloc (defnlen
);
606 struct lexer_state old_state
;
607 struct save_macro_item
*d
;
609 int saved_line
= r
->line
;
611 /* Restore spec_nodes, which will be full of references to the old
612 hashtable entries and so will now be invalid. */
614 struct spec_nodes
*s
= &r
->spec_nodes
;
615 s
->n_defined
= cpp_lookup (r
, DSC("defined"));
616 s
->n_true
= cpp_lookup (r
, DSC("true"));
617 s
->n_false
= cpp_lookup (r
, DSC("false"));
618 s
->n__VA_ARGS__
= cpp_lookup (r
, DSC("__VA_ARGS__"));
621 /* Run through the carefully-saved macros, insert them. */
623 mac_count
= data
->count
;
626 struct save_macro_item
*nextd
;
627 for (i
= 0; i
< mac_count
; i
++)
631 h
= cpp_lookup (r
, HT_STR (HT_NODE (&d
->macs
[i
])),
632 HT_LEN (HT_NODE (&d
->macs
[i
])));
633 h
->type
= d
->macs
[i
].type
;
634 h
->flags
= d
->macs
[i
].flags
;
635 h
->value
= d
->macs
[i
].value
;
636 free ((void *)HT_STR (HT_NODE (&d
->macs
[i
])));
641 mac_count
= ARRAY_SIZE (d
->macs
);
644 _cpp_restore_pragma_names (r
, data
->saved_pragmas
);
648 old_state
= r
->state
;
650 r
->state
.in_directive
= 1;
651 r
->state
.prevent_expansion
= 1;
652 r
->state
.angled_headers
= 0;
654 /* Read in the identifiers that must be defined. */
659 if (fread (&m
, sizeof (m
), 1, f
) != 1)
662 if (m
.name_length
== 0)
665 if (defnlen
< m
.definition_length
+ 1)
667 defnlen
= m
.definition_length
+ 256;
668 defn
= xrealloc (defn
, defnlen
);
671 if (fread (defn
, 1, m
.definition_length
, f
) != m
.definition_length
)
673 defn
[m
.definition_length
] = '\n';
675 h
= cpp_lookup (r
, defn
, m
.name_length
);
677 if (h
->type
== NT_MACRO
)
678 _cpp_free_definition (h
);
679 if (m
.flags
& NODE_POISONED
)
680 h
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
681 else if (m
.name_length
!= m
.definition_length
)
683 if (cpp_push_buffer (r
, defn
+ m
.name_length
,
684 m
.definition_length
- m
.name_length
,
688 if (!_cpp_create_definition (r
, h
))
697 r
->state
= old_state
;
698 r
->line
= saved_line
;
702 if (deps_restore (r
->deps
, f
, CPP_OPTION (r
, restore_pch_deps
) ? name
: NULL
)
709 cpp_errno (r
, DL_ERROR
, "while reading precompiled header");