diff options
Diffstat (limited to 'contrib/gcc/cpplib.c')
| -rw-r--r-- | contrib/gcc/cpplib.c | 4168 |
1 files changed, 1363 insertions, 2805 deletions
diff --git a/contrib/gcc/cpplib.c b/contrib/gcc/cpplib.c index bcf40e1..12baa10 100644 --- a/contrib/gcc/cpplib.c +++ b/contrib/gcc/cpplib.c @@ -1,5 +1,6 @@ -/* CPP Library. - Copyright (C) 1986, 87, 89, 92-98, 1999 Free Software Foundation, Inc. +/* CPP Library. (Directive handling.) + Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, + 1999, 2000, 2001, 2002 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 @@ -23,3253 +24,1810 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "cpplib.h" #include "cpphash.h" -#include "intl.h" +#include "obstack.h" -#define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0) -#define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0) +/* Chained list of answers to an assertion. */ +struct answer +{ + struct answer *next; + unsigned int count; + cpp_token first[1]; +}; -#define PEEKN(N) (CPP_BUFFER (pfile)->rlimit - CPP_BUFFER (pfile)->cur >= (N) ? CPP_BUFFER (pfile)->cur[N] : EOF) -#define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N)) -#define GETC() CPP_BUF_GET (CPP_BUFFER (pfile)) -#define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile)) -/* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion. - (Note that it is false while we're expanding macro *arguments*.) */ -#define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL) +/* Stack of conditionals currently in progress + (including both successful and failing conditionals). */ +struct if_stack +{ + struct if_stack *next; + unsigned int line; /* Line where condition started. */ + const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */ + bool skip_elses; /* Can future #else / #elif be skipped? */ + bool was_skipping; /* If were skipping on entry. */ + int type; /* Most recent conditional, for diagnostics. */ +}; -/* Forward declarations. */ +/* Contains a registered pragma or pragma namespace. */ +typedef void (*pragma_cb) PARAMS ((cpp_reader *)); +struct pragma_entry +{ + struct pragma_entry *next; + const cpp_hashnode *pragma; /* Name and length. */ + int is_nspace; + union { + pragma_cb handler; + struct pragma_entry *space; + } u; +}; -static char *my_strerror PROTO ((int)); -static void validate_else PROTO ((cpp_reader *, char *)); -static HOST_WIDEST_INT eval_if_expression PROTO ((cpp_reader *)); +/* Values for the origin field of struct directive. KANDR directives + come from traditional (K&R) C. STDC89 directives come from the + 1989 C standard. EXTENSION directives are extensions. */ +#define KANDR 0 +#define STDC89 1 +#define EXTENSION 2 + +/* Values for the flags field of struct directive. COND indicates a + conditional; IF_COND an opening conditional. INCL means to treat + "..." and <...> as q-char and h-char sequences respectively. IN_I + means this directive should be handled even if -fpreprocessed is in + effect (these are the directives with callback hooks). */ +#define COND (1 << 0) +#define IF_COND (1 << 1) +#define INCL (1 << 2) +#define IN_I (1 << 3) + +/* Defines one #-directive, including how to handle it. */ +typedef void (*directive_handler) PARAMS ((cpp_reader *)); +typedef struct directive directive; +struct directive +{ + directive_handler handler; /* Function to handle directive. */ + const U_CHAR *name; /* Name of directive. */ + unsigned short length; /* Length of name. */ + unsigned char origin; /* Origin of directive. */ + unsigned char flags; /* Flags describing this directive. */ +}; -static void conditional_skip PROTO ((cpp_reader *, int, - enum node_type, U_CHAR *)); -static void skip_if_group PROTO ((cpp_reader *)); +/* Forward declarations. */ -static void parse_name PARAMS ((cpp_reader *, int)); -static void parse_string PARAMS ((cpp_reader *, int)); -static int parse_assertion PARAMS ((cpp_reader *)); +static void skip_rest_of_line PARAMS ((cpp_reader *)); +static void check_eol PARAMS ((cpp_reader *)); +static void start_directive PARAMS ((cpp_reader *)); +static void end_directive PARAMS ((cpp_reader *, int)); +static void directive_diagnostics + PARAMS ((cpp_reader *, const directive *, int)); +static void run_directive PARAMS ((cpp_reader *, int, + const char *, size_t)); +static const cpp_token *glue_header_name PARAMS ((cpp_reader *)); +static const cpp_token *parse_include PARAMS ((cpp_reader *)); +static void push_conditional PARAMS ((cpp_reader *, int, int, + const cpp_hashnode *)); +static unsigned int read_flag PARAMS ((cpp_reader *, unsigned int)); +static int strtoul_for_line PARAMS ((const U_CHAR *, unsigned int, + unsigned long *)); +static void do_diagnostic PARAMS ((cpp_reader *, enum error_type, int)); +static cpp_hashnode *lex_macro_node PARAMS ((cpp_reader *)); +static void do_include_common PARAMS ((cpp_reader *, enum include_type)); +static struct pragma_entry *lookup_pragma_entry + PARAMS ((struct pragma_entry *, const cpp_hashnode *pragma)); +static struct pragma_entry *insert_pragma_entry + PARAMS ((cpp_reader *, struct pragma_entry **, const cpp_hashnode *, + pragma_cb)); +static void do_pragma_once PARAMS ((cpp_reader *)); +static void do_pragma_poison PARAMS ((cpp_reader *)); +static void do_pragma_system_header PARAMS ((cpp_reader *)); +static void do_pragma_dependency PARAMS ((cpp_reader *)); +static const cpp_token *get_token_no_padding PARAMS ((cpp_reader *)); +static const cpp_token *get__Pragma_string PARAMS ((cpp_reader *)); +static void destringize_and_run PARAMS ((cpp_reader *, const cpp_string *)); +static int parse_answer PARAMS ((cpp_reader *, struct answer **, int)); +static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **, + int)); +static struct answer ** find_answer PARAMS ((cpp_hashnode *, + const struct answer *)); +static void handle_assertion PARAMS ((cpp_reader *, const char *, int)); + +/* This is the table of directive handlers. It is ordered by + frequency of occurrence; the numbers at the end are directive + counts from all the source code I have lying around (egcs and libc + CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and + pcmcia-cs-3.0.9). This is no longer important as directive lookup + is now O(1). All extensions other than #warning and #include_next + are deprecated. The name is where the extension appears to have + come from. */ + +#define DIRECTIVE_TABLE \ +D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \ +D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \ +D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \ +D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \ +D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \ +D(else, T_ELSE, KANDR, COND) /* 9863 */ \ +D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \ +D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \ +D(line, T_LINE, KANDR, IN_I) /* 2465 */ \ +D(elif, T_ELIF, STDC89, COND) /* 610 */ \ +D(error, T_ERROR, STDC89, 0) /* 475 */ \ +D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \ +D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \ +D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \ +D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \ +D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \ +D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \ +D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \ +SCCS_ENTRY /* 0 SVR4? */ + +/* #sccs is not always recognized. */ +#ifdef SCCS_DIRECTIVE +# define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0) +#else +# define SCCS_ENTRY /* nothing */ +#endif -/* External declarations. */ +/* Use the table to generate a series of prototypes, an enum for the + directive names, and an array of directive handlers. */ -extern HOST_WIDEST_INT cpp_parse_expr PARAMS ((cpp_reader *)); +/* The directive-processing functions are declared to return int + instead of void, because some old compilers have trouble with + pointers to functions returning void. */ -/* `struct directive' defines one #-directive, including how to handle it. */ +/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */ +#define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *)); +DIRECTIVE_TABLE +#undef D -struct directive { - int length; /* Length of name */ - int (*func) /* Function to handle directive */ - PARAMS ((cpp_reader *, struct directive *)); - char *name; /* Name of directive */ - enum node_type type; /* Code which describes which directive. */ +#define D(n, tag, o, f) tag, +enum +{ + DIRECTIVE_TABLE + N_DIRECTIVES }; +#undef D -/* These functions are declared to return int instead of void since they - are going to be placed in a table and some old compilers have trouble with - pointers to functions returning void. */ - -static int do_define PARAMS ((cpp_reader *, struct directive *)); -static int do_line PARAMS ((cpp_reader *, struct directive *)); -static int do_include PARAMS ((cpp_reader *, struct directive *)); -static int do_undef PARAMS ((cpp_reader *, struct directive *)); -static int do_error PARAMS ((cpp_reader *, struct directive *)); -static int do_pragma PARAMS ((cpp_reader *, struct directive *)); -static int do_ident PARAMS ((cpp_reader *, struct directive *)); -static int do_if PARAMS ((cpp_reader *, struct directive *)); -static int do_xifdef PARAMS ((cpp_reader *, struct directive *)); -static int do_else PARAMS ((cpp_reader *, struct directive *)); -static int do_elif PARAMS ((cpp_reader *, struct directive *)); -static int do_endif PARAMS ((cpp_reader *, struct directive *)); -#ifdef SCCS_DIRECTIVE -static int do_sccs PARAMS ((cpp_reader *, struct directive *)); -#endif -static int do_assert PARAMS ((cpp_reader *, struct directive *)); -static int do_unassert PARAMS ((cpp_reader *, struct directive *)); -static int do_warning PARAMS ((cpp_reader *, struct directive *)); - -#define IS_INCLUDE_DIRECTIVE_TYPE(t) \ -((int) T_INCLUDE <= (int) (t) && (int) (t) <= (int) T_IMPORT) - -/* Here is the actual list of #-directives, most-often-used first. - The initialize_builtins function assumes #define is the very first. */ - -static struct directive directive_table[] = { - { 6, do_define, "define", T_DEFINE }, - { 5, do_xifdef, "ifdef", T_IFDEF }, - { 6, do_xifdef, "ifndef", T_IFNDEF }, - { 7, do_include, "include", T_INCLUDE }, - { 12, do_include, "include_next", T_INCLUDE_NEXT }, - { 6, do_include, "import", T_IMPORT }, - { 5, do_endif, "endif", T_ENDIF }, - { 4, do_else, "else", T_ELSE }, - { 2, do_if, "if", T_IF }, - { 4, do_elif, "elif", T_ELIF }, - { 5, do_undef, "undef", T_UNDEF }, - { 5, do_error, "error", T_ERROR }, - { 7, do_warning, "warning", T_WARNING }, - { 6, do_pragma, "pragma", T_PRAGMA }, - { 4, do_line, "line", T_LINE }, - { 5, do_ident, "ident", T_IDENT }, -#ifdef SCCS_DIRECTIVE - { 4, do_sccs, "sccs", T_SCCS }, -#endif - { 6, do_assert, "assert", T_ASSERT }, - { 8, do_unassert, "unassert", T_UNASSERT }, - { -1, 0, "", T_UNUSED } +/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */ +#define D(name, t, origin, flags) \ +{ CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \ + sizeof STRINGX(name) - 1, origin, flags }, +static const directive dtable[] = +{ +DIRECTIVE_TABLE }; +#undef D +#undef DIRECTIVE_TABLE -/* Place into PFILE a quoted string representing the string SRC. - Caller must reserve enough space in pfile->token_buffer. */ +#define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF) -void -quote_string (pfile, src) +/* Skip any remaining tokens in a directive. */ +static void +skip_rest_of_line (pfile) cpp_reader *pfile; - const char *src; { - U_CHAR c; - - CPP_PUTC_Q (pfile, '\"'); - for (;;) - switch ((c = *src++)) - { - default: - if (ISPRINT (c)) - CPP_PUTC_Q (pfile, c); - else - { - sprintf ((char *)CPP_PWRITTEN (pfile), "\\%03o", c); - CPP_ADJUST_WRITTEN (pfile, 4); - } - break; + /* Discard all stacked contexts. */ + while (pfile->context != &pfile->base_context) + _cpp_pop_context (pfile); - case '\"': - case '\\': - CPP_PUTC_Q (pfile, '\\'); - CPP_PUTC_Q (pfile, c); - break; - - case '\0': - CPP_PUTC_Q (pfile, '\"'); - CPP_NUL_TERMINATE_Q (pfile); - return; - } + /* Sweep up all tokens remaining on the line. */ + if (! SEEN_EOL ()) + while (_cpp_lex_token (pfile)->type != CPP_EOF) + ; } -/* Re-allocates PFILE->token_buffer so it will hold at least N more chars. */ - -void -cpp_grow_buffer (pfile, n) +/* Ensure there are no stray tokens at the end of a directive. */ +static void +check_eol (pfile) cpp_reader *pfile; - long n; { - long old_written = CPP_WRITTEN (pfile); - pfile->token_buffer_size = n + 2 * pfile->token_buffer_size; - pfile->token_buffer = (U_CHAR *) - xrealloc(pfile->token_buffer, pfile->token_buffer_size); - CPP_SET_WRITTEN (pfile, old_written); + if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF) + cpp_pedwarn (pfile, "extra tokens at end of #%s directive", + pfile->directive->name); } -/* Process the string STR as if it appeared as the body of a #define - If STR is just an identifier, define it with value 1. - If STR has anything after the identifier, then it should - be identifier=definition. */ - -void -cpp_define (pfile, str) +/* Called when entering a directive, _Pragma or command-line directive. */ +static void +start_directive (pfile) cpp_reader *pfile; - U_CHAR *str; { - U_CHAR *buf, *p; - size_t count; + /* Setup in-directive state. */ + pfile->state.in_directive = 1; + pfile->state.save_comments = 0; - /* Copy the entire option so we can modify it. */ - count = strlen (str) + 3; - buf = (U_CHAR *) alloca (count); - memcpy (buf, str, count - 2); - /* Change the first "=" in the string to a space. If there is none, - tack " 1" on the end. */ - p = (U_CHAR *) strchr (buf, '='); - if (p) - { - *p = ' '; - count -= 2; - } - else - strcpy (&buf[count-3], " 1"); - - if (cpp_push_buffer (pfile, buf, count - 1) != NULL) - { - do_define (pfile, NULL); - cpp_pop_buffer (pfile); - } + /* Some handlers need the position of the # for diagnostics. */ + pfile->directive_line = pfile->line; } -/* Process the string STR as if it appeared as the body of a #assert. */ -void -cpp_assert (pfile, str) +/* Called when leaving a directive, _Pragma or command-line directive. */ +static void +end_directive (pfile, skip_line) cpp_reader *pfile; - U_CHAR *str; + int skip_line; { - if (cpp_push_buffer (pfile, str, strlen (str)) != NULL) + /* We don't skip for an assembler #. */ + if (skip_line) { - do_assert (pfile, NULL); - cpp_pop_buffer (pfile); + skip_rest_of_line (pfile); + if (!pfile->keep_tokens) + { + pfile->cur_run = &pfile->base_run; + pfile->cur_token = pfile->base_run.base; + } } -} - -static enum cpp_token -null_underflow (pfile) - cpp_reader *pfile ATTRIBUTE_UNUSED; -{ - return CPP_EOF; -} - -static int -null_cleanup (pbuf, pfile) - cpp_buffer *pbuf ATTRIBUTE_UNUSED; - cpp_reader *pfile ATTRIBUTE_UNUSED; -{ - return 0; + /* Restore state. */ + pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments); + pfile->state.in_directive = 0; + pfile->state.angled_headers = 0; + pfile->state.line_extension = 0; + pfile->directive = 0; } -/* Skip a comment - C, C++, or Chill style. M is the first character - of the comment marker. If this really is a comment, skip to its - end and return ' '. If we hit end-of-file before end-of-comment, - return EOF. If this is not a comment, return M (which will be - '/' or '-'). */ - -static int -skip_comment (pfile, m) +/* Output diagnostics for a directive DIR. INDENTED is non-zero if + the '#' was indented. */ +static void +directive_diagnostics (pfile, dir, indented) cpp_reader *pfile; - int m; + const directive *dir; + int indented; { - if (m == '/' && PEEKC() == '*') + if (pfile->state.line_extension) { - int c, prev_c = -1; - long line, col; - - FORWARD(1); - cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col); - for (;;) - { - c = GETC (); - if (c == EOF) - { - cpp_error_with_line (pfile, line, col, "unterminated comment"); - return EOF; - } - else if (c == '\n' || c == '\r') - /* \r cannot be a macro escape marker here. */ - CPP_BUMP_LINE (pfile); - else if (c == '/' && prev_c == '*') - return ' '; - else if (c == '*' && prev_c == '/' - && CPP_OPTIONS (pfile)->warn_comments) - cpp_warning (pfile, "`/*' within comment"); - - prev_c = c; - } + if (CPP_PEDANTIC (pfile) + && ! pfile->state.skipping) + cpp_pedwarn (pfile, "style of line directive is a GCC extension"); } - else if ((m == '/' && PEEKC() == '/' - && CPP_OPTIONS (pfile)->cplusplus_comments) - || (m == '-' && PEEKC() == '-' - && CPP_OPTIONS (pfile)->chill)) + else { - FORWARD(1); - for (;;) + /* Issue -pedantic warnings for extensions. */ + if (CPP_PEDANTIC (pfile) + && ! pfile->state.skipping + && dir->origin == EXTENSION) + cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name); + + /* Traditionally, a directive is ignored unless its # is in + column 1. Therefore in code intended to work with K+R + compilers, directives added by C89 must have their # + indented, and directives present in traditional C must not. + This is true even of directives in skipped conditional + blocks. */ + if (CPP_WTRADITIONAL (pfile)) { - int c = GETC (); - if (c == EOF) - return ' '; /* Allow // to be terminated by EOF. */ - if (c == '\n') - { - /* Don't consider final '\n' to be part of comment. */ - FORWARD(-1); - return ' '; - } - else if (c == '\r') - /* \r cannot be a macro escape marker here. */ - CPP_BUMP_LINE (pfile); + if (dir == &dtable[T_ELIF]) + cpp_warning (pfile, "suggest not using #elif in traditional C"); + else if (indented && dir->origin == KANDR) + cpp_warning (pfile, + "traditional C ignores #%s with the # indented", + dir->name); + else if (!indented && dir->origin != KANDR) + cpp_warning (pfile, + "suggest hiding #%s from traditional C with an indented #", + dir->name); } } - else - return m; } -/* Identical to skip_comment except that it copies the comment into the - token_buffer. This is used if put_out_comments. */ -static int -copy_comment (pfile, m) +/* Check if we have a known directive. INDENTED is non-zero if the + '#' of the directive was indented. This function is in this file + to save unnecessarily exporting dtable etc. to cpplex.c. Returns + non-zero if the line of tokens has been handled, zero if we should + continue processing the line. */ +int +_cpp_handle_directive (pfile, indented) cpp_reader *pfile; - int m; + int indented; { - if (m == '/' && PEEKC() == '*') - { - int c, prev_c = -1; - long line, col; - - CPP_PUTC (pfile, '/'); - CPP_PUTC (pfile, '*'); - FORWARD(1); - cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col); - for (;;) - { - c = GETC (); - if (c == EOF) - { - cpp_error_with_line (pfile, line, col, "unterminated comment"); - /* We must pretend this was a legitimate comment, so that the - output in token_buffer is not passed back tagged CPP_POP. */ - return ' '; - } - else if (c == '\r') - { - /* \r cannot be a macro escape marker here. */ - CPP_BUMP_LINE (pfile); - continue; - } + const directive *dir = 0; + const cpp_token *dname; + int skip = 1; - CPP_PUTC (pfile, c); - if (c == '\n') - { - pfile->lineno++; - CPP_BUMP_LINE (pfile); - } - else if (c == '/' && prev_c == '*') - return ' '; - else if (c == '*' && prev_c == '/' - && CPP_OPTIONS (pfile)->warn_comments) - cpp_warning (pfile, "`/*' within comment"); + start_directive (pfile); + dname = _cpp_lex_token (pfile); - prev_c = c; - } + if (dname->type == CPP_NAME) + { + if (dname->val.node->directive_index) + dir = &dtable[dname->val.node->directive_index - 1]; } - else if ((m == '/' && PEEKC() == '/' - && CPP_OPTIONS (pfile)->cplusplus_comments) - || (m == '-' && PEEKC() == '-' - && CPP_OPTIONS (pfile)->chill)) + /* We do not recognise the # followed by a number extension in + assembler code. */ + else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM) { - CPP_PUTC (pfile, m); - CPP_PUTC (pfile, m); - FORWARD(1); - for (;;) - { - int c = GETC (); - if (c == EOF) - return ' '; /* Allow line comments to be terminated by EOF. */ - else if (c == '\n') - { - /* Don't consider final '\n' to be part of comment. */ - FORWARD(-1); - return ' '; - } - else if (c == '\r') - /* \r cannot be a macro escape marker here. */ - CPP_BUMP_LINE (pfile); - - CPP_PUTC (pfile, c); - } + dir = &dtable[T_LINE]; + pfile->state.line_extension = 1; } - else - return m; -} + if (dir) + { + /* If we have a directive that is not an opening conditional, + invalidate any control macro. */ + if (! (dir->flags & IF_COND)) + pfile->mi_valid = false; -/* Skip whitespace \-newline and comments. Does not macro-expand. */ + /* Kluge alert. In order to be sure that code like this -void -cpp_skip_hspace (pfile) - cpp_reader *pfile; -{ - int c; - while (1) - { - c = GETC(); - if (c == EOF) - return; - else if (is_hor_space[c]) - { - if ((c == '\f' || c == '\v') && CPP_PEDANTIC (pfile)) - cpp_pedwarn (pfile, "%s in preprocessing directive", - c == '\f' ? "formfeed" : "vertical tab"); - } - else if (c == '\r') + #define HASH # + HASH define foo bar + + does not cause '#define foo bar' to get executed when + compiled with -save-temps, we recognize directives in + -fpreprocessed mode only if the # is in column 1. cppmacro.c + puts a space in front of any '#' at the start of a macro. */ + if (CPP_OPTION (pfile, preprocessed) + && (indented || !(dir->flags & IN_I))) { - /* \r is a backslash-newline marker if !has_escapes, and - a deletable-whitespace or no-reexpansion marker otherwise. */ - if (CPP_BUFFER (pfile)->has_escapes) - { - if (PEEKC() == ' ') - FORWARD(1); - else - break; - } - else - CPP_BUFFER (pfile)->lineno++; + skip = 0; + dir = 0; } - else if (c == '/' || c == '-') + else { - c = skip_comment (pfile, c); - if (c == EOF) - return; - else if (c != ' ') - break; + /* In failed conditional groups, all non-conditional + directives are ignored. Before doing that, whether + skipping or not, we should lex angle-bracketed headers + correctly, and maybe output some diagnostics. */ + pfile->state.angled_headers = dir->flags & INCL; + if (! CPP_OPTION (pfile, preprocessed)) + directive_diagnostics (pfile, dir, indented); + if (pfile->state.skipping && !(dir->flags & COND)) + dir = 0; } - else - break; } - FORWARD(-1); -} - -/* Read the rest of the current line. - The line is appended to PFILE's output buffer. */ - -static void -copy_rest_of_line (pfile) - cpp_reader *pfile; -{ - for (;;) + else if (dname->type == CPP_EOF) + ; /* CPP_EOF is the "null directive". */ + else { - int c = GETC(); - switch (c) - { - case '\n': - FORWARD(-1); - case EOF: - CPP_NUL_TERMINATE (pfile); - return; - - case '\r': - if (CPP_BUFFER (pfile)->has_escapes) - break; - else - { - CPP_BUFFER (pfile)->lineno++; - continue; - } - case '\'': - case '\"': - parse_string (pfile, c); - continue; - case '/': - if (PEEKC() == '*' && CPP_TRADITIONAL (pfile)) - { - CPP_PUTS (pfile, "/**/", 4); - skip_comment (pfile, c); - continue; - } - /* else fall through */ - case '-': - c = skip_comment (pfile, c); - break; - - case '\f': - case '\v': - if (CPP_PEDANTIC (pfile)) - cpp_pedwarn (pfile, "%s in preprocessing directive", - c == '\f' ? "formfeed" : "vertical tab"); - break; + /* An unknown directive. Don't complain about it in assembly + source: we don't know where the comments are, and # may + introduce assembler pseudo-ops. Don't complain about invalid + directives in skipped conditional groups (6.10 p4). */ + if (CPP_OPTION (pfile, lang) == CLK_ASM) + skip = 0; + else if (!pfile->state.skipping) + cpp_error (pfile, "invalid preprocessing directive #%s", + cpp_token_as_text (pfile, dname)); + } - } - CPP_PUTC (pfile, c); + if (dir) + { + pfile->directive = dir; + (*pfile->directive->handler) (pfile); } -} + else if (skip == 0) + _cpp_backup_tokens (pfile, 1); -/* FIXME: It is almost definitely a performance win to make this do - the scan itself. >75% of calls to copy_r_o_l are from here or - skip_if_group, which means the common case is to copy stuff into the - token_buffer only to discard it. */ -void -skip_rest_of_line (pfile) - cpp_reader *pfile; -{ - long old = CPP_WRITTEN (pfile); - copy_rest_of_line (pfile); - CPP_SET_WRITTEN (pfile, old); + end_directive (pfile, skip); + return skip; } -/* Handle a possible # directive. - '#' has already been read. */ - -static int -handle_directive (pfile) +/* Directive handler wrapper used by the command line option + processor. */ +static void +run_directive (pfile, dir_no, buf, count) + cpp_reader *pfile; + int dir_no; + const char *buf; + size_t count; +{ + cpp_push_buffer (pfile, (const U_CHAR *) buf, count, + /* from_stage3 */ true, 1); + start_directive (pfile); + /* We don't want a leading # to be interpreted as a directive. */ + pfile->buffer->saved_flags = 0; + pfile->directive = &dtable[dir_no]; + (void) (*pfile->directive->handler) (pfile); + end_directive (pfile, 1); + _cpp_pop_buffer (pfile); +} + +/* Checks for validity the macro name in #define, #undef, #ifdef and + #ifndef directives. */ +static cpp_hashnode * +lex_macro_node (pfile) cpp_reader *pfile; { - int c; - register struct directive *kt; - int ident_length; - U_CHAR *ident; - long old_written = CPP_WRITTEN (pfile); - - cpp_skip_hspace (pfile); + cpp_hashnode *node; + const cpp_token *token = _cpp_lex_token (pfile); + + /* The token immediately after #define must be an identifier. That + identifier may not be "defined", per C99 6.10.8p4. + In C++, it may not be any of the "named operators" either, + per C++98 [lex.digraph], [lex.key]. + Finally, the identifier may not have been poisoned. (In that case + the lexer has issued the error message for us.) */ + + if (token->type != CPP_NAME) + { + if (token->type == CPP_EOF) + cpp_error (pfile, "no macro name given in #%s directive", + pfile->directive->name); + else if (token->flags & NAMED_OP) + cpp_error (pfile, + "\"%s\" cannot be used as a macro name as it is an operator in C++", + NODE_NAME (token->val.node)); + else + cpp_error (pfile, "macro names must be identifiers"); - c = PEEKC (); - if (c >= '0' && c <= '9') - { - /* Handle # followed by a line number. */ - if (CPP_PEDANTIC (pfile)) - cpp_pedwarn (pfile, "`#' followed by integer"); - do_line (pfile, NULL); - return 1; + return 0; } - /* Now find the directive name. */ - CPP_PUTC (pfile, '#'); - parse_name (pfile, GETC()); - ident = pfile->token_buffer + old_written + 1; - ident_length = CPP_PWRITTEN (pfile) - ident; - if (ident_length == 0) - { - /* A line of just `#' becomes blank. */ - if (PEEKC() == '\n') - return 1; - else - return 0; - } + node = token->val.node; + if (node->flags & NODE_POISONED) + return 0; - /* - * Decode the keyword and call the appropriate expansion - * routine, after moving the input pointer up to the next line. - */ - for (kt = directive_table; ; kt++) + if (node == pfile->spec_nodes.n_defined) { - if (kt->length <= 0) - return 0; - if (kt->length == ident_length - && !strncmp (kt->name, ident, ident_length)) - break; + cpp_error (pfile, "\"%s\" cannot be used as a macro name", + NODE_NAME (node)); + return 0; } - CPP_SET_WRITTEN (pfile, old_written); - (*kt->func) (pfile, kt); - - return 1; + return node; } -/* Pass a directive through to the output file. - BUF points to the contents of the directive, as a contiguous string. - LEN is the length of the string pointed to by BUF. - KEYWORD is the keyword-table entry for the directive. */ - +/* Process a #define directive. Most work is done in cppmacro.c. */ static void -pass_thru_directive (buf, len, pfile, keyword) - U_CHAR *buf; - size_t len; - cpp_reader *pfile; - struct directive *keyword; -{ - register unsigned keyword_length = keyword->length; - - CPP_RESERVE (pfile, 1 + keyword_length + len); - CPP_PUTC_Q (pfile, '#'); - CPP_PUTS_Q (pfile, keyword->name, keyword_length); - if (len != 0 && buf[0] != ' ') - CPP_PUTC_Q (pfile, ' '); - CPP_PUTS_Q (pfile, buf, len); -} - -/* Check a purported macro name SYMNAME, and yield its length. - ASSERTION is nonzero if this is really for an assertion name. */ - -int -check_macro_name (pfile, symname, assertion) - cpp_reader *pfile; - U_CHAR *symname; - int assertion; -{ - U_CHAR *p; - int sym_length; - - for (p = symname; is_idchar[*p]; p++) - ; - sym_length = p - symname; - if (sym_length == 0 - || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"'))) - cpp_error (pfile, - assertion ? "invalid assertion name" : "invalid macro name"); - else if (!is_idstart[*symname] - || (! strncmp (symname, "defined", 7) && sym_length == 7)) { - U_CHAR *msg; /* what pain... */ - msg = (U_CHAR *) alloca (sym_length + 1); - bcopy (symname, msg, sym_length); - msg[sym_length] = 0; - cpp_error (pfile, - (assertion - ? "invalid assertion name `%s'" - : "invalid macro name `%s'"), - msg); - } - return sym_length; -} - -/* Process a #define command. -KEYWORD is the keyword-table entry for #define, -or NULL for a "predefined" macro. */ - -static int -do_define (pfile, keyword) +do_define (pfile) cpp_reader *pfile; - struct directive *keyword; { - int hashcode; - MACRODEF mdef; - HASHNODE *hp; - long here; - U_CHAR *macro, *buf, *end; - - here = CPP_WRITTEN (pfile); - copy_rest_of_line (pfile); - - /* Copy out the line so we can pop the token buffer. */ - buf = pfile->token_buffer + here; - end = CPP_PWRITTEN (pfile); - macro = alloca (end - buf + 1); - bcopy (buf, macro, end - buf + 1); - end = macro + (end - buf); - - CPP_SET_WRITTEN (pfile, here); - - mdef = create_definition (macro, end, pfile, keyword == NULL); - if (mdef.defn == 0) - return 0; - - hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE); - - if ((hp = cpp_lookup (pfile, mdef.symnam, mdef.symlen, hashcode)) != NULL) - { - int ok = 0; - /* Redefining a precompiled key is ok. */ - if (hp->type == T_PCSTRING) - ok = 1; - /* Redefining a macro is ok if the definitions are the same. */ - else if (hp->type == T_MACRO) - ok = ! compare_defs (pfile, mdef.defn, hp->value.defn); - /* Redefining a constant is ok with -D. */ - else if (hp->type == T_CONST || hp->type == T_STDC) - ok = ! CPP_OPTIONS (pfile)->done_initializing; - /* Print the warning if it's not ok. */ - if (!ok) - { - cpp_pedwarn (pfile, "`%.*s' redefined", mdef.symlen, mdef.symnam); - if (hp->type == T_MACRO) - cpp_pedwarn_with_file_and_line (pfile, hp->value.defn->file, - hp->value.defn->line, - "this is the location of the previous definition"); - } - /* Replace the old definition. */ - hp->type = T_MACRO; - hp->value.defn = mdef.defn; - } - else - cpp_install (pfile, mdef.symnam, mdef.symlen, T_MACRO, - (char *) mdef.defn, hashcode); + cpp_hashnode *node = lex_macro_node (pfile); - if (keyword) + if (node) { - if (CPP_OPTIONS (pfile)->debug_output - || CPP_OPTIONS (pfile)->dump_macros == dump_definitions) - dump_definition (pfile, mdef); - else if (CPP_OPTIONS (pfile)->dump_macros == dump_names) - pass_thru_directive (mdef.symnam, mdef.symlen, pfile, keyword); + if (_cpp_create_definition (pfile, node)) + if (pfile->cb.define) + (*pfile->cb.define) (pfile, pfile->directive_line, node); } - - return 0; } - -/* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack. - If BUFFER != NULL, then use the LENGTH characters in BUFFER - as the new input buffer. - Return the new buffer, or NULL on failure. */ - -cpp_buffer * -cpp_push_buffer (pfile, buffer, length) +/* Handle #undef. Mark the identifier NT_VOID in the hash table. */ +static void +do_undef (pfile) cpp_reader *pfile; - U_CHAR *buffer; - long length; { - cpp_buffer *buf = CPP_BUFFER (pfile); - cpp_buffer *new; - if (++pfile->buffer_stack_depth == CPP_STACK_MAX) - { - cpp_fatal (pfile, "macro or `#include' recursion too deep"); - return NULL; - } + cpp_hashnode *node = lex_macro_node (pfile); - new = (cpp_buffer *) xcalloc (sizeof (cpp_buffer), 1); + /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier + is not currently defined as a macro name. */ + if (node && node->type == NT_MACRO) + { + if (pfile->cb.undef) + (*pfile->cb.undef) (pfile, pfile->directive_line, node); - new->if_stack = pfile->if_stack; - new->cleanup = null_cleanup; - new->underflow = null_underflow; - new->buf = new->cur = buffer; - new->alimit = new->rlimit = buffer + length; - new->prev = buf; - new->mark = -1; + if (node->flags & NODE_WARN) + cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node)); - CPP_BUFFER (pfile) = new; - return new; + _cpp_free_definition (node); + } + check_eol (pfile); } -cpp_buffer * -cpp_pop_buffer (pfile) +/* Helper routine used by parse_include. Reinterpret the current line + as an h-char-sequence (< ... >); we are looking at the first token + after the <. Returns the header as a token, or NULL on failure. */ +static const cpp_token * +glue_header_name (pfile) cpp_reader *pfile; { - cpp_buffer *buf = CPP_BUFFER (pfile); - (*buf->cleanup) (buf, pfile); - CPP_BUFFER (pfile) = CPP_PREV_BUFFER (buf); - free (buf); - pfile->buffer_stack_depth--; - return CPP_BUFFER (pfile); -} + cpp_token *header = NULL; + const cpp_token *token; + unsigned char *dest; + size_t len; -/* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer. - Pop the buffer when done. */ + /* To avoid lexed tokens overwriting our glued name, we can only + allocate from the string pool once we've lexed everything. */ -void -cpp_scan_buffer (pfile) - cpp_reader *pfile; -{ - cpp_buffer *buffer = CPP_BUFFER (pfile); + dest = BUFF_FRONT (pfile->u_buff); for (;;) { - enum cpp_token token = cpp_get_token (pfile); - if (token == CPP_EOF) /* Should not happen ... */ + token = cpp_get_token (pfile); + + if (token->type == CPP_GREATER || token->type == CPP_EOF) break; - if (token == CPP_POP && CPP_BUFFER (pfile) == buffer) + + /* + 1 for terminating NUL. */ + len = cpp_token_len (token) + 1; + if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len) { - cpp_pop_buffer (pfile); - break; + size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff); + _cpp_extend_buff (pfile, &pfile->u_buff, len); + dest = BUFF_FRONT (pfile->u_buff) + len_so_far; } - } -} -/* - * Rescan a string (which may have escape marks) into pfile's buffer. - * Place the result in pfile->token_buffer. - * - * The input is copied before it is scanned, so it is safe to pass - * it something from the token_buffer that will get overwritten - * (because it follows CPP_WRITTEN). This is used by do_include. - */ - -void -cpp_expand_to_buffer (pfile, buf, length) - cpp_reader *pfile; - U_CHAR *buf; - int length; -{ - register cpp_buffer *ip; -#if 0 - cpp_buffer obuf; -#endif - U_CHAR *buf1; -#if 0 - int odepth = indepth; -#endif + if (token->flags & PREV_WHITE) + *dest++ = ' '; - if (length < 0) - { - cpp_fatal (pfile, "internal error: length < 0 in cpp_expand_to_buffer"); - return; + dest = cpp_spell_token (pfile, token, dest); } - /* Set up the input on the input stack. */ - - buf1 = (U_CHAR *) alloca (length + 1); - memcpy (buf1, buf, length); - buf1[length] = 0; - - ip = cpp_push_buffer (pfile, buf1, length); - if (ip == NULL) - return; - ip->has_escapes = 1; -#if 0 - ip->lineno = obuf.lineno = 1; -#endif - - /* Scan the input, create the output. */ - cpp_scan_buffer (pfile); - - CPP_NUL_TERMINATE (pfile); -} - -void -cpp_buf_line_and_col (pbuf, linep, colp) - register cpp_buffer *pbuf; - long *linep, *colp; -{ - if (pbuf) - { - *linep = pbuf->lineno; - if (colp) - *colp = pbuf->cur - pbuf->line_base; - } + if (token->type == CPP_EOF) + cpp_error (pfile, "missing terminating > character"); else { - *linep = 0; - if (colp) - *colp = 0; + header = _cpp_temp_token (pfile); + header->type = CPP_HEADER_NAME; + header->flags = 0; + header->val.str.len = dest - BUFF_FRONT (pfile->u_buff); + header->val.str.text = BUFF_FRONT (pfile->u_buff); + *dest++ = '\0'; + BUFF_FRONT (pfile->u_buff) = dest; } -} - -/* Return the cpp_buffer that corresponds to a file (not a macro). */ - -cpp_buffer * -cpp_file_buffer (pfile) - cpp_reader *pfile; -{ - cpp_buffer *ip = CPP_BUFFER (pfile); - for ( ; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip)) - if (ip->fname != NULL) - return ip; - return NULL; + return header; } -/* - * write out a #line command, for instance, after an #include file. - * FILE_CHANGE says whether we are entering a file, leaving, or neither. - */ - -void -output_line_command (pfile, file_change) +/* Returns the header string of #include, #include_next, #import and + #pragma dependency. Returns NULL on error. */ +static const cpp_token * +parse_include (pfile) cpp_reader *pfile; - enum file_change_code file_change; { - long line; - cpp_buffer *ip = CPP_BUFFER (pfile); - - if (ip->fname == NULL) - return; + const unsigned char *dir; + const cpp_token *header; - if (CPP_OPTIONS (pfile)->no_line_commands - || CPP_OPTIONS (pfile)->no_output) - return; - - cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, NULL); + if (pfile->directive == &dtable[T_PRAGMA]) + dir = U"pragma dependency"; + else + dir = pfile->directive->name; - /* If the current file has not changed, we omit the #line if it would - appear to be a no-op, and we output a few newlines instead - if we want to increase the line number by a small amount. - We cannot do this if pfile->lineno is zero, because that means we - haven't output any line commands yet. (The very first line command - output is a `same_file' command.) */ - if (file_change == same_file && pfile->lineno != 0) + /* Allow macro expansion. */ + header = cpp_get_token (pfile); + if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME) { - if (line == pfile->lineno) - return; - - /* If the inherited line number is a little too small, - output some newlines instead of a #line command. */ - if (line > pfile->lineno && line < pfile->lineno + 8) + if (header->type != CPP_LESS) { - CPP_RESERVE (pfile, 20); - while (line > pfile->lineno) - { - CPP_PUTC_Q (pfile, '\n'); - pfile->lineno++; - } - return; + cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir); + return NULL; } - } - CPP_RESERVE (pfile, 4 * strlen (ip->nominal_fname) + 50); - CPP_PUTS_Q (pfile, "# ", 2); - - sprintf ((char *) CPP_PWRITTEN (pfile), "%ld ", line); - CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile))); - - quote_string (pfile, ip->nominal_fname); - if (file_change != same_file) - { - CPP_PUTC_Q (pfile, ' '); - CPP_PUTC_Q (pfile, file_change == enter_file ? '1' : '2'); + header = glue_header_name (pfile); + if (header == NULL) + return header; } - /* Tell cc1 if following text comes from a system header file. */ - if (ip->system_header_p) - { - CPP_PUTC_Q (pfile, ' '); - CPP_PUTC_Q (pfile, '3'); - } -#ifndef NO_IMPLICIT_EXTERN_C - /* Tell cc1plus if following text should be treated as C. */ - if (ip->system_header_p == 2 && CPP_OPTIONS (pfile)->cplusplus) - { - CPP_PUTC_Q (pfile, ' '); - CPP_PUTC_Q (pfile, '4'); - } -#endif - CPP_PUTC_Q (pfile, '\n'); - pfile->lineno = line; -} - -/* Like cpp_get_token, except that it does not read past end-of-line. - Also, horizontal space is skipped, and macros are popped. */ - -static enum cpp_token -get_directive_token (pfile) - cpp_reader *pfile; -{ - for (;;) + if (header->val.str.len == 0) { - long old_written = CPP_WRITTEN (pfile); - enum cpp_token token; - cpp_skip_hspace (pfile); - if (PEEKC () == '\n') - return CPP_VSPACE; - token = cpp_get_token (pfile); - switch (token) - { - case CPP_POP: - if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile))) - return token; - /* ... else fall though ... */ - case CPP_HSPACE: case CPP_COMMENT: - CPP_SET_WRITTEN (pfile, old_written); - break; - default: - return token; - } + cpp_error (pfile, "empty file name in #%s", dir); + return NULL; } -} - -/* Handle #include and #import. - This function expects to see "fname" or <fname> on the input. - The input is normally in part of the output_buffer following - CPP_WRITTEN, and will get overwritten by output_line_command. - I.e. in input file specification has been popped by handle_directive. - This is safe. */ + return header; +} -static int -do_include (pfile, keyword) +/* Handle #include, #include_next and #import. */ +static void +do_include_common (pfile, type) cpp_reader *pfile; - struct directive *keyword; + enum include_type type; { - int importing = (keyword->type == T_IMPORT); - int skip_dirs = (keyword->type == T_INCLUDE_NEXT); - int angle_brackets = 0; /* 0 for "...", 1 for <...> */ - int before; /* included before? */ - long flen; - unsigned char *ftok; - cpp_buffer *fp; + const cpp_token *header; - enum cpp_token token; - - /* Chain of dirs to search */ - struct include_hash *ihash; - struct file_name_list *search_start; - - long old_written = CPP_WRITTEN (pfile); - - int fd; - - if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p) + /* For #include_next, if this is the primary source file, warn and + use the normal search logic. */ + if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev) { - if (importing) - cpp_pedwarn (pfile, "ANSI C does not allow `#import'"); - if (skip_dirs) - cpp_pedwarn (pfile, "ANSI C does not allow `#include_next'"); + cpp_warning (pfile, "#include_next in primary source file"); + type = IT_INCLUDE; } - - if (importing && CPP_OPTIONS (pfile)->warn_import - && !CPP_OPTIONS (pfile)->inhibit_warnings - && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning) + else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import)) { - pfile->import_warning = 1; + CPP_OPTION (pfile, warn_import) = 0; cpp_warning (pfile, "#import is obsolete, use an #ifndef wrapper in the header file"); } - pfile->parsing_include_directive++; - token = get_directive_token (pfile); - pfile->parsing_include_directive--; - - if (token == CPP_STRING) - { - if (pfile->token_buffer[old_written] == '<') - angle_brackets = 1; - } -#ifdef VMS - else if (token == CPP_NAME) - { - /* Support '#include xyz' like VAX-C. It is taken as - '#include <xyz.h>' and generates a warning. */ - cpp_warning (pfile, - "`#include filename' is obsolete, use `#include <filename.h>'"); - angle_brackets = 1; - - /* Append the missing `.h' to the name. */ - CPP_PUTS (pfile, ".h", 2); - } -#endif - else - { - cpp_error (pfile, - "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name); - CPP_SET_WRITTEN (pfile, old_written); - skip_rest_of_line (pfile); - return 0; - } - - flen = CPP_WRITTEN (pfile) - old_written; - ftok = alloca (flen + 1); - memcpy (ftok, pfile->token_buffer + old_written, flen); - ftok[flen] = '\0'; - - if (get_directive_token (pfile) != CPP_VSPACE) - { - cpp_error (pfile, "junk at end of `#include'"); - skip_rest_of_line (pfile); - } - - CPP_SET_WRITTEN (pfile, old_written); - - if (flen == 0) + header = parse_include (pfile); + if (header) { - cpp_error (pfile, "empty file name in `#%s'", keyword->name); - return 0; - } - - if (CPP_OPTIONS (pfile)->dump_includes) - pass_thru_directive (ftok, - flen -#ifdef VMS - - ((token == CPP_NAME) ? 2 : 0) -#endif - , pfile, keyword); - -#ifdef VMS - if (token == CPP_STRING) -#endif - { - ftok++; - flen -= 2; - ftok[flen] = '\0'; - } - - search_start = 0; - - for (fp = CPP_BUFFER (pfile); - fp != CPP_NULL_BUFFER (pfile); - fp = CPP_PREV_BUFFER (fp)) - if (fp->fname != NULL) - break; - - if (fp == CPP_NULL_BUFFER (pfile)) - { - cpp_fatal (pfile, "cpp internal error: fp == NULL_BUFFER in do_include"); - return 0; - } - - /* For #include_next, skip in the search path past the dir in which the - containing file was found. Treat files specified using an absolute path - as if there are no more directories to search. Treat the primary source - file like any other included source, but generate a warning. */ - if (skip_dirs && CPP_PREV_BUFFER(fp) != CPP_NULL_BUFFER (pfile)) - { - if (fp->ihash->foundhere != ABSOLUTE_PATH) - search_start = fp->ihash->foundhere->next; - } - else - { - if (skip_dirs) - cpp_warning (pfile, "#include_next in primary source file"); - - if (angle_brackets) - search_start = CPP_OPTIONS (pfile)->bracket_include; + /* Prevent #include recursion. */ + if (pfile->line_maps.depth >= CPP_STACK_MAX) + cpp_fatal (pfile, "#include nested too deeply"); else - { - if (!CPP_OPTIONS (pfile)->ignore_srcdir) - { - if (fp) - search_start = fp->actual_dir; - } - else - search_start = CPP_OPTIONS (pfile)->quote_include; + { + check_eol (pfile); + /* Get out of macro context, if we are. */ + skip_rest_of_line (pfile); + if (pfile->cb.include) + (*pfile->cb.include) (pfile, pfile->directive_line, + pfile->directive->name, header); + + _cpp_execute_include (pfile, header, type); } } +} - if (!search_start) - { - cpp_error (pfile, "No include path in which to find %s", ftok); - return 0; - } - - fd = find_include_file (pfile, ftok, search_start, &ihash, &before); +static void +do_include (pfile) + cpp_reader *pfile; +{ + do_include_common (pfile, IT_INCLUDE); +} - if (fd == -2) - return 0; - - if (fd == -1) - { - if (CPP_OPTIONS (pfile)->print_deps_missing_files - && CPP_PRINT_DEPS (pfile) > (angle_brackets || - (pfile->system_include_depth > 0))) - { - if (!angle_brackets) - deps_output (pfile, ftok, ' '); - else - { - char *p; - struct file_name_list *ptr; - /* If requested as a system header, assume it belongs in - the first system header directory. */ - if (CPP_OPTIONS (pfile)->bracket_include) - ptr = CPP_OPTIONS (pfile)->bracket_include; - else - ptr = CPP_OPTIONS (pfile)->quote_include; - - p = (char *) alloca (strlen (ptr->name) - + strlen (ftok) + 2); - if (*ptr->name != '\0') - { - strcpy (p, ptr->name); - strcat (p, "/"); - } - strcat (p, ftok); - deps_output (pfile, p, ' '); - } - } - /* If -M was specified, and this header file won't be added to - the dependency list, then don't count this as an error, - because we can still produce correct output. Otherwise, we - can't produce correct output, because there may be - dependencies we need inside the missing file, and we don't - know what directory this missing file exists in. */ - else if (CPP_PRINT_DEPS (pfile) - && (CPP_PRINT_DEPS (pfile) - <= (angle_brackets || (pfile->system_include_depth > 0)))) - cpp_warning (pfile, "No include path in which to find %s", ftok); - else - cpp_error_from_errno (pfile, ftok); +static void +do_import (pfile) + cpp_reader *pfile; +{ + do_include_common (pfile, IT_IMPORT); +} - return 0; - } +static void +do_include_next (pfile) + cpp_reader *pfile; +{ + do_include_common (pfile, IT_INCLUDE_NEXT); +} - /* For -M, add the file to the dependencies on its first inclusion. */ - if (!before && (CPP_PRINT_DEPS (pfile) - > (angle_brackets || (pfile->system_include_depth > 0)))) - deps_output (pfile, ihash->name, ' '); +/* Subroutine of do_line. Read possible flags after file name. LAST + is the last flag seen; 0 if this is the first flag. Return the flag + if it is valid, 0 at the end of the directive. Otherwise complain. */ +static unsigned int +read_flag (pfile, last) + cpp_reader *pfile; + unsigned int last; +{ + const cpp_token *token = _cpp_lex_token (pfile); - /* Handle -H option. */ - if (CPP_OPTIONS(pfile)->print_include_names) + if (token->type == CPP_NUMBER && token->val.str.len == 1) { - fp = CPP_BUFFER (pfile); - while ((fp = CPP_PREV_BUFFER (fp)) != CPP_NULL_BUFFER (pfile)) - putc ('.', stderr); - fprintf (stderr, " %s\n", ihash->name); - } + unsigned int flag = token->val.str.text[0] - '0'; - /* Actually process the file */ - - if (importing) - ihash->control_macro = ""; - - if (cpp_push_buffer (pfile, NULL, 0) == NULL) - { - close (fd); - return 0; + if (flag > last && flag <= 4 + && (flag != 4 || last == 3) + && (flag != 2 || last == 0)) + return flag; } - - if (angle_brackets) - pfile->system_include_depth++; /* Decremented in file_cleanup. */ - if (finclude (pfile, fd, ihash)) + if (token->type != CPP_EOF) + cpp_error (pfile, "invalid flag \"%s\" in line directive", + cpp_token_as_text (pfile, token)); + return 0; +} + +/* Another subroutine of do_line. Convert a number in STR, of length + LEN, to binary; store it in NUMP, and return 0 if the number was + well-formed, 1 if not. Temporary, hopefully. */ +static int +strtoul_for_line (str, len, nump) + const U_CHAR *str; + unsigned int len; + unsigned long *nump; +{ + unsigned long reg = 0; + U_CHAR c; + while (len--) { - output_line_command (pfile, enter_file); - pfile->only_seen_white = 2; + c = *str++; + if (!ISDIGIT (c)) + return 1; + reg *= 10; + reg += c - '0'; } - + *nump = reg; return 0; } /* Interpret #line command. Note that the filename string (if any) is treated as if it were an include filename. That means no escape handling. */ - -static int -do_line (pfile, keyword) +static void +do_line (pfile) cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; { - cpp_buffer *ip = CPP_BUFFER (pfile); - int new_lineno; - long old_written = CPP_WRITTEN (pfile); - enum file_change_code file_change = same_file; - enum cpp_token token; - char *x; + const cpp_token *token; + const char *new_file = pfile->map->to_file; + unsigned long new_lineno; + unsigned int cap, new_sysp = pfile->map->sysp; + enum lc_reason reason = LC_RENAME; - token = get_directive_token (pfile); + /* C99 raised the minimum limit on #line numbers. */ + cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767; - if (token != CPP_NUMBER) - { - cpp_error (pfile, "token after `#line' is not an integer"); - goto bad_line_directive; - } + /* Putting this in _cpp_handle_directive risks two calls to + _cpp_backup_tokens in some circumstances, which can segfault. */ + if (pfile->state.line_extension) + _cpp_backup_tokens (pfile, 1); - new_lineno = strtol (pfile->token_buffer + old_written, &x, 10); - if (x[0] != '\0') + /* #line commands expand macros. */ + token = cpp_get_token (pfile); + if (token->type != CPP_NUMBER + || strtoul_for_line (token->val.str.text, token->val.str.len, + &new_lineno)) { - cpp_error (pfile, "token after `#line' is not an integer"); - goto bad_line_directive; + cpp_error (pfile, "\"%s\" after #line is not a positive integer", + cpp_token_as_text (pfile, token)); + return; } - CPP_SET_WRITTEN (pfile, old_written); - - if (CPP_PEDANTIC (pfile) && new_lineno <= 0) - cpp_pedwarn (pfile, "line number out of range in `#line' command"); - token = get_directive_token (pfile); + if (CPP_PEDANTIC (pfile) && ! pfile->state.line_extension + && (new_lineno == 0 || new_lineno > cap)) + cpp_pedwarn (pfile, "line number out of range"); - if (token == CPP_STRING) + token = cpp_get_token (pfile); + if (token->type == CPP_STRING) { - U_CHAR *fname = pfile->token_buffer + old_written + 1; - U_CHAR *end_name = CPP_PWRITTEN (pfile) - 1; - long num_start = CPP_WRITTEN (pfile); + new_file = (const char *) token->val.str.text; - token = get_directive_token (pfile); - if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP) + /* Only accept flags for the # 55 form. */ + if (pfile->state.line_extension) { - U_CHAR *p = pfile->token_buffer + num_start; - if (CPP_PEDANTIC (pfile)) - cpp_pedwarn (pfile, "garbage at end of `#line' command"); + int flag; - if (token != CPP_NUMBER || *p < '0' || *p > '4' || p[1] != '\0') + new_sysp = 0; + flag = read_flag (pfile, 0); + if (flag == 1) { - cpp_error (pfile, "invalid format `#line' command"); - goto bad_line_directive; + reason = LC_ENTER; + /* Fake an include for cpp_included (). */ + _cpp_fake_include (pfile, new_file); + flag = read_flag (pfile, flag); } - if (*p == '1') - file_change = enter_file; - else if (*p == '2') - file_change = leave_file; - else if (*p == '3') - ip->system_header_p = 1; - else /* if (*p == '4') */ - ip->system_header_p = 2; - - CPP_SET_WRITTEN (pfile, num_start); - token = get_directive_token (pfile); - p = pfile->token_buffer + num_start; - if (token == CPP_NUMBER && p[1] == '\0' && (*p == '3' || *p== '4')) + else if (flag == 2) { - ip->system_header_p = *p == '3' ? 1 : 2; - token = get_directive_token (pfile); + reason = LC_LEAVE; + flag = read_flag (pfile, flag); } - if (token != CPP_VSPACE) + if (flag == 3) { - cpp_error (pfile, "invalid format `#line' command"); - goto bad_line_directive; + new_sysp = 1; + flag = read_flag (pfile, flag); + if (flag == 4) + new_sysp = 2; } } - - *end_name = '\0'; - - if (strcmp (fname, ip->nominal_fname)) - { - char *newname, *oldname; - if (!strcmp (fname, ip->fname)) - newname = ip->fname; - else if (ip->last_nominal_fname - && !strcmp (fname, ip->last_nominal_fname)) - newname = ip->last_nominal_fname; - else - newname = xstrdup (fname); - - oldname = ip->nominal_fname; - ip->nominal_fname = newname; - - if (ip->last_nominal_fname - && ip->last_nominal_fname != oldname - && ip->last_nominal_fname != newname - && ip->last_nominal_fname != ip->fname) - free (ip->last_nominal_fname); - - if (newname == ip->fname) - ip->last_nominal_fname = NULL; - else - ip->last_nominal_fname = oldname; - } + check_eol (pfile); } - else if (token != CPP_VSPACE && token != CPP_EOF) + else if (token->type != CPP_EOF) { - cpp_error (pfile, "token after `#line %d' is not a string", new_lineno); - goto bad_line_directive; + cpp_error (pfile, "\"%s\" is not a valid filename", + cpp_token_as_text (pfile, token)); + return; } - /* The Newline at the end of this line remains to be processed. - To put the next line at the specified line number, - we must store a line number now that is one less. */ - ip->lineno = new_lineno - 1; - CPP_SET_WRITTEN (pfile, old_written); - output_line_command (pfile, file_change); - return 0; - - bad_line_directive: skip_rest_of_line (pfile); - CPP_SET_WRITTEN (pfile, old_written); - return 0; + _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp); } -/* Remove the definition of a symbol from the symbol table. - According to the C standard, it is not an error to undef - something that has no definitions. */ -static int -do_undef (pfile, keyword) +/* Arrange the file_change callback. pfile->line has changed to + FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system + header, 2 for a system header that needs to be extern "C" protected, + and zero otherwise. */ +void +_cpp_do_file_change (pfile, reason, to_file, file_line, sysp) cpp_reader *pfile; - struct directive *keyword; -{ - int sym_length; - HASHNODE *hp; - U_CHAR *buf, *name, *limit; - int c; - long here = CPP_WRITTEN (pfile); - enum cpp_token token; - - cpp_skip_hspace (pfile); - c = GETC(); - if (! is_idstart[c]) - { - cpp_error (pfile, "token after #undef is not an identifier"); - skip_rest_of_line (pfile); - return 1; - } - - parse_name (pfile, c); - buf = pfile->token_buffer + here; - limit = CPP_PWRITTEN(pfile); - - /* Copy out the token so we can pop the token buffer. */ - name = alloca (limit - buf + 1); - bcopy(buf, name, limit - buf); - name[limit - buf] = '\0'; - - token = get_directive_token (pfile); - if (token != CPP_VSPACE && token != CPP_POP) - { - cpp_pedwarn (pfile, "junk on line after #undef"); - skip_rest_of_line (pfile); - } - - CPP_SET_WRITTEN (pfile, here); - - sym_length = check_macro_name (pfile, buf, 0); - - while ((hp = cpp_lookup (pfile, name, sym_length, -1)) != NULL) - { - /* If we are generating additional info for debugging (with -g) we - need to pass through all effective #undef commands. */ - if (CPP_OPTIONS (pfile)->debug_output && keyword) - pass_thru_directive (name, sym_length, pfile, keyword); - if (hp->type != T_MACRO) - cpp_warning (pfile, "undefining `%s'", hp->name); - delete_macro (hp); - } + enum lc_reason reason; + const char *to_file; + unsigned int file_line; + unsigned int sysp; +{ + pfile->map = add_line_map (&pfile->line_maps, reason, sysp, + pfile->line, to_file, file_line); - return 0; + if (pfile->cb.file_change) + (*pfile->cb.file_change) (pfile, pfile->map); } -/* Wrap do_undef for -U processing. */ -void -cpp_undef (pfile, macro) +/* Report a warning or error detected by the program we are + processing. Use the directive's tokens in the error message. */ +static void +do_diagnostic (pfile, code, print_dir) cpp_reader *pfile; - U_CHAR *macro; + enum error_type code; + int print_dir; { - if (cpp_push_buffer (pfile, macro, strlen (macro))) + if (_cpp_begin_message (pfile, code, 0, 0)) { - do_undef (pfile, NULL); - cpp_pop_buffer (pfile); + if (print_dir) + fprintf (stderr, "#%s ", pfile->directive->name); + pfile->state.prevent_expansion++; + cpp_output_line (pfile, stderr); + pfile->state.prevent_expansion--; } } - -/* - * Report an error detected by the program we are processing. - * Use the text of the line in the error message. - * (We use error because it prints the filename & line#.) - */ - -static int -do_error (pfile, keyword) +static void +do_error (pfile) cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; { - long here = CPP_WRITTEN (pfile); - U_CHAR *text; - copy_rest_of_line (pfile); - text = pfile->token_buffer + here; - SKIP_WHITE_SPACE(text); - - cpp_error (pfile, "#error %s", text); - CPP_SET_WRITTEN (pfile, here); - return 0; + do_diagnostic (pfile, ERROR, 1); } -/* - * Report a warning detected by the program we are processing. - * Use the text of the line in the warning message, then continue. - */ - -static int -do_warning (pfile, keyword) +static void +do_warning (pfile) cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; { - U_CHAR *text; - long here = CPP_WRITTEN(pfile); - copy_rest_of_line (pfile); - text = pfile->token_buffer + here; - SKIP_WHITE_SPACE(text); - - if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p) - cpp_pedwarn (pfile, "ANSI C does not allow `#warning'"); - - /* Use `pedwarn' not `warning', because #warning isn't in the C Standard; - if -pedantic-errors is given, #warning should cause an error. */ - cpp_pedwarn (pfile, "#warning %s", text); - CPP_SET_WRITTEN (pfile, here); - return 0; + /* We want #warning diagnostics to be emitted in system headers too. */ + do_diagnostic (pfile, WARNING_SYSHDR, 1); } -/* Report program identification. - This is not precisely what cccp does with #ident, however I believe - it matches `closely enough' (behavior is identical as long as there - are no macros on the #ident line, which is pathological in my opinion). */ - -static int -do_ident (pfile, keyword) +/* Report program identification. */ +static void +do_ident (pfile) cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; { - /* Allow #ident in system headers, since that's not user's fault. */ - if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p) - cpp_pedwarn (pfile, "ANSI C does not allow `#ident'"); + const cpp_token *str = cpp_get_token (pfile); - CPP_PUTS (pfile, "#ident ", 7); - cpp_skip_hspace (pfile); - copy_rest_of_line (pfile); + if (str->type != CPP_STRING) + cpp_error (pfile, "invalid #ident directive"); + else if (pfile->cb.ident) + (*pfile->cb.ident) (pfile, pfile->directive_line, &str->val.str); - return 0; + check_eol (pfile); } -/* Just check for some recognized pragmas that need validation here, - and leave the text in the token buffer to be output. */ +/* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the + matching entry, or NULL if none is found. The returned entry could + be the start of a namespace chain, or a pragma. */ +static struct pragma_entry * +lookup_pragma_entry (chain, pragma) + struct pragma_entry *chain; + const cpp_hashnode *pragma; +{ + while (chain && chain->pragma != pragma) + chain = chain->next; -static int -do_pragma (pfile, keyword) + return chain; +} + +/* Create and insert a pragma entry for NAME at the beginning of a + singly-linked CHAIN. If handler is NULL, it is a namespace, + otherwise it is a pragma and its handler. */ +static struct pragma_entry * +insert_pragma_entry (pfile, chain, pragma, handler) cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; + struct pragma_entry **chain; + const cpp_hashnode *pragma; + pragma_cb handler; { - long here; - U_CHAR *buf; + struct pragma_entry *new; - CPP_PUTS (pfile, "#pragma ", 8); - cpp_skip_hspace (pfile); - - here = CPP_WRITTEN (pfile); - copy_rest_of_line (pfile); - buf = pfile->token_buffer + here; - - if (!strncmp (buf, "once", 4)) + new = (struct pragma_entry *) + _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry)); + new->pragma = pragma; + if (handler) { - cpp_buffer *ip = NULL; - - /* Allow #pragma once in system headers, since that's not the user's - fault. */ - if (!CPP_BUFFER (pfile)->system_header_p) - cpp_warning (pfile, "`#pragma once' is obsolete"); - - for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip)) - { - if (ip == CPP_NULL_BUFFER (pfile)) - return 0; - if (ip->fname != NULL) - break; - } - - if (CPP_PREV_BUFFER (ip) == CPP_NULL_BUFFER (pfile)) - cpp_warning (pfile, "`#pragma once' outside include file"); - else - ip->ihash->control_macro = ""; /* never repeat */ + new->is_nspace = 0; + new->u.handler = handler; } - else if (!strncmp (buf, "implementation", 14)) + else { - /* Be quiet about `#pragma implementation' for a file only if it hasn't - been included yet. */ - struct include_hash *ptr; - U_CHAR *p = buf + 14, *fname, *fcopy; - SKIP_WHITE_SPACE (p); - if (*p == '\n' || *p != '\"') - return 0; - - fname = p + 1; - p = (U_CHAR *) index (fname, '\"'); - - fcopy = alloca (p - fname + 1); - bcopy (fname, fcopy, p - fname); - fcopy[p-fname] = '\0'; - - ptr = include_hash (pfile, fcopy, 0); - if (ptr) - cpp_warning (pfile, - "`#pragma implementation' for `%s' appears after file is included", - fcopy); + new->is_nspace = 1; + new->u.space = NULL; } - return 0; + new->next = *chain; + *chain = new; + return new; } -#ifdef SCCS_DIRECTIVE -/* Just ignore #sccs, on systems where we define it at all. */ - -static int -do_sccs (pfile, keyword) +/* Register a pragma NAME in namespace SPACE. If SPACE is null, it + goes in the global namespace. HANDLER is the handler it will call, + which must be non-NULL. */ +void +cpp_register_pragma (pfile, space, name, handler) cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; -{ - if (CPP_PEDANTIC (pfile)) - cpp_pedwarn (pfile, "ANSI C does not allow `#sccs'"); - skip_rest_of_line (pfile); - return 0; + const char *space; + const char *name; + pragma_cb handler; +{ + struct pragma_entry **chain = &pfile->pragmas; + struct pragma_entry *entry; + const cpp_hashnode *node; + + if (!handler) + abort (); + + if (space) + { + node = cpp_lookup (pfile, U space, strlen (space)); + entry = lookup_pragma_entry (*chain, node); + if (!entry) + entry = insert_pragma_entry (pfile, chain, node, NULL); + else if (!entry->is_nspace) + goto clash; + chain = &entry->u.space; + } + + /* Check for duplicates. */ + node = cpp_lookup (pfile, U name, strlen (name)); + entry = lookup_pragma_entry (*chain, node); + if (entry) + { + if (entry->is_nspace) + clash: + cpp_ice (pfile, + "registering \"%s\" as both a pragma and a pragma namespace", + NODE_NAME (node)); + else if (space) + cpp_ice (pfile, "#pragma %s %s is already registered", space, name); + else + cpp_ice (pfile, "#pragma %s is already registered", name); + } + else + insert_pragma_entry (pfile, chain, node, handler); } -#endif - -/* - * handle #if command by - * 1) inserting special `defined' keyword into the hash table - * that gets turned into 0 or 1 by special_symbol (thus, - * if the luser has a symbol called `defined' already, it won't - * work inside the #if command) - * 2) rescan the input into a temporary output buffer - * 3) pass the output buffer to the yacc parser and collect a value - * 4) clean up the mess left from steps 1 and 2. - * 5) call conditional_skip to skip til the next #endif (etc.), - * or not, depending on the value from step 3. - */ -static int -do_if (pfile, keyword) +/* Register the pragmas the preprocessor itself handles. */ +void +_cpp_init_internal_pragmas (pfile) cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; { - HOST_WIDEST_INT value = eval_if_expression (pfile); - conditional_skip (pfile, value == 0, T_IF, NULL_PTR); - return 0; -} + /* Pragmas in the global namespace. */ + cpp_register_pragma (pfile, 0, "poison", do_pragma_poison); + cpp_register_pragma (pfile, 0, "once", do_pragma_once); -/* - * handle a #elif directive by not changing if_stack either. - * see the comment above do_else. - */ - -static int -do_elif (pfile, keyword) - cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; -{ - if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) { - cpp_error (pfile, "`#elif' not within a conditional"); - return 0; - } else { - if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) { - cpp_error (pfile, "`#elif' after `#else'"); -#if 0 - fprintf (stderr, " (matches line %d", pfile->if_stack->lineno); -#endif - if (pfile->if_stack->fname != NULL && CPP_BUFFER (pfile)->fname != NULL - && strcmp (pfile->if_stack->fname, - CPP_BUFFER (pfile)->nominal_fname) != 0) - fprintf (stderr, ", file %s", pfile->if_stack->fname); - fprintf (stderr, ")\n"); - } - pfile->if_stack->type = T_ELIF; - } - - if (pfile->if_stack->if_succeeded) - skip_if_group (pfile); - else { - HOST_WIDEST_INT value = eval_if_expression (pfile); - if (value == 0) - skip_if_group (pfile); - else { - ++pfile->if_stack->if_succeeded; /* continue processing input */ - output_line_command (pfile, same_file); - } - } - return 0; + /* New GCC-specific pragmas should be put in the GCC namespace. */ + cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison); + cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header); + cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency); } -/* - * evaluate a #if expression in BUF, of length LENGTH, - * then parse the result as a C expression and return the value as an int. - */ - -static HOST_WIDEST_INT -eval_if_expression (pfile) +/* Pragmata handling. We handle some, and pass the rest on to the + front end. C99 defines three pragmas and says that no macro + expansion is to be performed on them; whether or not macro + expansion happens for other pragmas is implementation defined. + This implementation never macro-expands the text after #pragma. */ +static void +do_pragma (pfile) cpp_reader *pfile; { - HOST_WIDEST_INT value; - long old_written = CPP_WRITTEN (pfile); - - pfile->pcp_inside_if = 1; - value = cpp_parse_expr (pfile); - pfile->pcp_inside_if = 0; + const struct pragma_entry *p = NULL; + const cpp_token *token; + unsigned int count = 1; - CPP_SET_WRITTEN (pfile, old_written); /* Pop */ + pfile->state.prevent_expansion++; - return value; -} - -/* - * routine to handle ifdef/ifndef. Try to look up the symbol, - * then do or don't skip to the #endif/#else/#elif depending - * on what directive is actually being processed. - */ - -static int -do_xifdef (pfile, keyword) - cpp_reader *pfile; - struct directive *keyword; -{ - int skip; - cpp_buffer *ip = CPP_BUFFER (pfile); - U_CHAR *ident; - int ident_length; - enum cpp_token token; - int start_of_file = 0; - U_CHAR *control_macro = 0; - int old_written = CPP_WRITTEN (pfile); - - /* Detect a #ifndef at start of file (not counting comments). */ - if (ip->fname != 0 && keyword->type == T_IFNDEF) - start_of_file = pfile->only_seen_white == 2; - - pfile->no_macro_expand++; - token = get_directive_token (pfile); - pfile->no_macro_expand--; - - ident = pfile->token_buffer + old_written; - ident_length = CPP_WRITTEN (pfile) - old_written; - CPP_SET_WRITTEN (pfile, old_written); /* Pop */ - - if (token == CPP_VSPACE || token == CPP_POP || token == CPP_EOF) - { - skip = (keyword->type == T_IFDEF); - if (! CPP_TRADITIONAL (pfile)) - cpp_pedwarn (pfile, "`#%s' with no argument", keyword->name); - } - else if (token == CPP_NAME) + token = cpp_get_token (pfile); + if (token->type == CPP_NAME) { - HASHNODE *hp = cpp_lookup (pfile, ident, ident_length, -1); - skip = (hp == NULL) ^ (keyword->type == T_IFNDEF); - if (start_of_file && !skip) + p = lookup_pragma_entry (pfile->pragmas, token->val.node); + if (p && p->is_nspace) { - control_macro = (U_CHAR *) xmalloc (ident_length + 1); - bcopy (ident, control_macro, ident_length + 1); + count = 2; + token = cpp_get_token (pfile); + if (token->type == CPP_NAME) + p = lookup_pragma_entry (p->u.space, token->val.node); + else + p = NULL; } } - else - { - skip = (keyword->type == T_IFDEF); - if (! CPP_TRADITIONAL (pfile)) - cpp_error (pfile, "`#%s' with invalid argument", keyword->name); - } - if (!CPP_TRADITIONAL (pfile)) - { int c; - cpp_skip_hspace (pfile); - c = PEEKC (); - if (c != EOF && c != '\n') - cpp_pedwarn (pfile, "garbage at end of `#%s' argument", keyword->name); - } - skip_rest_of_line (pfile); + /* FIXME. This is an awful kludge to get the front ends to update + their notion of line number for diagnostic purposes. The line + number should be passed to the handler and they should do it + themselves. Stand-alone CPP must ignore us, otherwise it will + prefix the directive with spaces, hence the 1. Ugh. */ + if (pfile->cb.line_change) + (*pfile->cb.line_change)(pfile, token, 1); -#if 0 - if (pcp_outfile) { - /* Output a precondition for this macro. */ - if (hp && hp->value.defn->predefined) - fprintf (pcp_outfile, "#define %s\n", hp->name); - else { - U_CHAR *cp = buf; - fprintf (pcp_outfile, "#undef "); - while (is_idchar[*cp]) /* Ick! */ - fputc (*cp++, pcp_outfile); - putc ('\n', pcp_outfile); - } -#endif + if (p) + (*p->u.handler) (pfile); + else if (pfile->cb.def_pragma) + { + _cpp_backup_tokens (pfile, count); + (*pfile->cb.def_pragma) (pfile, pfile->directive_line); + } - conditional_skip (pfile, skip, T_IF, control_macro); - return 0; + pfile->state.prevent_expansion--; } -/* Push TYPE on stack; then, if SKIP is nonzero, skip ahead. - If this is a #ifndef starting at the beginning of a file, - CONTROL_MACRO is the macro name tested by the #ifndef. - Otherwise, CONTROL_MACRO is 0. */ - +/* Handle #pragma once. */ static void -conditional_skip (pfile, skip, type, control_macro) +do_pragma_once (pfile) cpp_reader *pfile; - int skip; - enum node_type type; - U_CHAR *control_macro; { - IF_STACK_FRAME *temp; - - temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME)); - temp->fname = CPP_BUFFER (pfile)->nominal_fname; -#if 0 - temp->lineno = CPP_BUFFER (pfile)->lineno; -#endif - temp->next = pfile->if_stack; - temp->control_macro = control_macro; - pfile->if_stack = temp; - - pfile->if_stack->type = type; + cpp_warning (pfile, "#pragma once is obsolete"); + + if (pfile->buffer->prev == NULL) + cpp_warning (pfile, "#pragma once in main file"); + else + _cpp_never_reread (pfile->buffer->inc); - if (skip != 0) { - skip_if_group (pfile); - return; - } else { - ++pfile->if_stack->if_succeeded; - output_line_command (pfile, same_file); - } + check_eol (pfile); } -/* Subroutine of skip_if_group. Examine one preprocessing directive and - return 0 if skipping should continue, 1 if it should halt. Also - adjusts the if_stack as appropriate. - The `#' has been read, but not the identifier. */ +/* Handle #pragma poison, to poison one or more identifiers so that + the lexer produces a hard error for each subsequent usage. */ +static void +do_pragma_poison (pfile) + cpp_reader *pfile; +{ + const cpp_token *tok; + cpp_hashnode *hp; -static int -consider_directive_while_skipping (pfile, stack) - cpp_reader *pfile; - IF_STACK_FRAME *stack; -{ - long ident_len, ident; - struct directive *kt; - IF_STACK_FRAME *temp; - - cpp_skip_hspace (pfile); - - ident = CPP_WRITTEN (pfile); - parse_name (pfile, GETC()); - ident_len = CPP_WRITTEN (pfile) - ident; - - CPP_SET_WRITTEN (pfile, ident); - - for (kt = directive_table; kt->length >= 0; kt++) - if (kt->length == ident_len - && strncmp (pfile->token_buffer + ident, kt->name, kt->length) == 0) - switch (kt->type) + pfile->state.poisoned_ok = 1; + for (;;) + { + tok = _cpp_lex_token (pfile); + if (tok->type == CPP_EOF) + break; + if (tok->type != CPP_NAME) { - case T_IF: - case T_IFDEF: - case T_IFNDEF: - temp = (IF_STACK_FRAME *) xmalloc (sizeof (IF_STACK_FRAME)); - temp->next = pfile->if_stack; - pfile->if_stack = temp; - temp->fname = CPP_BUFFER(pfile)->nominal_fname; - temp->type = kt->type; - return 0; - - case T_ELSE: - if (CPP_PEDANTIC (pfile) && pfile->if_stack != stack) - validate_else (pfile, "#else"); - /* fall through */ - case T_ELIF: - if (pfile->if_stack->type == T_ELSE) - cpp_error (pfile, "`%s' after `#else'", kt->name); - - if (pfile->if_stack == stack) - return 1; - else - { - pfile->if_stack->type = kt->type; - return 0; - } - - case T_ENDIF: - if (CPP_PEDANTIC (pfile) && pfile->if_stack != stack) - validate_else (pfile, "#endif"); - - if (pfile->if_stack == stack) - return 1; - - temp = pfile->if_stack; - pfile->if_stack = temp->next; - free (temp); - return 0; - - default: - return 0; - } + cpp_error (pfile, "invalid #pragma GCC poison directive"); + break; + } - /* Don't let erroneous code go by. */ - if (!CPP_OPTIONS (pfile)->lang_asm && CPP_PEDANTIC (pfile)) - cpp_pedwarn (pfile, "invalid preprocessor directive name"); - return 0; + hp = tok->val.node; + if (hp->flags & NODE_POISONED) + continue; + + if (hp->type == NT_MACRO) + cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp)); + _cpp_free_definition (hp); + hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC; + } + pfile->state.poisoned_ok = 0; } -/* skip to #endif, #else, or #elif. adjust line numbers, etc. - * leaves input ptr at the sharp sign found. - */ +/* Mark the current header as a system header. This will suppress + some categories of warnings (notably those from -pedantic). It is + intended for use in system libraries that cannot be implemented in + conforming C, but cannot be certain that their headers appear in a + system include directory. To prevent abuse, it is rejected in the + primary source file. */ static void -skip_if_group (pfile) - cpp_reader *pfile; +do_pragma_system_header (pfile) + cpp_reader *pfile; { - int c; - IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */ - U_CHAR *beg_of_line; - long old_written; + cpp_buffer *buffer = pfile->buffer; - if (CPP_OPTIONS (pfile)->output_conditionals) + if (buffer->prev == 0) + cpp_warning (pfile, "#pragma system_header ignored outside include file"); + else { - CPP_PUTS (pfile, "#failed\n", 8); - pfile->lineno++; - output_line_command (pfile, same_file); + check_eol (pfile); + skip_rest_of_line (pfile); + cpp_make_system_header (pfile, 1, 0); } +} - old_written = CPP_WRITTEN (pfile); - - for (;;) - { - beg_of_line = CPP_BUFFER (pfile)->cur; - - if (! CPP_TRADITIONAL (pfile)) - cpp_skip_hspace (pfile); - c = GETC(); - if (c == '\n') - { - if (CPP_OPTIONS (pfile)->output_conditionals) - CPP_PUTC (pfile, c); - CPP_BUMP_LINE (pfile); - continue; - } - else if (c == '#') - { - if (consider_directive_while_skipping (pfile, save_if_stack)) - break; - } - else if (c == EOF) - return; /* Caller will issue error. */ - - FORWARD(-1); - if (CPP_OPTIONS (pfile)->output_conditionals) - { - CPP_PUTS (pfile, beg_of_line, CPP_BUFFER (pfile)->cur - beg_of_line); - copy_rest_of_line (pfile); - } - else - { - copy_rest_of_line (pfile); - CPP_SET_WRITTEN (pfile, old_written); /* discard it */ - } +/* Check the modified date of the current include file against a specified + file. Issue a diagnostic, if the specified file is newer. We use this to + determine if a fixed header should be refixed. */ +static void +do_pragma_dependency (pfile) + cpp_reader *pfile; +{ + const cpp_token *header; + int ordering; + + header = parse_include (pfile); + if (!header) + return; - c = GETC(); - if (c == EOF) - return; /* Caller will issue error. */ - else + ordering = _cpp_compare_file_date (pfile, header); + if (ordering < 0) + cpp_warning (pfile, "cannot find source %s", + cpp_token_as_text (pfile, header)); + else if (ordering > 0) + { + cpp_warning (pfile, "current file is older than %s", + cpp_token_as_text (pfile, header)); + if (cpp_get_token (pfile)->type != CPP_EOF) { - /* \n */ - if (CPP_OPTIONS (pfile)->output_conditionals) - { - CPP_PUTC (pfile, c); - pfile->lineno++; - } - CPP_BUMP_LINE (pfile); + _cpp_backup_tokens (pfile, 1); + do_diagnostic (pfile, WARNING, 0); } - } - - /* Back up to the beginning of this line. Caller will process the - directive. */ - CPP_BUFFER (pfile)->cur = beg_of_line; - pfile->only_seen_white = 1; - if (CPP_OPTIONS (pfile)->output_conditionals) - { - CPP_PUTS (pfile, "#endfailed\n", 11); - pfile->lineno++; } } -/* - * handle a #else directive. Do this by just continuing processing - * without changing if_stack ; this is so that the error message - * for missing #endif's etc. will point to the original #if. It - * is possible that something different would be better. - */ - -static int -do_else (pfile, keyword) +/* Get a token but skip padding. */ +static const cpp_token * +get_token_no_padding (pfile) cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; { - cpp_buffer *ip = CPP_BUFFER (pfile); - - if (CPP_PEDANTIC (pfile)) - validate_else (pfile, "#else"); - skip_rest_of_line (pfile); - - if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) { - cpp_error (pfile, "`#else' not within a conditional"); - return 0; - } else { - /* #ifndef can't have its special treatment for containing the whole file - if it has a #else clause. */ - pfile->if_stack->control_macro = 0; - - if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) { - cpp_error (pfile, "`#else' after `#else'"); - fprintf (stderr, " (matches line %d", pfile->if_stack->lineno); - if (strcmp (pfile->if_stack->fname, ip->nominal_fname) != 0) - fprintf (stderr, ", file %s", pfile->if_stack->fname); - fprintf (stderr, ")\n"); + for (;;) + { + const cpp_token *result = cpp_get_token (pfile); + if (result->type != CPP_PADDING) + return result; } - pfile->if_stack->type = T_ELSE; - } - - if (pfile->if_stack->if_succeeded) - skip_if_group (pfile); - else { - ++pfile->if_stack->if_succeeded; /* continue processing input */ - output_line_command (pfile, same_file); - } - return 0; } -/* - * unstack after #endif command - */ - -static int -do_endif (pfile, keyword) +/* Check syntax is "(string-literal)". Returns the string on success, + or NULL on failure. */ +static const cpp_token * +get__Pragma_string (pfile) cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; { - if (CPP_PEDANTIC (pfile)) - validate_else (pfile, "#endif"); - skip_rest_of_line (pfile); + const cpp_token *string; - if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) - cpp_error (pfile, "unbalanced `#endif'"); - else - { - IF_STACK_FRAME *temp = pfile->if_stack; - pfile->if_stack = temp->next; - if (temp->control_macro != 0) - { - /* This #endif matched a #ifndef at the start of the file. - See if it is at the end of the file. */ - int c; + if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN) + return NULL; - parse_set_mark (pfile); + string = get_token_no_padding (pfile); + if (string->type != CPP_STRING && string->type != CPP_WSTRING) + return NULL; - for (;;) - { - cpp_skip_hspace (pfile); - c = GETC (); - if (c != '\n') - break; - } - parse_goto_mark (pfile); + if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN) + return NULL; - if (c == EOF) - { - /* This #endif ends a #ifndef - that contains all of the file (aside from whitespace). - Arrange not to include the file again - if the macro that was tested is defined. */ - struct cpp_buffer *ip; - for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip)) - if (ip->fname != NULL) - break; - ip->ihash->control_macro = (char *) temp->control_macro; - } - } - free (temp); - output_line_command (pfile, same_file); - } - return 0; + return string; } -/* When an #else or #endif is found while skipping failed conditional, - if -pedantic was specified, this is called to warn about text after - the command name. P points to the first char after the command name. */ - +/* Destringize IN into a temporary buffer, by removing the first \ of + \" and \\ sequences, and process the result as a #pragma directive. */ static void -validate_else (pfile, directive) +destringize_and_run (pfile, in) cpp_reader *pfile; - char *directive; + const cpp_string *in; { - int c; - cpp_skip_hspace (pfile); - c = PEEKC (); - if (c != EOF && c != '\n') - cpp_pedwarn (pfile, - "text following `%s' violates ANSI standard", directive); + const unsigned char *src, *limit; + char *dest, *result; + + dest = result = alloca (in->len + 1); + for (src = in->text, limit = src + in->len; src < limit;) + { + /* We know there is a character following the backslash. */ + if (*src == '\\' && (src[1] == '\\' || src[1] == '"')) + src++; + *dest++ = *src++; + } + *dest = '\0'; + + run_directive (pfile, T_PRAGMA, result, dest - result); } -/* Get the next token, and add it to the text in pfile->token_buffer. - Return the kind of token we got. */ - -enum cpp_token -cpp_get_token (pfile) +/* Handle the _Pragma operator. */ +void +_cpp_do__Pragma (pfile) cpp_reader *pfile; { - register int c, c2, c3; - enum cpp_token token; - struct cpp_options *opts = CPP_OPTIONS (pfile); + const cpp_token *string = get__Pragma_string (pfile); - get_next: - c = GETC(); - if (c == EOF) - { - handle_eof: - if (CPP_BUFFER (pfile)->seen_eof) - { - if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)) == CPP_NULL_BUFFER (pfile)) - return CPP_EOF; - - cpp_pop_buffer (pfile); - goto get_next; - } - else - { - cpp_buffer *next_buf - = CPP_PREV_BUFFER (CPP_BUFFER (pfile)); - CPP_BUFFER (pfile)->seen_eof = 1; - if (CPP_BUFFER (pfile)->nominal_fname - && next_buf != CPP_NULL_BUFFER (pfile)) - { - /* We're about to return from an #include file. - Emit #line information now (as part of the CPP_POP) result. - But the #line refers to the file we will pop to. */ - cpp_buffer *cur_buffer = CPP_BUFFER (pfile); - CPP_BUFFER (pfile) = next_buf; - pfile->input_stack_listing_current = 0; - output_line_command (pfile, leave_file); - CPP_BUFFER (pfile) = cur_buffer; - } - return CPP_POP; - } - } + if (!string) + cpp_error (pfile, "_Pragma takes a parenthesized string literal"); else { - switch (c) - { - case '/': - if (PEEKC () == '=') - goto op2; + /* Ideally, we'd like + token1 _Pragma ("foo") token2 + to be output as + token1 + # 7 "file.c" + #pragma foo + # 7 "file.c" + token2 + Getting these correct line markers is a little tricky. */ - comment: - if (opts->put_out_comments) - c = copy_comment (pfile, c); - else - c = skip_comment (pfile, c); - if (c == EOF) - goto handle_eof; - else if (c != ' ') - goto randomchar; - - /* Comments are equivalent to spaces. - For -traditional, a comment is equivalent to nothing. */ - if (opts->traditional || opts->put_out_comments) - return CPP_COMMENT; - else - { - CPP_PUTC (pfile, c); - return CPP_HSPACE; - } -#if 0 - if (opts->for_lint) { - U_CHAR *argbp; - int cmdlen, arglen; - char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen); - - if (lintcmd != NULL) { - /* I believe it is always safe to emit this newline: */ - obp[-1] = '\n'; - bcopy ("#pragma lint ", (char *) obp, 13); - obp += 13; - bcopy (lintcmd, (char *) obp, cmdlen); - obp += cmdlen; - - if (arglen != 0) { - *(obp++) = ' '; - bcopy (argbp, (char *) obp, arglen); - obp += arglen; - } - - /* OK, now bring us back to the state we were in before we entered - this branch. We need #line because the newline for the pragma - could mess things up. */ - output_line_command (pfile, same_file); - *(obp++) = ' '; /* just in case, if comments are copied thru */ - *(obp++) = '/'; - } - } -#endif + unsigned int orig_line = pfile->line; + destringize_and_run (pfile, &string->val.str); + pfile->line = orig_line; + pfile->buffer->saved_flags = BOL; + } +} - case '#': -#if 0 - /* If this is expanding a macro definition, don't recognize - preprocessor directives. */ - if (ip->macro != 0) - goto randomchar; - /* If this is expand_into_temp_buffer, recognize them - only after an actual newline at this level, - not at the beginning of the input level. */ - if (ip->fname == 0 && beg_of_line == ip->buf) - goto randomchar; - if (ident_length) - goto specialchar; +/* Just ignore #sccs, on systems where we define it at all. */ +#ifdef SCCS_DIRECTIVE +static void +do_sccs (pfile) + cpp_reader *pfile ATTRIBUTE_UNUSED; +{ +} #endif - if (!pfile->only_seen_white) - goto randomchar; - if (handle_directive (pfile)) - return CPP_DIRECTIVE; - pfile->only_seen_white = 0; - return CPP_OTHER; - - case '\"': - case '\'': - string: - parse_string (pfile, c); - pfile->only_seen_white = 0; - return c == '\'' ? CPP_CHAR : CPP_STRING; - - case '$': - if (!opts->dollars_in_ident) - goto randomchar; - goto letter; - - case ':': - if (opts->cplusplus && PEEKC () == ':') - goto op2; - goto randomchar; - - case '&': - case '+': - case '|': - c2 = PEEKC (); - if (c2 == c || c2 == '=') - goto op2; - goto randomchar; - - case '*': - case '!': - case '%': - case '=': - case '^': - if (PEEKC () == '=') - goto op2; - goto randomchar; - - case '-': - c2 = PEEKC (); - if (c2 == '-' && opts->chill) - goto comment; /* Chill style comment */ - if (c2 == '-' || c2 == '=' || c2 == '>') - goto op2; - goto randomchar; - - case '<': - if (pfile->parsing_include_directive) - { - for (;;) - { - CPP_PUTC (pfile, c); - if (c == '>') - break; - c = GETC (); - if (c == '\n' || c == EOF) - { - cpp_error (pfile, - "missing '>' in `#include <FILENAME>'"); - break; - } - else if (c == '\r') - { - if (!CPP_BUFFER (pfile)->has_escapes) - { - /* Backslash newline is replaced by nothing. */ - CPP_ADJUST_WRITTEN (pfile, -1); - CPP_BUMP_LINE (pfile); - } - else - { - /* We might conceivably get \r- or \r<space> in - here. Just delete 'em. */ - int d = GETC(); - if (d != '-' && d != ' ') - cpp_fatal (pfile, - "internal error: unrecognized escape \\r%c", - d); - CPP_ADJUST_WRITTEN (pfile, -1); - } - } - } - return CPP_STRING; - } - /* else fall through */ - case '>': - c2 = PEEKC (); - if (c2 == '=') - goto op2; - if (c2 != c) - goto randomchar; - FORWARD(1); - CPP_RESERVE (pfile, 4); - CPP_PUTC (pfile, c); - CPP_PUTC (pfile, c2); - c3 = PEEKC (); - if (c3 == '=') - CPP_PUTC_Q (pfile, GETC ()); - CPP_NUL_TERMINATE_Q (pfile); - pfile->only_seen_white = 0; - return CPP_OTHER; - - case '.': - c2 = PEEKC (); - if (ISDIGIT(c2)) - { - CPP_RESERVE(pfile, 2); - CPP_PUTC_Q (pfile, '.'); - c = GETC (); - goto number; - } - if (c2 == '.' && PEEKN(1) == '.') - { - CPP_RESERVE(pfile, 4); - CPP_PUTC_Q (pfile, '.'); - CPP_PUTC_Q (pfile, '.'); - CPP_PUTC_Q (pfile, '.'); - FORWARD (2); - CPP_NUL_TERMINATE_Q (pfile); - pfile->only_seen_white = 0; - return CPP_3DOTS; - } - goto randomchar; - - op2: - token = CPP_OTHER; - pfile->only_seen_white = 0; - CPP_RESERVE(pfile, 3); - CPP_PUTC_Q (pfile, c); - CPP_PUTC_Q (pfile, GETC ()); - CPP_NUL_TERMINATE_Q (pfile); - return token; - - case 'L': - c2 = PEEKC (); - if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile)) - { - CPP_PUTC (pfile, c); - c = GETC (); - goto string; - } - goto letter; +/* Handle #ifdef. */ +static void +do_ifdef (pfile) + cpp_reader *pfile; +{ + int skip = 1; - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - number: - c2 = '.'; - for (;;) - { - CPP_RESERVE (pfile, 2); - CPP_PUTC_Q (pfile, c); - c = PEEKC (); - if (c == EOF) - break; - if (!is_idchar[c] && c != '.' - && ((c2 != 'e' && c2 != 'E' - && ((c2 != 'p' && c2 != 'P') || CPP_C89 (pfile))) - || (c != '+' && c != '-'))) - break; - FORWARD(1); - c2= c; - } - CPP_NUL_TERMINATE_Q (pfile); - pfile->only_seen_white = 0; - return CPP_NUMBER; - case 'b': case 'c': case 'd': case 'h': case 'o': - case 'B': case 'C': case 'D': case 'H': case 'O': - if (opts->chill && PEEKC () == '\'') - { - pfile->only_seen_white = 0; - CPP_RESERVE (pfile, 2); - CPP_PUTC_Q (pfile, c); - CPP_PUTC_Q (pfile, '\''); - FORWARD(1); - for (;;) - { - c = GETC(); - if (c == EOF) - goto chill_number_eof; - if (!is_idchar[c]) - break; - CPP_PUTC (pfile, c); - } - if (c == '\'') - { - CPP_RESERVE (pfile, 2); - CPP_PUTC_Q (pfile, c); - CPP_NUL_TERMINATE_Q (pfile); - return CPP_STRING; - } - else - { - FORWARD(-1); - chill_number_eof: - CPP_NUL_TERMINATE (pfile); - return CPP_NUMBER; - } - } - else - goto letter; - case '_': - case 'a': case 'e': case 'f': case 'g': case 'i': case 'j': - case 'k': case 'l': case 'm': case 'n': case 'p': case 'q': - case 'r': case 's': case 't': case 'u': case 'v': case 'w': - case 'x': case 'y': case 'z': - case 'A': case 'E': case 'F': case 'G': case 'I': case 'J': - case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R': - case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': - case 'Y': case 'Z': - letter: - { - HASHNODE *hp; - unsigned char *ident; - int before_name_written = CPP_WRITTEN (pfile); - int ident_len; - parse_name (pfile, c); - pfile->only_seen_white = 0; - if (pfile->no_macro_expand) - return CPP_NAME; - ident = pfile->token_buffer + before_name_written; - ident_len = CPP_PWRITTEN (pfile) - ident; - hp = cpp_lookup (pfile, ident, ident_len, -1); - if (!hp) - return CPP_NAME; - if (hp->type == T_DISABLED) - { - if (pfile->output_escapes) - { /* Return "\r-IDENT", followed by '\0'. */ - int i; - CPP_RESERVE (pfile, 3); - ident = pfile->token_buffer + before_name_written; - CPP_ADJUST_WRITTEN (pfile, 2); - for (i = ident_len; i >= 0; i--) ident[i+2] = ident[i]; - ident[0] = '\r'; - ident[1] = '-'; - } - return CPP_NAME; - } - - /* If macro wants an arglist, verify that a '(' follows. - first skip all whitespace, copying it to the output - after the macro name. Then, if there is no '(', - decide this is not a macro call and leave things that way. */ - if (hp->type == T_MACRO && hp->value.defn->nargs >= 0) - { - int is_macro_call, macbuf_whitespace = 0; - - parse_set_mark (pfile); - for (;;) - { - cpp_skip_hspace (pfile); - c = PEEKC (); - is_macro_call = c == '('; - if (c != EOF) - { - if (c != '\n') - break; - FORWARD (1); - } - else - { - if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile))) - { - if (CPP_BUFFER (pfile)->mark != - (CPP_BUFFER (pfile)->cur - - CPP_BUFFER (pfile)->buf)) - macbuf_whitespace = 1; - - /* The mark goes away automatically when - the buffer is popped. */ - cpp_pop_buffer (pfile); - parse_set_mark (pfile); - } - else - break; - } - } - if (!is_macro_call) - { - parse_goto_mark (pfile); - if (macbuf_whitespace) - CPP_PUTC (pfile, ' '); - } - else - parse_clear_mark (pfile); - if (!is_macro_call) - return CPP_NAME; - } - /* This is now known to be a macro call. - Expand the macro, reading arguments as needed, - and push the expansion on the input stack. */ - macroexpand (pfile, hp); - CPP_SET_WRITTEN (pfile, before_name_written); - } - goto get_next; - - case ' ': case '\t': case '\v': - for (;;) - { - CPP_PUTC (pfile, c); - c = PEEKC (); - if (c == EOF || !is_hor_space[c]) - break; - FORWARD(1); - } - return CPP_HSPACE; + if (! pfile->state.skipping) + { + const cpp_hashnode *node = lex_macro_node (pfile); - case '\r': - if (CPP_BUFFER (pfile)->has_escapes) - { - c = GETC (); - if (c == '-') - { - if (pfile->output_escapes) - CPP_PUTS (pfile, "\r-", 2); - parse_name (pfile, GETC ()); - return CPP_NAME; - } - else if (c == ' ') - { - CPP_RESERVE (pfile, 2); - if (pfile->output_escapes) - CPP_PUTC_Q (pfile, '\r'); - CPP_PUTC_Q (pfile, c); - return CPP_HSPACE; - } - else - { - cpp_fatal (pfile, - "internal error: unrecognized escape \\r%c", c); - goto get_next; - } - } - else - { - /* Backslash newline is ignored. */ - CPP_BUMP_LINE (pfile); - goto get_next; - } + if (node) + skip = node->type != NT_MACRO; - case '\n': - CPP_PUTC (pfile, c); - if (pfile->only_seen_white == 0) - pfile->only_seen_white = 1; - CPP_BUMP_LINE (pfile); - if (! CPP_OPTIONS (pfile)->no_line_commands) - { - pfile->lineno++; - if (CPP_BUFFER (pfile)->lineno != pfile->lineno) - output_line_command (pfile, same_file); - } - return CPP_VSPACE; - - case '(': token = CPP_LPAREN; goto char1; - case ')': token = CPP_RPAREN; goto char1; - case '{': token = CPP_LBRACE; goto char1; - case '}': token = CPP_RBRACE; goto char1; - case ',': token = CPP_COMMA; goto char1; - case ';': token = CPP_SEMICOLON; goto char1; - - randomchar: - default: - token = CPP_OTHER; - char1: - pfile->only_seen_white = 0; - CPP_PUTC (pfile, c); - return token; - } + if (node) + check_eol (pfile); } -} -/* Like cpp_get_token, but skip spaces and comments. */ + push_conditional (pfile, skip, T_IFDEF, 0); +} -enum cpp_token -cpp_get_non_space_token (pfile) +/* Handle #ifndef. */ +static void +do_ifndef (pfile) cpp_reader *pfile; { - int old_written = CPP_WRITTEN (pfile); - for (;;) + int skip = 1; + const cpp_hashnode *node = 0; + + if (! pfile->state.skipping) { - enum cpp_token token = cpp_get_token (pfile); - if (token != CPP_COMMENT && token != CPP_POP - && token != CPP_HSPACE && token != CPP_VSPACE) - return token; - CPP_SET_WRITTEN (pfile, old_written); + node = lex_macro_node (pfile); + if (node) + skip = node->type == NT_MACRO; + + if (node) + check_eol (pfile); } -} -/* Parse an identifier starting with C. */ + push_conditional (pfile, skip, T_IFNDEF, node); +} +/* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in + pfile->mi_ind_cmacro so we can handle multiple-include + optimisations. If macro expansion occurs in the expression, we + cannot treat it as a controlling conditional, since the expansion + could change in the future. That is handled by cpp_get_token. */ static void -parse_name (pfile, c) +do_if (pfile) cpp_reader *pfile; - int c; { - for (;;) - { - if (! is_idchar[c]) - { - FORWARD (-1); - break; - } + int skip = 1; - if (c == '$' && CPP_PEDANTIC (pfile)) - cpp_pedwarn (pfile, "`$' in identifier"); + if (! pfile->state.skipping) + skip = _cpp_parse_expr (pfile) == 0; - CPP_RESERVE(pfile, 2); /* One more for final NUL. */ - CPP_PUTC_Q (pfile, c); - c = GETC(); - if (c == EOF) - break; - } - CPP_NUL_TERMINATE_Q (pfile); - return; + push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro); } -/* Parse a string starting with C. A single quoted string is treated - like a double -- some programs (e.g., troff) are perverse this way. - (However, a single quoted string is not allowed to extend over - multiple lines. */ +/* Flip skipping state if appropriate and continue without changing + if_stack; this is so that the error message for missing #endif's + etc. will point to the original #if. */ static void -parse_string (pfile, c) +do_else (pfile) cpp_reader *pfile; - int c; { - long start_line, start_column; - - cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column); + cpp_buffer *buffer = pfile->buffer; + struct if_stack *ifs = buffer->if_stack; - CPP_PUTC (pfile, c); - while (1) + if (ifs == NULL) + cpp_error (pfile, "#else without #if"); + else { - int cc = GETC(); - if (cc == EOF) + if (ifs->type == T_ELSE) { - if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile))) - { - /* try harder: this string crosses a macro expansion - boundary. This can happen naturally if -traditional. - Otherwise, only -D can make a macro with an unmatched - quote. */ - cpp_pop_buffer (pfile); - continue; - } - if (!CPP_TRADITIONAL (pfile)) - { - cpp_error_with_line (pfile, start_line, start_column, - "unterminated string or character constant"); - if (pfile->multiline_string_line != start_line - && pfile->multiline_string_line != 0) - cpp_error_with_line (pfile, - pfile->multiline_string_line, -1, - "possible real start of unterminated constant"); - pfile->multiline_string_line = 0; - } - break; + cpp_error (pfile, "#else after #else"); + cpp_error_with_line (pfile, ifs->line, 0, + "the conditional began here"); } - CPP_PUTC (pfile, cc); - switch (cc) - { - case '\n': - CPP_BUMP_LINE (pfile); - pfile->lineno++; - /* Traditionally, end of line ends a string constant with - no error. */ - if (CPP_TRADITIONAL (pfile)) - return; - /* Character constants may not extend over multiple lines. */ - if (c == '\'') - { - cpp_error_with_line (pfile, start_line, start_column, - "unterminated character constant"); - return; - } - if (CPP_PEDANTIC (pfile) && pfile->multiline_string_line == 0) - { - cpp_pedwarn_with_line (pfile, start_line, start_column, - "string constant runs past end of line"); - } - if (pfile->multiline_string_line == 0) - pfile->multiline_string_line = start_line; - break; + ifs->type = T_ELSE; - case '\r': - CPP_ADJUST_WRITTEN (pfile, -1); - if (CPP_BUFFER (pfile)->has_escapes) - { - cpp_fatal (pfile, - "internal error: \\r escape inside string constant"); - FORWARD(1); - } - else - /* Backslash newline is replaced by nothing at all. */ - CPP_BUMP_LINE (pfile); - break; + /* Skip any future (erroneous) #elses or #elifs. */ + pfile->state.skipping = ifs->skip_elses; + ifs->skip_elses = true; - case '\\': - cc = GETC(); - if (cc != EOF) - CPP_PUTC (pfile, cc); - break; + /* Invalidate any controlling macro. */ + ifs->mi_cmacro = 0; - case '\"': - case '\'': - if (cc == c) - return; - break; - } + /* Only check EOL if was not originally skipping. */ + if (!ifs->was_skipping) + check_eol (pfile); } } -/* Read an assertion into the token buffer, converting to - canonical form: `#predicate(a n swe r)' The next non-whitespace - character to read should be the first letter of the predicate. - Returns 0 for syntax error, 1 for bare predicate, 2 for predicate - with answer (see callers for why). In case of 0, an error has been - printed. */ -static int -parse_assertion (pfile) +/* Handle a #elif directive by not changing if_stack either. See the + comment above do_else. */ +static void +do_elif (pfile) cpp_reader *pfile; { - int c, dropwhite; - cpp_skip_hspace (pfile); - c = PEEKC(); - if (! is_idstart[c]) - { - cpp_error (pfile, "assertion predicate is not an identifier"); - return 0; - } - CPP_PUTC(pfile, '#'); - FORWARD(1); - parse_name(pfile, c); - - c = PEEKC(); - if (c != '(') - { - if (is_hor_space[c] || c == '\r') - cpp_skip_hspace (pfile); - c = PEEKC(); - } - if (c != '(') - return 1; + cpp_buffer *buffer = pfile->buffer; + struct if_stack *ifs = buffer->if_stack; - CPP_PUTC(pfile, '('); - FORWARD(1); - dropwhite = 1; - while ((c = GETC()) != ')') + if (ifs == NULL) + cpp_error (pfile, "#elif without #if"); + else { - if (is_hor_space[c]) + if (ifs->type == T_ELSE) { - if (! dropwhite) - { - CPP_PUTC(pfile, ' '); - dropwhite = 1; - } + cpp_error (pfile, "#elif after #else"); + cpp_error_with_line (pfile, ifs->line, 0, + "the conditional began here"); } - else if (c == '\n' || c == EOF) - { - if (c == '\n') FORWARD(-1); - cpp_error (pfile, "un-terminated assertion answer"); - return 0; - } - else if (c == '\r') - /* \r cannot be a macro escape here. */ - CPP_BUMP_LINE (pfile); + ifs->type = T_ELIF; + + /* Only evaluate this if we aren't skipping elses. During + evaluation, set skipping to false to get lexer warnings. */ + if (ifs->skip_elses) + pfile->state.skipping = 1; else { - CPP_PUTC (pfile, c); - dropwhite = 0; + pfile->state.skipping = 0; + pfile->state.skipping = ! _cpp_parse_expr (pfile); + ifs->skip_elses = ! pfile->state.skipping; } - } - if (pfile->limit[-1] == ' ') - pfile->limit[-1] = ')'; - else if (pfile->limit[-1] == '(') - { - cpp_error (pfile, "empty token sequence in assertion"); - return 0; + /* Invalidate any controlling macro. */ + ifs->mi_cmacro = 0; } - else - CPP_PUTC (pfile, ')'); - - CPP_NUL_TERMINATE (pfile); - return 2; } -static int -do_assert (pfile, keyword) +/* #endif pops the if stack and resets pfile->state.skipping. */ +static void +do_endif (pfile) cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; -{ - char *sym; - int ret, c; - HASHNODE *base, *this; - int baselen, thislen; - - if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing - && !CPP_BUFFER (pfile)->system_header_p) - cpp_pedwarn (pfile, "ANSI C does not allow `#assert'"); - - cpp_skip_hspace (pfile); - sym = (char *) CPP_PWRITTEN (pfile); /* remember where it starts */ - ret = parse_assertion (pfile); - if (ret == 0) - goto error; - else if (ret == 1) - { - cpp_error (pfile, "missing token-sequence in `#assert'"); - goto error; - } +{ + cpp_buffer *buffer = pfile->buffer; + struct if_stack *ifs = buffer->if_stack; - cpp_skip_hspace (pfile); - c = PEEKC(); - if (c != EOF && c != '\n') + if (ifs == NULL) + cpp_error (pfile, "#endif without #if"); + else { - cpp_error (pfile, "junk at end of `#assert'"); - goto error; - } + /* Only check EOL if was not originally skipping. */ + if (!ifs->was_skipping) + check_eol (pfile); - thislen = strlen (sym); - baselen = index (sym, '(') - sym; - this = cpp_lookup (pfile, sym, thislen, -1); - if (this) - { - cpp_warning (pfile, "`%s' re-asserted", sym); - goto error; + /* If potential control macro, we go back outside again. */ + if (ifs->next == 0 && ifs->mi_cmacro) + { + pfile->mi_valid = true; + pfile->mi_cmacro = ifs->mi_cmacro; + } + + buffer->if_stack = ifs->next; + pfile->state.skipping = ifs->was_skipping; + obstack_free (&pfile->buffer_ob, ifs); } +} - base = cpp_lookup (pfile, sym, baselen, -1); - if (! base) - base = cpp_install (pfile, sym, baselen, T_ASSERT, 0, -1); - else if (base->type != T_ASSERT) - { - /* Token clash - but with what?! */ - cpp_fatal (pfile, - "cpp internal error: base->type != T_ASSERT in do_assert"); - goto error; - } - - this = cpp_install (pfile, sym, thislen, T_ASSERT, - (char *)base->value.aschain, -1); - base->value.aschain = this; - - pfile->limit = (unsigned char *) sym; /* Pop */ - return 0; +/* Push an if_stack entry for a preprocessor conditional, and set + pfile->state.skipping to SKIP. If TYPE indicates the conditional + is #if or #ifndef, CMACRO is a potentially controlling macro, and + we need to check here that we are at the top of the file. */ +static void +push_conditional (pfile, skip, type, cmacro) + cpp_reader *pfile; + int skip; + int type; + const cpp_hashnode *cmacro; +{ + struct if_stack *ifs; + cpp_buffer *buffer = pfile->buffer; + + ifs = xobnew (&pfile->buffer_ob, struct if_stack); + ifs->line = pfile->directive_line; + ifs->next = buffer->if_stack; + ifs->skip_elses = pfile->state.skipping || !skip; + ifs->was_skipping = pfile->state.skipping; + ifs->type = type; + /* This condition is effectively a test for top-of-file. */ + if (pfile->mi_valid && pfile->mi_cmacro == 0) + ifs->mi_cmacro = cmacro; + else + ifs->mi_cmacro = 0; - error: - skip_rest_of_line (pfile); - pfile->limit = (unsigned char *) sym; /* Pop */ - return 0; + pfile->state.skipping = skip; + buffer->if_stack = ifs; } +/* Read the tokens of the answer into the macro pool, in a directive + of type TYPE. Only commit the memory if we intend it as permanent + storage, i.e. the #assert case. Returns 0 on success, and sets + ANSWERP to point to the answer. */ static int -do_unassert (pfile, keyword) +parse_answer (pfile, answerp, type) cpp_reader *pfile; - struct directive *keyword ATTRIBUTE_UNUSED; + struct answer **answerp; + int type; { - int c, ret; - char *sym; - long baselen, thislen; - HASHNODE *base, *this, *next; - - if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing - && !CPP_BUFFER (pfile)->system_header_p) - cpp_pedwarn (pfile, "ANSI C does not allow `#unassert'"); + const cpp_token *paren; + struct answer *answer; + unsigned int acount; - cpp_skip_hspace (pfile); + /* In a conditional, it is legal to not have an open paren. We + should save the following token in this case. */ + paren = cpp_get_token (pfile); - sym = (char *) CPP_PWRITTEN (pfile); /* remember where it starts */ - ret = parse_assertion (pfile); - if (ret == 0) - goto error; - - cpp_skip_hspace (pfile); - c = PEEKC (); - if (c != EOF && c != '\n') - cpp_error (pfile, "junk at end of `#unassert'"); - - thislen = strlen (sym); - if (ret == 1) + /* If not a paren, see if we're OK. */ + if (paren->type != CPP_OPEN_PAREN) { - base = cpp_lookup (pfile, sym, thislen, -1); - if (! base) - goto error; /* It isn't an error to #undef what isn't #defined, - so it isn't an error to #unassert what isn't - #asserted either. */ - - for (this = base->value.aschain; this; this = next) - { - next = this->value.aschain; - delete_macro (this); + /* In a conditional no answer is a test for any answer. It + could be followed by any token. */ + if (type == T_IF) + { + _cpp_backup_tokens (pfile, 1); + return 0; } - delete_macro (base); + + /* #unassert with no answer is valid - it removes all answers. */ + if (type == T_UNASSERT && paren->type == CPP_EOF) + return 0; + + cpp_error (pfile, "missing '(' after predicate"); + return 1; } - else + + for (acount = 0;; acount++) { - baselen = index (sym, '(') - sym; - base = cpp_lookup (pfile, sym, baselen, -1); - if (! base) goto error; - this = cpp_lookup (pfile, sym, thislen, -1); - if (! this) goto error; + size_t room_needed; + const cpp_token *token = cpp_get_token (pfile); + cpp_token *dest; + + if (token->type == CPP_CLOSE_PAREN) + break; + + if (token->type == CPP_EOF) + { + cpp_error (pfile, "missing ')' to complete answer"); + return 1; + } + + /* struct answer includes the space for one token. */ + room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token)); - next = base; - while (next->value.aschain != this) - next = next->value.aschain; + if (BUFF_ROOM (pfile->a_buff) < room_needed) + _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer)); - next->value.aschain = this->value.aschain; - delete_macro (this); + dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount]; + *dest = *token; - if (base->value.aschain == NULL) - delete_macro (base); /* Last answer for this predicate deleted. */ + /* Drop whitespace at start, for answer equivalence purposes. */ + if (acount == 0) + dest->flags &= ~PREV_WHITE; } - - pfile->limit = (unsigned char *) sym; /* Pop */ - return 0; - error: - skip_rest_of_line (pfile); - pfile->limit = (unsigned char *) sym; /* Pop */ - return 0; -} -/* Process STR as if it appeared as the body of an #unassert. */ -void -cpp_unassert (pfile, str) - cpp_reader *pfile; - unsigned char *str; -{ - if (cpp_push_buffer (pfile, str, strlen (str)) != NULL) + if (acount == 0) { - do_assert (pfile, NULL); - cpp_pop_buffer (pfile); + cpp_error (pfile, "predicate's answer is empty"); + return 1; } -} -int -cpp_read_check_assertion (pfile) + answer = (struct answer *) BUFF_FRONT (pfile->a_buff); + answer->count = acount; + answer->next = NULL; + *answerp = answer; + + return 0; +} + +/* Parses an assertion directive of type TYPE, returning a pointer to + the hash node of the predicate, or 0 on error. If an answer was + supplied, it is placed in ANSWERP, otherwise it is set to 0. */ +static cpp_hashnode * +parse_assertion (pfile, answerp, type) cpp_reader *pfile; + struct answer **answerp; + int type; { - U_CHAR *name = CPP_PWRITTEN (pfile); - int result; - HASHNODE *hp; - - FORWARD (1); /* Skip '#' */ - cpp_skip_hspace (pfile); - if (! parse_assertion (pfile)) - result = 0; - else + cpp_hashnode *result = 0; + const cpp_token *predicate; + + /* We don't expand predicates or answers. */ + pfile->state.prevent_expansion++; + + *answerp = 0; + predicate = cpp_get_token (pfile); + if (predicate->type == CPP_EOF) + cpp_error (pfile, "assertion without predicate"); + else if (predicate->type != CPP_NAME) + cpp_error (pfile, "predicate must be an identifier"); + else if (parse_answer (pfile, answerp, type) == 0) { - hp = cpp_lookup (pfile, name, CPP_PWRITTEN (pfile) - name, -1); - result = (hp != 0); + unsigned int len = NODE_LEN (predicate->val.node); + unsigned char *sym = alloca (len + 1); + + /* Prefix '#' to get it out of macro namespace. */ + sym[0] = '#'; + memcpy (sym + 1, NODE_NAME (predicate->val.node), len); + result = cpp_lookup (pfile, sym, len + 1); } - pfile->limit = name; + pfile->state.prevent_expansion--; return result; } -/* Remember the current position of PFILE. */ - -void -parse_set_mark (pfile) - cpp_reader *pfile; +/* Returns a pointer to the pointer to CANDIDATE in the answer chain, + or a pointer to NULL if the answer is not in the chain. */ +static struct answer ** +find_answer (node, candidate) + cpp_hashnode *node; + const struct answer *candidate; { - cpp_buffer *ip = CPP_BUFFER (pfile); - if (ip->mark != -1) - cpp_fatal (pfile, - "cpp internal error: ip->mark != -1 in parse_set_mark"); + unsigned int i; + struct answer **result; - ip->mark = ip->cur - ip->buf; -} + for (result = &node->value.answers; *result; result = &(*result)->next) + { + struct answer *answer = *result; -/* Clear the current mark - we no longer need it. */ + if (answer->count == candidate->count) + { + for (i = 0; i < answer->count; i++) + if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i])) + break; -void -parse_clear_mark (pfile) - cpp_reader *pfile; -{ - cpp_buffer *ip = CPP_BUFFER (pfile); - if (ip->mark == -1) - cpp_fatal (pfile, - "cpp internal error: ip->mark == -1 in parse_clear_mark"); + if (i == answer->count) + break; + } + } - ip->mark = -1; + return result; } -/* Backup the current position of PFILE to that saved in its mark, - and clear the mark. */ - -void -parse_goto_mark (pfile) +/* Test an assertion within a preprocessor conditional. Returns + non-zero on failure, zero on success. On success, the result of + the test is written into VALUE. */ +int +_cpp_test_assertion (pfile, value) cpp_reader *pfile; + int *value; { - cpp_buffer *ip = CPP_BUFFER (pfile); - if (ip->mark == -1) - cpp_fatal (pfile, - "cpp internal error: ip->mark == -1 in parse_goto_mark"); + struct answer *answer; + cpp_hashnode *node; - ip->cur = ip->buf + ip->mark; - ip->mark = -1; + node = parse_assertion (pfile, &answer, T_IF); + if (node) + *value = (node->type == NT_ASSERTION && + (answer == 0 || *find_answer (node, answer) != 0)); + + /* We don't commit the memory for the answer - it's temporary only. */ + return node == 0; } -void -cpp_print_file_and_line (pfile) +/* Handle #assert. */ +static void +do_assert (pfile) cpp_reader *pfile; { - cpp_buffer *ip = cpp_file_buffer (pfile); - - if (ip != NULL) + struct answer *new_answer; + cpp_hashnode *node; + + node = parse_assertion (pfile, &new_answer, T_ASSERT); + if (node) { - long line, col; - cpp_buf_line_and_col (ip, &line, &col); - cpp_file_line_for_message (pfile, ip->nominal_fname, - line, pfile->show_column ? col : -1); + /* Place the new answer in the answer list. First check there + is not a duplicate. */ + new_answer->next = 0; + if (node->type == NT_ASSERTION) + { + if (*find_answer (node, new_answer)) + { + cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1); + return; + } + new_answer->next = node->value.answers; + } + + node->type = NT_ASSERTION; + node->value.answers = new_answer; + BUFF_FRONT (pfile->a_buff) += (sizeof (struct answer) + + (new_answer->count - 1) + * sizeof (cpp_token)); + check_eol (pfile); } } +/* Handle #unassert. */ static void -v_cpp_error (pfile, msgid, ap) - cpp_reader *pfile; - const char *msgid; - va_list ap; +do_unassert (pfile) + cpp_reader *pfile; { - cpp_print_containing_files (pfile); - cpp_print_file_and_line (pfile); - v_cpp_message (pfile, 1, msgid, ap); -} + cpp_hashnode *node; + struct answer *answer; + + node = parse_assertion (pfile, &answer, T_UNASSERT); + /* It isn't an error to #unassert something that isn't asserted. */ + if (node && node->type == NT_ASSERTION) + { + if (answer) + { + struct answer **p = find_answer (node, answer), *temp; -void -cpp_error VPROTO ((cpp_reader * pfile, const char *msgid, ...)) -{ -#ifndef ANSI_PROTOTYPES - cpp_reader *pfile; - const char *msgid; -#endif - va_list ap; + /* Remove the answer from the list. */ + temp = *p; + if (temp) + *p = temp->next; - VA_START(ap, msgid); - -#ifndef ANSI_PROTOTYPES - pfile = va_arg (ap, cpp_reader *); - msgid = va_arg (ap, const char *); -#endif + /* Did we free the last answer? */ + if (node->value.answers == 0) + node->type = NT_VOID; - v_cpp_error (pfile, msgid, ap); - va_end(ap); + check_eol (pfile); + } + else + _cpp_free_definition (node); + } + + /* We don't commit the memory for the answer - it's temporary only. */ } -/* Print error message but don't count it. */ +/* These are for -D, -U, -A. */ -static void -v_cpp_warning (pfile, msgid, ap) - cpp_reader *pfile; - const char *msgid; - va_list ap; +/* Process the string STR as if it appeared as the body of a #define. + If STR is just an identifier, define it with value 1. + If STR has anything after the identifier, then it should + be identifier=definition. */ +void +cpp_define (pfile, str) + cpp_reader *pfile; + const char *str; { - if (CPP_OPTIONS (pfile)->inhibit_warnings) - return; + char *buf, *p; + size_t count; - if (CPP_OPTIONS (pfile)->warnings_are_errors) - pfile->errors++; + /* Copy the entire option so we can modify it. + Change the first "=" in the string to a space. If there is none, + tack " 1" on the end. */ + + count = strlen (str); + buf = (char *) alloca (count + 3); + memcpy (buf, str, count); + + p = strchr (str, '='); + if (p) + buf[p - str] = ' '; + else + { + buf[count++] = ' '; + buf[count++] = '1'; + } + buf[count] = '\0'; - cpp_print_containing_files (pfile); - cpp_print_file_and_line (pfile); - v_cpp_message (pfile, 0, msgid, ap); + run_directive (pfile, T_DEFINE, buf, count); } +/* Slight variant of the above for use by initialize_builtins. */ void -cpp_warning VPROTO ((cpp_reader * pfile, const char *msgid, ...)) +_cpp_define_builtin (pfile, str) + cpp_reader *pfile; + const char *str; { -#ifndef ANSI_PROTOTYPES - cpp_reader *pfile; - const char *msgid; -#endif - va_list ap; - - VA_START (ap, msgid); - -#ifndef ANSI_PROTOTYPES - pfile = va_arg (ap, cpp_reader *); - msgid = va_arg (ap, const char *); -#endif - - v_cpp_warning (pfile, msgid, ap); - va_end(ap); + run_directive (pfile, T_DEFINE, str, strlen (str)); } -/* Print an error message and maybe count it. */ - +/* Process MACRO as if it appeared as the body of an #undef. */ void -cpp_pedwarn VPROTO ((cpp_reader * pfile, const char *msgid, ...)) +cpp_undef (pfile, macro) + cpp_reader *pfile; + const char *macro; { -#ifndef ANSI_PROTOTYPES - cpp_reader *pfile; - const char *msgid; -#endif - va_list ap; - - VA_START (ap, msgid); - -#ifndef ANSI_PROTOTYPES - pfile = va_arg (ap, cpp_reader *); - msgid = va_arg (ap, const char *); -#endif - - if (CPP_OPTIONS (pfile)->pedantic_errors) - v_cpp_error (pfile, msgid, ap); - else - v_cpp_warning (pfile, msgid, ap); - va_end(ap); + run_directive (pfile, T_UNDEF, macro, strlen (macro)); } -static void -v_cpp_error_with_line (pfile, line, column, msgid, ap) - cpp_reader * pfile; - int line; - int column; - const char * msgid; - va_list ap; +/* Process the string STR as if it appeared as the body of a #assert. */ +void +cpp_assert (pfile, str) + cpp_reader *pfile; + const char *str; { - cpp_buffer *ip = cpp_file_buffer (pfile); - - cpp_print_containing_files (pfile); - - if (ip != NULL) - cpp_file_line_for_message (pfile, ip->nominal_fname, line, column); - - v_cpp_message (pfile, 1, msgid, ap); + handle_assertion (pfile, str, T_ASSERT); } +/* Process STR as if it appeared as the body of an #unassert. */ void -cpp_error_with_line VPROTO ((cpp_reader * pfile, int line, int column, - const char *msgid, ...)) -{ -#ifndef ANSI_PROTOTYPES - cpp_reader *pfile; - int line; - int column; - const char *msgid; -#endif - va_list ap; - - VA_START (ap, msgid); - -#ifndef ANSI_PROTOTYPES - pfile = va_arg (ap, cpp_reader *); - line = va_arg (ap, int); - column = va_arg (ap, int); - msgid = va_arg (ap, const char *); -#endif - - v_cpp_error_with_line(pfile, line, column, msgid, ap); - va_end(ap); -} +cpp_unassert (pfile, str) + cpp_reader *pfile; + const char *str; +{ + handle_assertion (pfile, str, T_UNASSERT); +} +/* Common code for cpp_assert (-A) and cpp_unassert (-A-). */ static void -v_cpp_warning_with_line (pfile, line, column, msgid, ap) - cpp_reader * pfile; - int line; - int column; - const char *msgid; - va_list ap; +handle_assertion (pfile, str, type) + cpp_reader *pfile; + const char *str; + int type; { - cpp_buffer *ip; - - if (CPP_OPTIONS (pfile)->inhibit_warnings) - return; - - if (CPP_OPTIONS (pfile)->warnings_are_errors) - pfile->errors++; - - cpp_print_containing_files (pfile); + size_t count = strlen (str); + const char *p = strchr (str, '='); - ip = cpp_file_buffer (pfile); - - if (ip != NULL) - cpp_file_line_for_message (pfile, ip->nominal_fname, line, column); + if (p) + { + /* Copy the entire option so we can modify it. Change the first + "=" in the string to a '(', and tack a ')' on the end. */ + char *buf = (char *) alloca (count + 2); - v_cpp_message (pfile, 0, msgid, ap); -} + memcpy (buf, str, count); + buf[p - str] = '('; + buf[count++] = ')'; + buf[count] = '\0'; + str = buf; + } -void -cpp_warning_with_line VPROTO ((cpp_reader * pfile, int line, int column, - const char *msgid, ...)) -{ -#ifndef ANSI_PROTOTYPES - cpp_reader *pfile; - int line; - int column; - const char *msgid; -#endif - va_list ap; - - VA_START (ap, msgid); - -#ifndef ANSI_PROTOTYPES - pfile = va_arg (ap, cpp_reader *); - line = va_arg (ap, int); - column = va_arg (ap, int); - msgid = va_arg (ap, const char *); -#endif + run_directive (pfile, type, str, count); +} - v_cpp_warning_with_line (pfile, line, column, msgid, ap); - va_end(ap); +/* The number of errors for a given reader. */ +unsigned int +cpp_errors (pfile) + cpp_reader *pfile; +{ + return pfile->errors; } -void -cpp_pedwarn_with_line VPROTO ((cpp_reader * pfile, int line, int column, - const char *msgid, ...)) -{ -#ifndef ANSI_PROTOTYPES - cpp_reader *pfile; - int line; - int column; - const char *msgid; -#endif - va_list ap; - - VA_START (ap, msgid); - -#ifndef ANSI_PROTOTYPES - pfile = va_arg (ap, cpp_reader *); - line = va_arg (ap, int); - column = va_arg (ap, int); - msgid = va_arg (ap, const char *); -#endif +/* The options structure. */ +cpp_options * +cpp_get_options (pfile) + cpp_reader *pfile; +{ + return &pfile->opts; +} - if (CPP_OPTIONS (pfile)->pedantic_errors) - v_cpp_error_with_line (pfile, column, line, msgid, ap); - else - v_cpp_warning_with_line (pfile, line, column, msgid, ap); - va_end(ap); +/* The callbacks structure. */ +cpp_callbacks * +cpp_get_callbacks (pfile) + cpp_reader *pfile; +{ + return &pfile->cb; } -/* Report a warning (or an error if pedantic_errors) - giving specified file name and line number, not current. */ +/* The line map set. */ +const struct line_maps * +cpp_get_line_maps (pfile) + cpp_reader *pfile; +{ + return &pfile->line_maps; +} +/* Copy the given callbacks structure to our own. */ void -cpp_pedwarn_with_file_and_line VPROTO ((cpp_reader *pfile, char *file, int line, - const char *msgid, ...)) -{ -#ifndef ANSI_PROTOTYPES - cpp_reader *pfile; - char *file; - int line; - const char *msgid; -#endif - va_list ap; - - VA_START (ap, msgid); - -#ifndef ANSI_PROTOTYPES - pfile = va_arg (ap, cpp_reader *); - file = va_arg (ap, char *); - line = va_arg (ap, int); - msgid = va_arg (ap, const char *); -#endif - - if (!CPP_OPTIONS (pfile)->pedantic_errors - && CPP_OPTIONS (pfile)->inhibit_warnings) - return; - if (file != NULL) - cpp_file_line_for_message (pfile, file, line, -1); - v_cpp_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors, msgid, ap); - va_end(ap); +cpp_set_callbacks (pfile, cb) + cpp_reader *pfile; + cpp_callbacks *cb; +{ + pfile->cb = *cb; } -/* my_strerror - return the descriptive text associated with an - `errno' code. */ - -static char * -my_strerror (errnum) - int errnum; +/* Push a new buffer on the buffer stack. Returns the new buffer; it + doesn't fail. It does not generate a file change call back; that + is the responsibility of the caller. */ +cpp_buffer * +cpp_push_buffer (pfile, buffer, len, from_stage3, return_at_eof) + cpp_reader *pfile; + const U_CHAR *buffer; + size_t len; + int from_stage3; + int return_at_eof; { - char *result; + cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer); -#ifndef VMS -#ifndef HAVE_STRERROR - result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0); -#else - result = strerror (errnum); -#endif -#else /* VMS */ - /* VAXCRTL's strerror() takes an optional second argument, which only - matters when the first argument is EVMSERR. However, it's simplest - just to pass it unconditionally. `vaxc$errno' is declared in - <errno.h>, and maintained by the library in parallel with `errno'. - We assume that caller's `errnum' either matches the last setting of - `errno' by the library or else does not have the value `EVMSERR'. */ - - result = strerror (errnum, vaxc$errno); -#endif + /* Clears, amongst other things, if_stack and mi_cmacro. */ + memset (new, 0, sizeof (cpp_buffer)); - if (!result) - result = "errno = ?"; - - return result; -} + new->line_base = new->buf = new->cur = buffer; + new->rlimit = buffer + len; + new->from_stage3 = from_stage3; + new->prev = pfile->buffer; + new->return_at_eof = return_at_eof; + new->saved_flags = BOL; -/* Error including a message from `errno'. */ + pfile->buffer = new; -void -cpp_error_from_errno (pfile, name) - cpp_reader *pfile; - const char *name; -{ - cpp_message_from_errno (pfile, 1, name); + return new; } +/* If called from do_line, pops a single buffer. Otherwise pops all + buffers until a real file is reached. Generates appropriate + call-backs. */ void -cpp_message_from_errno (pfile, is_error, name) +_cpp_pop_buffer (pfile) cpp_reader *pfile; - int is_error; - const char *name; { - int e = errno; - cpp_buffer *ip = cpp_file_buffer (pfile); + cpp_buffer *buffer = pfile->buffer; + struct if_stack *ifs; + bool pushed = false; + + /* Walk back up the conditional stack till we reach its level at + entry to this file, issuing error messages. */ + for (ifs = buffer->if_stack; ifs; ifs = ifs->next) + cpp_error_with_line (pfile, ifs->line, 0, + "unterminated #%s", dtable[ifs->type].name); - cpp_print_containing_files (pfile); + /* In case of a missing #endif. */ + pfile->state.skipping = 0; - if (ip != NULL) - cpp_file_line_for_message (pfile, ip->nominal_fname, ip->lineno, -1); + /* Update the reader's buffer before _cpp_do_file_change. */ + pfile->buffer = buffer->prev; - cpp_message (pfile, is_error, "%s: %s", name, my_strerror (e)); + if (buffer->inc) + pushed = _cpp_pop_file_buffer (pfile, buffer->inc); + + if (!pushed) + obstack_free (&pfile->buffer_ob, buffer); } +/* Enter all recognised directives in the hash table. */ void -cpp_perror_with_name (pfile, name) +_cpp_init_directives (pfile) cpp_reader *pfile; - const char *name; { - cpp_message (pfile, 1, "%s: %s: %s", progname, name, my_strerror (errno)); -} + unsigned int i; + cpp_hashnode *node; -/* TODO: - * No pre-compiled header file support. - * - * Possibly different enum token codes for each C/C++ token. - * - * Find and cleanup remaining uses of static variables, - * - * Support -dM flag (dump_all_macros). - * - * Support for_lint flag. - */ + for (i = 0; i < (unsigned int) N_DIRECTIVES; i++) + { + node = cpp_lookup (pfile, dtable[i].name, dtable[i].length); + node->directive_index = i + 1; + } +} |
