/* CPP Library.
Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
Contributed by Per Bothner, 1994-95.
Based on CCCP program by Paul Rubin, June 1986
Adapted to ANSI C, Richard Stallman, Jan 1987
#include "system.h"
#include "cpplib.h"
#include "cpphash.h"
-#include "output.h"
#include "prefix.h"
#include "intl.h"
#include "version.h"
#include "mkdeps.h"
#include "cppdefault.h"
+#include "except.h" /* for USING_SJLJ_EXCEPTIONS */
/* Predefined symbols, built-in macros, and the default include path. */
/* Windows does not natively support inodes, and neither does MSDOS.
Cygwin's emulation can generate non-unique inodes, so don't use it.
- VMS has non-numeric inodes. */
+ VMS has non-numeric inodes. */
#ifdef VMS
-#define INO_T_EQ(a, b) (!memcmp (&(a), &(b), sizeof (a)))
-#elif (defined _WIN32 && ! defined (_UWIN)) || defined __MSDOS__
-#define INO_T_EQ(a, b) 0
+# define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A)))
+# define INO_T_COPY(DEST, SRC) memcpy(&(DEST), &(SRC), sizeof (SRC))
#else
-#define INO_T_EQ(a, b) ((a) == (b))
+# if (defined _WIN32 && ! defined (_UWIN)) || defined __MSDOS__
+# define INO_T_EQ(A, B) 0
+# else
+# define INO_T_EQ(A, B) ((A) == (B))
+# endif
+# define INO_T_COPY(DEST, SRC) (DEST) = (SRC)
#endif
/* Internal structures and prototypes. */
/* A `struct pending_option' remembers one -D, -A, -U, -include, or
-imacros switch. */
-
typedef void (* cl_directive_handler) PARAMS ((cpp_reader *, const char *));
struct pending_option
{
};
/* The `pending' structure accumulates all the options that are not
- actually processed until we hit cpp_start_read. It consists of
+ actually processed until we hit cpp_read_main_file. It consists of
several lists, one for each type of option. We keep both head and
tail pointers for quick insertion. */
struct cpp_pending
{
struct pending_option *directive_head, *directive_tail;
- struct file_name_list *quote_head, *quote_tail;
- struct file_name_list *brack_head, *brack_tail;
- struct file_name_list *systm_head, *systm_tail;
- struct file_name_list *after_head, *after_tail;
+ struct search_path *quote_head, *quote_tail;
+ struct search_path *brack_head, *brack_tail;
+ struct search_path *systm_head, *systm_tail;
+ struct search_path *after_head, *after_tail;
struct pending_option *imacros_head, *imacros_tail;
struct pending_option *include_head, *include_tail;
static void print_help PARAMS ((void));
static void path_include PARAMS ((cpp_reader *,
char *, int));
-static void initialize PARAMS ((void));
-static void initialize_builtins PARAMS ((cpp_reader *));
+static void init_library PARAMS ((void));
+static void init_builtins PARAMS ((cpp_reader *));
static void append_include_chain PARAMS ((cpp_reader *,
char *, int, int));
-struct file_name_list * remove_dup_dir PARAMS ((cpp_reader *,
- struct file_name_list *));
-struct file_name_list * remove_dup_dirs PARAMS ((cpp_reader *,
- struct file_name_list *));
+static struct search_path * remove_dup_dir PARAMS ((cpp_reader *,
+ struct search_path *));
+static struct search_path * remove_dup_dirs PARAMS ((cpp_reader *,
+ struct search_path *));
static void merge_include_chains PARAMS ((cpp_reader *));
-static void do_includes PARAMS ((cpp_reader *,
- struct pending_option *,
- int));
+static bool push_include PARAMS ((cpp_reader *,
+ struct pending_option *));
+static void free_chain PARAMS ((struct pending_option *));
static void set_lang PARAMS ((cpp_reader *, enum c_lang));
-static void initialize_dependency_output PARAMS ((cpp_reader *));
-static void initialize_standard_includes PARAMS ((cpp_reader *));
+static void init_dependency_output PARAMS ((cpp_reader *));
+static void init_standard_includes PARAMS ((cpp_reader *));
+static void read_original_filename PARAMS ((cpp_reader *));
static void new_pending_directive PARAMS ((struct cpp_pending *,
const char *,
cl_directive_handler));
-#ifdef HOST_EBCDIC
-static int opt_comp PARAMS ((const void *, const void *));
-#endif
+static void output_deps PARAMS ((cpp_reader *));
static int parse_option PARAMS ((const char *));
-/* Fourth argument to append_include_chain: chain to use. */
-enum { QUOTE = 0, BRACKET, SYSTEM, AFTER };
+/* Fourth argument to append_include_chain: chain to use.
+ Note it's never asked to append to the quote chain. */
+enum { BRACKET = 0, SYSTEM, AFTER };
/* If we have designated initializers (GCC >2.7) these tables can be
initialized, constant data. Otherwise, they have to be filled in at
/* Given a colon-separated list of file names PATH,
add all the names to the search path for include files. */
-
static void
path_include (pfile, list, path)
cpp_reader *pfile;
while (1);
}
-/* Append DIR to include path PATH. DIR must be permanently allocated
- and writable. */
+/* Append DIR to include path PATH. DIR must be allocated on the
+ heap; this routine takes responsibility for freeing it. CXX_AWARE
+ is non-zero if the header contains extern "C" guards for C++,
+ otherwise it is zero. */
static void
append_include_chain (pfile, dir, path, cxx_aware)
cpp_reader *pfile;
char *dir;
int path;
- int cxx_aware;
+ int cxx_aware ATTRIBUTE_UNUSED;
{
struct cpp_pending *pend = CPP_OPTION (pfile, pending);
- struct file_name_list *new;
+ struct search_path *new;
struct stat st;
unsigned int len;
+ if (*dir == '\0')
+ {
+ free (dir);
+ dir = xstrdup (".");
+ }
_cpp_simplify_pathname (dir);
+
if (stat (dir, &st))
{
- /* Dirs that don't exist are silently ignored. */
+ /* Dirs that don't exist are silently ignored. */
if (errno != ENOENT)
cpp_notice_from_errno (pfile, dir);
else if (CPP_OPTION (pfile, verbose))
fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"), dir);
+ free (dir);
return;
}
if (!S_ISDIR (st.st_mode))
{
cpp_notice (pfile, "%s: Not a directory", dir);
+ free (dir);
return;
}
if (len > pfile->max_include_len)
pfile->max_include_len = len;
- new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
+ new = (struct search_path *) xmalloc (sizeof (struct search_path));
new->name = dir;
- new->nlen = len;
- new->ino = st.st_ino;
+ new->len = len;
+ INO_T_COPY (new->ino, st.st_ino);
new->dev = st.st_dev;
- if (path == SYSTEM)
+ /* Both systm and after include file lists should be treated as system
+ include files since these two lists are really just a concatenation
+ of one "system" list. */
+ if (path == SYSTEM || path == AFTER)
+#ifdef NO_IMPLICIT_EXTERN_C
+ new->sysp = 1;
+#else
new->sysp = cxx_aware ? 1 : 2;
+#endif
else
new->sysp = 0;
new->name_map = NULL;
new->next = NULL;
- new->alloc = NULL;
switch (path)
{
- case QUOTE: APPEND (pend, quote, new); break;
case BRACKET: APPEND (pend, brack, new); break;
case SYSTEM: APPEND (pend, systm, new); break;
case AFTER: APPEND (pend, after, new); break;
/* Handle a duplicated include path. PREV is the link in the chain
before the duplicate. The duplicate is removed from the chain and
freed. Returns PREV. */
-struct file_name_list *
+static struct search_path *
remove_dup_dir (pfile, prev)
cpp_reader *pfile;
- struct file_name_list *prev;
+ struct search_path *prev;
{
- struct file_name_list *cur = prev->next;
+ struct search_path *cur = prev->next;
if (CPP_OPTION (pfile, verbose))
fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), cur->name);
prev->next = cur->next;
- free (cur->name);
+ free ((PTR) cur->name);
free (cur);
return prev;
chain, or NULL if the chain is empty. This algorithm is quadratic
in the number of -I switches, which is acceptable since there
aren't usually that many of them. */
-struct file_name_list *
+static struct search_path *
remove_dup_dirs (pfile, head)
cpp_reader *pfile;
- struct file_name_list *head;
+ struct search_path *head;
{
- struct file_name_list *prev = NULL, *cur, *other;
+ struct search_path *prev = NULL, *cur, *other;
for (cur = head; cur; cur = cur->next)
{
for (other = head; other != cur; other = other->next)
if (INO_T_EQ (cur->ino, other->ino) && cur->dev == other->dev)
{
+ if (cur->sysp && !other->sysp)
+ {
+ cpp_warning (pfile,
+ "changing search order for system directory \"%s\"",
+ cur->name);
+ if (strcmp (cur->name, other->name))
+ cpp_warning (pfile,
+ " as it is the same as non-system directory \"%s\"",
+ other->name);
+ else
+ cpp_warning (pfile,
+ " as it has already been specified as a non-system directory");
+ }
cur = remove_dup_dir (pfile, prev);
break;
}
system, after. Remove duplicate dirs (as determined by
INO_T_EQ()). The system_include and after_include chains are never
referred to again after this function; all access is through the
- bracket_include path.
-
- For the future: Check if the directory is empty (but
- how?) and possibly preload the include hash. */
-
+ bracket_include path. */
static void
merge_include_chains (pfile)
cpp_reader *pfile;
{
- struct file_name_list *quote, *brack, *systm, *qtail;
+ struct search_path *quote, *brack, *systm, *qtail;
struct cpp_pending *pend = CPP_OPTION (pfile, pending);
/* This is a bit tricky. First we drop dupes from the quote-include
list. Then we drop dupes from the bracket-include list.
Finally, if qtail and brack are the same directory, we cut out
- brack.
+ brack and move brack up to point to qtail.
We can't just merge the lists and then uniquify them because
then we may lose directories from the <> search path that should
brack = remove_dup_dir (pfile, qtail);
}
else
- quote = brack;
+ quote = brack;
CPP_OPTION (pfile, quote_include) = quote;
CPP_OPTION (pfile, bracket_include) = brack;
}
-/* Sets internal flags correctly for a given language, and defines
- macros if necessary. */
+/* A set of booleans indicating what CPP features each source language
+ requires. */
+struct lang_flags
+{
+ char c99;
+ char objc;
+ char cplusplus;
+ char extended_numbers;
+ char trigraphs;
+ char dollars_in_ident;
+ char cplusplus_comments;
+ char digraphs;
+};
+
+/* ??? Enable $ in identifiers in assembly? */
+static const struct lang_flags lang_defaults[] =
+{ /* c99 objc c++ xnum trig dollar c++comm digr */
+ /* GNUC89 */ { 0, 0, 0, 1, 0, 1, 1, 1 },
+ /* GNUC99 */ { 1, 0, 0, 1, 0, 1, 1, 1 },
+ /* STDC89 */ { 0, 0, 0, 0, 1, 0, 0, 0 },
+ /* STDC94 */ { 0, 0, 0, 0, 1, 0, 0, 1 },
+ /* STDC99 */ { 1, 0, 0, 1, 1, 0, 1, 1 },
+ /* GNUCXX */ { 0, 0, 1, 1, 0, 1, 1, 1 },
+ /* CXX98 */ { 0, 0, 1, 1, 1, 0, 1, 1 },
+ /* OBJC */ { 0, 1, 0, 1, 0, 1, 1, 1 },
+ /* OBJCXX */ { 0, 1, 1, 1, 0, 1, 1, 1 },
+ /* ASM */ { 0, 0, 0, 1, 0, 0, 1, 0 }
+};
+
+/* Sets internal flags correctly for a given language. */
static void
set_lang (pfile, lang)
cpp_reader *pfile;
enum c_lang lang;
{
- struct cpp_pending *pend = CPP_OPTION (pfile, pending);
-
- /* Defaults. */
+ const struct lang_flags *l = &lang_defaults[(int) lang];
+
CPP_OPTION (pfile, lang) = lang;
- CPP_OPTION (pfile, objc) = 0;
- CPP_OPTION (pfile, cplusplus) = 0;
- CPP_OPTION (pfile, extended_numbers) = 1; /* Allowed in GNU C and C99. */
-
- switch (lang)
- {
- /* GNU C. */
- case CLK_GNUC99:
- CPP_OPTION (pfile, trigraphs) = 0;
- CPP_OPTION (pfile, dollars_in_ident) = 1;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, digraphs) = 1;
- CPP_OPTION (pfile, c99) = 1;
- new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
- break;
- case CLK_GNUC89:
- CPP_OPTION (pfile, trigraphs) = 0;
- CPP_OPTION (pfile, dollars_in_ident) = 1;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, digraphs) = 1;
- CPP_OPTION (pfile, c99) = 0;
- break;
-
- /* ISO C. */
- case CLK_STDC94:
- new_pending_directive (pend, "__STDC_VERSION__=199409L", cpp_define);
- case CLK_STDC89:
- CPP_OPTION (pfile, trigraphs) = 1;
- CPP_OPTION (pfile, dollars_in_ident) = 0;
- CPP_OPTION (pfile, cplusplus_comments) = 0;
- CPP_OPTION (pfile, digraphs) = lang == CLK_STDC94;
- CPP_OPTION (pfile, c99) = 0;
- CPP_OPTION (pfile, extended_numbers) = 0;
- new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
- break;
- case CLK_STDC99:
- CPP_OPTION (pfile, trigraphs) = 1;
- CPP_OPTION (pfile, dollars_in_ident) = 0;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, digraphs) = 1;
- CPP_OPTION (pfile, c99) = 1;
- new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
- new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
- break;
- /* Objective C. */
- case CLK_OBJCXX:
- new_pending_directive (pend, "__cplusplus", cpp_define);
- CPP_OPTION (pfile, cplusplus) = 1;
- case CLK_OBJC:
- CPP_OPTION (pfile, trigraphs) = 0;
- CPP_OPTION (pfile, dollars_in_ident) = 1;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, digraphs) = 1;
- CPP_OPTION (pfile, c99) = 0;
- CPP_OPTION (pfile, objc) = 1;
- new_pending_directive (pend, "__OBJC__", cpp_define);
- break;
+ CPP_OPTION (pfile, c99) = l->c99;
+ CPP_OPTION (pfile, objc) = l->objc;
+ CPP_OPTION (pfile, cplusplus) = l->cplusplus;
+ CPP_OPTION (pfile, extended_numbers) = l->extended_numbers;
+ CPP_OPTION (pfile, trigraphs) = l->trigraphs;
+ CPP_OPTION (pfile, dollars_in_ident) = l->dollars_in_ident;
+ CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
+ CPP_OPTION (pfile, digraphs) = l->digraphs;
+}
- /* C++. */
- case CLK_GNUCXX:
- case CLK_CXX98:
- CPP_OPTION (pfile, cplusplus) = 1;
- CPP_OPTION (pfile, trigraphs) = lang == CLK_CXX98;
- CPP_OPTION (pfile, dollars_in_ident) = lang == CLK_GNUCXX;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, digraphs) = 1;
- CPP_OPTION (pfile, c99) = 0;
- new_pending_directive (pend, "__cplusplus", cpp_define);
- break;
+#ifdef HOST_EBCDIC
+static int opt_comp PARAMS ((const void *, const void *));
- /* Assembler. */
- case CLK_ASM:
- CPP_OPTION (pfile, trigraphs) = 0;
- CPP_OPTION (pfile, dollars_in_ident) = 0; /* Maybe not? */
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, digraphs) = 0;
- CPP_OPTION (pfile, c99) = 0;
- new_pending_directive (pend, "__ASSEMBLER__", cpp_define);
- break;
- }
+/* Run-time sorting of options array. */
+static int
+opt_comp (p1, p2)
+ const void *p1, *p2;
+{
+ return strcmp (((struct cl_option *) p1)->opt_text,
+ ((struct cl_option *) p2)->opt_text);
}
+#endif
-/* initialize initializes library global state. It might not need to
+/* init initializes library global state. It might not need to
do anything depending on the platform and compiler. */
-
-static int initialized = 0;
-
static void
-initialize ()
+init_library ()
{
+ static int initialized = 0;
+
+ if (! initialized)
+ {
+ initialized = 1;
+
#ifdef HOST_EBCDIC
- /* For non-ASCII hosts, the cl_options array needs to be sorted at
- runtime. */
- qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
+ /* For non-ASCII hosts, the cl_options array needs to be sorted at
+ runtime. */
+ qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
#endif
- /* Set up the trigraph map. This doesn't need to do anything if we were
- compiled with a compiler that supports C99 designated initializers. */
- init_trigraph_map ();
-
- initialized = 1;
+ /* Set up the trigraph map. This doesn't need to do anything if
+ we were compiled with a compiler that supports C99 designated
+ initializers. */
+ init_trigraph_map ();
+ }
}
-/* Initialize a cpp_reader structure. */
+/* Initialize a cpp_reader structure. */
cpp_reader *
cpp_create_reader (lang)
enum c_lang lang;
{
- struct spec_nodes *s;
- cpp_reader *pfile = (cpp_reader *) xcalloc (1, sizeof (cpp_reader));
+ cpp_reader *pfile;
/* Initialise this instance of the library if it hasn't been already. */
- if (! initialized)
- initialize ();
+ init_library ();
+ pfile = (cpp_reader *) xcalloc (1, sizeof (cpp_reader));
+
+ set_lang (pfile, lang);
CPP_OPTION (pfile, warn_import) = 1;
CPP_OPTION (pfile, discard_comments) = 1;
CPP_OPTION (pfile, show_column) = 1;
CPP_OPTION (pfile, pending) =
(struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
- /* After creating pfile->pending. */
- set_lang (pfile, lang);
-
/* It's simplest to just create this struct whether or not it will
be needed. */
pfile->deps = deps_init ();
+ /* Initialise the line map. Start at logical line 1, so we can use
+ a line number of zero for special states. */
+ init_line_maps (&pfile->line_maps);
+ pfile->line = 1;
+
/* Initialize lexer state. */
pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
- /* Indicate date and time not yet calculated. */
+ /* Set up static tokens. */
pfile->date.type = CPP_EOF;
+ pfile->avoid_paste.type = CPP_PADDING;
+ pfile->avoid_paste.val.source = NULL;
+ pfile->eof.type = CPP_EOF;
+ pfile->eof.flags = 0;
+
+ /* Create a token buffer for the lexer. */
+ _cpp_init_tokenrun (&pfile->base_run, 250);
+ pfile->cur_run = &pfile->base_run;
+ pfile->cur_token = pfile->base_run.base;
/* Initialise the base context. */
pfile->context = &pfile->base_context;
pfile->base_context.macro = 0;
pfile->base_context.prev = pfile->base_context.next = 0;
- /* Identifier pool initially 8K. Unaligned, permanent pool. */
- _cpp_init_pool (&pfile->ident_pool, 8 * 1024, 1, 0);
-
- /* Argument pool initially 8K. Aligned, temporary pool. */
- _cpp_init_pool (&pfile->argument_pool, 8 * 1024, 0, 1);
+ /* Aligned and unaligned storage. */
+ pfile->a_buff = _cpp_get_buff (pfile, 0);
+ pfile->u_buff = _cpp_get_buff (pfile, 0);
- /* Macro pool initially 8K. Aligned, permanent pool. */
- _cpp_init_pool (&pfile->macro_pool, 8 * 1024, 0, 0);
+ /* Initialise the buffer obstack. */
+ gcc_obstack_init (&pfile->buffer_ob);
- _cpp_init_hashtable (pfile);
- _cpp_init_stacks (pfile);
_cpp_init_includes (pfile);
- _cpp_init_internal_pragmas (pfile);
-
- /* Initialize the special nodes. */
- s = &pfile->spec_nodes;
- s->n_L = cpp_lookup (pfile, DSC("L"));
- s->n_defined = cpp_lookup (pfile, DSC("defined"));
- s->n__Pragma = cpp_lookup (pfile, DSC("_Pragma"));
- s->n__STRICT_ANSI__ = cpp_lookup (pfile, DSC("__STRICT_ANSI__"));
- s->n__CHAR_UNSIGNED__ = cpp_lookup (pfile, DSC("__CHAR_UNSIGNED__"));
- s->n__VA_ARGS__ = cpp_lookup (pfile, DSC("__VA_ARGS__"));
- s->n__VA_ARGS__->flags |= NODE_DIAGNOSTIC;
return pfile;
}
-/* Free resources used by PFILE.
- This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology). */
-void
-cpp_cleanup (pfile)
+/* Free resources used by PFILE. Accessing PFILE after this function
+ returns leads to undefined behaviour. Returns the error count. */
+int
+cpp_destroy (pfile)
cpp_reader *pfile;
{
- struct file_name_list *dir, *dirn;
+ int result;
+ struct search_path *dir, *dirn;
cpp_context *context, *contextn;
+ tokenrun *run, *runn;
while (CPP_BUFFER (pfile) != NULL)
- cpp_pop_buffer (pfile);
+ _cpp_pop_buffer (pfile);
if (pfile->macro_buffer)
- free ((PTR) pfile->macro_buffer);
+ {
+ free ((PTR) pfile->macro_buffer);
+ pfile->macro_buffer = NULL;
+ pfile->macro_buffer_len = 0;
+ }
deps_free (pfile->deps);
+ obstack_free (&pfile->buffer_ob, 0);
+ _cpp_destroy_hashtable (pfile);
_cpp_cleanup_includes (pfile);
- _cpp_cleanup_stacks (pfile);
- _cpp_cleanup_hashtable (pfile);
- _cpp_free_lookaheads (pfile);
+ _cpp_free_buff (pfile->a_buff);
+ _cpp_free_buff (pfile->u_buff);
+ _cpp_free_buff (pfile->free_buffs);
- _cpp_free_pool (&pfile->ident_pool);
- _cpp_free_pool (&pfile->macro_pool);
- _cpp_free_pool (&pfile->argument_pool);
+ for (run = &pfile->base_run; run; run = runn)
+ {
+ runn = run->next;
+ free (run->base);
+ if (run != &pfile->base_run)
+ free (run);
+ }
for (dir = CPP_OPTION (pfile, quote_include); dir; dir = dirn)
{
dirn = dir->next;
- free (dir->name);
+ free ((PTR) dir->name);
free (dir);
}
contextn = context->next;
free (context);
}
+
+ free_line_maps (&pfile->line_maps);
+
+ result = pfile->errors;
+ free (pfile);
+
+ return result;
}
/* This structure defines one built-in identifier. A node will be
entered in the hash table under the name NAME, with value VALUE (if
any). If flags has OPERATOR, the node's operator field is used; if
- flags has BUILTIN the node's builtin field is used.
+ flags has BUILTIN the node's builtin field is used. Macros that are
+ known at build time should not be flagged BUILTIN, as then they do
+ not appear in macro dumps with e.g. -dM or -dD.
Two values are not compile time constants, so we tag
them in the FLAGS field instead:
ULP value is the global user_label_prefix
Also, macros with CPLUS set in the flags field are entered only for C++. */
-
struct builtin
{
const U_CHAR *name;
B("__BASE_FILE__", BT_BASE_FILE),
B("__LINE__", BT_SPECLINE),
B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
- B("__STDC__", BT_STDC),
+ B("_Pragma", BT_PRAGMA),
X("__VERSION__", VERS),
X("__USER_LABEL_PREFIX__", ULP),
C("__REGISTER_PREFIX__", REGISTER_PREFIX),
C("__HAVE_BUILTIN_SETJMP__", "1"),
+#if USING_SJLJ_EXCEPTIONS
+ /* libgcc needs to know this. */
+ C("__USING_SJLJ_EXCEPTIONS__","1"),
+#endif
#ifndef NO_BUILTIN_SIZE_TYPE
C("__SIZE_TYPE__", SIZE_TYPE),
#endif
#ifndef NO_BUILTIN_WINT_TYPE
C("__WINT_TYPE__", WINT_TYPE),
#endif
+#ifdef STDC_0_IN_SYSTEM_HEADERS
+ B("__STDC__", BT_STDC),
+#else
+ C("__STDC__", "1"),
+#endif
/* Named operators known to the preprocessor. These cannot be #defined
and always have their stated meaning. They are treated like normal
#define builtin_array_end \
builtin_array + sizeof(builtin_array)/sizeof(struct builtin)
-/* Subroutine of cpp_start_read; reads the builtins table above and
- enters the macros into the hash table. */
+/* Subroutine of cpp_read_main_file; reads the builtins table above and
+ enters them, and language-specific macros, into the hash table. */
static void
-initialize_builtins (pfile)
+init_builtins (pfile)
cpp_reader *pfile;
{
const struct builtin *b;
else
{
hp->type = NT_MACRO;
- hp->flags |= NODE_BUILTIN;
+ hp->flags |= NODE_BUILTIN | NODE_WARN;
hp->value.builtin = b->builtin;
}
}
_cpp_define_builtin (pfile, str);
}
}
+
+ if (CPP_OPTION (pfile, cplusplus))
+ {
+ _cpp_define_builtin (pfile, "__cplusplus 1");
+ if (SUPPORTS_ONE_ONLY)
+ _cpp_define_builtin (pfile, "__GXX_WEAK__ 1");
+ else
+ _cpp_define_builtin (pfile, "__GXX_WEAK__ 0");
+ }
+ if (CPP_OPTION (pfile, objc))
+ _cpp_define_builtin (pfile, "__OBJC__ 1");
+
+ if (CPP_OPTION (pfile, lang) == CLK_STDC94)
+ _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
+ else if (CPP_OPTION (pfile, c99))
+ _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
+
+ if (CPP_OPTION (pfile, lang) == CLK_STDC89
+ || CPP_OPTION (pfile, lang) == CLK_STDC94
+ || CPP_OPTION (pfile, lang) == CLK_STDC99)
+ _cpp_define_builtin (pfile, "__STRICT_ANSI__ 1");
+ else if (CPP_OPTION (pfile, lang) == CLK_ASM)
+ _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
}
#undef BUILTIN
#undef OPERATOR
#undef CPLUS
#undef builtin_array_end
-/* Another subroutine of cpp_start_read. This one sets up to do
- dependency-file output. */
-static void
-initialize_dependency_output (pfile)
- cpp_reader *pfile;
-{
- char *spec, *s, *output_file;
-
- /* Either of two environment variables can specify output of deps.
- Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
- where OUTPUT_FILE is the file to write deps info to
- and DEPS_TARGET is the target to mention in the deps. */
-
- if (CPP_OPTION (pfile, print_deps) == 0)
- {
- spec = getenv ("DEPENDENCIES_OUTPUT");
- if (spec)
- CPP_OPTION (pfile, print_deps) = 1;
- else
- {
- spec = getenv ("SUNPRO_DEPENDENCIES");
- if (spec)
- CPP_OPTION (pfile, print_deps) = 2;
- else
- return;
- }
-
- /* Find the space before the DEPS_TARGET, if there is one. */
- s = strchr (spec, ' ');
- if (s)
- {
- /* Let the caller perform MAKE quoting. */
- deps_add_target (pfile->deps, s + 1, 0);
- output_file = (char *) xmalloc (s - spec + 1);
- memcpy (output_file, spec, s - spec);
- output_file[s - spec] = 0;
- }
- else
- output_file = spec;
-
- CPP_OPTION (pfile, deps_file) = output_file;
- CPP_OPTION (pfile, print_deps_append) = 1;
- }
-
- /* Set the default target (if there is none already). */
- deps_add_default_target (pfile->deps, CPP_OPTION (pfile, in_fname));
-
- if (CPP_OPTION (pfile, in_fname))
- deps_add_dep (pfile->deps, CPP_OPTION (pfile, in_fname));
-}
-
/* And another subroutine. This one sets up the standard include path. */
static void
-initialize_standard_includes (pfile)
+init_standard_includes (pfile)
cpp_reader *pfile;
{
char *path;
if (specd_prefix != 0 && cpp_GCC_INCLUDE_DIR_len)
{
/* Remove the `include' from /usr/local/lib/gcc.../include.
- GCC_INCLUDE_DIR will always end in /include. */
+ GCC_INCLUDE_DIR will always end in /include. */
int default_len = cpp_GCC_INCLUDE_DIR_len;
char *default_prefix = (char *) alloca (default_len + 1);
int specd_len = strlen (specd_prefix);
|| (CPP_OPTION (pfile, cplusplus)
&& !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
{
- char *str = xstrdup (update_path (p->fname, p->component));
+ char *str = update_path (p->fname, p->component);
append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
}
}
}
-/* Handles -imacro and -include from the command line. */
-static void
-do_includes (pfile, p, scan)
+/* Pushes a command line -imacro and -include file indicated by P onto
+ the buffer stack. Returns non-zero if successful. */
+static bool
+push_include (pfile, p)
cpp_reader *pfile;
struct pending_option *p;
- int scan;
{
- while (p)
+ cpp_token header;
+
+ /* Later: maybe update this to use the #include "" search path
+ if cpp_read_file fails. */
+ header.type = CPP_STRING;
+ header.val.str.text = (const unsigned char *) p->arg;
+ header.val.str.len = strlen (p->arg);
+ /* Make the command line directive take up a line. */
+ pfile->line++;
+
+ return _cpp_execute_include (pfile, &header, IT_CMDLINE);
+}
+
+/* Frees a pending_option chain. */
+static void
+free_chain (head)
+ struct pending_option *head;
+{
+ struct pending_option *next;
+
+ while (head)
{
- struct pending_option *q;
-
- /* Later: maybe update this to use the #include "" search path
- if cpp_read_file fails. */
- if (_cpp_read_file (pfile, p->arg) && scan)
- cpp_scan_buffer_nooutput (pfile, 0);
- q = p->next;
- free (p);
- p = q;
+ next = head->next;
+ free (head);
+ head = next;
}
}
-/* This is called after options have been processed. Check options
- for consistency, and setup for processing input from the file named
- FNAME. (Use standard input if FNAME == NULL.) Return 1 on success,
- 0 on failure. */
-
-int
-cpp_start_read (pfile, fname)
+/* This is called after options have been parsed, and partially
+ processed. Setup for processing input from the file named FNAME,
+ or stdin if it is the empty string. Return the original filename
+ on success (e.g. foo.i->foo.c), or NULL on failure. */
+const char *
+cpp_read_main_file (pfile, fname, table)
cpp_reader *pfile;
const char *fname;
+ hash_table *table;
{
- struct pending_option *p, *q;
-
- /* -MG doesn't select the form of output and must be specified with one of
- -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
- inhibit compilation. */
- if (CPP_OPTION (pfile, print_deps_missing_files)
- && (CPP_OPTION (pfile, print_deps) == 0
- || !CPP_OPTION (pfile, no_output)))
- {
- cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
- return 0;
- }
-
- /* -Wtraditional is not useful in C++ mode. */
- if (CPP_OPTION (pfile, cplusplus))
- CPP_OPTION (pfile, warn_traditional) = 0;
-
- /* Set this if it hasn't been set already. */
- if (CPP_OPTION (pfile, user_label_prefix) == NULL)
- CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
+ /* The front ends don't set up the hash table until they have
+ finished processing the command line options, so initializing the
+ hashtable is deferred until now. */
+ _cpp_init_hashtable (pfile, table);
/* Set up the include search path now. */
if (! CPP_OPTION (pfile, no_standard_includes))
- initialize_standard_includes (pfile);
+ init_standard_includes (pfile);
merge_include_chains (pfile);
/* With -v, print the list of dirs to search. */
if (CPP_OPTION (pfile, verbose))
{
- struct file_name_list *l;
+ struct search_path *l;
fprintf (stderr, _("#include \"...\" search starts here:\n"));
for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
{
fprintf (stderr, _("End of search list.\n"));
}
- /* Open the main input file. This must be done early, so we have a
- buffer to stand on. */
- if (CPP_OPTION (pfile, in_fname) == NULL
- || *CPP_OPTION (pfile, in_fname) == 0)
- {
- CPP_OPTION (pfile, in_fname) = fname;
- if (CPP_OPTION (pfile, in_fname) == NULL)
- CPP_OPTION (pfile, in_fname) = "";
- }
- if (CPP_OPTION (pfile, out_fname) == NULL)
- CPP_OPTION (pfile, out_fname) = "";
+ if (CPP_OPTION (pfile, print_deps))
+ /* Set the default target (if there is none already). */
+ deps_add_default_target (pfile->deps, fname);
+ /* Open the main input file. */
if (!_cpp_read_file (pfile, fname))
- return 0;
+ return NULL;
- initialize_dependency_output (pfile);
+ /* Set this after cpp_post_options so the client can change the
+ option if it wishes, and after stacking the main file so we don't
+ trace the main file. */
+ pfile->line_maps.trace_includes = CPP_OPTION (pfile, print_include_names);
- /* Install __LINE__, etc. */
- initialize_builtins (pfile);
+ /* For foo.i, read the original filename foo.c now, for the benefit
+ of the front ends. */
+ if (CPP_OPTION (pfile, preprocessed))
+ read_original_filename (pfile);
- /* Do -U's, -D's and -A's in the order they were seen. */
- p = CPP_OPTION (pfile, pending)->directive_head;
- while (p)
- {
- (*p->handler) (pfile, p->arg);
- q = p->next;
- free (p);
- p = q;
- }
- pfile->done_initializing = 1;
+ return pfile->map->to_file;
+}
+
+/* For preprocessed files, if the first tokens are of the form # NUM.
+ handle the directive so we know the original file name. This will
+ generate file_change callbacks, which the front ends must handle
+ appropriately given their state of initialization. */
+static void
+read_original_filename (pfile)
+ cpp_reader *pfile;
+{
+ const cpp_token *token, *token1;
- /* The -imacros files can be scanned now, but the -include files
- have to be pushed onto the buffer stack and processed later,
- otherwise cppmain.c won't see the tokens. include_head was built
- up as a stack, and popping this stack onto the buffer stack means
- we preserve the order of the command line. */
- do_includes (pfile, CPP_OPTION (pfile, pending)->imacros_head, 1);
- do_includes (pfile, CPP_OPTION (pfile, pending)->include_head, 0);
+ /* Lex ahead; if the first tokens are of the form # NUM, then
+ process the directive, otherwise back up. */
+ token = _cpp_lex_direct (pfile);
+ if (token->type == CPP_HASH)
+ {
+ token1 = _cpp_lex_direct (pfile);
+ _cpp_backup_tokens (pfile, 1);
- free (CPP_OPTION (pfile, pending));
- CPP_OPTION (pfile, pending) = NULL;
+ /* If it's a #line directive, handle it. */
+ if (token1->type == CPP_NUMBER)
+ {
+ _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
+ return;
+ }
+ }
- return 1;
+ /* Backup as if nothing happened. */
+ _cpp_backup_tokens (pfile, 1);
}
-/* This is called at the end of preprocessing. It pops the
- last buffer and writes dependency output. It should also
- clear macro definitions, such that you could call cpp_start_read
- with a new filename to restart processing. */
+/* Handle pending command line options: -D, -U, -A, -imacros and
+ -include. This should be called after debugging has been properly
+ set up in the front ends. */
void
-cpp_finish (pfile)
+cpp_finish_options (pfile)
cpp_reader *pfile;
{
- if (CPP_BUFFER (pfile))
+ /* Install builtins and process command line macros etc. in the order
+ they appeared, but only if not already preprocessed. */
+ if (! CPP_OPTION (pfile, preprocessed))
{
- cpp_ice (pfile, "buffers still stacked in cpp_finish");
- while (CPP_BUFFER (pfile))
- cpp_pop_buffer (pfile);
+ struct pending_option *p;
+
+ _cpp_do_file_change (pfile, LC_RENAME, _("<built-in>"), 1, 0);
+ init_builtins (pfile);
+ _cpp_do_file_change (pfile, LC_RENAME, _("<command line>"), 1, 0);
+ for (p = CPP_OPTION (pfile, pending)->directive_head; p; p = p->next)
+ (*p->handler) (pfile, p->arg);
+
+ /* Scan -imacros files after command line defines, but before
+ files given with -include. */
+ while ((p = CPP_OPTION (pfile, pending)->imacros_head) != NULL)
+ {
+ if (push_include (pfile, p))
+ {
+ pfile->buffer->return_at_eof = true;
+ cpp_scan_nooutput (pfile);
+ }
+ CPP_OPTION (pfile, pending)->imacros_head = p->next;
+ free (p);
+ }
}
- /* Don't write the deps file if preprocessing has failed. */
- if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
+ free_chain (CPP_OPTION (pfile, pending)->directive_head);
+ _cpp_push_next_buffer (pfile);
+}
+
+/* Called to push the next buffer on the stack given by -include. If
+ there are none, free the pending structure and restore the line map
+ for the main file. */
+bool
+_cpp_push_next_buffer (pfile)
+ cpp_reader *pfile;
+{
+ bool pushed = false;
+
+ /* This is't pretty; we'd rather not be relying on this as a boolean
+ for reverting the line map. Further, we only free the chains in
+ this conditional, so an early call to cpp_finish / cpp_destroy
+ will leak that memory. */
+ if (CPP_OPTION (pfile, pending)
+ && CPP_OPTION (pfile, pending)->imacros_head == NULL)
{
- /* Stream on which to print the dependency information. */
- FILE *deps_stream = 0;
- const char *deps_mode
- = CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
- if (CPP_OPTION (pfile, deps_file) == 0)
- deps_stream = stdout;
- else
+ while (!pushed)
{
- deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
- if (deps_stream == 0)
- cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
+ struct pending_option *p = CPP_OPTION (pfile, pending)->include_head;
+
+ if (p == NULL)
+ break;
+ if (! CPP_OPTION (pfile, preprocessed))
+ pushed = push_include (pfile, p);
+ CPP_OPTION (pfile, pending)->include_head = p->next;
+ free (p);
}
- if (deps_stream)
+
+ if (!pushed)
{
- deps_write (pfile->deps, deps_stream, 72);
+ free (CPP_OPTION (pfile, pending));
+ CPP_OPTION (pfile, pending) = NULL;
- if (CPP_OPTION (pfile, deps_phony_targets))
- deps_phony_targets (pfile->deps, deps_stream);
+ /* Restore the line map for the main file. */
+ if (! CPP_OPTION (pfile, preprocessed))
+ _cpp_do_file_change (pfile, LC_RENAME,
+ pfile->line_maps.maps[0].to_file, 1, 0);
+ }
+ }
- if (CPP_OPTION (pfile, deps_file))
- {
- if (ferror (deps_stream) || fclose (deps_stream) != 0)
- cpp_fatal (pfile, "I/O error on output");
- }
+ return pushed;
+}
+
+/* Use mkdeps.c to output dependency information. */
+static void
+output_deps (pfile)
+ cpp_reader *pfile;
+{
+ /* Stream on which to print the dependency information. */
+ FILE *deps_stream = 0;
+ const char *const deps_mode =
+ CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
+
+ if (CPP_OPTION (pfile, deps_file) == 0)
+ deps_stream = stdout;
+ else
+ {
+ deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
+ if (deps_stream == 0)
+ {
+ cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
+ return;
}
}
+ deps_write (pfile->deps, deps_stream, 72);
+
+ if (CPP_OPTION (pfile, deps_phony_targets))
+ deps_phony_targets (pfile->deps, deps_stream);
+
+ /* Don't close stdout. */
+ if (CPP_OPTION (pfile, deps_file))
+ {
+ if (ferror (deps_stream) || fclose (deps_stream) != 0)
+ cpp_fatal (pfile, "I/O error on output");
+ }
+}
+
+/* This is called at the end of preprocessing. It pops the
+ last buffer and writes dependency output. It should also
+ clear macro definitions, such that you could call cpp_start_read
+ with a new filename to restart processing. */
+void
+cpp_finish (pfile)
+ cpp_reader *pfile;
+{
+ /* cpplex.c leaves the final buffer on the stack. This it so that
+ it returns an unending stream of CPP_EOFs to the client. If we
+ popped the buffer, we'd dereference a NULL buffer pointer and
+ segfault. It's nice to allow the client to do worry-free excess
+ cpp_get_token calls. */
+ while (pfile->buffer)
+ _cpp_pop_buffer (pfile);
+
+ /* Don't write the deps file if preprocessing has failed. */
+ if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
+ output_deps (pfile);
+
/* Report on headers that could use multiple include guards. */
if (CPP_OPTION (pfile, print_include_names))
_cpp_report_missing_guards (pfile);
}
+/* Add a directive to be handled later in the initialization phase. */
static void
new_pending_directive (pend, text, handler)
struct cpp_pending *pend;
/* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
I.e. a const string initializer with parens around it. That is
what N_("string") resolves to, so we make no_* be macros instead. */
-#define no_arg N_("Argument missing after %s")
-#define no_ass N_("Assertion missing after %s")
-#define no_dir N_("Directory name missing after %s")
-#define no_fil N_("File name missing after %s")
-#define no_mac N_("Macro name missing after %s")
-#define no_pth N_("Path name missing after %s")
-#define no_num N_("Number missing after %s")
-#define no_tgt N_("Target missing after %s")
+#define no_arg N_("argument missing after %s")
+#define no_ass N_("assertion missing after %s")
+#define no_dir N_("directory name missing after %s")
+#define no_fil N_("file name missing after %s")
+#define no_mac N_("macro name missing after %s")
+#define no_pth N_("path name missing after %s")
+#define no_num N_("number missing after %s")
+#define no_tgt N_("target missing after %s")
/* This is the list of all command line options, with the leading
"-" removed. It must be sorted in ASCII collating order. */
#define COMMAND_LINE_OPTIONS \
- DEF_OPT("", 0, OPT_stdin_stdout) \
DEF_OPT("$", 0, OPT_dollar) \
DEF_OPT("+", 0, OPT_plus) \
DEF_OPT("-help", 0, OPT__help) \
DEF_OPT("I", no_dir, OPT_I) \
DEF_OPT("M", 0, OPT_M) \
DEF_OPT("MD", no_fil, OPT_MD) \
+ DEF_OPT("MF", no_fil, OPT_MF) \
DEF_OPT("MG", 0, OPT_MG) \
DEF_OPT("MM", 0, OPT_MM) \
DEF_OPT("MMD", no_fil, OPT_MMD) \
DEF_OPT("fpreprocessed", 0, OPT_fpreprocessed) \
DEF_OPT("fshow-column", 0, OPT_fshow_column) \
DEF_OPT("ftabstop=", no_num, OPT_ftabstop) \
- DEF_OPT("g", no_arg, OPT_g) /* arg optional */ \
DEF_OPT("h", 0, OPT_h) \
DEF_OPT("idirafter", no_dir, OPT_idirafter) \
DEF_OPT("imacros", no_fil, OPT_imacros) \
command-line matches. Returns its index in the option array,
negative on failure. Complications arise since some options can be
suffixed with an argument, and multiple complete matches can occur,
- e.g. -iwithprefix and -iwithprefixbefore. Moreover, we want to
- accept options beginning with -g and -W that we do not recognise,
- but not to swallow any subsequent command line argument; these are
- handled as special cases in cpp_handle_option. */
+ e.g. -iwithprefix and -iwithprefixbefore. Moreover, we need to
+ accept options beginning with -W that we do not recognise, but not
+ to swallow any subsequent command line argument; this is handled as
+ special cases in cpp_handle_option. */
static int
parse_option (input)
const char *input;
Otherwise, return the longest option-accepting match.
This loops no more than twice with current options. */
mx = md;
- for (; mn < N_OPTS; mn++)
+ for (; mn < (unsigned int) N_OPTS; mn++)
{
opt_len = cl_options[mn].opt_len;
if (memcmp (input, cl_options[mn].opt_text, opt_len))
/* Handle one command-line option in (argc, argv).
Can be called multiple times, to handle multiple sets of options.
Returns number of strings consumed. */
-
int
cpp_handle_option (pfile, argc, argv)
cpp_reader *pfile;
int i = 0;
struct cpp_pending *pend = CPP_OPTION (pfile, pending);
- if (argv[i][0] != '-')
+ /* Interpret "-" or a non-option as a file name. */
+ if (argv[i][0] != '-' || argv[i][1] == '\0')
{
- if (CPP_OPTION (pfile, out_fname) != NULL)
- cpp_fatal (pfile, "Too many arguments. Type %s --help for usage info",
- progname);
- else if (CPP_OPTION (pfile, in_fname) != NULL)
+ if (CPP_OPTION (pfile, in_fname) == NULL)
+ CPP_OPTION (pfile, in_fname) = argv[i];
+ else if (CPP_OPTION (pfile, out_fname) == NULL)
CPP_OPTION (pfile, out_fname) = argv[i];
else
- CPP_OPTION (pfile, in_fname) = argv[i];
+ cpp_fatal (pfile, "too many filenames. Type %s --help for usage info",
+ progname);
}
else
{
{
arg = &argv[i][cl_options[opt_index].opt_len + 1];
- /* Yuk. Special case for -g and -W as they must not swallow
+ /* Yuk. Special case for -W as it must not swallow
up any following argument. If this becomes common, add
another field to the cl_options table. */
- if (arg[0] == '\0' && !(opt_code == OPT_g || opt_code == OPT_W))
+ if (arg[0] == '\0' && opt_code != OPT_W)
{
arg = argv[++i];
if (!arg)
case OPT_w:
CPP_OPTION (pfile, inhibit_warnings) = 1;
break;
- case OPT_g: /* Silently ignore anything but -g3. */
- if (!strcmp(&argv[i][2], "3"))
- CPP_OPTION (pfile, debug_output) = 1;
- break;
case OPT_h:
case OPT__help:
print_help ();
- pfile->help_only = 1;
+ CPP_OPTION (pfile, help_only) = 1;
break;
case OPT_target__help:
/* Print if any target specific options. cpplib has none, but
make sure help_only gets set. */
- pfile->help_only = 1;
+ CPP_OPTION (pfile, help_only) = 1;
break;
/* --version inhibits compilation, -version doesn't. -v means
verbose and -version. Historical reasons, don't ask. */
case OPT__version:
- pfile->help_only = 1;
- goto version;
+ CPP_OPTION (pfile, help_only) = 1;
+ pfile->print_version = 1;
+ break;
case OPT_v:
CPP_OPTION (pfile, verbose) = 1;
- goto version;
-
+ pfile->print_version = 1;
+ break;
case OPT_version:
- version:
- fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string);
-#ifdef TARGET_VERSION
- TARGET_VERSION;
-#endif
- fputc ('\n', stderr);
+ pfile->print_version = 1;
break;
case OPT_C:
CPP_OPTION (pfile, no_standard_includes) = 1;
break;
case OPT_nostdincplusplus:
- /* -nostdinc++ causes no default C++-specific include directories. */
+ /* -nostdinc++ causes no default C++-specific include directories. */
CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
break;
case OPT_o:
- if (CPP_OPTION (pfile, out_fname) != NULL)
+ if (CPP_OPTION (pfile, out_fname) == NULL)
+ CPP_OPTION (pfile, out_fname) = arg;
+ else
{
- cpp_fatal (pfile, "Output filename specified twice");
+ cpp_fatal (pfile, "output filename specified twice");
return argc;
}
- CPP_OPTION (pfile, out_fname) = arg;
- if (!strcmp (CPP_OPTION (pfile, out_fname), "-"))
- CPP_OPTION (pfile, out_fname) = "";
- break;
- case OPT_stdin_stdout:
- /* JF handle '-' as file name meaning stdin or stdout. */
- if (CPP_OPTION (pfile, in_fname) == NULL)
- CPP_OPTION (pfile, in_fname) = "";
- else if (CPP_OPTION (pfile, out_fname) == NULL)
- CPP_OPTION (pfile, out_fname) = "";
break;
case OPT_d:
/* Args to -d specify what parts of macros to dump.
}
}
break;
- /* The style of the choices here is a bit mixed.
- The chosen scheme is a hybrid of keeping all options in one string
- and specifying each option in a separate argument:
- -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
- -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
- -M[M][G][D file]. This is awkward to handle in specs, and is not
- as extensible. */
- /* ??? -MG must be specified in addition to one of -M or -MM.
- This can be relaxed in the future without breaking anything.
- The converse isn't true. */
-
- /* -MG isn't valid with -MD or -MMD. This is checked for later. */
+
case OPT_MG:
CPP_OPTION (pfile, print_deps_missing_files) = 1;
break;
case OPT_M:
- case OPT_MD:
+ CPP_OPTION (pfile, print_deps) = 2;
+ break;
case OPT_MM:
- case OPT_MMD:
- if (opt_code == OPT_M || opt_code == OPT_MD)
- CPP_OPTION (pfile, print_deps) = 2;
- else
- CPP_OPTION (pfile, print_deps) = 1;
-
- /* For -MD and -MMD, write deps on file named by next arg. */
- /* For -M and -MM, write deps on standard output and
- suppress the usual output. */
- if (opt_code == OPT_MD || opt_code == OPT_MMD)
- CPP_OPTION (pfile, deps_file) = arg;
- else
- CPP_OPTION (pfile, no_output) = 1;
+ CPP_OPTION (pfile, print_deps) = 1;
break;
-
- case OPT_MP:
+ case OPT_MF:
+ CPP_OPTION (pfile, deps_file) = arg;
+ break;
+ case OPT_MP:
CPP_OPTION (pfile, deps_phony_targets) = 1;
break;
-
case OPT_MQ:
case OPT_MT:
/* Add a target. -MQ quotes for Make. */
deps_add_target (pfile->deps, arg, opt_code == OPT_MQ);
break;
+ /* -MD and -MMD for cpp0 are deprecated and undocumented
+ (use -M or -MM with -MF instead), and probably should be
+ removed with the next major GCC version. For the moment
+ we allow these for the benefit of Automake 1.4, which
+ uses these when dependency tracking is enabled. Automake
+ 1.5 will fix this. */
+ case OPT_MD:
+ CPP_OPTION (pfile, print_deps) = 2;
+ CPP_OPTION (pfile, deps_file) = arg;
+ break;
+ case OPT_MMD:
+ CPP_OPTION (pfile, print_deps) = 1;
+ CPP_OPTION (pfile, deps_file) = arg;
+ break;
+
case OPT_A:
if (arg[0] == '-')
{
if (arg[1] == '\0')
{
- struct pending_option *o1, *o2;
-
- o1 = pend->directive_head;
- while (o1)
- {
- o2 = o1->next;
- free (o1);
- o1 = o2;
- }
+ free_chain (pend->directive_head);
pend->directive_head = NULL;
pend->directive_tail = NULL;
}
append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
break;
case OPT_include:
- {
- struct pending_option *o = (struct pending_option *)
- xmalloc (sizeof (struct pending_option));
- o->arg = arg;
-
- /* This list has to be built in reverse order so that
- when cpp_start_read pushes all the -include files onto
- the buffer stack, they will be scanned in forward order. */
- o->next = pend->include_head;
- pend->include_head = o;
- }
- break;
case OPT_imacros:
{
struct pending_option *o = (struct pending_option *)
o->arg = arg;
o->next = NULL;
- APPEND (pend, imacros, o);
+ if (opt_code == OPT_include)
+ APPEND (pend, include, o);
+ else
+ APPEND (pend, imacros, o);
}
break;
case OPT_iwithprefix:
return i + 1;
}
-#ifdef HOST_EBCDIC
-static int
-opt_comp (const void *p1, const void *p2)
-{
- return strcmp (((struct cl_option *)p1)->opt_text,
- ((struct cl_option *)p2)->opt_text);
-}
-#endif
-
/* Handle command-line options in (argc, argv).
Can be called multiple times, to handle multiple sets of options.
Returns if an unrecognized option is seen.
if (strings_processed == 0)
break;
}
+
return i;
}
+/* Extra processing when all options are parsed, after all calls to
+ cpp_handle_option[s]. Consistency checks etc. */
+void
+cpp_post_options (pfile)
+ cpp_reader *pfile;
+{
+ if (pfile->print_version)
+ {
+ fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string);
+#ifdef TARGET_VERSION
+ TARGET_VERSION;
+#endif
+ fputc ('\n', stderr);
+ }
+
+ /* Canonicalize in_fname and out_fname. We guarantee they are not
+ NULL, and that the empty string represents stdin / stdout. */
+ if (CPP_OPTION (pfile, in_fname) == NULL
+ || !strcmp (CPP_OPTION (pfile, in_fname), "-"))
+ CPP_OPTION (pfile, in_fname) = "";
+
+ if (CPP_OPTION (pfile, out_fname) == NULL
+ || !strcmp (CPP_OPTION (pfile, out_fname), "-"))
+ CPP_OPTION (pfile, out_fname) = "";
+
+ /* -Wtraditional is not useful in C++ mode. */
+ if (CPP_OPTION (pfile, cplusplus))
+ CPP_OPTION (pfile, warn_traditional) = 0;
+
+ /* Set this if it hasn't been set already. */
+ if (CPP_OPTION (pfile, user_label_prefix) == NULL)
+ CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
+
+ /* Permanently disable macro expansion if we are rescanning
+ preprocessed text. */
+ if (CPP_OPTION (pfile, preprocessed))
+ pfile->state.prevent_expansion = 1;
+
+ /* We need to do this after option processing and before
+ cpp_start_read, as cppmain.c relies on the options->no_output to
+ set its callbacks correctly before calling cpp_start_read. */
+ init_dependency_output (pfile);
+
+ /* After checking the environment variables, check if -M or -MM has
+ not been specified, but other -M options have. */
+ if (CPP_OPTION (pfile, print_deps) == 0 &&
+ (CPP_OPTION (pfile, print_deps_missing_files)
+ || CPP_OPTION (pfile, deps_file)
+ || CPP_OPTION (pfile, deps_phony_targets)))
+ cpp_fatal (pfile, "you must additionally specify either -M or -MM");
+}
+
+/* Set up dependency-file output. */
+static void
+init_dependency_output (pfile)
+ cpp_reader *pfile;
+{
+ char *spec, *s, *output_file;
+
+ /* Either of two environment variables can specify output of deps.
+ Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
+ where OUTPUT_FILE is the file to write deps info to
+ and DEPS_TARGET is the target to mention in the deps. */
+
+ if (CPP_OPTION (pfile, print_deps) == 0)
+ {
+ spec = getenv ("DEPENDENCIES_OUTPUT");
+ if (spec)
+ CPP_OPTION (pfile, print_deps) = 1;
+ else
+ {
+ spec = getenv ("SUNPRO_DEPENDENCIES");
+ if (spec)
+ CPP_OPTION (pfile, print_deps) = 2;
+ else
+ return;
+ }
+
+ /* Find the space before the DEPS_TARGET, if there is one. */
+ s = strchr (spec, ' ');
+ if (s)
+ {
+ /* Let the caller perform MAKE quoting. */
+ deps_add_target (pfile->deps, s + 1, 0);
+ output_file = (char *) xmalloc (s - spec + 1);
+ memcpy (output_file, spec, s - spec);
+ output_file[s - spec] = 0;
+ }
+ else
+ output_file = spec;
+
+ /* Command line overrides environment variables. */
+ if (CPP_OPTION (pfile, deps_file) == 0)
+ CPP_OPTION (pfile, deps_file) = output_file;
+ CPP_OPTION (pfile, print_deps_append) = 1;
+ }
+
+ /* If dependencies go to standard output, or -MG is used, we should
+ suppress output, including -dM, -dI etc. */
+ if (CPP_OPTION (pfile, deps_file) == 0
+ || CPP_OPTION (pfile, print_deps_missing_files))
+ {
+ CPP_OPTION (pfile, no_output) = 1;
+ CPP_OPTION (pfile, dump_macros) = 0;
+ CPP_OPTION (pfile, dump_includes) = 0;
+ }
+}
+
+/* Handle --help output. */
static void
print_help ()
{
fprintf (stderr, _("Usage: %s [switches] input output\n"), progname);
/* To keep the lines from getting too long for some compilers, limit
- to about 500 characters (6 lines) per chunk. */
+ to about 500 characters (6 lines) per chunk. */
fputs (_("\
Switches:\n\
-include <file> Include the contents of <file> before other files\n\
fputs (_("\
-M Generate make dependencies\n\
-MM As -M, but ignore system header files\n\
- -MD As -M, but put output in a .d file\n\
- -MMD As -MD, but ignore system header files\n\
+ -MF <file> Write dependency output to the given file\n\
-MG Treat missing header file as generated files\n\
- -g3 Include #define and #undef directives in the output\n\
+"), stdout);
+ fputs (_("\
+ -MP Generate phony targets for all headers\n\
+ -MQ <target> Add a MAKE-quoted target\n\
+ -MT <target> Add an unquoted target\n\
"), stdout);
fputs (_("\
-D<macro> Define a <macro> with string '1' as its value\n\
-dI Include #include directives in the output\n\
"), stdout);
fputs (_("\
+ -fpreprocessed Treat the input file as already preprocessed\n\
-ftabstop=<number> Distance between tab stops for column reporting\n\
-P Do not generate #line directives\n\
-$ Do not allow '$' in identifiers\n\