Skip to content

R
riscv-gcc-1
Commit afd9b9dd by Mark Mitchell Committed by Mark Mitchell
Options

parse.y: Remove. 

	* parse.y: Remove.
	* spew.c: Likewise.
	* Make-lang.in (gt-cp-spew.h): Remove.
	* cp-tree.h (do_pending_lang_change): Remove.
	(do_identifier): Change prototype.
	(finish_id_expr): Remove.
	* decl.c (lookup_name_real): Remove yylex variable.
	* decl2.c (build_expr_from_tree): Adjust call to do_identifier.
	* lex.c (init_cpp_parse): Remove.
	(reduce_cmp): Likewise.
	(token_cmp): Likewise.
	(yychar): Likewise.
	(lastiddecl): Likewise.
	(token_count): Likewise.
	(reduce_count): Likewise.
	(yyhook): Likewise.
	(print_parse_statistics): Likewise.
	(do_pending_lang_change): Likewise.
	(do_identifier): Remove parsing parameter.
	* lex.h (lastiddecl): Remove.
	(looking_for_typename): Remove.
	(looking_for_template): Likewise.
	(pending_lang_change): Likewise.
	(yylex): Likewise.
	* semantics.c (finish_id_expr): Remove.

From-SVN: r60642
parent a47a6810
Showing with 35 additions and 1735 deletions
gcc/cp/ChangeLog
...@@ -10,6 +10,32 @@ ...@@ -10,6 +10,32 @@
2002-12-30 Mark Mitchell <mark@codesourcery.com> 2002-12-30 Mark Mitchell <mark@codesourcery.com>
* parse.y: Remove.
* spew.c: Likewise.
* Make-lang.in (gt-cp-spew.h): Remove.
* cp-tree.h (do_pending_lang_change): Remove.
(do_identifier): Change prototype.
(finish_id_expr): Remove.
* decl.c (lookup_name_real): Remove yylex variable.
* decl2.c (build_expr_from_tree): Adjust call to do_identifier.
* lex.c (init_cpp_parse): Remove.
(reduce_cmp): Likewise.
(token_cmp): Likewise.
(yychar): Likewise.
(lastiddecl): Likewise.
(token_count): Likewise.
(reduce_count): Likewise.
(yyhook): Likewise.
(print_parse_statistics): Likewise.
(do_pending_lang_change): Likewise.
(do_identifier): Remove parsing parameter.
* lex.h (lastiddecl): Remove.
(looking_for_typename): Remove.
(looking_for_template): Likewise.
(pending_lang_change): Likewise.
(yylex): Likewise.
* semantics.c (finish_id_expr): Remove.
* decl.c (grokdeclarator): Diagnost "extern thread" and "static * decl.c (grokdeclarator): Diagnost "extern thread" and "static
thread" correctly. thread" correctly.
......
gcc/cp/Make-lang.in
...@@ -102,7 +102,7 @@ $(srcdir)/cp/cfns.h: $(srcdir)/cp/cfns.gperf ...@@ -102,7 +102,7 @@ $(srcdir)/cp/cfns.h: $(srcdir)/cp/cfns.gperf
$(srcdir)/cp/cfns.gperf > $(srcdir)/cp/cfns.h $(srcdir)/cp/cfns.gperf > $(srcdir)/cp/cfns.h
gtype-cp.h gt-cp-call.h gt-cp-decl.h gt-cp-decl2.h : s-gtype; @true gtype-cp.h gt-cp-call.h gt-cp-decl.h gt-cp-decl2.h : s-gtype; @true
gt-cp-pt.h gt-cp-repo.h gt-cp-spew.h gt-cp-parser.h : s-gtype; @true gt-cp-pt.h gt-cp-repo.h gt-cp-parser.h : s-gtype; @true
gt-cp-tree.h : s-gtype; @true gt-cp-tree.h : s-gtype; @true
# #
......
gcc/cp/cp-tree.h
...@@ -3974,10 +3974,9 @@ extern void snarf_method PARAMS ((tree)); ...@@ -3974,10 +3974,9 @@ extern void snarf_method PARAMS ((tree));
extern void note_got_semicolon PARAMS ((tree)); extern void note_got_semicolon PARAMS ((tree));
extern void note_list_got_semicolon PARAMS ((tree)); extern void note_list_got_semicolon PARAMS ((tree));
extern void do_pending_lang_change PARAMS ((void));
extern void see_typename PARAMS ((void)); extern void see_typename PARAMS ((void));
extern void unqualified_name_lookup_error PARAMS ((tree)); extern void unqualified_name_lookup_error PARAMS ((tree));
extern tree do_identifier PARAMS ((tree, int, tree)); extern tree do_identifier PARAMS ((tree, tree));
extern tree do_scoped_id PARAMS ((tree, tree)); extern tree do_scoped_id PARAMS ((tree, tree));
extern tree identifier_typedecl_value PARAMS ((tree)); extern tree identifier_typedecl_value PARAMS ((tree));
extern tree build_lang_decl PARAMS ((enum tree_code, tree, tree)); extern tree build_lang_decl PARAMS ((enum tree_code, tree, tree));
...@@ -4198,7 +4197,6 @@ extern tree finish_object_call_expr PARAMS ((tree, tree, tree)); ...@@ -4198,7 +4197,6 @@ extern tree finish_object_call_expr PARAMS ((tree, tree, tree));
extern tree finish_qualified_object_call_expr PARAMS ((tree, tree, tree)); extern tree finish_qualified_object_call_expr PARAMS ((tree, tree, tree));
extern tree finish_pseudo_destructor_expr (tree, tree, tree); extern tree finish_pseudo_destructor_expr (tree, tree, tree);
extern tree finish_unary_op_expr PARAMS ((enum tree_code, tree)); extern tree finish_unary_op_expr PARAMS ((enum tree_code, tree));
extern tree finish_id_expr PARAMS ((tree));
extern tree finish_compound_literal (tree, tree); extern tree finish_compound_literal (tree, tree);
extern tree finish_fname (tree); extern tree finish_fname (tree);
extern void save_type_access_control PARAMS ((tree)); extern void save_type_access_control PARAMS ((tree));
......
gcc/cp/decl.c
...@@ -6081,7 +6081,6 @@ lookup_name_real (tree name, ...@@ -6081,7 +6081,6 @@ lookup_name_real (tree name,
{ {
tree t; tree t;
tree val = NULL_TREE; tree val = NULL_TREE;
int yylex = 0;
int val_is_implicit_typename = 0; int val_is_implicit_typename = 0;
/* Conversion operators are handled specially because ordinary /* Conversion operators are handled specially because ordinary
...@@ -6144,7 +6143,7 @@ lookup_name_real (tree name, ...@@ -6144,7 +6143,7 @@ lookup_name_real (tree name,
if (binding if (binding
&& (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding))) && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
{ {
if (val_is_implicit_typename && !yylex) if (val_is_implicit_typename)
warn_about_implicit_typename_lookup (val, binding); warn_about_implicit_typename_lookup (val, binding);
val = binding; val = binding;
val_is_implicit_typename val_is_implicit_typename
...@@ -6160,7 +6159,7 @@ lookup_name_real (tree name, ...@@ -6160,7 +6159,7 @@ lookup_name_real (tree name,
t = unqualified_namespace_lookup (name, flags, 0); t = unqualified_namespace_lookup (name, flags, 0);
if (t) if (t)
{ {
if (val_is_implicit_typename && !yylex) if (val_is_implicit_typename)
warn_about_implicit_typename_lookup (val, t); warn_about_implicit_typename_lookup (val, t);
val = t; val = t;
} }
......
gcc/cp/decl2.c
...@@ -2940,7 +2940,7 @@ build_expr_from_tree (t) ...@@ -2940,7 +2940,7 @@ build_expr_from_tree (t)
switch (TREE_CODE (t)) switch (TREE_CODE (t))
{ {
case IDENTIFIER_NODE: case IDENTIFIER_NODE:
return do_identifier (t, 0, NULL_TREE); return do_identifier (t, NULL_TREE);
case LOOKUP_EXPR: case LOOKUP_EXPR:
if (LOOKUP_EXPR_GLOBAL (t)) if (LOOKUP_EXPR_GLOBAL (t))
...@@ -2950,7 +2950,7 @@ build_expr_from_tree (t) ...@@ -2950,7 +2950,7 @@ build_expr_from_tree (t)
} }
else else
{ {
t = do_identifier (TREE_OPERAND (t, 0), 0, NULL_TREE); t = do_identifier (TREE_OPERAND (t, 0), NULL_TREE);
if (TREE_CODE (t) == ALIAS_DECL) if (TREE_CODE (t) == ALIAS_DECL)
t = DECL_INITIAL (t); t = DECL_INITIAL (t);
return t; return t;
...@@ -3186,7 +3186,7 @@ build_expr_from_tree (t) ...@@ -3186,7 +3186,7 @@ build_expr_from_tree (t)
|| !lookup_member (current_class_type, id, 0, 0))) || !lookup_member (current_class_type, id, 0, 0)))
{ {
/* Do Koenig lookup if there are no class members. */ /* Do Koenig lookup if there are no class members. */
name = do_identifier (id, 0, args); name = do_identifier (id, args);
} }
else if (TREE_CODE (name) == TEMPLATE_ID_EXPR else if (TREE_CODE (name) == TEMPLATE_ID_EXPR
|| ! really_overloaded_fn (name)) || ! really_overloaded_fn (name))
......
gcc/cp/lex.c
...@@ -47,7 +47,6 @@ Boston, MA 02111-1307, USA. */ ...@@ -47,7 +47,6 @@ Boston, MA 02111-1307, USA. */
#endif #endif
static int interface_strcmp PARAMS ((const char *)); static int interface_strcmp PARAMS ((const char *));
static int *init_cpp_parse PARAMS ((void));
static void init_cp_pragma PARAMS ((void)); static void init_cp_pragma PARAMS ((void));
static tree parse_strconst_pragma PARAMS ((const char *, int)); static tree parse_strconst_pragma PARAMS ((const char *, int));
...@@ -57,12 +56,6 @@ static void handle_pragma_interface PARAMS ((cpp_reader *)); ...@@ -57,12 +56,6 @@ static void handle_pragma_interface PARAMS ((cpp_reader *));
static void handle_pragma_implementation PARAMS ((cpp_reader *)); static void handle_pragma_implementation PARAMS ((cpp_reader *));
static void handle_pragma_java_exceptions PARAMS ((cpp_reader *)); static void handle_pragma_java_exceptions PARAMS ((cpp_reader *));
#ifdef GATHER_STATISTICS
#ifdef REDUCE_LENGTH
static int reduce_cmp PARAMS ((int *, int *));
static int token_cmp PARAMS ((int *, int *));
#endif
#endif
static int is_global PARAMS ((tree)); static int is_global PARAMS ((tree));
static void init_operators PARAMS ((void)); static void init_operators PARAMS ((void));
static void copy_lang_type PARAMS ((tree)); static void copy_lang_type PARAMS ((tree));
...@@ -76,18 +69,6 @@ static void copy_lang_type PARAMS ((tree)); ...@@ -76,18 +69,6 @@ static void copy_lang_type PARAMS ((tree));
#include "cpplib.h" #include "cpplib.h"
extern int yychar; /* the lookahead symbol */
/* the declaration found for the last IDENTIFIER token read in. yylex
must look this up to detect typedefs, which get token type
tTYPENAME, so it is left around in case the identifier is not a
typedef but is used in a context which makes it a reference to a
variable. */
tree lastiddecl;
/* Array for holding counts of the numbers of tokens seen. */
extern int *token_count;
/* Functions and data structures for #pragma interface. /* Functions and data structures for #pragma interface.
`#pragma implementation' means that the main file being compiled `#pragma implementation' means that the main file being compiled
...@@ -202,20 +183,6 @@ cxx_finish () ...@@ -202,20 +183,6 @@ cxx_finish ()
c_common_finish (); c_common_finish ();
} }
static int *
init_cpp_parse ()
{
#ifdef GATHER_STATISTICS
#ifdef REDUCE_LENGTH
reduce_count = (int *) xcalloc (sizeof (int), (REDUCE_LENGTH + 1));
reduce_count += 1;
token_count = (int *) xcalloc (sizeof (int), (TOKEN_LENGTH + 1));
token_count += 1;
#endif
#endif
return token_count;
}
/* A mapping from tree codes to operator name information. */ /* A mapping from tree codes to operator name information. */
operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE]; operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE];
/* Similar, but for assignment operators. */ /* Similar, but for assignment operators. */
...@@ -492,7 +459,6 @@ cxx_init (filename) ...@@ -492,7 +459,6 @@ cxx_init (filename)
TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0); TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
ridpointers[RID_NULL] = null_node; ridpointers[RID_NULL] = null_node;
token_count = init_cpp_parse ();
interface_unknown = 1; interface_unknown = 1;
filename = c_common_init (filename); filename = c_common_init (filename);
...@@ -506,92 +472,6 @@ cxx_init (filename) ...@@ -506,92 +472,6 @@ cxx_init (filename)
return filename; return filename;
} }
#if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
static int *reduce_count;
#endif
int *token_count;
#if 0
#define REDUCE_LENGTH ARRAY_SIZE (yyr2)
#define TOKEN_LENGTH (256 + ARRAY_SIZE (yytname))
#endif
#ifdef GATHER_STATISTICS
#ifdef REDUCE_LENGTH
void
yyhook (yyn)
int yyn;
{
reduce_count[yyn] += 1;
}
static int
reduce_cmp (p, q)
int *p, *q;
{
return reduce_count[*q] - reduce_count[*p];
}
static int
token_cmp (p, q)
int *p, *q;
{
return token_count[*q] - token_count[*p];
}
#endif
#endif
void
print_parse_statistics ()
{
#ifdef GATHER_STATISTICS
#ifdef REDUCE_LENGTH
#if YYDEBUG != 0
int i;
int maxlen = REDUCE_LENGTH;
unsigned *sorted;
if (reduce_count[-1] == 0)
return;
if (TOKEN_LENGTH > REDUCE_LENGTH)
maxlen = TOKEN_LENGTH;
sorted = (unsigned *) alloca (sizeof (int) * maxlen);
for (i = 0; i < TOKEN_LENGTH; i++)
sorted[i] = i;
qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
for (i = 0; i < TOKEN_LENGTH; i++)
{
int idx = sorted[i];
if (token_count[idx] == 0)
break;
if (token_count[idx] < token_count[-1])
break;
fprintf (stderr, "token %d, `%s', count = %d\n",
idx, yytname[YYTRANSLATE (idx)], token_count[idx]);
}
fprintf (stderr, "\n");
for (i = 0; i < REDUCE_LENGTH; i++)
sorted[i] = i;
qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
for (i = 0; i < REDUCE_LENGTH; i++)
{
int idx = sorted[i];
if (reduce_count[idx] == 0)
break;
if (reduce_count[idx] < reduce_count[-1])
break;
fprintf (stderr, "rule %d, line %d, count = %d\n",
idx, yyrline[idx], reduce_count[idx]);
}
fprintf (stderr, "\n");
#endif
#endif
#endif
}
/* Helper function to load global variables with interface /* Helper function to load global variables with interface
information. */ information. */
...@@ -819,15 +699,6 @@ handle_pragma_java_exceptions (dfile) ...@@ -819,15 +699,6 @@ handle_pragma_java_exceptions (dfile)
choose_personality_routine (lang_java); choose_personality_routine (lang_java);
} }
void
do_pending_lang_change ()
{
for (; pending_lang_change > 0; --pending_lang_change)
push_lang_context (lang_name_c);
for (; pending_lang_change < 0; ++pending_lang_change)
pop_lang_context ();
}
/* Return true if d is in a global scope. */ /* Return true if d is in a global scope. */
static int static int
...@@ -884,21 +755,13 @@ unqualified_name_lookup_error (tree name) ...@@ -884,21 +755,13 @@ unqualified_name_lookup_error (tree name)
} }
tree tree
do_identifier (token, parsing, args) do_identifier (token, args)
register tree token; register tree token;
int parsing;
tree args; tree args;
{ {
register tree id; register tree id;
int lexing = (parsing == 1 || parsing == 3);
if (! lexing) id = lookup_name (token, 0);
id = lookup_name (token, 0);
else
id = lastiddecl;
if (lexing && id && TREE_DEPRECATED (id))
warn_deprecated_use (id);
/* Do Koenig lookup if appropriate (inside templates we build lookup /* Do Koenig lookup if appropriate (inside templates we build lookup
expressions instead). expressions instead).
...@@ -910,11 +773,6 @@ do_identifier (token, parsing, args) ...@@ -910,11 +773,6 @@ do_identifier (token, parsing, args)
if (args && !current_template_parms && (!id || is_global (id))) if (args && !current_template_parms && (!id || is_global (id)))
id = lookup_arg_dependent (token, id, args); id = lookup_arg_dependent (token, id, args);
/* Remember that this name has been used in the class definition, as per
[class.scope0] */
if (id && parsing && parsing != 3)
maybe_note_name_used_in_class (token, id);
if (id == error_mark_node) if (id == error_mark_node)
{ {
/* lookup_name quietly returns error_mark_node if we're parsing, /* lookup_name quietly returns error_mark_node if we're parsing,
......
gcc/cp/lex.h
...@@ -64,20 +64,4 @@ typedef unsigned long RID_BIT_TYPE; /* assumed at least 32 bits */ ...@@ -64,20 +64,4 @@ typedef unsigned long RID_BIT_TYPE; /* assumed at least 32 bits */
#define RIDBIT_RESET_ALL(V) do { (V) = 0; } while (0) #define RIDBIT_RESET_ALL(V) do { (V) = 0; } while (0)
#endif #endif
/* the declaration found for the last IDENTIFIER token read in.
yylex must look this up to detect typedefs, which get token type TYPENAME,
so it is left around in case the identifier is not a typedef but is
used in a context which makes it a reference to a variable. */
extern GTY(()) tree lastiddecl;
/* Back-door communication channel to the lexer. */
extern int looking_for_typename;
extern int looking_for_template;
/* Pending language change.
Positive is push count, negative is pop count. */
extern int pending_lang_change;
extern int yylex PARAMS ((void));
#endif /* ! GCC_CP_LEX_H */ #endif /* ! GCC_CP_LEX_H */
gcc/cp/parse.y deleted 100644 → 0
This source diff could not be displayed because it is too large. You can view the blob instead.
gcc/cp/semantics.c
...@@ -1550,20 +1550,6 @@ finish_unary_op_expr (code, expr) ...@@ -1550,20 +1550,6 @@ finish_unary_op_expr (code, expr)
return result; return result;
} }
/* Finish an id-expression. */
tree
finish_id_expr (expr)
tree expr;
{
if (TREE_CODE (expr) == IDENTIFIER_NODE)
expr = do_identifier (expr, 1, NULL_TREE);
if (TREE_TYPE (expr) == error_mark_node)
expr = error_mark_node;
return expr;
}
/* Finish a compound-literal expression. TYPE is the type to which /* Finish a compound-literal expression. TYPE is the type to which
the INITIALIZER_LIST is being cast. */ the INITIALIZER_LIST is being cast. */
......
gcc/cp/spew.c deleted 100644 → 0
/* Type Analyzer for GNU C++.
Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002 Free Software Foundation, Inc.
Hacked... nay, bludgeoned... by Mark Eichin (eichin@cygnus.com)
This file is part of GNU CC.
GNU CC 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.
GNU CC 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 GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* This file is the type analyzer for GNU C++. To debug it, define SPEW_DEBUG
when compiling parse.c and spew.c. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "input.h"
#include "tree.h"
#include "cp-tree.h"
#include "cpplib.h"
#include "c-pragma.h"
#include "lex.h"
#include "flags.h"
#include "obstack.h"
#include "toplev.h"
#include "ggc.h"
#include "intl.h"
#include "timevar.h"
#ifdef SPEW_DEBUG
#define SPEW_INLINE
#else
#define SPEW_INLINE inline
#endif
/* This takes a token stream that hasn't decided much about types and
tries to figure out as much as it can, with excessive lookahead and
backtracking. */
/* fifo of tokens recognized and available to parser. */
struct token GTY(())
{
/* The values for YYCHAR will fit in a short. */
short yychar;
unsigned int lineno;
YYSTYPE GTY ((desc ("%1.yychar"))) yylval;
};
/* Since inline methods can refer to text which has not yet been seen,
we store the text of the method in a structure which is placed in the
DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
After parsing the body of the class definition, the FUNCTION_DECL's are
scanned to see which ones have this field set. Those are then digested
one at a time.
This function's FUNCTION_DECL will have a bit set in its common so
that we know to watch out for it. */
#define TOKEN_CHUNK_SIZE 20
struct token_chunk GTY(())
{
struct token_chunk *next;
struct token toks[TOKEN_CHUNK_SIZE];
};
struct unparsed_text GTY(())
{
struct unparsed_text *next; /* process this one next */
tree decl; /* associated declaration */
location_t locus; /* location we got the text from */
int interface; /* remembering interface_unknown and interface_only */
struct token_chunk * tokens; /* Start of the token list. */
struct token_chunk *last_chunk; /* End of the token list. */
short last_pos; /* Number of tokens used in the last chunk of
TOKENS. */
short cur_pos; /* Current token in 'cur_chunk', when rescanning. */
struct token_chunk *cur_chunk; /* Current chunk, when rescanning. */
};
/* Stack of state saved off when we return to an inline method or
default argument that has been stored for later parsing. */
struct feed GTY(())
{
struct unparsed_text *input;
location_t locus;
int yychar;
YYSTYPE GTY ((desc ("%1.yychar"))) yylval;
int first_token;
struct obstack GTY ((skip (""))) token_obstack;
struct feed *next;
};
static GTY(()) struct feed *feed;
static SPEW_INLINE void do_aggr PARAMS ((void));
static SPEW_INLINE int identifier_type PARAMS ((tree));
static void scan_tokens PARAMS ((int));
static void feed_defarg PARAMS ((tree));
static void finish_defarg PARAMS ((void));
static void yylexstring PARAMS ((struct token *));
static int read_token PARAMS ((struct token *));
static SPEW_INLINE int num_tokens PARAMS ((void));
static SPEW_INLINE struct token *nth_token PARAMS ((int));
static SPEW_INLINE int next_token PARAMS ((struct token *));
static SPEW_INLINE int shift_token PARAMS ((void));
static SPEW_INLINE void push_token PARAMS ((struct token *));
static SPEW_INLINE void consume_token PARAMS ((void));
static SPEW_INLINE int read_process_identifier PARAMS ((YYSTYPE *));
static SPEW_INLINE void feed_input PARAMS ((struct unparsed_text *));
static SPEW_INLINE struct token * space_for_token
PARAMS ((struct unparsed_text *t));
static SPEW_INLINE struct token * remove_last_token
PARAMS ((struct unparsed_text *t));
static struct unparsed_text * alloc_unparsed_text
PARAMS ((const location_t *, tree decl, int interface));
static void snarf_block PARAMS ((struct unparsed_text *t));
static tree snarf_defarg PARAMS ((void));
static void snarf_parenthesized_expression (struct unparsed_text *);
static int frob_id PARAMS ((int, int, tree *));
/* The list of inline functions being held off until we reach the end of
the current class declaration. */
static GTY(()) struct unparsed_text *pending_inlines;
static GTY(()) struct unparsed_text *pending_inlines_tail;
/* The list of previously-deferred inline functions currently being parsed.
This exists solely to be a GC root. */
static GTY(()) struct unparsed_text *processing_these_inlines;
static void begin_parsing_inclass_inline PARAMS ((struct unparsed_text *));
#ifdef SPEW_DEBUG
int spew_debug = 0;
static unsigned int yylex_ctr = 0;
static void debug_yychar PARAMS ((int));
/* In parse.y: */
extern char *debug_yytranslate PARAMS ((int));
#endif
static enum cpp_ttype last_token;
static tree last_token_id;
/* From lex.c: */
/* the declaration found for the last IDENTIFIER token read in. yylex
must look this up to detect typedefs, which get token type
tTYPENAME, so it is left around in case the identifier is not a
typedef but is used in a context which makes it a reference to a
variable. */
extern tree lastiddecl; /* let our brains leak out here too */
extern int yychar; /* the lookahead symbol */
extern YYSTYPE yylval; /* the semantic value of the */
/* lookahead symbol */
/* The token fifo lives in this obstack. */
static struct obstack token_obstack;
static int first_token;
/* When we see a default argument in a method declaration, we snarf it as
text using snarf_defarg. When we get up to namespace scope, we then go
through and parse all of them using do_pending_defargs. Since yacc
parsers are not reentrant, we retain defargs state in these two
variables so that subsequent calls to do_pending_defargs can resume
where the previous call left off. DEFARG_FNS is a tree_list where
the TREE_TYPE is the current_class_type, TREE_VALUE is the FUNCTION_DECL,
and TREE_PURPOSE is the list unprocessed dependent functions. */
/* list of functions with unprocessed defargs */
static GTY(()) tree defarg_fns;
/* current default parameter */
static GTY(()) tree defarg_parm;
/* list of unprocessed fns met during current fn. */
static GTY(()) tree defarg_depfns;
/* list of fns with circular defargs */
static GTY(()) tree defarg_fnsdone;
/* Initialize obstacks. Called once, from cxx_init. */
void
init_spew ()
{
gcc_obstack_init (&token_obstack);
}
/* Subroutine of read_token. */
static SPEW_INLINE int
read_process_identifier (pyylval)
YYSTYPE *pyylval;
{
tree id = pyylval->ttype;
if (C_IS_RESERVED_WORD (id))
{
pyylval->ttype = ridpointers[C_RID_CODE (id)];
return C_RID_YYCODE (id);
}
/* Make sure that user does not collide with our internal naming
scheme. This is not necessary if '.' is used to remove them from
the user's namespace, but is if '$' or double underscores are. */
#if !defined(JOINER) || JOINER == '$'
if (VPTR_NAME_P (id)
|| VTABLE_NAME_P (id)
|| TEMP_NAME_P (id)
|| ANON_AGGRNAME_P (id))
warning (
"identifier name `%s' conflicts with GNU C++ internal naming strategy",
IDENTIFIER_POINTER (id));
#endif
return IDENTIFIER;
}
/* Concatenate strings before returning them to the parser. This isn't quite
as good as having it done in the lexer, but it's better than nothing. */
static void
yylexstring (t)
struct token *t;
{
enum cpp_ttype next_type;
tree next;
next_type = c_lex (&next);
if (next_type == CPP_STRING || next_type == CPP_WSTRING)
{
varray_type strings;
VARRAY_TREE_INIT (strings, 32, "strings");
VARRAY_PUSH_TREE (strings, t->yylval.ttype);
do
{
VARRAY_PUSH_TREE (strings, next);
next_type = c_lex (&next);
}
while (next_type == CPP_STRING || next_type == CPP_WSTRING);
t->yylval.ttype = combine_strings (strings);
last_token_id = t->yylval.ttype;
}
/* We will have always read one token too many. */
_cpp_backup_tokens (parse_in, 1);
t->yychar = STRING;
}
/* Read the next token from the input file. The token is written into
T, and its type number is returned. */
static int
read_token (t)
struct token *t;
{
retry:
last_token = c_lex (&last_token_id);
t->yylval.ttype = last_token_id;
switch (last_token)
{
#define YYCHAR(YY) t->yychar = (YY); break;
#define YYCODE(C) t->yylval.code = (C);
case CPP_EQ: YYCHAR('=');
case CPP_NOT: YYCHAR('!');
case CPP_GREATER: YYCODE(GT_EXPR); YYCHAR('>');
case CPP_LESS: YYCODE(LT_EXPR); YYCHAR('<');
case CPP_PLUS: YYCODE(PLUS_EXPR); YYCHAR('+');
case CPP_MINUS: YYCODE(MINUS_EXPR); YYCHAR('-');
case CPP_MULT: YYCODE(MULT_EXPR); YYCHAR('*');
case CPP_DIV: YYCODE(TRUNC_DIV_EXPR); YYCHAR('/');
case CPP_MOD: YYCODE(TRUNC_MOD_EXPR); YYCHAR('%');
case CPP_AND: YYCODE(BIT_AND_EXPR); YYCHAR('&');
case CPP_OR: YYCODE(BIT_IOR_EXPR); YYCHAR('|');
case CPP_XOR: YYCODE(BIT_XOR_EXPR); YYCHAR('^');
case CPP_RSHIFT: YYCODE(RSHIFT_EXPR); YYCHAR(RSHIFT);
case CPP_LSHIFT: YYCODE(LSHIFT_EXPR); YYCHAR(LSHIFT);
case CPP_COMPL: YYCHAR('~');
case CPP_AND_AND: YYCHAR(ANDAND);
case CPP_OR_OR: YYCHAR(OROR);
case CPP_QUERY: YYCHAR('?');
case CPP_COLON: YYCHAR(':');
case CPP_COMMA: YYCHAR(',');
case CPP_OPEN_PAREN: YYCHAR('(');
case CPP_CLOSE_PAREN: YYCHAR(')');
case CPP_EQ_EQ: YYCODE(EQ_EXPR); YYCHAR(EQCOMPARE);
case CPP_NOT_EQ: YYCODE(NE_EXPR); YYCHAR(EQCOMPARE);
case CPP_GREATER_EQ:YYCODE(GE_EXPR); YYCHAR(ARITHCOMPARE);
case CPP_LESS_EQ: YYCODE(LE_EXPR); YYCHAR(ARITHCOMPARE);
case CPP_PLUS_EQ: YYCODE(PLUS_EXPR); YYCHAR(ASSIGN);
case CPP_MINUS_EQ: YYCODE(MINUS_EXPR); YYCHAR(ASSIGN);
case CPP_MULT_EQ: YYCODE(MULT_EXPR); YYCHAR(ASSIGN);
case CPP_DIV_EQ: YYCODE(TRUNC_DIV_EXPR); YYCHAR(ASSIGN);
case CPP_MOD_EQ: YYCODE(TRUNC_MOD_EXPR); YYCHAR(ASSIGN);
case CPP_AND_EQ: YYCODE(BIT_AND_EXPR); YYCHAR(ASSIGN);
case CPP_OR_EQ: YYCODE(BIT_IOR_EXPR); YYCHAR(ASSIGN);
case CPP_XOR_EQ: YYCODE(BIT_XOR_EXPR); YYCHAR(ASSIGN);
case CPP_RSHIFT_EQ: YYCODE(RSHIFT_EXPR); YYCHAR(ASSIGN);
case CPP_LSHIFT_EQ: YYCODE(LSHIFT_EXPR); YYCHAR(ASSIGN);
case CPP_OPEN_SQUARE: YYCHAR('[');
case CPP_CLOSE_SQUARE: YYCHAR(']');
case CPP_OPEN_BRACE: YYCHAR('{');
case CPP_CLOSE_BRACE: YYCHAR('}');
case CPP_SEMICOLON: YYCHAR(';');
case CPP_ELLIPSIS: YYCHAR(ELLIPSIS);
case CPP_PLUS_PLUS: YYCHAR(PLUSPLUS);
case CPP_MINUS_MINUS: YYCHAR(MINUSMINUS);
case CPP_DEREF: YYCHAR(POINTSAT);
case CPP_DOT: YYCHAR('.');
/* These tokens are C++ specific. */
case CPP_SCOPE: YYCHAR(SCOPE);
case CPP_DEREF_STAR: YYCHAR(POINTSAT_STAR);
case CPP_DOT_STAR: YYCHAR(DOT_STAR);
case CPP_MIN_EQ: YYCODE(MIN_EXPR); YYCHAR(ASSIGN);
case CPP_MAX_EQ: YYCODE(MAX_EXPR); YYCHAR(ASSIGN);
case CPP_MIN: YYCODE(MIN_EXPR); YYCHAR(MIN_MAX);
case CPP_MAX: YYCODE(MAX_EXPR); YYCHAR(MIN_MAX);
#undef YYCHAR
#undef YYCODE
case CPP_EOF:
t->yychar = 0;
break;
case CPP_NAME:
t->yychar = read_process_identifier (&t->yylval);
break;
case CPP_NUMBER:
case CPP_CHAR:
case CPP_WCHAR:
t->yychar = CONSTANT;
break;
case CPP_STRING:
case CPP_WSTRING:
yylexstring (t);
break;
default:
yyerror ("parse error");
goto retry;
}
t->lineno = lineno;
return t->yychar;
}
static void
feed_input (input)
struct unparsed_text *input;
{
struct feed *f;
#if 0
if (feed)
abort ();
#endif
f = ggc_alloc (sizeof (struct feed));
input->cur_chunk = input->tokens;
input->cur_pos = 0;
#ifdef SPEW_DEBUG
if (spew_debug)
fprintf (stderr, "\tfeeding %s:%d [%d tokens]\n",
input->locus.file, input->locus.line,
input->last_pos - input->cur_pos);
#endif
f->input = input;
f->locus.file = input_filename;
f->locus.line = lineno;
f->yychar = yychar;
f->yylval = yylval;
f->first_token = first_token;
f->token_obstack = token_obstack;
f->next = feed;
input_filename = input->locus.file;
lineno = input->locus.line;
yychar = YYEMPTY;
yylval.ttype = NULL_TREE;
first_token = 0;
gcc_obstack_init (&token_obstack);
feed = f;
}
void
end_input ()
{
struct feed *f = feed;
input_filename = f->locus.file;
lineno = f->locus.line;
yychar = f->yychar;
yylval = f->yylval;
first_token = f->first_token;
obstack_free (&token_obstack, 0);
token_obstack = f->token_obstack;
feed = f->next;
#ifdef SPEW_DEBUG
if (spew_debug)
fprintf (stderr, "\treturning to %s:%d\n", input_filename, lineno);
#endif
}
/* Token queue management. */
/* Return the number of tokens available on the fifo. */
static SPEW_INLINE int
num_tokens ()
{
return (obstack_object_size (&token_obstack) / sizeof (struct token))
- first_token;
}
/* Fetch the token N down the line from the head of the fifo. */
static SPEW_INLINE struct token*
nth_token (n)
int n;
{
#ifdef ENABLE_CHECKING
/* could just have this do slurp_ implicitly, but this way is easier
to debug... */
my_friendly_assert (n >= 0 && n < num_tokens (), 298);
#endif
return ((struct token*)obstack_base (&token_obstack)) + n + first_token;
}
static const struct token Teosi = { END_OF_SAVED_INPUT, 0 UNION_INIT_ZERO };
static const struct token Tpad = { EMPTY, 0 UNION_INIT_ZERO };
/* Copy the next token into T and return its value. */
static SPEW_INLINE int
next_token (t)
struct token *t;
{
if (!feed)
return read_token (t);
if (feed->input->cur_chunk != feed->input->last_chunk
|| feed->input->cur_pos != feed->input->last_pos)
{
if (feed->input->cur_pos == TOKEN_CHUNK_SIZE)
{
feed->input->cur_chunk = feed->input->cur_chunk->next;
feed->input->cur_pos = 0;
}
memcpy (t, feed->input->cur_chunk->toks + feed->input->cur_pos,
sizeof (struct token));
feed->input->cur_pos++;
return t->yychar;
}
return 0;
}
/* Shift the next token onto the fifo. */
static SPEW_INLINE int
shift_token ()
{
size_t point = obstack_object_size (&token_obstack);
obstack_blank (&token_obstack, sizeof (struct token));
return next_token ((struct token *) (obstack_base (&token_obstack) + point));
}
/* Consume the next token out of the fifo. */
static SPEW_INLINE void
consume_token ()
{
if (num_tokens () == 1)
{
obstack_free (&token_obstack, obstack_base (&token_obstack));
first_token = 0;
}
else
first_token++;
}
/* Push a token at the head of the queue; it will be the next token read. */
static SPEW_INLINE void
push_token (t)
struct token *t;
{
if (first_token == 0) /* We hope this doesn't happen often. */
{
size_t active = obstack_object_size (&token_obstack);
obstack_blank (&token_obstack, sizeof (struct token));
if (active)
memmove (obstack_base (&token_obstack) + sizeof (struct token),
obstack_base (&token_obstack), active);
first_token++;
}
first_token--;
memcpy (nth_token (0), t, sizeof (struct token));
}
/* Pull in enough tokens that the queue is N long beyond the current
token. */
static void
scan_tokens (n)
int n;
{
int i;
int num = num_tokens ();
int yychar;
/* First, prune any empty tokens at the end. */
i = num;
while (i > 0 && nth_token (i - 1)->yychar == EMPTY)
i--;
if (i < num)
{
obstack_blank (&token_obstack, -((num - i) * sizeof (struct token)));
num = i;
}
/* Now, if we already have enough tokens, return. */
if (num > n)
return;
/* Never read past these characters: they might separate
the current input stream from one we save away later. */
for (i = 0; i < num; i++)
{
yychar = nth_token (i)->yychar;
if (yychar == '{' || yychar == ':' || yychar == ';')
goto pad_tokens;
}
while (num_tokens () <= n)
{
yychar = shift_token ();
if (yychar == '{' || yychar == ':' || yychar == ';')
goto pad_tokens;
}
return;
pad_tokens:
while (num_tokens () <= n)
obstack_grow (&token_obstack, &Tpad, sizeof (struct token));
}
int looking_for_typename;
int looking_for_template;
static int after_friend;
static int after_new;
static int do_snarf_defarg;
tree got_scope;
tree got_object;
static SPEW_INLINE int
identifier_type (decl)
tree decl;
{
tree t;
if (TREE_CODE (decl) == TEMPLATE_DECL)
{
if (TREE_CODE (DECL_TEMPLATE_RESULT (decl)) == TYPE_DECL)
return PTYPENAME;
else if (looking_for_template)
return PFUNCNAME;
}
if (looking_for_template && really_overloaded_fn (decl))
{
/* See through a baselink. */
if (TREE_CODE (decl) == BASELINK)
decl = BASELINK_FUNCTIONS (decl);
for (t = decl; t != NULL_TREE; t = OVL_CHAIN (t))
if (DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (t)))
return PFUNCNAME;
}
if (TREE_CODE (decl) == NAMESPACE_DECL)
return NSNAME;
if (TREE_CODE (decl) != TYPE_DECL)
return IDENTIFIER;
if (DECL_ARTIFICIAL (decl) && TREE_TYPE (decl) == current_class_type)
return SELFNAME;
/* A constructor declarator for a template type will get here as an
implicit typename, a TYPENAME_TYPE with a type. */
t = got_scope;
if (t && TREE_CODE (t) == TYPENAME_TYPE)
t = TREE_TYPE (t);
decl = TREE_TYPE (decl);
if (TREE_CODE (decl) == TYPENAME_TYPE)
decl = TREE_TYPE (decl);
if (t && t == decl)
return SELFNAME;
return tTYPENAME;
}
/* token[0] == AGGR (struct/union/enum)
Thus, token[1] is either a tTYPENAME or a TYPENAME_DEFN.
If token[2] == '{' or ':' then it's TYPENAME_DEFN.
It's also a definition if it's a forward declaration (as in 'struct Foo;')
which we can tell if token[2] == ';' *and* token[-1] != FRIEND or NEW. */
static SPEW_INLINE void
do_aggr ()
{
int yc1, yc2;
scan_tokens (2);
yc1 = nth_token (1)->yychar;
if (yc1 != tTYPENAME && yc1 != IDENTIFIER && yc1 != PTYPENAME)
return;
yc2 = nth_token (2)->yychar;
if (yc2 == ';')
{
/* It's a forward declaration iff we were not preceded by
'friend' or `new'. */
if (after_friend || after_new)
return;
}
else if (yc2 != '{' && yc2 != ':')
return;
switch (yc1)
{
case tTYPENAME:
nth_token (1)->yychar = TYPENAME_DEFN;
break;
case PTYPENAME:
nth_token (1)->yychar = PTYPENAME_DEFN;
break;
case IDENTIFIER:
nth_token (1)->yychar = IDENTIFIER_DEFN;
break;
default:
abort ();
}
}
void
see_typename ()
{
/* Only types expected, not even namespaces. */
looking_for_typename = 2;
if (yychar < 0)
if ((yychar = yylex ()) < 0) yychar = 0;
looking_for_typename = 0;
if (yychar == IDENTIFIER)
{
lastiddecl = lookup_name (yylval.ttype, -2);
if (lastiddecl)
yychar = identifier_type (lastiddecl);
}
}
int
yylex ()
{
int yychr;
int old_looking_for_typename = 0;
int just_saw_new = 0;
int just_saw_friend = 0;
timevar_push (TV_LEX);
retry:
#ifdef SPEW_DEBUG
if (spew_debug)
{
yylex_ctr ++;
fprintf (stderr, "\t\t## %d @%d ", yylex_ctr, lineno);
}
#endif
if (do_snarf_defarg)
{
do_snarf_defarg = 0;
yylval.ttype = snarf_defarg ();
yychar = DEFARG;
got_object = NULL_TREE;
timevar_pop (TV_LEX);
return DEFARG;
}
/* if we've got tokens, send them */
else if (num_tokens ())
yychr = nth_token (0)->yychar;
else
yychr = shift_token ();
/* many tokens just need to be returned. At first glance, all we
have to do is send them back up, but some of them are needed to
figure out local context. */
switch (yychr)
{
case EMPTY:
/* This is a lexical no-op. */
#ifdef SPEW_DEBUG
if (spew_debug)
debug_yychar (yychr);
#endif
consume_token ();
goto retry;
case '(':
scan_tokens (1);
if (nth_token (1)->yychar == ')')
{
consume_token ();
yychr = LEFT_RIGHT;
}
break;
case IDENTIFIER:
{
int peek;
scan_tokens (1);
peek = nth_token (1)->yychar;
yychr = frob_id (yychr, peek, &nth_token (0)->yylval.ttype);
break;
}
case IDENTIFIER_DEFN:
case tTYPENAME:
case TYPENAME_DEFN:
case PTYPENAME:
case PTYPENAME_DEFN:
/* If we see a SCOPE next, restore the old value.
Otherwise, we got what we want. */
looking_for_typename = old_looking_for_typename;
looking_for_template = 0;
break;
case SCSPEC:
if (nth_token (0)->yylval.ttype == ridpointers[RID_EXTERN])
{
scan_tokens (1);
if (nth_token (1)->yychar == STRING)
{
yychr = EXTERN_LANG_STRING;
nth_token (1)->yylval.ttype = get_identifier
(TREE_STRING_POINTER (nth_token (1)->yylval.ttype));
consume_token ();
}
}
/* do_aggr needs to know if the previous token was `friend'. */
else if (nth_token (0)->yylval.ttype == ridpointers[RID_FRIEND])
just_saw_friend = 1;
break;
case NEW:
/* do_aggr needs to know if the previous token was `new'. */
just_saw_new = 1;
break;
case TYPESPEC:
case '{':
case ':':
case ';':
/* If this provides a type for us, then revert lexical
state to standard state. */
looking_for_typename = 0;
break;
case AGGR:
do_aggr ();
break;
case ENUM:
/* Set this again, in case we are rescanning. */
looking_for_typename = 2;
break;
default:
break;
}
after_friend = just_saw_friend;
after_new = just_saw_new;
/* class member lookup only applies to the first token after the object
expression, except for explicit destructor calls. */
if (yychr != '~')
got_object = NULL_TREE;
yychar = yychr;
{
struct token *tok = nth_token (0);
yylval = tok->yylval;
if (tok->lineno)
lineno = tok->lineno;
}
#ifdef SPEW_DEBUG
if (spew_debug)
debug_yychar (yychr);
#endif
consume_token ();
timevar_pop (TV_LEX);
return yychr;
}
/* Unget character CH from the input stream.
If RESCAN is nonzero, then we want to `see' this
character as the next input token. */
void
yyungetc (ch, rescan)
int ch;
int rescan;
{
/* Unget a character from the input stream. */
if (yychar == YYEMPTY || rescan == 0)
{
struct token fake;
fake.yychar = ch;
fake.yylval.ttype = 0;
fake.lineno = lineno;
push_token (&fake);
}
else
{
yychar = ch;
}
}
/* Lexer hackery to determine what *IDP really is. */
static int
frob_id (yyc, peek, idp)
int yyc;
int peek;
tree *idp;
{
tree trrr;
int old_looking_for_typename = 0;
if (peek == SCOPE)
{
/* Don't interfere with the setting from an 'aggr' prefix. */
old_looking_for_typename = looking_for_typename;
looking_for_typename = 1;
}
else if (peek == '<')
looking_for_template = 1;
trrr = lookup_name (*idp, -2);
if (trrr)
{
yyc = identifier_type (trrr);
switch(yyc)
{
case tTYPENAME:
case SELFNAME:
case NSNAME:
case PTYPENAME:
/* If this got special lookup, remember it. In these
cases, we know it can't be a declarator-id. */
if (got_scope || got_object)
*idp = trrr;
/* FALLTHROUGH */
case PFUNCNAME:
case IDENTIFIER:
lastiddecl = trrr;
break;
default:
abort ();
}
}
else
lastiddecl = NULL_TREE;
got_scope = NULL_TREE;
looking_for_typename = old_looking_for_typename;
looking_for_template = 0;
return yyc;
}
/* ID is an operator name. Duplicate the hackery in yylex to determine what
it really is. */
tree frob_opname (id)
tree id;
{
scan_tokens (0);
frob_id (0, nth_token (0)->yychar, &id);
got_object = NULL_TREE;
return id;
}
/* Set up the state required to correctly handle the definition of the
inline function whose preparsed state has been saved in PI. */
static void
begin_parsing_inclass_inline (pi)
struct unparsed_text *pi;
{
tree context;
/* Record that we are processing the chain of inlines starting at
PI for GC. */
if (cfun)
cp_function_chain->unparsed_inlines = pi;
else
processing_these_inlines = pi;
ggc_collect ();
/* If this is an inline function in a local class, we must make sure
that we save all pertinent information about the function
surrounding the local class. */
context = decl_function_context (pi->decl);
if (context)
push_function_context_to (context);
feed_input (pi);
interface_unknown = pi->interface == 1;
interface_only = pi->interface == 0;
DECL_PENDING_INLINE_P (pi->decl) = 0;
DECL_PENDING_INLINE_INFO (pi->decl) = 0;
/* Pass back a handle to the rest of the inline functions, so that they
can be processed later. */
yychar = PRE_PARSED_FUNCTION_DECL;
yylval.pi = pi;
start_function (NULL_TREE, pi->decl, NULL_TREE,
(SF_DEFAULT | SF_PRE_PARSED | SF_INCLASS_INLINE));
}
/* Called from the top level: if there are any pending inlines to
do, set up to process them now. This function sets up the first function
to be parsed; after it has been, the rule for fndef in parse.y will
call process_next_inline to start working on the next one. */
void
do_pending_inlines ()
{
/* Oops, we're still dealing with the last batch. */
if (yychar == PRE_PARSED_FUNCTION_DECL)
return;
if (pending_inlines)
{
/* Clear the chain, so that any inlines nested inside the batch
we're to process now don't refer to this batch. See e.g.
g++.other/lookup6.C. */
struct unparsed_text *first = pending_inlines;
pending_inlines = pending_inlines_tail = 0;
begin_parsing_inclass_inline (first);
}
}
/* Called from the fndecl rule in the parser when the function just parsed
was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
do_pending_inlines). */
void
process_next_inline (i)
struct unparsed_text *i;
{
tree decl = i->decl;
tree context = decl_function_context (decl);
if (context)
pop_function_context_from (context);
if (yychar == YYEMPTY)
yychar = yylex ();
if (yychar != END_OF_SAVED_INPUT)
error ("parse error at end of saved function text");
end_input ();
i = i->next;
if (i)
begin_parsing_inclass_inline (i);
else
{
if (cfun)
cp_function_chain->unparsed_inlines = 0;
else
processing_these_inlines = 0;
extract_interface_info ();
}
}
/* Create a new token at the end of the token list in T. */
static SPEW_INLINE struct token *
space_for_token (t)
struct unparsed_text *t;
{
if (t->last_pos != TOKEN_CHUNK_SIZE)
return t->last_chunk->toks + (t->last_pos++);
t->last_chunk->next = ggc_alloc_cleared (sizeof (*t->last_chunk->next));
t->last_chunk = t->last_chunk->next;
t->last_chunk->next = NULL;
t->last_pos = 1;
return t->last_chunk->toks;
}
/* Shrink the token list in T by one token. */
static SPEW_INLINE struct token *
remove_last_token (t)
struct unparsed_text *t;
{
struct token *result = t->last_chunk->toks + t->last_pos - 1;
if (t->last_pos == 0)
abort ();
t->last_pos--;
if (t->last_pos == 0 && t->last_chunk != t->tokens)
{
struct token_chunk *c;
c = t->tokens;
while (c->next != t->last_chunk)
c = c->next;
c->next = NULL;
t->last_chunk = c;
t->last_pos = ARRAY_SIZE (c->toks);
}
return result;
}
/* Allocate an 'unparsed_text' structure, ready to use space_for_token. */
static struct unparsed_text *
alloc_unparsed_text (locus, decl, interface)
const location_t *locus;
tree decl;
int interface;
{
struct unparsed_text *r;
r = ggc_alloc_cleared (sizeof (*r));
r->decl = decl;
r->locus = *locus;
r->interface = interface;
r->tokens = r->last_chunk = ggc_alloc_cleared (sizeof (*r->tokens));
return r;
}
/* Accumulate the tokens that make up a parenthesized expression in T,
having already read the opening parenthesis. */
static void
snarf_parenthesized_expression (struct unparsed_text *t)
{
int yyc;
int level = 1;
while (1)
{
yyc = next_token (space_for_token (t));
if (yyc == '(')
++level;
else if (yyc == ')' && --level == 0)
break;
else if (yyc == 0)
{
error ("%Hend of file read inside definition", &t->locus);
break;
}
}
}
/* Subroutine of snarf_method, deals with actual absorption of the block. */
static void
snarf_block (t)
struct unparsed_text *t;
{
int blev = 1;
int look_for_semicolon = 0;
int look_for_lbrac = 0;
int look_for_catch = 0;
int yyc;
struct token *current;
if (yychar == '{')
;
else if (yychar == '=')
look_for_semicolon = 1;
else if (yychar == ':' || yychar == RETURN_KEYWORD || yychar == TRY)
{
if (yychar == TRY)
look_for_catch = 1;
look_for_lbrac = 1;
blev = 0;
}
else
yyerror ("parse error in method specification");
/* The current token is the first one to be recorded. */
current = space_for_token (t);
current->yychar = yychar;
current->yylval = yylval;
current->lineno = lineno;
for (;;)
{
yyc = next_token (space_for_token (t));
if (yyc == '{')
{
look_for_lbrac = 0;
blev++;
}
else if (yyc == '}')
{
blev--;
if (blev == 0 && !look_for_semicolon)
{
if (!look_for_catch)
break;
if (next_token (space_for_token (t)) != CATCH)
{
push_token (remove_last_token (t));
break;
}
look_for_lbrac = 1;
}
}
else if (yyc == ';')
{
if (look_for_lbrac)
{
struct token *fake;
error ("function body for constructor missing");
/* fake a { } to avoid further errors */
fake = space_for_token (t);
fake->yylval.ttype = 0;
fake->yychar = '{';
fake = space_for_token (t);
fake->yylval.ttype = 0;
fake->yychar = '}';
break;
}
else if (look_for_semicolon && blev == 0)
break;
}
else if (yyc == '(' && blev == 0)
snarf_parenthesized_expression (t);
else if (yyc == 0)
{
error ("%Hend of file read inside definition", &t->locus);
break;
}
}
}
/* This function stores away the text for an inline function that should
be processed later (by do_pending_inlines). */
void
snarf_method (decl)
tree decl;
{
struct unparsed_text *meth;
location_t starting;
starting.file = input_filename;
starting.line = lineno;
meth = alloc_unparsed_text (&starting, decl, (interface_unknown ? 1
: (interface_only ? 0 : 2)));
snarf_block (meth);
/* Add three END_OF_SAVED_INPUT tokens. We used to provide an
infinite stream of END_OF_SAVED_INPUT tokens -- but that can
cause the compiler to get stuck in an infinite loop when
encountering invalid code. We need more than one because the
parser sometimes peeks ahead several tokens. */
memcpy (space_for_token (meth), &Teosi, sizeof (struct token));
memcpy (space_for_token (meth), &Teosi, sizeof (struct token));
memcpy (space_for_token (meth), &Teosi, sizeof (struct token));
/* Happens when we get two declarations of the same function in the
same scope. */
if (decl == void_type_node
|| (current_class_type && TYPE_REDEFINED (current_class_type)))
return;
#ifdef SPEW_DEBUG
if (spew_debug)
fprintf (stderr, "\tsaved method of %d tokens from %s:%d\n",
meth->last_pos, starting.file, starting.line);
#endif
DECL_PENDING_INLINE_INFO (decl) = meth;
DECL_PENDING_INLINE_P (decl) = 1;
if (pending_inlines_tail)
pending_inlines_tail->next = meth;
else
pending_inlines = meth;
pending_inlines_tail = meth;
}
/* Consume a no-commas expression - a default argument - and return
a DEFAULT_ARG tree node. */
static tree
snarf_defarg ()
{
int yyc;
int plev = 0;
struct unparsed_text *buf;
tree arg;
location_t starting;
starting.file = input_filename;
starting.line = lineno;
buf = alloc_unparsed_text (&starting, 0, 0);
for (;;)
{
yyc = next_token (space_for_token (buf));
if (plev <= 0 && (yyc == ')' || yyc == ','))
break;
else if (yyc == '(' || yyc == '[')
++plev;
else if (yyc == ']' || yyc == ')')
--plev;
else if (yyc == 0)
{
error ("%Hend of file read inside default argument", &starting);
goto done;
}
}
/* Unget the last token. */
push_token (remove_last_token (buf));
/* Add three END_OF_SAVED_INPUT tokens. We used to provide an
infinite stream of END_OF_SAVED_INPUT tokens -- but that can
cause the compiler to get stuck in an infinite loop when
encountering invalid code. We need more than one because the
parser sometimes peeks ahead several tokens. */
memcpy (space_for_token (buf), &Teosi, sizeof (struct token));
memcpy (space_for_token (buf), &Teosi, sizeof (struct token));
memcpy (space_for_token (buf), &Teosi, sizeof (struct token));
done:
#ifdef SPEW_DEBUG
if (spew_debug)
fprintf (stderr, "\tsaved defarg of %d tokens from %s:%d\n",
buf->last_pos, starting.file, starting.line);
#endif
arg = make_node (DEFAULT_ARG);
DEFARG_POINTER (arg) = (char *)buf;
return arg;
}
/* Decide whether the default argument we are about to see should be
gobbled up as text for later parsing. */
void
maybe_snarf_defarg ()
{
if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
do_snarf_defarg = 1;
}
/* Called from grokfndecl to note a function decl with unparsed default
arguments for later processing. Also called from grokdeclarator
for function types with unparsed defargs; the call from grokfndecl
will always come second, so we can overwrite the entry from the type. */
void
add_defarg_fn (decl)
tree decl;
{
if (TREE_CODE (decl) == FUNCTION_DECL)
TREE_VALUE (defarg_fns) = decl;
else
{
defarg_fns = tree_cons (NULL_TREE, decl, defarg_fns);
TREE_TYPE (defarg_fns) = current_class_type;
}
}
/* Helper for do_pending_defargs. Starts the parsing of a default arg. */
static void
feed_defarg (p)
tree p;
{
tree d = TREE_PURPOSE (p);
feed_input ((struct unparsed_text *)DEFARG_POINTER (d));
yychar = DEFARG_MARKER;
yylval.ttype = p;
}
/* Helper for do_pending_defargs. Ends the parsing of a default arg. */
static void
finish_defarg ()
{
if (yychar == YYEMPTY)
yychar = yylex ();
if (yychar != END_OF_SAVED_INPUT)
error ("parse error at end of saved function text");
end_input ();
}
/* Main function for deferred parsing of default arguments. Called from
the parser. */
void
do_pending_defargs ()
{
if (defarg_parm)
finish_defarg ();
for (; defarg_fns;)
{
tree current = defarg_fns;
tree defarg_fn = TREE_VALUE (defarg_fns);
if (defarg_parm == NULL_TREE)
{
push_nested_class (TREE_TYPE (defarg_fns), 1);
pushlevel (0);
if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
maybe_begin_member_template_processing (defarg_fn);
if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
defarg_parm = TYPE_ARG_TYPES (TREE_TYPE (defarg_fn));
else
defarg_parm = TYPE_ARG_TYPES (defarg_fn);
}
else
defarg_parm = TREE_CHAIN (defarg_parm);
for (; defarg_parm; defarg_parm = TREE_CHAIN (defarg_parm))
if (!TREE_PURPOSE (defarg_parm)
|| TREE_CODE (TREE_PURPOSE (defarg_parm)) != DEFAULT_ARG)
;/* OK */
else if (TREE_PURPOSE (current) == error_mark_node)
DEFARG_POINTER (TREE_PURPOSE (defarg_parm)) = NULL;
else
{
feed_defarg (defarg_parm);
/* Return to the parser, which will process this defarg
and call us again. */
return;
}
if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
{
maybe_end_member_template_processing ();
check_default_args (defarg_fn);
}
poplevel (0, 0, 0);
pop_nested_class ();
defarg_fns = TREE_CHAIN (defarg_fns);
if (defarg_depfns)
{
/* This function's default args depend on unprocessed default args
of defarg_fns. We will need to reprocess this function, and
check for circular dependencies. */
tree a, b;
for (a = defarg_depfns, b = TREE_PURPOSE (current); a && b;
a = TREE_CHAIN (a), b = TREE_CHAIN (b))
if (TREE_VALUE (a) != TREE_VALUE (b))
goto different;
if (a || b)
{
different:;
TREE_CHAIN (current) = NULL_TREE;
defarg_fns = chainon (defarg_fns, current);
TREE_PURPOSE (current) = defarg_depfns;
}
else
{
cp_warning_at ("circular dependency in default args of `%#D'", defarg_fn);
/* No need to say what else is dependent, as they will be
picked up in another pass. */
/* Immediately repeat, but marked so that we break the loop. */
defarg_fns = current;
TREE_PURPOSE (current) = error_mark_node;
}
defarg_depfns = NULL_TREE;
}
else if (TREE_PURPOSE (current) == error_mark_node)
defarg_fnsdone = tree_cons (NULL_TREE, defarg_fn, defarg_fnsdone);
}
}
/* After parsing all the default arguments, we must clear any that remain,
which will be part of a circular dependency. */
void
done_pending_defargs ()
{
for (; defarg_fnsdone; defarg_fnsdone = TREE_CHAIN (defarg_fnsdone))
{
tree fn = TREE_VALUE (defarg_fnsdone);
tree parms;
if (TREE_CODE (fn) == FUNCTION_DECL)
parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
else
parms = TYPE_ARG_TYPES (fn);
for (; parms; parms = TREE_CHAIN (parms))
if (TREE_PURPOSE (parms)
&& TREE_CODE (TREE_PURPOSE (parms)) == DEFAULT_ARG)
{
my_friendly_assert (!DEFARG_POINTER (TREE_PURPOSE (parms)), 20010107);
TREE_PURPOSE (parms) = NULL_TREE;
}
}
}
/* In processing the current default arg, we called FN, but that call
required a default argument of FN, and that had not yet been processed.
Remember FN. */
void
unprocessed_defarg_fn (fn)
tree fn;
{
defarg_depfns = tree_cons (NULL_TREE, fn, defarg_depfns);
}
/* Called from the parser to update an element of TYPE_ARG_TYPES for some
FUNCTION_TYPE with the newly parsed version of its default argument, which
was previously digested as text. */
void
replace_defarg (arg, init)
tree arg, init;
{
if (init == error_mark_node)
TREE_PURPOSE (arg) = error_mark_node;
else
{
if (! processing_template_decl
&& ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
pedwarn ("invalid type `%T' for default argument to `%T'",
TREE_TYPE (init), TREE_VALUE (arg));
if (!defarg_depfns)
TREE_PURPOSE (arg) = init;
}
}
#ifdef SPEW_DEBUG
/* debug_yychar takes a yychar (token number) value and prints its name. */
static void
debug_yychar (yy)
int yy;
{
if (yy<256)
fprintf (stderr, "->%d < %c >\n", lineno, yy);
else if (yy == IDENTIFIER || yy == tTYPENAME)
{
const char *id;
if (TREE_CODE (yylval.ttype) == IDENTIFIER_NODE)
id = IDENTIFIER_POINTER (yylval.ttype);
else if (TREE_CODE_CLASS (TREE_CODE (yylval.ttype)) == 'd')
id = IDENTIFIER_POINTER (DECL_NAME (yylval.ttype));
else
id = "";
fprintf (stderr, "->%d <%s `%s'>\n", lineno, debug_yytranslate (yy), id);
}
else
fprintf (stderr, "->%d <%s>\n", lineno, debug_yytranslate (yy));
}
#endif
#define NAME(TYPE) cpp_type2name (TYPE)
void
yyerror (msgid)
const char *msgid;
{
const char *string = _(msgid);
if (last_token == CPP_EOF)
error ("%s at end of input", string);
else if (last_token == CPP_CHAR || last_token == CPP_WCHAR)
{
unsigned int val = TREE_INT_CST_LOW (yylval.ttype);
const char *const ell = (last_token == CPP_CHAR) ? "" : "L";
if (val <= UCHAR_MAX && ISGRAPH (val))
error ("%s before %s'%c'", string, ell, val);
else
error ("%s before %s'\\x%x'", string, ell, val);
}
else if (last_token == CPP_STRING
|| last_token == CPP_WSTRING)
error ("%s before string constant", string);
else if (last_token == CPP_NUMBER)
error ("%s before numeric constant", string);
else if (last_token == CPP_NAME)
{
if (TREE_CODE (last_token_id) == IDENTIFIER_NODE)
error ("%s before `%s'", string, IDENTIFIER_POINTER (last_token_id));
else if (ISGRAPH (yychar))
error ("%s before `%c'", string, yychar);
else
error ("%s before `\%o'", string, yychar);
}
else
error ("%s before `%s' token", string, NAME (last_token));
}
#include "gt-cp-spew.h"
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment