-/* CPP Library.
+/* CPP Library. (Directive handling.)
Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000 Free Software Foundation, Inc.
+ 1999, 2000, 2001 Free Software Foundation, Inc.
Contributed by Per Bothner, 1994-95.
Based on CCCP program by Paul Rubin, June 1986
Adapted to ANSI C, Richard Stallman, Jan 1987
#include "cpplib.h"
#include "cpphash.h"
-#include "intl.h"
#include "obstack.h"
-#include "symcat.h"
+
+/* Chained list of answers to an assertion. */
+struct answer
+{
+ struct answer *next;
+ unsigned int count;
+ cpp_token first[1];
+};
/* Stack of conditionals currently in progress
(including both successful and failing conditionals). */
struct if_stack
{
struct if_stack *next;
- unsigned int lineno; /* line number where condition started */
- unsigned int colno; /* and column */
- int was_skipping; /* value of pfile->skipping before this if */
- const cpp_hashnode *cmacro; /* macro name for #ifndef around entire file */
- int type; /* type of last directive seen in this group */
+ 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. */
+};
+
+/* 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;
+};
+
+/* 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. */
};
/* Forward declarations. */
-static void validate_else PARAMS ((cpp_reader *, const U_CHAR *));
-static int parse_include PARAMS ((cpp_reader *, const U_CHAR *, int,
- const U_CHAR **, unsigned int *,
- int *));
+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 int read_line_number PARAMS ((cpp_reader *, int *));
+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));
-static const cpp_hashnode *
- parse_ifdef PARAMS ((cpp_reader *, const U_CHAR *));
-static const cpp_hashnode *
- detect_if_not_defined PARAMS ((cpp_reader *));
-static cpp_hashnode *
- get_define_node PARAMS ((cpp_reader *));
-static void unwind_if_stack PARAMS ((cpp_reader *, cpp_buffer *));
+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).
+ 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. */
- The entries with a dash and a name after the count are extensions,
- of which all but #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 /* nothing */
#endif
-#define DIRECTIVE_TABLE \
-D(define, T_DEFINE = 0, KANDR, COMMENTS | IN_I)/* 270554 */ \
-D(include, T_INCLUDE, KANDR, EXPAND | INCL) /* 52262 */ \
-D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
-D(ifdef, T_IFDEF, KANDR, COND) /* 22000 */ \
-D(if, T_IF, KANDR, COND | EXPAND) /* 18162 */ \
-D(else, T_ELSE, KANDR, COND) /* 9863 */ \
-D(ifndef, T_IFNDEF, KANDR, COND) /* 9675 */ \
-D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
-D(line, T_LINE, KANDR, EXPAND) /* 2465 */ \
-D(elif, T_ELIF, KANDR, COND | EXPAND) /* 610 */ \
-D(error, T_ERROR, STDC89, 0) /* 475 */ \
-D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
-D(warning, T_WARNING, EXTENSION, 0) /* 22 GNU */ \
-D(include_next, T_INCLUDE_NEXT, EXTENSION, EXPAND | INCL) /* 19 GNU */ \
-D(ident, T_IDENT, EXTENSION, IN_I) /* 11 SVR4 */ \
-D(import, T_IMPORT, EXTENSION, EXPAND | INCL) /* 0 ObjC */ \
-D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
-D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
-SCCS_ENTRY /* 0 SVR2? */
-
/* Use the table to generate a series of prototypes, an enum for the
directive names, and an array of directive handlers. */
instead of void, because some old compilers have trouble with
pointers to functions returning void. */
-/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
+/* 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
};
#undef D
-/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
+/* 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 struct directive dtable[] =
+static const directive dtable[] =
{
DIRECTIVE_TABLE
};
#undef D
#undef DIRECTIVE_TABLE
-/* Check if a token's name matches that of a known directive. Put in
- this file to save exporting dtable and other unneeded information. */
-const struct directive *
-_cpp_check_directive (pfile, token)
+#define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
+
+/* Skip any remaining tokens in a directive. */
+static void
+skip_rest_of_line (pfile)
cpp_reader *pfile;
- const cpp_token *token;
{
- unsigned int i;
+ /* Discard all stacked contexts. */
+ while (pfile->context != &pfile->base_context)
+ _cpp_pop_context (pfile);
+
+ /* Sweep up all tokens remaining on the line. */
+ if (! SEEN_EOL ())
+ while (_cpp_lex_token (pfile)->type != CPP_EOF)
+ ;
+}
- if (token->type != CPP_NAME)
- {
- if (token->type == CPP_EOF && CPP_WTRADITIONAL (pfile)
- && pfile->state.indented)
- cpp_warning (pfile, "traditional C ignores #\\n with the # indented");
+/* Ensure there are no stray tokens at the end of a directive. */
+static void
+check_eol (pfile)
+ cpp_reader *pfile;
+{
+ if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF)
+ cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
+ pfile->directive->name);
+}
- return 0;
- }
+/* Called when entering a directive, _Pragma or command-line directive. */
+static void
+start_directive (pfile)
+ cpp_reader *pfile;
+{
+ /* Setup in-directive state. */
+ pfile->state.in_directive = 1;
+ pfile->state.save_comments = 0;
- for (i = 0; i < N_DIRECTIVES; i++)
- if (pfile->spec_nodes->dirs[i] == token->val.node)
- break;
+ /* Some handlers need the position of the # for diagnostics. */
+ pfile->directive_line = pfile->line;
+}
- if (i == N_DIRECTIVES)
- return 0;
+/* Called when leaving a directive, _Pragma or command-line directive. */
+static void
+end_directive (pfile, skip_line)
+ cpp_reader *pfile;
+ int skip_line;
+{
+ /* We don't skip for an assembler #. */
+ if (skip_line)
+ {
+ skip_rest_of_line (pfile);
+ if (!pfile->keep_tokens)
+ {
+ pfile->cur_run = &pfile->base_run;
+ pfile->cur_token = pfile->base_run.base;
+ }
+ }
- /* We should lex headers correctly, regardless of whether we're
- skipping or not. */
- pfile->state.angled_headers = dtable[i].flags & INCL;
+ /* 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;
+}
+
+/* Output diagnostics for a directive DIR. INDENTED is non-zero if
+ the '#' was indented. */
- /* If we are rescanning preprocessed input, only directives tagged
- with IN_I are honored, and the warnings below are suppressed. */
- if (CPP_OPTION (pfile, preprocessed))
+static void
+directive_diagnostics (pfile, dir, indented)
+ cpp_reader *pfile;
+ const directive *dir;
+ int indented;
+{
+ if (pfile->state.line_extension)
{
- if (!dtable[i].flags & IN_I)
- return 0;
+ if (CPP_PEDANTIC (pfile)
+ && ! pfile->state.skipping)
+ cpp_pedwarn (pfile, "style of line directive is a GCC extension");
}
else
{
+ /* 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 #
blocks. */
if (CPP_WTRADITIONAL (pfile))
{
- if (pfile->state.indented && dtable[i].origin == KANDR)
- cpp_warning (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",
- dtable[i].name);
-
- else if (!pfile->state.indented && dtable[i].origin != KANDR)
+ dir->name);
+ else if (!indented && dir->origin != KANDR)
cpp_warning (pfile,
"suggest hiding #%s from traditional C with an indented #",
- dtable[i].name);
+ dir->name);
}
+ }
+}
- /* If we are skipping a failed conditional group, all non-conditional
- directives are ignored. */
- if (pfile->skipping && !(dtable[i].flags & COND))
- return 0;
+/* 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. */
- /* Issue -pedantic warnings for extended directives. */
- if (CPP_PEDANTIC (pfile) && dtable[i].origin == EXTENSION)
- cpp_pedwarn (pfile, "ISO C does not allow #%s", dtable[i].name);
- }
+int
+_cpp_handle_directive (pfile, indented)
+ cpp_reader *pfile;
+ int indented;
+{
+ const directive *dir = 0;
+ const cpp_token *dname;
+ int skip = 1;
- /* Only flag to save comments if we process the directive. */
- pfile->state.save_comments = (! CPP_OPTION (pfile, discard_comments)
- && (dtable[i].flags & COMMENTS));
+ start_directive (pfile);
+ dname = _cpp_lex_token (pfile);
- return &dtable[i];
-}
+ if (dname->type == CPP_NAME)
+ {
+ if (dname->val.node->directive_index)
+ dir = &dtable[dname->val.node->directive_index - 1];
+ }
+ /* 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)
+ {
+ dir = &dtable[T_LINE];
+ pfile->state.line_extension = 1;
+ }
-const struct directive *
-_cpp_check_linemarker (pfile, token)
- cpp_reader *pfile;
- const cpp_token *token ATTRIBUTE_UNUSED;
-{
- /* # followed by a number is equivalent to #line. Do not recognize
- this form in assembly language source files or skipped
- conditional groups. Complain about this form if we're being
- pedantic, but not if this is regurgitated input (preprocessed or
- fed back in by the C++ frontend). */
- if (pfile->skipping || CPP_OPTION (pfile, lang_asm))
- return 0;
+ 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;
+
+ /* Kluge alert. In order to be sure that code like this
+
+ #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 fron of any '#' at the start of a macro. */
+ if (CPP_OPTION (pfile, preprocessed)
+ && (indented || !(dir->flags & IN_I)))
+ {
+ skip = 0;
+ dir = 0;
+ }
+ else
+ {
+ /* 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 if (dname->type == CPP_EOF)
+ ; /* CPP_EOF is the "null directive". */
+ else
+ {
+ /* 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));
+ }
- if (CPP_PEDANTIC (pfile) && CPP_BUFFER (pfile)->inc
- && ! CPP_OPTION (pfile, preprocessed))
- cpp_pedwarn (pfile, "# followed by integer");
+ if (dir)
+ {
+ pfile->directive = dir;
+ (*pfile->directive->handler) (pfile);
+ }
+ else if (skip == 0)
+ _cpp_backup_tokens (pfile, 1);
- /* In -traditional mode, a directive is ignored unless its #
- is in column 1. */
- if (pfile->state.indented && CPP_WTRADITIONAL (pfile))
- cpp_warning (pfile, "traditional C ignores #%s with the # indented",
- dtable[T_LINE].name);
+ end_directive (pfile, skip);
+ return skip;
+}
- return &dtable[T_LINE];
-}
+/* 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 *
-get_define_node (pfile)
+lex_macro_node (pfile)
cpp_reader *pfile;
{
- const cpp_token *token;
-
- /* Skip any -C comments. */
- while ((token = _cpp_get_token (pfile))->type == CPP_COMMENT)
- ;
+ cpp_hashnode *node;
+ const cpp_token *token = _cpp_lex_token (pfile);
/* The token immediately after #define must be an identifier. That
- identifier is not allowed to be "defined". See predefined macro
- names (6.10.8.4). In C++, it is not allowed to be any of the
- <iso646.h> macro names (which are keywords in C++) either. */
+ 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_DEFINED)
- cpp_error_with_line (pfile, token->line, token->col,
- "\"defined\" cannot be used as a macro 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_with_line (pfile, token->line, token->col,
- "\"%s\" cannot be used as a macro name in C++",
- token->val.node->name);
+ 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_with_line (pfile, token->line, token->col,
- "macro names must be identifiers");
- return 0;
- }
+ cpp_error (pfile, "macro names must be identifiers");
- /* In Objective C, some keywords begin with '@', but general identifiers
- do not, and you're not allowed to #define them. */
- if (token->val.node->name[0] == '@')
- {
- cpp_error_with_line (pfile, token->line, token->col,
- "\"%s\" cannot be used as a macro name",
- token->val.node->name);
return 0;
}
- /* Check for poisoned identifiers now. */
- if (token->val.node->type == T_POISON)
+ node = token->val.node;
+ if (node->flags & NODE_POISONED)
+ return 0;
+
+ if (node == pfile->spec_nodes.n_defined)
{
- cpp_error_with_line (pfile, token->line, token->col,
- "attempt to use poisoned \"%s\"",
- token->val.node->name);
+ cpp_error (pfile, "\"%s\" cannot be used as a macro name",
+ NODE_NAME (node));
return 0;
}
- return token->val.node;
+ return node;
}
-/* Process a #define command. */
+/* Process a #define directive. Most work is done in cppmacro.c. */
static void
do_define (pfile)
cpp_reader *pfile;
{
- cpp_hashnode *node;
+ cpp_hashnode *node = lex_macro_node (pfile);
- if ((node = get_define_node (pfile)))
- if (_cpp_create_definition (pfile, node))
- if (pfile->cb.define)
- (*pfile->cb.define) (pfile, node);
+ if (node)
+ {
+ if (_cpp_create_definition (pfile, node))
+ if (pfile->cb.define)
+ (*pfile->cb.define) (pfile, pfile->directive_line, node);
+ }
}
-/* Remove the definition of a symbol from the symbol table. */
+/* Handle #undef. Marks the identifier NT_VOID in the hash table. */
static void
do_undef (pfile)
cpp_reader *pfile;
{
- cpp_hashnode *node = get_define_node (pfile);
-
- if (_cpp_get_token (pfile)->type != CPP_EOF)
- cpp_pedwarn (pfile, "junk on line after #undef");
+ cpp_hashnode *node = lex_macro_node (pfile);
/* 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 != T_VOID)
+ if (node && node->type == NT_MACRO)
{
if (pfile->cb.undef)
- (*pfile->cb.undef) (pfile, node);
+ (*pfile->cb.undef) (pfile, pfile->directive_line, node);
- if (node->type != T_MACRO)
- cpp_warning (pfile, "undefining \"%s\"", node->name);
+ if (node->flags & NODE_WARN)
+ cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
_cpp_free_definition (node);
}
+ check_eol (pfile);
}
-
-/* Handle #include and #import. */
-
-static int
-parse_include (pfile, dir, trail, strp, lenp, abp)
+/* 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;
- const U_CHAR *dir;
- int trail;
- const U_CHAR **strp;
- unsigned int *lenp;
- int *abp;
{
- const cpp_token *name = _cpp_get_token (pfile);
+ cpp_token *header = NULL;
+ const cpp_token *token;
+ unsigned char *dest;
+ size_t len;
- if (name->type != CPP_STRING && name->type != CPP_HEADER_NAME)
+ /* To avoid lexed tokens overwriting our glued name, we can only
+ allocate from the string pool once we've lexed everything. */
+
+ dest = BUFF_FRONT (pfile->u_buff);
+ for (;;)
{
- if (name->type == CPP_LESS)
- name = _cpp_glue_header_name (pfile);
- else
+ token = cpp_get_token (pfile);
+
+ if (token->type == CPP_GREATER || token->type == CPP_EOF)
+ break;
+
+ /* + 1 for terminating NUL. */
+ len = cpp_token_len (token) + 1;
+ if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
{
- cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
- return 1;
+ 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;
}
+
+ if (token->flags & PREV_WHITE)
+ *dest++ = ' ';
+
+ dest = cpp_spell_token (pfile, token, dest);
}
- if (name->val.str.len == 0)
+
+ if (token->type == CPP_EOF)
+ cpp_error (pfile, "missing terminating > character");
+ else
{
- cpp_error (pfile, "empty file name in #%s", dir);
- return 1;
+ 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;
}
- if (!trail && _cpp_get_token (pfile)->type != CPP_EOF)
- cpp_error (pfile, "junk at end of #%s", dir);
-
- *lenp = name->val.str.len;
- *strp = name->val.str.text;
- *abp = (name->type == CPP_HEADER_NAME);
-
- if (pfile->cb.include)
- (*pfile->cb.include) (pfile, dir, *strp, *lenp, *abp);
- return 0;
+ return header;
}
-static void
-do_include (pfile)
+/* 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;
{
- unsigned int len;
- const U_CHAR *str;
- int ab;
+ const unsigned char *dir;
+ const cpp_token *header;
- if (parse_include (pfile, dtable[T_INCLUDE].name, 0, &str, &len, &ab))
- return;
+ if (pfile->directive == &dtable[T_PRAGMA])
+ dir = U"pragma dependency";
+ else
+ dir = pfile->directive->name;
+
+ /* Allow macro expansion. */
+ header = cpp_get_token (pfile);
+ if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
+ {
+ if (header->type != CPP_LESS)
+ {
+ cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
+ return NULL;
+ }
- _cpp_execute_include (pfile, str, len, 0, 0, ab);
+ header = glue_header_name (pfile);
+ if (header == NULL)
+ return header;
+ }
+
+ if (header->val.str.len == 0)
+ {
+ cpp_error (pfile, "empty file name in #%s", dir);
+ return NULL;
+ }
+
+ return header;
}
+/* Handle #include, #include_next and #import. */
static void
-do_import (pfile)
+do_include_common (pfile, type)
cpp_reader *pfile;
+ enum include_type type;
{
- unsigned int len;
- const U_CHAR *str;
- int ab;
+ const cpp_token *header;
- if (!pfile->import_warning && CPP_OPTION (pfile, warn_import))
+ /* 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)
+ {
+ cpp_warning (pfile, "#include_next in primary source file");
+ type = IT_INCLUDE;
+ }
+ 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");
}
- if (parse_include (pfile, dtable[T_IMPORT].name, 0, &str, &len, &ab))
- return;
-
- _cpp_execute_include (pfile, str, len, 1, 0, ab);
+ header = parse_include (pfile);
+ if (header)
+ {
+ /* Prevent #include recursion. */
+ if (pfile->line_maps.depth >= CPP_STACK_MAX)
+ cpp_fatal (pfile, "#include nested too deeply");
+ else
+ {
+ 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);
+ }
+ }
}
static void
-do_include_next (pfile)
+do_include (pfile)
cpp_reader *pfile;
{
- unsigned int len;
- const U_CHAR *str;
- struct file_name_list *search_start = 0;
- int ab;
-
- if (parse_include (pfile, dtable[T_INCLUDE_NEXT].name, 0, &str, &len, &ab))
- return;
+ do_include_common (pfile, IT_INCLUDE);
+}
- /* For #include_next, skip in the search path past the dir in which
- the current file was found. If this is the last directory in the
- search path, don't include anything. If the current file was
- specified with an absolute path, use the normal search logic. If
- this is the primary source file, use the normal search logic and
- generate a warning. */
- if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)))
- {
- if (CPP_BUFFER (pfile)->inc->foundhere)
- {
- search_start = CPP_BUFFER (pfile)->inc->foundhere->next;
- if (!search_start)
- return;
- }
- }
- else
- cpp_warning (pfile, "#include_next in primary source file");
+static void
+do_import (pfile)
+ cpp_reader *pfile;
+{
+ do_include_common (pfile, IT_IMPORT);
+}
- _cpp_execute_include (pfile, str, len, 0, search_start, ab);
+static void
+do_include_next (pfile)
+ cpp_reader *pfile;
+{
+ do_include_common (pfile, IT_INCLUDE_NEXT);
}
-/* Subroutine of do_line. Read next token from PFILE without adding it to
- the output buffer. If it is a number between 1 and 4, store it in *NUM
- and return 1; otherwise, return 0 and complain if we aren't at the end
- of the directive. */
+/* 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 int
-read_line_number (pfile, num)
+static unsigned int
+read_flag (pfile, last)
cpp_reader *pfile;
- int *num;
+ unsigned int last;
{
- const cpp_token *tok = _cpp_get_token (pfile);
- enum cpp_ttype type = tok->type;
- const U_CHAR *p = tok->val.str.text;
- unsigned int len = tok->val.str.len;
+ const cpp_token *token = _cpp_lex_token (pfile);
- if (type == CPP_NUMBER && len == 1 && p[0] >= '1' && p[0] <= '4')
- {
- *num = p[0] - '0';
- return 1;
- }
- else
+ if (token->type == CPP_NUMBER && token->val.str.len == 1)
{
- if (type != CPP_EOF)
- cpp_error (pfile, "invalid format #line");
- return 0;
+ unsigned int flag = token->val.str.text[0] - '0';
+
+ if (flag > last && flag <= 4
+ && (flag != 4 || last == 3)
+ && (flag != 2 || last == 0))
+ return flag;
}
+
+ 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
do_line (pfile)
cpp_reader *pfile;
{
- cpp_buffer *ip = CPP_BUFFER (pfile);
- unsigned long new_lineno, old_lineno;
- /* C99 raised the minimum limit on #line numbers. */
- unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
- int action_number = 0;
- int enter = 0, leave = 0, rename = 0;
- enum cpp_ttype type;
- const U_CHAR *str;
- char *fname;
- unsigned int len;
- const cpp_token *tok;
-
- tok = _cpp_get_token (pfile);
- type = tok->type;
- str = tok->val.str.text;
- len = tok->val.str.len;
+ 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;
- if (type != CPP_NUMBER || strtoul_for_line (str, len, &new_lineno))
+ /* C99 raised the minimum limit on #line numbers. */
+ cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
+
+ /* 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);
+
+ /* #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 a positive integer");
+ cpp_error (pfile, "\"%s\" after #line is not a positive integer",
+ cpp_token_as_text (pfile, token));
return;
}
- if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
+ if (CPP_PEDANTIC (pfile) && ! pfile->state.line_extension
+ && (new_lineno == 0 || new_lineno > cap))
cpp_pedwarn (pfile, "line number out of range");
- old_lineno = ip->lineno;
- ip->lineno = new_lineno;
- tok = _cpp_get_token (pfile);
- type = tok->type;
- str = tok->val.str.text;
- len = tok->val.str.len;
-
- if (type == CPP_EOF)
- goto done;
- else if (type != CPP_STRING)
+ token = cpp_get_token (pfile);
+ if (token->type == CPP_STRING)
{
- cpp_error (pfile, "second token after #line is not a string");
- ip->lineno = old_lineno; /* malformed #line should have no effect */
- return;
- }
+ new_file = (const char *) token->val.str.text;
- fname = alloca (len + 1);
- memcpy (fname, str, len);
- fname[len] = '\0';
-
- if (strcmp (fname, ip->nominal_fname))
- {
- rename = 1;
- if (!strcmp (fname, ip->inc->name))
- ip->nominal_fname = ip->inc->name;
- else
- ip->nominal_fname = _cpp_fake_include (pfile, fname);
- }
-
- if (read_line_number (pfile, &action_number) == 0)
- goto done;
-
- if (CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "garbage at end of #line");
+ /* Only accept flags for the # 55 form. */
+ if (pfile->state.line_extension)
+ {
+ int flag;
- if (action_number == 1)
- {
- enter = 1;
- cpp_make_system_header (pfile, ip, 0);
- read_line_number (pfile, &action_number);
- }
- else if (action_number == 2)
- {
- leave = 1;
- cpp_make_system_header (pfile, ip, 0);
- read_line_number (pfile, &action_number);
- }
- if (action_number == 3)
- {
- cpp_make_system_header (pfile, ip, 1);
- read_line_number (pfile, &action_number);
+ new_sysp = 0;
+ flag = read_flag (pfile, 0);
+ if (flag == 1)
+ {
+ reason = LC_ENTER;
+ /* Fake an include for cpp_included (). */
+ _cpp_fake_include (pfile, new_file);
+ flag = read_flag (pfile, flag);
+ }
+ else if (flag == 2)
+ {
+ reason = LC_LEAVE;
+ flag = read_flag (pfile, flag);
+ }
+ if (flag == 3)
+ {
+ new_sysp = 1;
+ flag = read_flag (pfile, flag);
+ if (flag == 4)
+ new_sysp = 2;
+ }
+ }
+ check_eol (pfile);
}
- if (action_number == 4)
+ else if (token->type != CPP_EOF)
{
- cpp_make_system_header (pfile, ip, 2);
- read_line_number (pfile, &action_number);
+ cpp_error (pfile, "\"%s\" is not a valid filename",
+ cpp_token_as_text (pfile, token));
+ return;
}
- done:
- if (enter && pfile->cb.enter_file)
- (*pfile->cb.enter_file) (pfile);
- if (leave && pfile->cb.leave_file)
- (*pfile->cb.leave_file) (pfile);
- if (rename && pfile->cb.rename_file)
- (*pfile->cb.rename_file) (pfile);
+ skip_rest_of_line (pfile);
+ _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
+}
+
+/* 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 sytem 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;
+ 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);
+
+ if (pfile->cb.file_change)
+ (*pfile->cb.file_change) (pfile, pfile->map);
}
/*
*/
static void
-do_diagnostic (pfile, code)
+do_diagnostic (pfile, code, print_dir)
cpp_reader *pfile;
enum error_type code;
+ int print_dir;
{
- if (_cpp_begin_message (pfile, code, NULL, 0, 0))
+ if (_cpp_begin_message (pfile, code, 0, 0))
{
- cpp_output_list (pfile, stderr, &pfile->token_list,
- pfile->first_directive_token);
- putc ('\n', stderr);
+ if (print_dir)
+ fprintf (stderr, "#%s ", pfile->directive->name);
+ pfile->state.prevent_expansion++;
+ cpp_output_line (pfile, stderr);
+ pfile->state.prevent_expansion--;
}
}
do_error (pfile)
cpp_reader *pfile;
{
- do_diagnostic (pfile, ERROR);
+ do_diagnostic (pfile, ERROR, 1);
}
static void
do_warning (pfile)
cpp_reader *pfile;
{
- do_diagnostic (pfile, WARNING);
+ /* We want #warning diagnostics to be emitted in system headers too. */
+ do_diagnostic (pfile, WARNING_SYSHDR, 1);
}
/* Report program identification. */
do_ident (pfile)
cpp_reader *pfile;
{
- const cpp_token *str = _cpp_get_token (pfile);
+ const cpp_token *str = cpp_get_token (pfile);
- if (str->type == CPP_STRING && _cpp_get_token (pfile)->type == CPP_EOF)
- {
- if (pfile->cb.ident)
- (*pfile->cb.ident) (pfile, str->val.str.text, str->val.str.len);
- return;
- }
+ 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);
- cpp_error (pfile, "invalid #ident");
+ check_eol (pfile);
}
-/* Pragmata handling. We handle some of these, 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.
-
- We currently do not support the _Pragma operator. Support for that
- has to be coordinated with the front end. Proposed implementation:
- both #pragma blah blah and _Pragma("blah blah") become
- __builtin_pragma(blah blah) and we teach the parser about that. */
-
-/* Sub-handlers for the pragmas needing treatment here.
- They return 1 if the token buffer is to be popped, 0 if not. */
-struct pragma_entry
+/* 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;
{
- struct pragma_entry *next;
- const char *name;
- size_t len;
- int isnspace;
- union {
- void (*handler) PARAMS ((cpp_reader *));
- struct pragma_entry *space;
- } u;
-};
+ while (chain && chain->pragma != pragma)
+ chain = chain->next;
-void
-cpp_register_pragma (pfile, space, name, handler)
+ 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;
- const char *space;
- const char *name;
- void (*handler) PARAMS ((cpp_reader *));
+ struct pragma_entry **chain;
+ const cpp_hashnode *pragma;
+ pragma_cb handler;
{
- struct pragma_entry **x, *new;
- size_t len;
+ struct pragma_entry *new;
- x = &pfile->pragmas;
- if (space)
+ new = (struct pragma_entry *)
+ _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
+ new->pragma = pragma;
+ if (handler)
{
- struct pragma_entry *p = pfile->pragmas;
- len = strlen (space);
- while (p)
- {
- if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
- {
- x = &p->u.space;
- goto found;
- }
- p = p->next;
- }
- cpp_ice (pfile, "unknown #pragma namespace %s", space);
- return;
+ new->is_nspace = 0;
+ new->u.handler = handler;
+ }
+ else
+ {
+ new->is_nspace = 1;
+ new->u.space = NULL;
}
- found:
- new = xnew (struct pragma_entry);
- new->name = name;
- new->len = strlen (name);
- new->isnspace = 0;
- new->u.handler = handler;
-
- new->next = *x;
- *x = new;
+ new->next = *chain;
+ *chain = new;
+ return new;
}
+/* 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_space (pfile, space)
+cpp_register_pragma (pfile, space, name, handler)
cpp_reader *pfile;
const char *space;
+ const char *name;
+ pragma_cb handler;
{
- struct pragma_entry *new;
- const struct pragma_entry *p = pfile->pragmas;
- size_t len = strlen (space);
+ struct pragma_entry **chain = &pfile->pragmas;
+ struct pragma_entry *entry;
+ const cpp_hashnode *node;
+
+ if (!handler)
+ abort ();
- while (p)
+ if (space)
{
- if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
- /* Multiple different callers are allowed to register the same
- namespace. */
- return;
- p = p->next;
+ 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;
}
- new = xnew (struct pragma_entry);
- new->name = space;
- new->len = len;
- new->isnspace = 1;
- new->u.space = 0;
-
- new->next = pfile->pragmas;
- pfile->pragmas = new;
+ /* 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);
}
-
-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 *));
+/* Register the pragmas the preprocessor itself handles. */
void
_cpp_init_internal_pragmas (pfile)
cpp_reader *pfile;
{
- /* top level */
+ /* Pragmas in the global namespace. */
cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
cpp_register_pragma (pfile, 0, "once", do_pragma_once);
- /* GCC namespace */
- cpp_register_pragma_space (pfile, "GCC");
-
+ /* 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);
}
+/* 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;
{
- const struct pragma_entry *p;
- const cpp_token *tok;
- const cpp_hashnode *node;
- const U_CHAR *name;
- size_t len;
-
- p = pfile->pragmas;
-
- new_space:
- tok = _cpp_get_token (pfile);
- if (tok->type == CPP_EOF)
- return;
+ const struct pragma_entry *p = NULL;
+ const cpp_token *token;
+ unsigned int count = 1;
- if (tok->type != CPP_NAME)
- {
- cpp_error (pfile, "malformed #pragma directive");
- return;
- }
+ pfile->state.prevent_expansion++;
- node = tok->val.node;
- name = node->name;
- len = node->length;
- while (p)
+ token = cpp_get_token (pfile);
+ if (token->type == CPP_NAME)
{
- if (strlen (p->name) == len && !memcmp (p->name, name, len))
+ p = lookup_pragma_entry (pfile->pragmas, token->val.node);
+ if (p && p->is_nspace)
{
- if (p->isnspace)
- {
- p = p->u.space;
- goto new_space;
- }
+ count = 2;
+ token = cpp_get_token (pfile);
+ if (token->type == CPP_NAME)
+ p = lookup_pragma_entry (p->u.space, token->val.node);
else
- {
- (*p->u.handler) (pfile);
- return;
- }
+ p = NULL;
}
- p = p->next;
}
- if (pfile->cb.def_pragma)
- (*pfile->cb.def_pragma) (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 (p)
+ (*p->u.handler) (pfile);
+ else if (pfile->cb.def_pragma)
+ {
+ _cpp_backup_tokens (pfile, count);
+ (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
+ }
+
+ pfile->state.prevent_expansion--;
}
static void
do_pragma_once (pfile)
cpp_reader *pfile;
{
- cpp_buffer *ip = CPP_BUFFER (pfile);
-
- /* Allow #pragma once in system headers, since that's not the user's
- fault. */
cpp_warning (pfile, "#pragma once is obsolete");
- if (CPP_PREV_BUFFER (ip) == NULL)
- cpp_warning (pfile, "#pragma once outside include file");
+ if (pfile->buffer->prev == NULL)
+ cpp_warning (pfile, "#pragma once in main file");
else
- ip->inc->cmacro = NEVER_REREAD;
+ _cpp_never_reread (pfile->buffer->inc);
+
+ check_eol (pfile);
}
static void
const cpp_token *tok;
cpp_hashnode *hp;
+ pfile->state.poisoned_ok = 1;
for (;;)
{
- tok = _cpp_get_token (pfile);
+ tok = _cpp_lex_token (pfile);
if (tok->type == CPP_EOF)
break;
if (tok->type != CPP_NAME)
{
- cpp_error (pfile, "invalid #pragma poison directive");
- return;
+ cpp_error (pfile, "invalid #pragma GCC poison directive");
+ break;
}
hp = tok->val.node;
- if (hp->type == T_POISON)
- ; /* It is allowed to poison the same identifier twice. */
- else
- {
- if (hp->type != T_VOID)
- cpp_warning (pfile, "poisoning existing macro \"%s\"", hp->name);
- _cpp_free_definition (hp);
- hp->type = T_POISON;
- }
- }
+ if (hp->flags & NODE_POISONED)
+ continue;
- if (pfile->cb.poison)
- (*pfile->cb.poison) (pfile);
+ 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;
}
/* Mark the current header as a system header. This will suppress
do_pragma_system_header (pfile)
cpp_reader *pfile;
{
- cpp_buffer *ip = CPP_BUFFER (pfile);
- if (CPP_PREV_BUFFER (ip) == NULL)
- cpp_warning (pfile, "#pragma system_header outside include file");
+ cpp_buffer *buffer = pfile->buffer;
+
+ if (buffer->prev == 0)
+ cpp_warning (pfile, "#pragma system_header ignored outside include file");
else
- cpp_make_system_header (pfile, ip, 1);
+ {
+ check_eol (pfile);
+ skip_rest_of_line (pfile);
+ cpp_make_system_header (pfile, 1, 0);
+ }
}
/* Check the modified date of the current include file against a specified
do_pragma_dependency (pfile)
cpp_reader *pfile;
{
- const U_CHAR *name;
- unsigned int len;
- int ordering, ab;
- char left, right;
+ const cpp_token *header;
+ int ordering;
- if (parse_include (pfile, U"pragma dependency", 1, &name, &len, &ab))
+ header = parse_include (pfile);
+ if (!header)
return;
- left = ab ? '<' : '"';
- right = ab ? '>' : '"';
-
- ordering = _cpp_compare_file_date (pfile, name, len, ab);
+ ordering = _cpp_compare_file_date (pfile, header);
if (ordering < 0)
- cpp_warning (pfile, "cannot find source %c%s%c", left, name, right);
+ cpp_warning (pfile, "cannot find source %s",
+ cpp_token_as_text (pfile, header));
else if (ordering > 0)
{
- const cpp_token *msg = _cpp_get_token (pfile);
-
- cpp_warning (pfile, "current file is older than %c%.*s%c",
- left, (int)len, name, right);
- if (msg->type != CPP_EOF
- && _cpp_begin_message (pfile, WARNING, NULL, msg->line, msg->col))
+ cpp_warning (pfile, "current file is older than %s",
+ cpp_token_as_text (pfile, header));
+ if (cpp_get_token (pfile)->type != CPP_EOF)
{
- cpp_output_list (pfile, stderr, &pfile->token_list, msg);
- putc ('\n', stderr);
+ _cpp_backup_tokens (pfile, 1);
+ do_diagnostic (pfile, WARNING, 0);
}
}
}
-/* Just ignore #sccs, on systems where we define it at all. */
-#ifdef SCCS_DIRECTIVE
-static void
-do_sccs (pfile)
- cpp_reader *pfile ATTRIBUTE_UNUSED;
+/* Get a token but skip padding. */
+static const cpp_token *
+get_token_no_padding (pfile)
+ cpp_reader *pfile;
{
+ for (;;)
+ {
+ const cpp_token *result = cpp_get_token (pfile);
+ if (result->type != CPP_PADDING)
+ return result;
+ }
}
-#endif
-
-/* We've found an `#if' directive. If the only thing before it in
- this file is white space, and if it is of the form
- `#if ! defined SYMBOL', then SYMBOL is a possible controlling macro
- for inclusion of this file. (See redundant_include_p in cppfiles.c
- for an explanation of controlling macros.) If so, return the
- hash node for SYMBOL. Otherwise, return NULL. */
-static const cpp_hashnode *
-detect_if_not_defined (pfile)
+/* 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;
{
- const cpp_token *token;
- cpp_hashnode *cmacro = 0;
-
- /* We are guaranteed that tokens are consecutive and end in CPP_EOF. */
- token = pfile->first_directive_token + 2;
+ const cpp_token *string;
- if (token->type != CPP_NOT)
- return 0;
+ if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
+ return NULL;
- token++;
- if (token->type != CPP_DEFINED)
- return 0;
+ string = get_token_no_padding (pfile);
+ if (string->type != CPP_STRING && string->type != CPP_WSTRING)
+ return NULL;
- token++;
- if (token->type == CPP_OPEN_PAREN)
- token++;
+ if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
+ return NULL;
- if (token->type != CPP_NAME)
- return 0;
+ return string;
+}
- cmacro = token->val.node;
+/* Destringize IN into a temporary buffer, by removing the first \ of
+ \" and \\ sequences, and process the result as a #pragma directive. */
+static void
+destringize_and_run (pfile, in)
+ cpp_reader *pfile;
+ const cpp_string *in;
+{
+ const unsigned char *src, *limit;
+ char *dest, *result;
- if (token[-1].type == CPP_OPEN_PAREN)
+ dest = result = alloca (in->len);
+ for (src = in->text, limit = src + in->len; src < limit;)
{
- token++;
- if (token->type != CPP_CLOSE_PAREN)
- return 0;
+ /* We know there is a character following the backslash. */
+ if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
+ src++;
+ *dest++ = *src++;
}
- token++;
- if (token->type != CPP_EOF)
- return 0;
-
- return cmacro;
+ run_directive (pfile, T_PRAGMA, result, dest - result);
}
-/* Parse an #ifdef or #ifndef directive. Returns the hash node of the
- macro being tested, and issues various error messages. */
-
-static const cpp_hashnode *
-parse_ifdef (pfile, name)
+/* Handle the _Pragma operator. */
+void
+_cpp_do__Pragma (pfile)
cpp_reader *pfile;
- const U_CHAR *name;
{
- enum cpp_ttype type;
- const cpp_hashnode *node = 0;
-
- const cpp_token *token = _cpp_get_token (pfile);
- type = token->type;
+ const cpp_token *string = get__Pragma_string (pfile);
- if (type == CPP_EOF)
- cpp_pedwarn (pfile, "#%s with no argument", name);
- else if (type != CPP_NAME)
- cpp_pedwarn (pfile, "#%s with invalid argument", name);
- else if (_cpp_get_token (pfile)->type != CPP_EOF)
- cpp_pedwarn (pfile, "garbage at end of #%s", name);
-
- if (type == CPP_NAME)
- node = token->val.node;
- if (node && node->type == T_POISON)
+ if (!string)
+ cpp_error (pfile, "_Pragma takes a parenthesized string literal");
+ else
{
- cpp_error (pfile, "attempt to use poisoned identifier \"%s\"",
- node->name);
- node = 0;
+ /* 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. */
+
+ unsigned int orig_line = pfile->line;
+ destringize_and_run (pfile, &string->val.str);
+ pfile->line = orig_line;
+ pfile->buffer->saved_flags = BOL;
}
-
- return node;
}
-/* #ifdef is dead simple. */
+/* 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
static void
do_ifdef (pfile)
cpp_reader *pfile;
{
- const cpp_hashnode *node = 0;
+ int skip = 1;
+
+ if (! pfile->state.skipping)
+ {
+ const cpp_hashnode *node = lex_macro_node (pfile);
- if (! pfile->skipping)
- node = parse_ifdef (pfile, dtable[T_IFDEF].name);
+ if (node)
+ skip = node->type != NT_MACRO;
- push_conditional (pfile, !(node && node->type != T_VOID), T_IFDEF, 0);
-}
+ if (node)
+ check_eol (pfile);
+ }
-/* #ifndef is a tad more complex, because we need to check for a
- no-reinclusion wrapper. */
+ push_conditional (pfile, skip, T_IFDEF, 0);
+}
static void
do_ifndef (pfile)
cpp_reader *pfile;
{
- int start_of_file = 0;
+ int skip = 1;
const cpp_hashnode *node = 0;
- if (! pfile->skipping)
+ if (! pfile->state.skipping)
{
- start_of_file = (pfile->token_list.flags & BEG_OF_FILE);
- node = parse_ifdef (pfile, dtable[T_IFNDEF].name);
+ node = lex_macro_node (pfile);
+ if (node)
+ skip = node->type == NT_MACRO;
+
+ if (node)
+ check_eol (pfile);
}
- push_conditional (pfile, node && node->type != T_VOID,
- T_IFNDEF, start_of_file ? node : 0);
+ push_conditional (pfile, skip, T_IFNDEF, node);
}
-/* #if is straightforward; just call _cpp_parse_expr, then conditional_skip.
- Also, check for a reinclude preventer of the form #if !defined (MACRO). */
+/* _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
do_if (pfile)
cpp_reader *pfile;
{
- const cpp_hashnode *cmacro = 0;
- int value = 0;
+ int skip = 1;
- if (! pfile->skipping)
- {
- if (pfile->token_list.flags & BEG_OF_FILE)
- cmacro = detect_if_not_defined (pfile);
- value = _cpp_parse_expr (pfile);
- }
- push_conditional (pfile, value == 0, T_IF, cmacro);
+ if (! pfile->state.skipping)
+ skip = _cpp_parse_expr (pfile) == 0;
+
+ push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
}
-/* #else flips pfile->skipping and continues without changing
+/* 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. */
do_else (pfile)
cpp_reader *pfile;
{
- struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
- validate_else (pfile, dtable[T_ELSE].name);
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
+ cpp_error (pfile, "#else without #if");
+ else
{
- cpp_error (pfile, "#else without #if");
- return;
- }
- if (ifs->type == T_ELSE)
- {
- cpp_error (pfile, "#else after #else");
- cpp_error_with_line (pfile, ifs->lineno, ifs->colno,
- "the conditional began here");
- }
+ if (ifs->type == T_ELSE)
+ {
+ cpp_error (pfile, "#else after #else");
+ cpp_error_with_line (pfile, ifs->line, 0,
+ "the conditional began here");
+ }
+ ifs->type = T_ELSE;
- /* #ifndef can't have its special treatment for containing the whole file
- if it has a #else clause. */
- ifs->cmacro = 0;
- ifs->type = T_ELSE;
- if (! ifs->was_skipping)
- {
- /* If pfile->skipping is 2, one of the blocks in an #if/#elif/... chain
- succeeded, so we mustn't do the else block. */
- if (pfile->skipping < 2)
- pfile->skipping = ! pfile->skipping;
+ /* Skip any future (erroneous) #elses or #elifs. */
+ pfile->state.skipping = ifs->skip_elses;
+ ifs->skip_elses = true;
+
+ /* Invalidate any controlling macro. */
+ ifs->mi_cmacro = 0;
+
+ /* Only check EOL if was not originally skipping. */
+ if (!ifs->was_skipping)
+ check_eol (pfile);
}
}
-/*
- * handle a #elif directive by not changing if_stack either.
- * see the comment above do_else.
- */
+/* handle a #elif directive by not changing if_stack either. see the
+ comment above do_else. */
static void
do_elif (pfile)
cpp_reader *pfile;
{
- struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
+ cpp_error (pfile, "#elif without #if");
+ else
{
- cpp_error (pfile, "#elif without #if");
- return;
- }
- if (ifs->type == T_ELSE)
- {
- cpp_error (pfile, "#elif after #else");
- cpp_error_with_line (pfile, ifs->lineno, ifs->colno,
- "the conditional began here");
- }
+ if (ifs->type == T_ELSE)
+ {
+ cpp_error (pfile, "#elif after #else");
+ cpp_error_with_line (pfile, ifs->line, 0,
+ "the conditional began here");
+ }
+ ifs->type = T_ELIF;
- ifs->type = T_ELIF;
- if (ifs->was_skipping)
- return; /* Don't evaluate a nested #if */
+ /* 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
+ {
+ pfile->state.skipping = 0;
+ pfile->state.skipping = ! _cpp_parse_expr (pfile);
+ ifs->skip_elses = ! pfile->state.skipping;
+ }
- if (pfile->skipping != 1)
- {
- pfile->skipping = 2; /* one block succeeded, so don't do any others */
- return;
+ /* Invalidate any controlling macro. */
+ ifs->mi_cmacro = 0;
}
-
- pfile->skipping = ! _cpp_parse_expr (pfile);
}
-/* #endif pops the if stack and resets pfile->skipping. */
+/* #endif pops the if stack and resets pfile->state.skipping. */
static void
do_endif (pfile)
cpp_reader *pfile;
{
- struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
-
- validate_else (pfile, dtable[T_ENDIF].name);
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
cpp_error (pfile, "#endif without #if");
else
{
- CPP_BUFFER (pfile)->if_stack = ifs->next;
- pfile->skipping = ifs->was_skipping;
- pfile->potential_control_macro = ifs->cmacro;
- obstack_free (pfile->buffer_ob, ifs);
+ /* Only check EOL if was not originally skipping. */
+ if (!ifs->was_skipping)
+ check_eol (pfile);
+
+ /* 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);
}
}
-
-/* Push an if_stack entry and set pfile->skipping accordingly.
- If this is a #ifndef starting at the beginning of a file,
- CMACRO is the macro name tested by the #ifndef. */
+/* Push an if_stack entry and set pfile->state.skipping accordingly.
+ If this is a #if or #ifndef, CMACRO is a potentially controlling
+ macro - we need to check here that we are at the top of the file. */
static void
push_conditional (pfile, skip, type, cmacro)
const cpp_hashnode *cmacro;
{
struct if_stack *ifs;
+ cpp_buffer *buffer = pfile->buffer;
- ifs = xobnew (pfile->buffer_ob, struct if_stack);
- ifs->lineno = _cpp_get_line (pfile, &ifs->colno);
- ifs->next = CPP_BUFFER (pfile)->if_stack;
- ifs->cmacro = cmacro;
- ifs->was_skipping = pfile->skipping;
+ 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;
- if (!pfile->skipping)
- pfile->skipping = skip;
-
- CPP_BUFFER (pfile)->if_stack = ifs;
-}
-
-/* Issue -pedantic warning for text which is not a comment following
- an #else or #endif. */
-
-static void
-validate_else (pfile, directive)
- cpp_reader *pfile;
- const U_CHAR *directive;
-{
- if (CPP_PEDANTIC (pfile) && _cpp_get_token (pfile)->type != CPP_EOF)
- cpp_pedwarn (pfile, "ISO C forbids text after #%s", directive);
+ pfile->state.skipping = skip;
+ buffer->if_stack = ifs;
}
-/* Called when we reach the end of a file. Walk back up the
- conditional stack till we reach its level at entry to this file,
- issuing error messages. Then force skipping off. */
-static void
-unwind_if_stack (pfile, pbuf)
- cpp_reader *pfile;
- cpp_buffer *pbuf;
-{
- struct if_stack *ifs, *nifs;
-
- for (ifs = pbuf->if_stack; ifs; ifs = nifs)
- {
- cpp_error_with_line (pfile, ifs->lineno, ifs->colno, "unterminated #%s",
- dtable[ifs->type].name);
- nifs = ifs->next;
- /* No need to free - they'll all go away with the buffer. */
- }
- pfile->skipping = 0;
-}
+/* Read the tokens of the answer into the macro pool. Only commit the
+ memory if we intend it as permanent storage, i.e. the #assert case.
+ Returns 0 on success. */
-/* Parses an assertion, returning a pointer to the hash node of the
- predicate, or 0 on error. If an answer was supplied, it is
- allocated and placed in ANSWERP, otherwise it is set to 0. We use
- _cpp_get_raw_token, since we cannot assume tokens are consecutive
- in a #if statement (we may be in a macro), and we don't want to
- macro expand. */
-cpp_hashnode *
-_cpp_parse_assertion (pfile, answerp)
+static int
+parse_answer (pfile, answerp, type)
cpp_reader *pfile;
struct answer **answerp;
+ int type;
{
- struct answer *answer = 0;
- cpp_toklist *list;
- U_CHAR *sym;
- const cpp_token *token, *predicate;
- const struct directive *d = pfile->token_list.directive;
- unsigned int len = 0;
+ const cpp_token *paren;
+ struct answer *answer;
+ unsigned int acount;
- predicate = _cpp_get_raw_token (pfile);
- if (predicate->type == CPP_EOF)
- {
- cpp_error (pfile, "assertion without predicate");
- return 0;
- }
- else if (predicate->type != CPP_NAME)
- {
- cpp_error (pfile, "predicate must be an identifier");
- return 0;
- }
+ /* 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);
- token = _cpp_get_raw_token (pfile);
- if (token->type != CPP_OPEN_PAREN)
+ /* If not a paren, see if we're OK. */
+ if (paren->type != CPP_OPEN_PAREN)
{
- /* #unassert and #if are OK without predicate. */
- if (d == &dtable[T_UNASSERT])
- {
- if (token->type == CPP_EOF)
- goto lookup_node;
- }
- else if (d != &dtable[T_ASSERT])
+ /* In a conditional no answer is a test for any answer. It
+ could be followed by any token. */
+ if (type == T_IF)
{
- _cpp_push_token (pfile, token);
- goto lookup_node;
+ _cpp_backup_tokens (pfile, 1);
+ return 0;
}
+
+ /* #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 0;
+ return 1;
}
- /* Allocate a struct answer, and copy the answer to it. */
- answer = (struct answer *) xmalloc (sizeof (struct answer));
- list = &answer->list;
- _cpp_init_toklist (list, 1); /* Empty. */
-
- for (;;)
+ for (acount = 0;; acount++)
{
+ size_t room_needed;
+ const cpp_token *token = cpp_get_token (pfile);
cpp_token *dest;
- token = _cpp_get_raw_token (pfile);
+ if (token->type == CPP_CLOSE_PAREN)
+ break;
if (token->type == CPP_EOF)
{
cpp_error (pfile, "missing ')' to complete answer");
- goto error;
+ return 1;
}
- if (token->type == CPP_CLOSE_PAREN)
- break;
- /* Copy the token. */
- _cpp_expand_token_space (list, 1);
- dest = &list->tokens[list->tokens_used++];
+ /* struct answer includes the space for one token. */
+ room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
+
+ if (BUFF_ROOM (pfile->a_buff) < room_needed)
+ _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
+
+ dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
*dest = *token;
- if (TOKEN_SPELL (token) == SPELL_STRING)
- {
- _cpp_expand_name_space (list, token->val.str.len);
- dest->val.str.text = list->namebuf + list->name_used;
- memcpy (list->namebuf + list->name_used,
- token->val.str.text, token->val.str.len);
- list->name_used += token->val.str.len;
- }
+ /* Drop whitespace at start, for answer equivalence purposes. */
+ if (acount == 0)
+ dest->flags &= ~PREV_WHITE;
}
- if (list->tokens_used == 0)
+ if (acount == 0)
{
cpp_error (pfile, "predicate's answer is empty");
- goto error;
+ return 1;
}
- /* Drop whitespace at start. */
- list->tokens[0].flags &= ~PREV_WHITE;
+ answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
+ answer->count = acount;
+ answer->next = NULL;
+ *answerp = answer;
- if ((d == &dtable[T_ASSERT] || d == &dtable[T_UNASSERT])
- && token[1].type != CPP_EOF)
- {
- cpp_error (pfile, "junk at end of assertion");
- goto error;
- }
+ return 0;
+}
- lookup_node:
- *answerp = answer;
- len = predicate->val.node->length;
- sym = alloca (len + 1);
+/* Parses an assertion, 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;
+{
+ cpp_hashnode *result = 0;
+ const cpp_token *predicate;
- /* Prefix '#' to get it out of macro namespace. */
- sym[0] = '#';
- memcpy (sym + 1, predicate->val.node->name, len);
- return cpp_lookup (pfile, sym, len + 1);
+ /* We don't expand predicates or answers. */
+ pfile->state.prevent_expansion++;
- error:
- FREE_ANSWER (answer);
- return 0;
+ *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)
+ {
+ 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->state.prevent_expansion--;
+ return result;
}
/* Returns a pointer to the pointer to the answer in the answer chain,
or a pointer to NULL if the answer is not in the chain. */
-struct answer **
-_cpp_find_answer (node, candidate)
+static struct answer **
+find_answer (node, candidate)
cpp_hashnode *node;
- const cpp_toklist *candidate;
+ const struct answer *candidate;
{
+ unsigned int i;
struct answer **result;
for (result = &node->value.answers; *result; result = &(*result)->next)
- if (_cpp_equiv_toklists (&(*result)->list, candidate))
- break;
+ {
+ struct answer *answer = *result;
+
+ if (answer->count == candidate->count)
+ {
+ for (i = 0; i < answer->count; i++)
+ if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
+ break;
+
+ if (i == answer->count)
+ break;
+ }
+ }
return result;
}
+/* 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;
+{
+ struct answer *answer;
+ cpp_hashnode *node;
+
+ 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;
+}
+
static void
do_assert (pfile)
cpp_reader *pfile;
struct answer *new_answer;
cpp_hashnode *node;
- node = _cpp_parse_assertion (pfile, &new_answer);
+ node = parse_assertion (pfile, &new_answer, T_ASSERT);
if (node)
{
+ /* Place the new answer in the answer list. First check there
+ is not a duplicate. */
new_answer->next = 0;
- new_answer->list.file = pfile->token_list.file;
-
- if (node->type == T_ASSERTION)
+ if (node->type == NT_ASSERTION)
{
- if (*_cpp_find_answer (node, &new_answer->list))
- goto err;
+ 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 = T_ASSERTION;
+
+ 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);
}
- return;
-
- err:
- cpp_warning (pfile, "\"%s\" re-asserted", node->name + 1);
- FREE_ANSWER (new_answer);
}
static void
cpp_reader *pfile;
{
cpp_hashnode *node;
- struct answer *answer, *temp;
+ struct answer *answer;
- node = _cpp_parse_assertion (pfile, &answer);
- if (node)
+ 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)
{
- /* It isn't an error to #unassert something that isn't asserted. */
- if (node->type == T_ASSERTION)
+ if (answer)
{
- if (answer)
- {
- struct answer **p = _cpp_find_answer (node, &answer->list);
-
- temp = *p;
- if (temp)
- {
- *p = temp->next;
- FREE_ANSWER (temp);
- }
- if (node->value.answers == 0)
- node->type = T_VOID;
- }
- else
- _cpp_free_definition (node);
- }
+ struct answer **p = find_answer (node, answer), *temp;
- if (answer)
- FREE_ANSWER (answer);
+ /* Remove the answer from the list. */
+ temp = *p;
+ if (temp)
+ *p = temp->next;
+
+ /* Did we free the last answer? */
+ if (node->value.answers == 0)
+ node->type = NT_VOID;
+
+ check_eol (pfile);
+ }
+ else
+ _cpp_free_definition (node);
}
+
+ /* We don't commit the memory for the answer - it's temporary only. */
}
/* These are for -D, -U, -A. */
/* 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. */
+ be identifier=definition. */
void
cpp_define (pfile, str)
char *buf, *p;
size_t count;
- p = strchr (str, '=');
/* 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. Then add a newline and a NUL. */
-
+ tack " 1" on the end. */
+
+ /* Length including the null. */
+ count = strlen (str);
+ buf = (char *) alloca (count + 2);
+ memcpy (buf, str, count);
+
+ p = strchr (str, '=');
if (p)
- {
- count = strlen (str) + 2;
- buf = (char *) alloca (count);
- memcpy (buf, str, count - 2);
- buf[p - str] = ' ';
- buf[count - 2] = '\n';
- buf[count - 1] = '\0';
- }
+ buf[p - str] = ' ';
else
{
- count = strlen (str) + 4;
- buf = (char *) alloca (count);
- memcpy (buf, str, count - 4);
- strcpy (&buf[count-4], " 1\n");
+ buf[count++] = ' ';
+ buf[count++] = '1';
}
- _cpp_run_directive (pfile, &dtable[T_DEFINE], buf, count - 1, 0);
+ run_directive (pfile, T_DEFINE, buf, count);
}
-/* Slight variant of the above for use by initialize_builtins, which (a)
- knows how to set up the buffer itself, (b) needs a different "filename"
- tag. */
+/* Slight variant of the above for use by initialize_builtins. */
void
_cpp_define_builtin (pfile, str)
cpp_reader *pfile;
const char *str;
{
- _cpp_run_directive (pfile, &dtable[T_DEFINE],
- str, strlen (str),
- _("<builtin>"));
+ run_directive (pfile, T_DEFINE, str, strlen (str));
}
/* Process MACRO as if it appeared as the body of an #undef. */
cpp_reader *pfile;
const char *macro;
{
- _cpp_run_directive (pfile, &dtable[T_UNDEF], macro, strlen (macro), 0);
+ run_directive (pfile, T_UNDEF, macro, strlen (macro));
}
-/* Process the string STR as if it appeared as the body of a #assert. */
+/* 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_run_directive (pfile, &dtable[T_ASSERT], str, strlen (str), 0);
+ handle_assertion (pfile, str, T_ASSERT);
}
-/* Process STR as if it appeared as the body of an #unassert. */
+/* Process STR as if it appeared as the body of an #unassert. */
void
cpp_unassert (pfile, str)
cpp_reader *pfile;
const char *str;
{
- _cpp_run_directive (pfile, &dtable[T_UNASSERT], str, strlen (str), 0);
+ handle_assertion (pfile, str, T_UNASSERT);
}
-/* Determine whether the identifier ID, of length LEN, is a defined macro. */
-int
-cpp_defined (pfile, id, len)
+/* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
+static void
+handle_assertion (pfile, str, type)
cpp_reader *pfile;
- const U_CHAR *id;
- int len;
+ const char *str;
+ int type;
{
- cpp_hashnode *hp = cpp_lookup (pfile, id, len);
- if (hp->type == T_POISON)
+ size_t count = strlen (str);
+ const char *p = strchr (str, '=');
+
+ if (p)
{
- cpp_error (pfile, "attempt to use poisoned \"%s\"", hp->name);
- return 0;
+ /* 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 + 1);
+
+ memcpy (buf, str, count);
+ buf[p - str] = '(';
+ buf[count++] = ')';
+ str = buf;
}
- return (hp->type != T_VOID);
+
+ run_directive (pfile, type, str, count);
+}
+
+/* The number of errors for a given reader. */
+unsigned int
+cpp_errors (pfile)
+ cpp_reader *pfile;
+{
+ return pfile->errors;
+}
+
+/* The options structure. */
+cpp_options *
+cpp_get_options (pfile)
+ cpp_reader *pfile;
+{
+ return &pfile->opts;
+}
+
+/* The callbacks structure. */
+cpp_callbacks *
+cpp_get_callbacks (pfile)
+ cpp_reader *pfile;
+{
+ return &pfile->cb;
+}
+
+/* The line map set. */
+const struct line_maps *
+cpp_get_line_maps (pfile)
+ cpp_reader *pfile;
+{
+ return &pfile->line_maps;
}
-/* 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. */
+/* Copy the given callbacks structure to our own. */
+void
+cpp_set_callbacks (pfile, cb)
+ cpp_reader *pfile;
+ cpp_callbacks *cb;
+{
+ pfile->cb = *cb;
+}
+/* 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, length)
+cpp_push_buffer (pfile, buffer, len, from_stage3, return_at_eof)
cpp_reader *pfile;
const U_CHAR *buffer;
- long length;
+ size_t len;
+ int from_stage3;
+ int return_at_eof;
{
- cpp_buffer *buf = CPP_BUFFER (pfile);
- cpp_buffer *new;
- if (++pfile->buffer_stack_depth == CPP_STACK_MAX)
- {
- cpp_fatal (pfile, "#include nested too deep");
- return NULL;
- }
- if (pfile->cur_context > 0)
- {
- cpp_ice (pfile, "buffer pushed with contexts stacked");
- _cpp_skip_rest_of_line (pfile);
- }
+ cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
- new = xobnew (pfile->buffer_ob, cpp_buffer);
+ /* Clears, amongst other things, if_stack and mi_cmacro. */
memset (new, 0, sizeof (cpp_buffer));
new->line_base = new->buf = new->cur = buffer;
- new->rlimit = buffer + length;
- new->prev = buf;
- new->pfile = pfile;
+ new->rlimit = buffer + len;
+
/* No read ahead or extra char initially. */
new->read_ahead = EOF;
new->extra_char = EOF;
+ new->from_stage3 = from_stage3;
+ new->prev = pfile->buffer;
+ new->return_at_eof = return_at_eof;
+ new->saved_flags = BOL;
+
+ pfile->buffer = new;
- CPP_BUFFER (pfile) = new;
return new;
}
-cpp_buffer *
-cpp_pop_buffer (pfile)
+/* 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_pop_buffer (pfile)
cpp_reader *pfile;
{
- int wfb;
- cpp_buffer *buf = CPP_BUFFER (pfile);
-
- unwind_if_stack (pfile, buf);
- wfb = (buf->inc != 0);
- if (wfb)
- _cpp_pop_file_buffer (pfile, buf);
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs;
- CPP_BUFFER (pfile) = CPP_PREV_BUFFER (buf);
- obstack_free (pfile->buffer_ob, buf);
- pfile->buffer_stack_depth--;
+ /* 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);
- if (wfb && pfile->cb.leave_file && CPP_BUFFER (pfile))
- (*pfile->cb.leave_file) (pfile);
-
- return CPP_BUFFER (pfile);
-}
+ /* In case of a missing #endif. */
+ pfile->state.skipping = 0;
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-#define DSC(x) U x, sizeof x - 1
-void
-_cpp_init_stacks (pfile)
- cpp_reader *pfile;
-{
- int i;
- struct spec_nodes *s;
+ /* Update the reader's buffer before _cpp_do_file_change. */
+ pfile->buffer = buffer->prev;
- pfile->buffer_ob = xnew (struct obstack);
- obstack_init (pfile->buffer_ob);
+ if (buffer->inc)
+ _cpp_pop_file_buffer (pfile, buffer->inc);
- /* Perhaps not the ideal place to put this. */
- pfile->spec_nodes = s = xnew (struct spec_nodes);
- s->n_L = cpp_lookup (pfile, DSC("L"));
- s->n__STRICT_ANSI__ = cpp_lookup (pfile, DSC("__STRICT_ANSI__"));
- s->n__CHAR_UNSIGNED__ = cpp_lookup (pfile, DSC("__CHAR_UNSIGNED__"));
- s->n__VA_ARGS__ = cpp_lookup (pfile, DSC("__VA_ARGS__"));
- for (i = 0; i < N_DIRECTIVES; i++)
- s->dirs[i] = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
+ obstack_free (&pfile->buffer_ob, buffer);
}
void
-_cpp_cleanup_stacks (pfile)
+_cpp_init_directives (pfile)
cpp_reader *pfile;
{
- obstack_free (pfile->buffer_ob, 0);
- free (pfile->buffer_ob);
+ unsigned int i;
+ cpp_hashnode *node;
+
+ /* Register the directives. */
+ for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
+ {
+ node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
+ node->directive_index = i + 1;
+ }
}
OSDN Git Service
