/* CPP Library.
Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000 Free Software Foundation, Inc.
+ 1999, 2000, 2001 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 "mkdeps.h"
#include "cppdefault.h"
-/* Predefined symbols, built-in macros, and the default include path. */
+/* Predefined symbols, built-in macros, and the default include path. */
#ifndef GET_ENV_PATH_LIST
#define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
#define INO_T_EQ(a, b) ((a) == (b))
#endif
-/* Internal structures and prototypes. */
+/* Internal structures and prototypes. */
-/* A `struct pending_option' remembers one -D, -A, -U, -include, or -imacros
- switch. There are four lists: one for -D and -U, one for -A, one
- for -include, one for -imacros. `undef' is set for -U, clear for
- -D, ignored for the others.
- (Future: add an equivalent of -U for -A) */
+/* 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
several lists, one for each type of option. We keep both head and
- tail pointers for quick insertion. */
+ tail pointers for quick insertion. */
struct cpp_pending
{
struct pending_option *directive_head, *directive_tail;
static void print_help PARAMS ((void));
static void path_include PARAMS ((cpp_reader *,
- struct cpp_pending *,
char *, int));
-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 *,
- struct cpp_pending *,
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 void merge_include_chains PARAMS ((cpp_reader *));
-
-static void initialize_dependency_output PARAMS ((cpp_reader *));
-static void initialize_standard_includes PARAMS ((cpp_reader *));
-static void new_pending_directive PARAMS ((struct cpp_pending *,
+static void do_includes PARAMS ((cpp_reader *,
+ struct pending_option *,
+ int));
+static void set_lang PARAMS ((cpp_reader *, enum c_lang));
+static void init_dependency_output PARAMS ((cpp_reader *));
+static void init_standard_includes 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 *));
-static int handle_option PARAMS ((cpp_reader *, int, char **));
-/* Fourth argument to append_include_chain: chain to use */
+/* Fourth argument to append_include_chain: chain to use. */
enum { QUOTE = 0, BRACKET, SYSTEM, AFTER };
-/* If we have designated initializers (GCC >2.7) this table can be
- initialized, constant data. Otherwise, it has to be filled in at
+/* If we have designated initializers (GCC >2.7) these tables can be
+ initialized, constant data. Otherwise, they have to be filled in at
runtime. */
+#if HAVE_DESIGNATED_INITIALIZERS
+
+#define init_trigraph_map() /* Nothing. */
+#define TRIGRAPH_MAP \
+__extension__ const U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = {
-#if (GCC_VERSION >= 2007)
-#define init_IStable() /* nothing */
-#define ISTABLE __extension__ const unsigned char _cpp_IStable[256] = {
#define END };
#define s(p, v) [p] = v,
-#else
-#define ISTABLE unsigned char _cpp_IStable[256] = { 0 }; \
- static void init_IStable PARAMS ((void)) { \
- unsigned char *x = _cpp_IStable;
-#define END }
-#define s(p, v) x[p] = v;
-#endif
-
-#define A(x) s(x, ISidnum|ISidstart)
-#define N(x) s(x, ISidnum|ISnumstart)
-#define H(x) s(x, IShspace|ISspace)
-#define V(x) s(x, ISvspace|ISspace)
-#define S(x) s(x, ISspace)
-
-ISTABLE
- A('_')
-
- A('a') A('b') A('c') A('d') A('e') A('f') A('g') A('h') A('i')
- A('j') A('k') A('l') A('m') A('n') A('o') A('p') A('q') A('r')
- A('s') A('t') A('u') A('v') A('w') A('x') A('y') A('z')
- A('A') A('B') A('C') A('D') A('E') A('F') A('G') A('H') A('I')
- A('J') A('K') A('L') A('M') A('N') A('O') A('P') A('Q') A('R')
- A('S') A('T') A('U') A('V') A('W') A('X') A('Y') A('Z')
+#else
- N('1') N('2') N('3') N('4') N('5') N('6') N('7') N('8') N('9') N('0')
+#define TRIGRAPH_MAP U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
+ static void init_trigraph_map PARAMS ((void)) { \
+ unsigned char *x = _cpp_trigraph_map;
- H(' ') H('\t')
+#define END }
+#define s(p, v) x[p] = v;
- V('\n') V('\r')
+#endif
- S('\0') S('\v') S('\f')
+TRIGRAPH_MAP
+ s('=', '#') s(')', ']') s('!', '|')
+ s('(', '[') s('\'', '^') s('>', '}')
+ s('/', '\\') s('<', '{') s('-', '~')
END
-#undef A
-#undef N
-#undef H
-#undef V
-#undef S
#undef s
-#undef ISTABLE
#undef END
+#undef TRIGRAPH_MAP
/* 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, pend, list, path)
+path_include (pfile, list, path)
cpp_reader *pfile;
- struct cpp_pending *pend;
char *list;
int path;
{
name[q - p] = 0;
}
- append_include_chain (pfile, pend, name, path, 0);
+ append_include_chain (pfile, name, path, 0);
/* Advance past this name. */
if (*q == 0)
/* Append DIR to include path PATH. DIR must be permanently allocated
and writable. */
static void
-append_include_chain (pfile, pend, dir, path, cxx_aware)
+append_include_chain (pfile, dir, path, cxx_aware)
cpp_reader *pfile;
- struct cpp_pending *pend;
char *dir;
int path;
int cxx_aware;
{
+ struct cpp_pending *pend = CPP_OPTION (pfile, pending);
struct file_name_list *new;
struct stat st;
unsigned int len;
}
}
+/* 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 *
+remove_dup_dir (pfile, prev)
+ cpp_reader *pfile;
+ struct file_name_list *prev;
+{
+ struct file_name_list *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 (cur);
+
+ return prev;
+}
+
+/* Remove duplicate directories from a chain. Returns the tail of the
+ 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 *
+remove_dup_dirs (pfile, head)
+ cpp_reader *pfile;
+ struct file_name_list *head;
+{
+ struct file_name_list *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)
+ {
+ cur = remove_dup_dir (pfile, prev);
+ break;
+ }
+ prev = cur;
+ }
+
+ return prev;
+}
+
/* Merge the four include chains together in the order quote, bracket,
system, after. Remove duplicate dirs (as determined by
INO_T_EQ()). The system_include and after_include chains are never
bracket_include path.
For the future: Check if the directory is empty (but
- how?) and possibly preload the include hash. */
+ how?) and possibly preload the include hash. */
static void
merge_include_chains (pfile)
cpp_reader *pfile;
{
- struct file_name_list *prev, *cur, *other;
- struct file_name_list *quote, *brack, *systm, *after;
- struct file_name_list *qtail, *btail, *stail, *atail;
+ struct file_name_list *quote, *brack, *systm, *qtail;
struct cpp_pending *pend = CPP_OPTION (pfile, pending);
- qtail = pend->quote_tail;
- btail = pend->brack_tail;
- stail = pend->systm_tail;
- atail = pend->after_tail;
-
quote = pend->quote_head;
brack = pend->brack_head;
systm = pend->systm_head;
- after = pend->after_head;
+ qtail = pend->quote_tail;
- /* Paste together bracket, system, and after include chains. */
- if (stail)
- stail->next = after;
+ /* Paste together bracket, system, and after include chains. */
+ if (systm)
+ pend->systm_tail->next = pend->after_head;
else
- systm = after;
- if (btail)
- btail->next = systm;
+ systm = pend->after_head;
+
+ if (brack)
+ pend->brack_tail->next = systm;
else
brack = systm;
- /* 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 qtail.
+ /* 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.
We can't just merge the lists and then uniquify them because
then we may lose directories from the <> search path that should
be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
- -Ibar -I- -Ifoo -Iquux.
+ -Ibar -I- -Ifoo -Iquux. */
- Note that this algorithm is quadratic in the number of -I switches,
- which is acceptable since there aren't usually that many of them. */
-
- for (cur = quote, prev = NULL; cur; cur = cur->next)
- {
- for (other = quote; other != cur; other = other->next)
- if (INO_T_EQ (cur->ino, other->ino)
- && cur->dev == other->dev)
- {
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"),
- cur->name);
-
- prev->next = cur->next;
- free (cur->name);
- free (cur);
- cur = prev;
- break;
- }
- prev = cur;
- }
- qtail = prev;
-
- for (cur = brack; cur; cur = cur->next)
- {
- for (other = brack; other != cur; other = other->next)
- if (INO_T_EQ (cur->ino, other->ino)
- && cur->dev == other->dev)
- {
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"),
- cur->name);
-
- prev->next = cur->next;
- free (cur->name);
- free (cur);
- cur = prev;
- break;
- }
- prev = cur;
- }
+ remove_dup_dirs (pfile, brack);
+ qtail = remove_dup_dirs (pfile, quote);
if (quote)
{
- if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
- {
- if (quote == qtail)
- {
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"),
- quote->name);
+ qtail->next = brack;
- free (quote->name);
- free (quote);
- quote = brack;
- }
- else
- {
- cur = quote;
- while (cur->next != qtail)
- cur = cur->next;
- cur->next = brack;
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"),
- qtail->name);
-
- free (qtail->name);
- free (qtail);
- }
- }
- else
- qtail->next = brack;
+ /* If brack == qtail, remove brack as it's simpler. */
+ if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
+ brack = remove_dup_dir (pfile, qtail);
}
else
quote = brack;
CPP_OPTION (pfile, bracket_include) = brack;
}
+/* Sets internal flags correctly for a given language, and defines
+ macros if necessary. */
+static void
+set_lang (pfile, lang)
+ cpp_reader *pfile;
+ enum c_lang lang;
+{
+ struct cpp_pending *pend = CPP_OPTION (pfile, pending);
+
+ /* Defaults. */
+ 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;
+
+ /* 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;
+
+ /* 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;
+ }
+}
+
+#ifdef HOST_EBCDIC
+static int opt_comp PARAMS ((const void *, const void *));
+
+/* 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
+
+/* init initializes library global state. It might not need to
+ do anything depending on the platform and compiler. */
+
+static void
+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);
+#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 ();
+ }
+}
/* Initialize a cpp_reader structure. */
-void
-cpp_reader_init (pfile)
- cpp_reader *pfile;
+cpp_reader *
+cpp_create_reader (lang)
+ enum c_lang lang;
{
- memset ((char *) pfile, 0, sizeof (cpp_reader));
+ struct spec_nodes *s;
+ cpp_reader *pfile;
- pfile->token_buffer_size = 200;
- pfile->token_buffer = (U_CHAR *) xmalloc (pfile->token_buffer_size);
- CPP_SET_WRITTEN (pfile, 0);
+ /* Initialise this instance of the library if it hasn't been already. */
+ init_library ();
+
+ pfile = (cpp_reader *) xcalloc (1, sizeof (cpp_reader));
- CPP_OPTION (pfile, dollars_in_ident) = 1;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
CPP_OPTION (pfile, warn_import) = 1;
- CPP_OPTION (pfile, warn_paste) = 1;
CPP_OPTION (pfile, discard_comments) = 1;
CPP_OPTION (pfile, show_column) = 1;
CPP_OPTION (pfile, tabstop) = 8;
+ CPP_OPTION (pfile, operator_names) = 1;
CPP_OPTION (pfile, pending) =
(struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
- _cpp_init_macros (pfile);
+ /* 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 ();
+
+ /* Initialize lexer state. */
+ pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
+
+ /* Indicate date and time not yet calculated. */
+ pfile->date.type = CPP_EOF;
+
+ /* 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);
+
+ /* Macro pool initially 8K. Aligned, permanent pool. */
+ _cpp_init_pool (&pfile->macro_pool, 8 * 1024, 0, 0);
+
+ _cpp_init_hashtable (pfile);
_cpp_init_stacks (pfile);
_cpp_init_includes (pfile);
-}
-
-/* Initialize a cpp_printer structure. As a side effect, open the
- output file. */
-cpp_printer *
-cpp_printer_init (pfile, print)
- cpp_reader *pfile;
- cpp_printer *print;
-{
- memset (print, '\0', sizeof (cpp_printer));
- if (CPP_OPTION (pfile, out_fname) == NULL)
- CPP_OPTION (pfile, out_fname) = "";
-
- if (CPP_OPTION (pfile, out_fname)[0] == '\0')
- print->outf = stdout;
- else
- {
- print->outf = fopen (CPP_OPTION (pfile, out_fname), "w");
- if (! print->outf)
- {
- cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
- return NULL;
- }
- }
- return print;
+ _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.
cpp_cleanup (pfile)
cpp_reader *pfile;
{
+ struct file_name_list *dir, *dirn;
+ cpp_context *context, *contextn;
+
while (CPP_BUFFER (pfile) != NULL)
cpp_pop_buffer (pfile);
- if (pfile->token_buffer)
+ if (pfile->macro_buffer)
{
- free (pfile->token_buffer);
- pfile->token_buffer = NULL;
+ free ((PTR) pfile->macro_buffer);
+ pfile->macro_buffer = NULL;
+ pfile->macro_buffer_len = 0;
}
- if (pfile->deps)
- deps_free (pfile->deps);
-
- if (pfile->spec_nodes)
- free (pfile->spec_nodes);
+ deps_free (pfile->deps);
- _cpp_free_temp_tokens (pfile);
_cpp_cleanup_includes (pfile);
_cpp_cleanup_stacks (pfile);
- _cpp_cleanup_macros (pfile);
+ _cpp_cleanup_hashtable (pfile);
+
+ _cpp_free_lookaheads (pfile);
+
+ _cpp_free_pool (&pfile->ident_pool);
+ _cpp_free_pool (&pfile->macro_pool);
+ _cpp_free_pool (&pfile->argument_pool);
+
+ for (dir = CPP_OPTION (pfile, quote_include); dir; dir = dirn)
+ {
+ dirn = dir->next;
+ free (dir->name);
+ free (dir);
+ }
+
+ for (context = pfile->base_context.next; context; context = contextn)
+ {
+ contextn = context->next;
+ free (context);
+ }
}
-/* This structure defines one built-in macro. A node of type TYPE will
- be entered in the macro hash table under the name NAME, with value
- VALUE (if any). Two values are not compile time constants, so we tag
+/* 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.
+
+ Two values are not compile time constants, so we tag
them in the FLAGS field instead:
VERS value is the global version_string, quoted
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;
const char *value;
- unsigned short type;
+ unsigned char builtin;
+ unsigned char operator;
unsigned short flags;
- unsigned int len;
+ unsigned short len;
};
-#define VERS 0x01
-#define ULP 0x02
-
-#define B(n, t) { U n, 0, t, 0, sizeof n - 1 }
-#define C(n, v) { U n, v, T_MACRO, 0, sizeof n - 1 }
-#define X(n, f) { U n, 0, T_MACRO, f, sizeof n - 1 }
+#define VERS 0x01
+#define ULP 0x02
+#define CPLUS 0x04
+#define BUILTIN 0x08
+#define OPERATOR 0x10
+
+#define B(n, t) { U n, 0, t, 0, BUILTIN, sizeof n - 1 }
+#define C(n, v) { U n, v, 0, 0, 0, sizeof n - 1 }
+#define X(n, f) { U n, 0, 0, 0, f, sizeof n - 1 }
+#define O(n, c, f) { U n, 0, 0, c, OPERATOR | f, sizeof n - 1 }
static const struct builtin builtin_array[] =
{
- B("__TIME__", T_TIME),
- B("__DATE__", T_DATE),
- B("__FILE__", T_FILE),
- B("__BASE_FILE__", T_BASE_FILE),
- B("__LINE__", T_SPECLINE),
- B("__INCLUDE_LEVEL__", T_INCLUDE_LEVEL),
- B("__STDC__", T_STDC),
+ B("__TIME__", BT_TIME),
+ B("__DATE__", BT_DATE),
+ B("__FILE__", BT_FILE),
+ B("__BASE_FILE__", BT_BASE_FILE),
+ B("__LINE__", BT_SPECLINE),
+ B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
+ B("__STDC__", BT_STDC),
X("__VERSION__", VERS),
X("__USER_LABEL_PREFIX__", ULP),
#ifndef NO_BUILTIN_WCHAR_TYPE
C("__WCHAR_TYPE__", WCHAR_TYPE),
#endif
+#ifndef NO_BUILTIN_WINT_TYPE
+ C("__WINT_TYPE__", WINT_TYPE),
+#endif
+
+ /* Named operators known to the preprocessor. These cannot be #defined
+ and always have their stated meaning. They are treated like normal
+ identifiers except for the type code and the meaning. Most of them
+ are only for C++ (but see iso646.h). */
+ O("and", CPP_AND_AND, CPLUS),
+ O("and_eq", CPP_AND_EQ, CPLUS),
+ O("bitand", CPP_AND, CPLUS),
+ O("bitor", CPP_OR, CPLUS),
+ O("compl", CPP_COMPL, CPLUS),
+ O("not", CPP_NOT, CPLUS),
+ O("not_eq", CPP_NOT_EQ, CPLUS),
+ O("or", CPP_OR_OR, CPLUS),
+ O("or_eq", CPP_OR_EQ, CPLUS),
+ O("xor", CPP_XOR, CPLUS),
+ O("xor_eq", CPP_XOR_EQ, CPLUS)
};
#undef B
#undef C
#undef X
+#undef O
#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. */
static void
-initialize_builtins (pfile)
+init_builtins (pfile)
cpp_reader *pfile;
{
const struct builtin *b;
+
for(b = builtin_array; b < builtin_array_end; b++)
{
- if (b->type == T_MACRO)
+ if ((b->flags & CPLUS) && ! CPP_OPTION (pfile, cplusplus))
+ continue;
+
+ if ((b->flags & OPERATOR) && ! CPP_OPTION (pfile, operator_names))
+ continue;
+
+ if (b->flags & (OPERATOR | BUILTIN))
+ {
+ cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
+ if (b->flags & OPERATOR)
+ {
+ hp->flags |= NODE_OPERATOR;
+ hp->value.operator = b->operator;
+ }
+ else
+ {
+ hp->type = NT_MACRO;
+ hp->flags |= NODE_BUILTIN;
+ hp->value.builtin = b->builtin;
+ }
+ }
+ else /* A standard macro of some kind. */
{
const char *val;
char *str;
if (b->flags & VERS)
{
- /* Allocate enough space for 'name="value"\0'. */
- str = xmalloc (b->len + strlen (version_string) + 4);
- sprintf (str, "%s=\"%s\"", b->name, version_string);
+ /* Allocate enough space for 'name "value"\n\0'. */
+ str = alloca (b->len + strlen (version_string) + 5);
+ sprintf (str, "%s \"%s\"\n", b->name, version_string);
}
else
{
if (b->flags & ULP)
- val = user_label_prefix;
+ val = CPP_OPTION (pfile, user_label_prefix);
else
val = b->value;
- /* Allocate enough space for "name=value\0". */
- str = xmalloc (b->len + strlen (val) + 2);
- sprintf(str, "%s=%s", b->name, val);
+ /* Allocate enough space for "name value\n\0". */
+ str = alloca (b->len + strlen (val) + 3);
+ sprintf(str, "%s %s\n", b->name, val);
}
- cpp_define (pfile, str);
- }
- else
- {
- cpp_hashnode *hp;
-
- if (b->type == T_STDC && CPP_TRADITIONAL (pfile))
- continue;
- hp = cpp_lookup (pfile, b->name, b->len);
- hp->type = b->type;
+ _cpp_define_builtin (pfile, str);
}
}
}
+#undef BUILTIN
+#undef OPERATOR
#undef VERS
#undef ULP
+#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)
- {
- CPP_OPTION (pfile, deps_target) = s + 1;
- output_file = (char *) xmalloc (s - spec + 1);
- memcpy (output_file, spec, s - spec);
- output_file[s - spec] = 0;
- }
- else
- {
- CPP_OPTION (pfile, deps_target) = 0;
- output_file = spec;
- }
-
- CPP_OPTION (pfile, deps_file) = output_file;
- CPP_OPTION (pfile, print_deps_append) = 1;
- }
-
- pfile->deps = deps_init ();
-
- /* Print the expected object file name as the target of this Make-rule. */
- if (CPP_OPTION (pfile, deps_target))
- deps_add_target (pfile->deps, CPP_OPTION (pfile, deps_target));
- else if (*CPP_OPTION (pfile, in_fname) == 0)
- deps_add_target (pfile->deps, "-");
- else
- deps_calc_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;
GET_ENV_PATH_LIST (path, "CPATH");
if (path != 0 && *path != 0)
- path_include (pfile, CPP_OPTION (pfile, pending), path, BRACKET);
+ path_include (pfile, path, BRACKET);
switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus))
{
break;
}
if (path != 0 && *path != 0)
- path_include (pfile, CPP_OPTION (pfile, pending), path, SYSTEM);
+ path_include (pfile, path, SYSTEM);
/* Search "translated" versions of GNU directories.
These have /usr/local/lib/gcc... replaced by specd_prefix. */
&& !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
{
/* Does this dir start with the prefix? */
- if (!strncmp (p->fname, default_prefix, default_len))
+ if (!memcmp (p->fname, default_prefix, default_len))
{
/* Yes; change prefix and add to search list. */
int flen = strlen (p->fname);
p->fname + default_len,
flen - default_len + 1);
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- str, SYSTEM, p->cxx_aware);
+ append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
}
}
}
|| (CPP_OPTION (pfile, cplusplus)
&& !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
{
- /* XXX Potential memory leak! */
char *str = xstrdup (update_path (p->fname, p->component));
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- str, SYSTEM, p->cxx_aware);
+ append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
}
}
}
-/* 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, print, fname)
+/* Handles -imacro and -include from the command line. */
+static void
+do_includes (pfile, p, scan)
cpp_reader *pfile;
- cpp_printer *print;
- const char *fname;
+ struct pending_option *p;
+ int scan;
{
- 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;
- }
-
- /* Chill should not be used with -trigraphs. */
- if (CPP_OPTION (pfile, chill) && CPP_OPTION (pfile, trigraphs))
+ while (p)
{
- cpp_warning (pfile, "-lang-chill and -trigraphs are mutually exclusive");
- CPP_OPTION (pfile, trigraphs) = 0;
+ struct pending_option *q;
+
+ /* Don't handle if -fpreprocessed. Later: maybe update this to
+ use the #include "" search path if cpp_read_file fails. */
+ if (CPP_OPTION (pfile, preprocessed))
+ cpp_error (pfile, "-include and -imacros cannot be used with -fpreprocessed");
+ else if (_cpp_read_file (pfile, p->arg) && scan)
+ cpp_scan_buffer_nooutput (pfile, 0);
+ q = p->next;
+ free (p);
+ p = q;
}
+}
- /* -Wtraditional is not useful in C++ mode. */
- if (CPP_OPTION (pfile, cplusplus))
- CPP_OPTION (pfile, warn_traditional) = 0;
-
- /* Do not warn about illegal token pasting if -traditional,
- -lang-fortran, or -lang-asm. */
- if (CPP_OPTION (pfile, traditional)
- || CPP_OPTION (pfile, lang_fortran)
- || CPP_OPTION (pfile, lang_asm))
- CPP_OPTION (pfile, warn_paste) = 0;
+/* This is called after options have been processed. Setup for
+ processing input from the file named FNAME. (Use standard input if
+ FNAME == NULL.) Return 1 on success, 0 on failure. */
- /* Set this if it hasn't been set already. */
- if (user_label_prefix == NULL)
- user_label_prefix = USER_LABEL_PREFIX;
-
- /* Figure out if we need to save function macro parameter spellings.
- We don't use CPP_PEDANTIC() here because that depends on whether
- or not the current file is a system header, and there is no
- current file yet. */
- pfile->save_parameter_spellings =
- CPP_OPTION (pfile, pedantic)
- || CPP_OPTION (pfile, debug_output)
- || CPP_OPTION (pfile, dump_macros) == dump_definitions
- || CPP_OPTION (pfile, dump_macros) == dump_only;
-
- /* Set up the IStable. This doesn't do anything if we were compiled
- with a compiler that supports C99 designated initializers. */
- init_IStable ();
-
- /* Set up the tables used by read_and_prescan. */
- _cpp_init_input_buffer (pfile);
+int
+cpp_start_read (pfile, fname)
+ cpp_reader *pfile;
+ const char *fname;
+{
+ struct pending_option *p, *q;
/* 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);
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)
{
if (CPP_OPTION (pfile, out_fname) == NULL)
CPP_OPTION (pfile, out_fname) = "";
- if (!cpp_read_file (pfile, fname))
- return 0;
-
- initialize_dependency_output (pfile);
-
- /* -D and friends may produce output, which should be identified
- as line 0. */
-
- CPP_BUFFER (pfile)->lineno = 0;
- if (print)
+ if (CPP_OPTION (pfile, print_deps))
{
- print->last_fname = CPP_BUFFER (pfile)->nominal_fname;
- print->last_id = pfile->include_depth;
- print->written = CPP_WRITTEN (pfile);
- print->lineno = 0;
+ /* Set the default target (if there is none already), and
+ the dependency on the main file. */
+ deps_add_default_target (pfile->deps, CPP_OPTION (pfile, in_fname));
+
+ deps_add_dep (pfile->deps, CPP_OPTION (pfile, in_fname));
}
- /* Install __LINE__, etc. */
- initialize_builtins (pfile);
+ /* Open the main input file. This must be done early, so we have a
+ buffer to stand on. */
+ if (!_cpp_read_file (pfile, fname))
+ return 0;
+
+ /* If already preprocessed, don't install __LINE__, etc., and ignore
+ command line definitions and assertions. Handle -U's, -D's and
+ -A's in the order they were seen. */
+ if (! CPP_OPTION (pfile, preprocessed))
+ init_builtins (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);
+ if (! CPP_OPTION (pfile, preprocessed))
+ (*p->handler) (pfile, p->arg);
q = p->next;
free (p);
p = q;
}
+
pfile->done_initializing = 1;
- /* Now flush any output recorded during initialization, and advance
- to line 1 of the main input file. */
- CPP_BUFFER (pfile)->lineno = 1;
+ /* 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);
- if (print && ! CPP_OPTION (pfile, no_output))
- cpp_output_tokens (pfile, print, 1);
+ free (CPP_OPTION (pfile, pending));
+ CPP_OPTION (pfile, pending) = NULL;
- /* The -imacros files can be scanned now, but the -include files
- have to be pushed onto the include stack and processed later,
- in the main loop calling cpp_get_token. */
+ return 1;
+}
- p = CPP_OPTION (pfile, pending)->imacros_head;
- while (p)
- {
- if (cpp_read_file (pfile, p->arg))
- cpp_scan_buffer_nooutput (pfile);
- q = p->next;
- free (p);
- p = q;
- }
+/* 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 *deps_mode = CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
- p = CPP_OPTION (pfile, pending)->include_head;
- while (p)
+ if (CPP_OPTION (pfile, deps_file) == 0)
+ deps_stream = stdout;
+ else
{
- if (cpp_read_file (pfile, p->arg)
- && print && ! CPP_OPTION (pfile, no_output))
- cpp_output_tokens (pfile, print, 1); /* record entry to file */
- q = p->next;
- free (p);
- p = q;
+ 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;
+ }
}
- free (CPP_OPTION (pfile, pending));
- CPP_OPTION (pfile, pending) = NULL;
+ deps_write (pfile->deps, deps_stream, 72);
- return 1;
+ 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. */
+ with a new filename to restart processing. */
void
-cpp_finish (pfile, print)
+cpp_finish (pfile)
cpp_reader *pfile;
- cpp_printer *print;
{
if (CPP_BUFFER (pfile))
{
/* Don't write the deps file if preprocessing has failed. */
if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
- {
- /* 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
- {
- deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
- if (deps_stream == 0)
- cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
- }
- if (deps_stream)
- {
- deps_write (pfile->deps, deps_stream, 72);
- if (CPP_OPTION (pfile, deps_file))
- {
- if (ferror (deps_stream) || fclose (deps_stream) != 0)
- cpp_fatal (pfile, "I/O error on output");
- }
- }
- }
-
- if (CPP_OPTION (pfile, dump_macros) == dump_only)
- _cpp_dump_macro_hash (pfile);
-
- /* Flush any pending output. */
- if (print)
- {
- cpp_output_tokens (pfile, print, print->lineno);
- if (ferror (print->outf) || fclose (print->outf))
- cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
- }
+ output_deps (pfile);
/* Report on headers that could use multiple include guards. */
if (CPP_OPTION (pfile, print_include_names))
#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. */
DEF_OPT("$", 0, OPT_dollar) \
DEF_OPT("+", 0, OPT_plus) \
DEF_OPT("-help", 0, OPT__help) \
+ DEF_OPT("-target-help", 0, OPT_target__help) \
DEF_OPT("-version", 0, OPT__version) \
DEF_OPT("A", no_ass, OPT_A) \
DEF_OPT("C", 0, OPT_C) \
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("MP", 0, OPT_MP) \
+ DEF_OPT("MQ", no_tgt, OPT_MQ) \
+ DEF_OPT("MT", no_tgt, OPT_MT) \
DEF_OPT("P", 0, OPT_P) \
DEF_OPT("U", no_mac, OPT_U) \
DEF_OPT("W", no_arg, OPT_W) /* arg optional */ \
DEF_OPT("d", no_arg, OPT_d) \
DEF_OPT("fleading-underscore", 0, OPT_fleading_underscore) \
DEF_OPT("fno-leading-underscore", 0, OPT_fno_leading_underscore) \
+ DEF_OPT("fno-operator-names", 0, OPT_fno_operator_names) \
DEF_OPT("fno-preprocessed", 0, OPT_fno_preprocessed) \
DEF_OPT("fno-show-column", 0, OPT_fno_show_column) \
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) \
DEF_OPT("lang-c", 0, OPT_lang_c) \
DEF_OPT("lang-c++", 0, OPT_lang_cplusplus) \
DEF_OPT("lang-c89", 0, OPT_lang_c89) \
- DEF_OPT("lang-chill", 0, OPT_lang_chill) \
- DEF_OPT("lang-fortran", 0, OPT_lang_fortran) \
DEF_OPT("lang-objc", 0, OPT_lang_objc) \
DEF_OPT("lang-objc++", 0, OPT_lang_objcplusplus) \
DEF_OPT("nostdinc", 0, OPT_nostdinc) \
DEF_OPT("pedantic", 0, OPT_pedantic) \
DEF_OPT("pedantic-errors", 0, OPT_pedantic_errors) \
DEF_OPT("remap", 0, OPT_remap) \
+ DEF_OPT("std=c++98", 0, OPT_std_cplusplus98) \
DEF_OPT("std=c89", 0, OPT_std_c89) \
DEF_OPT("std=c99", 0, OPT_std_c99) \
DEF_OPT("std=c9x", 0, OPT_std_c9x) \
DEF_OPT("std=iso9899:199409", 0, OPT_std_iso9899_199409) \
DEF_OPT("std=iso9899:1999", 0, OPT_std_iso9899_1999) \
DEF_OPT("std=iso9899:199x", 0, OPT_std_iso9899_199x) \
- DEF_OPT("traditional", 0, OPT_traditional) \
DEF_OPT("trigraphs", 0, OPT_trigraphs) \
DEF_OPT("v", 0, OPT_v) \
+ DEF_OPT("version", 0, OPT_version) \
DEF_OPT("w", 0, OPT_w)
#define DEF_OPT(text, msg, code) code,
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;
md = (mn + mx) / 2;
opt_len = cl_options[md].opt_len;
- comp = strncmp (input, cl_options[md].opt_text, opt_len);
+ comp = memcmp (input, cl_options[md].opt_text, opt_len);
if (comp > 0)
mn = md + 1;
we may match a later option or we may have been passed the
argument. The longest possible option match succeeds.
If the option takes no arguments we have not matched and
- continue the search (e.g. input="stdc++" match was "stdc") */
+ continue the search (e.g. input="stdc++" match was "stdc"). */
mn = md + 1;
if (cl_options[md].msg)
{
/* Scan forwards. If we get an exact match, return it.
Otherwise, return the longest option-accepting match.
- This loops no more than twice with current options */
+ This loops no more than twice with current options. */
mx = md;
for (; mn < N_OPTS; mn++)
{
opt_len = cl_options[mn].opt_len;
- if (strncmp (input, cl_options[mn].opt_text, opt_len))
+ if (memcmp (input, cl_options[mn].opt_text, opt_len))
break;
if (input[opt_len] == '\0')
return mn;
Can be called multiple times, to handle multiple sets of options.
Returns number of strings consumed. */
-static int
-handle_option (pfile, argc, argv)
+int
+cpp_handle_option (pfile, argc, argv)
cpp_reader *pfile;
int argc;
char **argv;
int opt_index;
const char *arg = 0;
- /* Skip over '-' */
+ /* Skip over '-'. */
opt_index = parse_option (&argv[i][1]);
if (opt_index < 0)
return i;
{
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))
+ another field to the cl_options table. */
+ if (arg[0] == '\0' && opt_code != OPT_W)
{
arg = argv[++i];
if (!arg)
switch (opt_code)
{
- case N_OPTS: /* shut GCC up */
+ case N_OPTS: /* Shut GCC up. */
break;
case OPT_fleading_underscore:
- user_label_prefix = "_";
+ CPP_OPTION (pfile, user_label_prefix) = "_";
break;
case OPT_fno_leading_underscore:
- user_label_prefix = "";
+ CPP_OPTION (pfile, user_label_prefix) = "";
+ break;
+ case OPT_fno_operator_names:
+ CPP_OPTION (pfile, operator_names) = 0;
break;
case OPT_fpreprocessed:
CPP_OPTION (pfile, preprocessed) = 1;
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 ();
- exit (0); /* XXX */
+ 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. */
+ 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:
- fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string);
- exit (0); /* XXX */
+ CPP_OPTION (pfile, help_only) = 1;
+ goto version;
+ case OPT_v:
+ CPP_OPTION (pfile, verbose) = 1;
+ goto version;
+
+ case OPT_version:
+ version:
+ fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string);
+#ifdef TARGET_VERSION
+ TARGET_VERSION;
+#endif
+ fputc ('\n', stderr);
break;
+
case OPT_C:
CPP_OPTION (pfile, discard_comments) = 0;
break;
case OPT_P:
CPP_OPTION (pfile, no_line_commands) = 1;
break;
- case OPT_dollar: /* Don't include $ in identifiers. */
+ case OPT_dollar: /* Don't include $ in identifiers. */
CPP_OPTION (pfile, dollars_in_ident) = 0;
break;
case OPT_H:
case OPT_pedantic:
CPP_OPTION (pfile, pedantic) = 1;
break;
- case OPT_traditional:
- CPP_OPTION (pfile, traditional) = 1;
- CPP_OPTION (pfile, cplusplus_comments) = 0;
- CPP_OPTION (pfile, trigraphs) = 0;
- CPP_OPTION (pfile, warn_trigraphs) = 0;
- break;
case OPT_trigraphs:
CPP_OPTION (pfile, trigraphs) = 1;
break;
CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
break;
case OPT_lang_c:
- CPP_OPTION (pfile, cplusplus) = 0;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, c89) = 0;
- CPP_OPTION (pfile, c99) = 1;
- CPP_OPTION (pfile, objc) = 0;
- break;
- case OPT_lang_c89:
- CPP_OPTION (pfile, cplusplus) = 0;
- CPP_OPTION (pfile, cplusplus_comments) = 0;
- CPP_OPTION (pfile, c89) = 1;
- CPP_OPTION (pfile, c99) = 0;
- CPP_OPTION (pfile, objc) = 0;
- CPP_OPTION (pfile, trigraphs) = 1;
- new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
+ set_lang (pfile, CLK_GNUC89);
break;
case OPT_lang_cplusplus:
- CPP_OPTION (pfile, cplusplus) = 1;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, c89) = 0;
- CPP_OPTION (pfile, c99) = 0;
- CPP_OPTION (pfile, objc) = 0;
- new_pending_directive (pend, "__cplusplus", cpp_define);
+ set_lang (pfile, CLK_GNUCXX);
break;
- case OPT_lang_objcplusplus:
- CPP_OPTION (pfile, cplusplus) = 1;
- new_pending_directive (pend, "__cplusplus", cpp_define);
- /* fall through */
case OPT_lang_objc:
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, c89) = 0;
- CPP_OPTION (pfile, c99) = 0;
- CPP_OPTION (pfile, objc) = 1;
- new_pending_directive (pend, "__OBJC__", cpp_define);
- break;
- case OPT_lang_asm:
- CPP_OPTION (pfile, lang_asm) = 1;
- CPP_OPTION (pfile, dollars_in_ident) = 0;
- new_pending_directive (pend, "__ASSEMBLER__", cpp_define);
- break;
- case OPT_lang_fortran:
- CPP_OPTION (pfile, lang_fortran) = 1;
- CPP_OPTION (pfile, traditional) = 1;
- CPP_OPTION (pfile, cplusplus_comments) = 0;
- new_pending_directive (pend, "_LANGUAGE_FORTRAN", cpp_define);
+ set_lang (pfile, CLK_OBJC);
break;
- case OPT_lang_chill:
- CPP_OPTION (pfile, objc) = 0;
- CPP_OPTION (pfile, cplusplus) = 0;
- CPP_OPTION (pfile, chill) = 1;
- CPP_OPTION (pfile, traditional) = 1;
+ case OPT_lang_objcplusplus:
+ set_lang (pfile, CLK_OBJCXX);
break;
- case OPT_nostdinc:
- /* -nostdinc causes no default include directories.
- You must specify all include-file directories with -I. */
- CPP_OPTION (pfile, no_standard_includes) = 1;
+ case OPT_lang_asm:
+ set_lang (pfile, CLK_ASM);
break;
- case OPT_nostdincplusplus:
- /* -nostdinc++ causes no default C++-specific include directories. */
- CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
+ case OPT_std_cplusplus98:
+ set_lang (pfile, CLK_CXX98);
break;
case OPT_std_gnu89:
- CPP_OPTION (pfile, cplusplus) = 0;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, c89) = 1;
- CPP_OPTION (pfile, c99) = 0;
- CPP_OPTION (pfile, objc) = 0;
+ set_lang (pfile, CLK_GNUC89);
break;
case OPT_std_gnu9x:
case OPT_std_gnu99:
- CPP_OPTION (pfile, cplusplus) = 0;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, c89) = 0;
- CPP_OPTION (pfile, c99) = 1;
- CPP_OPTION (pfile, objc) = 0;
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STDC_VERSION__=199901L", cpp_define);
+ set_lang (pfile, CLK_GNUC99);
break;
case OPT_std_iso9899_199409:
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STDC_VERSION__=199409L", cpp_define);
- /* Fall through */
+ set_lang (pfile, CLK_STDC94);
+ break;
case OPT_std_iso9899_1990:
case OPT_std_c89:
- CPP_OPTION (pfile, cplusplus) = 0;
- CPP_OPTION (pfile, cplusplus_comments) = 0;
- CPP_OPTION (pfile, c89) = 1;
- CPP_OPTION (pfile, c99) = 0;
- CPP_OPTION (pfile, objc) = 0;
- CPP_OPTION (pfile, trigraphs) = 1;
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STRICT_ANSI__", cpp_define);
+ case OPT_lang_c89:
+ set_lang (pfile, CLK_STDC89);
break;
case OPT_std_iso9899_199x:
case OPT_std_iso9899_1999:
case OPT_std_c9x:
case OPT_std_c99:
- CPP_OPTION (pfile, cplusplus) = 0;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- CPP_OPTION (pfile, c89) = 0;
- CPP_OPTION (pfile, c99) = 1;
- CPP_OPTION (pfile, objc) = 0;
- CPP_OPTION (pfile, trigraphs) = 1;
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STRICT_ANSI__", cpp_define);
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STDC_VERSION__=199901L", cpp_define);
+ set_lang (pfile, CLK_STDC99);
+ break;
+ case OPT_nostdinc:
+ /* -nostdinc causes no default include directories.
+ You must specify all include-file directories with -I. */
+ CPP_OPTION (pfile, no_standard_includes) = 1;
+ break;
+ case OPT_nostdincplusplus:
+ /* -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 (!strcmp (CPP_OPTION (pfile, out_fname), "-"))
CPP_OPTION (pfile, out_fname) = "";
break;
- case OPT_v:
- fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string);
-#ifdef TARGET_VERSION
- TARGET_VERSION;
-#endif
- fputc ('\n', stderr);
- CPP_OPTION (pfile, verbose) = 1;
- break;
case OPT_stdin_stdout:
- /* JF handle '-' as file name meaning stdin or 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)
case OPT_d:
/* Args to -d specify what parts of macros to dump.
Silently ignore unrecognised options; they may
- be aimed at the compiler proper. */
+ be aimed at the compiler proper. */
{
char c;
}
}
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;
+ CPP_OPTION (pfile, print_deps) = 1;
+ break;
+ 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;
- /* For -MD and -MMD options, 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;
+ /* -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] == '-')
{
{
struct pending_option *o1, *o2;
- o1 = CPP_OPTION (pfile, pending)->directive_head;
+ o1 = pend->directive_head;
while (o1)
{
o2 = o1->next;
free (o1);
o1 = o2;
}
- CPP_OPTION (pfile, pending)->directive_head = NULL;
- CPP_OPTION (pfile, pending)->directive_tail = NULL;
+ pend->directive_head = NULL;
+ pend->directive_tail = NULL;
}
else
- new_pending_directive (CPP_OPTION (pfile, pending),
- arg + 1, cpp_unassert);
+ new_pending_directive (pend, arg + 1, cpp_unassert);
}
else
- new_pending_directive (CPP_OPTION (pfile, pending),
- arg, cpp_assert);
+ new_pending_directive (pend, arg, cpp_assert);
break;
case OPT_U:
- new_pending_directive (CPP_OPTION (pfile, pending), arg, cpp_undef);
+ new_pending_directive (pend, arg, cpp_undef);
break;
case OPT_I: /* Add directory to path for includes. */
if (!strcmp (arg, "-"))
the default setup; -I. uses the compiler's working dir.) */
if (! CPP_OPTION (pfile, ignore_srcdir))
{
- struct cpp_pending *pend = CPP_OPTION (pfile, pending);
pend->quote_head = pend->brack_head;
pend->quote_tail = pend->brack_tail;
pend->brack_head = 0;
}
}
else
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- xstrdup (arg), BRACKET, 0);
+ append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
break;
case OPT_isystem:
/* Add directory to beginning of system include path, as a system
- include directory. */
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- xstrdup (arg), SYSTEM, 0);
+ include directory. */
+ append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
break;
case OPT_include:
{
/* 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 = CPP_OPTION (pfile, pending)->include_head;
- CPP_OPTION (pfile, pending)->include_head = o;
+ o->next = pend->include_head;
+ pend->include_head = o;
}
break;
case OPT_imacros:
o->arg = arg;
o->next = NULL;
- APPEND (CPP_OPTION (pfile, pending), imacros, o);
+ APPEND (pend, imacros, o);
}
break;
case OPT_iwithprefix:
else
fname = xstrdup (arg);
- append_include_chain (pfile, CPP_OPTION (pfile, pending), fname,
+ append_include_chain (pfile, fname,
opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
}
break;
case OPT_idirafter:
/* Add directory to end of path for includes. */
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- xstrdup (arg), AFTER, 0);
+ append_include_chain (pfile, xstrdup (arg), AFTER, 0);
break;
case OPT_W:
- /* Silently ignore unrecognised options */
+ /* Silently ignore unrecognised options. */
if (!strcmp (argv[i], "-Wall"))
{
CPP_OPTION (pfile, warn_trigraphs) = 1;
CPP_OPTION (pfile, warn_undef) = 1;
else if (!strcmp (argv[i], "-Wimport"))
CPP_OPTION (pfile, warn_import) = 1;
- else if (!strcmp (argv[i], "-Wpaste"))
- CPP_OPTION (pfile, warn_paste) = 1;
else if (!strcmp (argv[i], "-Werror"))
CPP_OPTION (pfile, warnings_are_errors) = 1;
+ else if (!strcmp (argv[i], "-Wsystem-headers"))
+ CPP_OPTION (pfile, warn_system_headers) = 1;
else if (!strcmp (argv[i], "-Wno-traditional"))
CPP_OPTION (pfile, warn_traditional) = 0;
else if (!strcmp (argv[i], "-Wno-trigraphs"))
CPP_OPTION (pfile, warn_undef) = 0;
else if (!strcmp (argv[i], "-Wno-import"))
CPP_OPTION (pfile, warn_import) = 0;
- else if (!strcmp (argv[i], "-Wno-paste"))
- CPP_OPTION (pfile, warn_paste) = 0;
else if (!strcmp (argv[i], "-Wno-error"))
CPP_OPTION (pfile, warnings_are_errors) = 0;
+ else if (!strcmp (argv[i], "-Wno-system-headers"))
+ CPP_OPTION (pfile, warn_system_headers) = 0;
break;
}
}
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.
int i;
int strings_processed;
-#ifdef HOST_EBCDIC
- static int opts_sorted = 0;
-
- if (!opts_sorted)
- {
- opts_sorted = 1;
- /* For non-ASCII hosts, the array needs to be sorted at runtime */
- qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
- }
-#endif
-
for (i = 0; i < argc; i += strings_processed)
{
- strings_processed = handle_option (pfile, argc - i, argv + i);
+ strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
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;
+{
+ /* -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;
+
+ /* 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. The user may be requesting other stuff to
+ stdout, with -dM, -v etc. We let them shoot themselves in the
+ foot. */
+ if (CPP_OPTION (pfile, deps_file) == 0
+ || CPP_OPTION (pfile, print_deps_missing_files))
+ CPP_OPTION (pfile, no_output) = 1;
+}
+
static void
print_help ()
{
fputs (_("\
-pedantic Issue all warnings demanded by strict ISO C\n\
-pedantic-errors Issue -pedantic warnings as errors instead\n\
- -traditional Follow K&R pre-processor behaviour\n\
-trigraphs Support ISO C trigraphs\n\
-lang-c Assume that the input sources are in C\n\
-lang-c89 Assume that the input sources are in C89\n\
- -lang-c++ Assume that the input sources are in C++\n\
"), stdout);
fputs (_("\
+ -lang-c++ Assume that the input sources are in C++\n\
-lang-objc Assume that the input sources are in ObjectiveC\n\
-lang-objc++ Assume that the input sources are in ObjectiveC++\n\
-lang-asm Assume that the input sources are in assembler\n\
- -lang-fortran Assume that the input sources are in Fortran\n\
- -lang-chill Assume that the input sources are in Chill\n\
"), stdout);
fputs (_("\
-std=<std name> Specify the conformance standard; one of:\n\
"), stdout);
fputs (_("\
-Wno-comment{s} Do not warn about comments\n\
- -Wtraditional Warn if a macro argument is/would be turned into\n\
- a string if -traditional is specified\n\
- -Wno-traditional Do not warn about stringification\n\
+ -Wtraditional Warn about features not present in traditional C\n\
+ -Wno-traditional Do not warn about traditional C\n\
-Wundef Warn if an undefined macro is used by #if\n\
-Wno-undef Do not warn about testing undefined macros\n\
-Wimport Warn about the use of the #import directive\n\
-Wno-import Do not warn about the use of #import\n\
-Werror Treat all warnings as errors\n\
-Wno-error Do not treat warnings as errors\n\
+ -Wsystem-headers Do not suppress warnings from system headers\n\
+ -Wno-system-headers Suppress warnings from system headers\n\
-Wall Enable all preprocessor warnings\n\
+"), stdout);
+ fputs (_("\
-M Generate make dependencies\n\
-MM As -M, 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\
"), stdout);
fputs (_("\
- -MD As -M, but put output in a .d file\n\
- -MMD As -MD, but ignore system header files\n\
- -MG Treat missing header file as generated files\n\
- -g3 Include #define and #undef directives in the output\n\
- -D<macro> Define a <macro> with string '1' as its value\n\
- -D<macro>=<val> Define a <macro> with <val> as its value\n\
+ -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\
+ -D<macro>=<val> Define a <macro> with <val> as its value\n\
-A<question> (<answer>) Assert the <answer> to <question>\n\
-A-<question> (<answer>) Disable the <answer> to <question>\n\
-U<macro> Undefine <macro> \n\
-v Display the version number\n\
- -H Print the name of header files as they are used\n\
- -C Do not discard comments\n\
"), stdout);
fputs (_("\
+ -H Print the name of header files as they are used\n\
+ -C Do not discard comments\n\
-dM Display a list of macro definitions active at end\n\
-dD Preserve macro definitions in output\n\
-dN As -dD except that only the names are preserved\n\
-dI Include #include directives in the output\n\
+"), stdout);
+ fputs (_("\
-ftabstop=<number> Distance between tab stops for column reporting\n\
-P Do not generate #line directives\n\
-$ Do not allow '$' in identifiers\n\
-"), stdout);
- fputs (_("\
-remap Remap file names when including files.\n\
--version Display version information\n\
-h or --help Display this information\n\