/* CPP Library.
Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004 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 "config.h"
#include "system.h"
-#include "coretypes.h"
-#include "tm.h"
#include "cpplib.h"
#include "cpphash.h"
-#include "intl.h"
#include "mkdeps.h"
-/* Internal structures and prototypes. */
-
-/* A `struct pending_option' remembers one -D, -A, -U, -include, or
- -imacros switch. */
-typedef void (* cl_directive_handler) PARAMS ((cpp_reader *, const char *));
-struct pending_option
-{
- struct pending_option *next;
- const char *arg;
- cl_directive_handler handler;
-};
-
-/* The `pending' structure accumulates all the options that are not
- actually processed until we hit cpp_read_main_file. It consists of
- several lists, one for each type of option. We keep both head and
- tail pointers for quick insertion. */
-struct cpp_pending
-{
- struct pending_option *directive_head, *directive_tail;
- struct pending_option *imacros_head, *imacros_tail;
- struct pending_option *include_head, *include_tail;
-};
-
-#ifdef __STDC__
-#define APPEND(pend, list, elt) \
- do { if (!(pend)->list##_head) (pend)->list##_head = (elt); \
- else (pend)->list##_tail->next = (elt); \
- (pend)->list##_tail = (elt); \
- } while (0)
-#else
-#define APPEND(pend, list, elt) \
- do { if (!(pend)->list/**/_head) (pend)->list/**/_head = (elt); \
- else (pend)->list/**/_tail->next = (elt); \
- (pend)->list/**/_tail = (elt); \
- } while (0)
-#endif
-
-static void init_library PARAMS ((void));
-static void init_builtins PARAMS ((cpp_reader *));
-static void mark_named_operators PARAMS ((cpp_reader *));
-static bool push_include PARAMS ((cpp_reader *,
- struct pending_option *));
-static void free_chain PARAMS ((struct pending_option *));
-static void read_original_filename PARAMS ((cpp_reader *));
-static void new_pending_directive PARAMS ((struct cpp_pending *,
- const char *,
- cl_directive_handler));
-static int parse_option PARAMS ((const char *));
-static void post_options PARAMS ((cpp_reader *));
+static void init_library (void);
+static void mark_named_operators (cpp_reader *);
+static void read_original_filename (cpp_reader *);
+static void read_original_directory (cpp_reader *);
+static void post_options (cpp_reader *);
/* If we have designated initializers (GCC >2.7) these tables can be
initialized, constant data. Otherwise, they have to be filled in at
#else
#define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
- static void init_trigraph_map PARAMS ((void)) { \
+ static void init_trigraph_map (void) { \
unsigned char *x = _cpp_trigraph_map;
#define END }
char cplusplus;
char extended_numbers;
char std;
- char dollars_in_ident;
char cplusplus_comments;
char digraphs;
};
-/* ??? Enable $ in identifiers in assembly? */
static const struct lang_flags lang_defaults[] =
-{ /* c99 c++ xnum std dollar c++comm digr */
- /* GNUC89 */ { 0, 0, 1, 0, 1, 1, 1 },
- /* GNUC99 */ { 1, 0, 1, 0, 1, 1, 1 },
- /* STDC89 */ { 0, 0, 0, 1, 0, 0, 0 },
- /* STDC94 */ { 0, 0, 0, 1, 0, 0, 1 },
- /* STDC99 */ { 1, 0, 1, 1, 0, 1, 1 },
- /* GNUCXX */ { 0, 1, 1, 0, 1, 1, 1 },
- /* CXX98 */ { 0, 1, 1, 1, 0, 1, 1 },
- /* ASM */ { 0, 0, 1, 0, 0, 1, 0 }
+{ /* c99 c++ xnum std // digr */
+ /* GNUC89 */ { 0, 0, 1, 0, 1, 1 },
+ /* GNUC99 */ { 1, 0, 1, 0, 1, 1 },
+ /* STDC89 */ { 0, 0, 0, 1, 0, 0 },
+ /* STDC94 */ { 0, 0, 0, 1, 0, 1 },
+ /* STDC99 */ { 1, 0, 1, 1, 1, 1 },
+ /* GNUCXX */ { 0, 1, 1, 0, 1, 1 },
+ /* CXX98 */ { 0, 1, 1, 1, 1, 1 },
+ /* ASM */ { 0, 0, 1, 0, 1, 0 }
};
/* Sets internal flags correctly for a given language. */
void
-cpp_set_lang (pfile, lang)
- cpp_reader *pfile;
- enum c_lang lang;
+cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
{
const struct lang_flags *l = &lang_defaults[(int) lang];
CPP_OPTION (pfile, extended_numbers) = l->extended_numbers;
CPP_OPTION (pfile, std) = l->std;
CPP_OPTION (pfile, trigraphs) = l->std;
- CPP_OPTION (pfile, dollars_in_ident) = l->dollars_in_ident;
CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
CPP_OPTION (pfile, digraphs) = l->digraphs;
}
-#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. */
+/* Initialize library global state. */
static void
-init_library ()
+init_library (void)
{
static int initialized = 0;
{
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. */
/* Initialize a cpp_reader structure. */
cpp_reader *
-cpp_create_reader (lang)
- enum c_lang lang;
+cpp_create_reader (enum c_lang lang, hash_table *table,
+ struct line_maps *line_table)
{
cpp_reader *pfile;
/* Initialize this instance of the library if it hasn't been already. */
init_library ();
- pfile = (cpp_reader *) xcalloc (1, sizeof (cpp_reader));
+ pfile = xcalloc (1, sizeof (cpp_reader));
cpp_set_lang (pfile, lang);
- CPP_OPTION (pfile, warn_import) = 1;
CPP_OPTION (pfile, warn_multichar) = 1;
CPP_OPTION (pfile, discard_comments) = 1;
CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
CPP_OPTION (pfile, show_column) = 1;
CPP_OPTION (pfile, tabstop) = 8;
CPP_OPTION (pfile, operator_names) = 1;
+ CPP_OPTION (pfile, warn_trigraphs) = 2;
CPP_OPTION (pfile, warn_endif_labels) = 1;
CPP_OPTION (pfile, warn_deprecated) = 1;
CPP_OPTION (pfile, warn_long_long) = !CPP_OPTION (pfile, c99);
-
- CPP_OPTION (pfile, pending) =
- (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
+ CPP_OPTION (pfile, dollars_in_ident) = 1;
+ CPP_OPTION (pfile, warn_dollars) = 1;
+ CPP_OPTION (pfile, warn_variadic_macros) = 1;
/* Default CPP arithmetic to something sensible for the host for the
benefit of dumb users like fix-header. */
CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
CPP_OPTION (pfile, unsigned_char) = 0;
CPP_OPTION (pfile, unsigned_wchar) = 1;
+ CPP_OPTION (pfile, bytes_big_endian) = 1; /* does not matter */
+
+ /* Default to no charset conversion. */
+ CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
+ CPP_OPTION (pfile, wide_charset) = 0;
+
+ /* Default the input character set to UTF-8. */
+ CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
+
+ /* A fake empty "directory" used as the starting point for files
+ looked up without a search path. Name cannot be '/' because we
+ don't want to prepend anything at all to filenames using it. All
+ other entries are correct zero-initialized. */
+ pfile->no_search_path.name = (char *) "";
/* Initialize the line map. Start at logical line 1, so we can use
a line number of zero for special states. */
- init_line_maps (&pfile->line_maps);
+ pfile->line_table = line_table;
pfile->line = 1;
/* Initialize lexer state. */
_cpp_expand_op_stack (pfile);
/* Initialize the buffer obstack. */
- gcc_obstack_init (&pfile->buffer_ob);
+ _obstack_begin (&pfile->buffer_ob, 0, 0,
+ (void *(*) (long)) xmalloc,
+ (void (*) (void *)) free);
- _cpp_init_includes (pfile);
+ _cpp_init_files (pfile);
+
+ _cpp_init_hashtable (pfile, table);
return pfile;
}
/* Free resources used by PFILE. Accessing PFILE after this function
returns leads to undefined behavior. Returns the error count. */
void
-cpp_destroy (pfile)
- cpp_reader *pfile;
+cpp_destroy (cpp_reader *pfile)
{
cpp_context *context, *contextn;
tokenrun *run, *runn;
- free_chain (CPP_OPTION (pfile, pending)->include_head);
- free (CPP_OPTION (pfile, pending));
free (pfile->op_stack);
while (CPP_BUFFER (pfile) != NULL)
if (pfile->macro_buffer)
{
- free ((PTR) pfile->macro_buffer);
+ free (pfile->macro_buffer);
pfile->macro_buffer = NULL;
pfile->macro_buffer_len = 0;
}
obstack_free (&pfile->buffer_ob, 0);
_cpp_destroy_hashtable (pfile);
- _cpp_cleanup_includes (pfile);
+ _cpp_cleanup_files (pfile);
+ _cpp_destroy_iconv (pfile);
_cpp_free_buff (pfile->a_buff);
_cpp_free_buff (pfile->u_buff);
free (context);
}
- free_line_maps (&pfile->line_maps);
free (pfile);
}
/* Mark the C++ named operators in the hash table. */
static void
-mark_named_operators (pfile)
- cpp_reader *pfile;
+mark_named_operators (cpp_reader *pfile)
{
const struct builtin *b;
}
}
-/* Subroutine of cpp_read_main_file; reads the builtins table above and
- enters them, and language-specific macros, into the hash table. */
-static void
-init_builtins (pfile)
- cpp_reader *pfile;
+/* Read the builtins table above and enter them, and language-specific
+ macros, into the hash table. HOSTED is true if this is a hosted
+ environment. */
+void
+cpp_init_builtins (cpp_reader *pfile, int hosted)
{
const struct builtin *b;
size_t n = ARRAY_SIZE (builtin_array);
else if (CPP_OPTION (pfile, c99))
_cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
+ if (hosted)
+ _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
+ else
+ _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
+
if (CPP_OPTION (pfile, objc))
_cpp_define_builtin (pfile, "__OBJC__ 1");
-
- if (pfile->cb.register_builtins)
- (*pfile->cb.register_builtins) (pfile);
-}
-
-/* Pushes a command line -imacro and -include file indicated by P onto
- the buffer stack. Returns nonzero if successful. */
-static bool
-push_include (pfile, p)
- cpp_reader *pfile;
- struct pending_option *p;
-{
- cpp_token header;
-
- /* Later: maybe update this to use the #include "" search path
- if cpp_read_file fails. */
- header.type = CPP_STRING;
- header.val.str.text = (const unsigned char *) p->arg;
- header.val.str.len = strlen (p->arg);
- /* Make the command line directive take up a line. */
- pfile->line++;
-
- return _cpp_execute_include (pfile, &header, IT_CMDLINE);
-}
-
-/* Frees a pending_option chain. */
-static void
-free_chain (head)
- struct pending_option *head;
-{
- struct pending_option *next;
-
- while (head)
- {
- next = head->next;
- free (head);
- head = next;
- }
}
/* Sanity-checks are dependent on command-line options, so it is
called as a subroutine of cpp_read_main_file (). */
#if ENABLE_CHECKING
-static void sanity_checks PARAMS ((cpp_reader *));
-static void sanity_checks (pfile)
- cpp_reader *pfile;
+static void sanity_checks (cpp_reader *);
+static void sanity_checks (cpp_reader *pfile)
{
cppchar_t test = 0;
size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
type precisions made by cpplib. */
test--;
if (test < 1)
- cpp_error (pfile, DL_ICE, "cppchar_t must be an unsigned type");
+ cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
if (CPP_OPTION (pfile, precision) > max_precision)
- cpp_error (pfile, DL_ICE,
- "preprocessor arithmetic has maximum precision of %lu bits; target requires %lu bits",
+ cpp_error (pfile, CPP_DL_ICE,
+ "preprocessor arithmetic has maximum precision of %lu bits;"
+ " target requires %lu bits",
(unsigned long) max_precision,
(unsigned long) CPP_OPTION (pfile, precision));
if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
- cpp_error (pfile, DL_ICE,
+ cpp_error (pfile, CPP_DL_ICE,
"CPP arithmetic must be at least as precise as a target int");
if (CPP_OPTION (pfile, char_precision) < 8)
- cpp_error (pfile, DL_ICE, "target char is less than 8 bits wide");
+ cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
- cpp_error (pfile, DL_ICE,
+ cpp_error (pfile, CPP_DL_ICE,
"target wchar_t is narrower than target char");
if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
- cpp_error (pfile, DL_ICE,
+ cpp_error (pfile, CPP_DL_ICE,
"target int is narrower than target char");
/* This is assumed in eval_token() and could be fixed if necessary. */
if (sizeof (cppchar_t) > sizeof (cpp_num_part))
- cpp_error (pfile, DL_ICE, "CPP half-integer narrower than CPP character");
+ cpp_error (pfile, CPP_DL_ICE,
+ "CPP half-integer narrower than CPP character");
if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
- cpp_error (pfile, DL_ICE,
- "CPP on this host cannot handle wide character constants over %lu bits, but the target requires %lu bits",
+ cpp_error (pfile, CPP_DL_ICE,
+ "CPP on this host cannot handle wide character constants over"
+ " %lu bits, but the target requires %lu bits",
(unsigned long) BITS_PER_CPPCHAR_T,
(unsigned long) CPP_OPTION (pfile, wchar_precision));
}
cpp_read_main_file(). If no targets have been added before
cpp_read_main_file(), then the default target is used. */
void
-cpp_add_dependency_target (pfile, target, quote)
- cpp_reader *pfile;
- const char *target;
- int quote;
+cpp_add_dependency_target (cpp_reader *pfile, const char *target, int quote)
{
if (!pfile->deps)
pfile->deps = deps_init ();
}
/* This is called after options have been parsed, and partially
- processed. Setup for processing input from the file named FNAME,
- or stdin if it is the empty string. Return the original filename
- on success (e.g. foo.i->foo.c), or NULL on failure. */
-const char *
-cpp_read_main_file (pfile, fname, table)
- cpp_reader *pfile;
- const char *fname;
- hash_table *table;
+ processed. */
+void
+cpp_post_options (cpp_reader *pfile)
{
sanity_checks (pfile);
post_options (pfile);
- /* The front ends don't set up the hash table until they have
- finished processing the command line options, so initializing the
- hashtable is deferred until now. */
- _cpp_init_hashtable (pfile, table);
+ /* Mark named operators before handling command line macros. */
+ if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
+ mark_named_operators (pfile);
+}
+/* Setup for processing input from the file named FNAME, or stdin if
+ it is the empty string. Return the original filename
+ on success (e.g. foo.i->foo.c), or NULL on failure. */
+const char *
+cpp_read_main_file (cpp_reader *pfile, const char *fname)
+{
if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
{
if (!pfile->deps)
deps_add_default_target (pfile->deps, fname);
}
- /* Open the main input file. */
- if (!_cpp_read_file (pfile, fname))
- return NULL;
+ pfile->main_file
+ = _cpp_find_file (pfile, fname, &pfile->no_search_path, false);
+ if (_cpp_find_failed (pfile->main_file))
+ return false;
- /* Set this here so the client can change the option if it wishes,
- and after stacking the main file so we don't trace the main
- file. */
- pfile->line_maps.trace_includes = CPP_OPTION (pfile, print_include_names);
+ _cpp_stack_file (pfile, pfile->main_file, false);
/* For foo.i, read the original filename foo.c now, for the benefit
of the front ends. */
if (CPP_OPTION (pfile, preprocessed))
- read_original_filename (pfile);
-
- return pfile->map->to_file;
+ {
+ read_original_filename (pfile);
+ fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
+ }
+ return fname;
}
/* For preprocessed files, if the first tokens are of the form # NUM.
generate file_change callbacks, which the front ends must handle
appropriately given their state of initialization. */
static void
-read_original_filename (pfile)
- cpp_reader *pfile;
+read_original_filename (cpp_reader *pfile)
{
const cpp_token *token, *token1;
if (token1->type == CPP_NUMBER)
{
_cpp_handle_directive (pfile, token->flags & PREV_WHITE);
+ read_original_directory (pfile);
return;
}
}
_cpp_backup_tokens (pfile, 1);
}
-/* Handle pending command line options: -D, -U, -A, -imacros and
- -include. This should be called after debugging has been properly
- set up in the front ends. */
-void
-cpp_finish_options (pfile)
- cpp_reader *pfile;
+/* For preprocessed files, if the tokens following the first filename
+ line is of the form # <line> "/path/name//", handle the
+ directive so we know the original current directory. */
+static void
+read_original_directory (cpp_reader *pfile)
{
- /* Mark named operators before handling command line macros. */
- if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
- mark_named_operators (pfile);
+ const cpp_token *hash, *token;
+
+ /* Lex ahead; if the first tokens are of the form # NUM, then
+ process the directive, otherwise back up. */
+ hash = _cpp_lex_direct (pfile);
+ if (hash->type != CPP_HASH)
+ {
+ _cpp_backup_tokens (pfile, 1);
+ return;
+ }
- /* Install builtins and process command line macros etc. in the order
- they appeared, but only if not already preprocessed. */
- if (! CPP_OPTION (pfile, preprocessed))
+ token = _cpp_lex_direct (pfile);
+
+ if (token->type != CPP_NUMBER)
{
- struct pending_option *p;
-
- _cpp_do_file_change (pfile, LC_RENAME, _("<built-in>"), 1, 0);
- init_builtins (pfile);
- _cpp_do_file_change (pfile, LC_RENAME, _("<command line>"), 1, 0);
- for (p = CPP_OPTION (pfile, pending)->directive_head; p; p = p->next)
- (*p->handler) (pfile, p->arg);
-
- /* Scan -imacros files after -D, -U, but before -include.
- pfile->next_include_file is NULL, so _cpp_pop_buffer does not
- push -include files. */
- for (p = CPP_OPTION (pfile, pending)->imacros_head; p; p = p->next)
- if (push_include (pfile, p))
- cpp_scan_nooutput (pfile);
-
- pfile->next_include_file = &CPP_OPTION (pfile, pending)->include_head;
- _cpp_maybe_push_include_file (pfile);
+ _cpp_backup_tokens (pfile, 2);
+ return;
}
- pfile->first_unused_line = pfile->line;
+ token = _cpp_lex_direct (pfile);
- free_chain (CPP_OPTION (pfile, pending)->imacros_head);
- free_chain (CPP_OPTION (pfile, pending)->directive_head);
-}
+ if (token->type != CPP_STRING
+ || ! (token->val.str.len >= 5
+ && token->val.str.text[token->val.str.len-2] == '/'
+ && token->val.str.text[token->val.str.len-3] == '/'))
+ {
+ _cpp_backup_tokens (pfile, 3);
+ return;
+ }
-/* Push the next buffer on the stack given by -include, if any. */
-void
-_cpp_maybe_push_include_file (pfile)
- cpp_reader *pfile;
-{
- if (pfile->next_include_file)
+ if (pfile->cb.dir_change)
{
- struct pending_option *head = *pfile->next_include_file;
+ char *debugdir = alloca (token->val.str.len - 3);
- while (head && !push_include (pfile, head))
- head = head->next;
+ memcpy (debugdir, (const char *) token->val.str.text + 1,
+ token->val.str.len - 4);
+ debugdir[token->val.str.len - 4] = '\0';
- if (head)
- pfile->next_include_file = &head->next;
- else
- {
- /* All done; restore the line map from <command line>. */
- _cpp_do_file_change (pfile, LC_RENAME,
- pfile->line_maps.maps[0].to_file, 1, 0);
- /* Don't come back here again. */
- pfile->next_include_file = NULL;
- }
- }
+ pfile->cb.dir_change (pfile, debugdir);
+ }
}
/* This is called at the end of preprocessing. It pops the last
buffer and writes dependency output, and returns the number of
errors.
-
+
Maybe it should also reset state, such that you could call
cpp_start_read with a new filename to restart processing. */
int
-cpp_finish (pfile, deps_stream)
- cpp_reader *pfile;
- FILE *deps_stream;
+cpp_finish (cpp_reader *pfile, FILE *deps_stream)
{
/* Warn about unused macros before popping the final buffer. */
if (CPP_OPTION (pfile, warn_unused_macros))
return pfile->errors;
}
-/* Add a directive to be handled later in the initialization phase. */
-static void
-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->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_ass N_("assertion missing after %s")
-#define no_fil N_("file name missing after %s")
-#define no_mac N_("macro 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("A", no_ass, OPT_A) \
- DEF_OPT("D", no_mac, OPT_D) \
- DEF_OPT("U", no_mac, OPT_U) \
- DEF_OPT("imacros", no_fil, OPT_imacros) \
- DEF_OPT("include", no_fil, OPT_include)
-
-#define DEF_OPT(text, msg, code) code,
-enum opt_code
-{
- COMMAND_LINE_OPTIONS
- N_OPTS
-};
-#undef DEF_OPT
-
-struct cl_option
-{
- const char *opt_text;
- const char *msg;
- size_t opt_len;
- enum opt_code opt_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
-{
- 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,
- negative on failure. Complications arise since some options can be
- suffixed with an argument, and multiple complete matches can occur,
- e.g. -pedantic and -pedantic-errors. */
-static int
-parse_option (input)
- const char *input;
-{
- unsigned int md, mn, mx;
- size_t opt_len;
- int comp;
-
- mn = 0;
- mx = N_OPTS;
-
- 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)
- mx = md;
- else
- {
- if (input[opt_len] == '\0')
- return md;
- /* We were passed more text. If the option takes an argument,
- 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"). */
- 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. */
- mx = md;
- for (; mn < (unsigned int) N_OPTS; mn++)
- {
- opt_len = cl_options[mn].opt_len;
- if (strncmp (input, cl_options[mn].opt_text, opt_len))
- break;
- if (input[opt_len] == '\0')
- return mn;
- if (cl_options[mn].msg)
- mx = mn;
- }
- return mx;
- }
- }
- }
-
- return -1;
-}
-
-/* Handle one command-line option in (argc, argv).
- Can be called multiple times, to handle multiple sets of options.
- Returns number of strings consumed. */
-int
-cpp_handle_option (pfile, argc, argv)
- cpp_reader *pfile;
- int argc;
- char **argv;
-{
- int i = 0;
- struct cpp_pending *pend = CPP_OPTION (pfile, pending);
-
- {
- enum opt_code opt_code;
- int opt_index;
- const char *arg = 0;
-
- /* Skip over '-'. */
- opt_index = parse_option (&argv[i][1]);
- if (opt_index < 0)
- return i;
-
- opt_code = cl_options[opt_index].opt_code;
- if (cl_options[opt_index].msg)
- {
- arg = &argv[i][cl_options[opt_index].opt_len + 1];
- if (arg[0] == '\0')
- {
- arg = argv[++i];
- if (!arg)
- {
- cpp_error (pfile, DL_ERROR,
- cl_options[opt_index].msg, argv[i - 1]);
- return argc;
- }
- }
- }
-
- switch (opt_code)
- {
- case N_OPTS: /* Shut GCC up. */
- break;
-
- case OPT_D:
- new_pending_directive (pend, arg, cpp_define);
- break;
-
- case OPT_A:
- if (arg[0] == '-')
- {
- /* -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')
- {
- free_chain (pend->directive_head);
- pend->directive_head = NULL;
- pend->directive_tail = NULL;
- }
- else
- new_pending_directive (pend, arg + 1, cpp_unassert);
- }
- else
- new_pending_directive (pend, arg, cpp_assert);
- break;
- case OPT_U:
- new_pending_directive (pend, arg, cpp_undef);
- break;
- case OPT_include:
- case OPT_imacros:
- {
- struct pending_option *o = (struct pending_option *)
- xmalloc (sizeof (struct pending_option));
- o->arg = arg;
- o->next = NULL;
-
- if (opt_code == OPT_include)
- APPEND (pend, include, o);
- else
- APPEND (pend, imacros, o);
- }
- break;
- }
- }
- return i + 1;
-}
-
static void
-post_options (pfile)
- cpp_reader *pfile;
+post_options (cpp_reader *pfile)
{
/* -Wtraditional is not useful in C++ mode. */
if (CPP_OPTION (pfile, cplusplus))
CPP_OPTION (pfile, traditional) = 0;
}
- /* Traditional CPP does not accurately track column information. */
+ if (CPP_OPTION (pfile, warn_trigraphs) == 2)
+ CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
+
if (CPP_OPTION (pfile, traditional))
- CPP_OPTION (pfile, show_column) = 0;
+ {
+ /* Traditional CPP does not accurately track column information. */
+ CPP_OPTION (pfile, show_column) = 0;
+ CPP_OPTION (pfile, trigraphs) = 0;
+ CPP_OPTION (pfile, warn_trigraphs) = 0;
+ }
}