X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fcppinit.c;h=c3347c94d718cc37ab907c5ef7e1a3cf03039fb8;hb=786c6b83c3028ecb4637cb1c7f9687491958e28f;hp=c66f0456bbf8f879ea7947ee58935757d3a52c49;hpb=1e8b9746d3bbc54b8ba4a0d02f049d169163a851;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/cppinit.c b/gcc/cppinit.c index c66f0456bbf..c3347c94d71 100644 --- a/gcc/cppinit.c +++ b/gcc/cppinit.c @@ -1,6 +1,6 @@ /* CPP Library. Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000 Free Software Foundation, Inc. + 1999, 2000, 2001 Free Software Foundation, Inc. Contributed by Per Bothner, 1994-95. Based on CCCP program by Paul Rubin, June 1986 Adapted to ANSI C, Richard Stallman, Jan 1987 @@ -21,7 +21,6 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "config.h" #include "system.h" - #include "cpplib.h" #include "cpphash.h" #include "output.h" @@ -29,8 +28,9 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "intl.h" #include "version.h" #include "mkdeps.h" +#include "cppdefault.h" -/* Predefined symbols, built-in macros, and the default include path. */ +/* Predefined symbols, built-in macros, and the default include path. */ #ifndef GET_ENV_PATH_LIST #define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0) @@ -47,138 +47,26 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #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 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. */ -/* Internal structures and prototypes. */ +/* A `struct pending_option' remembers one -D, -A, -U, -include, or + -imacros switch. */ -/* A `struct pending_option' remembers one -D, -A, -U, -include, or -imacros - switch. There are four lists: one for -D and -U, one for -A, one - for -include, one for -imacros. `undef' is set for -U, clear for - -D, ignored for the others. - (Future: add an equivalent of -U for -A) */ +typedef void (* cl_directive_handler) PARAMS ((cpp_reader *, const char *)); struct pending_option { struct pending_option *next; - char *arg; - int undef; + const char *arg; + cl_directive_handler handler; }; /* The `pending' structure accumulates all the options that are not actually processed until we hit cpp_start_read. It consists of several lists, one for each type of option. We keep both head and - tail pointers for quick insertion. */ + tail pointers for quick insertion. */ struct cpp_pending { - struct pending_option *define_head, *define_tail; - struct pending_option *assert_head, *assert_tail; + struct pending_option *directive_head, *directive_tail; struct file_name_list *quote_head, *quote_tail; struct file_name_list *brack_head, *brack_tail; @@ -205,83 +93,70 @@ struct cpp_pending static void print_help PARAMS ((void)); static void path_include PARAMS ((cpp_reader *, - struct cpp_pending *, char *, int)); -static void initialize_builtins PARAMS ((cpp_reader *)); +static void init_library PARAMS ((void)); +static void init_builtins PARAMS ((cpp_reader *)); static void append_include_chain PARAMS ((cpp_reader *, - struct cpp_pending *, char *, int, int)); -static void merge_include_chains PARAMS ((struct cpp_options *)); - -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_define PARAMS ((struct cpp_options *, - const char *)); -#ifdef HOST_EBCDIC -static int opt_comp PARAMS ((const void *, const void *)); -#endif +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 do_includes PARAMS ((cpp_reader *, + struct pending_option *, + int)); +static void set_lang PARAMS ((cpp_reader *, enum c_lang)); +static void init_dependency_output PARAMS ((cpp_reader *)); +static void init_standard_includes PARAMS ((cpp_reader *)); +static void new_pending_directive PARAMS ((struct cpp_pending *, + const char *, + cl_directive_handler)); +static void output_deps PARAMS ((cpp_reader *)); static int parse_option PARAMS ((const char *)); -static int handle_option PARAMS ((cpp_reader *, int, char **)); -/* Fourth argument to append_include_chain: chain to use */ +/* Fourth argument to append_include_chain: chain to use. */ enum { QUOTE = 0, BRACKET, SYSTEM, AFTER }; -/* If we have designated initializers (GCC >2.7, 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 + +#define init_trigraph_map() /* Nothing. */ +#define TRIGRAPH_MAP \ +__extension__ const U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = { -#if (GCC_VERSION >= 2007) || (__STDC_VERSION__ >= 199901L) -#define init_IStable() /* nothing */ -#define ISTABLE const unsigned char _cpp_IStable[256] = { #define END }; #define s(p, v) [p] = v, -#else -#define ISTABLE unsigned char _cpp_IStable[256] = { 0 }; \ - static void init_IStable PARAMS ((void)) { \ - unsigned char *x = _cpp_IStable; -#define END } -#define s(p, v) x[p] = v; -#endif - -#define A(x) s(x, ISidnum|ISidstart) -#define N(x) s(x, ISidnum|ISnumstart) -#define H(x) s(x, IShspace|ISspace) -#define S(x) s(x, ISspace) -ISTABLE - A('_') - - A('a') A('b') A('c') A('d') A('e') A('f') A('g') A('h') A('i') - A('j') A('k') A('l') A('m') A('n') A('o') A('p') A('q') A('r') - A('s') A('t') A('u') A('v') A('w') A('x') A('y') A('z') +#else - A('A') A('B') A('C') A('D') A('E') A('F') A('G') A('H') A('I') - A('J') A('K') A('L') A('M') A('N') A('O') A('P') A('Q') A('R') - A('S') A('T') A('U') A('V') A('W') A('X') A('Y') A('Z') +#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; - N('1') N('2') N('3') N('4') N('5') N('6') N('7') N('8') N('9') N('0') +#define END } +#define s(p, v) x[p] = v; - H(' ') H('\t') H('\v') H('\f') +#endif - S('\n') +TRIGRAPH_MAP + s('=', '#') s(')', ']') s('!', '|') + s('(', '[') s('\'', '^') s('>', '}') + s('/', '\\') s('<', '{') s('-', '~') END -#undef A -#undef N -#undef H -#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; { @@ -309,7 +184,7 @@ path_include (pfile, pend, list, 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) @@ -322,13 +197,13 @@ path_include (pfile, pend, list, path) /* 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; @@ -339,8 +214,8 @@ append_include_chain (pfile, pend, dir, path, cxx_aware) /* Dirs that don't exist are silently ignored. */ if (errno != ENOENT) cpp_notice_from_errno (pfile, dir); - else if (CPP_OPTIONS (pfile)->verbose) - fprintf (stderr, _("ignoring nonexistent directory `%s'\n"), dir); + else if (CPP_OPTION (pfile, verbose)) + fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"), dir); return; } @@ -353,8 +228,8 @@ append_include_chain (pfile, pend, dir, path, cxx_aware) len = strlen (dir); if (len > pfile->max_include_len) pfile->max_include_len = len; - - new = (struct file_name_list *)xmalloc (sizeof (struct file_name_list)); + + new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list)); new->name = dir; new->nlen = len; new->ino = st.st_ino; @@ -376,6 +251,51 @@ append_include_chain (pfile, pend, dir, path, cxx_aware) } } +/* 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 @@ -383,176 +303,258 @@ append_include_chain (pfile, pend, dir, path, cxx_aware) bracket_include path. For the future: Check if the directory is empty (but - how?) and possibly preload the include hash. */ + how?) and possibly preload the include hash. */ static void -merge_include_chains (opts) - struct cpp_options *opts; +merge_include_chains (pfile) + cpp_reader *pfile; { - struct file_name_list *prev, *cur, *other; - struct file_name_list *quote, *brack, *systm, *after; - struct file_name_list *qtail, *btail, *stail, *atail; - - qtail = opts->pending->quote_tail; - btail = opts->pending->brack_tail; - stail = opts->pending->systm_tail; - atail = opts->pending->after_tail; - - quote = opts->pending->quote_head; - brack = opts->pending->brack_head; - systm = opts->pending->systm_head; - after = opts->pending->after_head; - - /* Paste together bracket, system, and after include chains. */ - if (stail) - stail->next = after; + struct file_name_list *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 = 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 (opts->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 (opts->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 (opts->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 (opts->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; - opts->quote_include = quote; - opts->bracket_include = brack; + CPP_OPTION (pfile, quote_include) = quote; + CPP_OPTION (pfile, bracket_include) = brack; } - -/* Write out a #define command for the special named MACRO_NAME - to PFILE's token_buffer. */ - +/* Sets internal flags correctly for a given language, and defines + macros if necessary. */ static void -dump_special_to_buffer (pfile, macro_name) +set_lang (pfile, lang) cpp_reader *pfile; - const char *macro_name; + enum c_lang lang; { - static const char define_directive[] = "#define "; - int macro_name_length = strlen (macro_name); - output_line_command (pfile, same_file); - CPP_RESERVE (pfile, sizeof(define_directive) + macro_name_length); - CPP_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'); + struct cpp_pending *pend = CPP_OPTION (pfile, pending); + + /* Defaults. */ + CPP_OPTION (pfile, lang) = lang; + CPP_OPTION (pfile, objc) = 0; + CPP_OPTION (pfile, cplusplus) = 0; + CPP_OPTION (pfile, extended_numbers) = 1; /* Allowed in GNU C and C99. */ + + switch (lang) + { + /* GNU C. */ + case CLK_GNUC99: + CPP_OPTION (pfile, trigraphs) = 0; + CPP_OPTION (pfile, dollars_in_ident) = 1; + CPP_OPTION (pfile, cplusplus_comments) = 1; + CPP_OPTION (pfile, digraphs) = 1; + CPP_OPTION (pfile, c99) = 1; + new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define); + break; + case CLK_GNUC89: + CPP_OPTION (pfile, trigraphs) = 0; + CPP_OPTION (pfile, dollars_in_ident) = 1; + CPP_OPTION (pfile, cplusplus_comments) = 1; + CPP_OPTION (pfile, digraphs) = 1; + CPP_OPTION (pfile, c99) = 0; + break; + + /* ISO C. */ + case CLK_STDC94: + new_pending_directive (pend, "__STDC_VERSION__=199409L", cpp_define); + case CLK_STDC89: + CPP_OPTION (pfile, trigraphs) = 1; + CPP_OPTION (pfile, dollars_in_ident) = 0; + CPP_OPTION (pfile, cplusplus_comments) = 0; + CPP_OPTION (pfile, digraphs) = lang == CLK_STDC94; + CPP_OPTION (pfile, c99) = 0; + CPP_OPTION (pfile, extended_numbers) = 0; + new_pending_directive (pend, "__STRICT_ANSI__", cpp_define); + break; + case CLK_STDC99: + CPP_OPTION (pfile, trigraphs) = 1; + CPP_OPTION (pfile, dollars_in_ident) = 0; + CPP_OPTION (pfile, cplusplus_comments) = 1; + CPP_OPTION (pfile, digraphs) = 1; + CPP_OPTION (pfile, c99) = 1; + new_pending_directive (pend, "__STRICT_ANSI__", cpp_define); + new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define); + break; + + /* Objective C. */ + case CLK_OBJCXX: + new_pending_directive (pend, "__cplusplus", cpp_define); + CPP_OPTION (pfile, cplusplus) = 1; + case CLK_OBJC: + CPP_OPTION (pfile, trigraphs) = 0; + CPP_OPTION (pfile, dollars_in_ident) = 1; + CPP_OPTION (pfile, cplusplus_comments) = 1; + CPP_OPTION (pfile, digraphs) = 1; + CPP_OPTION (pfile, c99) = 0; + CPP_OPTION (pfile, objc) = 1; + new_pending_directive (pend, "__OBJC__", cpp_define); + break; + + /* C++. */ + case CLK_GNUCXX: + case CLK_CXX98: + CPP_OPTION (pfile, cplusplus) = 1; + CPP_OPTION (pfile, trigraphs) = lang == CLK_CXX98; + CPP_OPTION (pfile, dollars_in_ident) = lang == CLK_GNUCXX; + CPP_OPTION (pfile, cplusplus_comments) = 1; + CPP_OPTION (pfile, digraphs) = 1; + CPP_OPTION (pfile, c99) = 0; + new_pending_directive (pend, "__cplusplus", cpp_define); + break; + + /* Assembler. */ + case CLK_ASM: + CPP_OPTION (pfile, trigraphs) = 0; + CPP_OPTION (pfile, dollars_in_ident) = 0; /* Maybe not? */ + CPP_OPTION (pfile, cplusplus_comments) = 1; + CPP_OPTION (pfile, digraphs) = 0; + CPP_OPTION (pfile, c99) = 0; + new_pending_directive (pend, "__ASSEMBLER__", cpp_define); + break; + } } -/* Initialize a cpp_options structure. */ -void -cpp_options_init (opts) - cpp_options *opts; +#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; { - bzero ((char *) opts, sizeof (struct cpp_options)); + return strcmp (((struct cl_option *) p1)->opt_text, + ((struct cl_option *) p2)->opt_text); +} +#endif - opts->dollars_in_ident = 1; - opts->cplusplus_comments = 1; - opts->warn_import = 1; - opts->discard_comments = 1; +/* init initializes library global state. It might not need to + do anything depending on the platform and compiler. */ - opts->pending = - (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending)); +static void +init_library () +{ + static int initialized = 0; + + if (! initialized) + { + initialized = 1; + +#ifdef HOST_EBCDIC + /* For non-ASCII hosts, the cl_options array needs to be sorted at + runtime. */ + qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp); +#endif + + /* Set up the trigraph map. This doesn't need to do anything if + we were compiled with a compiler that supports C99 designated + initializers. */ + init_trigraph_map (); + } } /* Initialize a cpp_reader structure. */ -void -cpp_reader_init (pfile) - cpp_reader *pfile; +cpp_reader * +cpp_create_reader (lang) + enum c_lang lang; { - bzero ((char *) pfile, sizeof (cpp_reader)); + struct spec_nodes *s; + cpp_reader *pfile; + + /* Initialise this instance of the library if it hasn't been already. */ + init_library (); + + pfile = (cpp_reader *) xcalloc (1, sizeof (cpp_reader)); + + CPP_OPTION (pfile, warn_import) = 1; + CPP_OPTION (pfile, discard_comments) = 1; + CPP_OPTION (pfile, show_column) = 1; + CPP_OPTION (pfile, tabstop) = 8; + CPP_OPTION (pfile, operator_names) = 1; + + CPP_OPTION (pfile, pending) = + (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending)); + + /* After creating pfile->pending. */ + set_lang (pfile, lang); + + /* It's simplest to just create this struct whether or not it will + be needed. */ + pfile->deps = deps_init (); + + /* Initialize lexer state. */ + pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments); + + /* Indicate date and time not yet calculated. */ + pfile->date.type = CPP_EOF; + + /* Initialise the base context. */ + pfile->context = &pfile->base_context; + pfile->base_context.macro = 0; + pfile->base_context.prev = pfile->base_context.next = 0; - pfile->token_buffer_size = 200; - pfile->token_buffer = (U_CHAR *) xmalloc (pfile->token_buffer_size); - CPP_SET_WRITTEN (pfile, 0); + /* Identifier pool initially 8K. Unaligned, permanent pool. */ + _cpp_init_pool (&pfile->ident_pool, 8 * 1024, 1, 0); - pfile->hashtab = (HASHNODE **) xcalloc (HASHSIZE, sizeof (HASHNODE *)); + /* Argument pool initially 8K. Aligned, temporary pool. */ + _cpp_init_pool (&pfile->argument_pool, 8 * 1024, 0, 1); + + /* Macro pool initially 8K. Aligned, permanent pool. */ + _cpp_init_pool (&pfile->macro_pool, 8 * 1024, 0, 0); + + _cpp_init_hashtable (pfile); + _cpp_init_stacks (pfile); + _cpp_init_includes (pfile); + _cpp_init_internal_pragmas (pfile); + + /* Initialize the special nodes. */ + s = &pfile->spec_nodes; + s->n_L = cpp_lookup (pfile, DSC("L")); + s->n_defined = cpp_lookup (pfile, DSC("defined")); + s->n__Pragma = cpp_lookup (pfile, DSC("_Pragma")); + s->n__STRICT_ANSI__ = cpp_lookup (pfile, DSC("__STRICT_ANSI__")); + s->n__CHAR_UNSIGNED__ = cpp_lookup (pfile, DSC("__CHAR_UNSIGNED__")); + s->n__VA_ARGS__ = cpp_lookup (pfile, DSC("__VA_ARGS__")); + s->n__VA_ARGS__->flags |= NODE_DIAGNOSTIC; + + return pfile; } /* Free resources used by PFILE. @@ -561,193 +563,200 @@ void cpp_cleanup (pfile) cpp_reader *pfile; { - int i; + struct file_name_list *dir, *dirn; + cpp_context *context, *contextn; + while (CPP_BUFFER (pfile) != NULL) cpp_pop_buffer (pfile); - if (pfile->token_buffer) + if (pfile->macro_buffer) { - free (pfile->token_buffer); - pfile->token_buffer = NULL; + free ((PTR) pfile->macro_buffer); + pfile->macro_buffer = NULL; + pfile->macro_buffer_len = 0; } - if (pfile->input_buffer) - { - free (pfile->input_buffer); - free (pfile->input_speccase); - pfile->input_buffer = pfile->input_speccase = NULL; - pfile->input_buffer_len = 0; - } + deps_free (pfile->deps); - if (pfile->deps) - deps_free (pfile->deps); + _cpp_cleanup_includes (pfile); + _cpp_cleanup_stacks (pfile); + _cpp_cleanup_hashtable (pfile); - for (i = ALL_INCLUDE_HASHSIZE; --i >= 0; ) + _cpp_free_lookaheads (pfile); + + _cpp_free_pool (&pfile->ident_pool); + _cpp_free_pool (&pfile->macro_pool); + _cpp_free_pool (&pfile->argument_pool); + + for (dir = CPP_OPTION (pfile, quote_include); dir; dir = dirn) { - IHASH *imp, *next; - for (imp = pfile->all_include_files[i]; imp; imp = next) - { - next = imp->next; - free ((PTR) imp->name); - free ((PTR) imp->nshort); - free (imp); - } - pfile->all_include_files[i] = 0; + dirn = dir->next; + free (dir->name); + free (dir); } - for (i = HASHSIZE; --i >= 0;) + for (context = pfile->base_context.next; context; context = contextn) { - while (pfile->hashtab[i]) - _cpp_delete_macro (pfile->hashtab[i]); + contextn = context->next; + free (context); } - free (pfile->hashtab); } -/* 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 - STDC define only if not -traditional - ULP value is the global user_label_prefix (which can't be - put directly into the table). - */ +/* This structure defines one built-in identifier. A node will be + entered in the hash table under the name NAME, with value VALUE (if + any). If flags has OPERATOR, the node's operator field is used; if + flags has BUILTIN the node's builtin field is used. + + Two values are not compile time constants, so we tag + them in the FLAGS field instead: + VERS value is the global version_string, quoted + ULP value is the global user_label_prefix + + Also, macros with CPLUS set in the flags field are entered only for C++. */ struct builtin { - const char *name; + const U_CHAR *name; const char *value; - unsigned short type; + unsigned char builtin; + unsigned char operator; unsigned short flags; + unsigned short len; }; -#define DUMP 0x01 -#define STDC 0x02 -#define ULP 0x10 - +#define VERS 0x01 +#define ULP 0x02 +#define CPLUS 0x04 +#define BUILTIN 0x08 +#define OPERATOR 0x10 + +#define B(n, t) { U n, 0, t, 0, BUILTIN, sizeof n - 1 } +#define C(n, v) { U n, v, 0, 0, 0, sizeof n - 1 } +#define X(n, f) { U n, 0, 0, 0, f, sizeof n - 1 } +#define O(n, c, f) { U n, 0, 0, c, OPERATOR | f, sizeof n - 1 } static const struct builtin builtin_array[] = { - { "__TIME__", 0, T_TIME, DUMP }, - { "__DATE__", 0, T_DATE, DUMP }, - { "__FILE__", 0, T_FILE, 0 }, - { "__BASE_FILE__", 0, T_BASE_FILE, 0 }, - { "__LINE__", 0, T_SPECLINE, 0 }, - { "__INCLUDE_LEVEL__", 0, T_INCLUDE_LEVEL, 0 }, - { "__VERSION__", 0, T_VERSION, DUMP }, - { "__STDC__", 0, T_STDC, DUMP|STDC }, - - { "__USER_LABEL_PREFIX__", 0, T_CONST, ULP }, - { "__REGISTER_PREFIX__", REGISTER_PREFIX, T_CONST, 0 }, - { "__HAVE_BUILTIN_SETJMP__", "1", T_CONST, 0 }, + B("__TIME__", BT_TIME), + B("__DATE__", BT_DATE), + B("__FILE__", BT_FILE), + B("__BASE_FILE__", BT_BASE_FILE), + B("__LINE__", BT_SPECLINE), + B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL), + B("__STDC__", BT_STDC), + + X("__VERSION__", VERS), + X("__USER_LABEL_PREFIX__", ULP), + C("__REGISTER_PREFIX__", REGISTER_PREFIX), + C("__HAVE_BUILTIN_SETJMP__", "1"), #ifndef NO_BUILTIN_SIZE_TYPE - { "__SIZE_TYPE__", SIZE_TYPE, T_CONST, DUMP }, + C("__SIZE_TYPE__", SIZE_TYPE), #endif #ifndef NO_BUILTIN_PTRDIFF_TYPE - { "__PTRDIFF_TYPE__", PTRDIFF_TYPE, T_CONST, DUMP }, + C("__PTRDIFF_TYPE__", PTRDIFF_TYPE), #endif #ifndef NO_BUILTIN_WCHAR_TYPE - { "__WCHAR_TYPE__", WCHAR_TYPE, T_CONST, DUMP }, + C("__WCHAR_TYPE__", WCHAR_TYPE), #endif - { 0, 0, 0, 0 } +#ifndef NO_BUILTIN_WINT_TYPE + C("__WINT_TYPE__", WINT_TYPE), +#endif + + /* Named operators known to the preprocessor. These cannot be #defined + and always have their stated meaning. They are treated like normal + identifiers except for the type code and the meaning. Most of them + are only for C++ (but see iso646.h). */ + O("and", CPP_AND_AND, CPLUS), + O("and_eq", CPP_AND_EQ, CPLUS), + O("bitand", CPP_AND, CPLUS), + O("bitor", CPP_OR, CPLUS), + O("compl", CPP_COMPL, CPLUS), + O("not", CPP_NOT, CPLUS), + O("not_eq", CPP_NOT_EQ, CPLUS), + O("or", CPP_OR_OR, CPLUS), + O("or_eq", CPP_OR_EQ, CPLUS), + O("xor", CPP_XOR, CPLUS), + O("xor_eq", CPP_XOR_EQ, CPLUS) }; +#undef B +#undef C +#undef X +#undef O +#define builtin_array_end \ + builtin_array + sizeof(builtin_array)/sizeof(struct builtin) /* Subroutine of cpp_start_read; reads the builtins table above and enters the macros into the hash table. */ - static void -initialize_builtins (pfile) +init_builtins (pfile) cpp_reader *pfile; { - int len; const struct builtin *b; - const char *val; - for(b = builtin_array; b->name; b++) + + for(b = builtin_array; b < builtin_array_end; b++) { - if ((b->flags & STDC) && CPP_TRADITIONAL (pfile)) + if ((b->flags & CPLUS) && ! CPP_OPTION (pfile, cplusplus)) continue; - val = (b->flags & ULP) ? user_label_prefix : b->value; - len = strlen (b->name); - - _cpp_install (pfile, b->name, len, b->type, val); - if ((b->flags & DUMP) && CPP_OPTIONS (pfile)->debug_output) - dump_special_to_buffer (pfile, b->name); - } - -} -#undef DUMP -#undef STDC -#undef ULP - -/* Another subroutine of cpp_start_read. This one sets up to do - dependency-file output. */ -static void -initialize_dependency_output (pfile) - cpp_reader *pfile; -{ - cpp_options *opts = CPP_OPTIONS (pfile); - char *spec, *s, *output_file; - - /* Either of two environment variables can specify output of deps. - Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET", - where OUTPUT_FILE is the file to write deps info to - and DEPS_TARGET is the target to mention in the deps. */ + if ((b->flags & OPERATOR) && ! CPP_OPTION (pfile, operator_names)) + continue; - if (opts->print_deps == 0) - { - spec = getenv ("DEPENDENCIES_OUTPUT"); - if (spec) - opts->print_deps = 1; - else + if (b->flags & (OPERATOR | BUILTIN)) { - spec = getenv ("SUNPRO_DEPENDENCIES"); - if (spec) - opts->print_deps = 2; + cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len); + if (b->flags & OPERATOR) + { + hp->flags |= NODE_OPERATOR; + hp->value.operator = b->operator; + } else - return; - } - - /* Find the space before the DEPS_TARGET, if there is one. */ - s = strchr (spec, ' '); - if (s) - { - opts->deps_target = s + 1; - output_file = (char *) xmalloc (s - spec + 1); - memcpy (output_file, spec, s - spec); - output_file[s - spec] = 0; + { + hp->type = NT_MACRO; + hp->flags |= NODE_BUILTIN; + hp->value.builtin = b->builtin; + } } - else + else /* A standard macro of some kind. */ { - opts->deps_target = 0; - output_file = spec; - } - - opts->deps_file = output_file; - opts->print_deps_append = 1; - } + const char *val; + char *str; - pfile->deps = deps_init (); + 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; - /* Print the expected object file name as the target of this Make-rule. */ - if (opts->deps_target) - deps_add_target (pfile->deps, opts->deps_target); - else if (*opts->in_fname == 0) - deps_add_target (pfile->deps, "-"); - else - deps_calc_target (pfile->deps, opts->in_fname); + /* Allocate enough space for "name value\n\0". */ + str = alloca (b->len + strlen (val) + 3); + sprintf(str, "%s %s\n", b->name, val); + } - if (opts->in_fname) - deps_add_dep (pfile->deps, opts->in_fname); + _cpp_define_builtin (pfile, str); + } + } } +#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 -initialize_standard_includes (pfile) +init_standard_includes (pfile) cpp_reader *pfile; { - cpp_options *opts = CPP_OPTIONS (pfile); char *path; const struct default_include *p; - char *specd_prefix = opts->include_prefix; + const char *specd_prefix = CPP_OPTION (pfile, include_prefix); /* Several environment variables may add to the include search path. CPATH specifies an additional list of directories to be searched @@ -757,9 +766,9 @@ initialize_standard_includes (pfile) GET_ENV_PATH_LIST (path, "CPATH"); if (path != 0 && *path != 0) - path_include (pfile, opts->pending, path, BRACKET); + path_include (pfile, path, BRACKET); - switch ((opts->objc << 1) + opts->cplusplus) + switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus)) { case 0: GET_ENV_PATH_LIST (path, "C_INCLUDE_PATH"); @@ -775,30 +784,30 @@ initialize_standard_includes (pfile) break; } if (path != 0 && *path != 0) - path_include (pfile, opts->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 = 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 - || (opts->cplusplus - && !opts->no_standard_cplusplus_includes)) + || (CPP_OPTION (pfile, cplusplus) + && !CPP_OPTION (pfile, no_standard_cplusplus_includes))) { /* Does this dir start with the prefix? */ - if (!strncmp (p->fname, default_prefix, default_len)) + if (!memcmp (p->fname, default_prefix, default_len)) { /* Yes; change prefix and add to search list. */ int flen = strlen (p->fname); @@ -809,282 +818,299 @@ initialize_standard_includes (pfile) p->fname + default_len, flen - default_len + 1); - append_include_chain (pfile, opts->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 - || (opts->cplusplus - && !opts->no_standard_cplusplus_includes)) + || (CPP_OPTION (pfile, cplusplus) + && !CPP_OPTION (pfile, no_standard_cplusplus_includes))) { - /* XXX Potential memory leak! */ char *str = xstrdup (update_path (p->fname, p->component)); - append_include_chain (pfile, opts->pending, str, SYSTEM, - p->cxx_aware); + append_include_chain (pfile, str, SYSTEM, p->cxx_aware); } } } -/* This is called after options have been processed. - * Check options for consistency, and setup for processing input - * from the file named FNAME. (Use standard input if FNAME==NULL.) - * Return 1 on success, 0 on failure. - */ - -int -cpp_start_read (pfile, fname) +/* Handles -imacro and -include from the command line. */ +static void +do_includes (pfile, p, scan) cpp_reader *pfile; - char *fname; + struct pending_option *p; + int scan; { - struct cpp_options *opts = CPP_OPTIONS (pfile); - struct pending_option *p, *q; - - /* -MG doesn't select the form of output and must be specified with one of - -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't - inhibit compilation. */ - if (opts->print_deps_missing_files - && (opts->print_deps == 0 || !opts->no_output)) - { - cpp_fatal (pfile, "-MG must be specified with one of -M or -MM"); - return 0; - } - - /* Chill should not be used with -trigraphs. */ - if (opts->chill && opts->trigraphs) + while (p) { - cpp_warning (pfile, "-lang-chill and -trigraphs are mutually exclusive"); - opts->trigraphs = 0; + struct pending_option *q; + + /* Don't handle if -fpreprocessed. Later: maybe update this to + use the #include "" search path if cpp_read_file fails. */ + if (CPP_OPTION (pfile, preprocessed)) + cpp_error (pfile, "-include and -imacros cannot be used with -fpreprocessed"); + else if (_cpp_read_file (pfile, p->arg) && scan) + cpp_scan_buffer_nooutput (pfile, 0); + q = p->next; + free (p); + p = q; } +} - /* Set this if it hasn't been set already. */ - if (user_label_prefix == NULL) - user_label_prefix = USER_LABEL_PREFIX; - - /* Don't bother trying to do macro expansion if we've already done - preprocessing. */ - if (opts->preprocessed) - pfile->no_macro_expand++; +/* This is called after options have been processed. Setup for + processing input from the file named FNAME. (Use standard input if + FNAME == NULL.) Return 1 on success, 0 on failure. */ - /* Set up the IStable. This doesn't do anything if we were compiled - with a compiler that supports C99 designated initializers. */ - init_IStable (); +int +cpp_start_read (pfile, fname) + cpp_reader *pfile; + const char *fname; +{ + struct pending_option *p, *q; /* Set up the include search path now. */ - if (! opts->no_standard_includes) - initialize_standard_includes (pfile); + if (! CPP_OPTION (pfile, no_standard_includes)) + init_standard_includes (pfile); - merge_include_chains (opts); + merge_include_chains (pfile); /* With -v, print the list of dirs to search. */ - if (opts->verbose) + if (CPP_OPTION (pfile, verbose)) { struct file_name_list *l; fprintf (stderr, _("#include \"...\" search starts here:\n")); - for (l = opts->quote_include; l; l = l->next) + for (l = CPP_OPTION (pfile, quote_include); l; l = l->next) { - if (l == opts->bracket_include) + if (l == CPP_OPTION (pfile, bracket_include)) fprintf (stderr, _("#include <...> search starts here:\n")); fprintf (stderr, " %s\n", l->name); } fprintf (stderr, _("End of search list.\n")); } - initialize_dependency_output (pfile); - - /* Open the main input file. This must be done before -D processing - so we have a buffer to stand on. */ - if (opts->in_fname == NULL || *opts->in_fname == 0) + if (CPP_OPTION (pfile, in_fname) == NULL + || *CPP_OPTION (pfile, in_fname) == 0) { - opts->in_fname = fname; - if (opts->in_fname == NULL) - opts->in_fname = ""; + CPP_OPTION (pfile, in_fname) = fname; + if (CPP_OPTION (pfile, in_fname) == NULL) + CPP_OPTION (pfile, in_fname) = ""; } + if (CPP_OPTION (pfile, out_fname) == NULL) + CPP_OPTION (pfile, out_fname) = ""; - if (!cpp_read_file (pfile, fname)) - return 0; + if (CPP_OPTION (pfile, print_deps)) + { + /* Set the default target (if there is none already), and + the dependency on the main file. */ + deps_add_default_target (pfile->deps, CPP_OPTION (pfile, in_fname)); - /* -D and friends may produce output, which should be identified - as line 0. */ + deps_add_dep (pfile->deps, CPP_OPTION (pfile, in_fname)); + } - CPP_BUFFER (pfile)->lineno = 0; + /* Open the main input file. This must be done early, so we have a + buffer to stand on. */ + if (!_cpp_read_file (pfile, fname)) + return 0; - /* Install __LINE__, etc. */ - initialize_builtins (pfile); + /* If already preprocessed, don't install __LINE__, etc., and ignore + command line definitions and assertions. Handle -U's, -D's and + -A's in the order they were seen. */ + if (! CPP_OPTION (pfile, preprocessed)) + init_builtins (pfile); - /* Do -U's, -D's and -A's in the order they were seen. */ - p = opts->pending->define_head; + p = CPP_OPTION (pfile, pending)->directive_head; while (p) { - if (p->undef) - cpp_undef (pfile, p->arg); - else - cpp_define (pfile, p->arg); - + if (! CPP_OPTION (pfile, preprocessed)) + (*p->handler) (pfile, p->arg); q = p->next; free (p); p = q; } - p = opts->pending->assert_head; - while (p) - { - if (p->undef) - cpp_unassert (pfile, p->arg); - else - cpp_assert (pfile, p->arg); - - q = p->next; - free (p); - p = q; - } - - opts->done_initializing = 1; - CPP_BUFFER (pfile)->lineno = 1; - - if (opts->preprocessed) - /* If we've already processed this code, we want to trust the #line - directives in the input. But we still need to update our line - counter accordingly. */ - pfile->lineno = CPP_BUFFER (pfile)->lineno; - else - output_line_command (pfile, same_file); - pfile->only_seen_white = 2; + pfile->done_initializing = 1; /* The -imacros files can be scanned now, but the -include files - have to be pushed onto the include stack and processed later, - in the main loop calling cpp_get_token. */ - - opts->no_output++; - p = opts->pending->imacros_head; - while (p) - { - if (cpp_read_file (pfile, p->arg)) - cpp_scan_buffer (pfile); + have to be pushed onto the buffer stack and processed later, + otherwise cppmain.c won't see the tokens. include_head was built + up as a stack, and popping this stack onto the buffer stack means + we preserve the order of the command line. */ + do_includes (pfile, CPP_OPTION (pfile, pending)->imacros_head, 1); + do_includes (pfile, CPP_OPTION (pfile, pending)->include_head, 0); - q = p->next; - free (p); - p = q; - } - opts->no_output--; + free (CPP_OPTION (pfile, pending)); + CPP_OPTION (pfile, pending) = NULL; - p = opts->pending->include_head; - while (p) - { - if (cpp_read_file (pfile, p->arg)) - output_line_command (pfile, enter_file); + return 1; +} - q = p->next; - free (p); - p = q; +/* Use mkdeps.c to output dependency information. */ +static void +output_deps (pfile) + cpp_reader *pfile; +{ + /* Stream on which to print the dependency information. */ + FILE *deps_stream = 0; + const char *deps_mode = CPP_OPTION (pfile, print_deps_append) ? "a" : "w"; + + if (CPP_OPTION (pfile, deps_file) == 0) + deps_stream = stdout; + else + { + deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode); + if (deps_stream == 0) + { + cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file)); + return; + } } - free (opts->pending); - opts->pending = NULL; + deps_write (pfile->deps, deps_stream, 72); - return 1; + if (CPP_OPTION (pfile, deps_phony_targets)) + deps_phony_targets (pfile->deps, deps_stream); + + /* Don't close stdout. */ + if (CPP_OPTION (pfile, deps_file)) + { + if (ferror (deps_stream) || fclose (deps_stream) != 0) + cpp_fatal (pfile, "I/O error on output"); + } } /* This is called at the end of preprocessing. It pops the last buffer and writes dependency output. It should also clear macro definitions, such that you could call cpp_start_read - with a new filename to restart processing. */ + with a new filename to restart processing. */ void cpp_finish (pfile) cpp_reader *pfile; { - struct cpp_options *opts = CPP_OPTIONS (pfile); - - if (CPP_PREV_BUFFER (CPP_BUFFER (pfile))) - cpp_ice (pfile, "buffers still stacked in cpp_finish"); - while (CPP_BUFFER (pfile)) - cpp_pop_buffer (pfile); - - /* Don't write the deps file if preprocessing has failed. */ - if (opts->print_deps && pfile->errors == 0) + if (CPP_BUFFER (pfile)) { - /* Stream on which to print the dependency information. */ - FILE *deps_stream = 0; - - const char *deps_mode = opts->print_deps_append ? "a" : "w"; - if (opts->deps_file == 0) - deps_stream = stdout; - else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0) - cpp_notice_from_errno (pfile, opts->deps_file); - - if (deps_stream) - { - deps_write (pfile->deps, deps_stream, 72); - if (opts->deps_file) - { - if (ferror (deps_stream) || fclose (deps_stream) != 0) - cpp_fatal (pfile, "I/O error on output"); - } - } + cpp_ice (pfile, "buffers still stacked in cpp_finish"); + while (CPP_BUFFER (pfile)) + cpp_pop_buffer (pfile); } - if (opts->dump_macros == dump_only) - { - int i; - HASHNODE *h; - for (i = HASHSIZE; --i >= 0;) - { - for (h = pfile->hashtab[i]; h; h = h->next) - if (h->type == T_MACRO) - { - _cpp_dump_definition (pfile, h->name, h->length, - h->value.defn); - CPP_PUTC (pfile, '\n'); - } - } - } + /* 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); } static void -new_pending_define (opts, text) - struct cpp_options *opts; +new_pending_directive (pend, text, handler) + struct cpp_pending *pend; const char *text; + cl_directive_handler handler; { struct pending_option *o = (struct pending_option *) xmalloc (sizeof (struct pending_option)); - o->arg = (char *) text; + o->arg = text; o->next = NULL; - o->undef = 0; - APPEND (opts->pending, define, o); + o->handler = handler; + APPEND (pend, directive, o); } +/* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string"); + I.e. a const string initializer with parens around it. That is + what N_("string") resolves to, so we make no_* be macros instead. */ +#define no_arg N_("Argument missing after %s") +#define no_ass N_("Assertion missing after %s") +#define no_dir N_("Directory name missing after %s") +#define no_fil N_("File name missing after %s") +#define no_mac N_("Macro name missing after %s") +#define no_pth N_("Path name missing after %s") +#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_stdin_stdout) \ + 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("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("ftabstop=", no_num, OPT_ftabstop) \ + 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 { - OPT_stdin_stdout = 0, OPT_dollar, OPT_plus, - OPT__help, OPT__version, - OPT_A, OPT_C, OPT_D, OPT_H, OPT_I, OPT_M, - OPT_MD, OPT_MG, OPT_MM, OPT_MMD, - OPT_P, OPT_U, OPT_W, - OPT_d, - OPT_fleading_underscore, OPT_fno_leading_underscore, - OPT_fpreprocessed, OPT_fno_preprocessed, - OPT_g, OPT_h, - OPT_idirafter, OPT_imacros, OPT_include, - OPT_iprefix, OPT_isystem, OPT_iwithprefix, OPT_iwithprefixbefore, - OPT_lang_asm, OPT_lang_c, OPT_lang_cplusplus, OPT_lang_c89, - OPT_lang_chill, OPT_lang_fortran, OPT_lang_objc, OPT_lang_objcplusplus, - OPT_nostdinc, OPT_nostdincplusplus, - OPT_o, - OPT_pedantic, OPT_pedantic_errors, OPT_remap, - OPT_std_c89, OPT_std_c99, OPT_std_c9x, OPT_std_gnu89, OPT_std_gnu99, - OPT_std_gnu9x, OPT_std_iso9899_1990, OPT_std_iso9899_199409, - OPT_std_iso9899_1999, OPT_std_iso9899_199x, - OPT_traditional, OPT_trigraphs, - OPT_v, OPT_w, + COMMAND_LINE_OPTIONS N_OPTS }; +#undef DEF_OPT struct cl_option { @@ -1094,95 +1120,26 @@ struct cl_option enum opt_code opt_code; }; -static const char no_arg[] = N_("Argument missing after `%s' option"); -static const char no_ass[] = N_("Assertion missing after `%s' option"); -static const char no_dir[] = N_("Directory name missing after `%s' option"); -static const char no_fil[] = N_("File name missing after `%s' option"); -static const char no_mac[] = N_("Macro name missing after `%s' option"); -static const char no_pth[] = N_("Path name missing after `%s' option"); - -/* This list must be ASCII sorted. Make enum order above match this. */ -#define DEF_OPT(text, msg, code) {text, msg, sizeof(text) - 1, code} - +#define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code }, #ifdef HOST_EBCDIC static struct cl_option cl_options[] = #else static const struct cl_option cl_options[] = #endif { - DEF_OPT("", 0, OPT_stdin_stdout), - DEF_OPT("$", 0, OPT_dollar), - DEF_OPT("+", 0, OPT_plus), - DEF_OPT("-help", 0, OPT__help), - DEF_OPT("-version", 0, OPT__version), - DEF_OPT("A", no_ass, OPT_A), - DEF_OPT("C", 0, OPT_C), - DEF_OPT("D", no_mac, OPT_D), - DEF_OPT("H", 0, OPT_H), - DEF_OPT("I", no_dir, OPT_I), - DEF_OPT("M", 0, OPT_M), - DEF_OPT("MD", no_fil, OPT_MD), - DEF_OPT("MG", 0, OPT_MG), - DEF_OPT("MM", 0, OPT_MM), - DEF_OPT("MMD", no_fil, OPT_MMD), - DEF_OPT("P", 0, OPT_P), - DEF_OPT("U", no_mac, OPT_U), - /* NB: Immed arg only, and not reqd */ - DEF_OPT("W", no_arg, OPT_W), - DEF_OPT("d", no_arg, OPT_d), - DEF_OPT("fleading-underscore", 0, OPT_fleading_underscore), - DEF_OPT("fno-leading-underscore", 0, OPT_fno_leading_underscore), - DEF_OPT("fpreprocessed", 0, OPT_fpreprocessed), - DEF_OPT("fno-preprocessed", 0, OPT_fno_preprocessed), - /* NB: Immed arg only, and not reqd */ - DEF_OPT("g", no_arg, OPT_g), - DEF_OPT("h", 0, OPT_h), - DEF_OPT("idirafter", no_dir, OPT_idirafter), - DEF_OPT("imacros", no_fil, OPT_imacros), - DEF_OPT("include", no_fil, OPT_include), - DEF_OPT("iprefix", no_pth, OPT_iprefix), - DEF_OPT("isystem", no_dir, OPT_isystem), - DEF_OPT("iwithprefix", no_dir, OPT_iwithprefix), - DEF_OPT("iwithprefixbefore", no_dir, OPT_iwithprefixbefore), - DEF_OPT("lang-asm", 0, OPT_lang_asm), - DEF_OPT("lang-c", 0, OPT_lang_c), - DEF_OPT("lang-c++", 0, OPT_lang_cplusplus), - DEF_OPT("lang-c89", 0, OPT_lang_c89), - DEF_OPT("lang-chill", 0, OPT_lang_chill), - DEF_OPT("lang-fortran", 0, OPT_lang_fortran), - DEF_OPT("lang-objc", 0, OPT_lang_objc), - DEF_OPT("lang-objc++", 0, OPT_lang_objcplusplus), - DEF_OPT("nostdinc", 0, OPT_nostdinc), - DEF_OPT("nostdinc++", 0, OPT_nostdincplusplus), - DEF_OPT("o", no_fil, OPT_o), - DEF_OPT("pedantic", 0, OPT_pedantic), - DEF_OPT("pedantic-errors", 0, OPT_pedantic_errors), - DEF_OPT("remap", 0, OPT_remap), - DEF_OPT("std=c89", 0, OPT_std_c89), - DEF_OPT("std=c99", 0, OPT_std_c99), - DEF_OPT("std=c9x", 0, OPT_std_c9x), - DEF_OPT("std=gnu89", 0, OPT_std_gnu89), - DEF_OPT("std=gnu99", 0, OPT_std_gnu99), - DEF_OPT("std=gnu9x", 0, OPT_std_gnu9x), - DEF_OPT("std=iso9899:1990", 0, OPT_std_iso9899_1990), - DEF_OPT("std=iso9899:199409", 0, OPT_std_iso9899_199409), - DEF_OPT("std=iso9899:1999", 0, OPT_std_iso9899_1999), - DEF_OPT("std=iso9899:199x", 0, OPT_std_iso9899_199x), - DEF_OPT("traditional", 0, OPT_traditional), - DEF_OPT("trigraphs", 0, OPT_trigraphs), - DEF_OPT("v", 0, OPT_v), - DEF_OPT("w", 0, OPT_w) + COMMAND_LINE_OPTIONS }; #undef DEF_OPT +#undef COMMAND_LINE_OPTIONS /* Perform a binary search to find which, if any, option the given command-line matches. Returns its index in the option array, negative on failure. Complications arise since some options can be suffixed with an argument, and multiple complete matches can occur, - e.g. -iwithprefix and -iwithprefixbefore. Moreover, we want to - accept options beginning with -g and -W that we do not recognise, - but not to swallow any subsequent command line argument; these are - handled as special cases in cpp_handle_option */ + e.g. -iwithprefix and -iwithprefixbefore. Moreover, we need to + accept options beginning with -W that we do not recognise, but not + to swallow any subsequent command line argument; this is handled as + special cases in cpp_handle_option. */ static int parse_option (input) const char *input; @@ -1197,10 +1154,10 @@ parse_option (input) while (mx > mn) { 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; else if (comp < 0) @@ -1213,18 +1170,18 @@ parse_option (input) we may match a later option or we may have been passed the argument. The longest possible option match succeeds. If the option takes no arguments we have not matched and - continue the search (e.g. input="stdc++" match was "stdc") */ + continue the search (e.g. input="stdc++" match was "stdc"). */ mn = md + 1; if (cl_options[md].msg) { /* Scan forwards. If we get an exact match, return it. Otherwise, return the longest option-accepting match. - This loops no more than twice with current options */ + This loops no more than twice with current options. */ mx = md; for (; mn < N_OPTS; mn++) { opt_len = cl_options[mn].opt_len; - if (strncmp (input, cl_options[mn].opt_text, opt_len)) + if (memcmp (input, cl_options[mn].opt_text, opt_len)) break; if (input[opt_len] == '\0') return mn; @@ -1243,34 +1200,32 @@ parse_option (input) 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; { - struct cpp_options *opts = CPP_OPTIONS (pfile); int i = 0; + struct cpp_pending *pend = CPP_OPTION (pfile, pending); if (argv[i][0] != '-') { - if (opts->out_fname != NULL) - { - print_help (); - cpp_fatal (pfile, "Too many arguments"); - } - else if (opts->in_fname != NULL) - opts->out_fname = argv[i]; + if (CPP_OPTION (pfile, out_fname) != NULL) + cpp_fatal (pfile, "Too many arguments. Type %s --help for usage info", + progname); + else if (CPP_OPTION (pfile, in_fname) != NULL) + CPP_OPTION (pfile, out_fname) = argv[i]; else - opts->in_fname = argv[i]; + CPP_OPTION (pfile, in_fname) = argv[i]; } else { enum opt_code opt_code; int opt_index; - char *arg = 0; + const char *arg = 0; - /* Skip over '-' */ + /* Skip over '-'. */ opt_index = parse_option (&argv[i][1]); if (opt_index < 0) return i; @@ -1280,294 +1235,283 @@ handle_option (pfile, argc, argv) { arg = &argv[i][cl_options[opt_index].opt_len + 1]; - /* Yuk. Special case for -g and -W as they must not swallow + /* Yuk. Special case for -W as it must not swallow up any following argument. If this becomes common, add - another field to the cl_options table */ - if (arg[0] == '\0' && !(opt_code == OPT_g || opt_code == OPT_W)) + another field to the cl_options table. */ + if (arg[0] == '\0' && opt_code != OPT_W) { arg = argv[++i]; if (!arg) { - cpp_fatal (pfile, _(cl_options[opt_index].msg), argv[i - 1]); + cpp_fatal (pfile, cl_options[opt_index].msg, argv[i - 1]); return argc; } } } - + switch (opt_code) { - case N_OPTS: /* shut GCC up */ + case N_OPTS: /* Shut GCC up. */ break; case OPT_fleading_underscore: - user_label_prefix = "_"; + CPP_OPTION (pfile, user_label_prefix) = "_"; break; case OPT_fno_leading_underscore: - user_label_prefix = ""; + CPP_OPTION (pfile, user_label_prefix) = ""; + break; + case OPT_fno_operator_names: + CPP_OPTION (pfile, operator_names) = 0; break; case OPT_fpreprocessed: - opts->preprocessed = 1; + CPP_OPTION (pfile, preprocessed) = 1; break; case OPT_fno_preprocessed: - opts->preprocessed = 0; + CPP_OPTION (pfile, preprocessed) = 0; break; - case OPT_w: - opts->inhibit_warnings = 1; + 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_g: /* Silently ignore anything but -g3 */ - if (!strcmp(&argv[i][2], "3")) - opts->debug_output = 1; + 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 (); - exit (0); /* XXX */ + CPP_OPTION (pfile, help_only) = 1; break; + case OPT_target__help: + /* Print if any target specific options. cpplib has none, but + make sure help_only gets set. */ + CPP_OPTION (pfile, help_only) = 1; + break; + + /* --version inhibits compilation, -version doesn't. -v means + verbose and -version. Historical reasons, don't ask. */ case OPT__version: - fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string); - exit (0); /* XXX */ + CPP_OPTION (pfile, help_only) = 1; + goto version; + case OPT_v: + CPP_OPTION (pfile, verbose) = 1; + goto version; + + case OPT_version: + version: + fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string); +#ifdef TARGET_VERSION + TARGET_VERSION; +#endif + fputc ('\n', stderr); break; + case OPT_C: - opts->discard_comments = 0; + CPP_OPTION (pfile, discard_comments) = 0; break; case OPT_P: - opts->no_line_commands = 1; + CPP_OPTION (pfile, no_line_commands) = 1; break; - case OPT_dollar: /* Don't include $ in identifiers. */ - opts->dollars_in_ident = 0; + case OPT_dollar: /* Don't include $ in identifiers. */ + CPP_OPTION (pfile, dollars_in_ident) = 0; break; case OPT_H: - opts->print_include_names = 1; + CPP_OPTION (pfile, print_include_names) = 1; break; case OPT_D: - new_pending_define (opts, arg); + new_pending_directive (pend, arg, cpp_define); break; case OPT_pedantic_errors: - opts->pedantic_errors = 1; + CPP_OPTION (pfile, pedantic_errors) = 1; /* fall through */ case OPT_pedantic: - opts->pedantic = 1; - break; - case OPT_traditional: - opts->traditional = 1; - opts->cplusplus_comments = 0; - opts->trigraphs = 0; - opts->warn_trigraphs = 0; + CPP_OPTION (pfile, pedantic) = 1; break; case OPT_trigraphs: - opts->trigraphs = 1; + CPP_OPTION (pfile, trigraphs) = 1; break; case OPT_plus: - opts->cplusplus = 1; - opts->cplusplus_comments = 1; + CPP_OPTION (pfile, cplusplus) = 1; + CPP_OPTION (pfile, cplusplus_comments) = 1; break; case OPT_remap: - opts->remap = 1; + CPP_OPTION (pfile, remap) = 1; break; case OPT_iprefix: - opts->include_prefix = arg; - opts->include_prefix_len = strlen (arg); + CPP_OPTION (pfile, include_prefix) = arg; + CPP_OPTION (pfile, include_prefix_len) = strlen (arg); break; case OPT_lang_c: - opts->cplusplus = 0, opts->cplusplus_comments = 1; - opts->c89 = 0, opts->c99 = 1, opts->objc = 0; - break; - case OPT_lang_c89: - opts->cplusplus = 0, opts->cplusplus_comments = 0; - opts->c89 = 1, opts->c99 = 0, opts->objc = 0; - opts->trigraphs = 1; - new_pending_define (opts, "__STRICT_ANSI__"); + set_lang (pfile, CLK_GNUC89); break; case OPT_lang_cplusplus: - opts->cplusplus = 1, opts->cplusplus_comments = 1; - opts->c89 = 0, opts->c99 = 0, opts->objc = 0; + set_lang (pfile, CLK_GNUCXX); break; case OPT_lang_objc: + set_lang (pfile, CLK_OBJC); + break; case OPT_lang_objcplusplus: - opts->cplusplus = opt_code == OPT_lang_objcplusplus; - opts->cplusplus_comments = 1; - opts->c89 = 0, opts->c99 = 0, opts->objc = 1; + set_lang (pfile, CLK_OBJCXX); break; case OPT_lang_asm: - opts->lang_asm = 1; - break; - case OPT_lang_fortran: - opts->lang_fortran = 1, opts->cplusplus_comments = 0; - break; - case OPT_lang_chill: - opts->objc = 0, opts->cplusplus = 0; - opts->chill = 1, opts->traditional = 1; - break; - case OPT_nostdinc: - /* -nostdinc causes no default include directories. - You must specify all include-file directories with -I. */ - opts->no_standard_includes = 1; + set_lang (pfile, CLK_ASM); break; - case OPT_nostdincplusplus: - /* -nostdinc++ causes no default C++-specific include directories. */ - opts->no_standard_cplusplus_includes = 1; + case OPT_std_cplusplus98: + set_lang (pfile, CLK_CXX98); break; case OPT_std_gnu89: - opts->cplusplus = 0, opts->cplusplus_comments = 1; - opts->c89 = 1, opts->c99 = 0, opts->objc = 0; + set_lang (pfile, CLK_GNUC89); break; case OPT_std_gnu9x: case OPT_std_gnu99: - opts->cplusplus = 0, opts->cplusplus_comments = 1; - opts->c89 = 0, opts->c99 = 1, opts->objc = 0; - new_pending_define (opts, "__STDC_VERSION__=199901L"); + set_lang (pfile, CLK_GNUC99); break; case OPT_std_iso9899_199409: - new_pending_define (opts, "__STDC_VERSION__=199409L"); - /* Fall through */ + set_lang (pfile, CLK_STDC94); + break; case OPT_std_iso9899_1990: case OPT_std_c89: - opts->cplusplus = 0, opts->cplusplus_comments = 0; - opts->c89 = 1, opts->c99 = 0, opts->objc = 0; - opts->trigraphs = 1; - new_pending_define (opts, "__STRICT_ANSI__"); + 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: - opts->cplusplus = 0, opts->cplusplus_comments = 1; - opts->c89 = 0, opts->c99 = 1, opts->objc = 0; - opts->trigraphs = 1; - new_pending_define (opts, "__STRICT_ANSI__"); - new_pending_define (opts, "__STDC_VERSION__=199901L"); + 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 (opts->out_fname != NULL) + if (CPP_OPTION (pfile, out_fname) != NULL) { cpp_fatal (pfile, "Output filename specified twice"); return argc; } - opts->out_fname = arg; - if (!strcmp (opts->out_fname, "-")) - opts->out_fname = ""; - break; - case OPT_v: - fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string); -#ifdef TARGET_VERSION - TARGET_VERSION; -#endif - fputc ('\n', stderr); - opts->verbose = 1; + CPP_OPTION (pfile, out_fname) = arg; + if (!strcmp (CPP_OPTION (pfile, out_fname), "-")) + CPP_OPTION (pfile, out_fname) = ""; break; case OPT_stdin_stdout: - /* JF handle '-' as file name meaning stdin or stdout */ - if (opts->in_fname == NULL) - opts->in_fname = ""; - else if (opts->out_fname == NULL) - opts->out_fname = ""; + /* JF handle '-' as file name meaning stdin or stdout. */ + if (CPP_OPTION (pfile, in_fname) == NULL) + CPP_OPTION (pfile, in_fname) = ""; + else if (CPP_OPTION (pfile, out_fname) == NULL) + CPP_OPTION (pfile, out_fname) = ""; 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. */ + be aimed at the compiler proper. */ { char c; - + while ((c = *arg++) != '\0') switch (c) { case 'M': - opts->dump_macros = dump_only; - opts->no_output = 1; + CPP_OPTION (pfile, dump_macros) = dump_only; + CPP_OPTION (pfile, no_output) = 1; break; case 'N': - opts->dump_macros = dump_names; + CPP_OPTION (pfile, dump_macros) = dump_names; break; case 'D': - opts->dump_macros = dump_definitions; + CPP_OPTION (pfile, dump_macros) = dump_definitions; break; case 'I': - opts->dump_includes = 1; + CPP_OPTION (pfile, dump_includes) = 1; break; } } break; - /* The style of the choices here is a bit mixed. - The chosen scheme is a hybrid of keeping all options in one string - and specifying each option in a separate argument: - -M|-MM|-MD file|-MMD file [-MG]. An alternative is: - -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely: - -M[M][G][D file]. This is awkward to handle in specs, and is not - as extensible. */ - /* ??? -MG must be specified in addition to one of -M or -MM. - This can be relaxed in the future without breaking anything. - The converse isn't true. */ - - /* -MG isn't valid with -MD or -MMD. This is checked for later. */ + case OPT_MG: - opts->print_deps_missing_files = 1; + CPP_OPTION (pfile, print_deps_missing_files) = 1; break; case OPT_M: - case OPT_MD: + CPP_OPTION (pfile, print_deps) = 2; + break; case OPT_MM: - case OPT_MMD: - if (opt_code == OPT_M || opt_code == OPT_MD) - opts->print_deps = 2; - else - opts->print_deps = 1; + CPP_OPTION (pfile, print_deps) = 1; + break; + case OPT_MF: + CPP_OPTION (pfile, deps_file) = arg; + break; + case OPT_MP: + CPP_OPTION (pfile, deps_phony_targets) = 1; + break; + case OPT_MQ: + case OPT_MT: + /* Add a target. -MQ quotes for Make. */ + deps_add_target (pfile->deps, arg, opt_code == OPT_MQ); + break; - /* For -MD and -MMD options, write deps on file named by next arg */ - /* For -M and -MM, write deps on standard output - and suppress the usual output. */ - if (opt_code == OPT_MD || opt_code == OPT_MMD) - opts->deps_file = arg; - else - opts->no_output = 1; + /* -MD and -MMD for cpp0 are deprecated and undocumented + (use -M or -MM with -MF instead), and probably should be + removed with the next major GCC version. For the moment + we allow these for the benefit of Automake 1.4, which + uses these when dependency tracking is enabled. Automake + 1.5 will fix this. */ + case OPT_MD: + CPP_OPTION (pfile, print_deps) = 2; + CPP_OPTION (pfile, deps_file) = arg; break; + case OPT_MMD: + CPP_OPTION (pfile, print_deps) = 1; + CPP_OPTION (pfile, deps_file) = arg; + break; + case OPT_A: - if (strcmp (arg, "-")) - { - struct pending_option *o = (struct pending_option *) - xmalloc (sizeof (struct pending_option)); - - o->arg = arg; - o->next = NULL; - o->undef = 0; - APPEND (opts->pending, assert, o); - } - else + if (arg[0] == '-') { - /* -A- eliminates all predefined macros and assertions. - Let's include also any that were specified earlier - on the command line. That way we can get rid of any - that were passed automatically in from GCC. */ - struct pending_option *o1, *o2; - - o1 = opts->pending->define_head; - while (o1) - { - o2 = o1->next; - free (o1); - o1 = o2; - } - o1 = opts->pending->assert_head; - while (o1) + /* -A with an argument beginning with '-' acts as + #unassert on whatever immediately follows the '-'. + If "-" is the whole argument, we eliminate all + predefined macros and assertions, including those + that were specified earlier on the command line. + That way we can get rid of any that were passed + automatically in from GCC. */ + + if (arg[1] == '\0') { - o2 = o1->next; - free (o1); - o1 = o2; + struct pending_option *o1, *o2; + + o1 = pend->directive_head; + while (o1) + { + o2 = o1->next; + free (o1); + o1 = o2; + } + pend->directive_head = NULL; + pend->directive_tail = NULL; } - opts->pending->assert_head = NULL; - opts->pending->assert_tail = NULL; - opts->pending->define_head = NULL; - opts->pending->define_tail = NULL; + else + new_pending_directive (pend, arg + 1, cpp_unassert); } + else + new_pending_directive (pend, arg, cpp_assert); break; case OPT_U: - { - struct pending_option *o = (struct pending_option *) - xmalloc (sizeof (struct pending_option)); - - o->arg = arg; - o->next = NULL; - o->undef = 1; - APPEND (opts->pending, define, o); - } + new_pending_directive (pend, arg, cpp_undef); break; case OPT_I: /* Add directory to path for includes. */ if (!strcmp (arg, "-")) @@ -1578,13 +1522,13 @@ handle_option (pfile, argc, argv) Don't search the directory of the present file for #include "...". (Note that -I. -I- is not the same as the default setup; -I. uses the compiler's working dir.) */ - if (! opts->ignore_srcdir) + if (! CPP_OPTION (pfile, ignore_srcdir)) { - opts->ignore_srcdir = 1; - opts->pending->quote_head = opts->pending->brack_head; - opts->pending->quote_tail = opts->pending->brack_tail; - opts->pending->brack_head = 0; - opts->pending->brack_tail = 0; + 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 { @@ -1593,14 +1537,12 @@ handle_option (pfile, argc, argv) } } else - append_include_chain (pfile, opts->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, opts->pending, - xstrdup (arg), SYSTEM, 0); + include directory. */ + append_include_chain (pfile, xstrdup (arg), SYSTEM, 0); break; case OPT_include: { @@ -1611,8 +1553,8 @@ handle_option (pfile, argc, argv) /* This list has to be built in reverse order so that when cpp_start_read pushes all the -include files onto the buffer stack, they will be scanned in forward order. */ - o->next = opts->pending->include_head; - opts->pending->include_head = o; + o->next = pend->include_head; + pend->include_head = o; } break; case OPT_imacros: @@ -1621,8 +1563,8 @@ handle_option (pfile, argc, argv) xmalloc (sizeof (struct pending_option)); o->arg = arg; o->next = NULL; - - APPEND (opts->pending, imacros, o); + + APPEND (pend, imacros, o); } break; case OPT_iwithprefix: @@ -1635,81 +1577,78 @@ handle_option (pfile, argc, argv) { char *fname; int len; - + len = strlen (arg); - - if (opts->include_prefix != 0) + + if (CPP_OPTION (pfile, include_prefix) != 0) { - fname = xmalloc (opts->include_prefix_len + len + 1); - memcpy (fname, opts->include_prefix, opts->include_prefix_len); - memcpy (fname + opts->include_prefix_len, arg, len + 1); + size_t ipl = CPP_OPTION (pfile, include_prefix_len); + fname = xmalloc (ipl + len + 1); + memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl); + memcpy (fname + ipl, arg, len + 1); } - else + 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); } - - append_include_chain (pfile, opts->pending, fname, + 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, opts->pending, - xstrdup (arg), AFTER, 0); + append_include_chain (pfile, xstrdup (arg), AFTER, 0); break; case OPT_W: - /* Silently ignore unrecognised options */ + /* Silently ignore unrecognised options. */ if (!strcmp (argv[i], "-Wall")) { - opts->warn_trigraphs = 1; - opts->warn_comments = 1; + CPP_OPTION (pfile, warn_trigraphs) = 1; + CPP_OPTION (pfile, warn_comments) = 1; } else if (!strcmp (argv[i], "-Wtraditional")) - opts->warn_stringify = 1; + CPP_OPTION (pfile, warn_traditional) = 1; else if (!strcmp (argv[i], "-Wtrigraphs")) - opts->warn_trigraphs = 1; + CPP_OPTION (pfile, warn_trigraphs) = 1; else if (!strcmp (argv[i], "-Wcomment")) - opts->warn_comments = 1; + CPP_OPTION (pfile, warn_comments) = 1; else if (!strcmp (argv[i], "-Wcomments")) - opts->warn_comments = 1; + CPP_OPTION (pfile, warn_comments) = 1; else if (!strcmp (argv[i], "-Wundef")) - opts->warn_undef = 1; + CPP_OPTION (pfile, warn_undef) = 1; else if (!strcmp (argv[i], "-Wimport")) - opts->warn_import = 1; + CPP_OPTION (pfile, warn_import) = 1; else if (!strcmp (argv[i], "-Werror")) - opts->warnings_are_errors = 1; + CPP_OPTION (pfile, warnings_are_errors) = 1; + else if (!strcmp (argv[i], "-Wsystem-headers")) + CPP_OPTION (pfile, warn_system_headers) = 1; else if (!strcmp (argv[i], "-Wno-traditional")) - opts->warn_stringify = 0; + CPP_OPTION (pfile, warn_traditional) = 0; else if (!strcmp (argv[i], "-Wno-trigraphs")) - opts->warn_trigraphs = 0; + CPP_OPTION (pfile, warn_trigraphs) = 0; else if (!strcmp (argv[i], "-Wno-comment")) - opts->warn_comments = 0; + CPP_OPTION (pfile, warn_comments) = 0; else if (!strcmp (argv[i], "-Wno-comments")) - opts->warn_comments = 0; + CPP_OPTION (pfile, warn_comments) = 0; else if (!strcmp (argv[i], "-Wno-undef")) - opts->warn_undef = 0; + CPP_OPTION (pfile, warn_undef) = 0; else if (!strcmp (argv[i], "-Wno-import")) - opts->warn_import = 0; + CPP_OPTION (pfile, warn_import) = 0; else if (!strcmp (argv[i], "-Wno-error")) - opts->warnings_are_errors = 0; + CPP_OPTION (pfile, warnings_are_errors) = 0; + else if (!strcmp (argv[i], "-Wno-system-headers")) + CPP_OPTION (pfile, warn_system_headers) = 0; break; } } return i + 1; } -#ifdef HOST_EBCDIC -static int -opt_comp (const void *p1, const void *p2) -{ - return strcmp (((struct cl_option *)p1)->opt_text, - ((struct cl_option *)p2)->opt_text); -} -#endif - /* Handle command-line options in (argc, argv). Can be called multiple times, to handle multiple sets of options. Returns if an unrecognized option is seen. @@ -1723,30 +1662,104 @@ cpp_handle_options (pfile, argc, argv) int i; int strings_processed; -#ifdef HOST_EBCDIC - static int opts_sorted = 0; - - if (!opts_sorted) - { - opts_sorted = 1; - /* For non-ASCII hosts, the array needs to be sorted at runtime */ - qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp); - } -#endif - for (i = 0; i < argc; i += strings_processed) { - strings_processed = handle_option (pfile, argc - i, argv + i); + strings_processed = cpp_handle_option (pfile, argc - i, argv + i); if (strings_processed == 0) break; } + return i; } +/* Extra processing when all options are parsed, after all calls to + cpp_handle_option[s]. Consistency checks etc. */ +void +cpp_post_options (pfile) + cpp_reader *pfile; +{ + /* -Wtraditional is not useful in C++ mode. */ + if (CPP_OPTION (pfile, cplusplus)) + CPP_OPTION (pfile, warn_traditional) = 0; + + /* Set this if it hasn't been set already. */ + if (CPP_OPTION (pfile, user_label_prefix) == NULL) + CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX; + + /* We need to do this after option processing and before + cpp_start_read, as cppmain.c relies on the options->no_output to + set its callbacks correctly before calling cpp_start_read. */ + init_dependency_output (pfile); + + /* After checking the environment variables, check if -M or -MM has + not been specified, but other -M options have. */ + if (CPP_OPTION (pfile, print_deps) == 0 && + (CPP_OPTION (pfile, print_deps_missing_files) + || CPP_OPTION (pfile, deps_file) + || CPP_OPTION (pfile, deps_phony_targets))) + cpp_fatal (pfile, "you must additionally specify either -M or -MM"); +} + +/* Set up dependency-file output. */ +static void +init_dependency_output (pfile) + cpp_reader *pfile; +{ + char *spec, *s, *output_file; + + /* Either of two environment variables can specify output of deps. + Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET", + where OUTPUT_FILE is the file to write deps info to + and DEPS_TARGET is the target to mention in the deps. */ + + if (CPP_OPTION (pfile, print_deps) == 0) + { + spec = getenv ("DEPENDENCIES_OUTPUT"); + if (spec) + CPP_OPTION (pfile, print_deps) = 1; + else + { + spec = getenv ("SUNPRO_DEPENDENCIES"); + if (spec) + CPP_OPTION (pfile, print_deps) = 2; + else + return; + } + + /* Find the space before the DEPS_TARGET, if there is one. */ + s = strchr (spec, ' '); + if (s) + { + /* Let the caller perform MAKE quoting. */ + deps_add_target (pfile->deps, s + 1, 0); + output_file = (char *) xmalloc (s - spec + 1); + memcpy (output_file, spec, s - spec); + output_file[s - spec] = 0; + } + else + output_file = spec; + + /* Command line overrides environment variables. */ + if (CPP_OPTION (pfile, deps_file) == 0) + CPP_OPTION (pfile, deps_file) = output_file; + CPP_OPTION (pfile, print_deps_append) = 1; + } + + /* If dependencies go to standard output, or -MG is used, we should + suppress output. The user may be requesting other stuff to + stdout, with -dM, -v etc. We let them shoot themselves in the + foot. */ + if (CPP_OPTION (pfile, deps_file) == 0 + || CPP_OPTION (pfile, print_deps_missing_files)) + CPP_OPTION (pfile, no_output) = 1; +} + static void print_help () { 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 Include the contents of before other files\n\ @@ -1755,6 +1768,8 @@ Switches:\n\ -iwithprefix Add to the end of the system include path\n\ -iwithprefixbefore Add to the end of the main include path\n\ -isystem Add to the start of the system include path\n\ +"), stdout); + fputs (_("\ -idirafter Add to the end of the system include path\n\ -I Add to the end of the main include path\n\ -I- Fine-grained include path control; see info docs\n\ @@ -1762,18 +1777,21 @@ Switches:\n\ (dirs specified with -isystem will still be used)\n\ -nostdinc++ Do not search system include directories for C++\n\ -o Put output into \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= Specify the conformance standard; one of:\n\ gnu89, gnu99, c89, c99, iso9899:1990,\n\ iso9899:199409, iso9899:1999\n\ @@ -1782,34 +1800,52 @@ Switches:\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\ + -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 As -M, but put output in a .d file\n\ - -MMD As -MD, but ignore system header files\n\ + -MF Write dependency output to the given file\n\ -MG Treat missing header file as generated files\n\ - -g3 Include #define and #undef directives in the output\n\ +"), stdout); + fputs (_("\ + -MP Generate phony targets for all headers\n\ + -MQ Add a MAKE-quoted target\n\ + -MT Add an unquoted target\n\ +"), stdout); + fputs (_("\ -D Define a with string '1' as its value\n\ -D= Define a with as its value\n\ -A () Assert the to \n\ + -A- () Disable the to \n\ -U Undefine \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 (_("\ + -ftabstop= 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\