mirror of
git://gcc.gnu.org/git/gcc.git
synced 2025-04-10 12:21:09 +08:00
parser.c (cp_parser_class_head): Remove unused variable.
2004-07-12 Eric Christopher <echristo@redhat.com>
* parser.c (cp_parser_class_head): Remove unused variable.
From-SVN: r84571
This commit is contained in:
Eric Christopher
Eric Christopher
parent
dd4e150058
commit
98ca843cfb
@ -1,3 +1,7 @@
|
||||
2004-07-12 Eric Christopher <echristo@redhat.com>
|
||||
|
||||
* parser.c (cp_parser_class_head): Remove unused variable.
|
||||
|
||||
2004-07-12 Giovanni Bajo <giovannibajo@gcc.gnu.org>
|
||||
|
||||
* decl.c (grok_op_properties): Reject [de-]allocation functions
|
||||
@ -9,7 +13,7 @@
|
||||
* decl.c (xref_basetypes): Use make_tree_binfo directly.
|
||||
* tree.h (copy_base_binfos): Likewise.
|
||||
(make_binfo): Remove.
|
||||
|
||||
|
||||
* call.c (build_user_type_conversion_1, build_new_op,
|
||||
check_constructor_callable, build_temp,
|
||||
perform_direct_initialization_of_possible): Pass type directly to
|
||||
|
||||
157
gcc/cp/parser.c
157
gcc/cp/parser.c
@ -1015,19 +1015,19 @@ clear_decl_specs (cp_decl_specifier_seq *decl_specs)
|
||||
Other parts of the front end that need to create entities (like
|
||||
VAR_DECLs or FUNCTION_DECLs) should do that directly. */
|
||||
|
||||
static cp_declarator *make_id_declarator
|
||||
static cp_declarator *make_id_declarator
|
||||
(tree);
|
||||
static cp_declarator *make_call_declarator
|
||||
static cp_declarator *make_call_declarator
|
||||
(cp_declarator *, cp_parameter_declarator *, cp_cv_quals, tree);
|
||||
static cp_declarator *make_array_declarator
|
||||
static cp_declarator *make_array_declarator
|
||||
(cp_declarator *, tree);
|
||||
static cp_declarator *make_pointer_declarator
|
||||
static cp_declarator *make_pointer_declarator
|
||||
(cp_cv_quals, cp_declarator *);
|
||||
static cp_declarator *make_reference_declarator
|
||||
static cp_declarator *make_reference_declarator
|
||||
(cp_cv_quals, cp_declarator *);
|
||||
static cp_parameter_declarator *make_parameter_declarator
|
||||
static cp_parameter_declarator *make_parameter_declarator
|
||||
(cp_decl_specifier_seq *, cp_declarator *, tree);
|
||||
static cp_declarator *make_ptrmem_declarator
|
||||
static cp_declarator *make_ptrmem_declarator
|
||||
(cp_cv_quals, tree, cp_declarator *);
|
||||
|
||||
cp_declarator *cp_error_declarator;
|
||||
@ -1066,7 +1066,7 @@ cp_declarator *
|
||||
make_id_declarator (tree id)
|
||||
{
|
||||
cp_declarator *declarator;
|
||||
|
||||
|
||||
declarator = make_declarator (cdk_id);
|
||||
declarator->u.id.name = id;
|
||||
declarator->u.id.sfk = sfk_none;
|
||||
@ -1129,7 +1129,7 @@ make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
|
||||
indicates what exceptions can be thrown. */
|
||||
|
||||
cp_declarator *
|
||||
make_call_declarator (cp_declarator *target,
|
||||
make_call_declarator (cp_declarator *target,
|
||||
cp_parameter_declarator *parms,
|
||||
cp_cv_quals cv_qualifiers,
|
||||
tree exception_specification)
|
||||
@ -1166,13 +1166,13 @@ cp_parameter_declarator *no_parameters;
|
||||
DECLARATOR and DEFAULT_ARGUMENT. */
|
||||
|
||||
cp_parameter_declarator *
|
||||
make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
|
||||
make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
|
||||
cp_declarator *declarator,
|
||||
tree default_argument)
|
||||
{
|
||||
cp_parameter_declarator *parameter;
|
||||
|
||||
parameter = ((cp_parameter_declarator *)
|
||||
parameter = ((cp_parameter_declarator *)
|
||||
alloc_declarator (sizeof (cp_parameter_declarator)));
|
||||
parameter->next = NULL;
|
||||
if (decl_specifiers)
|
||||
@ -1650,7 +1650,7 @@ static tree cp_parser_storage_class_specifier_opt
|
||||
static tree cp_parser_function_specifier_opt
|
||||
(cp_parser *, cp_decl_specifier_seq *);
|
||||
static tree cp_parser_type_specifier
|
||||
(cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
|
||||
(cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
|
||||
int *, bool *);
|
||||
static tree cp_parser_simple_type_specifier
|
||||
(cp_parser *, cp_decl_specifier_seq *, cp_parser_flags);
|
||||
@ -1874,7 +1874,7 @@ static bool cp_parser_declares_only_class_p
|
||||
(cp_parser *);
|
||||
static void cp_parser_set_storage_class
|
||||
(cp_decl_specifier_seq *, cp_storage_class);
|
||||
static void cp_parser_set_decl_spec_type
|
||||
static void cp_parser_set_decl_spec_type
|
||||
(cp_decl_specifier_seq *, tree, bool);
|
||||
static bool cp_parser_friend_p
|
||||
(const cp_decl_specifier_seq *);
|
||||
@ -2623,7 +2623,7 @@ cp_parser_translation_unit (cp_parser* parser)
|
||||
static void *declarator_obstack_base;
|
||||
|
||||
bool success;
|
||||
|
||||
|
||||
/* Create the declarator obstack, if necessary. */
|
||||
if (!cp_error_declarator)
|
||||
{
|
||||
@ -2645,7 +2645,7 @@ cp_parser_translation_unit (cp_parser* parser)
|
||||
{
|
||||
/* Consume the EOF token. */
|
||||
cp_parser_require (parser, CPP_EOF, "end-of-file");
|
||||
|
||||
|
||||
/* Finish up. */
|
||||
finish_translation_unit ();
|
||||
|
||||
@ -3764,7 +3764,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
|
||||
if (parser->integral_constant_expression_p
|
||||
&& !dependent_type_p (type)
|
||||
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type)
|
||||
&& (cp_parser_non_integral_constant_expression
|
||||
&& (cp_parser_non_integral_constant_expression
|
||||
(parser,
|
||||
"a cast to a type other than an integral or "
|
||||
"enumeration type")))
|
||||
@ -3836,7 +3836,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
|
||||
cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
|
||||
}
|
||||
/* `typeid' may not appear in an integral constant expression. */
|
||||
if (cp_parser_non_integral_constant_expression(parser,
|
||||
if (cp_parser_non_integral_constant_expression(parser,
|
||||
"`typeid' operator"))
|
||||
return error_mark_node;
|
||||
/* Restore the saved message. */
|
||||
@ -3881,7 +3881,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
|
||||
/* Create a TYPENAME_TYPE to represent the type to which the
|
||||
functional cast is being performed. */
|
||||
else
|
||||
type = make_typename_type (parser->scope, id,
|
||||
type = make_typename_type (parser->scope, id,
|
||||
/*complain=*/1);
|
||||
|
||||
postfix_expression = cp_parser_functional_cast (parser, type);
|
||||
@ -4114,7 +4114,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
|
||||
postfix-expression . pseudo-destructor-name
|
||||
postfix-expression -> template [opt] id-expression
|
||||
postfix-expression -> pseudo-destructor-name */
|
||||
|
||||
|
||||
/* Consume the `.' or `->' operator. */
|
||||
cp_lexer_consume_token (parser->lexer);
|
||||
|
||||
@ -4308,7 +4308,7 @@ cp_parser_postfix_dot_deref_expression (cp_parser *parser,
|
||||
parser->object_scope = NULL_TREE;
|
||||
}
|
||||
if (scope && name && BASELINK_P (name))
|
||||
adjust_result_of_qualified_name_lookup
|
||||
adjust_result_of_qualified_name_lookup
|
||||
(name, BINFO_TYPE (BASELINK_BINFO (name)), scope);
|
||||
postfix_expression
|
||||
= finish_class_member_access_expr (postfix_expression, name);
|
||||
@ -4334,7 +4334,7 @@ cp_parser_postfix_dot_deref_expression (cp_parser *parser,
|
||||
/* Outside of offsetof, these operators may not appear in
|
||||
constant-expressions. */
|
||||
if (!for_offsetof
|
||||
&& (cp_parser_non_integral_constant_expression
|
||||
&& (cp_parser_non_integral_constant_expression
|
||||
(parser, token_type == CPP_DEREF ? "'->'" : "`.'")))
|
||||
postfix_expression = error_mark_node;
|
||||
|
||||
@ -4723,7 +4723,7 @@ cp_parser_unary_expression (cp_parser *parser, bool address_p)
|
||||
abort ();
|
||||
}
|
||||
|
||||
if (non_constant_p
|
||||
if (non_constant_p
|
||||
&& cp_parser_non_integral_constant_expression (parser,
|
||||
non_constant_p))
|
||||
expression = error_mark_node;
|
||||
@ -4808,7 +4808,7 @@ cp_parser_new_expression (cp_parser* parser)
|
||||
type = cp_parser_type_id (parser);
|
||||
/* Look for the closing `)'. */
|
||||
cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
|
||||
/* There should not be a direct-new-declarator in this production,
|
||||
/* There should not be a direct-new-declarator in this production,
|
||||
but GCC used to allowed this, so we check and emit a sensible error
|
||||
message for this case. */
|
||||
if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
|
||||
@ -4902,7 +4902,7 @@ cp_parser_new_type_id (cp_parser* parser, tree *nelts)
|
||||
outer_declarator = declarator;
|
||||
declarator = declarator->declarator;
|
||||
}
|
||||
while (declarator
|
||||
while (declarator
|
||||
&& declarator->kind == cdk_array
|
||||
&& declarator->declarator
|
||||
&& declarator->declarator->kind == cdk_array)
|
||||
@ -4910,7 +4910,7 @@ cp_parser_new_type_id (cp_parser* parser, tree *nelts)
|
||||
outer_declarator = declarator;
|
||||
declarator = declarator->declarator;
|
||||
}
|
||||
|
||||
|
||||
if (declarator && declarator->kind == cdk_array)
|
||||
{
|
||||
*nelts = declarator->u.array.bounds;
|
||||
@ -4918,7 +4918,7 @@ cp_parser_new_type_id (cp_parser* parser, tree *nelts)
|
||||
*nelts = integer_one_node;
|
||||
else if (!processing_template_decl)
|
||||
{
|
||||
if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, *nelts,
|
||||
if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, *nelts,
|
||||
false))
|
||||
pedwarn ("size in array new must have integral type");
|
||||
*nelts = save_expr (cp_convert (sizetype, *nelts));
|
||||
@ -5210,7 +5210,7 @@ cp_parser_cast_expression (cp_parser *parser, bool address_p)
|
||||
if (parser->integral_constant_expression_p
|
||||
&& !dependent_type_p (type)
|
||||
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type)
|
||||
&& (cp_parser_non_integral_constant_expression
|
||||
&& (cp_parser_non_integral_constant_expression
|
||||
(parser,
|
||||
"a cast to a type other than an integral or "
|
||||
"enumeration type")))
|
||||
@ -6443,7 +6443,7 @@ cp_parser_iteration_statement (cp_parser* parser)
|
||||
finish_for_expr (expression, statement);
|
||||
/* Look for the `)'. */
|
||||
cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
|
||||
|
||||
|
||||
/* Parse the body of the for-statement. */
|
||||
parser->in_iteration_statement_p = true;
|
||||
cp_parser_already_scoped_statement (parser);
|
||||
@ -6953,7 +6953,7 @@ cp_parser_simple_declaration (cp_parser* parser,
|
||||
/* In a block scope, a valid declaration must always have a
|
||||
decl-specifier-seq. By not trying to parse declarators, we can
|
||||
resolve the declaration/expression ambiguity more quickly. */
|
||||
if (!function_definition_allowed_p
|
||||
if (!function_definition_allowed_p
|
||||
&& !decl_specifiers.any_specifiers_p)
|
||||
{
|
||||
cp_parser_error (parser, "expected declaration");
|
||||
@ -7094,7 +7094,7 @@ cp_parser_simple_declaration (cp_parser* parser,
|
||||
(i.e., a type declaration)
|
||||
2: one of the decl-specifiers is an enum-specifier or a
|
||||
class-specifier (i.e., a type definition)
|
||||
|
||||
|
||||
*/
|
||||
|
||||
static void
|
||||
@ -7124,7 +7124,7 @@ cp_parser_decl_specifier_seq (cp_parser* parser,
|
||||
if (token->keyword == RID_ATTRIBUTE)
|
||||
{
|
||||
/* Parse the attributes. */
|
||||
decl_specs->attributes
|
||||
decl_specs->attributes
|
||||
= chainon (decl_specs->attributes,
|
||||
cp_parser_attributes_opt (parser));
|
||||
continue;
|
||||
@ -7225,10 +7225,10 @@ cp_parser_decl_specifier_seq (cp_parser* parser,
|
||||
|
||||
/* Constructors are a special case. The `S' in `S()' is not a
|
||||
decl-specifier; it is the beginning of the declarator. */
|
||||
constructor_p
|
||||
constructor_p
|
||||
= (!found_decl_spec
|
||||
&& constructor_possible_p
|
||||
&& (cp_parser_constructor_declarator_p
|
||||
&& (cp_parser_constructor_declarator_p
|
||||
(parser, decl_specs->specs[(int) ds_friend] != 0)));
|
||||
|
||||
/* If we don't have a DECL_SPEC yet, then we must be looking at
|
||||
@ -7570,10 +7570,10 @@ cp_parser_conversion_declarator_opt (cp_parser* parser)
|
||||
if (cp_parser_parse_definitely (parser))
|
||||
{
|
||||
cp_declarator *declarator;
|
||||
|
||||
|
||||
/* Parse another optional declarator. */
|
||||
declarator = cp_parser_conversion_declarator_opt (parser);
|
||||
|
||||
|
||||
/* Create the representation of the declarator. */
|
||||
if (class_type)
|
||||
declarator = make_ptrmem_declarator (cv_quals, class_type,
|
||||
@ -7582,7 +7582,7 @@ cp_parser_conversion_declarator_opt (cp_parser* parser)
|
||||
declarator = make_pointer_declarator (cv_quals, declarator);
|
||||
else
|
||||
declarator = make_reference_declarator (cv_quals, declarator);
|
||||
|
||||
|
||||
return declarator;
|
||||
}
|
||||
|
||||
@ -8193,11 +8193,11 @@ cp_parser_template_parameter (cp_parser* parser, bool *is_non_type)
|
||||
parameter_declarator
|
||||
= cp_parser_parameter_declaration (parser, /*template_parm_p=*/true,
|
||||
/*parenthesized_p=*/NULL);
|
||||
return (build_tree_list
|
||||
return (build_tree_list
|
||||
(parameter_declarator->default_argument,
|
||||
grokdeclarator (parameter_declarator->declarator,
|
||||
¶meter_declarator->decl_specifiers,
|
||||
PARM, /*initialized=*/0,
|
||||
PARM, /*initialized=*/0,
|
||||
/*attrlist=*/NULL)));
|
||||
}
|
||||
|
||||
@ -8690,7 +8690,7 @@ cp_parser_template_name (cp_parser* parser,
|
||||
(and must) do name-lookup normally. */
|
||||
if (template_keyword_p
|
||||
&& (!parser->scope
|
||||
|| (TYPE_P (parser->scope)
|
||||
|| (TYPE_P (parser->scope)
|
||||
&& dependent_type_p (parser->scope))))
|
||||
return identifier;
|
||||
}
|
||||
@ -9045,7 +9045,7 @@ cp_parser_explicit_instantiation (cp_parser* parser)
|
||||
extension_specifier
|
||||
= cp_parser_storage_class_specifier_opt (parser);
|
||||
if (!extension_specifier)
|
||||
extension_specifier
|
||||
extension_specifier
|
||||
= cp_parser_function_specifier_opt (parser,
|
||||
/*decl_specs=*/NULL);
|
||||
}
|
||||
@ -9252,8 +9252,8 @@ cp_parser_type_specifier (cp_parser* parser,
|
||||
|
||||
case RID_TYPENAME:
|
||||
/* Look for an elaborated-type-specifier. */
|
||||
type_spec
|
||||
= (cp_parser_elaborated_type_specifier
|
||||
type_spec
|
||||
= (cp_parser_elaborated_type_specifier
|
||||
(parser,
|
||||
decl_specs && decl_specs->specs[(int) ds_friend],
|
||||
is_declaration));
|
||||
@ -9272,7 +9272,7 @@ cp_parser_type_specifier (cp_parser* parser,
|
||||
if (is_cv_qualifier)
|
||||
*is_cv_qualifier = true;
|
||||
break;
|
||||
|
||||
|
||||
case RID_VOLATILE:
|
||||
ds = ds_volatile;
|
||||
if (is_cv_qualifier)
|
||||
@ -9307,7 +9307,7 @@ cp_parser_type_specifier (cp_parser* parser,
|
||||
|
||||
/* If we do not already have a type-specifier, assume we are looking
|
||||
at a simple-type-specifier. */
|
||||
type_spec = cp_parser_simple_type_specifier (parser,
|
||||
type_spec = cp_parser_simple_type_specifier (parser,
|
||||
decl_specs,
|
||||
flags);
|
||||
|
||||
@ -9349,7 +9349,7 @@ cp_parser_type_specifier (cp_parser* parser,
|
||||
appropriately updated. */
|
||||
|
||||
static tree
|
||||
cp_parser_simple_type_specifier (cp_parser* parser,
|
||||
cp_parser_simple_type_specifier (cp_parser* parser,
|
||||
cp_decl_specifier_seq *decl_specs,
|
||||
cp_parser_flags flags)
|
||||
{
|
||||
@ -9420,7 +9420,7 @@ cp_parser_simple_type_specifier (cp_parser* parser,
|
||||
if (decl_specs)
|
||||
cp_parser_set_decl_spec_type (decl_specs, type,
|
||||
/*user_defined_p=*/true);
|
||||
|
||||
|
||||
return type;
|
||||
|
||||
default:
|
||||
@ -9438,7 +9438,7 @@ cp_parser_simple_type_specifier (cp_parser* parser,
|
||||
&& token->keyword != RID_UNSIGNED
|
||||
&& token->keyword != RID_SHORT
|
||||
&& token->keyword != RID_LONG))
|
||||
cp_parser_set_decl_spec_type (decl_specs,
|
||||
cp_parser_set_decl_spec_type (decl_specs,
|
||||
type,
|
||||
/*user_defined=*/false);
|
||||
if (decl_specs)
|
||||
@ -9498,9 +9498,9 @@ cp_parser_simple_type_specifier (cp_parser* parser,
|
||||
else
|
||||
type = cp_parser_type_name (parser);
|
||||
/* Keep track of all name-lookups performed in class scopes. */
|
||||
if (type
|
||||
if (type
|
||||
&& !qualified_p
|
||||
&& TREE_CODE (type) == TYPE_DECL
|
||||
&& TREE_CODE (type) == TYPE_DECL
|
||||
&& TREE_CODE (DECL_NAME (type)) == IDENTIFIER_NODE)
|
||||
maybe_note_name_used_in_class (DECL_NAME (type), type);
|
||||
/* If it didn't work out, we don't have a TYPE. */
|
||||
@ -11149,12 +11149,12 @@ cp_parser_direct_declarator (cp_parser* parser,
|
||||
if (ctor_dtor_or_conv_p && declarator->u.id.sfk != sfk_none)
|
||||
*ctor_dtor_or_conv_p = -1;
|
||||
if (TREE_CODE (id) == SCOPE_REF
|
||||
&& TREE_CODE (unqualified_name) == TYPE_DECL
|
||||
&& TREE_CODE (unqualified_name) == TYPE_DECL
|
||||
&& CLASSTYPE_USE_TEMPLATE (TREE_TYPE (unqualified_name)))
|
||||
{
|
||||
error ("invalid use of constructor as a template");
|
||||
inform ("use `%T::%D' instead of `%T::%T' to name the "
|
||||
"constructor in a qualified name", class_type,
|
||||
"constructor in a qualified name", class_type,
|
||||
DECL_NAME (TYPE_TI_TEMPLATE (class_type)),
|
||||
class_type, class_type);
|
||||
}
|
||||
@ -11299,7 +11299,7 @@ cp_parser_ptr_operator (cp_parser* parser,
|
||||
GNU Extension:
|
||||
|
||||
cv-qualifier:
|
||||
__restrict__
|
||||
__restrict__
|
||||
|
||||
Returns a bitmask representing the cv-qualifiers. */
|
||||
|
||||
@ -11312,7 +11312,7 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
|
||||
{
|
||||
cp_token *token;
|
||||
cp_cv_quals cv_qualifier;
|
||||
|
||||
|
||||
/* Peek at the next token. */
|
||||
token = cp_lexer_peek_token (parser->lexer);
|
||||
/* See if it's a cv-qualifier. */
|
||||
@ -11321,20 +11321,20 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
|
||||
case RID_CONST:
|
||||
cv_qualifier = TYPE_QUAL_CONST;
|
||||
break;
|
||||
|
||||
|
||||
case RID_VOLATILE:
|
||||
cv_qualifier = TYPE_QUAL_VOLATILE;
|
||||
break;
|
||||
|
||||
|
||||
case RID_RESTRICT:
|
||||
cv_qualifier = TYPE_QUAL_RESTRICT;
|
||||
break;
|
||||
|
||||
|
||||
default:
|
||||
cv_qualifier = TYPE_UNQUALIFIED;
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
if (!cv_qualifier)
|
||||
break;
|
||||
|
||||
@ -11461,7 +11461,7 @@ cp_parser_type_specifier_seq (cp_parser* parser,
|
||||
/* Check for attributes first. */
|
||||
if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
|
||||
{
|
||||
type_specifier_seq->attributes =
|
||||
type_specifier_seq->attributes =
|
||||
chainon (type_specifier_seq->attributes,
|
||||
cp_parser_attributes_opt (parser));
|
||||
continue;
|
||||
@ -11576,7 +11576,7 @@ cp_parser_parameter_declaration_clause (cp_parser* parser)
|
||||
/* Finish the parameter list. */
|
||||
if (parameters && ellipsis_p)
|
||||
parameters->ellipsis_p = true;
|
||||
|
||||
|
||||
return parameters;
|
||||
}
|
||||
|
||||
@ -11782,7 +11782,7 @@ cp_parser_parameter_declaration (cp_parser *parser,
|
||||
parser->default_arg_ok_p = saved_default_arg_ok_p;
|
||||
/* After the declarator, allow more attributes. */
|
||||
decl_specifiers.attributes
|
||||
= chainon (decl_specifiers.attributes,
|
||||
= chainon (decl_specifiers.attributes,
|
||||
cp_parser_attributes_opt (parser));
|
||||
}
|
||||
|
||||
@ -12040,7 +12040,7 @@ cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
|
||||
assignment-expression. */
|
||||
if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
|
||||
{
|
||||
initializer
|
||||
initializer
|
||||
= cp_parser_constant_expression (parser,
|
||||
/*allow_non_constant_p=*/true,
|
||||
non_constant_p);
|
||||
@ -12338,14 +12338,14 @@ cp_parser_class_specifier (cp_parser* parser)
|
||||
if (nested_name_specifier_p)
|
||||
pop_p = push_scope (CP_DECL_CONTEXT (TYPE_MAIN_DECL (type)));
|
||||
type = begin_class_definition (type);
|
||||
|
||||
|
||||
if (type == error_mark_node)
|
||||
/* If the type is erroneous, skip the entire body of the class. */
|
||||
cp_parser_skip_to_closing_brace (parser);
|
||||
else
|
||||
/* Parse the member-specification. */
|
||||
cp_parser_member_specification_opt (parser);
|
||||
|
||||
|
||||
/* Look for the trailing `}'. */
|
||||
cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
|
||||
/* We get better error messages by noticing a common problem: a
|
||||
@ -12482,7 +12482,6 @@ cp_parser_class_head (cp_parser* parser,
|
||||
bool* nested_name_specifier_p,
|
||||
tree *attributes_p)
|
||||
{
|
||||
cp_token *token;
|
||||
tree nested_name_specifier;
|
||||
enum tag_types class_key;
|
||||
tree id = NULL_TREE;
|
||||
@ -12771,13 +12770,13 @@ cp_parser_class_head (cp_parser* parser,
|
||||
is valid. */
|
||||
if (nested_name_specifier)
|
||||
pop_p = push_scope (nested_name_specifier);
|
||||
|
||||
|
||||
bases = NULL_TREE;
|
||||
|
||||
|
||||
/* Get the list of base-classes, if there is one. */
|
||||
if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
|
||||
bases = cp_parser_base_clause (parser);
|
||||
|
||||
|
||||
/* Process the base classes. */
|
||||
xref_basetypes (type, bases);
|
||||
|
||||
@ -12988,7 +12987,7 @@ cp_parser_member_declaration (cp_parser* parser)
|
||||
|
||||
A<T>::B will be represented by a TYPENAME_TYPE, and
|
||||
therefore not recognized by check_tag_decl. */
|
||||
if (!type
|
||||
if (!type
|
||||
&& decl_specifiers.type
|
||||
&& TYPE_P (decl_specifiers.type))
|
||||
type = decl_specifiers.type;
|
||||
@ -13069,7 +13068,7 @@ cp_parser_member_declaration (cp_parser* parser)
|
||||
attributes = chainon (prefix_attributes, attributes);
|
||||
|
||||
/* Create the bitfield declaration. */
|
||||
decl = grokbitfield (identifier
|
||||
decl = grokbitfield (identifier
|
||||
? make_id_declarator (identifier)
|
||||
: NULL,
|
||||
&decl_specifiers,
|
||||
@ -14418,7 +14417,7 @@ cp_parser_check_declarator_template_parameters (cp_parser* parser,
|
||||
case cdk_pointer:
|
||||
case cdk_reference:
|
||||
case cdk_ptrmem:
|
||||
return (cp_parser_check_declarator_template_parameters
|
||||
return (cp_parser_check_declarator_template_parameters
|
||||
(parser, declarator->declarator));
|
||||
|
||||
case cdk_error:
|
||||
@ -14513,7 +14512,7 @@ cp_parser_binary_expression (cp_parser* parser,
|
||||
/* Parse the right-hand side of the expression. */
|
||||
rhs = (*fn) (parser);
|
||||
/* Build the binary tree node. */
|
||||
lhs = build_x_binary_op (map_node->tree_type, lhs, rhs,
|
||||
lhs = build_x_binary_op (map_node->tree_type, lhs, rhs,
|
||||
&overloaded_p);
|
||||
/* If the binary operator required the use of an
|
||||
overloaded operator, then this expression cannot be an
|
||||
@ -14522,7 +14521,7 @@ cp_parser_binary_expression (cp_parser* parser,
|
||||
permissible in an integral constant-expression if at
|
||||
least one of the operands is of enumeration type. */
|
||||
if (overloaded_p
|
||||
&& (cp_parser_non_integral_constant_expression
|
||||
&& (cp_parser_non_integral_constant_expression
|
||||
(parser, "calls to overloaded operators")))
|
||||
lhs = error_mark_node;
|
||||
break;
|
||||
@ -14883,13 +14882,13 @@ cp_parser_template_declaration_after_export (cp_parser* parser, bool member_p)
|
||||
/* There are no access checks when parsing a template, as we do not
|
||||
know if a specialization will be a friend. */
|
||||
push_deferring_access_checks (dk_no_check);
|
||||
|
||||
|
||||
decl = cp_parser_single_declaration (parser,
|
||||
member_p,
|
||||
&friend_p);
|
||||
|
||||
pop_deferring_access_checks ();
|
||||
|
||||
|
||||
/* If this is a member template declaration, let the front
|
||||
end know. */
|
||||
if (member_p && !friend_p && decl)
|
||||
@ -15024,10 +15023,10 @@ cp_parser_functional_cast (cp_parser* parser, tree type)
|
||||
cast = build_functional_cast (type, expression_list);
|
||||
/* [expr.const]/1: In an integral constant expression "only type
|
||||
conversions to integral or enumeration type can be used". */
|
||||
if (cast != error_mark_node && !type_dependent_expression_p (type)
|
||||
if (cast != error_mark_node && !type_dependent_expression_p (type)
|
||||
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (type)))
|
||||
{
|
||||
if (cp_parser_non_integral_constant_expression
|
||||
if (cp_parser_non_integral_constant_expression
|
||||
(parser, "a call to a constructor"))
|
||||
return error_mark_node;
|
||||
}
|
||||
@ -15442,12 +15441,12 @@ cp_parser_set_decl_spec_type (cp_decl_specifier_seq *decl_specs,
|
||||
bool user_defined_p)
|
||||
{
|
||||
decl_specs->any_specifiers_p = true;
|
||||
|
||||
|
||||
/* If the user tries to redeclare a built-in type (with, for example,
|
||||
in "typedef int wchar_t;") we remember that this is what
|
||||
happened. In system headers, we ignore these declarations so
|
||||
that G++ can work with system headers that are not C++-safe. */
|
||||
if (decl_specs->specs[(int) ds_typedef]
|
||||
if (decl_specs->specs[(int) ds_typedef]
|
||||
&& !user_defined_p
|
||||
&& (decl_specs->type
|
||||
|| decl_specs->specs[(int) ds_long]
|
||||
@ -15805,7 +15804,7 @@ cp_parser_cache_group (cp_parser *parser,
|
||||
c_lex_string_translate = -1;
|
||||
|
||||
cp_parser_cache_group_1 (parser, cache, end, depth);
|
||||
|
||||
|
||||
c_lex_string_translate = saved_c_lex_string_translate;
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user