#include "config.h"
#include "system.h"
-#include "hashtab.h"
#include "cpplib.h"
#include "cpphash.h"
#include "output.h"
#include "intl.h"
#include "version.h"
#include "mkdeps.h"
+#include "cppdefault.h"
/* Predefined symbols, built-in macros, and the default include path. */
#define INO_T_EQ(a, b) ((a) == (b))
#endif
-#ifndef STANDARD_INCLUDE_DIR
-#define STANDARD_INCLUDE_DIR "/usr/include"
-#endif
-
-/* We let tm.h override the types used here, to handle trivial differences
- such as the choice of unsigned int or long unsigned int for size_t.
- When machines start needing nontrivial differences in the size type,
- it would be best to do something here to figure out automatically
- from other information what type to use. */
-
-/* The string value for __SIZE_TYPE__. */
-
-#ifndef SIZE_TYPE
-#define SIZE_TYPE "long unsigned int"
-#endif
-
-/* The string value for __PTRDIFF_TYPE__. */
-
-#ifndef PTRDIFF_TYPE
-#define PTRDIFF_TYPE "long int"
-#endif
-
-/* The string value for __WCHAR_TYPE__. */
-
-#ifndef WCHAR_TYPE
-#define WCHAR_TYPE "int"
-#endif
-
-/* The string value for __USER_LABEL_PREFIX__ */
-
-#ifndef USER_LABEL_PREFIX
-#define USER_LABEL_PREFIX ""
-#endif
-
-/* The string value for __REGISTER_PREFIX__ */
-
-#ifndef REGISTER_PREFIX
-#define REGISTER_PREFIX ""
-#endif
-
-/* This is the default list of directories to search for include files.
- It may be overridden by the various -I and -ixxx options.
-
- #include "file" looks in the same directory as the current file,
- then this list.
- #include <file> just looks in this list.
-
- All these directories are treated as `system' include directories
- (they are not subject to pedantic warnings in some cases). */
-
-struct default_include
-{
- const char *fname; /* The name of the directory. */
- const char *component; /* The component containing the directory
- (see update_path in prefix.c) */
- int cplusplus; /* Only look here if we're compiling C++. */
- int cxx_aware; /* Includes in this directory don't need to
- be wrapped in extern "C" when compiling
- C++. */
-};
-
-#ifndef STANDARD_INCLUDE_COMPONENT
-#define STANDARD_INCLUDE_COMPONENT 0
-#endif
-
-#ifdef CROSS_COMPILE
-#undef LOCAL_INCLUDE_DIR
-#undef SYSTEM_INCLUDE_DIR
-#undef STANDARD_INCLUDE_DIR
-#else
-#undef CROSS_INCLUDE_DIR
-#endif
-
-static const struct default_include include_defaults_array[]
-#ifdef INCLUDE_DEFAULTS
-= INCLUDE_DEFAULTS;
-#else
-= {
-#ifdef GPLUSPLUS_INCLUDE_DIR
- /* Pick up GNU C++ specific include files. */
- { GPLUSPLUS_INCLUDE_DIR, "G++", 1, 1 },
-#endif
-#ifdef LOCAL_INCLUDE_DIR
- /* /usr/local/include comes before the fixincluded header files. */
- { LOCAL_INCLUDE_DIR, 0, 0, 1 },
-#endif
-#ifdef GCC_INCLUDE_DIR
- /* This is the dir for fixincludes and for gcc's private headers. */
- { GCC_INCLUDE_DIR, "GCC", 0, 0 },
-#endif
-#ifdef CROSS_INCLUDE_DIR
- /* One place the target system's headers might be. */
- { CROSS_INCLUDE_DIR, "GCC", 0, 0 },
-#endif
-#ifdef TOOL_INCLUDE_DIR
- /* Another place the target system's headers might be. */
- { TOOL_INCLUDE_DIR, "BINUTILS", 0, 1 },
-#endif
-#ifdef SYSTEM_INCLUDE_DIR
- /* Some systems have an extra dir of include files. */
- { SYSTEM_INCLUDE_DIR, 0, 0, 0 },
-#endif
-#ifdef STANDARD_INCLUDE_DIR
- /* /usr/include comes dead last. */
- { STANDARD_INCLUDE_DIR, STANDARD_INCLUDE_COMPONENT, 0, 0 },
-#endif
- { 0, 0, 0, 0 }
- };
-#endif /* no INCLUDE_DEFAULTS */
-
/* Internal structures and prototypes. */
/* A `struct pending_option' remembers one -D, -A, -U, -include, or -imacros
static void print_help PARAMS ((void));
static void path_include PARAMS ((cpp_reader *,
- struct cpp_pending *,
char *, int));
static void initialize_builtins PARAMS ((cpp_reader *));
static void append_include_chain PARAMS ((cpp_reader *,
- struct cpp_pending *,
char *, int, int));
+struct file_name_list * remove_dup_dir PARAMS ((cpp_reader *,
+ struct file_name_list *));
+struct file_name_list * remove_dup_dirs PARAMS ((cpp_reader *,
+ struct file_name_list *));
static void merge_include_chains PARAMS ((cpp_reader *));
-static void dump_special_to_buffer PARAMS ((cpp_reader *, const char *));
static void initialize_dependency_output PARAMS ((cpp_reader *));
static void initialize_standard_includes PARAMS ((cpp_reader *));
-static void new_pending_directive PARAMS ((struct cpp_pending *,
+static void new_pending_directive PARAMS ((struct cpp_pending *,
const char *,
cl_directive_handler));
#ifdef HOST_EBCDIC
static int opt_comp PARAMS ((const void *, const void *));
#endif
static int parse_option PARAMS ((const char *));
-static int handle_option PARAMS ((cpp_reader *, int, char **));
/* Fourth argument to append_include_chain: chain to use */
enum { QUOTE = 0, BRACKET, SYSTEM, AFTER };
-/* If we have designated initializers (GCC >2.7, or C99) this table
- can be initialized, constant data. Otherwise, it has to be filled
- in at runtime. */
+/* If we have designated initializers (GCC >2.7) these tables can be
+ initialized, constant data. Otherwise, they have to be filled in at
+ runtime. */
+#if HAVE_DESIGNATED_INITIALIZERS
-#if (GCC_VERSION >= 2007) || (__STDC_VERSION__ >= 199901L)
#define init_IStable() /* nothing */
-#define ISTABLE const unsigned char _cpp_IStable[256] = {
+#define ISTABLE __extension__ const U_CHAR _cpp_IStable[UCHAR_MAX + 1] = {
+
+#define init_trigraph_map() /* nothing */
+#define TRIGRAPH_MAP \
+__extension__ const U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = {
+
#define END };
#define s(p, v) [p] = v,
+
#else
-#define ISTABLE unsigned char _cpp_IStable[256] = { 0 }; \
+
+#define ISTABLE unsigned char _cpp_IStable[UCHAR_MAX + 1] = { 0 }; \
static void init_IStable PARAMS ((void)) { \
unsigned char *x = _cpp_IStable;
+
+#define TRIGRAPH_MAP U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
+ static void init_trigraph_map PARAMS ((void)) { \
+ unsigned char *x = _cpp_trigraph_map;
+
#define END }
#define s(p, v) x[p] = v;
+
#endif
#define A(x) s(x, ISidnum|ISidstart)
#define N(x) s(x, ISidnum|ISnumstart)
#define H(x) s(x, IShspace|ISspace)
+#define V(x) s(x, ISvspace|ISspace)
#define S(x) s(x, ISspace)
ISTABLE
N('1') N('2') N('3') N('4') N('5') N('6') N('7') N('8') N('9') N('0')
- H('\0') H(' ') H('\t') H('\v') H('\f')
+ H(' ') H('\t')
+
+ V('\n') V('\r')
+
+ S('\0') S('\v') S('\f')
+END
- S('\n')
+TRIGRAPH_MAP
+ s('=', '#') s(')', ']') s('!', '|')
+ s('(', '[') s('\'', '^') s('>', '}')
+ s('/', '\\') s('<', '{') s('-', '~')
END
#undef A
#undef N
#undef H
+#undef V
#undef S
#undef s
#undef ISTABLE
#undef END
+#undef TRIGRAPH_MAP
/* Given a colon-separated list of file names PATH,
add all the names to the search path for include files. */
static void
-path_include (pfile, pend, list, path)
+path_include (pfile, list, path)
cpp_reader *pfile;
- struct cpp_pending *pend;
char *list;
int path;
{
name[q - p] = 0;
}
- append_include_chain (pfile, pend, name, path, 0);
+ append_include_chain (pfile, name, path, 0);
/* Advance past this name. */
if (*q == 0)
/* Append DIR to include path PATH. DIR must be permanently allocated
and writable. */
static void
-append_include_chain (pfile, pend, dir, path, cxx_aware)
+append_include_chain (pfile, dir, path, cxx_aware)
cpp_reader *pfile;
- struct cpp_pending *pend;
char *dir;
int path;
int cxx_aware;
{
+ struct cpp_pending *pend = CPP_OPTION (pfile, pending);
struct file_name_list *new;
struct stat st;
unsigned int len;
if (errno != ENOENT)
cpp_notice_from_errno (pfile, dir);
else if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring nonexistent directory `%s'\n"), dir);
+ fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"), dir);
return;
}
}
}
+/* Handle a duplicated include path. PREV is the link in the chain
+ before the duplicate. The duplicate is removed from the chain and
+ freed. Returns PREV. */
+struct file_name_list *
+remove_dup_dir (pfile, prev)
+ cpp_reader *pfile;
+ struct file_name_list *prev;
+{
+ struct file_name_list *cur = prev->next;
+
+ if (CPP_OPTION (pfile, verbose))
+ fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), cur->name);
+
+ prev->next = cur->next;
+ free (cur->name);
+ free (cur);
+
+ return prev;
+}
+
+/* Remove duplicate directories from a chain. Returns the tail of the
+ chain, or NULL if the chain is empty. This algorithm is quadratic
+ in the number of -I switches, which is acceptable since there
+ aren't usually that many of them. */
+struct file_name_list *
+remove_dup_dirs (pfile, head)
+ cpp_reader *pfile;
+ struct file_name_list *head;
+{
+ struct file_name_list *prev = NULL, *cur, *other;
+
+ for (cur = head; cur; cur = cur->next)
+ {
+ for (other = head; other != cur; other = other->next)
+ if (INO_T_EQ (cur->ino, other->ino) && cur->dev == other->dev)
+ {
+ cur = remove_dup_dir (pfile, prev);
+ break;
+ }
+ prev = cur;
+ }
+
+ return prev;
+}
+
/* Merge the four include chains together in the order quote, bracket,
system, after. Remove duplicate dirs (as determined by
INO_T_EQ()). The system_include and after_include chains are never
merge_include_chains (pfile)
cpp_reader *pfile;
{
- struct file_name_list *prev, *cur, *other;
- struct file_name_list *quote, *brack, *systm, *after;
- struct file_name_list *qtail, *btail, *stail, *atail;
+ struct file_name_list *quote, *brack, *systm, *qtail;
struct cpp_pending *pend = CPP_OPTION (pfile, pending);
- qtail = pend->quote_tail;
- btail = pend->brack_tail;
- stail = pend->systm_tail;
- atail = pend->after_tail;
-
quote = pend->quote_head;
brack = pend->brack_head;
systm = pend->systm_head;
- after = pend->after_head;
+ qtail = pend->quote_tail;
- /* Paste together bracket, system, and after include chains. */
- if (stail)
- stail->next = after;
+ /* Paste together bracket, system, and after include chains. */
+ if (systm)
+ pend->systm_tail->next = pend->after_head;
else
- systm = after;
- if (btail)
- btail->next = systm;
+ systm = pend->after_head;
+
+ if (brack)
+ pend->brack_tail->next = systm;
else
brack = systm;
- /* This is a bit tricky.
- First we drop dupes from the quote-include list.
- Then we drop dupes from the bracket-include list.
- Finally, if qtail and brack are the same directory,
- we cut out qtail.
+ /* This is a bit tricky. First we drop dupes from the quote-include
+ list. Then we drop dupes from the bracket-include list.
+ Finally, if qtail and brack are the same directory, we cut out
+ brack.
We can't just merge the lists and then uniquify them because
then we may lose directories from the <> search path that should
be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
- -Ibar -I- -Ifoo -Iquux.
-
- Note that this algorithm is quadratic in the number of -I switches,
- which is acceptable since there aren't usually that many of them. */
-
- for (cur = quote, prev = NULL; cur; cur = cur->next)
- {
- for (other = quote; other != cur; other = other->next)
- if (INO_T_EQ (cur->ino, other->ino)
- && cur->dev == other->dev)
- {
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
- cur->name);
-
- prev->next = cur->next;
- free (cur->name);
- free (cur);
- cur = prev;
- break;
- }
- prev = cur;
- }
- qtail = prev;
+ -Ibar -I- -Ifoo -Iquux. */
- for (cur = brack; cur; cur = cur->next)
- {
- for (other = brack; other != cur; other = other->next)
- if (INO_T_EQ (cur->ino, other->ino)
- && cur->dev == other->dev)
- {
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
- cur->name);
-
- prev->next = cur->next;
- free (cur->name);
- free (cur);
- cur = prev;
- break;
- }
- prev = cur;
- }
+ remove_dup_dirs (pfile, brack);
+ qtail = remove_dup_dirs (pfile, quote);
if (quote)
{
- if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
- {
- if (quote == qtail)
- {
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
- quote->name);
+ qtail->next = brack;
- free (quote->name);
- free (quote);
- quote = brack;
- }
- else
- {
- cur = quote;
- while (cur->next != qtail)
- cur = cur->next;
- cur->next = brack;
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
- qtail->name);
-
- free (qtail->name);
- free (qtail);
- }
- }
- else
- qtail->next = brack;
+ /* If brack == qtail, remove brack as it's simpler. */
+ if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
+ brack = remove_dup_dir (pfile, qtail);
}
else
quote = brack;
CPP_OPTION (pfile, bracket_include) = brack;
}
+/* cpp_init initializes library global state. It might not need to do
+ anything depending on the platform and compiler, so we have a static
+ flag to make sure it gets called before cpp_reader_init. */
-/* Write out a #define command for the special named MACRO_NAME
- to PFILE's token_buffer. */
+static int cpp_init_completed = 0;
-static void
-dump_special_to_buffer (pfile, macro_name)
- cpp_reader *pfile;
- const char *macro_name;
+void
+cpp_init ()
{
- static const char define_directive[] = "#define ";
- int macro_name_length = strlen (macro_name);
- CPP_RESERVE (pfile, sizeof(define_directive) + macro_name_length);
- CPP_PUTS_Q (pfile, define_directive, sizeof(define_directive)-1);
- CPP_PUTS_Q (pfile, macro_name, macro_name_length);
- CPP_PUTC_Q (pfile, ' ');
- _cpp_expand_to_buffer (pfile, macro_name, macro_name_length);
- CPP_PUTC (pfile, '\n');
+#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 and the IStable. These don't need to do
+ anything if we were compiled with a compiler that supports C99
+ designated initializers. */
+ init_trigraph_map ();
+ init_IStable ();
+
+ cpp_init_completed = 1;
}
/* Initialize a cpp_reader structure. */
{
memset ((char *) pfile, 0, sizeof (cpp_reader));
- pfile->token_buffer_size = 200;
- pfile->token_buffer = (U_CHAR *) xmalloc (pfile->token_buffer_size);
- CPP_SET_WRITTEN (pfile, 0);
-
CPP_OPTION (pfile, dollars_in_ident) = 1;
CPP_OPTION (pfile, cplusplus_comments) = 1;
CPP_OPTION (pfile, warn_import) = 1;
+ CPP_OPTION (pfile, warn_paste) = 1;
+ CPP_OPTION (pfile, digraphs) = 1;
CPP_OPTION (pfile, discard_comments) = 1;
CPP_OPTION (pfile, show_column) = 1;
+ CPP_OPTION (pfile, tabstop) = 8;
CPP_OPTION (pfile, pending) =
(struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
- _cpp_init_macro_hash (pfile);
- _cpp_init_include_hash (pfile);
+ /* If cpp_init hasn't been called, generate a fatal error (by hand)
+ and call it here. */
+ if (!cpp_init_completed)
+ {
+ fputs ("cpp_reader_init: internal error: cpp_init not called.\n", stderr);
+ pfile->errors = CPP_FATAL_LIMIT;
+ cpp_init ();
+ }
+
+ _cpp_init_macros (pfile);
+ _cpp_init_stacks (pfile);
+ _cpp_init_includes (pfile);
+ _cpp_init_internal_pragmas (pfile);
}
/* Initialize a cpp_printer structure. As a side effect, open the
cpp_cleanup (pfile)
cpp_reader *pfile;
{
+ struct file_name_list *dir, *next;
+
while (CPP_BUFFER (pfile) != NULL)
cpp_pop_buffer (pfile);
- if (pfile->token_buffer)
- {
- free (pfile->token_buffer);
- pfile->token_buffer = NULL;
- }
-
- if (pfile->input_buffer)
- {
- free (pfile->input_buffer);
- pfile->input_buffer = NULL;
- pfile->input_buffer_len = 0;
- }
-
if (pfile->deps)
deps_free (pfile->deps);
- htab_delete (pfile->hashtab);
- htab_delete (pfile->all_include_files);
+ if (pfile->spec_nodes)
+ free (pfile->spec_nodes);
+
+ _cpp_free_temp_tokens (pfile);
+ _cpp_cleanup_includes (pfile);
+ _cpp_cleanup_stacks (pfile);
+ _cpp_cleanup_macros (pfile);
+
+ for (dir = CPP_OPTION (pfile, quote_include); dir; dir = next)
+ {
+ next = dir->next;
+ free (dir->name);
+ free (dir);
+ }
}
/* This structure defines one built-in macro. A node of type TYPE will
be entered in the macro hash table under the name NAME, with value
- VALUE (if any). FLAGS tweaks the behavior a little:
- DUMP write debug info for this macro
+ VALUE (if any). If TYPE is T_OPERATOR, the CODE field is used instead.
+
+ Two values are not compile time constants, so we tag
+ them in the FLAGS field instead:
VERS value is the global version_string, quoted
ULP value is the global user_label_prefix
+
+ Also, macros with CPLUS set in the flags field are entered only for C++.
*/
struct builtin
{
- const char *name;
+ const U_CHAR *name;
const char *value;
- unsigned short type;
+ unsigned char code;
+ unsigned char type;
unsigned short flags;
+ unsigned int len;
};
-#define DUMP 0x01
-#define VERS 0x02
-#define ULP 0x04
-
+#define VERS 0x01
+#define ULP 0x02
+#define CPLUS 0x04
+
+#define B(n, t) { U n, 0, 0, t, 0, sizeof n - 1 }
+#define C(n, v) { U n, v, 0, T_MACRO, 0, sizeof n - 1 }
+#define X(n, f) { U n, 0, 0, T_MACRO, f, sizeof n - 1 }
+#define O(n, c, f) { U n, 0, c, T_OPERATOR, f, sizeof n - 1 }
static const struct builtin builtin_array[] =
{
- { "__TIME__", 0, T_TIME, 0 },
- { "__DATE__", 0, T_DATE, 0 },
- { "__FILE__", 0, T_FILE, 0 },
- { "__BASE_FILE__", 0, T_BASE_FILE, 0 },
- { "__LINE__", 0, T_SPECLINE, 0 },
- { "__INCLUDE_LEVEL__", 0, T_INCLUDE_LEVEL, 0 },
-
- { "__VERSION__", 0, T_XCONST, DUMP|VERS },
- { "__USER_LABEL_PREFIX__", 0, T_CONST, DUMP|ULP },
- { "__STDC__", "1", T_STDC, DUMP },
- { "__REGISTER_PREFIX__", REGISTER_PREFIX, T_CONST, DUMP },
- { "__HAVE_BUILTIN_SETJMP__", "1", T_CONST, DUMP },
+ B("__TIME__", T_TIME),
+ B("__DATE__", T_DATE),
+ B("__FILE__", T_FILE),
+ B("__BASE_FILE__", T_BASE_FILE),
+ B("__LINE__", T_SPECLINE),
+ B("__INCLUDE_LEVEL__", T_INCLUDE_LEVEL),
+ B("__STDC__", T_STDC),
+
+ X("__VERSION__", VERS),
+ X("__USER_LABEL_PREFIX__", ULP),
+ C("__REGISTER_PREFIX__", REGISTER_PREFIX),
+ C("__HAVE_BUILTIN_SETJMP__", "1"),
#ifndef NO_BUILTIN_SIZE_TYPE
- { "__SIZE_TYPE__", SIZE_TYPE, T_CONST, DUMP },
+ C("__SIZE_TYPE__", SIZE_TYPE),
#endif
#ifndef NO_BUILTIN_PTRDIFF_TYPE
- { "__PTRDIFF_TYPE__", PTRDIFF_TYPE, T_CONST, DUMP },
+ C("__PTRDIFF_TYPE__", PTRDIFF_TYPE),
#endif
#ifndef NO_BUILTIN_WCHAR_TYPE
- { "__WCHAR_TYPE__", WCHAR_TYPE, T_CONST, DUMP },
+ C("__WCHAR_TYPE__", WCHAR_TYPE),
+#endif
+#ifndef NO_BUILTIN_WINT_TYPE
+ C("__WINT_TYPE__", WINT_TYPE),
#endif
+
+ /* Named operators known to the preprocessor. These cannot be #defined
+ and always have their stated meaning. They are treated like normal
+ string tokens except for the type code and the meaning. Most of them
+ are only for C++ (but see iso646.h). */
+ O("defined", CPP_DEFINED, 0),
+ O("and", CPP_AND_AND, CPLUS),
+ O("and_eq", CPP_AND_EQ, CPLUS),
+ O("bitand", CPP_AND, CPLUS),
+ O("bitor", CPP_OR, CPLUS),
+ O("compl", CPP_COMPL, CPLUS),
+ O("not", CPP_NOT, CPLUS),
+ O("not_eq", CPP_NOT_EQ, CPLUS),
+ O("or", CPP_OR_OR, CPLUS),
+ O("or_eq", CPP_OR_EQ, CPLUS),
+ O("xor", CPP_XOR, CPLUS),
+ O("xor_eq", CPP_XOR_EQ, CPLUS),
};
+#undef B
+#undef C
+#undef X
#define builtin_array_end \
builtin_array + sizeof(builtin_array)/sizeof(struct builtin)
initialize_builtins (pfile)
cpp_reader *pfile;
{
- int len;
const struct builtin *b;
- const char *val;
- HASHNODE *hp;
+
for(b = builtin_array; b < builtin_array_end; b++)
{
- if (b->type == T_STDC && CPP_TRADITIONAL (pfile))
+ if (b->flags & CPLUS && ! CPP_OPTION (pfile, cplusplus))
continue;
- if (b->flags & ULP)
- val = user_label_prefix;
- else if (b->flags & VERS)
+ if (b->type == T_MACRO)
{
- val = xmalloc (strlen (version_string) + 3);
- sprintf ((char *)val, "\"%s\"", version_string);
- }
- else
- val = b->value;
+ const char *val;
+ char *str;
- len = strlen (b->name);
- hp = _cpp_make_hashnode (b->name, len, b->type,
- _cpp_calc_hash (b->name, len));
- hp->value.cpval = val;
- *(htab_find_slot (pfile->hashtab, (void *) hp, INSERT)) = hp;
+ 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);
+ }
- if ((b->flags & DUMP) && CPP_OPTION (pfile, debug_output))
- dump_special_to_buffer (pfile, b->name);
+ _cpp_define_builtin (pfile, str);
+ }
+ else
+ {
+ cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
+ hp->type = b->type;
+ if (b->type == T_OPERATOR)
+ hp->value.code = b->code;
+ }
}
}
-#undef DUMP
-#undef STDC
#undef VERS
#undef ULP
+#undef builtin_array_end
/* Another subroutine of cpp_start_read. This one sets up to do
dependency-file output. */
GET_ENV_PATH_LIST (path, "CPATH");
if (path != 0 && *path != 0)
- path_include (pfile, CPP_OPTION (pfile, pending), path, BRACKET);
+ path_include (pfile, path, BRACKET);
switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus))
{
break;
}
if (path != 0 && *path != 0)
- path_include (pfile, CPP_OPTION (pfile, pending), path, SYSTEM);
+ path_include (pfile, path, SYSTEM);
/* Search "translated" versions of GNU directories.
These have /usr/local/lib/gcc... replaced by specd_prefix. */
- if (specd_prefix != 0)
+ if (specd_prefix != 0 && cpp_GCC_INCLUDE_DIR_len)
{
- char *default_prefix = (char *) alloca (sizeof GCC_INCLUDE_DIR - 7);
/* Remove the `include' from /usr/local/lib/gcc.../include.
GCC_INCLUDE_DIR will always end in /include. */
- int default_len = sizeof GCC_INCLUDE_DIR - 8;
+ 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, GCC_INCLUDE_DIR, default_len);
+ memcpy (default_prefix, cpp_GCC_INCLUDE_DIR, default_len);
default_prefix[default_len] = '\0';
- for (p = include_defaults_array; p->fname; p++)
+ for (p = cpp_include_defaults; p->fname; p++)
{
/* Some standard dirs are only for C++. */
if (!p->cplusplus
&& !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
{
/* Does this dir start with the prefix? */
- if (!strncmp (p->fname, default_prefix, default_len))
+ if (!memcmp (p->fname, default_prefix, default_len))
{
/* Yes; change prefix and add to search list. */
int flen = strlen (p->fname);
p->fname + default_len,
flen - default_len + 1);
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- str, SYSTEM, p->cxx_aware);
+ append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
}
}
}
}
/* Search ordinary names for GNU include directories. */
- for (p = include_defaults_array; p->fname; p++)
+ for (p = cpp_include_defaults; p->fname; p++)
{
/* Some standard dirs are only for C++. */
if (!p->cplusplus
{
/* XXX Potential memory leak! */
char *str = xstrdup (update_path (p->fname, p->component));
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- str, SYSTEM, p->cxx_aware);
+ append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
}
}
}
return 0;
}
- /* Chill should not be used with -trigraphs. */
- if (CPP_OPTION (pfile, chill) && CPP_OPTION (pfile, trigraphs))
- {
- cpp_warning (pfile, "-lang-chill and -trigraphs are mutually exclusive");
- CPP_OPTION (pfile, trigraphs) = 0;
- }
-
/* -Wtraditional is not useful in C++ mode. */
if (CPP_OPTION (pfile, cplusplus))
CPP_OPTION (pfile, warn_traditional) = 0;
- /* Set this if it hasn't been set already. */
- if (user_label_prefix == NULL)
- user_label_prefix = USER_LABEL_PREFIX;
-
- /* Don't bother trying to do macro expansion if we've already done
- preprocessing. */
- if (CPP_OPTION (pfile, preprocessed))
- pfile->no_macro_expand++;
+ /* Do not warn about invalid token pasting if -lang-asm. */
+ if (CPP_OPTION (pfile, lang_asm))
+ CPP_OPTION (pfile, warn_paste) = 0;
- /* Set up the IStable. This doesn't do anything if we were compiled
- with a compiler that supports C99 designated initializers. */
- init_IStable ();
+ /* 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;
+
+ /* Figure out if we need to save function macro parameter spellings.
+ We don't use CPP_PEDANTIC() here because that depends on whether
+ or not the current file is a system header, and there is no
+ current file yet. */
+ pfile->save_parameter_spellings =
+ CPP_OPTION (pfile, pedantic)
+ || CPP_OPTION (pfile, debug_output)
+ || CPP_OPTION (pfile, dump_macros) == dump_definitions
+ || CPP_OPTION (pfile, dump_macros) == dump_only;
/* Set up the tables used by read_and_prescan. */
_cpp_init_input_buffer (pfile);
initialize_dependency_output (pfile);
- /* -D and friends may produce output, which should be identified
- as line 0. */
-
- CPP_BUFFER (pfile)->lineno = 0;
-
- if (print)
- {
- print->lineno = 0;
- print->last_fname = CPP_BUFFER (pfile)->nominal_fname;
- print->last_bsd = pfile->buffer_stack_depth;
- print->written = CPP_WRITTEN (pfile);
- }
-
/* Install __LINE__, etc. */
initialize_builtins (pfile);
p = q;
}
pfile->done_initializing = 1;
- pfile->only_seen_white = 2;
- CPP_BUFFER (pfile)->lineno = 1;
- if (print && ! CPP_OPTION (pfile, no_output))
- cpp_output_tokens (pfile, print);
+
+ /* We start at line 1 of the main input file. */
+ if (print)
+ {
+ print->last_fname = CPP_BUFFER (pfile)->nominal_fname;
+ print->lineno = 1;
+ }
/* The -imacros files can be scanned now, but the -include files
have to be pushed onto the include stack and processed later,
p = CPP_OPTION (pfile, pending)->include_head;
while (p)
{
- if (cpp_read_file (pfile, p->arg)
- && print && ! CPP_OPTION (pfile, no_output))
- cpp_output_tokens (pfile, print);
+ cpp_read_file (pfile, p->arg);
q = p->next;
free (p);
p = q;
}
}
- if (CPP_OPTION (pfile, dump_macros) == dump_only)
- _cpp_dump_macro_hash (pfile);
-
/* Flush any pending output. */
if (print)
{
- cpp_output_tokens (pfile, print);
+ if (pfile->need_newline)
+ putc ('\n', print->outf);
if (ferror (print->outf) || fclose (print->outf))
cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
}
+
+ /* Report on headers that could use multiple include guards. */
+ if (CPP_OPTION (pfile, print_include_names))
+ _cpp_report_missing_guards (pfile);
}
static void
#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")
/* This is the list of all command line options, with the leading
"-" removed. It must be sorted in ASCII collating order. */
DEF_OPT("fno-show-column", 0, OPT_fno_show_column) \
DEF_OPT("fpreprocessed", 0, OPT_fpreprocessed) \
DEF_OPT("fshow-column", 0, OPT_fshow_column) \
+ DEF_OPT("ftabstop=", no_num, OPT_ftabstop) \
DEF_OPT("g", no_arg, OPT_g) /* arg optional */ \
DEF_OPT("h", 0, OPT_h) \
DEF_OPT("idirafter", no_dir, OPT_idirafter) \
DEF_OPT("lang-c", 0, OPT_lang_c) \
DEF_OPT("lang-c++", 0, OPT_lang_cplusplus) \
DEF_OPT("lang-c89", 0, OPT_lang_c89) \
- DEF_OPT("lang-chill", 0, OPT_lang_chill) \
- DEF_OPT("lang-fortran", 0, OPT_lang_fortran) \
DEF_OPT("lang-objc", 0, OPT_lang_objc) \
DEF_OPT("lang-objc++", 0, OPT_lang_objcplusplus) \
DEF_OPT("nostdinc", 0, OPT_nostdinc) \
DEF_OPT("std=iso9899:199409", 0, OPT_std_iso9899_199409) \
DEF_OPT("std=iso9899:1999", 0, OPT_std_iso9899_1999) \
DEF_OPT("std=iso9899:199x", 0, OPT_std_iso9899_199x) \
- DEF_OPT("traditional", 0, OPT_traditional) \
DEF_OPT("trigraphs", 0, OPT_trigraphs) \
DEF_OPT("v", 0, OPT_v) \
DEF_OPT("w", 0, OPT_w)
md = (mn + mx) / 2;
opt_len = cl_options[md].opt_len;
- comp = strncmp (input, cl_options[md].opt_text, opt_len);
+ comp = memcmp (input, cl_options[md].opt_text, opt_len);
if (comp > 0)
mn = md + 1;
for (; mn < N_OPTS; mn++)
{
opt_len = cl_options[mn].opt_len;
- if (strncmp (input, cl_options[mn].opt_text, opt_len))
+ if (memcmp (input, cl_options[mn].opt_text, opt_len))
break;
if (input[opt_len] == '\0')
return mn;
Can be called multiple times, to handle multiple sets of options.
Returns number of strings consumed. */
-static int
-handle_option (pfile, argc, argv)
+int
+cpp_handle_option (pfile, argc, argv)
cpp_reader *pfile;
int argc;
char **argv;
{
int i = 0;
+ struct cpp_pending *pend = CPP_OPTION (pfile, pending);
if (argv[i][0] != '-')
{
case N_OPTS: /* shut GCC up */
break;
case OPT_fleading_underscore:
- user_label_prefix = "_";
+ CPP_OPTION (pfile, user_label_prefix) = "_";
break;
case OPT_fno_leading_underscore:
- user_label_prefix = "";
+ CPP_OPTION (pfile, user_label_prefix) = "";
break;
case OPT_fpreprocessed:
CPP_OPTION (pfile, preprocessed) = 1;
case OPT_fno_show_column:
CPP_OPTION (pfile, show_column) = 0;
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;
CPP_OPTION (pfile, print_include_names) = 1;
break;
case OPT_D:
- new_pending_directive (CPP_OPTION (pfile, pending), arg, cpp_define);
+ new_pending_directive (pend, arg, cpp_define);
break;
case OPT_pedantic_errors:
CPP_OPTION (pfile, pedantic_errors) = 1;
case OPT_pedantic:
CPP_OPTION (pfile, pedantic) = 1;
break;
- case OPT_traditional:
- CPP_OPTION (pfile, traditional) = 1;
- CPP_OPTION (pfile, cplusplus_comments) = 0;
- CPP_OPTION (pfile, trigraphs) = 0;
- CPP_OPTION (pfile, warn_trigraphs) = 0;
- break;
case OPT_trigraphs:
CPP_OPTION (pfile, trigraphs) = 1;
break;
CPP_OPTION (pfile, cplusplus_comments) = 1;
CPP_OPTION (pfile, c89) = 0;
CPP_OPTION (pfile, c99) = 1;
+ CPP_OPTION (pfile, digraphs) = 1;
CPP_OPTION (pfile, objc) = 0;
break;
- case OPT_lang_c89:
- CPP_OPTION (pfile, cplusplus) = 0;
- CPP_OPTION (pfile, cplusplus_comments) = 0;
- CPP_OPTION (pfile, c89) = 1;
- CPP_OPTION (pfile, c99) = 0;
- CPP_OPTION (pfile, objc) = 0;
- CPP_OPTION (pfile, trigraphs) = 1;
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STRICT_ANSI__", cpp_define);
- break;
case OPT_lang_cplusplus:
CPP_OPTION (pfile, cplusplus) = 1;
CPP_OPTION (pfile, cplusplus_comments) = 1;
CPP_OPTION (pfile, c89) = 0;
CPP_OPTION (pfile, c99) = 0;
CPP_OPTION (pfile, objc) = 0;
+ CPP_OPTION (pfile, digraphs) = 1;
+ new_pending_directive (pend, "__cplusplus", cpp_define);
break;
- case OPT_lang_objc:
case OPT_lang_objcplusplus:
- CPP_OPTION (pfile, cplusplus) = opt_code == OPT_lang_objcplusplus;
+ CPP_OPTION (pfile, cplusplus) = 1;
+ new_pending_directive (pend, "__cplusplus", cpp_define);
+ /* fall through */
+ case OPT_lang_objc:
CPP_OPTION (pfile, cplusplus_comments) = 1;
CPP_OPTION (pfile, c89) = 0;
CPP_OPTION (pfile, c99) = 0;
CPP_OPTION (pfile, objc) = 1;
+ new_pending_directive (pend, "__OBJC__", cpp_define);
break;
case OPT_lang_asm:
CPP_OPTION (pfile, lang_asm) = 1;
- break;
- case OPT_lang_fortran:
- CPP_OPTION (pfile, lang_fortran) = 1;
- CPP_OPTION (pfile, cplusplus_comments) = 0;
- break;
- case OPT_lang_chill:
- CPP_OPTION (pfile, objc) = 0;
- CPP_OPTION (pfile, cplusplus) = 0;
- CPP_OPTION (pfile, chill) = 1;
- CPP_OPTION (pfile, traditional) = 1;
+ CPP_OPTION (pfile, dollars_in_ident) = 0;
+ new_pending_directive (pend, "__ASSEMBLER__", cpp_define);
break;
case OPT_nostdinc:
/* -nostdinc causes no default include directories.
CPP_OPTION (pfile, c89) = 1;
CPP_OPTION (pfile, c99) = 0;
CPP_OPTION (pfile, objc) = 0;
+ CPP_OPTION (pfile, digraphs) = 1;
break;
case OPT_std_gnu9x:
case OPT_std_gnu99:
CPP_OPTION (pfile, cplusplus_comments) = 1;
CPP_OPTION (pfile, c89) = 0;
CPP_OPTION (pfile, c99) = 1;
+ CPP_OPTION (pfile, digraphs) = 1;
CPP_OPTION (pfile, objc) = 0;
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STDC_VERSION__=199901L", cpp_define);
+ new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
break;
case OPT_std_iso9899_199409:
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STDC_VERSION__=199409L", cpp_define);
+ new_pending_directive (pend, "__STDC_VERSION__=199409L", cpp_define);
/* Fall through */
case OPT_std_iso9899_1990:
case OPT_std_c89:
+ case OPT_lang_c89:
CPP_OPTION (pfile, cplusplus) = 0;
CPP_OPTION (pfile, cplusplus_comments) = 0;
CPP_OPTION (pfile, c89) = 1;
CPP_OPTION (pfile, c99) = 0;
CPP_OPTION (pfile, objc) = 0;
+ CPP_OPTION (pfile, digraphs) = opt_code == OPT_std_iso9899_199409;
CPP_OPTION (pfile, trigraphs) = 1;
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STRICT_ANSI__", cpp_define);
+ new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
break;
case OPT_std_iso9899_199x:
case OPT_std_iso9899_1999:
CPP_OPTION (pfile, c89) = 0;
CPP_OPTION (pfile, c99) = 1;
CPP_OPTION (pfile, objc) = 0;
+ CPP_OPTION (pfile, digraphs) = 1;
CPP_OPTION (pfile, trigraphs) = 1;
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STRICT_ANSI__", cpp_define);
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STDC_VERSION__=199901L", cpp_define);
+ new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
+ new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
break;
case OPT_o:
if (CPP_OPTION (pfile, out_fname) != NULL)
{
struct pending_option *o1, *o2;
- o1 = CPP_OPTION (pfile, pending)->directive_head;
+ o1 = pend->directive_head;
while (o1)
{
o2 = o1->next;
free (o1);
o1 = o2;
}
- CPP_OPTION (pfile, pending)->directive_head = NULL;
- CPP_OPTION (pfile, pending)->directive_tail = NULL;
+ pend->directive_head = NULL;
+ pend->directive_tail = NULL;
}
else
- new_pending_directive (CPP_OPTION (pfile, pending),
- arg + 1, cpp_unassert);
+ new_pending_directive (pend, arg + 1, cpp_unassert);
}
else
- new_pending_directive (CPP_OPTION (pfile, pending),
- arg, cpp_assert);
+ new_pending_directive (pend, arg, cpp_assert);
break;
case OPT_U:
- new_pending_directive (CPP_OPTION (pfile, pending), arg, cpp_undef);
+ new_pending_directive (pend, arg, cpp_undef);
break;
case OPT_I: /* Add directory to path for includes. */
if (!strcmp (arg, "-"))
the default setup; -I. uses the compiler's working dir.) */
if (! CPP_OPTION (pfile, ignore_srcdir))
{
- struct cpp_pending *pend = CPP_OPTION (pfile, pending);
pend->quote_head = pend->brack_head;
pend->quote_tail = pend->brack_tail;
pend->brack_head = 0;
}
}
else
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- xstrdup (arg), BRACKET, 0);
+ append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
break;
case OPT_isystem:
/* Add directory to beginning of system include path, as a system
include directory. */
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- xstrdup (arg), SYSTEM, 0);
+ append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
break;
case OPT_include:
{
/* This list has to be built in reverse order so that
when cpp_start_read pushes all the -include files onto
the buffer stack, they will be scanned in forward order. */
- o->next = CPP_OPTION (pfile, pending)->include_head;
- CPP_OPTION (pfile, pending)->include_head = o;
+ o->next = pend->include_head;
+ pend->include_head = o;
}
break;
case OPT_imacros:
o->arg = arg;
o->next = NULL;
- APPEND (CPP_OPTION (pfile, pending), imacros, o);
+ APPEND (pend, imacros, o);
}
break;
case OPT_iwithprefix:
memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
memcpy (fname + ipl, arg, len + 1);
}
- else
+ else if (cpp_GCC_INCLUDE_DIR_len)
{
- fname = xmalloc (sizeof GCC_INCLUDE_DIR - 8 + len);
- memcpy (fname, GCC_INCLUDE_DIR, sizeof GCC_INCLUDE_DIR - 9);
- memcpy (fname + sizeof GCC_INCLUDE_DIR - 9, arg, len + 1);
+ 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, CPP_OPTION (pfile, pending), fname,
+ append_include_chain (pfile, fname,
opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
}
break;
case OPT_idirafter:
/* Add directory to end of path for includes. */
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- xstrdup (arg), AFTER, 0);
+ append_include_chain (pfile, xstrdup (arg), AFTER, 0);
break;
case OPT_W:
/* Silently ignore unrecognised options */
CPP_OPTION (pfile, warn_undef) = 1;
else if (!strcmp (argv[i], "-Wimport"))
CPP_OPTION (pfile, warn_import) = 1;
+ else if (!strcmp (argv[i], "-Wpaste"))
+ CPP_OPTION (pfile, warn_paste) = 1;
else if (!strcmp (argv[i], "-Werror"))
CPP_OPTION (pfile, warnings_are_errors) = 1;
else if (!strcmp (argv[i], "-Wno-traditional"))
CPP_OPTION (pfile, warn_undef) = 0;
else if (!strcmp (argv[i], "-Wno-import"))
CPP_OPTION (pfile, warn_import) = 0;
+ else if (!strcmp (argv[i], "-Wno-paste"))
+ CPP_OPTION (pfile, warn_paste) = 0;
else if (!strcmp (argv[i], "-Wno-error"))
CPP_OPTION (pfile, warnings_are_errors) = 0;
break;
int i;
int strings_processed;
-#ifdef HOST_EBCDIC
- static int opts_sorted = 0;
-
- if (!opts_sorted)
- {
- opts_sorted = 1;
- /* For non-ASCII hosts, the array needs to be sorted at runtime */
- qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
- }
-#endif
-
for (i = 0; i < argc; i += strings_processed)
{
- strings_processed = handle_option (pfile, argc - i, argv + i);
+ strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
if (strings_processed == 0)
break;
}
print_help ()
{
fprintf (stderr, _("Usage: %s [switches] input output\n"), progname);
+ /* To keep the lines from getting too long for some compilers, limit
+ to about 500 characters (6 lines) per chunk. */
fputs (_("\
Switches:\n\
-include <file> Include the contents of <file> before other files\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\
(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\
- -pedantic Issue all warnings demanded by strict ANSI C\n\
+"), stdout);
+ fputs (_("\
+ -pedantic Issue all warnings demanded by strict ISO C\n\
-pedantic-errors Issue -pedantic warnings as errors instead\n\
- -traditional Follow K&R pre-processor behaviour\n\
- -trigraphs Support ANSI C trigraphs\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\
- -lang-fortran Assume that the input sources are in Fortran\n\
- -lang-chill Assume that the input sources are in Chill\n\
+"), stdout);
+ fputs (_("\
-std=<std name> Specify the conformance standard; one of:\n\
gnu89, gnu99, c89, c99, iso9899:1990,\n\
iso9899:199409, iso9899:1999\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 if a macro argument is/would be turned into\n\
- a string if -traditional is specified\n\
- -Wno-traditional Do not warn about stringification\n\
+ -Wtraditional Warn about features not present in traditional C\n\
+ -Wno-traditional Do not warn about traditional C\n\
-Wundef Warn if an undefined macro is used by #if\n\
-Wno-undef Do not warn about testing undefined macros\n\
-Wimport Warn about the use of the #import directive\n\
+"), 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\
-Wall Enable all preprocessor warnings\n\
-M Generate make dependencies\n\
-MM As -M, but ignore system header files\n\
+"), stdout);
+ fputs (_("\
-MD As -M, but put output in a .d file\n\
-MMD As -MD, but ignore system header files\n\
-MG Treat missing header file as generated files\n\
-g3 Include #define and #undef directives in the output\n\
-D<macro> Define a <macro> with string '1' as its value\n\
-D<macro>=<val> Define a <macro> with <val> as its value\n\
+"), stdout);
+ fputs (_("\
-A<question> (<answer>) Assert the <answer> to <question>\n\
-A-<question> (<answer>) Disable the <answer> to <question>\n\
-U<macro> Undefine <macro> \n\
-v Display the version number\n\
-H Print the name of header files as they are used\n\
-C Do not discard comments\n\
+"), stdout);
+ fputs (_("\
-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\
+ -ftabstop=<number> Distance between tab stops for column reporting\n\
-P Do not generate #line directives\n\
-$ Do not allow '$' in identifiers\n\
+"), stdout);
+ fputs (_("\
-remap Remap file names when including files.\n\
--version Display version information\n\
-h or --help Display this information\n\
OSDN Git Service
