From afd9b9dd9d8dded871213080f545548e193acfc1 Mon Sep 17 00:00:00 2001 From: Mark Mitchell Date: Mon, 30 Dec 2002 19:02:11 +0000 Subject: [PATCH] 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 --- gcc/cp/ChangeLog | 26 + gcc/cp/Make-lang.in | 2 +- gcc/cp/cp-tree.h | 4 +- gcc/cp/decl.c | 5 +- gcc/cp/decl2.c | 6 +- gcc/cp/lex.c | 146 +- gcc/cp/lex.h | 16 - gcc/cp/parse.y | 4220 ------------------------------------------- gcc/cp/semantics.c | 14 - gcc/cp/spew.c | 1551 ---------------- 10 files changed, 35 insertions(+), 5955 deletions(-) delete mode 100644 gcc/cp/parse.y delete mode 100644 gcc/cp/spew.c diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index ccc942e32f7..050ba952a51 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -10,6 +10,32 @@ 2002-12-30 Mark Mitchell + * 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 thread" correctly. diff --git a/gcc/cp/Make-lang.in b/gcc/cp/Make-lang.in index 5da73d33f8d..7361a2d5a27 100644 --- a/gcc/cp/Make-lang.in +++ b/gcc/cp/Make-lang.in @@ -102,7 +102,7 @@ $(srcdir)/cp/cfns.h: $(srcdir)/cp/cfns.gperf $(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 -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 # diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 6296731a080..bdc09a6a9f9 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -3974,10 +3974,9 @@ extern void snarf_method PARAMS ((tree)); extern void note_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 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 identifier_typedecl_value PARAMS ((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)); extern tree finish_qualified_object_call_expr PARAMS ((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_id_expr PARAMS ((tree)); extern tree finish_compound_literal (tree, tree); extern tree finish_fname (tree); extern void save_type_access_control PARAMS ((tree)); diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 7b29820d120..141373e972e 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -6081,7 +6081,6 @@ lookup_name_real (tree name, { tree t; tree val = NULL_TREE; - int yylex = 0; int val_is_implicit_typename = 0; /* Conversion operators are handled specially because ordinary @@ -6144,7 +6143,7 @@ lookup_name_real (tree name, if (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); val = binding; val_is_implicit_typename @@ -6160,7 +6159,7 @@ lookup_name_real (tree name, t = unqualified_namespace_lookup (name, flags, 0); if (t) { - if (val_is_implicit_typename && !yylex) + if (val_is_implicit_typename) warn_about_implicit_typename_lookup (val, t); val = t; } diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index f1e5e5efe04..6efb9bdd46b 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -2940,7 +2940,7 @@ build_expr_from_tree (t) switch (TREE_CODE (t)) { case IDENTIFIER_NODE: - return do_identifier (t, 0, NULL_TREE); + return do_identifier (t, NULL_TREE); case LOOKUP_EXPR: if (LOOKUP_EXPR_GLOBAL (t)) @@ -2950,7 +2950,7 @@ build_expr_from_tree (t) } 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) t = DECL_INITIAL (t); return t; @@ -3186,7 +3186,7 @@ build_expr_from_tree (t) || !lookup_member (current_class_type, id, 0, 0))) { /* 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 || ! really_overloaded_fn (name)) diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c index 92d0aa63848..57115b7260a 100644 --- a/gcc/cp/lex.c +++ b/gcc/cp/lex.c @@ -47,7 +47,6 @@ Boston, MA 02111-1307, USA. */ #endif static int interface_strcmp PARAMS ((const char *)); -static int *init_cpp_parse PARAMS ((void)); static void init_cp_pragma PARAMS ((void)); static tree parse_strconst_pragma PARAMS ((const char *, int)); @@ -57,12 +56,6 @@ static void handle_pragma_interface PARAMS ((cpp_reader *)); static void handle_pragma_implementation 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 void init_operators PARAMS ((void)); static void copy_lang_type PARAMS ((tree)); @@ -76,18 +69,6 @@ static void copy_lang_type PARAMS ((tree)); #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. `#pragma implementation' means that the main file being compiled @@ -202,20 +183,6 @@ cxx_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. */ operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE]; /* Similar, but for assignment operators. */ @@ -492,7 +459,6 @@ cxx_init (filename) TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0); ridpointers[RID_NULL] = null_node; - token_count = init_cpp_parse (); interface_unknown = 1; filename = c_common_init (filename); @@ -506,92 +472,6 @@ cxx_init (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 information. */ @@ -819,15 +699,6 @@ handle_pragma_java_exceptions (dfile) 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. */ static int @@ -884,21 +755,13 @@ unqualified_name_lookup_error (tree name) } tree -do_identifier (token, parsing, args) +do_identifier (token, args) register tree token; - int parsing; tree args; { register tree id; - int lexing = (parsing == 1 || parsing == 3); - if (! lexing) - id = lookup_name (token, 0); - else - id = lastiddecl; - - if (lexing && id && TREE_DEPRECATED (id)) - warn_deprecated_use (id); + id = lookup_name (token, 0); /* Do Koenig lookup if appropriate (inside templates we build lookup expressions instead). @@ -910,11 +773,6 @@ do_identifier (token, parsing, args) if (args && !current_template_parms && (!id || is_global (id))) 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) { /* lookup_name quietly returns error_mark_node if we're parsing, diff --git a/gcc/cp/lex.h b/gcc/cp/lex.h index ecd5861f686..5a08fd9a052 100644 --- a/gcc/cp/lex.h +++ b/gcc/cp/lex.h @@ -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) #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 */ diff --git a/gcc/cp/parse.y b/gcc/cp/parse.y deleted file mode 100644 index d1f9f4d68b4..00000000000 --- a/gcc/cp/parse.y +++ /dev/null @@ -1,4220 +0,0 @@ -/* YACC parser for C++ syntax. - Copyright (C) 1988, 1989, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002 Free Software Foundation, Inc. - Hacked by Michael Tiemann (tiemann@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 grammar is based on the GNU CC grammar. */ - -/* Note: Bison automatically applies a default action of "$$ = $1" for - all derivations; this is applied before the explicit action, if one - is given. Keep this in mind when reading the actions. */ - -%{ -#include "config.h" - -#include "system.h" -#include "coretypes.h" -#include "tm.h" - -#include "tree.h" -#include "input.h" -#include "flags.h" -#include "cp-tree.h" -#include "decl.h" -#include "lex.h" -#include "c-pragma.h" /* For YYDEBUG definition. */ -#include "output.h" -#include "except.h" -#include "toplev.h" -#include "ggc.h" - -/* Like YYERROR but do call yyerror. */ -#define YYERROR1 { yyerror ("syntax error"); YYERROR; } - -/* Like the default stack expander, except (1) use realloc when possible, - (2) impose no hard maxiumum on stack size, (3) REALLY do not use alloca. - - Irritatingly, YYSTYPE is defined after this %{ %} block, so we cannot - give malloced_yyvs its proper type. This is ok since all we need from - it is to be able to free it. */ - -static short *malloced_yyss; -static void *malloced_yyvs; - -#define yyoverflow(MSG, SS, SSSIZE, VS, VSSIZE, YYSSZ) \ -do { \ - size_t newsize; \ - short *newss; \ - YYSTYPE *newvs; \ - newsize = *(YYSSZ) *= 2; \ - if (malloced_yyss) \ - { \ - newss = (short *) \ - really_call_realloc (*(SS), newsize * sizeof (short)); \ - newvs = (YYSTYPE *) \ - really_call_realloc (*(VS), newsize * sizeof (YYSTYPE)); \ - } \ - else \ - { \ - newss = (short *) really_call_malloc (newsize * sizeof (short)); \ - newvs = (YYSTYPE *) really_call_malloc (newsize * sizeof (YYSTYPE)); \ - if (newss) \ - memcpy (newss, *(SS), (SSSIZE)); \ - if (newvs) \ - memcpy (newvs, *(VS), (VSSIZE)); \ - } \ - if (!newss || !newvs) \ - { \ - yyerror (MSG); \ - return 2; \ - } \ - *(SS) = newss; \ - *(VS) = newvs; \ - malloced_yyss = newss; \ - malloced_yyvs = (void *) newvs; \ -} while (0) -#define OP0(NODE) (TREE_OPERAND (NODE, 0)) -#define OP1(NODE) (TREE_OPERAND (NODE, 1)) - -/* Contains the statement keyword (if/while/do) to include in an - error message if the user supplies an empty conditional expression. */ -static const char *cond_stmt_keyword; - -/* List of types and structure classes of the current declaration. */ -static GTY(()) tree current_declspecs; - -/* List of prefix attributes in effect. - Prefix attributes are parsed by the reserved_declspecs and declmods - rules. They create a list that contains *both* declspecs and attrs. */ -/* ??? It is not clear yet that all cases where an attribute can now appear in - a declspec list have been updated. */ -static GTY(()) tree prefix_attributes; - -/* When defining an enumeration, this is the type of the enumeration. */ -static GTY(()) tree current_enum_type; - -/* When parsing a conversion operator name, this is the scope of the - operator itself. */ -static GTY(()) tree saved_scopes; - -static tree empty_parms PARAMS ((void)); -static tree parse_decl0 PARAMS ((tree, tree, tree, tree, int)); -static tree parse_decl PARAMS ((tree, tree, int)); -static void parse_end_decl PARAMS ((tree, tree, tree)); -static tree parse_field0 PARAMS ((tree, tree, tree, tree, tree, tree)); -static tree parse_field PARAMS ((tree, tree, tree, tree)); -static tree parse_bitfield0 PARAMS ((tree, tree, tree, tree, tree)); -static tree parse_bitfield PARAMS ((tree, tree, tree)); -static tree parse_method PARAMS ((tree, tree, tree)); -static void frob_specs PARAMS ((tree, tree)); -static void check_class_key PARAMS ((tree, tree)); -static tree parse_scoped_id PARAMS ((tree)); -static tree parse_xref_tag (tree, tree, int); -static tree parse_handle_class_head (tree, tree, tree, int, int *); -static void parse_decl_instantiation (tree, tree, tree); -static int parse_begin_function_definition (tree, tree); -static tree parse_finish_call_expr (tree, tree, int); - -/* Cons up an empty parameter list. */ -static inline tree -empty_parms () -{ - tree parms; - -#ifndef NO_IMPLICIT_EXTERN_C - if (in_system_header && current_class_type == NULL - && current_lang_name == lang_name_c) - parms = NULL_TREE; - else -#endif - parms = void_list_node; - return parms; -} - -/* Record the decl-specifiers, attributes and type lookups from the - decl-specifier-seq in a declaration. */ - -static void -frob_specs (specs_attrs, lookups) - tree specs_attrs, lookups; -{ - save_type_access_control (lookups); - split_specs_attrs (specs_attrs, ¤t_declspecs, &prefix_attributes); - if (current_declspecs - && TREE_CODE (current_declspecs) != TREE_LIST) - current_declspecs = build_tree_list (NULL_TREE, current_declspecs); - if (have_extern_spec) - { - /* We have to indicate that there is an "extern", but that it - was part of a language specifier. For instance, - - extern "C" typedef int (*Ptr) (); - - is well formed. */ - current_declspecs = tree_cons (error_mark_node, - get_identifier ("extern"), - current_declspecs); - have_extern_spec = false; - } -} - -static tree -parse_decl (declarator, attributes, initialized) - tree declarator, attributes; - int initialized; -{ - return start_decl (declarator, current_declspecs, initialized, - attributes, prefix_attributes); -} - -static tree -parse_decl0 (declarator, specs_attrs, lookups, attributes, initialized) - tree declarator, specs_attrs, lookups, attributes; - int initialized; -{ - frob_specs (specs_attrs, lookups); - return parse_decl (declarator, attributes, initialized); -} - -static void -parse_end_decl (decl, init, asmspec) - tree decl, init, asmspec; -{ - /* If decl is NULL_TREE, then this was a variable declaration using - () syntax for the initializer, so we handled it in grokdeclarator. */ - if (decl) - decl_type_access_control (decl); - cp_finish_decl (decl, init, asmspec, init ? LOOKUP_ONLYCONVERTING : 0); -} - -static tree -parse_field (declarator, attributes, asmspec, init) - tree declarator, attributes, asmspec, init; -{ - tree d = grokfield (declarator, current_declspecs, init, asmspec, - chainon (attributes, prefix_attributes)); - decl_type_access_control (d); - return d; -} - -static tree -parse_field0 (declarator, specs_attrs, lookups, attributes, asmspec, init) - tree declarator, specs_attrs, lookups, attributes, asmspec, init; -{ - frob_specs (specs_attrs, lookups); - return parse_field (declarator, attributes, asmspec, init); -} - -static tree -parse_bitfield (declarator, attributes, width) - tree declarator, attributes, width; -{ - tree d = grokbitfield (declarator, current_declspecs, width); - cplus_decl_attributes (&d, chainon (attributes, prefix_attributes), 0); - decl_type_access_control (d); - return d; -} - -static tree -parse_bitfield0 (declarator, specs_attrs, lookups, attributes, width) - tree declarator, specs_attrs, lookups, attributes, width; -{ - frob_specs (specs_attrs, lookups); - return parse_bitfield (declarator, attributes, width); -} - -static tree -parse_method (declarator, specs_attrs, lookups) - tree declarator, specs_attrs, lookups; -{ - tree d; - frob_specs (specs_attrs, lookups); - d = start_method (current_declspecs, declarator, prefix_attributes); - decl_type_access_control (d); - return d; -} - -static void -check_class_key (key, aggr) - tree key; - tree aggr; -{ - if (TREE_CODE (key) == TREE_LIST) - key = TREE_VALUE (key); - if ((key == union_type_node) != (TREE_CODE (aggr) == UNION_TYPE)) - pedwarn ("`%s' tag used in naming `%#T'", - key == union_type_node ? "union" - : key == record_type_node ? "struct" : "class", aggr); -} - -%} - -%start program - -%union { GTY(()) - long itype; - tree ttype; - char *strtype; - enum tree_code code; - flagged_type_tree ftype; - struct unparsed_text *pi; -} - -/* All identifiers that are not reserved words - and are not declared typedefs in the current block */ -%token IDENTIFIER - -/* All identifiers that are declared typedefs in the current block. - In some contexts, they are treated just like IDENTIFIER, - but they can also serve as typespecs in declarations. */ -%token tTYPENAME -%token SELFNAME - -/* A template function. */ -%token PFUNCNAME - -/* Reserved words that specify storage class. - yylval contains an IDENTIFIER_NODE which indicates which one. */ -%token SCSPEC - -/* Reserved words that specify type. - yylval contains an IDENTIFIER_NODE which indicates which one. */ -%token TYPESPEC - -/* Reserved words that qualify type: "const" or "volatile". - yylval contains an IDENTIFIER_NODE which indicates which one. */ -%token CV_QUALIFIER - -/* Character or numeric constants. - yylval is the node for the constant. */ -%token CONSTANT - -/* __func__, __FUNCTION__ or __PRETTY_FUNCTION__. - yylval contains an IDENTIFIER_NODE which indicates which one. */ -%token VAR_FUNC_NAME - -/* String constants in raw form. - yylval is a STRING_CST node. */ -%token STRING - -/* "...", used for functions with variable arglists. */ -%token ELLIPSIS - -/* the reserved words */ -/* SCO include files test "ASM", so use something else. */ -%token SIZEOF ENUM /* STRUCT UNION */ IF ELSE WHILE DO FOR SWITCH CASE DEFAULT -%token BREAK CONTINUE RETURN_KEYWORD GOTO ASM_KEYWORD TYPEOF ALIGNOF -%token SIGOF -%token ATTRIBUTE EXTENSION LABEL -%token REALPART IMAGPART VA_ARG - -/* the reserved words... C++ extensions */ -%token AGGR -%token VISSPEC -%token DELETE NEW THIS OPERATOR CXX_TRUE CXX_FALSE -%token NAMESPACE TYPENAME_KEYWORD USING -%token LEFT_RIGHT TEMPLATE -%token TYPEID DYNAMIC_CAST STATIC_CAST REINTERPRET_CAST CONST_CAST -%token SCOPE EXPORT - -/* Define the operator tokens and their precedences. - The value is an integer because, if used, it is the tree code - to use in the expression made from the operator. */ - -%left EMPTY /* used to resolve s/r with epsilon */ - -%left error - -/* Add precedence rules to solve dangling else s/r conflict */ -%nonassoc IF -%nonassoc ELSE - -%left IDENTIFIER PFUNCNAME tTYPENAME SELFNAME PTYPENAME SCSPEC TYPESPEC CV_QUALIFIER ENUM AGGR ELLIPSIS TYPEOF SIGOF OPERATOR NSNAME TYPENAME_KEYWORD ATTRIBUTE - -%left '{' ',' ';' - -%nonassoc THROW -%right ':' -%right ASSIGN '=' -%right '?' -%left OROR -%left ANDAND -%left '|' -%left '^' -%left '&' -%left MIN_MAX -%left EQCOMPARE -%left ARITHCOMPARE '<' '>' -%left LSHIFT RSHIFT -%left '+' '-' -%left '*' '/' '%' -%left POINTSAT_STAR DOT_STAR -%right UNARY PLUSPLUS MINUSMINUS '~' -%left HYPERUNARY -%left LEFT_RIGHT -%left POINTSAT '.' '(' '[' - -%right SCOPE /* C++ extension */ -%nonassoc NEW DELETE TRY CATCH - -%type unop - -%type identifier IDENTIFIER tTYPENAME CONSTANT expr nonnull_exprlist -%type PFUNCNAME maybe_identifier -%type paren_expr_or_null nontrivial_exprlist SELFNAME -%type expr_no_commas expr_no_comma_rangle -%type cast_expr unary_expr primary STRING -%type reserved_declspecs boolean_literal -%type reserved_typespecquals -%type SCSPEC TYPESPEC CV_QUALIFIER maybe_cv_qualifier -%type init initlist maybeasm maybe_init defarg defarg1 -%type asm_operands nonnull_asm_operands asm_operand asm_clobbers -%type maybe_attribute attributes attribute attribute_list attrib -%type any_word unoperator - -%type save_lineno -%type simple_stmt simple_if - -%type declarator notype_declarator after_type_declarator -%type notype_declarator_intern absdcl_intern -%type after_type_declarator_intern -%type direct_notype_declarator direct_after_type_declarator -%type components notype_components -%type component_decl component_decl_1 -%type component_declarator component_declarator0 -%type notype_component_declarator notype_component_declarator0 -%type after_type_component_declarator after_type_component_declarator0 -%type absdcl cv_qualifiers -%type direct_abstract_declarator conversion_declarator -%type new_declarator direct_new_declarator -%type xexpr parmlist parms bad_parm -%type identifiers_or_typenames -%type fcast_or_absdcl regcast_or_absdcl -%type expr_or_declarator expr_or_declarator_intern -%type complex_notype_declarator -%type notype_unqualified_id unqualified_id qualified_id -%type template_id do_id object_template_id notype_template_declarator -%type overqualified_id notype_qualified_id any_id -%type complex_direct_notype_declarator functional_cast -%type complex_parmlist parms_comma -%type namespace_qualifier namespace_using_decl - -%type type_id new_type_id typed_typespecs typespec typed_declspecs -%type typed_declspecs1 type_specifier_seq nonempty_cv_qualifiers -%type structsp typespecqual_reserved parm named_parm full_parm -%type declmods - -%type extension - -/* C++ extensions */ -%token PTYPENAME -%token EXTERN_LANG_STRING ALL -%token PRE_PARSED_CLASS_DECL DEFARG DEFARG_MARKER -%token PRE_PARSED_FUNCTION_DECL -%type component_constructor_declarator -%type fn_def2 return_id constructor_declarator -%type begin_function_body_ -%type class_head class_head_apparent_template -%type class_head_decl class_head_defn -%type base_class_list -%type base_class_access_list -%type base_class maybe_base_class_list base_class_1 -%type exception_specification_opt ansi_raise_identifier ansi_raise_identifiers -%type operator_name -%type object aggr -%type new delete -/* %type primary_no_id */ -%type maybe_parmlist -%type member_init -%type member_init_list -%type template_parm_header template_spec_header template_header -%type template_parm_list template_parm -%type template_type_parm template_template_parm -%type template_close_bracket -%type apparent_template_type -%type template_type template_arg_list template_arg_list_opt -%type template_arg -%type condition xcond paren_cond_or_null -%type type_name nested_name_specifier nested_type ptr_to_mem -%type complete_type_name notype_identifier nonnested_type -%type complex_type_name nested_name_specifier_1 -%type new_initializer new_placement -%type using_decl -%type typename_sub typename_sub0 typename_sub1 typename_sub2 -%type explicit_template_type -/* in order to recognize aggr tags as defining and thus shadowing. */ -%token TYPENAME_DEFN IDENTIFIER_DEFN PTYPENAME_DEFN -%type identifier_defn IDENTIFIER_DEFN TYPENAME_DEFN PTYPENAME_DEFN -%type handler_args -%type self_template_type finish_template_type_ - -%token NSNAME -%type NSNAME - -/* Used in lex.c for parsing pragmas. */ -%token END_OF_LINE - -/* lex.c and pt.c depend on this being the last token. Define - any new tokens before this one! */ -%token END_OF_SAVED_INPUT - -%{ -/* Tell yyparse how to print a token's value, if yydebug is set. */ -#define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL) -extern void yyprint PARAMS ((FILE *, int, YYSTYPE)); -%} - -%% -program: - /* empty */ - { finish_translation_unit (); } - | extdefs - { finish_translation_unit (); } - ; - -/* the reason for the strange actions in this rule - is so that notype_initdecls when reached via datadef - can find a valid list of type and sc specs in $0. */ - -extdefs: - { $$ = NULL_TREE; } - lang_extdef - { $$ = NULL_TREE; ggc_collect (); } - | extdefs lang_extdef - { $$ = NULL_TREE; ggc_collect (); } - ; - -extdefs_opt: - extdefs - | /* empty */ - ; - -.hush_warning: - { have_extern_spec = true; - $$ = NULL_TREE; } - ; -.warning_ok: - { have_extern_spec = false; } - ; - -extension: - EXTENSION - { $$ = pedantic; - pedantic = 0; } - ; - -asm_keyword: - ASM_KEYWORD - ; - -lang_extdef: - { if (pending_lang_change) do_pending_lang_change(); - type_lookups = NULL_TREE; } - extdef - { if (! toplevel_bindings_p ()) - pop_everything (); } - ; - -extdef: - fndef eat_saved_input - { do_pending_inlines (); } - | datadef - { do_pending_inlines (); } - - | EXPORT - { warning ("keyword `export' not implemented, and will be ignored"); } - template_def - { do_pending_inlines (); } - | template_def - { do_pending_inlines (); } - | asm_keyword '(' STRING ')' ';' - { assemble_asm ($3); } - | extern_lang_string '{' extdefs_opt '}' - { pop_lang_context (); } - | extern_lang_string .hush_warning fndef .warning_ok eat_saved_input - { do_pending_inlines (); pop_lang_context (); } - | extern_lang_string .hush_warning datadef .warning_ok - { do_pending_inlines (); pop_lang_context (); } - | NAMESPACE identifier '{' - { push_namespace ($2); } - extdefs_opt '}' - { pop_namespace (); } - | NAMESPACE '{' - { push_namespace (NULL_TREE); } - extdefs_opt '}' - { pop_namespace (); } - | namespace_alias - | using_decl ';' - { do_toplevel_using_decl ($1); } - | using_directive - | extension extdef - { pedantic = $1; } - ; - -namespace_alias: - NAMESPACE identifier '=' - { begin_only_namespace_names (); } - any_id ';' - { - end_only_namespace_names (); - if (lastiddecl) - $5 = lastiddecl; - do_namespace_alias ($2, $5); - } - ; - -using_decl: - USING qualified_id - { $$ = $2; } - | USING global_scope qualified_id - { $$ = $3; } - | USING global_scope unqualified_id - { $$ = $3; } - ; - -namespace_using_decl: - USING namespace_qualifier identifier - { $$ = build_nt (SCOPE_REF, $2, $3); } - | USING global_scope identifier - { $$ = build_nt (SCOPE_REF, global_namespace, $3); } - | USING global_scope namespace_qualifier identifier - { $$ = build_nt (SCOPE_REF, $3, $4); } - ; - -using_directive: - USING NAMESPACE - { begin_only_namespace_names (); } - any_id ';' - { - end_only_namespace_names (); - /* If no declaration was found, the using-directive is - invalid. Since that was not reported, we need the - identifier for the error message. */ - if (TREE_CODE ($4) == IDENTIFIER_NODE && lastiddecl) - $4 = lastiddecl; - do_using_directive ($4); - } - ; - -namespace_qualifier: - NSNAME SCOPE - { - if (TREE_CODE ($$) == IDENTIFIER_NODE) - $$ = lastiddecl; - got_scope = $$; - } - | namespace_qualifier NSNAME SCOPE - { - $$ = $2; - if (TREE_CODE ($$) == IDENTIFIER_NODE) - $$ = lastiddecl; - got_scope = $$; - } - ; - -any_id: - unqualified_id - | qualified_id - | global_scope qualified_id - { $$ = $2; } - | global_scope unqualified_id - { $$ = $2; } - ; - -extern_lang_string: - EXTERN_LANG_STRING - { push_lang_context ($1); } - | extern_lang_string EXTERN_LANG_STRING - { if (current_lang_name != $2) - error ("use of linkage spec `%D' is different from previous spec `%D'", $2, current_lang_name); - pop_lang_context (); push_lang_context ($2); } - ; - -template_parm_header: - TEMPLATE '<' - { begin_template_parm_list (); } - template_parm_list '>' - { $$ = end_template_parm_list ($4); } - ; - -template_spec_header: - TEMPLATE '<' '>' - { begin_specialization(); - $$ = NULL_TREE; } - ; - -template_header: - template_parm_header - | template_spec_header - ; - -template_parm_list: - template_parm - { $$ = process_template_parm (NULL_TREE, $1); } - | template_parm_list ',' template_parm - { $$ = process_template_parm ($1, $3); } - ; - -maybe_identifier: - identifier - { $$ = $1; } - | /* empty */ - { $$ = NULL_TREE; } - ; - -template_type_parm: - aggr maybe_identifier - { $$ = finish_template_type_parm ($1, $2); } - | TYPENAME_KEYWORD maybe_identifier - { $$ = finish_template_type_parm (class_type_node, $2); } - ; - -template_template_parm: - template_parm_header aggr maybe_identifier - { $$ = finish_template_template_parm ($2, $3); } - ; - -template_parm: - /* The following rules introduce a new reduce/reduce - conflict on the ',' and '>' input tokens: they are valid - prefixes for a `structsp', which means they could match a - nameless parameter. See 14.6, paragraph 3. - By putting them before the `parm' rule, we get - their match before considering them nameless parameter - declarations. */ - template_type_parm - { $$ = build_tree_list (NULL_TREE, $1); } - | template_type_parm '=' type_id - { $$ = build_tree_list (groktypename ($3.t), $1); } - | parm - { $$ = build_tree_list (NULL_TREE, $1.t); } - | parm '=' expr_no_comma_rangle - { $$ = build_tree_list ($3, $1.t); } - | template_template_parm - { $$ = build_tree_list (NULL_TREE, $1); } - | template_template_parm '=' template_arg - { - $3 = check_template_template_default_arg ($3); - $$ = build_tree_list ($3, $1); - } - ; - -template_def: - template_header template_extdef - { finish_template_decl ($1); } - | template_header error %prec EMPTY - { finish_template_decl ($1); } - ; - -template_extdef: - fndef eat_saved_input - { do_pending_inlines (); } - | template_datadef - { do_pending_inlines (); } - | template_def - { do_pending_inlines (); } - | extern_lang_string .hush_warning fndef .warning_ok eat_saved_input - { do_pending_inlines (); - pop_lang_context (); } - | extern_lang_string .hush_warning template_datadef .warning_ok - { do_pending_inlines (); - pop_lang_context (); } - | extension template_extdef - { pedantic = $1; } - ; - -template_datadef: - nomods_initdecls ';' - | declmods notype_initdecls ';' - {} - | typed_declspecs initdecls ';' - { note_list_got_semicolon ($1.t); } - | structsp ';' - { - if ($1.t != error_mark_node) - { - maybe_process_partial_specialization ($1.t); - note_got_semicolon ($1.t); - } - } - ; - -datadef: - nomods_initdecls ';' - | declmods notype_initdecls ';' - {} - | typed_declspecs initdecls ';' - { note_list_got_semicolon ($1.t); } - | declmods ';' - { pedwarn ("empty declaration"); } - | explicit_instantiation ';' - | typed_declspecs ';' - { - tree t, attrs; - split_specs_attrs ($1.t, &t, &attrs); - shadow_tag (t); - note_list_got_semicolon ($1.t); - } - | error ';' - | error '}' - | error END_OF_SAVED_INPUT - { end_input (); } - | ';' - | bad_decl - ; - -ctor_initializer_opt: - nodecls - | base_init - ; - -maybe_return_init: - /* empty */ - | return_init - | return_init ';' - ; - -eat_saved_input: - /* empty */ - | END_OF_SAVED_INPUT - ; - -/* The outermost block of a function really begins before the - mem-initializer-list, so we open one there, too. */ -function_body: - begin_function_body_ ctor_initializer_opt compstmt - { - finish_function_body ($1); - } - ; - -fndef: - fn.def1 maybe_return_init function_body - { expand_body (finish_function (0)); } - | fn.def1 maybe_return_init function_try_block - { expand_body (finish_function (0)); } - | fn.def1 maybe_return_init error - { } - ; - -constructor_declarator: - nested_name_specifier SELFNAME '(' - { $$ = begin_constructor_declarator ($1, $2); } - parmlist ')' cv_qualifiers exception_specification_opt - { $$ = make_call_declarator ($4, $5, $7, $8); } - | nested_name_specifier SELFNAME LEFT_RIGHT cv_qualifiers exception_specification_opt - { $$ = begin_constructor_declarator ($1, $2); - $$ = make_call_declarator ($$, empty_parms (), $4, $5); - } - | global_scope nested_name_specifier SELFNAME '(' - { $$ = begin_constructor_declarator ($2, $3); } - parmlist ')' cv_qualifiers exception_specification_opt - { $$ = make_call_declarator ($5, $6, $8, $9); } - | global_scope nested_name_specifier SELFNAME LEFT_RIGHT cv_qualifiers exception_specification_opt - { $$ = begin_constructor_declarator ($2, $3); - $$ = make_call_declarator ($$, empty_parms (), $5, $6); - } - | nested_name_specifier self_template_type '(' - { $$ = begin_constructor_declarator ($1, $2); } - parmlist ')' cv_qualifiers exception_specification_opt - { $$ = make_call_declarator ($4, $5, $7, $8); } - | nested_name_specifier self_template_type LEFT_RIGHT cv_qualifiers exception_specification_opt - { $$ = begin_constructor_declarator ($1, $2); - $$ = make_call_declarator ($$, empty_parms (), $4, $5); - } - | global_scope nested_name_specifier self_template_type '(' - { $$ = begin_constructor_declarator ($2, $3); } - parmlist ')' cv_qualifiers exception_specification_opt - { $$ = make_call_declarator ($5, $6, $8, $9); } - | global_scope nested_name_specifier self_template_type LEFT_RIGHT cv_qualifiers exception_specification_opt - { $$ = begin_constructor_declarator ($2, $3); - $$ = make_call_declarator ($$, empty_parms (), $5, $6); - } - ; - -fn.def1: - typed_declspecs declarator - { check_for_new_type ("return type", $1); - if (!parse_begin_function_definition ($1.t, $2)) - YYERROR1; } - | declmods notype_declarator - { if (!parse_begin_function_definition ($1.t, $2)) - YYERROR1; } - | notype_declarator - { if (!parse_begin_function_definition (NULL_TREE, $1)) - YYERROR1; } - | declmods constructor_declarator - { if (!parse_begin_function_definition ($1.t, $2)) - YYERROR1; } - | constructor_declarator - { if (!parse_begin_function_definition (NULL_TREE, $1)) - YYERROR1; } - ; - -/* ANSI allows optional parentheses around constructor class names. - See ISO/IEC 14882:1998(E) 12.1. */ - -component_constructor_declarator: - SELFNAME '(' parmlist ')' cv_qualifiers exception_specification_opt - { $$ = make_call_declarator ($1, $3, $5, $6); } - | '(' SELFNAME ')' '(' parmlist ')' cv_qualifiers - exception_specification_opt - { $$ = make_call_declarator ($2, $5, $7, $8); } - | SELFNAME LEFT_RIGHT cv_qualifiers exception_specification_opt - { $$ = make_call_declarator ($1, empty_parms (), $3, $4); } - | '(' SELFNAME ')' LEFT_RIGHT cv_qualifiers exception_specification_opt - { $$ = make_call_declarator ($2, empty_parms (), $5, $6); } - | self_template_type '(' parmlist ')' cv_qualifiers exception_specification_opt - { $$ = make_call_declarator ($1, $3, $5, $6); } - | self_template_type LEFT_RIGHT cv_qualifiers exception_specification_opt - { $$ = make_call_declarator ($1, empty_parms (), $3, $4); } - ; - -/* more C++ complexity. See component_decl for a comment on the - reduce/reduce conflict introduced by these rules. */ -fn_def2: - declmods component_constructor_declarator - { $$ = parse_method ($2, $1.t, $1.lookups); - rest_of_mdef: - if (! $$) - YYERROR1; - if (yychar == YYEMPTY) - yychar = YYLEX; - snarf_method ($$); } - | component_constructor_declarator - { $$ = parse_method ($1, NULL_TREE, NULL_TREE); - goto rest_of_mdef; } - | typed_declspecs declarator - { $$ = parse_method ($2, $1.t, $1.lookups); goto rest_of_mdef;} - | declmods notype_declarator - { $$ = parse_method ($2, $1.t, $1.lookups); goto rest_of_mdef;} - | notype_declarator - { $$ = parse_method ($1, NULL_TREE, NULL_TREE); - goto rest_of_mdef; } - | declmods constructor_declarator - { $$ = parse_method ($2, $1.t, $1.lookups); goto rest_of_mdef;} - | constructor_declarator - { $$ = parse_method ($1, NULL_TREE, NULL_TREE); - goto rest_of_mdef; } - ; - -return_id: - RETURN_KEYWORD IDENTIFIER - { - $$ = $2; - } - ; - -return_init: - return_id maybe_init - { finish_named_return_value ($$, $2); } - | return_id '(' nonnull_exprlist ')' - { finish_named_return_value ($$, $3); } - | return_id LEFT_RIGHT - { finish_named_return_value ($$, NULL_TREE); } - ; - -base_init: - ':' { begin_mem_initializers (); } member_init_list - { - if ($3.new_type_flag == 0) - error ("no base or member initializers given following ':'"); - finish_mem_initializers ($3.t); - } - ; - -begin_function_body_: - /* empty */ - { - $$ = begin_function_body (); - } - ; - -member_init_list: - /* empty */ - { - $$.new_type_flag = 0; - $$.t = NULL_TREE; - } - | member_init - { - $$.new_type_flag = 1; - $$.t = $1; - } - | member_init_list ',' member_init - { - if ($3) - { - $$.new_type_flag = 1; - TREE_CHAIN ($3) = $1.t; - $$.t = $3; - } - else - $$ = $1; - } - | member_init_list error - ; - -member_init: - '(' nonnull_exprlist ')' - { - if (current_class_name) - pedwarn ("anachronistic old style base class initializer"); - $$ = expand_member_init (NULL_TREE, $2); - } - | LEFT_RIGHT - { - if (current_class_name) - pedwarn ("anachronistic old style base class initializer"); - $$ = expand_member_init (NULL_TREE, - void_type_node); - } - | notype_identifier '(' nonnull_exprlist ')' - { $$ = expand_member_init ($1, $3); } - | notype_identifier LEFT_RIGHT - { $$ = expand_member_init ($1, void_type_node); } - | nonnested_type '(' nonnull_exprlist ')' - { $$ = expand_member_init ($1, $3); } - | nonnested_type LEFT_RIGHT - { $$ = expand_member_init ($1, void_type_node); } - | typename_sub '(' nonnull_exprlist ')' - { $$ = expand_member_init ($1, $3); } - | typename_sub LEFT_RIGHT - { $$ = expand_member_init ($1, void_type_node); } - | error - { $$ = NULL_TREE; } - ; - -identifier: - IDENTIFIER - | tTYPENAME - | SELFNAME - | PTYPENAME - | NSNAME - ; - -notype_identifier: - IDENTIFIER - | PTYPENAME - | NSNAME %prec EMPTY - ; - -identifier_defn: - IDENTIFIER_DEFN - | TYPENAME_DEFN - | PTYPENAME_DEFN - ; - -explicit_instantiation: - TEMPLATE begin_explicit_instantiation typespec ';' - { do_type_instantiation ($3.t, NULL_TREE, 1); - yyungetc (';', 1); } - end_explicit_instantiation - | TEMPLATE begin_explicit_instantiation typed_declspecs declarator - { tree specs = strip_attrs ($3.t); - parse_decl_instantiation (specs, $4, NULL_TREE); } - end_explicit_instantiation - | TEMPLATE begin_explicit_instantiation notype_declarator - { parse_decl_instantiation (NULL_TREE, $3, NULL_TREE); } - end_explicit_instantiation - | TEMPLATE begin_explicit_instantiation constructor_declarator - { parse_decl_instantiation (NULL_TREE, $3, NULL_TREE); } - end_explicit_instantiation - | SCSPEC TEMPLATE begin_explicit_instantiation typespec ';' - { do_type_instantiation ($4.t, $1, 1); - yyungetc (';', 1); } - end_explicit_instantiation - {} - | SCSPEC TEMPLATE begin_explicit_instantiation typed_declspecs - declarator - { tree specs = strip_attrs ($4.t); - parse_decl_instantiation (specs, $5, $1); } - end_explicit_instantiation - {} - | SCSPEC TEMPLATE begin_explicit_instantiation notype_declarator - { parse_decl_instantiation (NULL_TREE, $4, $1); } - end_explicit_instantiation - {} - | SCSPEC TEMPLATE begin_explicit_instantiation constructor_declarator - { parse_decl_instantiation (NULL_TREE, $4, $1); } - end_explicit_instantiation - {} - ; - -begin_explicit_instantiation: - { begin_explicit_instantiation(); } - ; - -end_explicit_instantiation: - { end_explicit_instantiation(); } - ; - -/* The TYPENAME expansions are to deal with use of a template class name as - a template within the class itself, where the template decl is hidden by - a type decl. Got all that? */ - -template_type: - PTYPENAME '<' template_arg_list_opt template_close_bracket - finish_template_type_ - { $$ = $5; } - | tTYPENAME '<' template_arg_list_opt template_close_bracket - finish_template_type_ - { $$ = $5; } - | self_template_type - ; - -apparent_template_type: - template_type - | identifier '<' template_arg_list_opt '>' - finish_template_type_ - { $$ = $5; } - ; - -self_template_type: - SELFNAME '<' template_arg_list_opt template_close_bracket - finish_template_type_ - { $$ = $5; } - ; - -finish_template_type_: - { - if (yychar == YYEMPTY) - yychar = YYLEX; - - $$ = finish_template_type ($-3, $-1, - yychar == SCOPE); - } - ; - -template_close_bracket: - '>' - | RSHIFT - { - /* Handle `Class>' without space in the `>>' */ - pedwarn ("`>>' should be `> >' in template class name"); - yyungetc ('>', 1); - } - ; - -template_arg_list_opt: - /* empty */ - { $$ = NULL_TREE; } - | template_arg_list - ; - -template_arg_list: - template_arg - { $$ = build_tree_list (NULL_TREE, $$); } - | template_arg_list ',' template_arg - { $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); } - ; - -template_arg: - type_id - { $$ = groktypename ($1.t); } - | PTYPENAME - { - $$ = lastiddecl; - if (DECL_TEMPLATE_TEMPLATE_PARM_P ($$)) - $$ = TREE_TYPE ($$); - } - | global_scope PTYPENAME - { - $$ = lastiddecl; - if (DECL_TEMPLATE_TEMPLATE_PARM_P ($$)) - $$ = TREE_TYPE ($$); - } - | expr_no_comma_rangle - | nested_name_specifier TEMPLATE identifier - { - if (!processing_template_decl) - { - error ("use of template qualifier outside template"); - $$ = error_mark_node; - } - else - $$ = make_unbound_class_template ($1, $3, tf_error | tf_parsing); - } - ; - -unop: - '-' - { $$ = NEGATE_EXPR; } - | '+' - { $$ = CONVERT_EXPR; } - | PLUSPLUS - { $$ = PREINCREMENT_EXPR; } - | MINUSMINUS - { $$ = PREDECREMENT_EXPR; } - | '!' - { $$ = TRUTH_NOT_EXPR; } - ; - -expr: - nontrivial_exprlist - { $$ = build_x_compound_expr ($$); } - | expr_no_commas - ; - -paren_expr_or_null: - LEFT_RIGHT - { error ("ISO C++ forbids an empty condition for `%s'", - cond_stmt_keyword); - $$ = integer_zero_node; } - | '(' expr ')' - { $$ = $2; } - ; - -paren_cond_or_null: - LEFT_RIGHT - { error ("ISO C++ forbids an empty condition for `%s'", - cond_stmt_keyword); - $$ = integer_zero_node; } - | '(' condition ')' - { $$ = $2; } - ; - -xcond: - /* empty */ - { $$ = NULL_TREE; } - | condition - | error - { $$ = NULL_TREE; } - ; - -condition: - type_specifier_seq declarator maybeasm maybe_attribute '=' - { { - tree d; - for (d = getdecls (); d; d = TREE_CHAIN (d)) - if (TREE_CODE (d) == TYPE_DECL) { - tree s = TREE_TYPE (d); - if (TREE_CODE (s) == RECORD_TYPE) - error ("definition of class `%T' in condition", s); - else if (TREE_CODE (s) == ENUMERAL_TYPE) - error ("definition of enum `%T' in condition", s); - } - } - current_declspecs = $1.t; - $$ = parse_decl ($2, $4, 1); - } - init - { - parse_end_decl ($6, $7, $4); - $$ = convert_from_reference ($6); - if (TREE_CODE (TREE_TYPE ($$)) == ARRAY_TYPE) - error ("definition of array `%#D' in condition", $$); - } - | expr - ; - -compstmtend: - '}' - | maybe_label_decls stmts '}' - | maybe_label_decls stmts error '}' - | maybe_label_decls error '}' - ; - -nontrivial_exprlist: - expr_no_commas ',' expr_no_commas - { $$ = tree_cons (NULL_TREE, $$, - build_tree_list (NULL_TREE, $3)); } - | expr_no_commas ',' error - { $$ = tree_cons (NULL_TREE, $$, - build_tree_list (NULL_TREE, error_mark_node)); } - | nontrivial_exprlist ',' expr_no_commas - { chainon ($$, build_tree_list (NULL_TREE, $3)); } - | nontrivial_exprlist ',' error - { chainon ($$, build_tree_list (NULL_TREE, error_mark_node)); } - ; - -nonnull_exprlist: - expr_no_commas - { $$ = build_tree_list (NULL_TREE, $$); } - | nontrivial_exprlist - ; - -unary_expr: - primary %prec UNARY - { $$ = $1; } - /* __extension__ turns off -pedantic for following primary. */ - | extension cast_expr %prec UNARY - { $$ = $2; - pedantic = $1; } - | '*' cast_expr %prec UNARY - { $$ = build_x_indirect_ref ($2, "unary *"); } - | '&' cast_expr %prec UNARY - { $$ = build_x_unary_op (ADDR_EXPR, $2); } - | '~' cast_expr - { $$ = build_x_unary_op (BIT_NOT_EXPR, $2); } - | unop cast_expr %prec UNARY - { $$ = finish_unary_op_expr ($1, $2); } - /* Refer to the address of a label as a pointer. */ - | ANDAND identifier - { $$ = finish_label_address_expr ($2); } - | sizeof unary_expr %prec UNARY - { $$ = finish_sizeof ($2); - skip_evaluation--; } - | sizeof '(' type_id ')' %prec HYPERUNARY - { $$ = finish_sizeof (groktypename ($3.t)); - check_for_new_type ("sizeof", $3); - skip_evaluation--; } - | alignof unary_expr %prec UNARY - { $$ = finish_alignof ($2); - skip_evaluation--; } - | alignof '(' type_id ')' %prec HYPERUNARY - { $$ = finish_alignof (groktypename ($3.t)); - check_for_new_type ("alignof", $3); - skip_evaluation--; } - - /* The %prec EMPTY's here are required by the = init initializer - syntax extension; see below. */ - | new new_type_id %prec EMPTY - { $$ = build_new (NULL_TREE, $2.t, NULL_TREE, $1); - check_for_new_type ("new", $2); } - | new new_type_id new_initializer - { $$ = build_new (NULL_TREE, $2.t, $3, $1); - check_for_new_type ("new", $2); } - | new new_placement new_type_id %prec EMPTY - { $$ = build_new ($2, $3.t, NULL_TREE, $1); - check_for_new_type ("new", $3); } - | new new_placement new_type_id new_initializer - { $$ = build_new ($2, $3.t, $4, $1); - check_for_new_type ("new", $3); } - | new '(' type_id ')' - %prec EMPTY - { $$ = build_new (NULL_TREE, groktypename($3.t), - NULL_TREE, $1); - check_for_new_type ("new", $3); } - | new '(' type_id ')' new_initializer - { $$ = build_new (NULL_TREE, groktypename($3.t), $5, $1); - check_for_new_type ("new", $3); } - | new new_placement '(' type_id ')' %prec EMPTY - { $$ = build_new ($2, groktypename($4.t), NULL_TREE, $1); - check_for_new_type ("new", $4); } - | new new_placement '(' type_id ')' new_initializer - { $$ = build_new ($2, groktypename($4.t), $6, $1); - check_for_new_type ("new", $4); } - - | delete cast_expr %prec UNARY - { $$ = delete_sanity ($2, NULL_TREE, 0, $1); } - | delete '[' ']' cast_expr %prec UNARY - { $$ = delete_sanity ($4, NULL_TREE, 1, $1); - if (yychar == YYEMPTY) - yychar = YYLEX; } - | delete '[' expr ']' cast_expr %prec UNARY - { $$ = delete_sanity ($5, $3, 2, $1); - if (yychar == YYEMPTY) - yychar = YYLEX; } - | REALPART cast_expr %prec UNARY - { $$ = build_x_unary_op (REALPART_EXPR, $2); } - | IMAGPART cast_expr %prec UNARY - { $$ = build_x_unary_op (IMAGPART_EXPR, $2); } - ; - -new_placement: - '(' nonnull_exprlist ')' - { $$ = $2; } - | '{' nonnull_exprlist '}' - { pedwarn ("old style placement syntax, use () instead"); - $$ = $2; } - ; - -new_initializer: - '(' nonnull_exprlist ')' - { $$ = $2; } - | LEFT_RIGHT - { $$ = void_zero_node; } - | '(' typespec ')' - { - error ("`%T' is not a valid expression", $2.t); - $$ = error_mark_node; - } - | '=' init - { - /* This was previously allowed as an extension, but - was removed in G++ 3.3. */ - error ("initialization of new expression with `='"); - $$ = error_mark_node; - } - ; - -/* This is necessary to postpone reduction of `int ((int)(int)(int))'. */ -regcast_or_absdcl: - '(' type_id ')' %prec EMPTY - { $2.t = finish_parmlist (build_tree_list (NULL_TREE, $2.t), 0); - $$ = make_call_declarator (NULL_TREE, $2.t, NULL_TREE, NULL_TREE); - check_for_new_type ("cast", $2); } - | regcast_or_absdcl '(' type_id ')' %prec EMPTY - { $3.t = finish_parmlist (build_tree_list (NULL_TREE, $3.t), 0); - $$ = make_call_declarator ($$, $3.t, NULL_TREE, NULL_TREE); - check_for_new_type ("cast", $3); } - ; - -cast_expr: - unary_expr - | regcast_or_absdcl unary_expr %prec UNARY - { $$ = reparse_absdcl_as_casts ($$, $2); } - | regcast_or_absdcl '{' initlist maybecomma '}' %prec UNARY - { - tree init = build_nt (CONSTRUCTOR, NULL_TREE, - nreverse ($3)); - if (pedantic) - pedwarn ("ISO C++ forbids compound literals"); - /* Indicate that this was a C99 compound literal. */ - TREE_HAS_CONSTRUCTOR (init) = 1; - - $$ = reparse_absdcl_as_casts ($$, init); - } - ; - -expr_no_commas: - cast_expr - /* Handle general members. */ - | expr_no_commas POINTSAT_STAR expr_no_commas - { $$ = build_x_binary_op (MEMBER_REF, $$, $3); } - | expr_no_commas DOT_STAR expr_no_commas - { $$ = build_m_component_ref ($$, $3); } - | expr_no_commas '+' expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas '-' expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas '*' expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas '/' expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas '%' expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas LSHIFT expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas RSHIFT expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas ARITHCOMPARE expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas '<' expr_no_commas - { $$ = build_x_binary_op (LT_EXPR, $$, $3); } - | expr_no_commas '>' expr_no_commas - { $$ = build_x_binary_op (GT_EXPR, $$, $3); } - | expr_no_commas EQCOMPARE expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas MIN_MAX expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas '&' expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas '|' expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas '^' expr_no_commas - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_commas ANDAND expr_no_commas - { $$ = build_x_binary_op (TRUTH_ANDIF_EXPR, $$, $3); } - | expr_no_commas OROR expr_no_commas - { $$ = build_x_binary_op (TRUTH_ORIF_EXPR, $$, $3); } - | expr_no_commas '?' xexpr ':' expr_no_commas - { $$ = build_x_conditional_expr ($$, $3, $5); } - | expr_no_commas '=' expr_no_commas - { $$ = build_x_modify_expr ($$, NOP_EXPR, $3); - if ($$ != error_mark_node) - C_SET_EXP_ORIGINAL_CODE ($$, MODIFY_EXPR); } - | expr_no_commas ASSIGN expr_no_commas - { $$ = build_x_modify_expr ($$, $2, $3); } - | THROW - { $$ = build_throw (NULL_TREE); } - | THROW expr_no_commas - { $$ = build_throw ($2); } - ; - -expr_no_comma_rangle: - cast_expr - /* Handle general members. */ - | expr_no_comma_rangle POINTSAT_STAR expr_no_comma_rangle - { $$ = build_x_binary_op (MEMBER_REF, $$, $3); } - | expr_no_comma_rangle DOT_STAR expr_no_comma_rangle - { $$ = build_m_component_ref ($$, $3); } - | expr_no_comma_rangle '+' expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle '-' expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle '*' expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle '/' expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle '%' expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle LSHIFT expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle RSHIFT expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle ARITHCOMPARE expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle '<' expr_no_comma_rangle - { $$ = build_x_binary_op (LT_EXPR, $$, $3); } - | expr_no_comma_rangle EQCOMPARE expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle MIN_MAX expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle '&' expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle '|' expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle '^' expr_no_comma_rangle - { $$ = build_x_binary_op ($2, $$, $3); } - | expr_no_comma_rangle ANDAND expr_no_comma_rangle - { $$ = build_x_binary_op (TRUTH_ANDIF_EXPR, $$, $3); } - | expr_no_comma_rangle OROR expr_no_comma_rangle - { $$ = build_x_binary_op (TRUTH_ORIF_EXPR, $$, $3); } - | expr_no_comma_rangle '?' xexpr ':' expr_no_comma_rangle - { $$ = build_x_conditional_expr ($$, $3, $5); } - | expr_no_comma_rangle '=' expr_no_comma_rangle - { $$ = build_x_modify_expr ($$, NOP_EXPR, $3); - if ($$ != error_mark_node) - C_SET_EXP_ORIGINAL_CODE ($$, MODIFY_EXPR); } - | expr_no_comma_rangle ASSIGN expr_no_comma_rangle - { $$ = build_x_modify_expr ($$, $2, $3); } - | THROW - { $$ = build_throw (NULL_TREE); } - | THROW expr_no_comma_rangle - { $$ = build_throw ($2); } - ; - -notype_unqualified_id: - '~' see_typename identifier - { $$ = build_nt (BIT_NOT_EXPR, $3); } - | '~' see_typename template_type - { $$ = build_nt (BIT_NOT_EXPR, $3); } - | template_id - | operator_name - | IDENTIFIER - | PTYPENAME - | NSNAME %prec EMPTY - ; - -do_id: - { - /* If lastiddecl is a BASELINK we're in an - expression like S::f, so don't - do_identifier; we only do that for unqualified - identifiers. */ - if (!lastiddecl || !BASELINK_P (lastiddecl)) - $$ = do_identifier ($-1, 3, NULL_TREE); - else - $$ = $-1; - } - ; - -template_id: - PFUNCNAME '<' do_id template_arg_list_opt template_close_bracket - { - tree template_name = $3; - if (TREE_CODE (template_name) == COMPONENT_REF) - template_name = TREE_OPERAND (template_name, 1); - $$ = lookup_template_function (template_name, $4); - } - | operator_name '<' do_id template_arg_list_opt template_close_bracket - { - tree template_name = $3; - if (TREE_CODE (template_name) == COMPONENT_REF) - template_name = TREE_OPERAND (template_name, 1); - $$ = lookup_template_function (template_name, $4); - } - ; - -object_template_id: - TEMPLATE identifier '<' template_arg_list_opt template_close_bracket - { $$ = lookup_template_function ($2, $4); } - | TEMPLATE PFUNCNAME '<' template_arg_list_opt template_close_bracket - { $$ = lookup_template_function ($2, $4); } - | TEMPLATE operator_name '<' template_arg_list_opt - template_close_bracket - { $$ = lookup_template_function ($2, $4); } - ; - -unqualified_id: - notype_unqualified_id - | tTYPENAME - | SELFNAME - ; - -expr_or_declarator_intern: - expr_or_declarator - | attributes expr_or_declarator - { - /* Provide support for '(' attributes '*' declarator ')' - etc */ - $$ = tree_cons ($1, $2, NULL_TREE); - } - ; - -expr_or_declarator: - notype_unqualified_id - | '*' expr_or_declarator_intern %prec UNARY - { $$ = build_nt (INDIRECT_REF, $2); } - | '&' expr_or_declarator_intern %prec UNARY - { $$ = build_nt (ADDR_EXPR, $2); } - | '(' expr_or_declarator_intern ')' - { $$ = $2; } - ; - -notype_template_declarator: - IDENTIFIER '<' template_arg_list_opt template_close_bracket - { $$ = lookup_template_function ($1, $3); } - | NSNAME '<' template_arg_list template_close_bracket - { $$ = lookup_template_function ($1, $3); } - ; - -direct_notype_declarator: - complex_direct_notype_declarator - /* This precedence declaration is to prefer this reduce - to the Koenig lookup shift in primary, below. I hate yacc. */ - | notype_unqualified_id %prec '(' - | notype_template_declarator - | '(' expr_or_declarator_intern ')' - { $$ = finish_decl_parsing ($2); } - ; - -primary: - notype_unqualified_id - { - if (TREE_CODE ($1) == BIT_NOT_EXPR) - $$ = build_x_unary_op (BIT_NOT_EXPR, TREE_OPERAND ($1, 0)); - else - $$ = finish_id_expr ($1); - } - | CONSTANT - | boolean_literal - | STRING - { - $$ = fix_string_type ($$); - /* fix_string_type doesn't set up TYPE_MAIN_VARIANT of - a const array the way we want, so fix it. */ - if (flag_const_strings) - TREE_TYPE ($$) = build_cplus_array_type - (TREE_TYPE (TREE_TYPE ($$)), - TYPE_DOMAIN (TREE_TYPE ($$))); - } - | VAR_FUNC_NAME - { $$ = finish_fname ($1); } - | '(' expr ')' - { $$ = finish_parenthesized_expr ($2); } - | '(' expr_or_declarator_intern ')' - { $2 = reparse_decl_as_expr (NULL_TREE, $2); - $$ = finish_parenthesized_expr ($2); } - | '(' error ')' - { $$ = error_mark_node; } - | '(' - { if (!at_function_scope_p ()) - { - error ("braced-group within expression allowed only inside a function"); - YYERROR; - } - if (pedantic) - pedwarn ("ISO C++ forbids braced-groups within expressions"); - $$ = begin_stmt_expr (); - } - compstmt_or_stmtexpr ')' - { $$ = finish_stmt_expr ($2); } - /* Koenig lookup support - We could store lastiddecl in $1 to avoid another lookup, - but that would result in many additional reduce/reduce conflicts. */ - | notype_unqualified_id '(' nonnull_exprlist ')' - { $$ = parse_finish_call_expr ($1, $3, 1); } - | notype_unqualified_id LEFT_RIGHT - { $$ = parse_finish_call_expr ($1, NULL_TREE, 1); } - | primary '(' nonnull_exprlist ')' - { $$ = parse_finish_call_expr ($1, $3, 0); } - | primary LEFT_RIGHT - { $$ = parse_finish_call_expr ($1, NULL_TREE, 0); } - | VA_ARG '(' expr_no_commas ',' type_id ')' - { $$ = build_x_va_arg ($3, groktypename ($5.t)); - check_for_new_type ("__builtin_va_arg", $5); } - | primary '[' expr ']' - { $$ = grok_array_decl ($$, $3); } - | primary PLUSPLUS - { $$ = finish_increment_expr ($1, POSTINCREMENT_EXPR); } - | primary MINUSMINUS - { $$ = finish_increment_expr ($1, POSTDECREMENT_EXPR); } - /* C++ extensions */ - | THIS - { $$ = finish_this_expr (); } - | CV_QUALIFIER '(' nonnull_exprlist ')' - { - /* This is a C cast in C++'s `functional' notation - using the "implicit int" extension so that: - `const (3)' is equivalent to `const int (3)'. */ - tree type; - - type = hash_tree_cons (NULL_TREE, $1, NULL_TREE); - type = groktypename (build_tree_list (type, NULL_TREE)); - $$ = build_functional_cast (type, $3); - } - | functional_cast - | DYNAMIC_CAST '<' type_id '>' '(' expr ')' - { tree type = groktypename ($3.t); - check_for_new_type ("dynamic_cast", $3); - $$ = build_dynamic_cast (type, $6); } - | STATIC_CAST '<' type_id '>' '(' expr ')' - { tree type = groktypename ($3.t); - check_for_new_type ("static_cast", $3); - $$ = build_static_cast (type, $6); } - | REINTERPRET_CAST '<' type_id '>' '(' expr ')' - { tree type = groktypename ($3.t); - check_for_new_type ("reinterpret_cast", $3); - $$ = build_reinterpret_cast (type, $6); } - | CONST_CAST '<' type_id '>' '(' expr ')' - { tree type = groktypename ($3.t); - check_for_new_type ("const_cast", $3); - $$ = build_const_cast (type, $6); } - | TYPEID '(' expr ')' - { $$ = build_typeid ($3); } - | TYPEID '(' type_id ')' - { tree type = groktypename ($3.t); - check_for_new_type ("typeid", $3); - $$ = get_typeid (type); } - | global_scope IDENTIFIER - { $$ = parse_scoped_id ($2); } - | global_scope template_id - { $$ = $2; } - | global_scope operator_name - { - got_scope = NULL_TREE; - if (TREE_CODE ($2) == IDENTIFIER_NODE) - $$ = parse_scoped_id ($2); - else - $$ = $2; - } - | overqualified_id %prec HYPERUNARY - { $$ = build_offset_ref (OP0 ($$), OP1 ($$)); } - | overqualified_id '(' nonnull_exprlist ')' - { $$ = parse_finish_call_expr ($1, $3, 0); } - | overqualified_id LEFT_RIGHT - { $$ = parse_finish_call_expr ($1, NULL_TREE, 0); } - | object object_template_id %prec UNARY - { $$ = finish_class_member_access_expr ($$, $2); } - | object object_template_id '(' nonnull_exprlist ')' - { $$ = finish_object_call_expr ($2, $1, $4); } - | object object_template_id LEFT_RIGHT - { $$ = finish_object_call_expr ($2, $1, NULL_TREE); } - | object unqualified_id %prec UNARY - { $$ = finish_class_member_access_expr ($$, $2); } - | object overqualified_id %prec UNARY - { $$ = finish_class_member_access_expr ($1, $2); } - | object unqualified_id '(' nonnull_exprlist ')' - { $$ = finish_object_call_expr ($2, $1, $4); } - | object unqualified_id LEFT_RIGHT - { $$ = finish_object_call_expr ($2, $1, NULL_TREE); } - | object overqualified_id '(' nonnull_exprlist ')' - { $$ = finish_qualified_object_call_expr ($2, $1, $4); } - | object overqualified_id LEFT_RIGHT - { $$ = finish_qualified_object_call_expr ($2, $1, NULL_TREE); } - /* p->int::~int() is valid -- 12.4 */ - | object '~' TYPESPEC LEFT_RIGHT - { $$ = finish_pseudo_destructor_call_expr ($1, NULL_TREE, $3); } - | object TYPESPEC SCOPE '~' TYPESPEC LEFT_RIGHT - { $$ = finish_pseudo_destructor_call_expr ($1, $2, $5); } - | object error - { - $$ = error_mark_node; - } - ; - -/* Not needed for now. - -primary_no_id: - '(' expr ')' - { $$ = $2; } - | '(' error ')' - { $$ = error_mark_node; } - | '(' - { if (current_function_decl == 0) - { - error ("braced-group within expression allowed only inside a function"); - YYERROR; - } - $$ = expand_start_stmt_expr (); } - compstmt_or_stmtexpr ')' - { if (pedantic) - pedwarn ("ISO C++ forbids braced-groups within expressions"); - $$ = expand_end_stmt_expr ($2); } - | primary_no_id '(' nonnull_exprlist ')' - { $$ = build_x_function_call ($$, $3, current_class_ref); } - | primary_no_id LEFT_RIGHT - { $$ = build_x_function_call ($$, NULL_TREE, current_class_ref); } - | primary_no_id '[' expr ']' - { goto do_array; } - | primary_no_id PLUSPLUS - { $$ = build_x_unary_op (POSTINCREMENT_EXPR, $$); } - | primary_no_id MINUSMINUS - { $$ = build_x_unary_op (POSTDECREMENT_EXPR, $$); } - | SCOPE IDENTIFIER - { goto do_scoped_id; } - | SCOPE operator_name - { if (TREE_CODE ($2) == IDENTIFIER_NODE) - goto do_scoped_id; - goto do_scoped_operator; - } - ; -*/ - -new: - NEW - { $$ = 0; } - | global_scope NEW - { got_scope = NULL_TREE; $$ = 1; } - ; - -delete: - DELETE - { $$ = 0; } - | global_scope delete - { got_scope = NULL_TREE; $$ = 1; } - ; - -boolean_literal: - CXX_TRUE - { $$ = boolean_true_node; } - | CXX_FALSE - { $$ = boolean_false_node; } - ; - -nodecls: - /* empty */ - { - if (DECL_CONSTRUCTOR_P (current_function_decl)) - finish_mem_initializers (NULL_TREE); - } - ; - -object: - primary '.' - { got_object = TREE_TYPE ($$); } - | primary POINTSAT - { - $$ = build_x_arrow ($$); - got_object = TREE_TYPE ($$); - } - ; - -decl: - typespec initdecls ';' - { - if ($1.t && IS_AGGR_TYPE_CODE (TREE_CODE ($1.t))) - note_got_semicolon ($1.t); - } - | typed_declspecs initdecls ';' - { - note_list_got_semicolon ($1.t); - } - | declmods notype_initdecls ';' - {} - | typed_declspecs ';' - { - shadow_tag ($1.t); - note_list_got_semicolon ($1.t); - } - | declmods ';' - { warning ("empty declaration"); } - | extension decl - { pedantic = $1; } - ; - -/* Any kind of declarator (thus, all declarators allowed - after an explicit typespec). */ - -declarator: - after_type_declarator %prec EMPTY - | notype_declarator %prec EMPTY - ; - -/* This is necessary to postpone reduction of `int()()()()'. */ -fcast_or_absdcl: - LEFT_RIGHT %prec EMPTY - { $$ = make_call_declarator (NULL_TREE, empty_parms (), - NULL_TREE, NULL_TREE); } - | fcast_or_absdcl LEFT_RIGHT %prec EMPTY - { $$ = make_call_declarator ($$, empty_parms (), NULL_TREE, - NULL_TREE); } - ; - -/* ISO type-id (8.1) */ -type_id: - typed_typespecs absdcl - { $$.t = build_tree_list ($1.t, $2); - $$.new_type_flag = $1.new_type_flag; } - | nonempty_cv_qualifiers absdcl - { $$.t = build_tree_list ($1.t, $2); - $$.new_type_flag = $1.new_type_flag; } - | typespec absdcl - { $$.t = build_tree_list (build_tree_list (NULL_TREE, $1.t), - $2); - $$.new_type_flag = $1.new_type_flag; } - | typed_typespecs %prec EMPTY - { $$.t = build_tree_list ($1.t, NULL_TREE); - $$.new_type_flag = $1.new_type_flag; } - | nonempty_cv_qualifiers %prec EMPTY - { $$.t = build_tree_list ($1.t, NULL_TREE); - $$.new_type_flag = $1.new_type_flag; } - ; - -/* Declspecs which contain at least one type specifier or typedef name. - (Just `const' or `volatile' is not enough.) - A typedef'd name following these is taken as a name to be declared. - In the result, declspecs have a non-NULL TREE_VALUE, attributes do not. */ - -typed_declspecs: - typed_typespecs %prec EMPTY - { $$.lookups = type_lookups; } - | typed_declspecs1 - { $$.lookups = type_lookups; } - ; - -typed_declspecs1: - declmods typespec - { $$.t = tree_cons (NULL_TREE, $2.t, $1.t); - $$.new_type_flag = $2.new_type_flag; } - | typespec reserved_declspecs %prec HYPERUNARY - { $$.t = tree_cons (NULL_TREE, $1.t, $2); - $$.new_type_flag = $1.new_type_flag; } - | typespec reserved_typespecquals reserved_declspecs - { $$.t = tree_cons (NULL_TREE, $1.t, chainon ($2, $3)); - $$.new_type_flag = $1.new_type_flag; } - | declmods typespec reserved_declspecs - { $$.t = tree_cons (NULL_TREE, $2.t, chainon ($3, $1.t)); - $$.new_type_flag = $2.new_type_flag; } - | declmods typespec reserved_typespecquals - { $$.t = tree_cons (NULL_TREE, $2.t, chainon ($3, $1.t)); - $$.new_type_flag = $2.new_type_flag; } - | declmods typespec reserved_typespecquals reserved_declspecs - { $$.t = tree_cons (NULL_TREE, $2.t, - chainon ($3, chainon ($4, $1.t))); - $$.new_type_flag = $2.new_type_flag; } - ; - -reserved_declspecs: - SCSPEC - { if (extra_warnings) - warning ("`%s' is not at beginning of declaration", - IDENTIFIER_POINTER ($$)); - $$ = build_tree_list (NULL_TREE, $$); } - | reserved_declspecs typespecqual_reserved - { $$ = tree_cons (NULL_TREE, $2.t, $$); } - | reserved_declspecs SCSPEC - { if (extra_warnings) - warning ("`%s' is not at beginning of declaration", - IDENTIFIER_POINTER ($2)); - $$ = tree_cons (NULL_TREE, $2, $$); } - ; - -/* List of just storage classes and type modifiers. - A declaration can start with just this, but then it cannot be used - to redeclare a typedef-name. - In the result, declspecs have a non-NULL TREE_VALUE, attributes do not. */ - -/* We use hash_tree_cons for lists of typeless declspecs so that they end - up on a persistent obstack. Otherwise, they could appear at the - beginning of something like - - static const struct { int foo () { } } b; - - and would be discarded after we finish compiling foo. We don't need to - worry once we see a type. */ - -declmods: - nonempty_cv_qualifiers %prec EMPTY - { $$.lookups = NULL_TREE; TREE_STATIC ($$.t) = 1; } - | SCSPEC - { - $$.t = hash_tree_cons (NULL_TREE, $1, NULL_TREE); - $$.new_type_flag = 0; $$.lookups = NULL_TREE; - } - | declmods CV_QUALIFIER - { - $$.t = hash_tree_cons (NULL_TREE, $2, $1.t); - TREE_STATIC ($$.t) = 1; - } - | declmods SCSPEC - { - if (extra_warnings && TREE_STATIC ($$.t)) - warning ("`%s' is not at beginning of declaration", - IDENTIFIER_POINTER ($2)); - $$.t = hash_tree_cons (NULL_TREE, $2, $1.t); - TREE_STATIC ($$.t) = TREE_STATIC ($1.t); - } - | declmods attributes - { $$.t = hash_tree_cons ($2, NULL_TREE, $1.t); } - ; - -/* Used instead of declspecs where storage classes are not allowed - (that is, for typenames and structure components). - - C++ can takes storage classes for structure components. - Don't accept a typedef-name if anything but a modifier precedes it. */ - -typed_typespecs: - typespec %prec EMPTY - { $$.t = build_tree_list (NULL_TREE, $1.t); - $$.new_type_flag = $1.new_type_flag; } - | nonempty_cv_qualifiers typespec - { $$.t = tree_cons (NULL_TREE, $2.t, $1.t); - $$.new_type_flag = $2.new_type_flag; } - | typespec reserved_typespecquals - { $$.t = tree_cons (NULL_TREE, $1.t, $2); - $$.new_type_flag = $1.new_type_flag; } - | nonempty_cv_qualifiers typespec reserved_typespecquals - { $$.t = tree_cons (NULL_TREE, $2.t, chainon ($3, $1.t)); - $$.new_type_flag = $2.new_type_flag; } - ; - -reserved_typespecquals: - typespecqual_reserved - { $$ = build_tree_list (NULL_TREE, $1.t); } - | reserved_typespecquals typespecqual_reserved - { $$ = tree_cons (NULL_TREE, $2.t, $1); } - | reserved_typespecquals attributes - { $$ = tree_cons ($2, NULL_TREE, $1); } - | attributes %prec EMPTY - { $$ = tree_cons ($1, NULL_TREE, NULL_TREE); } - ; - -sizeof: - SIZEOF { skip_evaluation++; } - ; - -alignof: - ALIGNOF { skip_evaluation++; } - ; - -typeof: - TYPEOF { skip_evaluation++; } - ; - -/* A typespec (but not a type qualifier). - Once we have seen one of these in a declaration, - if a typedef name appears then it is being redeclared. */ - -typespec: - structsp - { $$.lookups = NULL_TREE; } - | TYPESPEC %prec EMPTY - { $$.t = $1; $$.new_type_flag = 0; $$.lookups = NULL_TREE; } - | complete_type_name - { $$.t = $1; $$.new_type_flag = 0; $$.lookups = NULL_TREE; } - | typeof '(' expr ')' - { $$.t = finish_typeof ($3); - $$.new_type_flag = 0; $$.lookups = NULL_TREE; - skip_evaluation--; } - | typeof '(' type_id ')' - { $$.t = groktypename ($3.t); - $$.new_type_flag = 0; $$.lookups = NULL_TREE; - skip_evaluation--; } - | SIGOF '(' expr ')' - { tree type = TREE_TYPE ($3); - - $$.new_type_flag = 0; $$.lookups = NULL_TREE; - if (IS_AGGR_TYPE (type)) - { - sorry ("sigof type specifier"); - $$.t = type; - } - else - { - error ("`sigof' applied to non-aggregate expression"); - $$.t = error_mark_node; - } - } - | SIGOF '(' type_id ')' - { tree type = groktypename ($3.t); - - $$.new_type_flag = 0; $$.lookups = NULL_TREE; - if (IS_AGGR_TYPE (type)) - { - sorry ("sigof type specifier"); - $$.t = type; - } - else - { - error("`sigof' applied to non-aggregate type"); - $$.t = error_mark_node; - } - } - ; - -/* A typespec that is a reserved word, or a type qualifier. */ - -typespecqual_reserved: - TYPESPEC - { $$.t = $1; $$.new_type_flag = 0; } - | CV_QUALIFIER - { $$.t = $1; $$.new_type_flag = 0; } - | structsp - ; - -initdecls: - initdcl0 - | initdecls ',' initdcl - { check_multiple_declarators (); } - ; - -notype_initdecls: - notype_initdcl0 - | notype_initdecls ',' initdcl - { check_multiple_declarators (); } - ; - -nomods_initdecls: - nomods_initdcl0 - | nomods_initdecls ',' initdcl - { check_multiple_declarators (); } - ; - -maybeasm: - /* empty */ - { $$ = NULL_TREE; } - | asm_keyword '(' STRING ')' - { $$ = $3; } - ; - -initdcl: - declarator maybeasm maybe_attribute '=' - { $$ = parse_decl ($1, $3, 1); } - init -/* Note how the declaration of the variable is in effect while its init is parsed! */ - { parse_end_decl ($5, $6, $2); } - | declarator maybeasm maybe_attribute - { - $$ = parse_decl ($1, $3, 0); - parse_end_decl ($$, NULL_TREE, $2); - } - ; - - /* This rule assumes a certain configuration of the parser stack. - In particular, $0, the element directly before the beginning of - this rule on the stack, must be a maybeasm. $-1 must be a - declarator or notype_declarator. And $-2 must be some declmods - or declspecs. We can't move the maybeasm into this rule because - we need that reduce so we prefer fn.def1 when appropriate. */ -initdcl0_innards: - maybe_attribute '=' - { $$ = parse_decl0 ($-1, $-2.t, - $-2.lookups, $1, 1); } - /* Note how the declaration of the variable is in effect - while its init is parsed! */ - init - { parse_end_decl ($3, $4, $0); } - | maybe_attribute - { tree d = parse_decl0 ($-1, $-2.t, - $-2.lookups, $1, 0); - parse_end_decl (d, NULL_TREE, $0); } - ; - -initdcl0: - declarator maybeasm initdcl0_innards - {} - ; - -notype_initdcl0: - notype_declarator maybeasm initdcl0_innards - {} - ; - -nomods_initdcl0: - notype_declarator maybeasm - { /* Set things up as initdcl0_innards expects. */ - $$ = $2; - $2 = $1; - $1.t = NULL_TREE; - $1.lookups = NULL_TREE; } - initdcl0_innards - {} - | constructor_declarator maybeasm maybe_attribute - { tree d = parse_decl0 ($1, NULL_TREE, NULL_TREE, $3, 0); - parse_end_decl (d, NULL_TREE, $2); } - ; - -/* the * rules are dummies to accept the Apollo extended syntax - so that the header files compile. */ -maybe_attribute: - /* empty */ - { $$ = NULL_TREE; } - | attributes - { $$ = $1; } - ; - -attributes: - attribute - { $$ = $1; } - | attributes attribute - { $$ = chainon ($1, $2); } - ; - -attribute: - ATTRIBUTE '(' '(' attribute_list ')' ')' - { $$ = $4; } - ; - -attribute_list: - attrib - { $$ = $1; } - | attribute_list ',' attrib - { $$ = chainon ($1, $3); } - ; - -attrib: - /* empty */ - { $$ = NULL_TREE; } - | any_word - { $$ = build_tree_list ($1, NULL_TREE); } - | any_word '(' IDENTIFIER ')' - { $$ = build_tree_list ($1, build_tree_list (NULL_TREE, $3)); } - | any_word '(' IDENTIFIER ',' nonnull_exprlist ')' - { $$ = build_tree_list ($1, tree_cons (NULL_TREE, $3, $5)); } - | any_word '(' nonnull_exprlist ')' - { $$ = build_tree_list ($1, $3); } - ; - -/* This still leaves out most reserved keywords, - shouldn't we include them? */ - -any_word: - identifier - | SCSPEC - | TYPESPEC - | CV_QUALIFIER - ; - -/* A nonempty list of identifiers, including typenames. */ -identifiers_or_typenames: - identifier - { $$ = build_tree_list (NULL_TREE, $1); } - | identifiers_or_typenames ',' identifier - { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } - ; - -maybe_init: - /* empty */ %prec EMPTY - { $$ = NULL_TREE; } - | '=' init - { $$ = $2; } - ; - -/* If we are processing a template, we don't want to expand this - initializer yet. */ - -init: - expr_no_commas %prec '=' - | '{' '}' - { $$ = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE); - TREE_HAS_CONSTRUCTOR ($$) = 1; } - | '{' initlist '}' - { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); - TREE_HAS_CONSTRUCTOR ($$) = 1; } - | '{' initlist ',' '}' - { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); - TREE_HAS_CONSTRUCTOR ($$) = 1; } - | error - { $$ = NULL_TREE; } - ; - -/* This chain is built in reverse order, - and put in forward order where initlist is used. */ -initlist: - init - { $$ = build_tree_list (NULL_TREE, $$); } - | initlist ',' init - { $$ = tree_cons (NULL_TREE, $3, $$); } - /* These are for labeled elements. */ - | '[' expr_no_commas ']' init - { $$ = build_tree_list ($2, $4); } - | identifier ':' init - { $$ = build_tree_list ($$, $3); } - | initlist ',' identifier ':' init - { $$ = tree_cons ($3, $5, $$); } - ; - -pending_inline: - PRE_PARSED_FUNCTION_DECL maybe_return_init function_body - { - expand_body (finish_function (2)); - process_next_inline ($1); - } - | PRE_PARSED_FUNCTION_DECL maybe_return_init function_try_block - { - expand_body (finish_function (2)); - process_next_inline ($1); - } - | PRE_PARSED_FUNCTION_DECL maybe_return_init error - { - finish_function (2); - process_next_inline ($1); } - ; - -pending_inlines: - /* empty */ - | pending_inlines pending_inline eat_saved_input - ; - -/* A regurgitated default argument. The value of DEFARG_MARKER will be - the TREE_LIST node for the parameter in question. */ -defarg_again: - DEFARG_MARKER expr_no_commas END_OF_SAVED_INPUT - { replace_defarg ($1, $2); } - | DEFARG_MARKER error END_OF_SAVED_INPUT - { replace_defarg ($1, error_mark_node); } - ; - -pending_defargs: - /* empty */ %prec EMPTY - | pending_defargs defarg_again - { do_pending_defargs (); } - | pending_defargs error - { do_pending_defargs (); } - ; - -structsp: - ENUM identifier '{' - { $$ = current_enum_type; - current_enum_type = start_enum ($2); } - enumlist_opt '}' - { $$.t = current_enum_type; - finish_enum (current_enum_type); - $$.new_type_flag = 1; - current_enum_type = $4; - check_for_missing_semicolon ($$.t); } - | ENUM '{' - { $$ = current_enum_type; - current_enum_type = start_enum (make_anon_name ()); } - enumlist_opt '}' - { $$.t = current_enum_type; - finish_enum (current_enum_type); - $$.new_type_flag = 1; - current_enum_type = $3; - check_for_missing_semicolon ($$.t); } - | ENUM identifier - { $$.t = parse_xref_tag (enum_type_node, $2, 1); - $$.new_type_flag = 0; } - | ENUM complex_type_name - { $$.t = parse_xref_tag (enum_type_node, $2, 1); - $$.new_type_flag = 0; } - | TYPENAME_KEYWORD typename_sub - { $$.t = $2; - $$.new_type_flag = 0; - if (!processing_template_decl) - pedwarn ("using `typename' outside of template"); } - /* C++ extensions, merged with C to avoid shift/reduce conflicts */ - | class_head_defn maybe_base_class_list '{' - { - if ($2 && $1.t != error_mark_node) - { - tree type = TREE_TYPE ($1.t); - - if (TREE_CODE (type) == TYPENAME_TYPE) - /* In a definition of a member class template, - we will get here with an implicit typename, - a TYPENAME_TYPE with a type. */ - type = TREE_TYPE (type); - maybe_process_partial_specialization (type); - xref_basetypes (type, $2); - } - $1.t = begin_class_definition (TREE_TYPE ($1.t)); - check_class_key (current_aggr, $1.t); - current_aggr = NULL_TREE; } - opt.component_decl_list '}' maybe_attribute - { - int semi; - tree t; - - if (yychar == YYEMPTY) - yychar = YYLEX; - semi = yychar == ';'; - - t = finish_class_definition ($1.t, $7, semi, $1.new_type_flag); - $$ = t; - - /* restore current_aggr */ - current_aggr = TREE_CODE (t) != RECORD_TYPE - ? union_type_node - : CLASSTYPE_DECLARED_CLASS (t) - ? class_type_node : record_type_node; - } - pending_defargs - { - done_pending_defargs (); - begin_inline_definitions (); - } - pending_inlines - { - $$.t = $8; - $$.new_type_flag = 1; - } - | class_head_decl - { - $$.t = TREE_TYPE ($1.t); - $$.new_type_flag = $1.new_type_flag; - check_class_key (current_aggr, $$.t); - } - ; - -maybecomma: - /* empty */ - | ',' - ; - -maybecomma_warn: - /* empty */ - | ',' - { if (pedantic && !in_system_header) - pedwarn ("comma at end of enumerator list"); } - ; - -aggr: - AGGR - | aggr SCSPEC - { error ("storage class specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); } - | aggr TYPESPEC - { error ("type specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); } - | aggr CV_QUALIFIER - { error ("type qualifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); } - | aggr AGGR - { error ("no body nor ';' separates two class, struct or union declarations"); } - | aggr attributes - { $$ = build_tree_list ($2, $1); } - ; - -class_head: - aggr identifier - { - current_aggr = $1; - $$ = build_tree_list (NULL_TREE, $2); - } - | aggr nested_name_specifier identifier - { - current_aggr = $1; - $$ = build_tree_list ($2, $3); - } - | aggr global_scope nested_name_specifier identifier - { - current_aggr = $1; - $$ = build_tree_list ($3, $4); - } - | aggr global_scope identifier - { - current_aggr = $1; - $$ = build_tree_list (global_namespace, $3); - } - ; - -class_head_apparent_template: - aggr apparent_template_type - { - current_aggr = $1; - $$ = $2; - } - | aggr nested_name_specifier apparent_template_type - { - current_aggr = $1; - $$ = $3; - } - | aggr global_scope nested_name_specifier apparent_template_type - { - current_aggr = $1; - $$ = $4; - } - ; - -class_head_decl: - class_head %prec EMPTY - { - $$.t = parse_handle_class_head (current_aggr, - TREE_PURPOSE ($1), - TREE_VALUE ($1), - 0, &$$.new_type_flag); - } - | aggr identifier_defn %prec EMPTY - { - current_aggr = $1; - $$.t = TYPE_MAIN_DECL (parse_xref_tag (current_aggr, $2, 0)); - $$.new_type_flag = 1; - } - | class_head_apparent_template %prec EMPTY - { - $$.t = $1; - $$.new_type_flag = 0; - } - ; - -class_head_defn: - class_head '{' - { - yyungetc ('{', 1); - $$.t = parse_handle_class_head (current_aggr, - TREE_PURPOSE ($1), - TREE_VALUE ($1), - 1, - &$$.new_type_flag); - } - | class_head ':' - { - yyungetc (':', 1); - $$.t = parse_handle_class_head (current_aggr, - TREE_PURPOSE ($1), - TREE_VALUE ($1), - 1, &$$.new_type_flag); - } - | class_head_apparent_template '{' - { - yyungetc ('{', 1); - $$.t = $1; - $$.new_type_flag = 0; - if (TREE_CODE (TREE_TYPE ($1)) == RECORD_TYPE) - /* We might be specializing a template with a different - class-key. */ - CLASSTYPE_DECLARED_CLASS (TREE_TYPE ($1)) - = (current_aggr == class_type_node); - } - | class_head_apparent_template ':' - { - yyungetc (':', 1); - $$.t = $1; - $$.new_type_flag = 0; - if (TREE_CODE (TREE_TYPE ($1)) == RECORD_TYPE) - /* We might be specializing a template with a different - class-key. */ - CLASSTYPE_DECLARED_CLASS (TREE_TYPE ($1)) - = (current_aggr == class_type_node); - } - | aggr identifier_defn '{' - { - yyungetc ('{', 1); - current_aggr = $1; - $$.t = parse_handle_class_head (current_aggr, - NULL_TREE, $2, - 1, &$$.new_type_flag); - } - | aggr identifier_defn ':' - { - yyungetc (':', 1); - current_aggr = $1; - $$.t = parse_handle_class_head (current_aggr, - NULL_TREE, $2, - 1, &$$.new_type_flag); - } - | aggr '{' - { - current_aggr = $1; - $$.t = TYPE_MAIN_DECL (parse_xref_tag ($1, - make_anon_name (), - 0)); - $$.new_type_flag = 0; - CLASSTYPE_DECLARED_CLASS (TREE_TYPE ($$.t)) - = $1 == class_type_node; - yyungetc ('{', 1); - } - ; - -maybe_base_class_list: - /* empty */ - { $$ = NULL_TREE; } - | ':' see_typename - { error ("no bases given following `:'"); - $$ = NULL_TREE; } - | ':' see_typename base_class_list - { $$ = $3; } - ; - -base_class_list: - base_class - | base_class_list ',' see_typename base_class - { $$ = chainon ($$, $4); } - ; - -base_class: - base_class_1 - { $$ = finish_base_specifier (access_default_node, $1); } - | base_class_access_list see_typename base_class_1 - { $$ = finish_base_specifier ($1, $3); } - ; - -base_class_1: - typename_sub - { if (!TYPE_P ($$)) - $$ = error_mark_node; } - | nonnested_type - { $$ = TREE_TYPE ($$); } - ; - -base_class_access_list: - VISSPEC see_typename - | SCSPEC see_typename - { if ($1 != ridpointers[(int)RID_VIRTUAL]) - error ("`%D' access", $1); - $$ = access_default_virtual_node; } - | base_class_access_list VISSPEC see_typename - { - if ($1 != access_default_virtual_node) - error ("multiple access specifiers"); - else if ($2 == access_public_node) - $$ = access_public_virtual_node; - else if ($2 == access_protected_node) - $$ = access_protected_virtual_node; - else /* $2 == access_private_node */ - $$ = access_private_virtual_node; - } - | base_class_access_list SCSPEC see_typename - { if ($2 != ridpointers[(int)RID_VIRTUAL]) - error ("`%D' access", $2); - else if ($$ == access_public_node) - $$ = access_public_virtual_node; - else if ($$ == access_protected_node) - $$ = access_protected_virtual_node; - else if ($$ == access_private_node) - $$ = access_private_virtual_node; - else - error ("multiple `virtual' specifiers"); - } - ; - -opt.component_decl_list: - | component_decl_list - | opt.component_decl_list access_specifier component_decl_list - | opt.component_decl_list access_specifier - ; - -access_specifier: - VISSPEC ':' - { - current_access_specifier = $1; - } - ; - -/* Note: we no longer warn about the semicolon after a component_decl_list. - ARM $9.2 says that the semicolon is optional, and therefore allowed. */ -component_decl_list: - component_decl - { - finish_member_declaration ($1); - current_aggr = NULL_TREE; - reset_type_access_control (); - } - | component_decl_list component_decl - { - finish_member_declaration ($2); - current_aggr = NULL_TREE; - reset_type_access_control (); - } - ; - -component_decl: - component_decl_1 ';' - | component_decl_1 '}' - { error ("missing ';' before right brace"); - yyungetc ('}', 0); } - /* C++: handle constructors, destructors and inline functions */ - /* note that INLINE is like a TYPESPEC */ - | fn_def2 ':' /* base_init compstmt */ - { $$ = finish_method ($$); } - | fn_def2 TRY /* base_init compstmt */ - { $$ = finish_method ($$); } - | fn_def2 RETURN_KEYWORD /* base_init compstmt */ - { $$ = finish_method ($$); } - | fn_def2 '{' /* nodecls compstmt */ - { $$ = finish_method ($$); } - | ';' - { $$ = NULL_TREE; } - | extension component_decl - { $$ = $2; - pedantic = $1; } - | template_header component_decl - { - if ($2) - $$ = finish_member_template_decl ($2); - else - /* The component was already processed. */ - $$ = NULL_TREE; - - finish_template_decl ($1); - } - | template_header typed_declspecs ';' - { - $$ = finish_member_class_template ($2.t); - finish_template_decl ($1); - } - | bad_decl - { $$ = NULL_TREE; } - ; - -component_decl_1: - /* Do not add a "typed_declspecs declarator" rule here for - speed; we need to call grok_x_components for enums, so the - speedup would be insignificant. */ - typed_declspecs components - { - /* Most of the productions for component_decl only - allow the creation of one new member, so we call - finish_member_declaration in component_decl_list. - For this rule and the next, however, there can be - more than one member, e.g.: - - int i, j; - - and we need the first member to be fully - registered before the second is processed. - Therefore, the rules for components take care of - this processing. To avoid registering the - components more than once, we send NULL_TREE up - here; that lets finish_member_declaration know - that there is nothing to do. */ - if (!$2) - grok_x_components ($1.t); - $$ = NULL_TREE; - } - | declmods notype_components - { - if (!$2) - grok_x_components ($1.t); - $$ = NULL_TREE; - } - | notype_declarator maybeasm maybe_attribute maybe_init - { $$ = grokfield ($$, NULL_TREE, $4, $2, $3); } - | constructor_declarator maybeasm maybe_attribute maybe_init - { $$ = grokfield ($$, NULL_TREE, $4, $2, $3); } - | ':' expr_no_commas - { $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); } - | error - { $$ = NULL_TREE; } - - /* These rules introduce a reduce/reduce conflict; in - typedef int foo, bar; - class A { - foo (bar); - }; - should "A::foo" be declared as a function or "A::bar" as a data - member? In other words, is "bar" an after_type_declarator or a - parmlist? */ - | declmods component_constructor_declarator maybeasm maybe_attribute maybe_init - { tree specs, attrs; - split_specs_attrs ($1.t, &specs, &attrs); - $$ = grokfield ($2, specs, $5, $3, - chainon ($4, attrs)); } - | component_constructor_declarator maybeasm maybe_attribute maybe_init - { $$ = grokfield ($$, NULL_TREE, $4, $2, $3); } - | using_decl - { $$ = do_class_using_decl ($1); } - ; - -/* The case of exactly one component is handled directly by component_decl. */ -/* ??? Huh? ^^^ */ -components: - /* empty: possibly anonymous */ - { $$ = 0; } - | component_declarator0 - { - if (PROCESSING_REAL_TEMPLATE_DECL_P ()) - $1 = finish_member_template_decl ($1); - finish_member_declaration ($1); - $$ = 1; - } - | components ',' component_declarator - { - check_multiple_declarators (); - if (PROCESSING_REAL_TEMPLATE_DECL_P ()) - $3 = finish_member_template_decl ($3); - finish_member_declaration ($3); - $$ = 2; - } - ; - -notype_components: - /* empty: possibly anonymous */ - { $$ = 0; } - | notype_component_declarator0 - { - if (PROCESSING_REAL_TEMPLATE_DECL_P ()) - $1 = finish_member_template_decl ($1); - finish_member_declaration ($1); - $$ = 1; - } - | notype_components ',' notype_component_declarator - { - check_multiple_declarators (); - if (PROCESSING_REAL_TEMPLATE_DECL_P ()) - $3 = finish_member_template_decl ($3); - finish_member_declaration ($3); - $$ = 2; - } - ; - -component_declarator0: - after_type_component_declarator0 - | notype_component_declarator0 - ; - -component_declarator: - after_type_component_declarator - | notype_component_declarator - ; - -after_type_component_declarator0: - after_type_declarator maybeasm maybe_attribute maybe_init - { $$ = parse_field0 ($1, $0.t, $0.lookups, - $3, $2, $4); } - | tTYPENAME ':' expr_no_commas maybe_attribute - { $$ = parse_bitfield0 ($1, $0.t, $0.lookups, - $4, $3); } - ; - -notype_component_declarator0: - notype_declarator maybeasm maybe_attribute maybe_init - { $$ = parse_field0 ($1, $0.t, $0.lookups, - $3, $2, $4); } - | constructor_declarator maybeasm maybe_attribute maybe_init - { $$ = parse_field0 ($1, $0.t, $0.lookups, - $3, $2, $4); } - | IDENTIFIER ':' expr_no_commas maybe_attribute - { $$ = parse_bitfield0 ($1, $0.t, $0.lookups, - $4, $3); } - | ':' expr_no_commas maybe_attribute - { $$ = parse_bitfield0 (NULL_TREE, $0.t, - $0.lookups, $3, $2); } - ; - -after_type_component_declarator: - after_type_declarator maybeasm maybe_attribute maybe_init - { $$ = parse_field ($1, $3, $2, $4); } - | tTYPENAME ':' expr_no_commas maybe_attribute - { $$ = parse_bitfield ($1, $4, $3); } - ; - -notype_component_declarator: - notype_declarator maybeasm maybe_attribute maybe_init - { $$ = parse_field ($1, $3, $2, $4); } - | IDENTIFIER ':' expr_no_commas maybe_attribute - { $$ = parse_bitfield ($1, $4, $3); } - | ':' expr_no_commas maybe_attribute - { $$ = parse_bitfield (NULL_TREE, $3, $2); } - ; - -enumlist_opt: - enumlist maybecomma_warn - | maybecomma_warn - ; - -/* We chain the enumerators in reverse order. - Because of the way enums are built, the order is - insignificant. Take advantage of this fact. */ - -enumlist: - enumerator - | enumlist ',' enumerator - ; - -enumerator: - identifier - { build_enumerator ($1, NULL_TREE, current_enum_type); } - | identifier '=' expr_no_commas - { build_enumerator ($1, $3, current_enum_type); } - ; - -/* ISO new-type-id (5.3.4) */ -new_type_id: - type_specifier_seq new_declarator - { $$.t = build_tree_list ($1.t, $2); - $$.new_type_flag = $1.new_type_flag; } - | type_specifier_seq %prec EMPTY - { $$.t = build_tree_list ($1.t, NULL_TREE); - $$.new_type_flag = $1.new_type_flag; } - /* GNU extension to allow arrays of arbitrary types with - non-constant dimension. */ - | '(' type_id ')' '[' expr ']' - { - if (pedantic) - pedwarn ("ISO C++ forbids array dimensions with parenthesized type in new"); - $$.t = build_nt (ARRAY_REF, TREE_VALUE ($2.t), $5); - $$.t = build_tree_list (TREE_PURPOSE ($2.t), $$.t); - $$.new_type_flag = $2.new_type_flag; - } - ; - -cv_qualifiers: - /* empty */ %prec EMPTY - { $$ = NULL_TREE; } - | cv_qualifiers CV_QUALIFIER - { $$ = tree_cons (NULL_TREE, $2, $$); } - ; - -nonempty_cv_qualifiers: - CV_QUALIFIER - { $$.t = hash_tree_cons (NULL_TREE, $1, NULL_TREE); - $$.new_type_flag = 0; } - | nonempty_cv_qualifiers CV_QUALIFIER - { $$.t = hash_tree_cons (NULL_TREE, $2, $1.t); - $$.new_type_flag = $1.new_type_flag; } - | attributes %prec EMPTY - { $$.t = hash_tree_cons ($1, NULL_TREE, NULL_TREE); - $$.new_type_flag = 0; } - | nonempty_cv_qualifiers attributes %prec EMPTY - { $$.t = hash_tree_cons ($2, NULL_TREE, $1.t); - $$.new_type_flag = $1.new_type_flag; } - ; - -/* These rules must follow the rules for function declarations - and component declarations. That way, longer rules are preferred. */ - -/* An expression which will not live on the momentary obstack. */ -maybe_parmlist: - '(' nonnull_exprlist ')' - { $$ = $2; } - | '(' parmlist ')' - { $$ = $2; } - | LEFT_RIGHT - { $$ = empty_parms (); } - | '(' error ')' - { $$ = NULL_TREE; } - ; - -/* A declarator that is allowed only after an explicit typespec. */ - -after_type_declarator_intern: - after_type_declarator - | attributes after_type_declarator - { - /* Provide support for '(' attributes '*' declarator ')' - etc */ - $$ = tree_cons ($1, $2, NULL_TREE); - } - ; - -/* may all be followed by prec '.' */ -after_type_declarator: - '*' nonempty_cv_qualifiers after_type_declarator_intern %prec UNARY - { $$ = make_pointer_declarator ($2.t, $3); } - | '&' nonempty_cv_qualifiers after_type_declarator_intern %prec UNARY - { $$ = make_reference_declarator ($2.t, $3); } - | '*' after_type_declarator_intern %prec UNARY - { $$ = make_pointer_declarator (NULL_TREE, $2); } - | '&' after_type_declarator_intern %prec UNARY - { $$ = make_reference_declarator (NULL_TREE, $2); } - | ptr_to_mem cv_qualifiers after_type_declarator_intern - { tree arg = make_pointer_declarator ($2, $3); - $$ = build_nt (SCOPE_REF, $1, arg); - } - | direct_after_type_declarator - ; - -direct_after_type_declarator: - direct_after_type_declarator maybe_parmlist cv_qualifiers exception_specification_opt %prec '.' - { $$ = make_call_declarator ($$, $2, $3, $4); } - | direct_after_type_declarator '[' expr ']' - { $$ = build_nt (ARRAY_REF, $$, $3); } - | direct_after_type_declarator '[' ']' - { $$ = build_nt (ARRAY_REF, $$, NULL_TREE); } - | '(' after_type_declarator_intern ')' - { $$ = $2; } - | nested_name_specifier type_name %prec EMPTY - { push_nested_class ($1, 3); - $$ = build_nt (SCOPE_REF, $$, $2); - TREE_COMPLEXITY ($$) = current_class_depth; } - | type_name %prec EMPTY - ; - -nonnested_type: - type_name %prec EMPTY - { - if (TREE_CODE ($1) == IDENTIFIER_NODE) - { - $$ = lookup_name ($1, 1); - maybe_note_name_used_in_class ($1, $$); - } - else - $$ = $1; - } - | global_scope type_name - { - if (TREE_CODE ($2) == IDENTIFIER_NODE) - $$ = IDENTIFIER_GLOBAL_VALUE ($2); - else - $$ = $2; - got_scope = NULL_TREE; - } - ; - -complete_type_name: - nonnested_type - | nested_type - | global_scope nested_type - { $$ = $2; } - ; - -nested_type: - nested_name_specifier type_name %prec EMPTY - { $$ = get_type_decl ($2); } - ; - -/* A declarator allowed whether or not there has been - an explicit typespec. These cannot redeclare a typedef-name. */ - -notype_declarator_intern: - notype_declarator - | attributes notype_declarator - { - /* Provide support for '(' attributes '*' declarator ')' - etc */ - $$ = tree_cons ($1, $2, NULL_TREE); - } - ; - -notype_declarator: - '*' nonempty_cv_qualifiers notype_declarator_intern %prec UNARY - { $$ = make_pointer_declarator ($2.t, $3); } - | '&' nonempty_cv_qualifiers notype_declarator_intern %prec UNARY - { $$ = make_reference_declarator ($2.t, $3); } - | '*' notype_declarator_intern %prec UNARY - { $$ = make_pointer_declarator (NULL_TREE, $2); } - | '&' notype_declarator_intern %prec UNARY - { $$ = make_reference_declarator (NULL_TREE, $2); } - | ptr_to_mem cv_qualifiers notype_declarator_intern - { tree arg = make_pointer_declarator ($2, $3); - $$ = build_nt (SCOPE_REF, $1, arg); - } - | direct_notype_declarator - ; - -complex_notype_declarator: - '*' nonempty_cv_qualifiers notype_declarator_intern %prec UNARY - { $$ = make_pointer_declarator ($2.t, $3); } - | '&' nonempty_cv_qualifiers notype_declarator_intern %prec UNARY - { $$ = make_reference_declarator ($2.t, $3); } - | '*' complex_notype_declarator %prec UNARY - { $$ = make_pointer_declarator (NULL_TREE, $2); } - | '&' complex_notype_declarator %prec UNARY - { $$ = make_reference_declarator (NULL_TREE, $2); } - | ptr_to_mem cv_qualifiers notype_declarator_intern - { tree arg = make_pointer_declarator ($2, $3); - $$ = build_nt (SCOPE_REF, $1, arg); - } - | complex_direct_notype_declarator - ; - -complex_direct_notype_declarator: - direct_notype_declarator maybe_parmlist cv_qualifiers exception_specification_opt %prec '.' - { $$ = make_call_declarator ($$, $2, $3, $4); } - | '(' complex_notype_declarator ')' - { $$ = $2; } - | direct_notype_declarator '[' expr ']' - { $$ = build_nt (ARRAY_REF, $$, $3); } - | direct_notype_declarator '[' ']' - { $$ = build_nt (ARRAY_REF, $$, NULL_TREE); } - | notype_qualified_id - { enter_scope_of ($1); } - | global_scope notype_qualified_id - { enter_scope_of ($2); $$ = $2;} - | global_scope notype_unqualified_id - { $$ = build_nt (SCOPE_REF, global_namespace, $2); - enter_scope_of ($$); - } - | nested_name_specifier notype_template_declarator - { got_scope = NULL_TREE; - $$ = build_nt (SCOPE_REF, $1, $2); - enter_scope_of ($$); - } - ; - -qualified_id: - nested_name_specifier unqualified_id - { got_scope = NULL_TREE; - $$ = build_nt (SCOPE_REF, $$, $2); } - | nested_name_specifier object_template_id - { got_scope = NULL_TREE; - $$ = build_nt (SCOPE_REF, $1, $2); } - ; - -notype_qualified_id: - nested_name_specifier notype_unqualified_id - { got_scope = NULL_TREE; - $$ = build_nt (SCOPE_REF, $$, $2); } - | nested_name_specifier object_template_id - { got_scope = NULL_TREE; - $$ = build_nt (SCOPE_REF, $1, $2); } - ; - -overqualified_id: - notype_qualified_id - | global_scope notype_qualified_id - { $$ = $2; } - ; - -functional_cast: - typespec '(' nonnull_exprlist ')' - { $$ = build_functional_cast ($1.t, $3); } - | typespec '(' expr_or_declarator_intern ')' - { $$ = reparse_decl_as_expr ($1.t, $3); } - | typespec fcast_or_absdcl %prec EMPTY - { $$ = reparse_absdcl_as_expr ($1.t, $2); } - ; - -type_name: - tTYPENAME - | SELFNAME - | template_type %prec EMPTY - ; - -nested_name_specifier: - nested_name_specifier_1 - | nested_name_specifier nested_name_specifier_1 - { $$ = $2; } - | nested_name_specifier TEMPLATE explicit_template_type SCOPE - { got_scope = $$ - = make_typename_type ($1, $3, tf_error | tf_parsing); } - /* Error handling per Core 125. */ - | nested_name_specifier IDENTIFIER SCOPE - { got_scope = $$ - = make_typename_type ($1, $2, tf_error | tf_parsing); } - | nested_name_specifier PTYPENAME SCOPE - { got_scope = $$ - = make_typename_type ($1, $2, tf_error | tf_parsing); } - ; - -/* Why the @#$%^& do type_name and notype_identifier need to be expanded - inline here?!? (jason) */ -nested_name_specifier_1: - tTYPENAME SCOPE - { - if (TREE_CODE ($1) == IDENTIFIER_NODE) - { - $$ = lastiddecl; - maybe_note_name_used_in_class ($1, $$); - } - got_scope = $$ = - complete_type (TYPE_MAIN_VARIANT (TREE_TYPE ($$))); - } - | SELFNAME SCOPE - { - if (TREE_CODE ($1) == IDENTIFIER_NODE) - $$ = lastiddecl; - got_scope = $$ = TREE_TYPE ($$); - } - | NSNAME SCOPE - { - if (TREE_CODE ($$) == IDENTIFIER_NODE) - $$ = lastiddecl; - got_scope = $$; - } - | template_type SCOPE - { got_scope = $$ = complete_type (TREE_TYPE ($1)); } - ; - -typename_sub: - typename_sub0 - | global_scope typename_sub0 - { $$ = $2; } - ; - -typename_sub0: - typename_sub1 identifier %prec EMPTY - { - if (TYPE_P ($1)) - $$ = make_typename_type ($1, $2, tf_error | tf_parsing); - else if (TREE_CODE ($2) == IDENTIFIER_NODE) - error ("`%T' is not a class or namespace", $2); - else - { - $$ = $2; - if (TREE_CODE ($$) == TYPE_DECL) - $$ = TREE_TYPE ($$); - } - } - | typename_sub1 template_type %prec EMPTY - { $$ = TREE_TYPE ($2); } - | typename_sub1 explicit_template_type %prec EMPTY - { $$ = make_typename_type ($1, $2, tf_error | tf_parsing); } - | typename_sub1 TEMPLATE explicit_template_type %prec EMPTY - { $$ = make_typename_type ($1, $3, tf_error | tf_parsing); } - ; - -typename_sub1: - typename_sub2 - { - if (TREE_CODE ($1) == IDENTIFIER_NODE) - error ("`%T' is not a class or namespace", $1); - else if (TREE_CODE ($1) == TYPE_DECL) - $$ = TREE_TYPE ($1); - } - | typename_sub1 typename_sub2 - { - if (TYPE_P ($1)) - $$ = make_typename_type ($1, $2, tf_error | tf_parsing); - else if (TREE_CODE ($2) == IDENTIFIER_NODE) - error ("`%T' is not a class or namespace", $2); - else - { - $$ = $2; - if (TREE_CODE ($$) == TYPE_DECL) - $$ = TREE_TYPE ($$); - } - } - | typename_sub1 explicit_template_type SCOPE - { got_scope = $$ - = make_typename_type ($1, $2, tf_error | tf_parsing); } - | typename_sub1 TEMPLATE explicit_template_type SCOPE - { got_scope = $$ - = make_typename_type ($1, $3, tf_error | tf_parsing); } - ; - -/* This needs to return a TYPE_DECL for simple names so that we don't - forget what name was used. */ -typename_sub2: - tTYPENAME SCOPE - { - if (TREE_CODE ($1) != TYPE_DECL) - $$ = lastiddecl; - - /* Retrieve the type for the identifier, which might involve - some computation. */ - got_scope = complete_type (TREE_TYPE ($$)); - - if ($$ == error_mark_node) - error ("`%T' is not a class or namespace", $1); - } - | SELFNAME SCOPE - { - if (TREE_CODE ($1) != TYPE_DECL) - $$ = lastiddecl; - got_scope = complete_type (TREE_TYPE ($$)); - } - | template_type SCOPE - { got_scope = $$ = complete_type (TREE_TYPE ($$)); } - | PTYPENAME SCOPE - | IDENTIFIER SCOPE - | NSNAME SCOPE - { - if (TREE_CODE ($$) == IDENTIFIER_NODE) - $$ = lastiddecl; - got_scope = $$; - } - ; - -explicit_template_type: - identifier '<' template_arg_list_opt template_close_bracket - { $$ = build_min_nt (TEMPLATE_ID_EXPR, $1, $3); } - ; - -complex_type_name: - global_scope type_name - { - if (TREE_CODE ($2) == IDENTIFIER_NODE) - $$ = IDENTIFIER_GLOBAL_VALUE ($2); - else - $$ = $2; - got_scope = NULL_TREE; - } - | nested_type - | global_scope nested_type - { $$ = $2; } - ; - -ptr_to_mem: - nested_name_specifier '*' - { got_scope = NULL_TREE; } - | global_scope nested_name_specifier '*' - { $$ = $2; got_scope = NULL_TREE; } - ; - -/* All uses of explicit global scope must go through this nonterminal so - that got_scope will be set before yylex is called to get the next token. */ -global_scope: - SCOPE - { got_scope = void_type_node; } - ; - -/* ISO new-declarator (5.3.4) */ -new_declarator: - '*' cv_qualifiers new_declarator - { $$ = make_pointer_declarator ($2, $3); } - | '*' cv_qualifiers %prec EMPTY - { $$ = make_pointer_declarator ($2, NULL_TREE); } - | '&' cv_qualifiers new_declarator %prec EMPTY - { $$ = make_reference_declarator ($2, $3); } - | '&' cv_qualifiers %prec EMPTY - { $$ = make_reference_declarator ($2, NULL_TREE); } - | ptr_to_mem cv_qualifiers %prec EMPTY - { tree arg = make_pointer_declarator ($2, NULL_TREE); - $$ = build_nt (SCOPE_REF, $1, arg); - } - | ptr_to_mem cv_qualifiers new_declarator - { tree arg = make_pointer_declarator ($2, $3); - $$ = build_nt (SCOPE_REF, $1, arg); - } - | direct_new_declarator %prec EMPTY - ; - -/* ISO direct-new-declarator (5.3.4) */ -direct_new_declarator: - '[' expr ']' - { $$ = build_nt (ARRAY_REF, NULL_TREE, $2); } - | direct_new_declarator '[' expr ']' - { $$ = build_nt (ARRAY_REF, $$, $3); } - ; - -absdcl_intern: - absdcl - | attributes absdcl - { - /* Provide support for '(' attributes '*' declarator ')' - etc */ - $$ = tree_cons ($1, $2, NULL_TREE); - } - ; - -/* ISO abstract-declarator (8.1) */ -absdcl: - '*' nonempty_cv_qualifiers absdcl_intern - { $$ = make_pointer_declarator ($2.t, $3); } - | '*' absdcl_intern - { $$ = make_pointer_declarator (NULL_TREE, $2); } - | '*' nonempty_cv_qualifiers %prec EMPTY - { $$ = make_pointer_declarator ($2.t, NULL_TREE); } - | '*' %prec EMPTY - { $$ = make_pointer_declarator (NULL_TREE, NULL_TREE); } - | '&' nonempty_cv_qualifiers absdcl_intern - { $$ = make_reference_declarator ($2.t, $3); } - | '&' absdcl_intern - { $$ = make_reference_declarator (NULL_TREE, $2); } - | '&' nonempty_cv_qualifiers %prec EMPTY - { $$ = make_reference_declarator ($2.t, NULL_TREE); } - | '&' %prec EMPTY - { $$ = make_reference_declarator (NULL_TREE, NULL_TREE); } - | ptr_to_mem cv_qualifiers %prec EMPTY - { tree arg = make_pointer_declarator ($2, NULL_TREE); - $$ = build_nt (SCOPE_REF, $1, arg); - } - | ptr_to_mem cv_qualifiers absdcl_intern - { tree arg = make_pointer_declarator ($2, $3); - $$ = build_nt (SCOPE_REF, $1, arg); - } - | direct_abstract_declarator %prec EMPTY - ; - -/* ISO direct-abstract-declarator (8.1) */ -direct_abstract_declarator: - '(' absdcl_intern ')' - { $$ = $2; } - /* `(typedef)1' is `int'. */ - | direct_abstract_declarator '(' parmlist ')' cv_qualifiers exception_specification_opt %prec '.' - { $$ = make_call_declarator ($$, $3, $5, $6); } - | direct_abstract_declarator LEFT_RIGHT cv_qualifiers exception_specification_opt %prec '.' - { $$ = make_call_declarator ($$, empty_parms (), $3, $4); } - | direct_abstract_declarator '[' expr ']' %prec '.' - { $$ = build_nt (ARRAY_REF, $$, $3); } - | direct_abstract_declarator '[' ']' %prec '.' - { $$ = build_nt (ARRAY_REF, $$, NULL_TREE); } - | '(' complex_parmlist ')' cv_qualifiers exception_specification_opt %prec '.' - { $$ = make_call_declarator (NULL_TREE, $2, $4, $5); } - | regcast_or_absdcl cv_qualifiers exception_specification_opt %prec '.' - { set_quals_and_spec ($$, $2, $3); } - | fcast_or_absdcl cv_qualifiers exception_specification_opt %prec '.' - { set_quals_and_spec ($$, $2, $3); } - | '[' expr ']' %prec '.' - { $$ = build_nt (ARRAY_REF, NULL_TREE, $2); } - | '[' ']' %prec '.' - { $$ = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); } - ; - -/* For C++, decls and stmts can be intermixed, so we don't need to - have a special rule that won't start parsing the stmt section - until we have a stmt that parses without errors. */ - -stmts: - stmt - | errstmt - | stmts stmt - | stmts errstmt - ; - -errstmt: - error ';' - ; - -/* Read zero or more forward-declarations for labels - that nested functions can jump to. */ -maybe_label_decls: - /* empty */ - | label_decls - { if (pedantic) - pedwarn ("ISO C++ forbids label declarations"); } - ; - -label_decls: - label_decl - | label_decls label_decl - ; - -label_decl: - LABEL identifiers_or_typenames ';' - { - while ($2) - { - finish_label_decl (TREE_VALUE ($2)); - $2 = TREE_CHAIN ($2); - } - } - ; - -compstmt_or_stmtexpr: - save_lineno '{' - { $$ = begin_compound_stmt (0); } - compstmtend - { STMT_LINENO ($3) = $1; - finish_compound_stmt (0, $3); } - ; - -compstmt: - compstmt_or_stmtexpr - { last_expr_type = NULL_TREE; } - ; - -simple_if: - IF - { $$ = begin_if_stmt (); - cond_stmt_keyword = "if"; } - paren_cond_or_null - { finish_if_stmt_cond ($3, $2); } - implicitly_scoped_stmt - { $$ = $2; - finish_then_clause ($2); } - ; - -implicitly_scoped_stmt: - compstmt - | - { $$ = begin_compound_stmt (0); } - save_lineno simple_stmt - { STMT_LINENO ($1) = $2; - if ($3) STMT_LINENO ($3) = $2; - finish_compound_stmt (0, $1); } - ; - -stmt: - compstmt - | save_lineno simple_stmt - { if ($2) STMT_LINENO ($2) = $1; } - ; - -simple_stmt: - decl - { finish_stmt (); - $$ = NULL_TREE; } - | expr ';' - { $$ = finish_expr_stmt ($1); } - | simple_if ELSE - { begin_else_clause (); } - implicitly_scoped_stmt - { - $$ = $1; - finish_else_clause ($1); - finish_if_stmt (); - } - | simple_if %prec IF - { $$ = $1; - finish_if_stmt (); } - | WHILE - { - $$ = begin_while_stmt (); - cond_stmt_keyword = "while"; - } - paren_cond_or_null - { finish_while_stmt_cond ($3, $2); } - implicitly_scoped_stmt - { $$ = $2; - finish_while_stmt ($2); } - | DO - { $$ = begin_do_stmt (); } - implicitly_scoped_stmt WHILE - { - finish_do_body ($2); - cond_stmt_keyword = "do"; - } - paren_expr_or_null ';' - { $$ = $2; - finish_do_stmt ($6, $2); } - | FOR - { $$ = begin_for_stmt (); } - '(' for.init.statement - { finish_for_init_stmt ($2); } - xcond ';' - { finish_for_cond ($6, $2); } - xexpr ')' - { finish_for_expr ($9, $2); } - implicitly_scoped_stmt - { $$ = $2; - finish_for_stmt ($2); } - | SWITCH - { $$ = begin_switch_stmt (); } - '(' condition ')' - { finish_switch_cond ($4, $2); } - implicitly_scoped_stmt - { $$ = $2; - finish_switch_stmt ($2); } - | CASE expr_no_commas ':' - { $$ = finish_case_label ($2, NULL_TREE); } - stmt - { $$ = $4; } - | CASE expr_no_commas ELLIPSIS expr_no_commas ':' - { $$ = finish_case_label ($2, $4); } - stmt - { $$ = $6; } - | DEFAULT ':' - { $$ = finish_case_label (NULL_TREE, NULL_TREE); } - stmt - { $$ = $3; } - | BREAK ';' - { $$ = finish_break_stmt (); } - | CONTINUE ';' - { $$ = finish_continue_stmt (); } - | RETURN_KEYWORD ';' - { $$ = finish_return_stmt (NULL_TREE); } - | RETURN_KEYWORD expr ';' - { $$ = finish_return_stmt ($2); } - | asm_keyword maybe_cv_qualifier '(' STRING ')' ';' - { $$ = finish_asm_stmt ($2, $4, NULL_TREE, NULL_TREE, - NULL_TREE); - ASM_INPUT_P ($$) = 1; } - /* This is the case with just output operands. */ - | asm_keyword maybe_cv_qualifier '(' STRING ':' asm_operands ')' ';' - { $$ = finish_asm_stmt ($2, $4, $6, NULL_TREE, NULL_TREE); } - /* This is the case with input operands as well. */ - | asm_keyword maybe_cv_qualifier '(' STRING ':' asm_operands ':' - asm_operands ')' ';' - { $$ = finish_asm_stmt ($2, $4, $6, $8, NULL_TREE); } - | asm_keyword maybe_cv_qualifier '(' STRING SCOPE asm_operands ')' ';' - { $$ = finish_asm_stmt ($2, $4, NULL_TREE, $6, NULL_TREE); } - /* This is the case with clobbered registers as well. */ - | asm_keyword maybe_cv_qualifier '(' STRING ':' asm_operands ':' - asm_operands ':' asm_clobbers ')' ';' - { $$ = finish_asm_stmt ($2, $4, $6, $8, $10); } - | asm_keyword maybe_cv_qualifier '(' STRING SCOPE asm_operands ':' - asm_clobbers ')' ';' - { $$ = finish_asm_stmt ($2, $4, NULL_TREE, $6, $8); } - | asm_keyword maybe_cv_qualifier '(' STRING ':' asm_operands SCOPE - asm_clobbers ')' ';' - { $$ = finish_asm_stmt ($2, $4, $6, NULL_TREE, $8); } - | GOTO '*' expr ';' - { - if (pedantic) - pedwarn ("ISO C++ forbids computed gotos"); - $$ = finish_goto_stmt ($3); - } - | GOTO identifier ';' - { $$ = finish_goto_stmt ($2); } - | label_colon stmt - { $$ = NULL_TREE; } - | label_colon '}' - { error ("label must be followed by statement"); - yyungetc ('}', 0); - $$ = NULL_TREE; } - | ';' - { finish_stmt (); - $$ = NULL_TREE; } - | try_block - { $$ = NULL_TREE; } - | using_directive - { $$ = NULL_TREE; } - | namespace_using_decl - { do_local_using_decl ($1); - $$ = NULL_TREE; } - | namespace_alias - { $$ = NULL_TREE; } - ; - -function_try_block: - TRY - { $$ = begin_function_try_block (); } - function_body - { finish_function_try_block ($2); } - handler_seq - { finish_function_handler_sequence ($2); } - ; - -try_block: - TRY - { $$ = begin_try_block (); } - compstmt - { finish_try_block ($2); } - handler_seq - { finish_handler_sequence ($2); } - ; - -handler_seq: - handler - | handler_seq handler - | /* empty */ - { /* Generate a fake handler block to avoid later aborts. */ - tree fake_handler = begin_handler (); - finish_handler_parms (NULL_TREE, fake_handler); - finish_handler (fake_handler); - $$ = fake_handler; - - error ("must have at least one catch per try block"); - } - ; - -handler: - CATCH - { $$ = begin_handler (); } - handler_args - { finish_handler_parms ($3, $2); } - compstmt - { finish_handler ($2); } - ; - -type_specifier_seq: - typed_typespecs %prec EMPTY - | nonempty_cv_qualifiers %prec EMPTY - ; - -handler_args: - '(' ELLIPSIS ')' - { $$ = NULL_TREE; } - /* This doesn't allow reference parameters, the below does. - | '(' type_specifier_seq absdcl ')' - { check_for_new_type ("inside exception declarations", $2); - expand_start_catch_block ($2.t, $3); } - | '(' type_specifier_seq ')' - { check_for_new_type ("inside exception declarations", $2); - expand_start_catch_block ($2.t, NULL_TREE); } - | '(' type_specifier_seq notype_declarator ')' - { check_for_new_type ("inside exception declarations", $2); - expand_start_catch_block ($2.t, $3); } - | '(' typed_typespecs after_type_declarator ')' - { check_for_new_type ("inside exception declarations", $2); - expand_start_catch_block ($2.t, $3); } - This allows reference parameters... */ - | '(' parm ')' - { - check_for_new_type ("inside exception declarations", $2); - $$ = start_handler_parms (TREE_PURPOSE ($2.t), - TREE_VALUE ($2.t)); - } - ; - -label_colon: - IDENTIFIER ':' - { finish_label_stmt ($1); } - | PTYPENAME ':' - { finish_label_stmt ($1); } - | tTYPENAME ':' - { finish_label_stmt ($1); } - | SELFNAME ':' - { finish_label_stmt ($1); } - ; - -for.init.statement: - xexpr ';' - { finish_expr_stmt ($1); } - | decl - | '{' compstmtend - { if (pedantic) - pedwarn ("ISO C++ forbids compound statements inside for initializations"); - } - ; - -/* Either a type-qualifier or nothing. First thing in an `asm' statement. */ - -maybe_cv_qualifier: - /* empty */ - { $$ = NULL_TREE; } - | CV_QUALIFIER - ; - -xexpr: - /* empty */ - { $$ = NULL_TREE; } - | expr - | error - { $$ = NULL_TREE; } - ; - -/* These are the operands other than the first string and colon - in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */ -asm_operands: - /* empty */ - { $$ = NULL_TREE; } - | nonnull_asm_operands - ; - -nonnull_asm_operands: - asm_operand - | nonnull_asm_operands ',' asm_operand - { $$ = chainon ($$, $3); } - ; - -asm_operand: - STRING '(' expr ')' - { $$ = build_tree_list (build_tree_list (NULL_TREE, $1), $3); } - | '[' identifier ']' STRING '(' expr ')' - { $2 = build_string (IDENTIFIER_LENGTH ($2), - IDENTIFIER_POINTER ($2)); - $$ = build_tree_list (build_tree_list ($2, $4), $6); } - ; - -asm_clobbers: - STRING - { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);} - | asm_clobbers ',' STRING - { $$ = tree_cons (NULL_TREE, $3, $1); } - ; - -/* This is what appears inside the parens in a function declarator. - Its value is represented in the format that grokdeclarator expects. - - In C++, declaring a function with no parameters - means that that function takes *no* parameters. */ - -parmlist: - /* empty */ - { - $$ = empty_parms(); - } - | complex_parmlist - | type_id - { $$ = finish_parmlist (build_tree_list (NULL_TREE, $1.t), 0); - check_for_new_type ("inside parameter list", $1); } - ; - -/* This nonterminal does not include the common sequence '(' type_id ')', - as it is ambiguous and must be disambiguated elsewhere. */ -complex_parmlist: - parms - { $$ = finish_parmlist ($$, 0); } - | parms_comma ELLIPSIS - { $$ = finish_parmlist ($1, 1); } - /* C++ allows an ellipsis without a separating ',' */ - | parms ELLIPSIS - { $$ = finish_parmlist ($1, 1); } - | type_id ELLIPSIS - { $$ = finish_parmlist (build_tree_list (NULL_TREE, - $1.t), 1); } - | ELLIPSIS - { $$ = finish_parmlist (NULL_TREE, 1); } - | parms ':' - { - /* This helps us recover from really nasty - parse errors, for example, a missing right - parenthesis. */ - yyerror ("possibly missing ')'"); - $$ = finish_parmlist ($1, 0); - yyungetc (':', 0); - yychar = ')'; - } - | type_id ':' - { - /* This helps us recover from really nasty - parse errors, for example, a missing right - parenthesis. */ - yyerror ("possibly missing ')'"); - $$ = finish_parmlist (build_tree_list (NULL_TREE, - $1.t), 0); - yyungetc (':', 0); - yychar = ')'; - } - ; - -/* A default argument to a */ -defarg: - '=' - { maybe_snarf_defarg (); } - defarg1 - { $$ = $3; } - ; - -defarg1: - DEFARG - | init - ; - -/* A nonempty list of parameter declarations or type names. */ -parms: - named_parm - { check_for_new_type ("in a parameter list", $1); - $$ = build_tree_list (NULL_TREE, $1.t); } - | parm defarg - { check_for_new_type ("in a parameter list", $1); - $$ = build_tree_list ($2, $1.t); } - | parms_comma full_parm - { check_for_new_type ("in a parameter list", $2); - $$ = chainon ($$, $2.t); } - | parms_comma bad_parm - { $$ = chainon ($$, build_tree_list (NULL_TREE, $2)); } - | parms_comma bad_parm '=' init - { $$ = chainon ($$, build_tree_list ($4, $2)); } - ; - -parms_comma: - parms ',' - | type_id ',' - { check_for_new_type ("in a parameter list", $1); - $$ = build_tree_list (NULL_TREE, $1.t); } - ; - -/* A single parameter declaration or parameter type name, - as found in a parmlist. */ -named_parm: - /* Here we expand typed_declspecs inline to avoid mis-parsing of - TYPESPEC IDENTIFIER. */ - typed_declspecs1 declarator - { $$.new_type_flag = $1.new_type_flag; - $$.t = build_tree_list ($1.t, $2); } - | typed_typespecs declarator - { $$.t = build_tree_list ($1.t, $2); - $$.new_type_flag = $1.new_type_flag; } - | typespec declarator - { $$.t = build_tree_list (build_tree_list (NULL_TREE, $1.t), - $2); - $$.new_type_flag = $1.new_type_flag; } - | typed_declspecs1 absdcl - { $$.t = build_tree_list ($1.t, $2); - $$.new_type_flag = $1.new_type_flag; } - | typed_declspecs1 %prec EMPTY - { $$.t = build_tree_list ($1.t, NULL_TREE); - $$.new_type_flag = $1.new_type_flag; } - | declmods notype_declarator - { $$.t = build_tree_list ($1.t, $2); - $$.new_type_flag = 0; } - ; - -full_parm: - parm - { $$.t = build_tree_list (NULL_TREE, $1.t); - $$.new_type_flag = $1.new_type_flag; } - | parm defarg - { $$.t = build_tree_list ($2, $1.t); - $$.new_type_flag = $1.new_type_flag; } - ; - -parm: - named_parm - | type_id - ; - -see_typename: - /* empty */ %prec EMPTY - { see_typename (); } - ; - -bad_parm: - /* empty */ %prec EMPTY - { - error ("type specifier omitted for parameter"); - $$ = build_tree_list (integer_type_node, NULL_TREE); - } - | notype_declarator - { - if (TREE_CODE ($$) == SCOPE_REF) - { - if (TREE_CODE (TREE_OPERAND ($$, 0)) == TEMPLATE_TYPE_PARM - || TREE_CODE (TREE_OPERAND ($$, 0)) == BOUND_TEMPLATE_TEMPLATE_PARM) - error ("`%E' is not a type, use `typename %E' to make it one", $$); - else - error ("no type `%D' in `%T'", TREE_OPERAND ($$, 1), TREE_OPERAND ($$, 0)); - } - else - error ("type specifier omitted for parameter `%E'", $$); - $$ = build_tree_list (integer_type_node, $$); - } - ; - -bad_decl: - IDENTIFIER template_arg_list_ignore IDENTIFIER arg_list_ignore ';' - { - error("'%D' is used as a type, but is not defined as a type.", $1); - $3 = error_mark_node; - } - ; - -template_arg_list_ignore: - '<' template_arg_list_opt template_close_bracket - { } - | /* empty */ - ; - -arg_list_ignore: - '(' nonnull_exprlist ')' - { } - | /* empty */ - ; - -exception_specification_opt: - /* empty */ %prec EMPTY - { $$ = NULL_TREE; } - | THROW '(' ansi_raise_identifiers ')' %prec EMPTY - { $$ = $3; } - | THROW LEFT_RIGHT %prec EMPTY - { $$ = empty_except_spec; } - ; - -ansi_raise_identifier: - type_id - { - check_for_new_type ("exception specifier", $1); - $$ = groktypename ($1.t); - } - | error - { $$ = error_mark_node; } - ; - -ansi_raise_identifiers: - ansi_raise_identifier - { $$ = add_exception_specifier (NULL_TREE, $1, 1); } - | ansi_raise_identifiers ',' ansi_raise_identifier - { $$ = add_exception_specifier ($1, $3, 1); } - ; - -conversion_declarator: - /* empty */ %prec EMPTY - { $$ = NULL_TREE; } - | '*' cv_qualifiers conversion_declarator - { $$ = make_pointer_declarator ($2, $3); } - | '&' cv_qualifiers conversion_declarator - { $$ = make_reference_declarator ($2, $3); } - | ptr_to_mem cv_qualifiers conversion_declarator - { tree arg = make_pointer_declarator ($2, $3); - $$ = build_nt (SCOPE_REF, $1, arg); - } - ; - -operator: - OPERATOR - { - saved_scopes = tree_cons (got_scope, got_object, saved_scopes); - TREE_LANG_FLAG_0 (saved_scopes) = looking_for_typename; - /* We look for conversion-type-id's in both the class and current - scopes, just as for ID in 'ptr->ID::'. */ - looking_for_typename = 1; - got_object = got_scope; - got_scope = NULL_TREE; - } - ; - -unoperator: - { got_scope = TREE_PURPOSE (saved_scopes); - got_object = TREE_VALUE (saved_scopes); - looking_for_typename = TREE_LANG_FLAG_0 (saved_scopes); - saved_scopes = TREE_CHAIN (saved_scopes); - $$ = got_scope; - } - ; - -operator_name: - operator '*' unoperator - { $$ = frob_opname (ansi_opname (MULT_EXPR)); } - | operator '/' unoperator - { $$ = frob_opname (ansi_opname (TRUNC_DIV_EXPR)); } - | operator '%' unoperator - { $$ = frob_opname (ansi_opname (TRUNC_MOD_EXPR)); } - | operator '+' unoperator - { $$ = frob_opname (ansi_opname (PLUS_EXPR)); } - | operator '-' unoperator - { $$ = frob_opname (ansi_opname (MINUS_EXPR)); } - | operator '&' unoperator - { $$ = frob_opname (ansi_opname (BIT_AND_EXPR)); } - | operator '|' unoperator - { $$ = frob_opname (ansi_opname (BIT_IOR_EXPR)); } - | operator '^' unoperator - { $$ = frob_opname (ansi_opname (BIT_XOR_EXPR)); } - | operator '~' unoperator - { $$ = frob_opname (ansi_opname (BIT_NOT_EXPR)); } - | operator ',' unoperator - { $$ = frob_opname (ansi_opname (COMPOUND_EXPR)); } - | operator ARITHCOMPARE unoperator - { $$ = frob_opname (ansi_opname ($2)); } - | operator '<' unoperator - { $$ = frob_opname (ansi_opname (LT_EXPR)); } - | operator '>' unoperator - { $$ = frob_opname (ansi_opname (GT_EXPR)); } - | operator EQCOMPARE unoperator - { $$ = frob_opname (ansi_opname ($2)); } - | operator ASSIGN unoperator - { $$ = frob_opname (ansi_assopname ($2)); } - | operator '=' unoperator - { $$ = frob_opname (ansi_assopname (NOP_EXPR)); } - | operator LSHIFT unoperator - { $$ = frob_opname (ansi_opname ($2)); } - | operator RSHIFT unoperator - { $$ = frob_opname (ansi_opname ($2)); } - | operator PLUSPLUS unoperator - { $$ = frob_opname (ansi_opname (POSTINCREMENT_EXPR)); } - | operator MINUSMINUS unoperator - { $$ = frob_opname (ansi_opname (PREDECREMENT_EXPR)); } - | operator ANDAND unoperator - { $$ = frob_opname (ansi_opname (TRUTH_ANDIF_EXPR)); } - | operator OROR unoperator - { $$ = frob_opname (ansi_opname (TRUTH_ORIF_EXPR)); } - | operator '!' unoperator - { $$ = frob_opname (ansi_opname (TRUTH_NOT_EXPR)); } - | operator '?' ':' unoperator - { $$ = frob_opname (ansi_opname (COND_EXPR)); } - | operator MIN_MAX unoperator - { $$ = frob_opname (ansi_opname ($2)); } - | operator POINTSAT unoperator %prec EMPTY - { $$ = frob_opname (ansi_opname (COMPONENT_REF)); } - | operator POINTSAT_STAR unoperator %prec EMPTY - { $$ = frob_opname (ansi_opname (MEMBER_REF)); } - | operator LEFT_RIGHT unoperator - { $$ = frob_opname (ansi_opname (CALL_EXPR)); } - | operator '[' ']' unoperator - { $$ = frob_opname (ansi_opname (ARRAY_REF)); } - | operator NEW unoperator %prec EMPTY - { $$ = frob_opname (ansi_opname (NEW_EXPR)); } - | operator DELETE unoperator %prec EMPTY - { $$ = frob_opname (ansi_opname (DELETE_EXPR)); } - | operator NEW '[' ']' unoperator - { $$ = frob_opname (ansi_opname (VEC_NEW_EXPR)); } - | operator DELETE '[' ']' unoperator - { $$ = frob_opname (ansi_opname (VEC_DELETE_EXPR)); } - | operator type_specifier_seq conversion_declarator unoperator - { $$ = frob_opname (grokoptypename ($2.t, $3, $4)); } - | operator error unoperator - { $$ = frob_opname (ansi_opname (ERROR_MARK)); } - ; - -/* The forced readahead in here is because we might be at the end of a - line, and lineno won't be bumped until yylex absorbs the first token - on the next line. */ -save_lineno: - { if (yychar == YYEMPTY) - yychar = YYLEX; - $$ = lineno; } - ; -%% - -#ifdef SPEW_DEBUG -const char * -debug_yytranslate (value) - int value; -{ - return yytname[YYTRANSLATE (value)]; -} -#endif - -/* Free malloced parser stacks if necessary. */ - -void -free_parser_stacks () -{ - if (malloced_yyss) - { - free (malloced_yyss); - free (malloced_yyvs); - } -} - -/* Return the value corresponding to TOKEN in the global scope. */ - -static tree -parse_scoped_id (token) - tree token; -{ - tree id; - - id = make_node (CPLUS_BINDING); - if (!qualified_lookup_using_namespace (token, global_namespace, id, 0)) - id = NULL_TREE; - else - id = BINDING_VALUE (id); - if (yychar == YYEMPTY) - yychar = yylex(); - - return do_scoped_id (token, id); -} - -/* AGGR may be either a type node (like class_type_node) or a - TREE_LIST whose TREE_PURPOSE is a list of attributes and whose - TREE_VALUE is a type node. Set *TAG_KIND and *ATTRIBUTES to - represent the information encoded. */ - -static void -parse_split_aggr (tree aggr, enum tag_types *tag_kind, tree *attributes) -{ - if (TREE_CODE (aggr) == TREE_LIST) - { - *attributes = TREE_PURPOSE (aggr); - aggr = TREE_VALUE (aggr); - } - else - *attributes = NULL_TREE; - *tag_kind = (enum tag_types) tree_low_cst (aggr, 1); -} - -/* Like xref_tag, except that the AGGR may be either a type node (like - class_type_node) or a TREE_LIST whose TREE_PURPOSE is a list of - attributes and whose TREE_VALUE is a type node. */ - -static tree -parse_xref_tag (tree aggr, tree name, int globalize) -{ - tree attributes; - enum tag_types tag_kind; - parse_split_aggr (aggr, &tag_kind, &attributes); - return xref_tag (tag_kind, name, attributes, globalize); -} - -/* Like handle_class_head, but AGGR may be as for parse_xref_tag. */ - -static tree -parse_handle_class_head (tree aggr, tree scope, tree id, - int defn_p, int *new_type_p) -{ - tree attributes; - enum tag_types tag_kind; - parse_split_aggr (aggr, &tag_kind, &attributes); - return handle_class_head (tag_kind, scope, id, attributes, - defn_p, new_type_p); -} - -/* Like do_decl_instantiation, but the declarator has not yet been - parsed. */ - -static void -parse_decl_instantiation (tree declspecs, tree declarator, tree storage) -{ - tree decl = grokdeclarator (declarator, declspecs, NORMAL, 0, NULL); - do_decl_instantiation (decl, storage); -} - -/* Like begin_function_definition, but SPECS_ATTRS is a combined list - containing both a decl-specifier-seq and attributes. */ - -static int -parse_begin_function_definition (tree specs_attrs, tree declarator) -{ - tree specs; - tree attrs; - - split_specs_attrs (specs_attrs, &specs, &attrs); - return begin_function_definition (specs, attrs, declarator); -} - -/* Like finish_call_expr, but the name for FN has not yet been - resolved. */ - -static tree -parse_finish_call_expr (tree fn, tree args, int koenig) -{ - bool disallow_virtual; - - if (TREE_CODE (fn) == OFFSET_REF) - return build_offset_ref_call_from_tree (fn, args); - - if (TREE_CODE (fn) == SCOPE_REF) - { - tree scope = TREE_OPERAND (fn, 0); - tree name = TREE_OPERAND (fn, 1); - - if (scope == error_mark_node || name == error_mark_node) - return error_mark_node; - if (!processing_template_decl) - fn = resolve_scoped_fn_name (scope, name); - disallow_virtual = true; - } - else - disallow_virtual = false; - - if (koenig && TREE_CODE (fn) == IDENTIFIER_NODE) - { - tree f; - - /* Do the Koenig lookup. */ - fn = do_identifier (fn, 2, args); - /* If name lookup didn't find any matching declarations, we've - got an unbound identifier. */ - if (TREE_CODE (fn) == IDENTIFIER_NODE) - { - /* For some reason, do_identifier does not resolve - conversion operator names if the only matches would be - template conversion operators. So, we do it here. */ - if (IDENTIFIER_TYPENAME_P (fn) && current_class_type) - { - f = lookup_member (current_class_type, fn, - /*protect=*/1, /*want_type=*/0); - if (f) - return finish_call_expr (f, args, - /*disallow_virtual=*/false); - } - /* If the name still could not be resolved, then the program - is ill-formed. */ - if (TREE_CODE (fn) == IDENTIFIER_NODE) - { - unqualified_name_lookup_error (fn); - return error_mark_node; - } - } - else if (TREE_CODE (fn) == FUNCTION_DECL - || DECL_FUNCTION_TEMPLATE_P (fn) - || TREE_CODE (fn) == OVERLOAD) - { - tree scope = DECL_CONTEXT (get_first_fn (fn)); - if (scope && TYPE_P (scope)) - { - tree access_scope; - - if (DERIVED_FROM_P (scope, current_class_type) - && current_class_ref) - { - fn = build_baselink (lookup_base (current_class_type, - scope, - ba_any, - NULL), - TYPE_BINFO (current_class_type), - fn, - /*optype=*/NULL_TREE); - return finish_object_call_expr (fn, - current_class_ref, - args); - } - - - access_scope = current_class_type; - while (!DERIVED_FROM_P (scope, access_scope)) - { - access_scope = TYPE_CONTEXT (access_scope); - while (DECL_P (access_scope)) - access_scope = DECL_CONTEXT (access_scope); - } - - fn = build_baselink (NULL_TREE, - TYPE_BINFO (access_scope), - fn, - /*optype=*/NULL_TREE); - } - } - } - - if (TREE_CODE (fn) == COMPONENT_REF) - /* If the parser sees `(x->y)(bar)' we get here because the - parentheses confuse the parser. Treat this like - `x->y(bar)'. */ - return finish_object_call_expr (TREE_OPERAND (fn, 1), - TREE_OPERAND (fn, 0), - args); - - if (processing_template_decl) - return build_nt (CALL_EXPR, fn, args, NULL_TREE); - - return build_call_from_tree (fn, args, disallow_virtual); -} - -#include "gt-cp-parse.h" diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index e4624e38b1f..cb72800c6e1 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -1550,20 +1550,6 @@ finish_unary_op_expr (code, expr) 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 the INITIALIZER_LIST is being cast. */ diff --git a/gcc/cp/spew.c b/gcc/cp/spew.c deleted file mode 100644 index d50c926b095..00000000000 --- a/gcc/cp/spew.c +++ /dev/null @@ -1,1551 +0,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"