freebsd-skq/contrib/gcc/cpplib.c

1988 lines
55 KiB
C
Raw Normal View History

/* CPP Library. (Directive handling.)
Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
2003-11-07 02:43:04 +00:00
1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
1999-08-26 09:30:50 +00:00
Contributed by Per Bothner, 1994-95.
Based on CCCP program by Paul Rubin, June 1986
Adapted to ANSI C, Richard Stallman, Jan 1987
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
1999-08-26 09:30:50 +00:00
Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
1999-08-26 09:30:50 +00:00
#include "config.h"
#include "system.h"
#include "cpplib.h"
#include "cpphash.h"
#include "obstack.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 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. */
2004-07-28 03:11:36 +00:00
int type; /* Most recent conditional for diagnostics. */
};
/* Contains a registered pragma or pragma namespace. */
2004-07-28 03:11:36 +00:00
typedef void (*pragma_cb) (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
2003-07-11 03:40:53 +00:00
effect (these are the directives with callback hooks).
EXPAND is set on directives that are always macro-expanded. */
#define COND (1 << 0)
#define IF_COND (1 << 1)
#define INCL (1 << 2)
#define IN_I (1 << 3)
2003-07-11 03:40:53 +00:00
#define EXPAND (1 << 4)
/* Defines one #-directive, including how to handle it. */
2004-07-28 03:11:36 +00:00
typedef void (*directive_handler) (cpp_reader *);
typedef struct directive directive;
struct directive
{
directive_handler handler; /* Function to handle directive. */
2003-07-11 03:40:53 +00:00
const uchar *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. */
2004-07-28 03:11:36 +00:00
static void skip_rest_of_line (cpp_reader *);
static void check_eol (cpp_reader *);
static void start_directive (cpp_reader *);
static void prepare_directive_trad (cpp_reader *);
static void end_directive (cpp_reader *, int);
static void directive_diagnostics (cpp_reader *, const directive *, int);
static void run_directive (cpp_reader *, int, const char *, size_t);
static char *glue_header_name (cpp_reader *);
static const char *parse_include (cpp_reader *, int *);
static void push_conditional (cpp_reader *, int, int, const cpp_hashnode *);
static unsigned int read_flag (cpp_reader *, unsigned int);
static int strtoul_for_line (const uchar *, unsigned int, unsigned long *);
static void do_diagnostic (cpp_reader *, int, int);
static cpp_hashnode *lex_macro_node (cpp_reader *);
static int undefine_macros (cpp_reader *, cpp_hashnode *, void *);
static void do_include_common (cpp_reader *, enum include_type);
static struct pragma_entry *lookup_pragma_entry (struct pragma_entry *,
const cpp_hashnode *);
static struct pragma_entry *insert_pragma_entry (cpp_reader *,
struct pragma_entry **,
const cpp_hashnode *,
pragma_cb);
static int count_registered_pragmas (struct pragma_entry *);
static char ** save_registered_pragmas (struct pragma_entry *, char **);
static char ** restore_registered_pragmas (cpp_reader *, struct pragma_entry *,
char **);
static void do_pragma_once (cpp_reader *);
static void do_pragma_poison (cpp_reader *);
static void do_pragma_system_header (cpp_reader *);
static void do_pragma_dependency (cpp_reader *);
static void do_linemarker (cpp_reader *);
static const cpp_token *get_token_no_padding (cpp_reader *);
static const cpp_token *get__Pragma_string (cpp_reader *);
static void destringize_and_run (cpp_reader *, const cpp_string *);
static int parse_answer (cpp_reader *, struct answer **, int);
static cpp_hashnode *parse_assertion (cpp_reader *, struct answer **, int);
static struct answer ** find_answer (cpp_hashnode *, const struct answer *);
static void handle_assertion (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 */ \
2003-07-11 03:40:53 +00:00
D(include, T_INCLUDE, KANDR, INCL | EXPAND) /* 52262 */ \
D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
2003-07-11 03:40:53 +00:00
D(if, T_IF, KANDR, COND | IF_COND | EXPAND) /* 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 */ \
2003-07-11 03:40:53 +00:00
D(line, T_LINE, KANDR, EXPAND) /* 2465 */ \
D(elif, T_ELIF, STDC89, 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 */ \
2003-07-11 03:40:53 +00:00
D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) /* 19 */ \
D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
2003-07-11 03:40:53 +00:00
D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \
D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
2003-07-11 03:40:53 +00:00
D(sccs, T_SCCS, EXTENSION, 0) /* 0 SVR4? */
/* Use the table to generate a series of prototypes, an enum for the
directive names, and an array of directive handlers. */
2004-07-28 03:11:36 +00:00
#define D(name, t, o, f) static void do_##name (cpp_reader *);
DIRECTIVE_TABLE
#undef D
#define D(n, tag, o, f) tag,
enum
{
DIRECTIVE_TABLE
N_DIRECTIVES
};
#undef D
#define D(name, t, origin, flags) \
2004-07-28 03:11:36 +00:00
{ do_##name, (const uchar *) #name, \
sizeof #name - 1, origin, flags },
static const directive dtable[] =
{
DIRECTIVE_TABLE
};
#undef D
#undef DIRECTIVE_TABLE
/* Wrapper struct directive for linemarkers.
The origin is more or less true - the original K+R cpp
did use this notation in its preprocessed output. */
static const directive linemarker_dir =
{
do_linemarker, U"#", 1, KANDR, IN_I
};
#define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
1999-08-26 09:30:50 +00:00
/* Skip any remaining tokens in a directive. */
static void
2004-07-28 03:11:36 +00:00
skip_rest_of_line (cpp_reader *pfile)
{
/* Discard all stacked contexts. */
2003-02-10 05:41:50 +00:00
while (pfile->context->prev)
_cpp_pop_context (pfile);
/* Sweep up all tokens remaining on the line. */
if (! SEEN_EOL ())
while (_cpp_lex_token (pfile)->type != CPP_EOF)
;
}
/* Ensure there are no stray tokens at the end of a directive. */
static void
2004-07-28 03:11:36 +00:00
check_eol (cpp_reader *pfile)
{
if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_PEDWARN, "extra tokens at end of #%s directive",
2003-07-11 03:40:53 +00:00
pfile->directive->name);
}
/* Called when entering a directive, _Pragma or command-line directive. */
static void
2004-07-28 03:11:36 +00:00
start_directive (cpp_reader *pfile)
{
/* Setup in-directive state. */
pfile->state.in_directive = 1;
pfile->state.save_comments = 0;
/* Some handlers need the position of the # for diagnostics. */
pfile->directive_line = pfile->line;
}
/* Called when leaving a directive, _Pragma or command-line directive. */
static void
2004-07-28 03:11:36 +00:00
end_directive (cpp_reader *pfile, int skip_line)
{
2003-07-11 03:40:53 +00:00
if (CPP_OPTION (pfile, traditional))
{
/* Revert change of prepare_directive_trad. */
pfile->state.prevent_expansion--;
if (pfile->directive != &dtable[T_DEFINE])
_cpp_remove_overlay (pfile);
}
/* We don't skip for an assembler #. */
2003-07-11 03:40:53 +00:00
else 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;
}
}
/* Restore state. */
pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
pfile->state.in_directive = 0;
2003-07-11 03:40:53 +00:00
pfile->state.in_expression = 0;
pfile->state.angled_headers = 0;
pfile->directive = 0;
}
2003-07-11 03:40:53 +00:00
/* Prepare to handle the directive in pfile->directive. */
static void
2004-07-28 03:11:36 +00:00
prepare_directive_trad (cpp_reader *pfile)
2003-07-11 03:40:53 +00:00
{
if (pfile->directive != &dtable[T_DEFINE])
{
bool no_expand = (pfile->directive
&& ! (pfile->directive->flags & EXPAND));
bool was_skipping = pfile->state.skipping;
pfile->state.in_expression = (pfile->directive == &dtable[T_IF]
|| pfile->directive == &dtable[T_ELIF]);
2004-07-28 03:11:36 +00:00
if (pfile->state.in_expression)
pfile->state.skipping = false;
2003-07-11 03:40:53 +00:00
if (no_expand)
pfile->state.prevent_expansion++;
2004-07-28 03:11:36 +00:00
_cpp_scan_out_logical_line (pfile, NULL);
2003-07-11 03:40:53 +00:00
if (no_expand)
pfile->state.prevent_expansion--;
2004-07-28 03:11:36 +00:00
2003-07-11 03:40:53 +00:00
pfile->state.skipping = was_skipping;
_cpp_overlay_buffer (pfile, pfile->out.base,
pfile->out.cur - pfile->out.base);
}
/* Stop ISO C from expanding anything. */
pfile->state.prevent_expansion++;
}
/* Output diagnostics for a directive DIR. INDENTED is nonzero if
the '#' was indented. */
static void
2004-07-28 03:11:36 +00:00
directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented)
{
/* Issue -pedantic warnings for extensions. */
if (CPP_PEDANTIC (pfile)
&& ! pfile->state.skipping
&& dir->origin == EXTENSION)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_PEDWARN, "#%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. #elif cannot be used at all. */
if (CPP_WTRADITIONAL (pfile))
{
if (dir == &dtable[T_ELIF])
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_WARNING,
2003-07-11 03:40:53 +00:00
"suggest not using #elif in traditional C");
else if (indented && dir->origin == KANDR)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_WARNING,
2003-07-11 03:40:53 +00:00
"traditional C ignores #%s with the # indented",
dir->name);
else if (!indented && dir->origin != KANDR)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_WARNING,
2003-07-11 03:40:53 +00:00
"suggest hiding #%s from traditional C with an indented #",
dir->name);
}
}
2003-07-11 03:40:53 +00:00
/* Check if we have a known directive. INDENTED is nonzero if the
'#' of the directive was indented. This function is in this file
to save unnecessarily exporting dtable etc. to cpplex.c. Returns
2003-07-11 03:40:53 +00:00
nonzero if the line of tokens has been handled, zero if we should
continue processing the line. */
int
2004-07-28 03:11:36 +00:00
_cpp_handle_directive (cpp_reader *pfile, int indented)
{
const directive *dir = 0;
const cpp_token *dname;
2003-07-11 03:40:53 +00:00
bool was_parsing_args = pfile->state.parsing_args;
int skip = 1;
2003-07-11 03:40:53 +00:00
if (was_parsing_args)
{
if (CPP_OPTION (pfile, pedantic))
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_PEDWARN,
2003-07-11 03:40:53 +00:00
"embedding a directive within macro arguments is not portable");
pfile->state.parsing_args = 0;
pfile->state.prevent_expansion = 0;
}
start_directive (pfile);
dname = _cpp_lex_token (pfile);
if (dname->type == CPP_NAME)
{
2004-07-28 03:11:36 +00:00
if (dname->val.node->is_directive)
dir = &dtable[dname->val.node->directive_index];
}
2003-07-11 03:40:53 +00:00
/* We do not recognize the # followed by a number extension in
assembler code. */
else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
{
dir = &linemarker_dir;
if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)
&& ! pfile->state.skipping)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_PEDWARN,
2003-07-11 03:40:53 +00:00
"style of line directive is a GCC extension");
}
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
1999-08-26 09:30:50 +00:00
#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)))
{
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;
2003-07-11 03:40:53 +00:00
pfile->state.directive_wants_padding = 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)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "invalid preprocessing directive #%s",
cpp_token_as_text (pfile, dname));
}
2003-07-11 03:40:53 +00:00
pfile->directive = dir;
if (CPP_OPTION (pfile, traditional))
prepare_directive_trad (pfile);
if (dir)
2004-07-28 03:11:36 +00:00
pfile->directive->handler (pfile);
else if (skip == 0)
_cpp_backup_tokens (pfile, 1);
end_directive (pfile, skip);
2003-07-11 03:40:53 +00:00
if (was_parsing_args)
{
/* Restore state when within macro args. */
pfile->state.parsing_args = 2;
pfile->state.prevent_expansion = 1;
}
return skip;
}
/* Directive handler wrapper used by the command line option
2004-07-28 03:11:36 +00:00
processor. BUF is \n terminated. */
static void
2004-07-28 03:11:36 +00:00
run_directive (cpp_reader *pfile, int dir_no, const char *buf, size_t count)
{
2003-07-11 03:40:53 +00:00
cpp_push_buffer (pfile, (const uchar *) buf, count,
2004-07-28 03:11:36 +00:00
/* from_stage3 */ true);
/* Disgusting hack. */
if (dir_no == T_PRAGMA)
2004-07-28 03:11:36 +00:00
pfile->buffer->file = pfile->buffer->prev->file;
start_directive (pfile);
2004-07-28 03:11:36 +00:00
/* This is a short-term fix to prevent a leading '#' being
interpreted as a directive. */
_cpp_clean_line (pfile);
pfile->directive = &dtable[dir_no];
2003-07-11 03:40:53 +00:00
if (CPP_OPTION (pfile, traditional))
prepare_directive_trad (pfile);
2004-07-28 03:11:36 +00:00
pfile->directive->handler (pfile);
end_directive (pfile, 1);
if (dir_no == T_PRAGMA)
2004-07-28 03:11:36 +00:00
pfile->buffer->file = NULL;
_cpp_pop_buffer (pfile);
}
/* Checks for validity the macro name in #define, #undef, #ifdef and
#ifndef directives. */
static cpp_hashnode *
2004-07-28 03:11:36 +00:00
lex_macro_node (cpp_reader *pfile)
{
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.) */
2003-07-11 03:40:53 +00:00
if (token->type == CPP_NAME)
{
2003-07-11 03:40:53 +00:00
cpp_hashnode *node = token->val.node;
2003-07-11 03:40:53 +00:00
if (node == pfile->spec_nodes.n_defined)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR,
2003-07-11 03:40:53 +00:00
"\"defined\" cannot be used as a macro name");
else if (! (node->flags & NODE_POISONED))
return node;
}
2003-07-11 03:40:53 +00:00
else if (token->flags & NAMED_OP)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR,
2003-07-11 03:40:53 +00:00
"\"%s\" cannot be used as a macro name as it is an operator in C++",
NODE_NAME (token->val.node));
else if (token->type == CPP_EOF)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "no macro name given in #%s directive",
2003-07-11 03:40:53 +00:00
pfile->directive->name);
else
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "macro names must be identifiers");
2003-07-11 03:40:53 +00:00
return NULL;
}
/* Process a #define directive. Most work is done in cppmacro.c. */
static void
2004-07-28 03:11:36 +00:00
do_define (cpp_reader *pfile)
{
cpp_hashnode *node = lex_macro_node (pfile);
if (node)
{
2003-07-11 03:40:53 +00:00
/* If we have been requested to expand comments into macros,
then re-enable saving of comments. */
pfile->state.save_comments =
! CPP_OPTION (pfile, discard_comments_in_macro_exp);
if (_cpp_create_definition (pfile, node))
if (pfile->cb.define)
2004-07-28 03:11:36 +00:00
pfile->cb.define (pfile, pfile->directive_line, node);
}
}
/* Handle #undef. Mark the identifier NT_VOID in the hash table. */
static void
2004-07-28 03:11:36 +00:00
do_undef (cpp_reader *pfile)
{
2003-07-11 03:40:53 +00:00
cpp_hashnode *node = lex_macro_node (pfile);
2004-07-28 03:11:36 +00:00
if (node)
{
if (pfile->cb.undef)
2004-07-28 03:11:36 +00:00
pfile->cb.undef (pfile, pfile->directive_line, node);
2004-07-28 03:11:36 +00:00
/* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
identifier is not currently defined as a macro name. */
if (node->type == NT_MACRO)
{
if (node->flags & NODE_WARN)
cpp_error (pfile, CPP_DL_WARNING,
"undefining \"%s\"", NODE_NAME (node));
2003-07-11 03:40:53 +00:00
2004-07-28 03:11:36 +00:00
if (CPP_OPTION (pfile, warn_unused_macros))
_cpp_warn_if_unused_macro (pfile, node, NULL);
2004-07-28 03:11:36 +00:00
_cpp_free_definition (node);
}
}
2004-07-28 03:11:36 +00:00
check_eol (pfile);
}
2004-07-28 03:11:36 +00:00
/* Undefine a single macro/assertion/whatever. */
static int
undefine_macros (cpp_reader *pfile, cpp_hashnode *h,
void *data_p ATTRIBUTE_UNUSED)
{
switch (h->type)
{
case NT_VOID:
break;
case NT_MACRO:
if (pfile->cb.undef)
(*pfile->cb.undef) (pfile, pfile->directive_line, h);
if (CPP_OPTION (pfile, warn_unused_macros))
_cpp_warn_if_unused_macro (pfile, h, NULL);
/* And fall through.... */
case NT_ASSERTION:
_cpp_free_definition (h);
break;
default:
abort ();
}
h->flags &= ~NODE_POISONED;
return 1;
}
/* Undefine all macros and assertions. */
void
cpp_undef_all (cpp_reader *pfile)
{
cpp_forall_identifiers (pfile, undefine_macros, NULL);
}
/* Helper routine used by parse_include. Reinterpret the current line
as an h-char-sequence (< ... >); we are looking at the first token
2004-07-28 03:11:36 +00:00
after the <. Returns a malloced filename. */
static char *
glue_header_name (cpp_reader *pfile)
{
const cpp_token *token;
2004-07-28 03:11:36 +00:00
char *buffer;
size_t len, total_len = 0, capacity = 1024;
/* To avoid lexed tokens overwriting our glued name, we can only
allocate from the string pool once we've lexed everything. */
2004-07-28 03:11:36 +00:00
buffer = xmalloc (capacity);
for (;;)
{
2003-07-11 03:40:53 +00:00
token = get_token_no_padding (pfile);
2004-07-28 03:11:36 +00:00
if (token->type == CPP_GREATER)
break;
2004-07-28 03:11:36 +00:00
if (token->type == CPP_EOF)
{
cpp_error (pfile, CPP_DL_ERROR, "missing terminating > character");
break;
}
2004-07-28 03:11:36 +00:00
len = cpp_token_len (token) + 2; /* Leading space, terminating \0. */
if (total_len + len > capacity)
{
capacity = (capacity + len) * 2;
2004-07-28 03:11:36 +00:00
buffer = xrealloc (buffer, capacity);
}
if (token->flags & PREV_WHITE)
buffer[total_len++] = ' ';
2004-07-28 03:11:36 +00:00
total_len = (cpp_spell_token (pfile, token, (uchar *) &buffer[total_len])
- (uchar *) buffer);
}
2004-07-28 03:11:36 +00:00
buffer[total_len] = '\0';
return buffer;
}
2004-07-28 03:11:36 +00:00
/* Returns the file name of #include, #include_next, #import and
#pragma dependency. The string is malloced and the caller should
free it. Returns NULL on error. */
static const char *
parse_include (cpp_reader *pfile, int *pangle_brackets)
{
2004-07-28 03:11:36 +00:00
char *fname;
const cpp_token *header;
/* Allow macro expansion. */
2003-07-11 03:40:53 +00:00
header = get_token_no_padding (pfile);
2004-07-28 03:11:36 +00:00
if (header->type == CPP_STRING || header->type == CPP_HEADER_NAME)
{
2004-07-28 03:11:36 +00:00
fname = xmalloc (header->val.str.len - 1);
memcpy (fname, header->val.str.text + 1, header->val.str.len - 2);
fname[header->val.str.len - 2] = '\0';
*pangle_brackets = header->type == CPP_HEADER_NAME;
}
2004-07-28 03:11:36 +00:00
else if (header->type == CPP_LESS)
{
fname = glue_header_name (pfile);
*pangle_brackets = 1;
}
else
{
2004-07-28 03:11:36 +00:00
const unsigned char *dir;
if (pfile->directive == &dtable[T_PRAGMA])
dir = U"pragma dependency";
else
dir = pfile->directive->name;
cpp_error (pfile, CPP_DL_ERROR, "#%s expects \"FILENAME\" or <FILENAME>",
dir);
return NULL;
}
2004-07-28 03:11:36 +00:00
check_eol (pfile);
return fname;
}
/* Handle #include, #include_next and #import. */
static void
2004-07-28 03:11:36 +00:00
do_include_common (cpp_reader *pfile, enum include_type type)
{
2004-07-28 03:11:36 +00:00
const char *fname;
int angle_brackets;
2004-07-28 03:11:36 +00:00
fname = parse_include (pfile, &angle_brackets);
if (!fname)
return;
2004-07-28 03:11:36 +00:00
/* Prevent #include recursion. */
if (pfile->line_maps.depth >= CPP_STACK_MAX)
cpp_error (pfile, CPP_DL_ERROR, "#include nested too deeply");
else
{
2004-07-28 03:11:36 +00:00
/* 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, fname, angle_brackets);
_cpp_stack_include (pfile, fname, angle_brackets, type);
}
2004-07-28 03:11:36 +00:00
free ((void *) fname);
}
static void
2004-07-28 03:11:36 +00:00
do_include (cpp_reader *pfile)
{
do_include_common (pfile, IT_INCLUDE);
}
static void
2004-07-28 03:11:36 +00:00
do_import (cpp_reader *pfile)
{
do_include_common (pfile, IT_IMPORT);
}
1999-08-26 09:30:50 +00:00
static void
2004-07-28 03:11:36 +00:00
do_include_next (cpp_reader *pfile)
{
2004-07-28 03:11:36 +00:00
enum include_type type = IT_INCLUDE_NEXT;
/* If this is the primary source file, warn and use the normal
search logic. */
if (! pfile->buffer->prev)
{
cpp_error (pfile, CPP_DL_WARNING,
"#include_next in primary source file");
type = IT_INCLUDE;
}
do_include_common (pfile, type);
}
1999-08-26 09:30:50 +00:00
/* Subroutine of do_linemarker. 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
2004-07-28 03:11:36 +00:00
read_flag (cpp_reader *pfile, unsigned int last)
{
const cpp_token *token = _cpp_lex_token (pfile);
if (token->type == CPP_NUMBER && token->val.str.len == 1)
{
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)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "invalid flag \"%s\" in line directive",
cpp_token_as_text (pfile, token));
return 0;
}
/* Subroutine of do_line and do_linemarker. 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
2004-07-28 03:11:36 +00:00
strtoul_for_line (const uchar *str, unsigned int len, long unsigned int *nump)
{
unsigned long reg = 0;
2003-07-11 03:40:53 +00:00
uchar c;
while (len--)
{
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 a true string constant
(escapes are interpreted), unlike in #line. */
static void
2004-07-28 03:11:36 +00:00
do_line (cpp_reader *pfile)
{
const cpp_token *token;
const char *new_file = pfile->map->to_file;
unsigned long new_lineno;
/* C99 raised the minimum limit on #line numbers. */
unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
/* #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))
{
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR,
2003-07-11 03:40:53 +00:00
"\"%s\" after #line is not a positive integer",
cpp_token_as_text (pfile, token));
return;
2003-07-11 03:40:53 +00:00
}
if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_PEDWARN, "line number out of range");
token = cpp_get_token (pfile);
if (token->type == CPP_STRING)
{
2004-07-28 03:11:36 +00:00
cpp_string s = { 0, 0 };
if (_cpp_interpret_string_notranslate (pfile, &token->val.str, &s))
new_file = (const char *)s.text;
check_eol (pfile);
}
else if (token->type != CPP_EOF)
{
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
cpp_token_as_text (pfile, token));
return;
}
skip_rest_of_line (pfile);
_cpp_do_file_change (pfile, LC_RENAME, new_file, new_lineno,
pfile->map->sysp);
}
/* Interpret the # 44 "file" [flags] notation, which has slightly
different syntax and semantics from #line: Flags are allowed,
and we never complain about the line number being too big. */
static void
2004-07-28 03:11:36 +00:00
do_linemarker (cpp_reader *pfile)
{
const cpp_token *token;
const char *new_file = pfile->map->to_file;
unsigned long new_lineno;
unsigned int new_sysp = pfile->map->sysp;
enum lc_reason reason = LC_RENAME;
int flag;
/* Back up so we can get the number again. Putting this in
_cpp_handle_directive risks two calls to _cpp_backup_tokens in
some circumstances, which can segfault. */
_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))
{
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR,
"\"%s\" after # is not a positive integer",
cpp_token_as_text (pfile, token));
return;
2003-07-11 03:40:53 +00:00
}
token = cpp_get_token (pfile);
if (token->type == CPP_STRING)
{
2004-07-28 03:11:36 +00:00
cpp_string s = { 0, 0 };
if (_cpp_interpret_string_notranslate (pfile, &token->val.str, &s))
new_file = (const char *)s.text;
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);
}
else if (token->type != CPP_EOF)
{
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
cpp_token_as_text (pfile, token));
return;
}
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 system header that needs to be extern "C" protected,
and zero otherwise. */
void
2004-07-28 03:11:36 +00:00
_cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason,
const char *to_file, unsigned int file_line,
unsigned int sysp)
{
2004-07-28 03:11:36 +00:00
pfile->map = linemap_add (&pfile->line_maps, reason, sysp,
pfile->line, to_file, file_line);
if (pfile->cb.file_change)
2004-07-28 03:11:36 +00:00
pfile->cb.file_change (pfile, pfile->map);
}
/* Report a warning or error detected by the program we are
processing. Use the directive's tokens in the error message. */
static void
2004-07-28 03:11:36 +00:00
do_diagnostic (cpp_reader *pfile, int code, int print_dir)
{
2003-07-11 03:40:53 +00:00
if (_cpp_begin_message (pfile, code,
pfile->cur_token[-1].line,
pfile->cur_token[-1].col))
{
if (print_dir)
fprintf (stderr, "#%s ", pfile->directive->name);
pfile->state.prevent_expansion++;
cpp_output_line (pfile, stderr);
pfile->state.prevent_expansion--;
}
}
static void
2004-07-28 03:11:36 +00:00
do_error (cpp_reader *pfile)
{
2004-07-28 03:11:36 +00:00
do_diagnostic (pfile, CPP_DL_ERROR, 1);
}
static void
2004-07-28 03:11:36 +00:00
do_warning (cpp_reader *pfile)
{
/* We want #warning diagnostics to be emitted in system headers too. */
2004-07-28 03:11:36 +00:00
do_diagnostic (pfile, CPP_DL_WARNING_SYSHDR, 1);
}
/* Report program identification. */
static void
2004-07-28 03:11:36 +00:00
do_ident (cpp_reader *pfile)
{
const cpp_token *str = cpp_get_token (pfile);
1999-08-26 09:30:50 +00:00
if (str->type != CPP_STRING)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "invalid #ident directive");
else if (pfile->cb.ident)
2004-07-28 03:11:36 +00:00
pfile->cb.ident (pfile, pfile->directive_line, &str->val.str);
check_eol (pfile);
}
/* 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 *
2004-07-28 03:11:36 +00:00
lookup_pragma_entry (struct pragma_entry *chain, const cpp_hashnode *pragma)
{
while (chain && chain->pragma != pragma)
chain = chain->next;
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 *
2004-07-28 03:11:36 +00:00
insert_pragma_entry (cpp_reader *pfile, struct pragma_entry **chain,
const cpp_hashnode *pragma, pragma_cb handler)
{
struct pragma_entry *new;
new = (struct pragma_entry *)
_cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
new->pragma = pragma;
if (handler)
{
new->is_nspace = 0;
new->u.handler = handler;
}
else
{
new->is_nspace = 1;
new->u.space = NULL;
}
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
2004-07-28 03:11:36 +00:00
cpp_register_pragma (cpp_reader *pfile, 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:
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ICE,
"registering \"%s\" as both a pragma and a pragma namespace",
NODE_NAME (node));
else if (space)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ICE, "#pragma %s %s is already registered",
2003-07-11 03:40:53 +00:00
space, name);
else
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ICE, "#pragma %s is already registered", name);
}
else
insert_pragma_entry (pfile, chain, node, handler);
}
/* Register the pragmas the preprocessor itself handles. */
void
2004-07-28 03:11:36 +00:00
_cpp_init_internal_pragmas (cpp_reader *pfile)
{
/* Pragmas in the global namespace. */
cpp_register_pragma (pfile, 0, "once", do_pragma_once);
1999-08-26 09:30:50 +00:00
/* 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);
}
2004-07-28 03:11:36 +00:00
/* Return the number of registered pragmas in PE. */
static int
count_registered_pragmas (struct pragma_entry *pe)
{
int ct = 0;
for (; pe != NULL; pe = pe->next)
{
if (pe->is_nspace)
ct += count_registered_pragmas (pe->u.space);
ct++;
}
return ct;
}
/* Save into SD the names of the registered pragmas referenced by PE,
and return a pointer to the next free space in SD. */
static char **
save_registered_pragmas (struct pragma_entry *pe, char **sd)
{
for (; pe != NULL; pe = pe->next)
{
if (pe->is_nspace)
sd = save_registered_pragmas (pe->u.space, sd);
*sd++ = xmemdup (HT_STR (&pe->pragma->ident),
HT_LEN (&pe->pragma->ident),
HT_LEN (&pe->pragma->ident) + 1);
}
return sd;
}
/* Return a newly-allocated array which saves the names of the
registered pragmas. */
char **
_cpp_save_pragma_names (cpp_reader *pfile)
{
int ct = count_registered_pragmas (pfile->pragmas);
char **result = xnewvec (char *, ct);
(void) save_registered_pragmas (pfile->pragmas, result);
return result;
}
/* Restore from SD the names of the registered pragmas referenced by PE,
and return a pointer to the next unused name in SD. */
static char **
restore_registered_pragmas (cpp_reader *pfile, struct pragma_entry *pe,
char **sd)
{
for (; pe != NULL; pe = pe->next)
{
if (pe->is_nspace)
sd = restore_registered_pragmas (pfile, pe->u.space, sd);
pe->pragma = cpp_lookup (pfile, U *sd, strlen (*sd));
free (*sd);
sd++;
}
return sd;
}
/* Restore the names of the registered pragmas from SAVED. */
void
_cpp_restore_pragma_names (cpp_reader *pfile, char **saved)
{
(void) restore_registered_pragmas (pfile, pfile->pragmas, saved);
free (saved);
}
/* 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
2004-07-28 03:11:36 +00:00
do_pragma (cpp_reader *pfile)
{
const struct pragma_entry *p = NULL;
2003-11-07 02:43:04 +00:00
const cpp_token *token, *pragma_token = pfile->cur_token;
unsigned int count = 1;
pfile->state.prevent_expansion++;
token = cpp_get_token (pfile);
if (token->type == CPP_NAME)
{
p = lookup_pragma_entry (pfile->pragmas, token->val.node);
if (p && p->is_nspace)
{
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;
}
}
if (p)
2003-11-07 02:43:04 +00:00
{
/* Since the handler below doesn't get the line number, that it
might need for diagnostics, make sure it has the right
numbers in place. */
if (pfile->cb.line_change)
(*pfile->cb.line_change) (pfile, pragma_token, false);
(*p->u.handler) (pfile);
}
else if (pfile->cb.def_pragma)
{
_cpp_backup_tokens (pfile, count);
2004-07-28 03:11:36 +00:00
pfile->cb.def_pragma (pfile, pfile->directive_line);
}
pfile->state.prevent_expansion--;
}
/* Handle #pragma once. */
static void
2004-07-28 03:11:36 +00:00
do_pragma_once (cpp_reader *pfile)
{
if (pfile->buffer->prev == NULL)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_WARNING, "#pragma once in main file");
check_eol (pfile);
2004-07-28 03:11:36 +00:00
_cpp_mark_file_once_only (pfile, pfile->buffer->file);
}
2003-07-11 03:40:53 +00:00
/* Handle #pragma GCC poison, to poison one or more identifiers so
that the lexer produces a hard error for each subsequent usage. */
static void
2004-07-28 03:11:36 +00:00
do_pragma_poison (cpp_reader *pfile)
{
const cpp_token *tok;
cpp_hashnode *hp;
pfile->state.poisoned_ok = 1;
for (;;)
{
tok = _cpp_lex_token (pfile);
if (tok->type == CPP_EOF)
break;
if (tok->type != CPP_NAME)
{
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR,
"invalid #pragma GCC poison directive");
break;
}
hp = tok->val.node;
if (hp->flags & NODE_POISONED)
continue;
if (hp->type == NT_MACRO)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_WARNING, "poisoning existing macro \"%s\"",
2003-07-11 03:40:53 +00:00
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
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
2004-07-28 03:11:36 +00:00
do_pragma_system_header (cpp_reader *pfile)
{
cpp_buffer *buffer = pfile->buffer;
if (buffer->prev == 0)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_WARNING,
2003-07-11 03:40:53 +00:00
"#pragma system_header ignored outside include file");
else
{
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
file. Issue a diagnostic, if the specified file is newer. We use this to
determine if a fixed header should be refixed. */
static void
2004-07-28 03:11:36 +00:00
do_pragma_dependency (cpp_reader *pfile)
{
2004-07-28 03:11:36 +00:00
const char *fname;
int angle_brackets, ordering;
2003-07-11 03:40:53 +00:00
2004-07-28 03:11:36 +00:00
fname = parse_include (pfile, &angle_brackets);
if (!fname)
return;
2004-07-28 03:11:36 +00:00
ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
if (ordering < 0)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_WARNING, "cannot find source file %s", fname);
else if (ordering > 0)
{
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_WARNING,
"current file is older than %s", fname);
if (cpp_get_token (pfile)->type != CPP_EOF)
{
_cpp_backup_tokens (pfile, 1);
2004-07-28 03:11:36 +00:00
do_diagnostic (pfile, CPP_DL_WARNING, 0);
}
}
2004-07-28 03:11:36 +00:00
free ((void *) fname);
}
/* Get a token but skip padding. */
static const cpp_token *
2004-07-28 03:11:36 +00:00
get_token_no_padding (cpp_reader *pfile)
{
for (;;)
{
const cpp_token *result = cpp_get_token (pfile);
if (result->type != CPP_PADDING)
return result;
}
}
/* Check syntax is "(string-literal)". Returns the string on success,
or NULL on failure. */
static const cpp_token *
2004-07-28 03:11:36 +00:00
get__Pragma_string (cpp_reader *pfile)
{
const cpp_token *string;
if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
return NULL;
string = get_token_no_padding (pfile);
if (string->type != CPP_STRING && string->type != CPP_WSTRING)
return NULL;
if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
return NULL;
return string;
}
/* Destringize IN into a temporary buffer, by removing the first \ of
\" and \\ sequences, and process the result as a #pragma directive. */
static void
2004-07-28 03:11:36 +00:00
destringize_and_run (cpp_reader *pfile, const cpp_string *in)
{
const unsigned char *src, *limit;
char *dest, *result;
2004-07-28 03:11:36 +00:00
dest = result = alloca (in->len - 1);
src = in->text + 1 + (in->text[0] == 'L');
limit = in->text + in->len - 1;
while (src < limit)
{
/* We know there is a character following the backslash. */
if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
src++;
*dest++ = *src++;
}
2004-07-28 03:11:36 +00:00
*dest = '\n';
2003-02-10 05:41:50 +00:00
/* Ugh; an awful kludge. We are really not set up to be lexing
tokens when in the middle of a macro expansion. Use a new
context to force cpp_get_token to lex, and so skip_rest_of_line
doesn't go beyond the end of the text. Also, remember the
current lexing position so we can return to it later.
Something like line-at-a-time lexing should remove the need for
this. */
{
cpp_context *saved_context = pfile->context;
cpp_token *saved_cur_token = pfile->cur_token;
tokenrun *saved_cur_run = pfile->cur_run;
pfile->context = xnew (cpp_context);
pfile->context->macro = 0;
pfile->context->prev = 0;
run_directive (pfile, T_PRAGMA, result, dest - result);
free (pfile->context);
pfile->context = saved_context;
pfile->cur_token = saved_cur_token;
pfile->cur_run = saved_cur_run;
2003-07-11 03:40:53 +00:00
pfile->line--;
2003-02-10 05:41:50 +00:00
}
/* See above comment. For the moment, we'd like
token1 _Pragma ("foo") token2
to be output as
2003-07-11 03:40:53 +00:00
token1
# 7 "file.c"
#pragma foo
# 7 "file.c"
token2
Getting the line markers is a little tricky. */
if (pfile->cb.line_change)
2004-07-28 03:11:36 +00:00
pfile->cb.line_change (pfile, pfile->cur_token, false);
}
/* Handle the _Pragma operator. */
void
2004-07-28 03:11:36 +00:00
_cpp_do__Pragma (cpp_reader *pfile)
{
const cpp_token *string = get__Pragma_string (pfile);
if (string)
destringize_and_run (pfile, &string->val.str);
else
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR,
2003-07-11 03:40:53 +00:00
"_Pragma takes a parenthesized string literal");
}
2004-07-28 03:11:36 +00:00
/* Ignore #sccs on all systems. */
static void
2004-07-28 03:11:36 +00:00
do_sccs (cpp_reader *pfile ATTRIBUTE_UNUSED)
{
}
/* Handle #ifdef. */
static void
2004-07-28 03:11:36 +00:00
do_ifdef (cpp_reader *pfile)
{
int skip = 1;
if (! pfile->state.skipping)
{
const cpp_hashnode *node = lex_macro_node (pfile);
if (node)
2003-07-11 03:40:53 +00:00
{
skip = node->type != NT_MACRO;
_cpp_mark_macro_used (node);
check_eol (pfile);
}
}
push_conditional (pfile, skip, T_IFDEF, 0);
}
1999-08-26 09:30:50 +00:00
/* Handle #ifndef. */
static void
2004-07-28 03:11:36 +00:00
do_ifndef (cpp_reader *pfile)
{
int skip = 1;
const cpp_hashnode *node = 0;
if (! pfile->state.skipping)
{
node = lex_macro_node (pfile);
if (node)
2003-07-11 03:40:53 +00:00
{
skip = node->type == NT_MACRO;
_cpp_mark_macro_used (node);
check_eol (pfile);
}
}
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
2004-07-28 03:11:36 +00:00
optimizations. 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
2004-07-28 03:11:36 +00:00
do_if (cpp_reader *pfile)
{
int skip = 1;
if (! pfile->state.skipping)
2003-07-11 03:40:53 +00:00
skip = _cpp_parse_expr (pfile) == false;
1999-08-26 09:30:50 +00:00
push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
}
/* 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
2004-07-28 03:11:36 +00:00
do_else (cpp_reader *pfile)
{
cpp_buffer *buffer = pfile->buffer;
struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "#else without #if");
else
{
if (ifs->type == T_ELSE)
1999-08-26 09:30:50 +00:00
{
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "#else after #else");
cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
"the conditional began here");
}
ifs->type = T_ELSE;
/* 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. */
2003-07-11 03:40:53 +00:00
if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
check_eol (pfile);
}
}
/* Handle a #elif directive by not changing if_stack either. See the
comment above do_else. */
static void
2004-07-28 03:11:36 +00:00
do_elif (cpp_reader *pfile)
{
cpp_buffer *buffer = pfile->buffer;
struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "#elif without #if");
else
{
if (ifs->type == T_ELSE)
{
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "#elif after #else");
cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
"the conditional began here");
}
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
{
pfile->state.skipping = 0;
pfile->state.skipping = ! _cpp_parse_expr (pfile);
ifs->skip_elses = ! pfile->state.skipping;
}
/* Invalidate any controlling macro. */
ifs->mi_cmacro = 0;
}
}
/* #endif pops the if stack and resets pfile->state.skipping. */
static void
2004-07-28 03:11:36 +00:00
do_endif (cpp_reader *pfile)
{
cpp_buffer *buffer = pfile->buffer;
struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
else
{
/* Only check EOL if was not originally skipping. */
2003-07-11 03:40:53 +00:00
if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
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 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
2004-07-28 03:11:36 +00:00
push_conditional (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;
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
2004-07-28 03:11:36 +00:00
parse_answer (cpp_reader *pfile, struct answer **answerp, int type)
{
const cpp_token *paren;
struct answer *answer;
unsigned int acount;
/* 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);
/* If not a paren, see if we're OK. */
if (paren->type != CPP_OPEN_PAREN)
{
/* 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;
}
/* #unassert with no answer is valid - it removes all answers. */
if (type == T_UNASSERT && paren->type == CPP_EOF)
return 0;
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "missing '(' after predicate");
return 1;
}
for (acount = 0;; acount++)
{
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)
{
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");
return 1;
}
/* 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;
/* Drop whitespace at start, for answer equivalence purposes. */
if (acount == 0)
dest->flags &= ~PREV_WHITE;
}
if (acount == 0)
{
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");
return 1;
}
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 *
2004-07-28 03:11:36 +00:00
parse_assertion (cpp_reader *pfile, struct answer **answerp, int type)
{
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)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");
else if (predicate->type != CPP_NAME)
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_ERROR, "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;
1999-08-26 09:30:50 +00:00
}
/* 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 **
2004-07-28 03:11:36 +00:00
find_answer (cpp_hashnode *node, const struct answer *candidate)
{
unsigned int i;
struct answer **result;
1999-08-26 09:30:50 +00:00
for (result = &node->value.answers; *result; result = &(*result)->next)
{
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
2003-07-11 03:40:53 +00:00
nonzero on failure, zero on success. On success, the result of
the test is written into VALUE, otherwise the value 0. */
int
2004-07-28 03:11:36 +00:00
_cpp_test_assertion (cpp_reader *pfile, unsigned int *value)
{
struct answer *answer;
cpp_hashnode *node;
node = parse_assertion (pfile, &answer, T_IF);
2003-07-11 03:40:53 +00:00
/* For recovery, an erroneous assertion expression is handled as a
failing assertion. */
*value = 0;
if (node)
*value = (node->type == NT_ASSERTION &&
(answer == 0 || *find_answer (node, answer) != 0));
2003-07-11 03:40:53 +00:00
else if (pfile->cur_token[-1].type == CPP_EOF)
_cpp_backup_tokens (pfile, 1);
/* We don't commit the memory for the answer - it's temporary only. */
return node == 0;
}
/* Handle #assert. */
static void
2004-07-28 03:11:36 +00:00
do_assert (cpp_reader *pfile)
{
struct answer *new_answer;
cpp_hashnode *node;
2003-07-11 03:40:53 +00:00
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;
if (node->type == NT_ASSERTION)
{
if (*find_answer (node, new_answer))
{
2004-07-28 03:11:36 +00:00
cpp_error (pfile, CPP_DL_WARNING, "\"%s\" re-asserted",
2003-07-11 03:40:53 +00:00
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. */
1999-08-26 09:30:50 +00:00
static void
2004-07-28 03:11:36 +00:00
do_unassert (cpp_reader *pfile)
{
cpp_hashnode *node;
struct answer *answer;
2003-07-11 03:40:53 +00:00
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;
1999-08-26 09:30:50 +00:00
/* Remove the answer from the list. */
temp = *p;
if (temp)
*p = temp->next;
1999-08-26 09:30:50 +00:00
/* Did we free the last answer? */
if (node->value.answers == 0)
node->type = NT_VOID;
check_eol (pfile);
}
else
_cpp_free_definition (node);
}
1999-08-26 09:30:50 +00:00
/* 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. */
void
2004-07-28 03:11:36 +00:00
cpp_define (cpp_reader *pfile, const char *str)
{
char *buf, *p;
size_t count;
2003-07-11 03:40:53 +00:00
/* 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);
2004-07-28 03:11:36 +00:00
buf = alloca (count + 3);
memcpy (buf, str, count);
p = strchr (str, '=');
if (p)
buf[p - str] = ' ';
else
{
buf[count++] = ' ';
buf[count++] = '1';
}
2004-07-28 03:11:36 +00:00
buf[count] = '\n';
run_directive (pfile, T_DEFINE, buf, count);
1999-08-26 09:30:50 +00:00
}
/* Slight variant of the above for use by initialize_builtins. */
1999-08-26 09:30:50 +00:00
void
2004-07-28 03:11:36 +00:00
_cpp_define_builtin (cpp_reader *pfile, const char *str)
1999-08-26 09:30:50 +00:00
{
2004-07-28 03:11:36 +00:00
size_t len = strlen (str);
char *buf = alloca (len + 1);
memcpy (buf, str, len);
buf[len] = '\n';
run_directive (pfile, T_DEFINE, buf, len);
}
/* Process MACRO as if it appeared as the body of an #undef. */
void
2004-07-28 03:11:36 +00:00
cpp_undef (cpp_reader *pfile, const char *macro)
{
2004-07-28 03:11:36 +00:00
size_t len = strlen (macro);
char *buf = alloca (len + 1);
memcpy (buf, macro, len);
buf[len] = '\n';
run_directive (pfile, T_UNDEF, buf, len);
}
/* Process the string STR as if it appeared as the body of a #assert. */
void
2004-07-28 03:11:36 +00:00
cpp_assert (cpp_reader *pfile, const char *str)
{
handle_assertion (pfile, str, T_ASSERT);
1999-08-26 09:30:50 +00:00
}
/* Process STR as if it appeared as the body of an #unassert. */
1999-08-26 09:30:50 +00:00
void
2004-07-28 03:11:36 +00:00
cpp_unassert (cpp_reader *pfile, const char *str)
{
handle_assertion (pfile, str, T_UNASSERT);
2003-07-11 03:40:53 +00:00
}
/* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
static void
2004-07-28 03:11:36 +00:00
handle_assertion (cpp_reader *pfile, const char *str, int type)
{
size_t count = strlen (str);
const char *p = strchr (str, '=');
2004-07-28 03:11:36 +00:00
/* 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 = alloca (count + 2);
memcpy (buf, str, count);
if (p)
{
buf[p - str] = '(';
buf[count++] = ')';
}
2004-07-28 03:11:36 +00:00
buf[count] = '\n';
str = buf;
1999-08-26 09:30:50 +00:00
run_directive (pfile, type, str, count);
}
1999-08-26 09:30:50 +00:00
/* The number of errors for a given reader. */
unsigned int
2004-07-28 03:11:36 +00:00
cpp_errors (cpp_reader *pfile)
{
return pfile->errors;
}
/* The options structure. */
cpp_options *
2004-07-28 03:11:36 +00:00
cpp_get_options (cpp_reader *pfile)
{
return &pfile->opts;
}
1999-08-26 09:30:50 +00:00
/* The callbacks structure. */
cpp_callbacks *
2004-07-28 03:11:36 +00:00
cpp_get_callbacks (cpp_reader *pfile)
{
return &pfile->cb;
}
/* The line map set. */
2004-07-28 03:11:36 +00:00
struct line_maps *
cpp_get_line_maps (cpp_reader *pfile)
{
return &pfile->line_maps;
}
/* Copy the given callbacks structure to our own. */
void
2004-07-28 03:11:36 +00:00
cpp_set_callbacks (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 *
2004-07-28 03:11:36 +00:00
cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len,
int from_stage3)
{
cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
/* Clears, amongst other things, if_stack and mi_cmacro. */
memset (new, 0, sizeof (cpp_buffer));
2004-07-28 03:11:36 +00:00
new->next_line = new->buf = buffer;
new->rlimit = buffer + len;
2004-07-28 03:11:36 +00:00
new->from_stage3 = from_stage3;
new->prev = pfile->buffer;
2004-07-28 03:11:36 +00:00
new->need_line = true;
pfile->buffer = new;
return new;
1999-08-26 09:30:50 +00:00
}
2003-07-11 03:40:53 +00:00
/* Pops a single buffer, with a file change call-back if appropriate.
Then pushes the next -include file, if any remain. */
1999-08-26 09:30:50 +00:00
void
2004-07-28 03:11:36 +00:00
_cpp_pop_buffer (cpp_reader *pfile)
1999-08-26 09:30:50 +00:00
{
cpp_buffer *buffer = pfile->buffer;
2004-07-28 03:11:36 +00:00
struct _cpp_file *inc = buffer->file;
struct if_stack *ifs;
/* 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)
2004-07-28 03:11:36 +00:00
cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
"unterminated #%s", dtable[ifs->type].name);
/* In case of a missing #endif. */
pfile->state.skipping = 0;
2003-07-11 03:40:53 +00:00
/* _cpp_do_file_change expects pfile->buffer to be the new one. */
pfile->buffer = buffer->prev;
2004-07-28 03:11:36 +00:00
free (buffer->notes);
2003-07-11 03:40:53 +00:00
/* Free the buffer object now; we may want to push a new buffer
in _cpp_push_next_include_file. */
obstack_free (&pfile->buffer_ob, buffer);
if (inc)
{
_cpp_pop_file_buffer (pfile, inc);
2004-07-28 03:11:36 +00:00
_cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
2003-07-11 03:40:53 +00:00
}
}
2003-07-11 03:40:53 +00:00
/* Enter all recognized directives in the hash table. */
void
2004-07-28 03:11:36 +00:00
_cpp_init_directives (cpp_reader *pfile)
{
unsigned int i;
cpp_hashnode *node;
for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
{
node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
2004-07-28 03:11:36 +00:00
node->is_directive = 1;
node->directive_index = i;
}
}