#include "config.h"
#include "system.h"
-
+#include "hashtab.h"
#include "cpplib.h"
#include "cpphash.h"
#include "output.h"
It may be overridden by the various -I and -ixxx options.
#include "file" looks in the same directory as the current file,
- then this list.
+ then this list.
#include <file> just looks in this list.
All these directories are treated as `system' include directories
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) */
+
+typedef void (* cl_directive_handler) PARAMS ((cpp_reader *, const char *));
struct pending_option
{
struct pending_option *next;
const char *arg;
- int undef;
+ cl_directive_handler handler;
};
/* The `pending' structure accumulates all the options that are not
tail pointers for quick insertion. */
struct cpp_pending
{
- struct pending_option *define_head, *define_tail;
- struct pending_option *assert_head, *assert_tail;
+ struct pending_option *directive_head, *directive_tail;
struct file_name_list *quote_head, *quote_tail;
struct file_name_list *brack_head, *brack_tail;
static void append_include_chain PARAMS ((cpp_reader *,
struct cpp_pending *,
char *, int, int));
-static void merge_include_chains PARAMS ((struct cpp_options *));
+static void merge_include_chains PARAMS ((cpp_reader *));
-static void dump_special_to_buffer PARAMS ((cpp_reader *, const char *));
+static void dump_special_to_buffer PARAMS ((cpp_reader *, const U_CHAR *,
+ size_t));
static void initialize_dependency_output PARAMS ((cpp_reader *));
static void initialize_standard_includes PARAMS ((cpp_reader *));
-static void new_pending_define PARAMS ((struct cpp_options *,
- const char *));
+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
/* Fourth argument to append_include_chain: chain to use */
enum { QUOTE = 0, BRACKET, SYSTEM, AFTER };
-/* If we have designated initializers (GCC >2.7, or C99) this table
- can be initialized, constant data. Otherwise, it has to be filled
- in at runtime. */
+/* If we have designated initializers (GCC >2.7) this table can be
+ initialized, constant data. Otherwise, it has to be filled in at
+ runtime. */
-#if (GCC_VERSION >= 2007) || (__STDC_VERSION__ >= 199901L)
+#if (GCC_VERSION >= 2007)
#define init_IStable() /* nothing */
-#define ISTABLE const unsigned char _cpp_IStable[256] = {
+#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 END }
#define s(p, v) x[p] = v;
#endif
N('1') N('2') N('3') N('4') N('5') N('6') N('7') N('8') N('9') N('0')
- H(' ') H('\t') H('\v') H('\f')
+ H('\0') H(' ') H('\t') H('\v') H('\f')
S('\n')
END
/* Dirs that don't exist are silently ignored. */
if (errno != ENOENT)
cpp_notice_from_errno (pfile, dir);
- else if (CPP_OPTIONS (pfile)->verbose)
+ else if (CPP_OPTION (pfile, verbose))
fprintf (stderr, _("ignoring nonexistent directory `%s'\n"), dir);
return;
}
len = strlen (dir);
if (len > pfile->max_include_len)
pfile->max_include_len = len;
-
+
new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
new->name = dir;
new->nlen = len;
how?) and possibly preload the include hash. */
static void
-merge_include_chains (opts)
- struct cpp_options *opts;
+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;
- qtail = opts->pending->quote_tail;
- btail = opts->pending->brack_tail;
- stail = opts->pending->systm_tail;
- atail = opts->pending->after_tail;
+ 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 = opts->pending->quote_head;
- brack = opts->pending->brack_head;
- systm = opts->pending->systm_head;
- after = opts->pending->after_head;
+ quote = pend->quote_head;
+ brack = pend->brack_head;
+ systm = pend->systm_head;
+ after = pend->after_head;
/* Paste together bracket, system, and after include chains. */
if (stail)
if (INO_T_EQ (cur->ino, other->ino)
&& cur->dev == other->dev)
{
- if (opts->verbose)
+ if (CPP_OPTION (pfile, verbose))
fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
cur->name);
if (INO_T_EQ (cur->ino, other->ino)
&& cur->dev == other->dev)
{
- if (opts->verbose)
+ if (CPP_OPTION (pfile, verbose))
fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
cur->name);
{
if (quote == qtail)
{
- if (opts->verbose)
+ if (CPP_OPTION (pfile, verbose))
fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
quote->name);
while (cur->next != qtail)
cur = cur->next;
cur->next = brack;
- if (opts->verbose)
+ if (CPP_OPTION (pfile, verbose))
fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
qtail->name);
else
quote = brack;
- opts->quote_include = quote;
- opts->bracket_include = brack;
+ CPP_OPTION (pfile, quote_include) = quote;
+ CPP_OPTION (pfile, bracket_include) = brack;
}
to PFILE's token_buffer. */
static void
-dump_special_to_buffer (pfile, macro_name)
+dump_special_to_buffer (pfile, macro_name, macro_len)
cpp_reader *pfile;
- const char *macro_name;
+ const U_CHAR *macro_name;
+ size_t macro_len;
{
static const char define_directive[] = "#define ";
- int macro_name_length = strlen (macro_name);
- output_line_command (pfile, same_file);
- CPP_RESERVE (pfile, sizeof(define_directive) + macro_name_length);
+ CPP_RESERVE (pfile, sizeof(define_directive) + macro_len);
CPP_PUTS_Q (pfile, define_directive, sizeof(define_directive)-1);
- CPP_PUTS_Q (pfile, macro_name, macro_name_length);
+ CPP_PUTS_Q (pfile, macro_name, macro_len);
CPP_PUTC_Q (pfile, ' ');
- cpp_expand_to_buffer (pfile, macro_name, macro_name_length);
+ _cpp_expand_to_buffer (pfile, macro_name, macro_len);
CPP_PUTC (pfile, '\n');
}
-/* Initialize a cpp_options structure. */
-void
-cpp_options_init (opts)
- cpp_options *opts;
-{
- memset ((char *) opts, 0, sizeof (struct cpp_options));
-
- opts->dollars_in_ident = 1;
- opts->cplusplus_comments = 1;
- opts->warn_import = 1;
- opts->discard_comments = 1;
-
- opts->pending =
- (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
-}
-
/* Initialize a cpp_reader structure. */
void
cpp_reader_init (pfile)
pfile->token_buffer = (U_CHAR *) xmalloc (pfile->token_buffer_size);
CPP_SET_WRITTEN (pfile, 0);
- pfile->hashtab = (HASHNODE **) xcalloc (HASHSIZE, sizeof (HASHNODE *));
+ CPP_OPTION (pfile, dollars_in_ident) = 1;
+ CPP_OPTION (pfile, cplusplus_comments) = 1;
+ 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));
+
+ _cpp_init_macro_hash (pfile);
+ _cpp_init_include_hash (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;
}
/* Free resources used by PFILE.
cpp_cleanup (pfile)
cpp_reader *pfile;
{
- int i;
while (CPP_BUFFER (pfile) != NULL)
cpp_pop_buffer (pfile);
if (pfile->input_buffer)
{
free (pfile->input_buffer);
- free (pfile->input_speccase);
- pfile->input_buffer = pfile->input_speccase = NULL;
+ pfile->input_buffer = NULL;
pfile->input_buffer_len = 0;
}
if (pfile->deps)
deps_free (pfile->deps);
- for (i = ALL_INCLUDE_HASHSIZE; --i >= 0; )
- {
- IHASH *imp, *next;
- for (imp = pfile->all_include_files[i]; imp; imp = next)
- {
- next = imp->next;
- free ((PTR) imp->name);
- free ((PTR) imp->nshort);
- free (imp);
- }
- pfile->all_include_files[i] = 0;
- }
-
- for (i = HASHSIZE; --i >= 0;)
- {
- while (pfile->hashtab[i])
- _cpp_delete_macro (pfile->hashtab[i]);
- }
- free (pfile->hashtab);
+ htab_delete (pfile->hashtab);
+ htab_delete (pfile->all_include_files);
}
be entered in the macro hash table under the name NAME, with value
VALUE (if any). FLAGS tweaks the behavior a little:
DUMP write debug info for this macro
- STDC define only if not -traditional
- ULP value is the global user_label_prefix (which can't be
- put directly into the table).
+ VERS value is the global version_string, quoted
+ ULP value is the global user_label_prefix
*/
struct builtin
{
- const char *name;
- const char *value;
+ const U_CHAR *name;
+ const U_CHAR *value;
unsigned short type;
unsigned short flags;
+ unsigned int len;
};
#define DUMP 0x01
-#define STDC 0x02
-#define ULP 0x10
+#define VERS 0x02
+#define ULP 0x04
+#define B(n, t) { U n, 0, t, 0, sizeof n - 1 }
+#define C(n, v) { U n, U v, T_CONST, DUMP, sizeof n - 1 }
+#define X(n, v, t, f) { U n, U v, t, DUMP|f, sizeof n - 1 }
static const struct builtin builtin_array[] =
{
- { "__TIME__", 0, T_TIME, DUMP },
- { "__DATE__", 0, T_DATE, DUMP },
- { "__FILE__", 0, T_FILE, 0 },
- { "__BASE_FILE__", 0, T_BASE_FILE, 0 },
- { "__LINE__", 0, T_SPECLINE, 0 },
- { "__INCLUDE_LEVEL__", 0, T_INCLUDE_LEVEL, 0 },
- { "__VERSION__", 0, T_VERSION, DUMP },
- { "__STDC__", 0, T_STDC, DUMP|STDC },
-
- { "__USER_LABEL_PREFIX__", 0, T_CONST, ULP },
- { "__REGISTER_PREFIX__", REGISTER_PREFIX, T_CONST, 0 },
- { "__HAVE_BUILTIN_SETJMP__", "1", T_CONST, 0 },
+ 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),
+
+ X("__VERSION__", 0, T_XCONST, VERS),
+ X("__USER_LABEL_PREFIX__", 0, T_CONST, ULP),
+ X("__STDC__", "1", T_STDC, 0),
+ C("__REGISTER_PREFIX__", REGISTER_PREFIX),
+ C("__HAVE_BUILTIN_SETJMP__", "1"),
#ifndef NO_BUILTIN_SIZE_TYPE
- { "__SIZE_TYPE__", SIZE_TYPE, T_CONST, DUMP },
+ C("__SIZE_TYPE__", SIZE_TYPE),
#endif
#ifndef NO_BUILTIN_PTRDIFF_TYPE
- { "__PTRDIFF_TYPE__", PTRDIFF_TYPE, T_CONST, DUMP },
+ C("__PTRDIFF_TYPE__", PTRDIFF_TYPE),
#endif
#ifndef NO_BUILTIN_WCHAR_TYPE
- { "__WCHAR_TYPE__", WCHAR_TYPE, T_CONST, DUMP },
+ C("__WCHAR_TYPE__", WCHAR_TYPE),
#endif
- { 0, 0, 0, 0 }
};
+#undef B
+#undef C
+#undef X
+#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)
cpp_reader *pfile;
{
- int len;
const struct builtin *b;
- const char *val;
- for(b = builtin_array; b->name; b++)
+ const U_CHAR *val;
+ HASHNODE *hp;
+ for(b = builtin_array; b < builtin_array_end; b++)
{
- if ((b->flags & STDC) && CPP_TRADITIONAL (pfile))
+ if (b->type == T_STDC && CPP_TRADITIONAL (pfile))
continue;
- val = (b->flags & ULP) ? user_label_prefix : b->value;
- len = strlen (b->name);
+ if (b->flags & ULP)
+ val = (const U_CHAR *) user_label_prefix;
+ else if (b->flags & VERS)
+ {
+ val = (const U_CHAR *) xmalloc (strlen (version_string) + 3);
+ sprintf ((char *)val, "\"%s\"", version_string);
+ }
+ else
+ val = b->value;
- _cpp_install (pfile, b->name, len, b->type, val);
- if ((b->flags & DUMP) && CPP_OPTIONS (pfile)->debug_output)
- dump_special_to_buffer (pfile, b->name);
- }
+ hp = _cpp_lookup (pfile, b->name, b->len);
+ hp->value.cpval = val;
+ hp->type = b->type;
+ if ((b->flags & DUMP) && CPP_OPTION (pfile, debug_output))
+ dump_special_to_buffer (pfile, b->name, b->len);
+ }
}
#undef DUMP
#undef STDC
+#undef VERS
#undef ULP
/* Another subroutine of cpp_start_read. This one sets up to do
initialize_dependency_output (pfile)
cpp_reader *pfile;
{
- cpp_options *opts = CPP_OPTIONS (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 (opts->print_deps == 0)
+ if (CPP_OPTION (pfile, print_deps) == 0)
{
spec = getenv ("DEPENDENCIES_OUTPUT");
if (spec)
- opts->print_deps = 1;
+ CPP_OPTION (pfile, print_deps) = 1;
else
{
spec = getenv ("SUNPRO_DEPENDENCIES");
if (spec)
- opts->print_deps = 2;
+ CPP_OPTION (pfile, print_deps) = 2;
else
return;
}
s = strchr (spec, ' ');
if (s)
{
- opts->deps_target = s + 1;
+ 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
{
- opts->deps_target = 0;
+ CPP_OPTION (pfile, deps_target) = 0;
output_file = spec;
}
- opts->deps_file = output_file;
- opts->print_deps_append = 1;
+ 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 (opts->deps_target)
- deps_add_target (pfile->deps, opts->deps_target);
- else if (*opts->in_fname == 0)
+ 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, opts->in_fname);
+ deps_calc_target (pfile->deps, CPP_OPTION (pfile, in_fname));
- if (opts->in_fname)
- deps_add_dep (pfile->deps, opts->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. */
initialize_standard_includes (pfile)
cpp_reader *pfile;
{
- cpp_options *opts = CPP_OPTIONS (pfile);
char *path;
const struct default_include *p;
- const char *specd_prefix = opts->include_prefix;
+ const char *specd_prefix = CPP_OPTION (pfile, include_prefix);
/* Several environment variables may add to the include search path.
CPATH specifies an additional list of directories to be searched
GET_ENV_PATH_LIST (path, "CPATH");
if (path != 0 && *path != 0)
- path_include (pfile, opts->pending, path, BRACKET);
+ path_include (pfile, CPP_OPTION (pfile, pending), path, BRACKET);
- switch ((opts->objc << 1) + opts->cplusplus)
+ switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus))
{
case 0:
GET_ENV_PATH_LIST (path, "C_INCLUDE_PATH");
break;
}
if (path != 0 && *path != 0)
- path_include (pfile, opts->pending, path, SYSTEM);
+ path_include (pfile, CPP_OPTION (pfile, pending), path, SYSTEM);
/* Search "translated" versions of GNU directories.
These have /usr/local/lib/gcc... replaced by specd_prefix. */
if (specd_prefix != 0)
{
- char *default_prefix = alloca (sizeof GCC_INCLUDE_DIR - 7);
+ char *default_prefix = (char *) alloca (sizeof GCC_INCLUDE_DIR - 7);
/* Remove the `include' from /usr/local/lib/gcc.../include.
GCC_INCLUDE_DIR will always end in /include. */
int default_len = sizeof GCC_INCLUDE_DIR - 8;
{
/* Some standard dirs are only for C++. */
if (!p->cplusplus
- || (opts->cplusplus
- && !opts->no_standard_cplusplus_includes))
+ || (CPP_OPTION (pfile, cplusplus)
+ && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
{
/* Does this dir start with the prefix? */
if (!strncmp (p->fname, default_prefix, default_len))
p->fname + default_len,
flen - default_len + 1);
- append_include_chain (pfile, opts->pending,
+ append_include_chain (pfile, CPP_OPTION (pfile, pending),
str, SYSTEM, p->cxx_aware);
}
}
{
/* Some standard dirs are only for C++. */
if (!p->cplusplus
- || (opts->cplusplus
- && !opts->no_standard_cplusplus_includes))
+ || (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, opts->pending, str, SYSTEM,
- p->cxx_aware);
+ append_include_chain (pfile, CPP_OPTION (pfile, pending),
+ str, SYSTEM, p->cxx_aware);
}
}
}
*/
int
-cpp_start_read (pfile, fname)
+cpp_start_read (pfile, print, fname)
cpp_reader *pfile;
+ cpp_printer *print;
const char *fname;
{
- struct cpp_options *opts = CPP_OPTIONS (pfile);
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 (opts->print_deps_missing_files
- && (opts->print_deps == 0 || !opts->no_output))
+ 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 (opts->chill && opts->trigraphs)
+ if (CPP_OPTION (pfile, chill) && CPP_OPTION (pfile, trigraphs))
{
cpp_warning (pfile, "-lang-chill and -trigraphs are mutually exclusive");
- opts->trigraphs = 0;
+ CPP_OPTION (pfile, trigraphs) = 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 (user_label_prefix == NULL)
user_label_prefix = USER_LABEL_PREFIX;
/* Don't bother trying to do macro expansion if we've already done
preprocessing. */
- if (opts->preprocessed)
+ if (CPP_OPTION (pfile, preprocessed))
pfile->no_macro_expand++;
/* 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);
+
/* Set up the include search path now. */
- if (! opts->no_standard_includes)
+ if (! CPP_OPTION (pfile, no_standard_includes))
initialize_standard_includes (pfile);
- merge_include_chains (opts);
+ merge_include_chains (pfile);
/* With -v, print the list of dirs to search. */
- if (opts->verbose)
+ if (CPP_OPTION (pfile, verbose))
{
struct file_name_list *l;
fprintf (stderr, _("#include \"...\" search starts here:\n"));
- for (l = opts->quote_include; l; l = l->next)
+ for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
{
- if (l == opts->bracket_include)
+ if (l == CPP_OPTION (pfile, bracket_include))
fprintf (stderr, _("#include <...> search starts here:\n"));
fprintf (stderr, " %s\n", l->name);
}
fprintf (stderr, _("End of search list.\n"));
}
- initialize_dependency_output (pfile);
-
- /* Open the main input file. This must be done before -D processing
- so we have a buffer to stand on. */
- if (opts->in_fname == NULL || *opts->in_fname == 0)
+ /* 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)
{
- opts->in_fname = fname;
- if (opts->in_fname == NULL)
- opts->in_fname = "";
+ 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_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)
+ {
+ print->lineno = 0;
+ print->last_fname = CPP_BUFFER (pfile)->nominal_fname;
+ print->last_bsd = pfile->buffer_stack_depth;
+ print->written = CPP_WRITTEN (pfile);
+ }
+
/* Install __LINE__, etc. */
initialize_builtins (pfile);
/* Do -U's, -D's and -A's in the order they were seen. */
- p = opts->pending->define_head;
+ p = CPP_OPTION (pfile, pending)->directive_head;
while (p)
{
- if (p->undef)
- cpp_undef (pfile, p->arg);
- else
- cpp_define (pfile, p->arg);
-
+ (*p->handler) (pfile, p->arg);
q = p->next;
free (p);
p = q;
}
-
- p = opts->pending->assert_head;
- while (p)
- {
- if (p->undef)
- cpp_unassert (pfile, p->arg);
- else
- cpp_assert (pfile, p->arg);
-
- q = p->next;
- free (p);
- p = q;
- }
-
- opts->done_initializing = 1;
- CPP_BUFFER (pfile)->lineno = 1;
-
- if (opts->preprocessed)
- /* If we've already processed this code, we want to trust the #line
- directives in the input. But we still need to update our line
- counter accordingly. */
- pfile->lineno = CPP_BUFFER (pfile)->lineno;
- else
- output_line_command (pfile, same_file);
+ pfile->done_initializing = 1;
pfile->only_seen_white = 2;
+ CPP_BUFFER (pfile)->lineno = 1;
+ if (print && ! CPP_OPTION (pfile, no_output))
+ cpp_output_tokens (pfile, print);
/* 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. */
-
- opts->no_output++;
- p = opts->pending->imacros_head;
+
+ p = CPP_OPTION (pfile, pending)->imacros_head;
while (p)
{
if (cpp_read_file (pfile, p->arg))
- cpp_scan_buffer (pfile);
-
+ cpp_scan_buffer_nooutput (pfile);
q = p->next;
free (p);
p = q;
}
- opts->no_output--;
- p = opts->pending->include_head;
+ p = CPP_OPTION (pfile, pending)->include_head;
while (p)
{
- if (cpp_read_file (pfile, p->arg))
- output_line_command (pfile, enter_file);
-
+ if (cpp_read_file (pfile, p->arg)
+ && print && ! CPP_OPTION (pfile, no_output))
+ cpp_output_tokens (pfile, print);
q = p->next;
free (p);
p = q;
}
- free (opts->pending);
- opts->pending = NULL;
+ free (CPP_OPTION (pfile, pending));
+ CPP_OPTION (pfile, pending) = NULL;
return 1;
}
clear macro definitions, such that you could call cpp_start_read
with a new filename to restart processing. */
void
-cpp_finish (pfile)
+cpp_finish (pfile, print)
cpp_reader *pfile;
+ cpp_printer *print;
{
- struct cpp_options *opts = CPP_OPTIONS (pfile);
-
- if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)))
- cpp_ice (pfile, "buffers still stacked in cpp_finish");
- while (CPP_BUFFER (pfile))
- cpp_pop_buffer (pfile);
+ if (CPP_BUFFER (pfile))
+ {
+ cpp_ice (pfile, "buffers still stacked in cpp_finish");
+ while (CPP_BUFFER (pfile))
+ cpp_pop_buffer (pfile);
+ }
/* Don't write the deps file if preprocessing has failed. */
- if (opts->print_deps && pfile->errors == 0)
+ 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 = opts->print_deps_append ? "a" : "w";
- if (opts->deps_file == 0)
+ const char *deps_mode
+ = CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
+ if (CPP_OPTION (pfile, deps_file) == 0)
deps_stream = stdout;
- else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0)
- cpp_notice_from_errno (pfile, opts->deps_file);
-
+ 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 (opts->deps_file)
+ if (CPP_OPTION (pfile, deps_file))
{
if (ferror (deps_stream) || fclose (deps_stream) != 0)
cpp_fatal (pfile, "I/O error on output");
}
}
- if (opts->dump_macros == dump_only)
+ if (CPP_OPTION (pfile, dump_macros) == dump_only)
+ _cpp_dump_macro_hash (pfile);
+
+ /* Flush any pending output. */
+ if (print)
{
- int i;
- HASHNODE *h;
- for (i = HASHSIZE; --i >= 0;)
- {
- for (h = pfile->hashtab[i]; h; h = h->next)
- if (h->type == T_MACRO)
- {
- _cpp_dump_definition (pfile, h->name, h->length,
- h->value.defn);
- CPP_PUTC (pfile, '\n');
- }
- }
+ cpp_output_tokens (pfile, print);
+ if (ferror (print->outf) || fclose (print->outf))
+ cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
}
}
static void
-new_pending_define (opts, text)
- struct cpp_options *opts;
+new_pending_directive (pend, text, handler)
+ struct cpp_pending *pend;
const char *text;
+ cl_directive_handler handler;
{
struct pending_option *o = (struct pending_option *)
xmalloc (sizeof (struct pending_option));
o->arg = text;
o->next = NULL;
- o->undef = 0;
- APPEND (opts->pending, define, o);
+ o->handler = handler;
+ APPEND (pend, directive, o);
}
+/* 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")
+
+/* 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("-version", 0, OPT__version) \
+ DEF_OPT("A", no_ass, OPT_A) \
+ DEF_OPT("C", 0, OPT_C) \
+ DEF_OPT("D", no_mac, OPT_D) \
+ DEF_OPT("H", 0, OPT_H) \
+ DEF_OPT("I", no_dir, OPT_I) \
+ DEF_OPT("M", 0, OPT_M) \
+ DEF_OPT("MD", no_fil, OPT_MD) \
+ DEF_OPT("MG", 0, OPT_MG) \
+ DEF_OPT("MM", 0, OPT_MM) \
+ DEF_OPT("MMD", no_fil, OPT_MMD) \
+ 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-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("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("include", no_fil, OPT_include) \
+ DEF_OPT("iprefix", no_pth, OPT_iprefix) \
+ DEF_OPT("isystem", no_dir, OPT_isystem) \
+ DEF_OPT("iwithprefix", no_dir, OPT_iwithprefix) \
+ DEF_OPT("iwithprefixbefore", no_dir, OPT_iwithprefixbefore) \
+ DEF_OPT("lang-asm", 0, OPT_lang_asm) \
+ 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("nostdinc++", 0, OPT_nostdincplusplus) \
+ DEF_OPT("o", no_fil, OPT_o) \
+ DEF_OPT("pedantic", 0, OPT_pedantic) \
+ DEF_OPT("pedantic-errors", 0, OPT_pedantic_errors) \
+ DEF_OPT("remap", 0, OPT_remap) \
+ 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=gnu89", 0, OPT_std_gnu89) \
+ DEF_OPT("std=gnu99", 0, OPT_std_gnu99) \
+ DEF_OPT("std=gnu9x", 0, OPT_std_gnu9x) \
+ DEF_OPT("std=iso9899:1990", 0, OPT_std_iso9899_1990) \
+ 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("w", 0, OPT_w)
+
+#define DEF_OPT(text, msg, code) code,
enum opt_code
{
- OPT_stdin_stdout = 0, OPT_dollar, OPT_plus,
- OPT__help, OPT__version,
- OPT_A, OPT_C, OPT_D, OPT_H, OPT_I, OPT_M,
- OPT_MD, OPT_MG, OPT_MM, OPT_MMD,
- OPT_P, OPT_U, OPT_W,
- OPT_d,
- OPT_fleading_underscore, OPT_fno_leading_underscore,
- OPT_fpreprocessed, OPT_fno_preprocessed,
- OPT_g, OPT_h,
- OPT_idirafter, OPT_imacros, OPT_include,
- OPT_iprefix, OPT_isystem, OPT_iwithprefix, OPT_iwithprefixbefore,
- OPT_lang_asm, OPT_lang_c, OPT_lang_cplusplus, OPT_lang_c89,
- OPT_lang_chill, OPT_lang_fortran, OPT_lang_objc, OPT_lang_objcplusplus,
- OPT_nostdinc, OPT_nostdincplusplus,
- OPT_o,
- OPT_pedantic, OPT_pedantic_errors, OPT_remap,
- OPT_std_c89, OPT_std_c99, OPT_std_c9x, OPT_std_gnu89, OPT_std_gnu99,
- OPT_std_gnu9x, OPT_std_iso9899_1990, OPT_std_iso9899_199409,
- OPT_std_iso9899_1999, OPT_std_iso9899_199x,
- OPT_traditional, OPT_trigraphs,
- OPT_v, OPT_w,
+ COMMAND_LINE_OPTIONS
N_OPTS
};
+#undef DEF_OPT
struct cl_option
{
enum opt_code opt_code;
};
-static const char no_arg[] = N_("Argument missing after `%s' option");
-static const char no_ass[] = N_("Assertion missing after `%s' option");
-static const char no_dir[] = N_("Directory name missing after `%s' option");
-static const char no_fil[] = N_("File name missing after `%s' option");
-static const char no_mac[] = N_("Macro name missing after `%s' option");
-static const char no_pth[] = N_("Path name missing after `%s' option");
-
-/* This list must be ASCII sorted. Make enum order above match this. */
-#define DEF_OPT(text, msg, code) {text, msg, sizeof(text) - 1, code}
-
+#define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
#ifdef HOST_EBCDIC
static struct cl_option cl_options[] =
#else
static const struct cl_option cl_options[] =
#endif
{
- DEF_OPT("", 0, OPT_stdin_stdout),
- DEF_OPT("$", 0, OPT_dollar),
- DEF_OPT("+", 0, OPT_plus),
- DEF_OPT("-help", 0, OPT__help),
- DEF_OPT("-version", 0, OPT__version),
- DEF_OPT("A", no_ass, OPT_A),
- DEF_OPT("C", 0, OPT_C),
- DEF_OPT("D", no_mac, OPT_D),
- DEF_OPT("H", 0, OPT_H),
- DEF_OPT("I", no_dir, OPT_I),
- DEF_OPT("M", 0, OPT_M),
- DEF_OPT("MD", no_fil, OPT_MD),
- DEF_OPT("MG", 0, OPT_MG),
- DEF_OPT("MM", 0, OPT_MM),
- DEF_OPT("MMD", no_fil, OPT_MMD),
- DEF_OPT("P", 0, OPT_P),
- DEF_OPT("U", no_mac, OPT_U),
- /* NB: Immed arg only, and not reqd */
- DEF_OPT("W", no_arg, OPT_W),
- 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("fpreprocessed", 0, OPT_fpreprocessed),
- DEF_OPT("fno-preprocessed", 0, OPT_fno_preprocessed),
- /* NB: Immed arg only, and not reqd */
- DEF_OPT("g", no_arg, OPT_g),
- DEF_OPT("h", 0, OPT_h),
- DEF_OPT("idirafter", no_dir, OPT_idirafter),
- DEF_OPT("imacros", no_fil, OPT_imacros),
- DEF_OPT("include", no_fil, OPT_include),
- DEF_OPT("iprefix", no_pth, OPT_iprefix),
- DEF_OPT("isystem", no_dir, OPT_isystem),
- DEF_OPT("iwithprefix", no_dir, OPT_iwithprefix),
- DEF_OPT("iwithprefixbefore", no_dir, OPT_iwithprefixbefore),
- DEF_OPT("lang-asm", 0, OPT_lang_asm),
- 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("nostdinc++", 0, OPT_nostdincplusplus),
- DEF_OPT("o", no_fil, OPT_o),
- DEF_OPT("pedantic", 0, OPT_pedantic),
- DEF_OPT("pedantic-errors", 0, OPT_pedantic_errors),
- DEF_OPT("remap", 0, OPT_remap),
- 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=gnu89", 0, OPT_std_gnu89),
- DEF_OPT("std=gnu99", 0, OPT_std_gnu99),
- DEF_OPT("std=gnu9x", 0, OPT_std_gnu9x),
- DEF_OPT("std=iso9899:1990", 0, OPT_std_iso9899_1990),
- 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("w", 0, OPT_w)
+ COMMAND_LINE_OPTIONS
};
#undef DEF_OPT
+#undef COMMAND_LINE_OPTIONS
/* Perform a binary search to find which, if any, option the given
command-line matches. Returns its index in the option array,
while (mx > mn)
{
md = (mn + mx) / 2;
-
+
opt_len = cl_options[md].opt_len;
comp = strncmp (input, cl_options[md].opt_text, opt_len);
-
+
if (comp > 0)
mn = md + 1;
else if (comp < 0)
int argc;
char **argv;
{
- struct cpp_options *opts = CPP_OPTIONS (pfile);
int i = 0;
if (argv[i][0] != '-')
{
- if (opts->out_fname != NULL)
- {
- print_help ();
- cpp_fatal (pfile, "Too many arguments");
- }
- else if (opts->in_fname != NULL)
- opts->out_fname = argv[i];
+ 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)
+ CPP_OPTION (pfile, out_fname) = argv[i];
else
- opts->in_fname = argv[i];
+ CPP_OPTION (pfile, in_fname) = argv[i];
}
else
{
arg = argv[++i];
if (!arg)
{
- cpp_fatal (pfile, _(cl_options[opt_index].msg), argv[i - 1]);
+ cpp_fatal (pfile, cl_options[opt_index].msg, argv[i - 1]);
return argc;
}
}
}
-
+
switch (opt_code)
{
case N_OPTS: /* shut GCC up */
user_label_prefix = "";
break;
case OPT_fpreprocessed:
- opts->preprocessed = 1;
+ CPP_OPTION (pfile, preprocessed) = 1;
break;
case OPT_fno_preprocessed:
- opts->preprocessed = 0;
+ CPP_OPTION (pfile, preprocessed) = 0;
+ break;
+ case OPT_fshow_column:
+ CPP_OPTION (pfile, show_column) = 1;
+ break;
+ case OPT_fno_show_column:
+ CPP_OPTION (pfile, show_column) = 0;
break;
case OPT_w:
- opts->inhibit_warnings = 1;
+ CPP_OPTION (pfile, inhibit_warnings) = 1;
break;
case OPT_g: /* Silently ignore anything but -g3 */
if (!strcmp(&argv[i][2], "3"))
- opts->debug_output = 1;
+ CPP_OPTION (pfile, debug_output) = 1;
break;
case OPT_h:
case OPT__help:
exit (0); /* XXX */
break;
case OPT_C:
- opts->discard_comments = 0;
+ CPP_OPTION (pfile, discard_comments) = 0;
break;
case OPT_P:
- opts->no_line_commands = 1;
+ CPP_OPTION (pfile, no_line_commands) = 1;
break;
case OPT_dollar: /* Don't include $ in identifiers. */
- opts->dollars_in_ident = 0;
+ CPP_OPTION (pfile, dollars_in_ident) = 0;
break;
case OPT_H:
- opts->print_include_names = 1;
+ CPP_OPTION (pfile, print_include_names) = 1;
break;
case OPT_D:
- new_pending_define (opts, arg);
+ new_pending_directive (CPP_OPTION (pfile, pending), arg, cpp_define);
break;
case OPT_pedantic_errors:
- opts->pedantic_errors = 1;
+ CPP_OPTION (pfile, pedantic_errors) = 1;
/* fall through */
case OPT_pedantic:
- opts->pedantic = 1;
+ CPP_OPTION (pfile, pedantic) = 1;
break;
case OPT_traditional:
- opts->traditional = 1;
- opts->cplusplus_comments = 0;
- opts->trigraphs = 0;
- opts->warn_trigraphs = 0;
+ 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:
- opts->trigraphs = 1;
+ CPP_OPTION (pfile, trigraphs) = 1;
break;
case OPT_plus:
- opts->cplusplus = 1;
- opts->cplusplus_comments = 1;
+ CPP_OPTION (pfile, cplusplus) = 1;
+ CPP_OPTION (pfile, cplusplus_comments) = 1;
break;
case OPT_remap:
- opts->remap = 1;
+ CPP_OPTION (pfile, remap) = 1;
break;
case OPT_iprefix:
- opts->include_prefix = arg;
- opts->include_prefix_len = strlen (arg);
+ CPP_OPTION (pfile, include_prefix) = arg;
+ CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
break;
case OPT_lang_c:
- opts->cplusplus = 0, opts->cplusplus_comments = 1;
- opts->c89 = 0, opts->c99 = 1, opts->objc = 0;
+ 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:
- opts->cplusplus = 0, opts->cplusplus_comments = 0;
- opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
- opts->trigraphs = 1;
- new_pending_define (opts, "__STRICT_ANSI__");
+ 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);
break;
case OPT_lang_cplusplus:
- opts->cplusplus = 1, opts->cplusplus_comments = 1;
- opts->c89 = 0, opts->c99 = 0, opts->objc = 0;
+ 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;
break;
case OPT_lang_objc:
case OPT_lang_objcplusplus:
- opts->cplusplus = opt_code == OPT_lang_objcplusplus;
- opts->cplusplus_comments = 1;
- opts->c89 = 0, opts->c99 = 0, opts->objc = 1;
+ CPP_OPTION (pfile, cplusplus) = opt_code == OPT_lang_objcplusplus;
+ CPP_OPTION (pfile, cplusplus_comments) = 1;
+ CPP_OPTION (pfile, c89) = 0;
+ CPP_OPTION (pfile, c99) = 0;
+ CPP_OPTION (pfile, objc) = 1;
break;
case OPT_lang_asm:
- opts->lang_asm = 1;
+ CPP_OPTION (pfile, lang_asm) = 1;
break;
case OPT_lang_fortran:
- opts->lang_fortran = 1, opts->cplusplus_comments = 0;
+ CPP_OPTION (pfile, lang_fortran) = 1;
+ CPP_OPTION (pfile, cplusplus_comments) = 0;
break;
case OPT_lang_chill:
- opts->objc = 0, opts->cplusplus = 0;
- opts->chill = 1, opts->traditional = 1;
+ CPP_OPTION (pfile, objc) = 0;
+ CPP_OPTION (pfile, cplusplus) = 0;
+ CPP_OPTION (pfile, chill) = 1;
+ CPP_OPTION (pfile, traditional) = 1;
break;
case OPT_nostdinc:
/* -nostdinc causes no default include directories.
You must specify all include-file directories with -I. */
- opts->no_standard_includes = 1;
+ CPP_OPTION (pfile, no_standard_includes) = 1;
break;
case OPT_nostdincplusplus:
/* -nostdinc++ causes no default C++-specific include directories. */
- opts->no_standard_cplusplus_includes = 1;
+ CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
break;
case OPT_std_gnu89:
- opts->cplusplus = 0, opts->cplusplus_comments = 1;
- opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
+ 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;
break;
case OPT_std_gnu9x:
case OPT_std_gnu99:
- opts->cplusplus = 0, opts->cplusplus_comments = 1;
- opts->c89 = 0, opts->c99 = 1, opts->objc = 0;
- new_pending_define (opts, "__STDC_VERSION__=199901L");
+ 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);
break;
case OPT_std_iso9899_199409:
- new_pending_define (opts, "__STDC_VERSION__=199409L");
+ new_pending_directive (CPP_OPTION (pfile, pending),
+ "__STDC_VERSION__=199409L", cpp_define);
/* Fall through */
case OPT_std_iso9899_1990:
case OPT_std_c89:
- opts->cplusplus = 0, opts->cplusplus_comments = 0;
- opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
- opts->trigraphs = 1;
- new_pending_define (opts, "__STRICT_ANSI__");
+ 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);
break;
case OPT_std_iso9899_199x:
case OPT_std_iso9899_1999:
case OPT_std_c9x:
case OPT_std_c99:
- opts->cplusplus = 0, opts->cplusplus_comments = 1;
- opts->c89 = 0, opts->c99 = 1, opts->objc = 0;
- opts->trigraphs = 1;
- new_pending_define (opts, "__STRICT_ANSI__");
- new_pending_define (opts, "__STDC_VERSION__=199901L");
+ 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);
break;
case OPT_o:
- if (opts->out_fname != NULL)
+ if (CPP_OPTION (pfile, out_fname) != NULL)
{
cpp_fatal (pfile, "Output filename specified twice");
return argc;
}
- opts->out_fname = arg;
- if (!strcmp (opts->out_fname, "-"))
- opts->out_fname = "";
+ CPP_OPTION (pfile, out_fname) = arg;
+ 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);
TARGET_VERSION;
#endif
fputc ('\n', stderr);
- opts->verbose = 1;
+ CPP_OPTION (pfile, verbose) = 1;
break;
case OPT_stdin_stdout:
/* JF handle '-' as file name meaning stdin or stdout */
- if (opts->in_fname == NULL)
- opts->in_fname = "";
- else if (opts->out_fname == NULL)
- opts->out_fname = "";
+ 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.
be aimed at the compiler proper. */
{
char c;
-
+
while ((c = *arg++) != '\0')
switch (c)
{
case 'M':
- opts->dump_macros = dump_only;
- opts->no_output = 1;
+ CPP_OPTION (pfile, dump_macros) = dump_only;
+ CPP_OPTION (pfile, no_output) = 1;
break;
case 'N':
- opts->dump_macros = dump_names;
+ CPP_OPTION (pfile, dump_macros) = dump_names;
break;
case 'D':
- opts->dump_macros = dump_definitions;
+ CPP_OPTION (pfile, dump_macros) = dump_definitions;
break;
case 'I':
- opts->dump_includes = 1;
+ CPP_OPTION (pfile, dump_includes) = 1;
break;
}
}
/* ??? -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:
- opts->print_deps_missing_files = 1;
+ CPP_OPTION (pfile, print_deps_missing_files) = 1;
break;
case OPT_M:
case OPT_MD:
case OPT_MM:
case OPT_MMD:
if (opt_code == OPT_M || opt_code == OPT_MD)
- opts->print_deps = 2;
+ CPP_OPTION (pfile, print_deps) = 2;
else
- opts->print_deps = 1;
+ CPP_OPTION (pfile, print_deps) = 1;
/* 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)
- opts->deps_file = arg;
+ CPP_OPTION (pfile, deps_file) = arg;
else
- opts->no_output = 1;
+ CPP_OPTION (pfile, no_output) = 1;
break;
case OPT_A:
- if (strcmp (arg, "-"))
- {
- struct pending_option *o = (struct pending_option *)
- xmalloc (sizeof (struct pending_option));
-
- o->arg = arg;
- o->next = NULL;
- o->undef = 0;
- APPEND (opts->pending, assert, o);
- }
- else
+ if (arg[0] == '-')
{
- /* -A- eliminates all predefined macros and assertions.
- Let's include also any that were specified earlier
- on the command line. That way we can get rid of any
- that were passed automatically in from GCC. */
- struct pending_option *o1, *o2;
-
- o1 = opts->pending->define_head;
- while (o1)
- {
- o2 = o1->next;
- free (o1);
- o1 = o2;
- }
- o1 = opts->pending->assert_head;
- while (o1)
+ /* -A with an argument beginning with '-' acts as
+ #unassert on whatever immediately follows the '-'.
+ If "-" is the whole argument, we eliminate all
+ predefined macros and assertions, including those
+ that were specified earlier on the command line.
+ That way we can get rid of any that were passed
+ automatically in from GCC. */
+
+ if (arg[1] == '\0')
{
- o2 = o1->next;
- free (o1);
- o1 = o2;
+ struct pending_option *o1, *o2;
+
+ o1 = CPP_OPTION (pfile, pending)->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;
}
- opts->pending->assert_head = NULL;
- opts->pending->assert_tail = NULL;
- opts->pending->define_head = NULL;
- opts->pending->define_tail = NULL;
+ else
+ new_pending_directive (CPP_OPTION (pfile, pending),
+ arg + 1, cpp_unassert);
}
+ else
+ new_pending_directive (CPP_OPTION (pfile, pending),
+ arg, cpp_assert);
break;
case OPT_U:
- {
- struct pending_option *o = (struct pending_option *)
- xmalloc (sizeof (struct pending_option));
-
- o->arg = arg;
- o->next = NULL;
- o->undef = 1;
- APPEND (opts->pending, define, o);
- }
+ new_pending_directive (CPP_OPTION (pfile, pending), arg, cpp_undef);
break;
case OPT_I: /* Add directory to path for includes. */
if (!strcmp (arg, "-"))
Don't search the directory of the present file
for #include "...". (Note that -I. -I- is not the same as
the default setup; -I. uses the compiler's working dir.) */
- if (! opts->ignore_srcdir)
+ if (! CPP_OPTION (pfile, ignore_srcdir))
{
- opts->ignore_srcdir = 1;
- opts->pending->quote_head = opts->pending->brack_head;
- opts->pending->quote_tail = opts->pending->brack_tail;
- opts->pending->brack_head = 0;
- opts->pending->brack_tail = 0;
+ struct cpp_pending *pend = CPP_OPTION (pfile, pending);
+ pend->quote_head = pend->brack_head;
+ pend->quote_tail = pend->brack_tail;
+ pend->brack_head = 0;
+ pend->brack_tail = 0;
+ CPP_OPTION (pfile, ignore_srcdir) = 1;
}
else
{
}
}
else
- append_include_chain (pfile, opts->pending,
+ append_include_chain (pfile, CPP_OPTION (pfile, pending),
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, opts->pending,
+ append_include_chain (pfile, CPP_OPTION (pfile, pending),
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 = opts->pending->include_head;
- opts->pending->include_head = o;
+ o->next = CPP_OPTION (pfile, pending)->include_head;
+ CPP_OPTION (pfile, pending)->include_head = o;
}
break;
case OPT_imacros:
xmalloc (sizeof (struct pending_option));
o->arg = arg;
o->next = NULL;
-
- APPEND (opts->pending, imacros, o);
+
+ APPEND (CPP_OPTION (pfile, pending), imacros, o);
}
break;
case OPT_iwithprefix:
{
char *fname;
int len;
-
+
len = strlen (arg);
-
- if (opts->include_prefix != 0)
+
+ if (CPP_OPTION (pfile, include_prefix) != 0)
{
- fname = xmalloc (opts->include_prefix_len + len + 1);
- memcpy (fname, opts->include_prefix, opts->include_prefix_len);
- memcpy (fname + opts->include_prefix_len, arg, len + 1);
+ size_t ipl = CPP_OPTION (pfile, include_prefix_len);
+ fname = xmalloc (ipl + len + 1);
+ memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
+ memcpy (fname + ipl, arg, len + 1);
}
else
{
memcpy (fname, GCC_INCLUDE_DIR, sizeof GCC_INCLUDE_DIR - 9);
memcpy (fname + sizeof GCC_INCLUDE_DIR - 9, arg, len + 1);
}
-
- append_include_chain (pfile, opts->pending, fname,
+
+ append_include_chain (pfile, CPP_OPTION (pfile, pending), fname,
opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
}
break;
case OPT_idirafter:
/* Add directory to end of path for includes. */
- append_include_chain (pfile, opts->pending,
+ append_include_chain (pfile, CPP_OPTION (pfile, pending),
xstrdup (arg), AFTER, 0);
break;
case OPT_W:
/* Silently ignore unrecognised options */
if (!strcmp (argv[i], "-Wall"))
{
- opts->warn_trigraphs = 1;
- opts->warn_comments = 1;
+ CPP_OPTION (pfile, warn_trigraphs) = 1;
+ CPP_OPTION (pfile, warn_comments) = 1;
}
else if (!strcmp (argv[i], "-Wtraditional"))
- opts->warn_stringify = 1;
+ CPP_OPTION (pfile, warn_traditional) = 1;
else if (!strcmp (argv[i], "-Wtrigraphs"))
- opts->warn_trigraphs = 1;
+ CPP_OPTION (pfile, warn_trigraphs) = 1;
else if (!strcmp (argv[i], "-Wcomment"))
- opts->warn_comments = 1;
+ CPP_OPTION (pfile, warn_comments) = 1;
else if (!strcmp (argv[i], "-Wcomments"))
- opts->warn_comments = 1;
+ CPP_OPTION (pfile, warn_comments) = 1;
else if (!strcmp (argv[i], "-Wundef"))
- opts->warn_undef = 1;
+ CPP_OPTION (pfile, warn_undef) = 1;
else if (!strcmp (argv[i], "-Wimport"))
- opts->warn_import = 1;
+ CPP_OPTION (pfile, warn_import) = 1;
else if (!strcmp (argv[i], "-Werror"))
- opts->warnings_are_errors = 1;
+ CPP_OPTION (pfile, warnings_are_errors) = 1;
else if (!strcmp (argv[i], "-Wno-traditional"))
- opts->warn_stringify = 0;
+ CPP_OPTION (pfile, warn_traditional) = 0;
else if (!strcmp (argv[i], "-Wno-trigraphs"))
- opts->warn_trigraphs = 0;
+ CPP_OPTION (pfile, warn_trigraphs) = 0;
else if (!strcmp (argv[i], "-Wno-comment"))
- opts->warn_comments = 0;
+ CPP_OPTION (pfile, warn_comments) = 0;
else if (!strcmp (argv[i], "-Wno-comments"))
- opts->warn_comments = 0;
+ CPP_OPTION (pfile, warn_comments) = 0;
else if (!strcmp (argv[i], "-Wno-undef"))
- opts->warn_undef = 0;
+ CPP_OPTION (pfile, warn_undef) = 0;
else if (!strcmp (argv[i], "-Wno-import"))
- opts->warn_import = 0;
+ CPP_OPTION (pfile, warn_import) = 0;
else if (!strcmp (argv[i], "-Wno-error"))
- opts->warnings_are_errors = 0;
+ CPP_OPTION (pfile, warnings_are_errors) = 0;
break;
}
}
-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\
projects / gcc.git / blobdiff