/* CPP Library.
Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
Contributed by Per Bothner, 1994-95.
Based on CCCP program by Paul Rubin, June 1986
Adapted to ANSI C, Richard Stallman, Jan 1987
#include "system.h"
#include "cpplib.h"
#include "cpphash.h"
-#include "prefix.h"
-#include "intl.h"
-#include "version.h"
#include "mkdeps.h"
-#include "cppdefault.h"
-#include "except.h" /* for USING_SJLJ_EXCEPTIONS */
-/* Predefined symbols, built-in macros, and the default include path. */
-
-#ifndef GET_ENV_PATH_LIST
-#define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
-#endif
-
-/* Windows does not natively support inodes, and neither does MSDOS.
- Cygwin's emulation can generate non-unique inodes, so don't use it.
- VMS has non-numeric inodes. */
-#ifdef VMS
-# define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A)))
-# define INO_T_COPY(DEST, SRC) memcpy(&(DEST), &(SRC), sizeof (SRC))
-#else
-# if (defined _WIN32 && ! defined (_UWIN)) || defined __MSDOS__
-# define INO_T_EQ(A, B) 0
-# else
-# define INO_T_EQ(A, B) ((A) == (B))
-# endif
-# define INO_T_COPY(DEST, SRC) (DEST) = (SRC)
-#endif
-
-/* Internal structures and prototypes. */
-
-/* A `struct pending_option' remembers one -D, -A, -U, -include, or
- -imacros switch. */
-typedef void (* cl_directive_handler) PARAMS ((cpp_reader *, const char *));
-struct pending_option
-{
- 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 search_path *quote_head, *quote_tail;
- struct search_path *brack_head, *brack_tail;
- struct search_path *systm_head, *systm_tail;
- struct search_path *after_head, *after_tail;
-
- struct pending_option *imacros_head, *imacros_tail;
- struct pending_option *include_head, *include_tail;
-};
-
-#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 print_help PARAMS ((void));
-static void path_include PARAMS ((cpp_reader *,
- char *, int));
-static void init_library PARAMS ((void));
-static void init_builtins PARAMS ((cpp_reader *));
-static void append_include_chain PARAMS ((cpp_reader *,
- char *, int, int));
-static struct search_path * remove_dup_dir PARAMS ((cpp_reader *,
- struct search_path *));
-static struct search_path * remove_dup_dirs PARAMS ((cpp_reader *,
- struct search_path *));
-static void merge_include_chains PARAMS ((cpp_reader *));
-static bool push_include PARAMS ((cpp_reader *,
- struct pending_option *));
-static void free_chain PARAMS ((struct pending_option *));
-static void set_lang PARAMS ((cpp_reader *, enum c_lang));
-static void init_dependency_output PARAMS ((cpp_reader *));
-static void init_standard_includes PARAMS ((cpp_reader *));
-static void read_original_filename PARAMS ((cpp_reader *));
-static void new_pending_directive PARAMS ((struct cpp_pending *,
- const char *,
- cl_directive_handler));
-static void output_deps PARAMS ((cpp_reader *));
-static int parse_option PARAMS ((const char *));
-
-/* Fourth argument to append_include_chain: chain to use.
- Note it's never asked to append to the quote chain. */
-enum { BRACKET = 0, SYSTEM, AFTER };
+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 }
#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, list, path)
- cpp_reader *pfile;
- char *list;
- int path;
-{
- char *p, *q, *name;
-
- p = list;
-
- do
- {
- /* Find the end of this name. */
- q = p;
- while (*q != 0 && *q != PATH_SEPARATOR) q++;
- if (q == p)
- {
- /* An empty name in the path stands for the current directory. */
- name = (char *) xmalloc (2);
- name[0] = '.';
- name[1] = 0;
- }
- else
- {
- /* Otherwise use the directory that is named. */
- name = (char *) xmalloc (q - p + 1);
- memcpy (name, p, q - p);
- name[q - p] = 0;
- }
-
- append_include_chain (pfile, name, path, 0);
-
- /* Advance past this name. */
- if (*q == 0)
- break;
- p = q + 1;
- }
- while (1);
-}
-
-/* Append DIR to include path PATH. DIR must be allocated on the
- heap; this routine takes responsibility for freeing it. CXX_AWARE
- is non-zero if the header contains extern "C" guards for C++,
- otherwise it is zero. */
-static void
-append_include_chain (pfile, dir, path, cxx_aware)
- cpp_reader *pfile;
- char *dir;
- int path;
- int cxx_aware ATTRIBUTE_UNUSED;
-{
- struct cpp_pending *pend = CPP_OPTION (pfile, pending);
- struct search_path *new;
- struct stat st;
- unsigned int len;
-
- if (*dir == '\0')
- {
- free (dir);
- dir = xstrdup (".");
- }
- _cpp_simplify_pathname (dir);
-
- if (stat (dir, &st))
- {
- /* Dirs that don't exist are silently ignored. */
- if (errno != ENOENT)
- cpp_errno (pfile, DL_ERROR, dir);
- else if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"), dir);
- free (dir);
- return;
- }
-
- if (!S_ISDIR (st.st_mode))
- {
- cpp_error_with_line (pfile, DL_ERROR, 0, 0, "%s: Not a directory", dir);
- free (dir);
- return;
- }
-
- len = strlen (dir);
- if (len > pfile->max_include_len)
- pfile->max_include_len = len;
-
- new = (struct search_path *) xmalloc (sizeof (struct search_path));
- new->name = dir;
- new->len = len;
- INO_T_COPY (new->ino, st.st_ino);
- new->dev = st.st_dev;
- /* Both systm and after include file lists should be treated as system
- include files since these two lists are really just a concatenation
- of one "system" list. */
- if (path == SYSTEM || path == AFTER)
-#ifdef NO_IMPLICIT_EXTERN_C
- new->sysp = 1;
-#else
- new->sysp = cxx_aware ? 1 : 2;
-#endif
- else
- new->sysp = 0;
- new->name_map = NULL;
- new->next = NULL;
-
- switch (path)
- {
- case BRACKET: APPEND (pend, brack, new); break;
- case SYSTEM: APPEND (pend, systm, new); break;
- case AFTER: APPEND (pend, after, new); break;
- }
-}
-
-/* Handle a duplicated include path. PREV is the link in the chain
- before the duplicate. The duplicate is removed from the chain and
- freed. Returns PREV. */
-static struct search_path *
-remove_dup_dir (pfile, prev)
- cpp_reader *pfile;
- struct search_path *prev;
-{
- struct search_path *cur = prev->next;
-
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), cur->name);
-
- prev->next = cur->next;
- free ((PTR) 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. */
-static struct search_path *
-remove_dup_dirs (pfile, head)
- cpp_reader *pfile;
- struct search_path *head;
-{
- struct search_path *prev = NULL, *cur, *other;
-
- for (cur = head; cur; cur = cur->next)
- {
- for (other = head; other != cur; other = other->next)
- if (INO_T_EQ (cur->ino, other->ino) && cur->dev == other->dev)
- {
- if (cur->sysp && !other->sysp)
- {
- cpp_error (pfile, DL_WARNING,
- "changing search order for system directory \"%s\"",
- cur->name);
- if (strcmp (cur->name, other->name))
- cpp_error (pfile, DL_WARNING,
- " as it is the same as non-system directory \"%s\"",
- other->name);
- else
- cpp_error (pfile, DL_WARNING,
- " as it has already been specified as a non-system directory");
- }
- 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
- referred to again after this function; all access is through the
- bracket_include path. */
-static void
-merge_include_chains (pfile)
- cpp_reader *pfile;
-{
- struct search_path *quote, *brack, *systm, *qtail;
-
- struct cpp_pending *pend = CPP_OPTION (pfile, pending);
-
- quote = pend->quote_head;
- brack = pend->brack_head;
- systm = pend->systm_head;
- qtail = pend->quote_tail;
-
- /* Paste together bracket, system, and after include chains. */
- if (systm)
- pend->systm_tail->next = pend->after_head;
- else
- 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
- brack and move brack up to point to qtail.
-
- We can't just merge the lists and then uniquify them because
- then we may lose directories from the <> search path that should
- 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. */
-
- remove_dup_dirs (pfile, brack);
- qtail = remove_dup_dirs (pfile, quote);
-
- if (quote)
- {
- qtail->next = brack;
-
- /* If brack == qtail, remove brack as it's simpler. */
- if (brack && INO_T_EQ (qtail->ino, brack->ino)
- && qtail->dev == brack->dev)
- brack = remove_dup_dir (pfile, qtail);
- }
- else
- quote = brack;
-
- CPP_OPTION (pfile, quote_include) = quote;
- CPP_OPTION (pfile, bracket_include) = brack;
-}
-
/* A set of booleans indicating what CPP features each source language
requires. */
struct lang_flags
{
char c99;
- char objc;
char cplusplus;
char extended_numbers;
- char trigraphs;
- char dollars_in_ident;
+ char std;
char cplusplus_comments;
char digraphs;
};
-/* ??? Enable $ in identifiers in assembly? */
static const struct lang_flags lang_defaults[] =
-{ /* c99 objc c++ xnum trig dollar c++comm digr */
- /* GNUC89 */ { 0, 0, 0, 1, 0, 1, 1, 1 },
- /* GNUC99 */ { 1, 0, 0, 1, 0, 1, 1, 1 },
- /* STDC89 */ { 0, 0, 0, 0, 1, 0, 0, 0 },
- /* STDC94 */ { 0, 0, 0, 0, 1, 0, 0, 1 },
- /* STDC99 */ { 1, 0, 0, 1, 1, 0, 1, 1 },
- /* GNUCXX */ { 0, 0, 1, 1, 0, 1, 1, 1 },
- /* CXX98 */ { 0, 0, 1, 1, 1, 0, 1, 1 },
- /* OBJC */ { 0, 1, 0, 1, 0, 1, 1, 1 },
- /* OBJCXX */ { 0, 1, 1, 1, 0, 1, 1, 1 },
- /* ASM */ { 0, 0, 0, 1, 0, 0, 1, 0 }
+{ /* 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. */
-static void
-set_lang (pfile, lang)
- cpp_reader *pfile;
- enum c_lang lang;
+void
+cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
{
const struct lang_flags *l = &lang_defaults[(int) lang];
-
+
CPP_OPTION (pfile, lang) = lang;
CPP_OPTION (pfile, c99) = l->c99;
- CPP_OPTION (pfile, objc) = l->objc;
CPP_OPTION (pfile, cplusplus) = l->cplusplus;
CPP_OPTION (pfile, extended_numbers) = l->extended_numbers;
- CPP_OPTION (pfile, trigraphs) = l->trigraphs;
- CPP_OPTION (pfile, dollars_in_ident) = l->dollars_in_ident;
+ CPP_OPTION (pfile, std) = l->std;
+ CPP_OPTION (pfile, trigraphs) = l->std;
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)
{
cpp_reader *pfile;
- /* Initialise this instance of the library if it hasn't been already. */
+ /* 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));
- set_lang (pfile, lang);
- CPP_OPTION (pfile, warn_import) = 1;
+ cpp_set_lang (pfile, lang);
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, pending) =
- (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
+ CPP_OPTION (pfile, warn_deprecated) = 1;
+ CPP_OPTION (pfile, warn_long_long) = !CPP_OPTION (pfile, c99);
+ CPP_OPTION (pfile, dollars_in_ident) = 1;
+ CPP_OPTION (pfile, warn_dollars) = 1;
/* Default CPP arithmetic to something sensible for the host for the
benefit of dumb users like fix-header. */
-#define BITS_PER_HOST_WIDEST_INT (CHAR_BIT * sizeof (HOST_WIDEST_INT))
- CPP_OPTION (pfile, precision) = BITS_PER_HOST_WIDEST_INT;
+ CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
CPP_OPTION (pfile, char_precision) = CHAR_BIT;
CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
- CPP_OPTION (pfile, unsigned_char) = !DEFAULT_SIGNED_CHAR;
+ 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) = 0;
+ CPP_OPTION (pfile, wide_charset) = 0;
- /* It's simplest to just create this struct whether or not it will
- be needed. */
- pfile->deps = deps_init ();
+ /* 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 *) "";
- /* Initialise the line map. Start at logical line 1, so we can use
+ /* 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);
+ linemap_init (&pfile->line_maps);
pfile->line = 1;
/* Initialize lexer state. */
pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
/* Set up static tokens. */
- pfile->date.type = CPP_EOF;
pfile->avoid_paste.type = CPP_PADDING;
pfile->avoid_paste.val.source = NULL;
pfile->eof.type = CPP_EOF;
pfile->cur_run = &pfile->base_run;
pfile->cur_token = pfile->base_run.base;
- /* Initialise the base context. */
+ /* Initialize the base context. */
pfile->context = &pfile->base_context;
pfile->base_context.macro = 0;
pfile->base_context.prev = pfile->base_context.next = 0;
/* The expression parser stack. */
_cpp_expand_op_stack (pfile);
- /* Initialise the buffer obstack. */
- gcc_obstack_init (&pfile->buffer_ob);
+ /* Initialize the buffer obstack. */
+ _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 behaviour. Returns the error count. */
-int
-cpp_destroy (pfile)
- cpp_reader *pfile;
+ returns leads to undefined behavior. Returns the error count. */
+void
+cpp_destroy (cpp_reader *pfile)
{
- int result;
- struct search_path *dir, *dirn;
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)
_cpp_pop_buffer (pfile);
+ if (pfile->out.base)
+ free (pfile->out.base);
+
if (pfile->macro_buffer)
{
- free ((PTR) pfile->macro_buffer);
+ free (pfile->macro_buffer);
pfile->macro_buffer = NULL;
pfile->macro_buffer_len = 0;
}
- deps_free (pfile->deps);
+ if (pfile->deps)
+ deps_free (pfile->deps);
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 (run);
}
- for (dir = CPP_OPTION (pfile, quote_include); dir; dir = dirn)
- {
- dirn = dir->next;
- free ((PTR) dir->name);
- free (dir);
- }
-
for (context = pfile->base_context.next; context; context = contextn)
{
contextn = context->next;
free (context);
}
- free_line_maps (&pfile->line_maps);
-
- result = pfile->errors;
+ linemap_free (&pfile->line_maps);
free (pfile);
-
- return result;
}
-
/* This structure defines one built-in identifier. A node will be
- entered in the hash table under the name NAME, with value VALUE (if
- any). If flags has OPERATOR, the node's operator field is used; if
- flags has BUILTIN the node's builtin field is used. Macros that are
- known at build time should not be flagged BUILTIN, as then they do
- not appear in macro dumps with e.g. -dM or -dD.
-
- Two values are not compile time constants, so we tag
- them in the FLAGS field instead:
- 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++. */
+ entered in the hash table under the name NAME, with value VALUE.
+
+ There are two tables of these. builtin_array holds all the
+ "builtin" macros: these are handled by builtin_macro() in
+ cppmacro.c. Builtin is somewhat of a misnomer -- the property of
+ interest is that these macros require special code to compute their
+ expansions. The value is a "builtin_type" enumerator.
+
+ operator_array holds the C++ named operators. These are keywords
+ which act as aliases for punctuators. In C++, they cannot be
+ altered through #define, and #if recognizes them as operators. In
+ C, these are not entered into the hash table at all (but see
+ <iso646.h>). The value is a token-type enumerator. */
struct builtin
{
const uchar *name;
- const char *value;
- unsigned char builtin;
- unsigned char operator;
- unsigned short flags;
unsigned short len;
+ unsigned short value;
};
-#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 }
+
+#define B(n, t) { DSC(n), t }
static const struct builtin builtin_array[] =
{
B("__TIME__", BT_TIME),
B("__BASE_FILE__", BT_BASE_FILE),
B("__LINE__", BT_SPECLINE),
B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
+ /* Keep builtins not used for -traditional-cpp at the end, and
+ update init_builtins() if any more are added. */
B("_Pragma", BT_PRAGMA),
-
- X("__VERSION__", VERS),
- X("__USER_LABEL_PREFIX__", ULP),
- C("__REGISTER_PREFIX__", REGISTER_PREFIX),
- C("__HAVE_BUILTIN_SETJMP__", "1"),
-#if USING_SJLJ_EXCEPTIONS
- /* libgcc needs to know this. */
- C("__USING_SJLJ_EXCEPTIONS__","1"),
-#endif
-#ifndef NO_BUILTIN_SIZE_TYPE
- C("__SIZE_TYPE__", SIZE_TYPE),
-#endif
-#ifndef NO_BUILTIN_PTRDIFF_TYPE
- C("__PTRDIFF_TYPE__", PTRDIFF_TYPE),
-#endif
-#ifndef NO_BUILTIN_WCHAR_TYPE
- C("__WCHAR_TYPE__", WCHAR_TYPE),
-#endif
-#ifndef NO_BUILTIN_WINT_TYPE
- C("__WINT_TYPE__", WINT_TYPE),
-#endif
-#ifdef STDC_0_IN_SYSTEM_HEADERS
B("__STDC__", BT_STDC),
-#else
- C("__STDC__", "1"),
-#endif
+};
- /* Named operators known to the preprocessor. These cannot be #defined
- and always have their stated meaning. They are treated like normal
- 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)
+static const struct builtin operator_array[] =
+{
+ B("and", CPP_AND_AND),
+ B("and_eq", CPP_AND_EQ),
+ B("bitand", CPP_AND),
+ B("bitor", CPP_OR),
+ B("compl", CPP_COMPL),
+ B("not", CPP_NOT),
+ B("not_eq", CPP_NOT_EQ),
+ B("or", CPP_OR_OR),
+ B("or_eq", CPP_OR_EQ),
+ B("xor", CPP_XOR),
+ B("xor_eq", CPP_XOR_EQ)
};
#undef B
-#undef C
-#undef X
-#undef O
-#define builtin_array_end (builtin_array + ARRAY_SIZE (builtin_array))
-/* Subroutine of cpp_read_main_file; reads the builtins table above and
- enters them, and language-specific macros, into the hash table. */
+/* Mark the C++ named operators in the hash table. */
static void
-init_builtins (pfile)
- cpp_reader *pfile;
+mark_named_operators (cpp_reader *pfile)
{
const struct builtin *b;
- for(b = builtin_array; b < builtin_array_end; b++)
+ for (b = operator_array;
+ b < (operator_array + ARRAY_SIZE (operator_array));
+ b++)
{
- if ((b->flags & CPLUS) && ! CPP_OPTION (pfile, cplusplus))
- continue;
+ cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
+ hp->flags |= NODE_OPERATOR;
+ hp->is_directive = 0;
+ hp->directive_index = b->value;
+ }
+}
- if ((b->flags & OPERATOR) && ! CPP_OPTION (pfile, operator_names))
- continue;
+/* 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);
- 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 | NODE_WARN;
- 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"\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 = CPP_OPTION (pfile, user_label_prefix);
- else
- val = b->value;
-
- /* 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_builtin (pfile, str);
- }
+ if (CPP_OPTION (pfile, traditional))
+ n -= 2;
+
+ for(b = builtin_array; b < builtin_array + n; b++)
+ {
+ cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
+ hp->type = NT_MACRO;
+ hp->flags |= NODE_BUILTIN | NODE_WARN;
+ hp->value.builtin = b->value;
}
if (CPP_OPTION (pfile, cplusplus))
_cpp_define_builtin (pfile, "__cplusplus 1");
-
- if (CPP_OPTION (pfile, objc))
- _cpp_define_builtin (pfile, "__OBJC__ 1");
-
- if (CPP_OPTION (pfile, lang) == CLK_STDC94)
+ else if (CPP_OPTION (pfile, lang) == CLK_ASM)
+ _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
+ else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
_cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
else if (CPP_OPTION (pfile, c99))
_cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
- if (CPP_OPTION (pfile, unsigned_char))
- _cpp_define_builtin (pfile, "__CHAR_UNSIGNED__ 1");
-
- if (CPP_OPTION (pfile, lang) == CLK_STDC89
- || CPP_OPTION (pfile, lang) == CLK_STDC94
- || CPP_OPTION (pfile, lang) == CLK_STDC99)
- _cpp_define_builtin (pfile, "__STRICT_ANSI__ 1");
- else if (CPP_OPTION (pfile, lang) == CLK_ASM)
- _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
-
- if (pfile->cb.register_builtins)
- (*pfile->cb.register_builtins) (pfile);
-}
-#undef BUILTIN
-#undef OPERATOR
-#undef VERS
-#undef ULP
-#undef CPLUS
-#undef builtin_array_end
-
-/* And another subroutine. This one sets up the standard include path. */
-static void
-init_standard_includes (pfile)
- cpp_reader *pfile;
-{
- char *path;
- const struct default_include *p;
- 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
- as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
- etc. specify an additional list of directories to be searched as
- if specified with -isystem, for the language indicated. */
-
- GET_ENV_PATH_LIST (path, "CPATH");
- if (path != 0 && *path != 0)
- path_include (pfile, path, BRACKET);
-
- switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus))
- {
- case 0:
- GET_ENV_PATH_LIST (path, "C_INCLUDE_PATH");
- break;
- case 1:
- GET_ENV_PATH_LIST (path, "CPLUS_INCLUDE_PATH");
- break;
- case 2:
- GET_ENV_PATH_LIST (path, "OBJC_INCLUDE_PATH");
- break;
- case 3:
- GET_ENV_PATH_LIST (path, "OBJCPLUS_INCLUDE_PATH");
- break;
- }
- if (path != 0 && *path != 0)
- path_include (pfile, path, SYSTEM);
-
- /* Search "translated" versions of GNU directories.
- These have /usr/local/lib/gcc... replaced by specd_prefix. */
- if (specd_prefix != 0 && cpp_GCC_INCLUDE_DIR_len)
- {
- /* Remove the `include' from /usr/local/lib/gcc.../include.
- GCC_INCLUDE_DIR will always end in /include. */
- int default_len = cpp_GCC_INCLUDE_DIR_len;
- char *default_prefix = (char *) alloca (default_len + 1);
- int specd_len = strlen (specd_prefix);
-
- memcpy (default_prefix, cpp_GCC_INCLUDE_DIR, default_len);
- default_prefix[default_len] = '\0';
-
- for (p = cpp_include_defaults; p->fname; p++)
- {
- /* Some standard dirs are only for C++. */
- if (!p->cplusplus
- || (CPP_OPTION (pfile, cplusplus)
- && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
- {
- /* Does this dir start with the prefix? */
- if (!memcmp (p->fname, default_prefix, default_len))
- {
- /* Yes; change prefix and add to search list. */
- int flen = strlen (p->fname);
- int this_len = specd_len + flen - default_len;
- char *str = (char *) xmalloc (this_len + 1);
- memcpy (str, specd_prefix, specd_len);
- memcpy (str + specd_len,
- p->fname + default_len,
- flen - default_len + 1);
-
- append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
- }
- }
- }
- }
-
- /* Search ordinary names for GNU include directories. */
- for (p = cpp_include_defaults; p->fname; p++)
- {
- /* Some standard dirs are only for C++. */
- if (!p->cplusplus
- || (CPP_OPTION (pfile, cplusplus)
- && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
- {
- char *str = update_path (p->fname, p->component);
- append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
- }
- }
-}
-
-/* Pushes a command line -imacro and -include file indicated by P onto
- the buffer stack. Returns non-zero if successful. */
-static bool
-push_include (pfile, p)
- cpp_reader *pfile;
- struct pending_option *p;
-{
- 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;
+ if (hosted)
+ _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
+ else
+ _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
- while (head)
- {
- next = head->next;
- free (head);
- head = next;
- }
+ if (CPP_OPTION (pfile, objc))
+ _cpp_define_builtin (pfile, "__OBJC__ 1");
}
/* 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);
/* Sanity checks for assumptions about CPP arithmetic and target
type precisions made by cpplib. */
test--;
if (test < 1)
- cpp_error (pfile, DL_FATAL, "cppchar_t must be an unsigned type");
+ cpp_error (pfile, DL_ICE, "cppchar_t must be an unsigned type");
- if (CPP_OPTION (pfile, precision) > BITS_PER_HOST_WIDEST_INT)
- cpp_error (pfile, DL_FATAL,
- "preprocessor arithmetic has maximum precision of %u bits; target requires %u bits",
- BITS_PER_HOST_WIDEST_INT, CPP_OPTION (pfile, precision));
+ if (CPP_OPTION (pfile, precision) > max_precision)
+ cpp_error (pfile, 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_FATAL,
+ cpp_error (pfile, 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_FATAL, "target char is less than 8 bits wide");
+ cpp_error (pfile, 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_FATAL,
+ cpp_error (pfile, 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_FATAL,
+ cpp_error (pfile, 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");
+
if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
- cpp_error (pfile, DL_FATAL,
- "CPP on this host cannot handle wide character constants over %u bits, but the target requires %u bits",
- BITS_PER_CPPCHAR_T, CPP_OPTION (pfile, wchar_precision));
+ cpp_error (pfile, 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));
}
#else
# define sanity_checks(PFILE)
#endif
+/* Add a dependency target. Can be called any number of times before
+ 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 (cpp_reader *pfile, const char *target, int quote)
+{
+ if (!pfile->deps)
+ pfile->deps = deps_init ();
+
+ deps_add_target (pfile->deps, target, quote);
+}
+
/* 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);
- /* 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);
+ post_options (pfile);
- /* Set up the include search path now. */
- if (! CPP_OPTION (pfile, no_standard_includes))
- init_standard_includes (pfile);
-
- merge_include_chains (pfile);
+ /* Mark named operators before handling command line macros. */
+ if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
+ mark_named_operators (pfile);
+}
- /* With -v, print the list of dirs to search. */
- if (CPP_OPTION (pfile, verbose))
+/* 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)
{
- struct search_path *l;
- fprintf (stderr, _("#include \"...\" search starts here:\n"));
- for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
- {
- 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"));
- }
+ if (!pfile->deps)
+ pfile->deps = deps_init ();
- if (CPP_OPTION (pfile, print_deps))
- /* Set the default target (if there is none already). */
- deps_add_default_target (pfile->deps, fname);
+ /* Set the default target (if there is none already). */
+ deps_add_default_target (pfile->deps, fname);
+ }
- /* Open the main input file. */
- if (!_cpp_read_file (pfile, fname))
+ if (!_cpp_stack_file (pfile, fname))
return NULL;
- /* Set this after cpp_post_options so the client can change the
- option if it wishes, and after stacking the main file so we don't
- trace the main file. */
+ /* 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);
/* For foo.i, read the original filename foo.c now, for the benefit
if (CPP_OPTION (pfile, preprocessed))
read_original_filename (pfile);
+ if (CPP_OPTION (pfile, working_directory))
+ {
+ const char *name = pfile->map->to_file;
+ const char *dir = getpwd ();
+ char *dir_with_slashes = alloca (strlen (dir) + 3);
+
+ memcpy (dir_with_slashes, dir, strlen (dir));
+ memcpy (dir_with_slashes + strlen (dir), "//", 3);
+
+ if (pfile->cb.dir_change)
+ pfile->cb.dir_change (pfile, dir);
+ /* Emit file renames that will be recognized by
+ read_directory_filename, since dir_change doesn't output
+ anything. */
+ _cpp_do_file_change (pfile, LC_RENAME, dir_with_slashes, 1, 0);
+ _cpp_do_file_change (pfile, LC_RENAME, name, 1, 0);
+ }
+
return pfile->map->to_file;
}
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)
{
- /* Install builtins and process command line macros etc. in the order
- they appeared, but only if not already preprocessed. */
- if (! CPP_OPTION (pfile, preprocessed))
+ 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)
{
- 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, 1);
+ return;
}
- free_chain (CPP_OPTION (pfile, pending)->imacros_head);
- free_chain (CPP_OPTION (pfile, pending)->directive_head);
-}
+ token = _cpp_lex_direct (pfile);
-/* 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 (token->type != CPP_NUMBER)
{
- struct pending_option *head = *pfile->next_include_file;
-
- while (head && !push_include (pfile, head))
- head = head->next;
-
- 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;
- }
+ _cpp_backup_tokens (pfile, 2);
+ return;
}
-}
-/* Use mkdeps.c to output dependency information. */
-static void
-output_deps (pfile)
- cpp_reader *pfile;
-{
- /* Stream on which to print the dependency information. */
- FILE *deps_stream = 0;
- const char *const deps_mode =
- CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
+ token = _cpp_lex_direct (pfile);
- if (CPP_OPTION (pfile, deps_file)[0] == '\0')
- deps_stream = stdout;
- else
+ 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] == '/'))
{
- deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
- if (deps_stream == 0)
- {
- cpp_errno (pfile, DL_ERROR, CPP_OPTION (pfile, deps_file));
- return;
- }
+ _cpp_backup_tokens (pfile, 3);
+ return;
}
- deps_write (pfile->deps, deps_stream, 72);
+ if (pfile->cb.dir_change)
+ {
+ char *debugdir = alloca (token->val.str.len - 3);
- if (CPP_OPTION (pfile, deps_phony_targets))
- deps_phony_targets (pfile->deps, deps_stream);
+ memcpy (debugdir, (const char *) token->val.str.text + 1,
+ token->val.str.len - 4);
+ debugdir[token->val.str.len - 4] = '\0';
- /* Don't close stdout. */
- if (deps_stream != stdout)
- {
- if (ferror (deps_stream) || fclose (deps_stream) != 0)
- cpp_error (pfile, DL_FATAL, "I/O error on output");
- }
+ pfile->cb.dir_change (pfile, debugdir);
+ }
+
+ /* We want to process the fake line changes as regular changes, to
+ get them output. */
+ _cpp_backup_tokens (pfile, 3);
+
+ CPP_OPTION (pfile, working_directory) = false;
}
-/* This is called at the end of preprocessing. It pops the
- last buffer and writes dependency output. It should also
- clear macro definitions, such that you could call cpp_start_read
- with a new filename to restart processing. */
-void
-cpp_finish (pfile)
- cpp_reader *pfile;
+/* 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 (cpp_reader *pfile, FILE *deps_stream)
{
+ /* Warn about unused macros before popping the final buffer. */
+ if (CPP_OPTION (pfile, warn_unused_macros))
+ cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
+
/* cpplex.c leaves the final buffer on the stack. This it so that
it returns an unending stream of CPP_EOFs to the client. If we
popped the buffer, we'd dereference a NULL buffer pointer and
while (pfile->buffer)
_cpp_pop_buffer (pfile);
- /* Don't write the deps file if preprocessing has failed. */
- if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
- output_deps (pfile);
-
- /* Report on headers that could use multiple include guards. */
- if (CPP_OPTION (pfile, print_include_names))
- _cpp_report_missing_guards (pfile);
-}
-
-/* Add a directive to be handled later in the initialization phase. */
-static void
-new_pending_directive (pend, text, handler)
- struct cpp_pending *pend;
- 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_arg N_("argument missing after %s")
-#define no_ass N_("assertion missing after %s")
-#define no_dir N_("directory name missing after %s")
-#define no_fil N_("file name missing after %s")
-#define no_mac N_("macro name missing after %s")
-#define no_pth N_("path name missing after %s")
-#define no_num N_("number missing after %s")
-#define no_tgt N_("target missing after %s")
-
-/* This is the list of all command line options, with the leading
- "-" removed. It must be sorted in ASCII collating order. */
-#define COMMAND_LINE_OPTIONS \
- DEF_OPT("$", 0, OPT_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("CC", 0, OPT_CC) \
- 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("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("fsigned-char", 0, OPT_fsigned_char) \
- DEF_OPT("ftabstop=", no_num, OPT_ftabstop) \
- DEF_OPT("funsigned-char", 0, OPT_funsigned_char) \
- 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-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=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=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("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,
-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. -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;
-{
- unsigned int md, mn, mx;
- size_t opt_len;
- int comp;
-
- mn = 0;
- mx = N_OPTS;
-
- while (mx > mn)
+ /* Don't write the deps file if there are errors. */
+ if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
+ && deps_stream && pfile->errors == 0)
{
- md = (mn + mx) / 2;
-
- opt_len = cl_options[md].opt_len;
- comp = memcmp (input, cl_options[md].opt_text, opt_len);
+ deps_write (pfile->deps, deps_stream, 72);
- 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 (memcmp (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;
- }
- }
+ if (CPP_OPTION (pfile, deps.phony_targets))
+ deps_phony_targets (pfile->deps, deps_stream);
}
- return -1;
-}
-
-/* Handle one command-line option in (argc, argv).
- Can be called multiple times, to handle multiple sets of options.
- If ignore is non-zero, this will ignore unrecognized -W* options.
- Returns number of strings consumed. */
-int
-cpp_handle_option (pfile, argc, argv, ignore)
- cpp_reader *pfile;
- int argc;
- char **argv;
- int ignore;
-{
- int i = 0;
- struct cpp_pending *pend = CPP_OPTION (pfile, pending);
-
- /* Interpret "-" or a non-option as a file name. */
- if (argv[i][0] != '-' || argv[i][1] == '\0')
- {
- if (CPP_OPTION (pfile, in_fname) == NULL)
- CPP_OPTION (pfile, in_fname) = argv[i];
- else if (CPP_OPTION (pfile, out_fname) == NULL)
- CPP_OPTION (pfile, out_fname) = argv[i];
- else
- cpp_error (pfile, DL_FATAL,
- "too many filenames. Type %s --help for usage info",
- progname);
- }
- else
- {
- 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];
-
- /* 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_W)
- {
- arg = argv[++i];
- if (!arg)
- {
- cpp_error (pfile, DL_FATAL,
- cl_options[opt_index].msg, argv[i - 1]);
- return argc;
- }
- }
- }
-
- switch (opt_code)
- {
- case N_OPTS: /* Shut GCC up. */
- break;
- case OPT_fleading_underscore:
- CPP_OPTION (pfile, user_label_prefix) = "_";
- break;
- case OPT_fno_leading_underscore:
- 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;
- break;
- case OPT_fno_preprocessed:
- 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_fsigned_char:
- CPP_OPTION (pfile, unsigned_char) = 0;
- break;
- case OPT_funsigned_char:
- CPP_OPTION (pfile, unsigned_char) = 1;
- break;
- case OPT_ftabstop:
- /* Silently ignore empty string, non-longs and silly values. */
- if (arg[0] != '\0')
- {
- char *endptr;
- long tabstop = strtol (arg, &endptr, 10);
- if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
- CPP_OPTION (pfile, tabstop) = tabstop;
- }
- break;
- case OPT_w:
- CPP_OPTION (pfile, inhibit_warnings) = 1;
- break;
- case OPT_h:
- case OPT__help:
- print_help ();
- 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:
- CPP_OPTION (pfile, help_only) = 1;
- pfile->print_version = 1;
- break;
- case OPT_v:
- CPP_OPTION (pfile, verbose) = 1;
- pfile->print_version = 1;
- break;
- case OPT_version:
- pfile->print_version = 1;
- break;
-
- case OPT_C:
- CPP_OPTION (pfile, discard_comments) = 0;
- break;
- case OPT_CC:
- CPP_OPTION (pfile, discard_comments) = 0;
- CPP_OPTION (pfile, discard_comments_in_macro_exp) = 0;
- break;
- case OPT_P:
- CPP_OPTION (pfile, no_line_commands) = 1;
- break;
- case OPT_dollar: /* Don't include $ in identifiers. */
- CPP_OPTION (pfile, dollars_in_ident) = 0;
- break;
- case OPT_H:
- CPP_OPTION (pfile, print_include_names) = 1;
- break;
- case OPT_D:
- new_pending_directive (pend, arg, cpp_define);
- break;
- case OPT_pedantic_errors:
- CPP_OPTION (pfile, pedantic_errors) = 1;
- /* fall through */
- case OPT_pedantic:
- CPP_OPTION (pfile, pedantic) = 1;
- CPP_OPTION (pfile, warn_endif_labels) = 1;
- break;
- case OPT_trigraphs:
- CPP_OPTION (pfile, trigraphs) = 1;
- break;
- case OPT_plus:
- CPP_OPTION (pfile, cplusplus) = 1;
- CPP_OPTION (pfile, cplusplus_comments) = 1;
- break;
- case OPT_remap:
- CPP_OPTION (pfile, remap) = 1;
- break;
- case OPT_iprefix:
- CPP_OPTION (pfile, include_prefix) = arg;
- CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
- break;
- case OPT_lang_c:
- set_lang (pfile, CLK_GNUC89);
- break;
- case OPT_lang_cplusplus:
- set_lang (pfile, CLK_GNUCXX);
- break;
- case OPT_lang_objc:
- set_lang (pfile, CLK_OBJC);
- break;
- case OPT_lang_objcplusplus:
- set_lang (pfile, CLK_OBJCXX);
- break;
- case OPT_lang_asm:
- set_lang (pfile, CLK_ASM);
- break;
- case OPT_std_cplusplus98:
- set_lang (pfile, CLK_CXX98);
- break;
- case OPT_std_gnu89:
- set_lang (pfile, CLK_GNUC89);
- break;
- case OPT_std_gnu9x:
- case OPT_std_gnu99:
- set_lang (pfile, CLK_GNUC99);
- break;
- case OPT_std_iso9899_199409:
- set_lang (pfile, CLK_STDC94);
- break;
- case OPT_std_iso9899_1990:
- case OPT_std_c89:
- 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:
- 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)
- CPP_OPTION (pfile, out_fname) = arg;
- else
- {
- cpp_error (pfile, DL_FATAL, "output filename specified twice");
- return argc;
- }
- break;
- 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. */
- {
- char c;
-
- while ((c = *arg++) != '\0')
- switch (c)
- {
- case 'M':
- CPP_OPTION (pfile, dump_macros) = dump_only;
- break;
- case 'N':
- CPP_OPTION (pfile, dump_macros) = dump_names;
- break;
- case 'D':
- CPP_OPTION (pfile, dump_macros) = dump_definitions;
- break;
- case 'I':
- CPP_OPTION (pfile, dump_includes) = 1;
- break;
- }
- }
- break;
-
- case OPT_MG:
- CPP_OPTION (pfile, print_deps_missing_files) = 1;
- break;
- case OPT_M:
- /* When doing dependencies with -M or -MM, suppress normal
- preprocessed output, but still do -dM etc. as software
- depends on this. Preprocessed output occurs if -MD, -MMD
- or environment var dependency generation is used. */
- CPP_OPTION (pfile, print_deps) = 2;
- CPP_OPTION (pfile, no_output) = 1;
- break;
- case OPT_MM:
- CPP_OPTION (pfile, print_deps) = 1;
- CPP_OPTION (pfile, no_output) = 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;
-
- 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] == '-')
- {
- /* -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_I: /* Add directory to path for includes. */
- if (!strcmp (arg, "-"))
- {
- /* -I- means:
- Use the preceding -I directories for #include "..."
- but not #include <...>.
- 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 (! CPP_OPTION (pfile, ignore_srcdir))
- {
- 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
- {
- cpp_error (pfile, DL_FATAL, "-I- specified twice");
- return argc;
- }
- }
- else
- 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, xstrdup (arg), SYSTEM, 0);
- 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;
- case OPT_iwithprefix:
- /* Add directory to end of path for includes,
- with the default prefix at the front of its name. */
- /* fall through */
- case OPT_iwithprefixbefore:
- /* Add directory to main path for includes,
- with the default prefix at the front of its name. */
- {
- char *fname;
- int len;
-
- len = strlen (arg);
-
- if (CPP_OPTION (pfile, include_prefix) != 0)
- {
- 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 if (cpp_GCC_INCLUDE_DIR_len)
- {
- fname = xmalloc (cpp_GCC_INCLUDE_DIR_len + len + 1);
- memcpy (fname, cpp_GCC_INCLUDE_DIR, cpp_GCC_INCLUDE_DIR_len);
- memcpy (fname + cpp_GCC_INCLUDE_DIR_len, arg, len + 1);
- }
- else
- fname = xstrdup (arg);
-
- 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, xstrdup (arg), AFTER, 0);
- break;
- case OPT_W:
- /* Silently ignore unrecognised options. */
- if (!strcmp (argv[i], "-Wall"))
- {
- CPP_OPTION (pfile, warn_trigraphs) = 1;
- CPP_OPTION (pfile, warn_comments) = 1;
- }
- else if (!strcmp (argv[i], "-Wtraditional"))
- CPP_OPTION (pfile, warn_traditional) = 1;
- else if (!strcmp (argv[i], "-Wtrigraphs"))
- CPP_OPTION (pfile, warn_trigraphs) = 1;
- else if (!strcmp (argv[i], "-Wcomment"))
- CPP_OPTION (pfile, warn_comments) = 1;
- else if (!strcmp (argv[i], "-Wcomments"))
- CPP_OPTION (pfile, warn_comments) = 1;
- else if (!strcmp (argv[i], "-Wundef"))
- CPP_OPTION (pfile, warn_undef) = 1;
- else if (!strcmp (argv[i], "-Wimport"))
- CPP_OPTION (pfile, warn_import) = 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], "-Wendif-labels"))
- CPP_OPTION (pfile, warn_endif_labels) = 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_trigraphs) = 0;
- else if (!strcmp (argv[i], "-Wno-comment"))
- CPP_OPTION (pfile, warn_comments) = 0;
- else if (!strcmp (argv[i], "-Wno-comments"))
- CPP_OPTION (pfile, warn_comments) = 0;
- else if (!strcmp (argv[i], "-Wno-undef"))
- 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-error"))
- CPP_OPTION (pfile, warnings_are_errors) = 0;
- else if (!strcmp (argv[i], "-Wno-system-headers"))
- CPP_OPTION (pfile, warn_system_headers) = 0;
- else if (!strcmp (argv[i], "-Wno-endif-labels"))
- CPP_OPTION (pfile, warn_endif_labels) = 0;
- else if (! ignore)
- return i;
- break;
- }
- }
- return i + 1;
-}
-
-/* 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.
- Returns number of strings consumed. */
-int
-cpp_handle_options (pfile, argc, argv)
- cpp_reader *pfile;
- int argc;
- char **argv;
-{
- int i;
- int strings_processed;
-
- for (i = 0; i < argc; i += strings_processed)
- {
- strings_processed = cpp_handle_option (pfile, argc - i, argv + i, 1);
- if (strings_processed == 0)
- break;
- }
+ /* Report on headers that could use multiple include guards. */
+ if (CPP_OPTION (pfile, print_include_names))
+ _cpp_report_missing_guards (pfile);
- return i;
+ return pfile->errors;
}
-/* 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;
+static void
+post_options (cpp_reader *pfile)
{
- if (pfile->print_version)
- {
- fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string);
-#ifdef TARGET_VERSION
- TARGET_VERSION;
-#endif
- fputc ('\n', stderr);
- }
-
- /* Canonicalize in_fname and out_fname. We guarantee they are not
- NULL, and that the empty string represents stdin / stdout. */
- if (CPP_OPTION (pfile, in_fname) == NULL
- || !strcmp (CPP_OPTION (pfile, in_fname), "-"))
- CPP_OPTION (pfile, in_fname) = "";
-
- if (CPP_OPTION (pfile, out_fname) == NULL
- || !strcmp (CPP_OPTION (pfile, out_fname), "-"))
- CPP_OPTION (pfile, out_fname) = "";
-
/* -Wtraditional is not useful in C++ mode. */
if (CPP_OPTION (pfile, cplusplus))
CPP_OPTION (pfile, warn_traditional) = 0;
- /* Set this if it hasn't been set already. */
- if (CPP_OPTION (pfile, user_label_prefix) == NULL)
- CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
-
/* Permanently disable macro expansion if we are rescanning
- preprocessed text. */
+ preprocessed text. Read preprocesed source in ISO mode. */
if (CPP_OPTION (pfile, preprocessed))
- pfile->state.prevent_expansion = 1;
-
- /* -dM makes no normal output. This is set here so that -dM -dD
- works as expected. */
- if (CPP_OPTION (pfile, dump_macros) == dump_only)
- CPP_OPTION (pfile, no_output) = 1;
-
- /* Disable -dD, -dN and -dI if we should make no normal output
- (such as with -M). Allow -M -dM since some software relies on
- this. */
- if (CPP_OPTION (pfile, no_output))
{
- if (CPP_OPTION (pfile, dump_macros) != dump_only)
- CPP_OPTION (pfile, dump_macros) = dump_none;
- CPP_OPTION (pfile, dump_includes) = 0;
+ pfile->state.prevent_expansion = 1;
+ CPP_OPTION (pfile, traditional) = 0;
}
- /* 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_error (pfile, DL_FATAL,
- "you must additionally specify either -M or -MM");
-}
-
-/* Set up dependency-file output. On exit, if print_deps is non-zero
- then deps_file is not NULL; stdout is the empty string. */
-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, warn_trigraphs) == 2)
+ CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
- if (CPP_OPTION (pfile, print_deps) == 0)
+ if (CPP_OPTION (pfile, traditional))
{
- 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 -MF overrides environment variables and default. */
- if (CPP_OPTION (pfile, deps_file) == 0)
- CPP_OPTION (pfile, deps_file) = output_file;
-
- CPP_OPTION (pfile, print_deps_append) = 1;
+ /* 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;
}
- else if (CPP_OPTION (pfile, deps_file) == 0)
- /* If -M or -MM was seen without -MF, default output to wherever
- was specified with -o. out_fname is non-NULL here. */
- CPP_OPTION (pfile, deps_file) = CPP_OPTION (pfile, out_fname);
-}
-
-/* Handle --help output. */
-static void
-print_help ()
-{
- /* To keep the lines from getting too long for some compilers, limit
- to about 500 characters (6 lines) per chunk. */
- fputs (_("\
-Switches:\n\
- -include <file> Include the contents of <file> before other files\n\
- -imacros <file> Accept definition of macros in <file>\n\
- -iprefix <path> Specify <path> as a prefix for next two options\n\
- -iwithprefix <dir> Add <dir> to the end of the system include path\n\
- -iwithprefixbefore <dir> Add <dir> to the end of the main include path\n\
- -isystem <dir> Add <dir> to the start of the system include path\n\
-"), stdout);
- fputs (_("\
- -idirafter <dir> Add <dir> to the end of the system include path\n\
- -I <dir> Add <dir> to the end of the main include path\n\
- -I- Fine-grained include path control; see info docs\n\
- -nostdinc Do not search system include directories\n\
- (dirs specified with -isystem will still be used)\n\
- -nostdinc++ Do not search system include directories for C++\n\
- -o <file> Put output into <file>\n\
-"), stdout);
- fputs (_("\
- -pedantic Issue all warnings demanded by strict ISO C\n\
- -pedantic-errors Issue -pedantic warnings as errors instead\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\
-"), 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\
-"), stdout);
- fputs (_("\
- -std=<std name> Specify the conformance standard; one of:\n\
- gnu89, gnu99, c89, c99, iso9899:1990,\n\
- iso9899:199409, iso9899:1999\n\
- -+ Allow parsing of C++ style features\n\
- -w Inhibit warning messages\n\
- -Wtrigraphs Warn if trigraphs are encountered\n\
- -Wno-trigraphs Do not warn about trigraphs\n\
- -Wcomment{s} Warn if one comment starts inside another\n\
-"), stdout);
- fputs (_("\
- -Wno-comment{s} Do not warn about comments\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\
-"), stdout);
- fputs (_("\
- -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\
- -MD Generate make dependencies and compile\n\
- -MMD As -MD, but ignore system header files\n\
- -MF <file> Write dependency output to the given file\n\
- -MG Treat missing header file as generated files\n\
-"), stdout);
- fputs (_("\
- -MP Generate phony targets for all headers\n\
- -MQ <target> Add a MAKE-quoted target\n\
- -MT <target> Add an unquoted target\n\
-"), stdout);
- fputs (_("\
- -D<macro> Define a <macro> with string '1' as its value\n\
- -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\
-"), 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 (_("\
- -fpreprocessed Treat the input file as already preprocessed\n\
- -ftabstop=<number> Distance between tab stops for column reporting\n\
- -P Do not generate #line directives\n\
- -$ Do not allow '$' in identifiers\n\
- -remap Remap file names when including files\n\
- --version Display version information\n\
- -h or --help Display this information\n\
-"), stdout);
}
OSDN Git Service
