+2003-01-29 Mark Mitchell <mark@codesourcery.com>
+
+ * c-common.c (builtin_define_float_constants): Define
+ __<TYPE>_HAS_INFINITY__ and __<TYPE>_HAS_QUIET_NAN__.
+
2003-01-30 Kazu Hirata <kazu@cs.umass.edu>
* config/sh/lib1funcs.asm: Fix comment typos.
sprintf (buf, "0.0%s", fp_suffix);
builtin_define_with_value (name, buf, 0);
}
+
+ /* For C++ std::numeric_limits<T>::has_infinity. */
+ sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
+ builtin_define_with_int_value (name,
+ MODE_HAS_INFINITIES (TYPE_MODE (type)));
+ /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
+ predicate to distinguish a target that has both quiet and
+ signalling NaNs from a target that has only quiet NaNs or only
+ signalling NaNs, so we assume that a target that has any kind of
+ NaN has quiet NaNs. */
+ sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
+ builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
}
/* Hook that registers front end and target-specific built-ins. */
+2003-01-29 Mark Mitchell <mark@codesourcery.com>
+
+ * call.c (build_field_call): Use build_new_op, not build_opfncall.
+ (prep_operand): New function.
+ (build_new_op): Use it. Remove dead code.
+ * class.c (pushclass): Change "modify" parameter type from int to
+ bool.
+ (currently_open_class): Use same_type_p, not pointer equality.
+ (push_nested_class): Adjust calls to pushclass, remove modify
+ parameter.
+ * cp-tree.h (INTEGRAL_OR_ENUMERATION_TYPE_P): New macro.
+ (pushclass): Change prototype.
+ (push_nested_class): Likewise.
+ (grokoptypename): Remove.
+ (build_opfncall): Remove.
+ (value_dependent_expression_p): Declare.
+ (resolve_typename_type): Likewise.
+ (resolve_typename_type_in_current_instantiation): Likewise.
+ (enter_scope_of): Remove.
+ (tsubst): Remove.
+ (tsubst_expr): Likewise.
+ (tsubst_copy): Likewise.
+ (tsubst_copy_and_build): Likewise.
+ * decl.c (warn_about_implicit_typename_lookup): Remove.
+ (finish_case_label): Return error_mark_node for erroneous labels.
+ (start_decl): Adjust calls to push_nested_class.
+ (grokfndecl): Call push_scope/pop_scope around call to
+ duplicate_decls.
+ (grokdeclarator): Do not call tsubst.
+ (start_function): Adjust calls to push_nested_class.
+ * decl2.c (grok_array_decl): Use build_new_op, not build_opfncall.
+ (check_classfn): Use push_scope/pop_scope around type comparisions.
+ (grokoptypename): Remove.
+ (push_sscope): Adjust call to push_nested_class.
+ * error.c (dump_type): Show cv-qualification of typename types.
+ * init.c (build_member_call): Use build_new_op, not
+ build_opfncall.
+ * method.c (build_opfncall): Remove.
+ * parser.c (cp_parser): Add allow_non_constant_expression_p and
+ non_constant_expression_p.
+ (cp_parser_constant_expression): Adjust prototype.
+ (cp_parser_resolve_typename_type): Remove.
+ (cp_parser_non_constant_expression): New function.
+ (cp_parser_non_constant_id_expression): Likewise.
+ (cp_parser_new): Set allow_non_constant_expression_p and
+ non_constant_expression_p.
+ (cp_parser_primary_expression): Reject `this' and `va_arg' in
+ constant-expressions. Note that dependent names aren't really
+ constant.
+ (cp_parser_postfix_expression): Reject conversions to non-integral
+ types in constant-expressions. Neither are increments or
+ decrements.
+ (cp_parser_unary_expression): Reject increments and decrements in
+ constant-expressions.
+ (cp_parser_direct_new_declarator): Adjust call to
+ cp_parser_constant_expression.
+ (cp_parser_cast_expression): Reject conversions to non-integral
+ types in constant-expressions.
+ (cp_parser_assignment_expression): Rejects assignments in
+ constant-expressions.
+ (cp_parser_expression): Reject commas in constant-expressions.
+ (cp_parser_labeled_statement): Adjust call to
+ cp_parser_constant_expression.
+ (cp_parser_direct_declarator): Simplify array bounds, even in
+ templates, when they are non-dependent. Use
+ resolve_typename_type, not cp_parser_resolve_typename_type.
+ (cp_parser_class_head): Use resolve_typename_type, not
+ cp_parser_resolve_typename_type.
+ (cp_parser_member_declaration): Adjust call to
+ cp_parser_constant_expression.
+ (cp_parser_constant_initializer): Likewise.
+ (cp_parser_constructor_declarator): Use resolve_typename_type, not
+ cp_parser_resolve_typename_type.
+ (cp_parser_late_parsing_default_args): Adjust call to
+ push_nested_class.
+ * pt.c (tsubst): Give it internal linkage.
+ (tsubst_expr): Likewise.
+ (tsubst_copy): Likewise.
+ (tsubst_copy_and_build): Likewise.
+ (push_access_scope_real): Likewise.
+ (tsubst_friend_class): Likewise.
+ (instantiate_class_template): Adjust call to pushclass.
+ (value_dependent_expression_p): Give it external linkage.
+ Robustify.
+ (resolve_typename_type): New function.
+ * semantics.c (finish_call_expr): Use build_new_op, not
+ build_opfncall.
+ (begin_constructor_declarator): Remove.
+ (begin_class_definition): Adjust call to pushclass.
+ (enter_scope_of): Remove.
+ * typeck.c (comptypes): Resolve typename types as appropriate.
+ (build_x_indirect_ref): Use build_new_op, not build_opfncall.
+ (build_x_compound_expr): Likewise.
+ (build_modify_expr): Likewise.
+ (build_x_modify_expr): Likewise.
+ * typeck2.c (build_x_arrow): Likewise.
+
2003-01-29 Fariborz Jahanian <fjahanian@apple.com>
* pt.c (last_pending_template) Declare GTY().
static tree conditional_conversion (tree, tree);
static char *name_as_c_string (tree, tree, bool *);
static tree call_builtin_trap (void);
+static tree prep_operand (tree);
tree
build_vfield_ref (tree datum, tree type)
return error_mark_node;
if (IS_AGGR_TYPE (TREE_TYPE (instance)))
- return build_opfncall (CALL_EXPR, LOOKUP_NORMAL,
- instance, parms, NULL_TREE);
+ return build_new_op (CALL_EXPR, LOOKUP_NORMAL,
+ instance, parms, NULL_TREE);
else if (TREE_CODE (TREE_TYPE (instance)) == FUNCTION_TYPE
|| (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE
&& (TREE_CODE (TREE_TYPE (TREE_TYPE (instance)))
return result;
}
+/* OPERAND is an operand to an expression. Perform necessary steps
+ required before using it. If OPERAND is NULL_TREE, NULL_TREE is
+ returned. */
+
+static tree
+prep_operand (tree operand)
+{
+ if (operand)
+ {
+ if (TREE_CODE (operand) == OFFSET_REF)
+ operand = resolve_offset_ref (operand);
+ operand = convert_from_reference (operand);
+ if (CLASS_TYPE_P (TREE_TYPE (operand))
+ && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
+ /* Make sure the template type is instantiated now. */
+ instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
+ }
+
+ return operand;
+}
+
tree
build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3)
{
|| error_operand_p (arg3))
return error_mark_node;
- /* This can happen if a template takes all non-type parameters, e.g.
- undeclared_template<1, 5, 72>a; */
- if (code == LT_EXPR && TREE_CODE (arg1) == TEMPLATE_DECL)
- {
- error ("`%D' must be declared before use", arg1);
- return error_mark_node;
- }
-
if (code == MODIFY_EXPR)
{
code2 = TREE_CODE (arg3);
else
fnname = ansi_opname (code);
- if (TREE_CODE (arg1) == OFFSET_REF)
- arg1 = resolve_offset_ref (arg1);
- arg1 = convert_from_reference (arg1);
- if (CLASS_TYPE_P (TREE_TYPE (arg1))
- && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (arg1)))
- /* Make sure the template type is instantiated now. */
- instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)));
+ arg1 = prep_operand (arg1);
switch (code)
{
break;
}
- if (arg2)
- {
- if (TREE_CODE (arg2) == OFFSET_REF)
- arg2 = resolve_offset_ref (arg2);
- arg2 = convert_from_reference (arg2);
- if (CLASS_TYPE_P (TREE_TYPE (arg2))
- && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (arg2)))
- instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (arg2)));
- }
- if (arg3)
- {
- if (TREE_CODE (arg3) == OFFSET_REF)
- arg3 = resolve_offset_ref (arg3);
- arg3 = convert_from_reference (arg3);
- if (CLASS_TYPE_P (TREE_TYPE (arg3))
- && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (arg3)))
- instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (arg3)));
- }
+ arg2 = prep_operand (arg2);
+ arg3 = prep_operand (arg3);
if (code == COND_EXPR)
{
if (TREE_CODE (cand->fn) == FUNCTION_DECL)
{
- extern int warn_synth;
if (warn_synth
&& fnname == ansi_assopname (NOP_EXPR)
&& DECL_ARTIFICIAL (cand->fn)
that name becomes `error_mark_node'. */
void
-pushclass (tree type, int modify)
+pushclass (tree type, bool modify)
{
type = TYPE_MAIN_VARIANT (type);
currently_open_class (tree t)
{
int i;
- if (t == current_class_type)
+ if (current_class_type && same_type_p (t, current_class_type))
return 1;
for (i = 1; i < current_class_depth; ++i)
- if (current_class_stack [i].type == t)
+ if (current_class_stack[i].type
+ && same_type_p (current_class_stack [i].type, t))
return 1;
return 0;
}
}
/* When entering a class scope, all enclosing class scopes' names with
- static meaning (static variables, static functions, types and enumerators)
- have to be visible. This recursive function calls pushclass for all
- enclosing class contexts until global or a local scope is reached.
- TYPE is the enclosed class and MODIFY is equivalent with the pushclass
- formal of the same name. */
+ static meaning (static variables, static functions, types and
+ enumerators) have to be visible. This recursive function calls
+ pushclass for all enclosing class contexts until global or a local
+ scope is reached. TYPE is the enclosed class. */
void
-push_nested_class (tree type, int modify)
+push_nested_class (tree type)
{
tree context;
context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
if (context && CLASS_TYPE_P (context))
- push_nested_class (context, 2);
- pushclass (type, modify);
+ push_nested_class (context);
+ pushclass (type, true);
}
/* Undoes a push_nested_class call. */
(TREE_CODE (TYPE) == BOOLEAN_TYPE \
|| TREE_CODE (TYPE) == INTEGER_TYPE)
+/* Returns true if TYPE is an integral or enumeration name. */
+#define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \
+ (CP_INTEGRAL_TYPE_P (TYPE) || TREE_CODE (TYPE) == ENUMERAL_TYPE)
+
/* [basic.fundamental]
Integral and floating types are collectively called arithmetic
extern int resolves_to_fixed_type_p (tree, int *);
extern void init_class_processing (void);
extern int is_empty_class (tree);
-extern void pushclass (tree, int);
+extern void pushclass (tree, bool);
extern void popclass (void);
-extern void push_nested_class (tree, int);
+extern void push_nested_class (tree);
extern void pop_nested_class (void);
extern int current_lang_depth (void);
extern void push_lang_context (tree);
extern tree grokfield (tree, tree, tree, tree, tree);
extern tree grokbitfield (tree, tree, tree);
extern tree groktypefield (tree, tree);
-extern tree grokoptypename (tree, tree, tree);
extern void cplus_decl_attributes (tree *, tree, int);
extern tree constructor_name_full (tree);
extern tree constructor_name (tree);
/* in method.c */
extern void init_method (void);
extern void set_mangled_name_for_decl (tree);
-extern tree build_opfncall (enum tree_code, int, tree, tree, tree);
extern tree hack_identifier (tree, tree);
extern tree make_thunk (tree, bool, tree, tree);
extern void finish_thunk (tree);
/* in pt.c */
extern void check_template_shadow (tree);
extern tree get_innermost_template_args (tree, int);
-extern tree tsubst (tree, tree, tsubst_flags_t, tree);
-extern tree tsubst_expr (tree, tree, tsubst_flags_t, tree);
-extern tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
-extern tree tsubst_copy_and_build (tree, tree, tsubst_flags_t, tree);
extern void maybe_begin_member_template_processing (tree);
extern void maybe_end_member_template_processing (void);
extern tree finish_member_template_decl (tree);
extern bool dependent_template_arg_p (tree);
extern bool dependent_template_p (tree);
extern bool type_dependent_expression_p (tree);
+extern bool value_dependent_expression_p (tree);
+extern tree resolve_typename_type (tree, bool);
+extern tree resolve_typename_type_in_current_instantiation (tree);
/* in repo.c */
extern void repo_template_used (tree);
extern tree finish_compound_literal (tree, tree);
extern tree finish_fname (tree);
extern int begin_function_definition (tree, tree, tree);
-extern tree begin_constructor_declarator (tree, tree);
extern tree finish_declarator (tree, tree, tree, tree, int);
extern void finish_translation_unit (void);
extern tree finish_template_type_parm (tree, tree);
extern tree finish_member_class_template (tree);
extern void finish_template_decl (tree);
extern tree finish_template_type (tree, tree, int);
-extern void enter_scope_of (tree);
extern tree finish_base_specifier (tree, tree);
extern void finish_member_declaration (tree);
extern void check_multiple_declarators (void);
static const char *tag_name (enum tag_types code);
static void find_class_binding_level (void);
static struct cp_binding_level *innermost_nonclass_level (void);
-static void warn_about_implicit_typename_lookup (tree, tree);
static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
static int walk_globals_r (tree, void*);
static int walk_vtables_r (tree, void*);
cond = TREE_VALUE (cond);
r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
- if (r == error_mark_node)
- r = NULL_TREE;
check_switch_goto (switch_stack->level);
return val;
}
-/* Any other BINDING overrides an implicit TYPENAME. Warn about
- that. */
-
-static void
-warn_about_implicit_typename_lookup (tree typename, tree binding)
-{
- tree subtype = TREE_TYPE (TREE_TYPE (typename));
- tree name = DECL_NAME (typename);
-
- if (! (TREE_CODE (binding) == TEMPLATE_DECL
- && CLASSTYPE_TEMPLATE_INFO (subtype)
- && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
- && ! (TREE_CODE (binding) == TYPE_DECL
- && same_type_p (TREE_TYPE (binding), subtype)))
- {
- warning ("lookup of `%D' finds `%#D'",
- name, binding);
- warning (" instead of `%D' from dependent base class",
- typename);
- warning (" (use `typename %T::%D' if that's what you meant)",
- constructor_name (current_class_type), name);
- }
-}
-
/* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
bindings.
if (context && COMPLETE_TYPE_P (complete_type (context)))
{
- push_nested_class (context, 2);
+ push_nested_class (context);
if (TREE_CODE (decl) == VAR_DECL)
{
/* Attempt to merge the declarations. This can fail, in
the case of some invalid specialization declarations. */
+ push_scope (ctype);
if (!duplicate_decls (decl, old_decl))
error ("no `%#D' member function declared in class `%T'",
decl, ctype);
+ pop_scope (ctype);
return old_decl;
}
}
attrlist = &returned_attrs;
}
- /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq that refer
- to ctype. They couldn't be resolved earlier because we hadn't
- pushed into the class yet.
-
- For example, consider:
-
- template <typename T>
- struct S {
- typedef T X;
- X f();
- };
-
- template <typename T>
- typename S<T>::X f() {}
-
- When parsing the decl-specifier-seq for the definition of `f',
- we construct a TYPENAME_TYPE for `S<T>::X'. By substituting
- here, we resolve it to the correct type. */
- if (scope && CLASS_TYPE_P (scope)
- && current_template_parms
- && uses_template_parms (scope))
- {
- tree args = current_template_args ();
- push_scope (scope);
- type = tsubst (type, args, tf_error | tf_warning,
- NULL_TREE);
- pop_scope (scope);
- }
-
/* Now TYPE has the actual type. */
/* Did array size calculations overflow? */
/* Set up current_class_type, and enter the scope of the class, if
appropriate. */
if (ctype)
- push_nested_class (ctype, 1);
+ push_nested_class (ctype);
else if (DECL_STATIC_FUNCTION_P (decl1))
- push_nested_class (DECL_CONTEXT (decl1), 2);
+ push_nested_class (DECL_CONTEXT (decl1));
/* Now that we have entered the scope of the class, we must restore
the bindings for any template parameters surrounding DECL1, if it
/* If they have an `operator[]', use that. */
if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp)))
- return build_opfncall (ARRAY_REF, LOOKUP_NORMAL,
- array_expr, index_exp, NULL_TREE);
+ return build_new_op (ARRAY_REF, LOOKUP_NORMAL,
+ array_expr, index_exp, NULL_TREE);
/* Otherwise, create an ARRAY_REF for a pointer or array type. It
is a little-known fact that, if `a' is an array and `i' is an
bool is_conv_op;
const char *format = NULL;
+ push_scope (ctype);
for (fndecls = TREE_VEC_ELT (methods, ix);
fndecls; fndecls = OVL_NEXT (fndecls))
{
&& (!DECL_TEMPLATE_SPECIALIZATION (function)
|| (DECL_TI_TEMPLATE (function)
== DECL_TI_TEMPLATE (fndecl))))
- return fndecl;
+ break;
}
+ pop_scope (ctype);
+ if (fndecls)
+ return OVL_CURRENT (fndecls);
error ("prototype for `%#D' does not match any in class `%T'",
function, ctype);
is_conv_op = DECL_CONV_FN_P (fndecl);
return value;
}
-/* Convert a conversion operator name to an identifier. SCOPE is the
- scope of the conversion operator, if explicit. */
-
-tree
-grokoptypename (tree declspecs, tree declarator, tree scope)
-{
- tree t = grokdeclarator (declarator, declspecs, TYPENAME, 0, NULL);
-
- /* Resolve any TYPENAME_TYPEs that refer to SCOPE, before mangling
- the name, so that we mangle the right thing. */
- if (scope && current_template_parms
- && uses_template_parms (t)
- && uses_template_parms (scope))
- {
- tree args = current_template_args ();
-
- push_scope (scope);
- t = tsubst (t, args, tf_error | tf_warning, NULL_TREE);
- pop_scope (scope);
- }
-
- return mangle_conv_op_name_for_type (t);
-}
-
/* When a function is declared with an initializer,
do the right thing. Currently, there are two possibilities:
if (TREE_CODE (t) == NAMESPACE_DECL)
push_decl_namespace (t);
else if CLASS_TYPE_P (t)
- push_nested_class (t, 2);
+ push_nested_class (t);
}
/* Leave scope pushed by push_scope. */
break;
}
case TYPENAME_TYPE:
+ dump_qualifiers (t, after);
output_add_string (scratch_buffer, "typename ");
dump_typename (t, flags);
break;
return error_mark_node;
}
if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl)))
- return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, decl,
- parmlist, NULL_TREE);
+ return build_new_op (CALL_EXPR, LOOKUP_NORMAL, decl,
+ parmlist, NULL_TREE);
return build_function_call (decl, parmlist);
}
else
}
\f
-/* Given a tree_code CODE, and some arguments (at least one),
- attempt to use an overloaded operator on the arguments.
-
- For unary operators, only the first argument need be checked.
- For binary operators, both arguments may need to be checked.
-
- Member functions can convert class references to class pointers,
- for one-level deep indirection. More than that is not supported.
- Operators [](), ()(), and ->() must be member functions.
-
- We call function call building calls with LOOKUP_COMPLAIN if they
- are our only hope. This is true when we see a vanilla operator
- applied to something of aggregate type. If this fails, we are free
- to return `error_mark_node', because we will have reported the
- error.
-
- Operators NEW and DELETE overload in funny ways: operator new takes
- a single `size' parameter, and operator delete takes a pointer to the
- storage being deleted. When overloading these operators, success is
- assumed. If there is a failure, report an error message and return
- `error_mark_node'. */
-
-/* NOSTRICT */
-tree
-build_opfncall (enum tree_code code, int flags,
- tree xarg1, tree xarg2, tree arg3)
-{
- return build_new_op (code, flags, xarg1, xarg2, arg3);
-}
-\f
/* This function takes an identifier, ID, and attempts to figure out what
it means. There are a number of possible scenarios, presented in increasing
order of hair:
/* TRUE if we are parsing an integral constant-expression. See
[expr.const] for a precise definition. */
- /* FIXME: Need to implement code that checks this flag. */
bool constant_expression_p;
+ /* TRUE if we are parsing an integral constant-expression -- but a
+ non-constant expression should be permitted as well. This flag
+ is used when parsing an array bound so that GNU variable-length
+ arrays are tolerated. */
+ bool allow_non_constant_expression_p;
+
+ /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has
+ been seen that makes the expression non-constant. */
+ bool non_constant_expression_p;
+
/* TRUE if local variable names and `this' are forbidden in the
current context. */
bool local_variables_forbidden_p;
static tree cp_parser_expression
(cp_parser *);
static tree cp_parser_constant_expression
- (cp_parser *);
+ (cp_parser *, bool, bool *);
/* Statements [gram.stmt.stmt] */
(cp_parser *, tree, bool, bool, bool, bool);
static tree cp_parser_lookup_name_simple
(cp_parser *, tree);
-static tree cp_parser_resolve_typename_type
- (cp_parser *, tree);
static tree cp_parser_maybe_treat_template_as_class
(tree, bool);
static bool cp_parser_check_declarator_template_parameters
(cp_parser *);
static void cp_parser_check_type_definition
(cp_parser *);
+static tree cp_parser_non_constant_expression
+ (const char *);
+static tree cp_parser_non_constant_id_expression
+ (tree);
static bool cp_parser_diagnose_invalid_type_name
(cp_parser *);
static bool cp_parser_skip_to_closing_parenthesis
error ("%s", parser->type_definition_forbidden_message);
}
+/* Issue an eror message about the fact that THING appeared in a
+ constant-expression. Returns ERROR_MARK_NODE. */
+
+static tree
+cp_parser_non_constant_expression (const char *thing)
+{
+ error ("%s cannot appear in a constant-expression", thing);
+ return error_mark_node;
+}
+
+/* Issue an eror message about the fact that DECL appeared in a
+ constant-expression. Returns ERROR_MARK_NODE. */
+
+static tree
+cp_parser_non_constant_id_expression (tree decl)
+{
+ error ("`%D' cannot appear in a constant-expression", decl);
+ return error_mark_node;
+}
+
/* Check for a common situation where a type-name should be present,
but is not, and issue a sensible error message. Returns true if an
invalid type-name was detected. */
/* We are not parsing a constant-expression. */
parser->constant_expression_p = false;
+ parser->allow_non_constant_expression_p = false;
+ parser->non_constant_expression_p = false;
/* Local variable names are not forbidden. */
parser->local_variables_forbidden_p = false;
error ("`this' may not be used in this context");
return error_mark_node;
}
+ /* Pointers cannot appear in constant-expressions. */
+ if (parser->constant_expression_p)
+ {
+ if (!parser->allow_non_constant_expression_p)
+ return cp_parser_non_constant_expression ("`this'");
+ parser->non_constant_expression_p = true;
+ }
return finish_this_expr ();
/* The `operator' keyword can be the beginning of an
type = cp_parser_type_id (parser);
/* Look for the closing `)'. */
cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
-
+ /* Using `va_arg' in a constant-expression is not
+ allowed. */
+ if (parser->constant_expression_p)
+ {
+ if (!parser->allow_non_constant_expression_p)
+ return cp_parser_non_constant_expression ("`va_arg'");
+ parser->non_constant_expression_p = true;
+ }
return build_x_va_arg (expression, type);
}
{
if (TYPE_P (TREE_OPERAND (decl, 0)))
*qualifying_class = TREE_OPERAND (decl, 0);
+ /* Since this name was dependent, the expression isn't
+ constant -- yet. No error is issued because it
+ might be constant when things are instantiated. */
+ if (parser->constant_expression_p)
+ parser->non_constant_expression_p = true;
return decl;
}
/* Check to see if DECL is a local variable in a context
{
if (TYPE_P (parser->scope))
*qualifying_class = parser->scope;
+ /* Since this name was dependent, the expression isn't
+ constant -- yet. No error is issued because it
+ might be constant when things are instantiated. */
+ if (parser->constant_expression_p)
+ parser->non_constant_expression_p = true;
return build_nt (SCOPE_REF,
parser->scope,
id_expression);
we need. */
if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
return id_expression;
+ /* Since this name was dependent, the expression isn't
+ constant -- yet. No error is issued because it
+ might be constant when things are instantiated. */
+ if (parser->constant_expression_p)
+ parser->non_constant_expression_p = true;
/* Create a LOOKUP_EXPR for other unqualified names. */
return build_min_nt (LOOKUP_EXPR, id_expression);
}
+ /* Only certain kinds of names are allowed in constant
+ expression. Enumerators have already been handled
+ above. */
+ if (parser->constant_expression_p
+ /* Non-type template parameters of integral or
+ enumeration type. */
+ && !(TREE_CODE (decl) == TEMPLATE_PARM_INDEX
+ && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl)))
+ /* Const variables or static data members of integral
+ or enumeration types initialized with constant
+ expressions. */
+ && !(TREE_CODE (decl) == VAR_DECL
+ && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl))
+ && DECL_INITIAL (decl)
+ && TREE_CONSTANT (DECL_INITIAL (decl))))
+ {
+ if (!parser->allow_non_constant_expression_p)
+ return cp_parser_non_constant_id_expression (decl);
+ parser->non_constant_expression_p = true;
+ }
+
if (parser->scope)
{
decl = (adjust_result_of_qualified_name_lookup
expression = cp_parser_expression (parser);
cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+ /* Only type conversions to integral or enumeration types
+ can be used in constant-expressions. */
+ if (parser->constant_expression_p
+ && !dependent_type_p (type)
+ && !INTEGRAL_OR_ENUMERATION_TYPE_P (type))
+ {
+ if (!parser->allow_non_constant_expression_p)
+ return (cp_parser_non_constant_expression
+ ("a cast to a type other than an integral or "
+ "enumeration type"));
+ parser->non_constant_expression_p = true;
+ }
+
switch (keyword)
{
case RID_DYNCAST:
/* If the functional-cast didn't work out, try a
compound-literal. */
- if (cp_parser_allow_gnu_extensions_p (parser))
+ if (cp_parser_allow_gnu_extensions_p (parser)
+ && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
{
tree initializer_list = NULL_TREE;
cp_parser_parse_tentatively (parser);
- /* Look for the `('. */
- if (cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
+ /* Consume the `('. */
+ cp_lexer_consume_token (parser->lexer);
+ /* Parse the type. */
+ type = cp_parser_type_id (parser);
+ /* Look for the `)'. */
+ cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+ /* Look for the `{'. */
+ cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");
+ /* If things aren't going well, there's no need to
+ keep going. */
+ if (!cp_parser_error_occurred (parser))
{
- type = cp_parser_type_id (parser);
- /* Look for the `)'. */
- cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
- /* Look for the `{'. */
- cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");
- /* If things aren't going well, there's no need to
- keep going. */
- if (!cp_parser_error_occurred (parser))
- {
- /* Parse the initializer-list. */
- initializer_list
- = cp_parser_initializer_list (parser);
- /* Allow a trailing `,'. */
- if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
- cp_lexer_consume_token (parser->lexer);
- /* Look for the final `}'. */
- cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
- }
+ /* Parse the initializer-list. */
+ initializer_list
+ = cp_parser_initializer_list (parser);
+ /* Allow a trailing `,'. */
+ if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
+ cp_lexer_consume_token (parser->lexer);
+ /* Look for the final `}'. */
+ cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
}
/* If that worked, we're definitely looking at a
compound-literal expression. */
args = NULL_TREE;
/* Look for the closing `)'. */
cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+ /* Function calls are not permitted in
+ constant-expressions. */
+ if (parser->constant_expression_p)
+ {
+ if (!parser->allow_non_constant_expression_p)
+ return cp_parser_non_constant_expression ("a function call");
+ parser->non_constant_expression_p = true;
+ }
if (idk == CP_PARSER_ID_KIND_UNQUALIFIED
&& (is_overloaded_fn (postfix_expression)
/* postfix-expression ++ */
/* Consume the `++' token. */
cp_lexer_consume_token (parser->lexer);
+ /* Increments may not appear in constant-expressions. */
+ if (parser->constant_expression_p)
+ {
+ if (!parser->allow_non_constant_expression_p)
+ return cp_parser_non_constant_expression ("an increment");
+ parser->non_constant_expression_p = true;
+ }
/* Generate a reprsentation for the complete expression. */
postfix_expression
= finish_increment_expr (postfix_expression,
/* postfix-expression -- */
/* Consume the `--' token. */
cp_lexer_consume_token (parser->lexer);
+ /* Decrements may not appear in constant-expressions. */
+ if (parser->constant_expression_p)
+ {
+ if (!parser->allow_non_constant_expression_p)
+ return cp_parser_non_constant_expression ("a decrement");
+ parser->non_constant_expression_p = true;
+ }
/* Generate a reprsentation for the complete expression. */
postfix_expression
= finish_increment_expr (postfix_expression,
case ADDR_EXPR:
return build_x_unary_op (ADDR_EXPR, cast_expression);
+ case PREINCREMENT_EXPR:
+ case PREDECREMENT_EXPR:
+ if (parser->constant_expression_p)
+ {
+ if (!parser->allow_non_constant_expression_p)
+ return cp_parser_non_constant_expression (PREINCREMENT_EXPR
+ ? "an increment"
+ : "a decrement");
+ parser->non_constant_expression_p = true;
+ }
+ /* Fall through. */
case CONVERT_EXPR:
case NEGATE_EXPR:
case TRUTH_NOT_EXPR:
- case PREINCREMENT_EXPR:
- case PREDECREMENT_EXPR:
return finish_unary_op_expr (unary_operator, cast_expression);
case BIT_NOT_EXPR:
}
/* But all the other expressions must be. */
else
- expression = cp_parser_constant_expression (parser);
+ expression
+ = cp_parser_constant_expression (parser,
+ /*allow_non_constant=*/false,
+ NULL);
/* Look for the closing `]'. */
cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
&& !VOID_TYPE_P (type)
&& current_lang_name != lang_name_c)
warning ("use of old-style cast");
-
+
+ /* Only type conversions to integral or enumeration types
+ can be used in constant-expressions. */
+ if (parser->constant_expression_p
+ && !dependent_type_p (type)
+ && !INTEGRAL_OR_ENUMERATION_TYPE_P (type))
+ {
+ if (!parser->allow_non_constant_expression_p)
+ return (cp_parser_non_constant_expression
+ ("a casts to a type other than an integral or "
+ "enumeration type"));
+ parser->non_constant_expression_p = true;
+ }
/* Perform the cast. */
expr = build_c_cast (type, expr);
return expr;
/* Parse the right-hand side of the assignment. */
rhs = cp_parser_assignment_expression (parser);
+ /* An assignment may not appear in a
+ constant-expression. */
+ if (parser->constant_expression_p)
+ {
+ if (!parser->allow_non_constant_expression_p)
+ return cp_parser_non_constant_expression ("an assignment");
+ parser->non_constant_expression_p = true;
+ }
/* Build the asignment expression. */
expr = build_x_modify_expr (expr,
assignment_operator,
necessary. We built up the list in reverse order, so we must
straighten it out here. */
if (saw_comma_p)
- expression = build_x_compound_expr (nreverse (expression));
+ {
+ /* A comma operator cannot appear in a constant-expression. */
+ if (parser->constant_expression_p)
+ {
+ if (!parser->allow_non_constant_expression_p)
+ return cp_parser_non_constant_expression ("a comma operator");
+ parser->non_constant_expression_p = true;
+ }
+ expression = build_x_compound_expr (nreverse (expression));
+ }
return expression;
}
/* Parse a constant-expression.
constant-expression:
- conditional-expression */
+ conditional-expression
+
+ If ALLOW_NON_CONSTANT_P a non-constant expression is silently
+ accepted. In that case *NON_CONSTANT_P is set to TRUE. If
+ ALLOW_NON_CONSTANT_P is false, NON_CONSTANT_P should be NULL. */
static tree
-cp_parser_constant_expression (cp_parser* parser)
+cp_parser_constant_expression (cp_parser* parser,
+ bool allow_non_constant_p,
+ bool *non_constant_p)
{
bool saved_constant_expression_p;
+ bool saved_allow_non_constant_expression_p;
+ bool saved_non_constant_expression_p;
tree expression;
/* It might seem that we could simply parse the
constant-expression. However, GCC's constant-folding machinery
will fold this operation to an INTEGER_CST for `3'. */
- /* Save the old setting of CONSTANT_EXPRESSION_P. */
+ /* Save the old settings. */
saved_constant_expression_p = parser->constant_expression_p;
+ saved_allow_non_constant_expression_p
+ = parser->allow_non_constant_expression_p;
+ saved_non_constant_expression_p = parser->non_constant_expression_p;
/* We are now parsing a constant-expression. */
parser->constant_expression_p = true;
+ parser->allow_non_constant_expression_p = allow_non_constant_p;
+ parser->non_constant_expression_p = false;
/* Parse the conditional-expression. */
expression = cp_parser_conditional_expression (parser);
- /* Restore the old setting of CONSTANT_EXPRESSION_P. */
+ /* Restore the old settings. */
parser->constant_expression_p = saved_constant_expression_p;
+ parser->allow_non_constant_expression_p
+ = saved_allow_non_constant_expression_p;
+ if (allow_non_constant_p)
+ *non_constant_p = parser->non_constant_expression_p;
+ parser->non_constant_expression_p = saved_non_constant_expression_p;
return expression;
}
/* Consume the `case' token. */
cp_lexer_consume_token (parser->lexer);
/* Parse the constant-expression. */
- expr = cp_parser_constant_expression (parser);
+ expr = cp_parser_constant_expression (parser,
+ /*allow_non_constant=*/false,
+ NULL);
/* Create the label. */
statement = finish_case_label (expr, NULL_TREE);
}
/* Consume the `=' token. */
cp_lexer_consume_token (parser->lexer);
/* Parse the value. */
- value = cp_parser_constant_expression (parser);
+ value = cp_parser_constant_expression (parser,
+ /*allow_non_constant=*/false,
+ NULL);
}
else
value = NULL_TREE;
/* If the next token is `]', then there is no
constant-expression. */
if (token->type != CPP_CLOSE_SQUARE)
- bounds = cp_parser_constant_expression (parser);
+ {
+ bool non_constant_p;
+
+ bounds
+ = cp_parser_constant_expression (parser,
+ /*allow_non_constant=*/true,
+ &non_constant_p);
+ /* If we're in a template, but the constant-expression
+ isn't value dependent, simplify it. We're supposed
+ to treat:
+
+ template <typename T> void f(T[1 + 1]);
+ template <typename T> void f(T[2]);
+
+ as two declarations of the same function, for
+ example. */
+ if (processing_template_decl
+ && !non_constant_p
+ && !value_dependent_expression_p (bounds))
+ {
+ HOST_WIDE_INT saved_processing_template_decl;
+
+ saved_processing_template_decl = processing_template_decl;
+ processing_template_decl = 0;
+ bounds = build_expr_from_tree (bounds);
+ processing_template_decl = saved_processing_template_decl;
+ }
+ }
else
bounds = NULL_TREE;
/* Look for the closing `]'. */
is no harm in resolving the types here. */
if (TREE_CODE (scope) == TYPENAME_TYPE)
{
+ tree type;
+
/* Resolve the TYPENAME_TYPE. */
- scope = cp_parser_resolve_typename_type (parser, scope);
+ type = resolve_typename_type (scope,
+ /*only_current_p=*/false);
/* If that failed, the declarator is invalid. */
- if (scope == error_mark_node)
- return error_mark_node;
+ if (type != error_mark_node)
+ scope = type;
/* Build a new DECLARATOR. */
declarator = build_nt (SCOPE_REF,
scope,
/* Given:
template <typename T> struct S { struct T };
- template <typename T> struct S::T { };
+ template <typename T> struct S<T>::T { };
we will get a TYPENAME_TYPE when processing the definition of
`S::T'. We need to resolve it to the actual type before we
try to define it. */
if (TREE_CODE (TREE_TYPE (type)) == TYPENAME_TYPE)
{
- type = cp_parser_resolve_typename_type (parser, TREE_TYPE (type));
- if (type != error_mark_node)
- type = TYPE_NAME (type);
+ class_type = resolve_typename_type (TREE_TYPE (type),
+ /*only_current_p=*/false);
+ if (class_type != error_mark_node)
+ type = TYPE_NAME (class_type);
+ else
+ {
+ cp_parser_error (parser, "could not resolve typename type");
+ type = error_mark_node;
+ }
}
maybe_process_partial_specialization (TREE_TYPE (type));
/* Consume the `:' token. */
cp_lexer_consume_token (parser->lexer);
/* Get the width of the bitfield. */
- width = cp_parser_constant_expression (parser);
+ width
+ = cp_parser_constant_expression (parser,
+ /*allow_non_constant=*/false,
+ NULL);
/* Look for attributes that apply to the bitfield. */
attributes = cp_parser_attributes_opt (parser);
return error_mark_node;
}
- return cp_parser_constant_expression (parser);
+ return cp_parser_constant_expression (parser,
+ /*allow_non_constant=*/false,
+ NULL);
}
/* Derived classes [gram.class.derived] */
/*check_dependency=*/true);
}
-/* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
- TYPENAME_TYPE corresponds. Note that this function peers inside
- uninstantiated templates and therefore should be used only in
- extremely limited situations. */
-
-static tree
-cp_parser_resolve_typename_type (cp_parser* parser, tree type)
-{
- tree scope;
- tree name;
- tree decl;
-
- my_friendly_assert (TREE_CODE (type) == TYPENAME_TYPE,
- 20010702);
-
- scope = TYPE_CONTEXT (type);
- name = TYPE_IDENTIFIER (type);
-
- /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
- it first before we can figure out what NAME refers to. */
- if (TREE_CODE (scope) == TYPENAME_TYPE)
- scope = cp_parser_resolve_typename_type (parser, scope);
- /* If we don't know what SCOPE refers to, then we cannot resolve the
- TYPENAME_TYPE. */
- if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
- return error_mark_node;
- /* If the SCOPE is a template type parameter, we have no way of
- resolving the name. */
- if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
- return type;
- /* Enter the SCOPE so that name lookup will be resolved as if we
- were in the class definition. In particular, SCOPE will no
- longer be considered a dependent type. */
- push_scope (scope);
- /* Look up the declaration. */
- decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/1);
- /* If all went well, we got a TYPE_DECL for a non-typename. */
- if (!decl
- || TREE_CODE (decl) != TYPE_DECL
- || TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
- {
- cp_parser_error (parser, "could not resolve typename type");
- type = error_mark_node;
- }
- else
- type = TREE_TYPE (decl);
- /* Leave the SCOPE. */
- pop_scope (scope);
-
- return type;
-}
-
/* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
the current context, return the TYPE_DECL. If TAG_NAME_P is
true, the DECL indicates the class being defined in a class-head,
{
type = TREE_TYPE (type_decl);
if (TREE_CODE (type) == TYPENAME_TYPE)
- type = cp_parser_resolve_typename_type (parser, type);
+ {
+ type = resolve_typename_type (type,
+ /*only_current_p=*/false);
+ if (type == error_mark_node)
+ {
+ cp_parser_abort_tentative_parse (parser);
+ return false;
+ }
+ }
push_scope (type);
}
/* Look for the type-specifier. */
parser->local_variables_forbidden_p = true;
/* Parse the assignment-expression. */
if (DECL_CONTEXT (fn))
- push_nested_class (DECL_CONTEXT (fn), 1);
+ push_nested_class (DECL_CONTEXT (fn));
TREE_PURPOSE (parameters) = cp_parser_assignment_expression (parser);
if (DECL_CONTEXT (fn))
pop_nested_class ();
static int invalid_nontype_parm_type_p PARAMS ((tree, tsubst_flags_t));
static int eq_local_specializations (const void *, const void *);
static tree template_for_substitution (tree);
-static bool value_dependent_expression_p (tree);
static bool dependent_template_id_p (tree, tree);
+static tree tsubst (tree, tree, tsubst_flags_t, tree);
+static tree tsubst_expr (tree, tree, tsubst_flags_t, tree);
+static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
+static tree tsubst_copy_and_build (tree, tree, tsubst_flags_t, tree);
/* Make the current scope suitable for access checking when we are
processing T. T can be FUNCTION_DECL for instantiated function
if (!context)
context = DECL_CONTEXT (t);
if (context && TYPE_P (context))
- push_nested_class (context, 2);
+ push_nested_class (context);
else
push_to_top_level ();
if (TREE_CODE (context) == NAMESPACE_DECL)
push_nested_namespace (context);
else
- push_nested_class (tsubst (context, args, tf_none, NULL_TREE), 2);
+ push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
}
/* First, we look for a class template. */
correctly. This is precisely analogous to what we do in
begin_class_definition when defining an ordinary non-template
class. */
- pushclass (type, 1);
+ pushclass (type, true);
/* Now members are processed in the order of declaration. */
for (member = CLASSTYPE_DECL_LIST (pattern); member; member = TREE_CHAIN (member))
This function is used for dealing with types, decls and the like;
for expressions, use tsubst_expr or tsubst_copy. */
-tree
+static tree
tsubst (t, args, complain, in_decl)
tree t, args;
tsubst_flags_t complain;
template parms; to finish processing the resultant expression, use
tsubst_expr. */
-tree
+static tree
tsubst_copy (t, args, complain, in_decl)
tree t, args;
tsubst_flags_t complain;
/* Like tsubst_copy for expressions, etc. but also does semantic
processing. */
-tree
+static tree
tsubst_expr (t, args, complain, in_decl)
tree t, args;
tsubst_flags_t complain;
/* Like tsubst but deals with expressions and performs semantic
analysis. */
-tree
+static tree
tsubst_copy_and_build (t, args, complain, in_decl)
tree t, args;
tsubst_flags_t complain;
/* Returns TRUE if the EXPRESSION is value-dependent. */
-static bool
+bool
value_dependent_expression_p (tree expression)
{
if (!processing_template_decl)
return false;
/* A name declared with a dependent type. */
- if (DECL_P (expression)
- && dependent_type_p (TREE_TYPE (expression)))
+ if (TREE_CODE (expression) == LOOKUP_EXPR
+ || (DECL_P (expression)
+ && dependent_type_p (TREE_TYPE (expression))))
return true;
/* A non-type template parameter. */
if ((TREE_CODE (expression) == CONST_DECL
case 'e':
{
int i;
- for (i = 0;
- i < TREE_CODE_LENGTH (TREE_CODE (expression));
- ++i)
- if (value_dependent_expression_p
- (TREE_OPERAND (expression, i)))
+ for (i = 0; i < first_rtl_op (TREE_CODE (expression)); ++i)
+ /* In some cases, some of the operands may be missing.
+ (For example, in the case of PREDECREMENT_EXPR, the
+ amount to increment by may be missing.) That doesn't
+ make the expression dependent. */
+ if (TREE_OPERAND (expression, i)
+ && (value_dependent_expression_p
+ (TREE_OPERAND (expression, i))))
return true;
return false;
}
return false;
}
+/* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
+ TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
+ can be found. Note that this function peers inside uninstantiated
+ templates and therefore should be used only in extremely limited
+ situations. */
+
+tree
+resolve_typename_type (tree type, bool only_current_p)
+{
+ tree scope;
+ tree name;
+ tree decl;
+ int quals;
+
+ my_friendly_assert (TREE_CODE (type) == TYPENAME_TYPE,
+ 20010702);
+
+ scope = TYPE_CONTEXT (type);
+ name = TYPE_IDENTIFIER (type);
+
+ /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
+ it first before we can figure out what NAME refers to. */
+ if (TREE_CODE (scope) == TYPENAME_TYPE)
+ scope = resolve_typename_type (scope, only_current_p);
+ /* If we don't know what SCOPE refers to, then we cannot resolve the
+ TYPENAME_TYPE. */
+ if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
+ return error_mark_node;
+ /* If the SCOPE is a template type parameter, we have no way of
+ resolving the name. */
+ if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
+ return type;
+ /* If the SCOPE is not the current instantiation, there's no reason
+ to look inside it. */
+ if (only_current_p && !currently_open_class (scope))
+ return error_mark_node;
+ /* Enter the SCOPE so that name lookup will be resolved as if we
+ were in the class definition. In particular, SCOPE will no
+ longer be considered a dependent type. */
+ push_scope (scope);
+ /* Look up the declaration. */
+ decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/1);
+ /* Obtain the set of qualifiers applied to the TYPE. */
+ quals = cp_type_quals (type);
+ /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
+ find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
+ if (!decl)
+ type = error_mark_node;
+ else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
+ && TREE_CODE (decl) == TYPE_DECL)
+ type = TREE_TYPE (decl);
+ else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
+ && DECL_CLASS_TEMPLATE_P (decl))
+ {
+ tree tmpl;
+ tree args;
+ /* Obtain the template and the arguments. */
+ tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
+ args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
+ /* Instantiate the template. */
+ type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
+ /*entering_scope=*/0,
+ tf_error);
+ }
+ else
+ type = error_mark_node;
+ /* Qualify the resulting type. */
+ if (type != error_mark_node && quals)
+ type = cp_build_qualified_type (type, quals);
+ /* Leave the SCOPE. */
+ pop_scope (scope);
+
+ return type;
+}
+
+tree
+resolve_typename_type_in_current_instantiation (tree type)
+{
+ tree t;
+
+ t = resolve_typename_type (type, /*only_current_p=*/true);
+ return (t != error_mark_node) ? t : type;
+}
+
#include "gt-cp-pt.h"
/* If the "function" is really an object of class type, it might
have an overloaded `operator ()'. */
tree result;
- result = build_opfncall (CALL_EXPR, LOOKUP_NORMAL, fn, args, NULL_TREE);
+ result = build_new_op (CALL_EXPR, LOOKUP_NORMAL, fn, args, NULL_TREE);
if (result)
return result;
}
return 1;
}
-/* Begin a constructor declarator of the form `SCOPE::NAME'. Returns
- a SCOPE_REF. */
-
-tree
-begin_constructor_declarator (scope, name)
- tree scope;
- tree name;
-{
- tree result = build_nt (SCOPE_REF, scope, name);
- enter_scope_of (result);
- return result;
-}
-
/* Finish an init-declarator. Returns a DECL. */
tree
pushtag (TYPE_IDENTIFIER (t), t, 0);
}
maybe_process_partial_specialization (t);
- pushclass (t, 1);
+ pushclass (t, true);
TYPE_BEING_DEFINED (t) = 1;
TYPE_PACKED (t) = flag_pack_struct;
/* Reset the interface data, at the earliest possible
return decl;
}
-/* SR is a SCOPE_REF node. Enter the scope of SR, whether it is a
- namespace scope or a class scope. */
-
-void
-enter_scope_of (sr)
- tree sr;
-{
- tree scope = TREE_OPERAND (sr, 0);
-
- if (TREE_CODE (scope) == NAMESPACE_DECL)
- {
- push_decl_namespace (scope);
- TREE_COMPLEXITY (sr) = -1;
- }
- else if (scope != current_class_type)
- {
- if (TREE_CODE (scope) == TYPENAME_TYPE)
- {
- /* In a declarator for a template class member, the scope will
- get here as an implicit typename, a TYPENAME_TYPE with a type. */
- scope = TREE_TYPE (scope);
- TREE_OPERAND (sr, 0) = scope;
- }
- push_nested_class (scope, 3);
- TREE_COMPLEXITY (sr) = current_class_depth;
- }
-}
-
/* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
Return a TREE_LIST containing the ACCESS_SPECIFIER and the
BASE_CLASS, or NULL_TREE if an error occurred. The
if (TYPE_PTRMEMFUNC_P (t2))
t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
+ /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
+ current instantiation. */
+ if (TREE_CODE (t1) == TYPENAME_TYPE)
+ t1 = resolve_typename_type_in_current_instantiation (t1);
+ if (TREE_CODE (t2) == TYPENAME_TYPE)
+ t2 = resolve_typename_type_in_current_instantiation (t2);
+
/* Different classes of types can't be compatible. */
if (TREE_CODE (t1) != TREE_CODE (t2))
return 0;
if (processing_template_decl)
return build_min_nt (INDIRECT_REF, ptr);
- rval = build_opfncall (INDIRECT_REF, LOOKUP_NORMAL, ptr, NULL_TREE,
- NULL_TREE);
+ rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, ptr, NULL_TREE,
+ NULL_TREE);
if (rval)
return rval;
return build_indirect_ref (ptr, errorstring);
return build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE);
}
+#if 0
+
+tree
+build_template_expr (enum tree_code code, tree op0, tree op1, tree op2)
+{
+ tree type;
+
+ /* If any of the operands is erroneous the result is erroneous too. */
+ if (error_operand_p (op0)
+ || (op1 && error_operand_p (op1))
+ || (op2 && error_operand_p (op2)))
+ return error_mark_node;
+
+ if (dependent_type_p (TREE_TYPE (op0))
+ || (op1 && dependent_type_p (TREE_TYPE (op1)))
+ || (op2 && dependent_type_p (TREE_TYPE (op2))))
+ /* If at least one operand has a dependent type, we cannot
+ determine the type of the expression until instantiation time. */
+ type = NULL_TREE;
+ else
+ {
+ struct z_candidate *cand;
+ tree op0_type;
+ tree op1_type;
+ tree op2_type;
+
+ /* None of the operands is dependent, so we can compute the type
+ of the expression at this point. We must compute the type so
+ that in things like:
+
+ template <int I>
+ void f() { S<sizeof(I + 3)> s; ... }
+
+ we can tell that the type of "s" is non-dependent.
+
+ If we're processing a template argument, we do not want to
+ actually change the operands in any way. Adding conversions,
+ performing constant folding, etc., would all change mangled
+ names. For example, in:
+
+ template <int I>
+ void f(S<sizeof(3 + 4 + I)>);
+
+ we need to determine that "3 + 4 + I" has type "int", without
+ actually turning the expression into "7 + I". */
+ cand = find_overloaded_op (code, op0, op1, op2);
+ if (cand)
+ /* If an overloaded operator was found, the expression will
+ have the type returned by the function. */
+ type = non_reference (TREE_TYPE (cand->fn));
+ else
+ {
+ /* There is no overloaded operator so we can just use the
+ default rules for determining the type of the operand. */
+ op0_type = TREE_TYPE (op0);
+ op1_type = op1 ? TREE_TYPE (op1) : NULL_TREE;
+ op2_type = op2 ? TREE_TYPE (op2) : NULL_TREE;
+ type = NULL_TREE;
+
+ switch (code)
+ {
+ case MODIFY_EXPR:
+ /* [expr.ass]
+
+ The result of the assignment operation is the value
+ stored in the left operand. */
+ type = op0_type;
+ break;
+ case COMPONENT_REF:
+ /* Implement this case. */
+ break;
+ case POSTINCREMENT_EXPR:
+ case POSTDECREMENT_EXPR:
+ /* [expr.post.incr]
+
+ The type of the result is the cv-unqualified version
+ of the type of the operand. */
+ type = TYPE_MAIN_VARIANT (op0_type);
+ break;
+ case PREINCREMENT_EXPR:
+ case PREDECREMENT_EXPR:
+ /* [expr.pre.incr]
+
+ The value is the new value of the operand. */
+ type = op0_type;
+ break;
+ case INDIRECT_REF:
+ /* [expr.unary.op]
+
+ If the type of the expression is "pointer to T", the
+ type of the result is "T". */
+ type = TREE_TYPE (op0_type);
+ break;
+ case ADDR_EXPR:
+ /* [expr.unary.op]
+
+ If the type of the expression is "T", the type of the
+ result is "pointer to T". */
+ /* FIXME: Handle the pointer-to-member case. */
+ break;
+ case MEMBER_REF:
+ /* FIXME: Implement this case. */
+ break;
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ /* [expr.shift]
+
+ The type of the result is that of the promoted left
+ operand. */
+ break;
+ case PLUS_EXPR:
+ case MINUS_EXPR:
+ /* FIXME: Be careful of special pointer-arithmetic
+ cases. */
+ /* Fall through. */
+ case MAX_EXPR:
+ case MIN_EXPR:
+ /* These are GNU extensions; the result type is computed
+ as it would be for other arithmetic operators. */
+ /* Fall through. */
+ case BIT_AND_EXPR:
+ case BIT_XOR_EXPR:
+ case BIT_IOR_EXPR:
+ case MULT_EXPR:
+ case TRUNC_DIV_EXPR:
+ case TRUNC_MOD_EXPR:
+ /* [expr.bit.and], [expr.xor], [expr.or], [expr.mul]
+
+ The usual arithmetic conversions are performed on the
+ operands and determine the type of the result. */
+ /* FIXME: Check that this is possible. */
+ type = type_after_usual_arithmetic_conversions (t1, t2);
+ break;
+ case GT_EXPR:
+ case LT_EXPR:
+ case GE_EXPR:
+ case LE_EXPR:
+ case EQ_EXPR:
+ case NE_EXPR:
+ /* [expr.rel]
+
+ The type of the result is bool. */
+ type = boolean_type_node;
+ break;
+ case TRUTH_ANDIF_EXPR:
+ case TRUTH_ORIF_EXPR:
+ /* [expr.log.and], [expr.log.org]
+
+ The result is a bool. */
+ type = boolean_type_node;
+ break;
+ case COND_EXPR:
+ /* FIXME: Handle special rules for conditioanl
+ expressions. */
+ break;
+ case COMPOUND_EXPR:
+ type = op1_type;
+ break;
+ default:
+ abort ();
+ }
+ /* If the type of the expression could not be determined,
+ something is wrong. */
+ if (!type)
+ abort ();
+ /* If the type is erroneous, the expression is erroneous
+ too. */
+ if (type == error_mark_node)
+ return error_mark_node;
+ }
+ }
+
+ return build_min (code, type, op0, op1, op2, NULL_TREE);
+}
+
+#endif
+
/* Build a binary-operation expression without default conversions.
CODE is the kind of expression to build.
This function differs from `build' in several ways:
if (rest == NULL_TREE)
return build_compound_expr (list);
- result = build_opfncall (COMPOUND_EXPR, LOOKUP_NORMAL,
- TREE_VALUE (list), TREE_VALUE (rest), NULL_TREE);
+ result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL,
+ TREE_VALUE (list), TREE_VALUE (rest), NULL_TREE);
if (result)
return build_x_compound_expr (tree_cons (NULL_TREE, result,
TREE_CHAIN (rest)));
/* Do the default thing */;
else
{
- result = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL,
- lhs, rhs, make_node (NOP_EXPR));
+ result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
+ lhs, rhs, make_node (NOP_EXPR));
if (result == NULL_TREE)
return error_mark_node;
return result;
if (modifycode != NOP_EXPR)
{
- tree rval = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
- make_node (modifycode));
+ tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
+ make_node (modifycode));
if (rval)
return rval;
}
if (IS_AGGR_TYPE (type))
{
- while ((rval = build_opfncall (COMPONENT_REF, LOOKUP_NORMAL, rval,
- NULL_TREE, NULL_TREE)))
+ while ((rval = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, rval,
+ NULL_TREE, NULL_TREE)))
{
if (rval == error_mark_node)
return error_mark_node;
+2003-01-29 Mark Mitchell <mark@codesourcery.com>
+
+ * g++.dg/parser/constant1.C: New test.
+
2003-01-29 Kriang Lerdsuwanakij <lerdsuwa@users.sourceforge.net>
PR c++/8591
--- /dev/null
+void f () {
+ switch (0) {
+ case (3, 0): // { dg-error "" }
+ break;
+ }
+}
+
+int g ();
+
+struct S {
+ int i : (false ? g () : 1); // { dg-error "" }
+};
+
+2003-01-29 Mark Mitchell <mark@codesourcery.com>
+
+ * include/std/std_limits.h (numeric_limits<float>::has_infinity):
+ Use __FLT_HAS_INIFINITY__ to initialize.
+ (numeric_limits<float>::has_quiet_NaN): Likewise.
+ (numeric_limits<double>::has_infinity): Use __DBL_HAS_INIFINITY__
+ to initialize.
+ (numeric_limits<double>::has_quiet_NaN): Likewise.
+ (numeric_limits<long double>::has_infinity): Use
+ __LDBL_HAS_INIFINITY__ to initialize.
+ (numeric_limits<long_double>::has_quiet_NaN): Likewise.
+
2003-01-28 Nathan Sidwell <nathan@codesourcery.com>
PR c++/9433
// The template and inlines for the -*- C++ -*- numeric_limits classes.
-// Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+// Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
static const int max_exponent = __FLT_MAX_EXP__;
static const int max_exponent10 = __FLT_MAX_10_EXP__;
- static const bool has_infinity
- = __builtin_huge_valf () / 2 == __builtin_huge_valf ();
- static const bool has_quiet_NaN
- = __builtin_nanf ("") != __builtin_nanf ("");
+ static const bool has_infinity = __FLT_HAS_INFINITY__;
+ static const bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
static const bool has_signaling_NaN = has_quiet_NaN;
static const float_denorm_style has_denorm
= __FLT_DENORM_MIN__ ? denorm_present : denorm_absent;
static const int max_exponent = __DBL_MAX_EXP__;
static const int max_exponent10 = __DBL_MAX_10_EXP__;
- static const bool has_infinity
- = __builtin_huge_val () / 2 == __builtin_huge_val ();
- static const bool has_quiet_NaN
- = __builtin_nan ("") != __builtin_nan ("");
+ static const bool has_infinity = __DBL_HAS_INFINITY__;
+ static const bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
static const bool has_signaling_NaN = has_quiet_NaN;
static const float_denorm_style has_denorm
= __DBL_DENORM_MIN__ ? denorm_present : denorm_absent;
static const int max_exponent = __LDBL_MAX_EXP__;
static const int max_exponent10 = __LDBL_MAX_10_EXP__;
- static const bool has_infinity
- = __builtin_huge_vall () / 2 == __builtin_huge_vall ();
- static const bool has_quiet_NaN
- = __builtin_nanl ("") != __builtin_nanl ("");
+ static const bool has_infinity = __LDBL_HAS_INFINITY__;
+ static const bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
static const bool has_signaling_NaN = has_quiet_NaN;
static const float_denorm_style has_denorm
= __LDBL_DENORM_MIN__ ? denorm_present : denorm_absent;
OSDN Git Service
