/* Language-dependent node constructors for parse phase of GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
Hacked by Michael Tiemann (tiemann@cygnus.com)
This file is part of GCC.
/* A currently unresolved scope ref. */
case SCOPE_REF:
- abort ();
+ gcc_unreachable ();
case MAX_EXPR:
case MIN_EXPR:
+ /* Disallow <? and >? as lvalues if either argument side-effects. */
+ if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
+ || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
+ return clk_none;
op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
treat_class_rvalues_as_lvalues);
op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
(lvalue_p_1 (ref, /*class rvalue ok*/ 1) != clk_none);
}
-/* Return nonzero if REF is an lvalue valid for this language;
- otherwise, print an error message and return zero. */
-
-int
-lvalue_or_else (tree ref, const char* string)
-{
- if (!lvalue_p (ref))
- {
- error ("non-lvalue in %s", string);
- return 0;
- }
- return 1;
-}
-
/* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
static tree
tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
if (!(complain & tf_ignore_bad_quals))
- error ("`%V' qualifiers cannot be applied to `%T'",
+ error ("%qV qualifiers cannot be applied to %qT",
bad_type, type);
}
}
tree base_binfo;
gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo));
- gcc_assert (type == BINFO_TYPE (binfo));
+ gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
count_functions (tree t)
{
int i;
+
if (TREE_CODE (t) == FUNCTION_DECL)
return 1;
- else if (TREE_CODE (t) == OVERLOAD)
- {
- for (i = 0; t; t = OVL_CHAIN (t))
- i++;
- return i;
- }
-
- abort ();
- return 0;
+ gcc_assert (TREE_CODE (t) == OVERLOAD);
+
+ for (i = 0; t; t = OVL_CHAIN (t))
+ i++;
+ return i;
}
int
ring_counter += 1;
if (ring_counter == PRINT_RING_SIZE)
ring_counter = 0;
- if (decl_ring[ring_counter] == current_function_decl)
- abort ();
+ gcc_assert (decl_ring[ring_counter] != current_function_decl);
}
if (print_ring[ring_counter])
/* If this statement is already present in the hash table, then
there is a circularity in the statement tree. */
- if (htab_find (*statements, t))
- abort ();
+ gcc_assert (!htab_find (*statements, t));
slot = htab_find_slot (*statements, t, INSERT);
*slot = t;
return t;
if (TYPE_P (t))
return TYPE_STUB_DECL (t);
- if (t == error_mark_node)
- return t;
-
- abort ();
-
- /* Stop compiler from complaining control reaches end of non-void function. */
- return 0;
+ gcc_assert (t == error_mark_node);
+ return t;
}
/* Returns the namespace that contains DECL, whether directly or
case IDENTIFIER_NODE:
return false;
+ case BASELINK:
+ return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
+ && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
+ && cp_tree_equal (BASELINK_FUNCTIONS (t1),
+ BASELINK_FUNCTIONS (t2)));
+
case TEMPLATE_PARM_INDEX:
return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
&& TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
+ case OVERLOAD:
+ if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
+ return false;
+ return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
+
default:
break;
}
switch (TREE_CODE_CLASS (code1))
{
- case '1':
- case '2':
- case '<':
- case 'e':
- case 'r':
- case 's':
+ case tcc_unary:
+ case tcc_binary:
+ case tcc_comparison:
+ case tcc_expression:
+ case tcc_reference:
+ case tcc_statement:
{
int i;
return true;
}
- case 't':
+ case tcc_type:
return same_type_p (t1, t2);
+ default:
+ gcc_unreachable ();
}
-
- gcc_unreachable ();
+ /* We can get here with --disable-checking. */
return false;
}
if (current_class_type
&& (binfo = lookup_base (current_class_type, type,
- ba_ignore | ba_quiet, NULL)))
+ ba_unique | ba_quiet, NULL)))
context = current_class_type;
else
{
return 1; /* pointer to member */
if (TREE_CODE (t) == VECTOR_TYPE)
- return 1; /* vectors are (small) arrays if scalars */
+ return 1; /* vectors are (small) arrays of scalars */
if (! CLASS_TYPE_P (t))
return 0; /* other non-class type (reference or function) */
|| !CLASS_TYPE_P (*node)
|| !TYPE_FOR_JAVA (*node))
{
- error ("`%E' attribute can only be applied to Java class definitions",
+ error ("%qE attribute can only be applied to Java class definitions",
name);
*no_add_attrs = true;
return NULL_TREE;
|| !CLASS_TYPE_P (*node)
|| *node != TYPE_MAIN_VARIANT (*node))
{
- warning ("`%E' attribute can only be applied to class definitions",
- name);
+ warning ("%qE attribute can only be applied to class definitions", name);
return NULL_TREE;
}
if (!warned++)
- warning ("`%E' is obsolete; g++ vtables are now COM-compatible by default",
+ warning ("%qE is obsolete; g++ vtables are now COM-compatible by default",
name);
return NULL_TREE;
init_priority value, so don't allow it. */
|| current_function_decl)
{
- error ("can only use `%E' attribute on file-scope definitions "
+ error ("can only use %qE attribute on file-scope definitions "
"of objects of class type", name);
*no_add_attrs = true;
return NULL_TREE;
}
else
{
- error ("`%E' attribute is not supported on this platform", name);
+ error ("%qE attribute is not supported on this platform", name);
*no_add_attrs = true;
return NULL_TREE;
}
tree
cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
- void *data, void *htab)
+ void *data, struct pointer_set_t *pset)
{
enum tree_code code = TREE_CODE (*tp);
location_t save_locus;
#define WALK_SUBTREE(NODE) \
do \
{ \
- result = walk_tree (&(NODE), func, data, htab); \
+ result = walk_tree (&(NODE), func, data, pset); \
if (result) goto out; \
} \
while (0)
return exp;
}
+/* Add NEW, an expression whose value we don't care about, after the
+ similar expression ORIG. */
+
+tree
+add_stmt_to_compound (tree orig, tree new)
+{
+ if (!new || !TREE_SIDE_EFFECTS (new))
+ return orig;
+ if (!orig || !TREE_SIDE_EFFECTS (orig))
+ return new;
+ return build2 (COMPOUND_EXPR, void_type_node, orig, new);
+}
+
/* Like stabilize_expr, but for a call whose args we want to
pre-evaluate. */
if (call == error_mark_node)
return;
- if (TREE_CODE (call) != CALL_EXPR
- && TREE_CODE (call) != AGGR_INIT_EXPR)
- abort ();
+ gcc_assert (TREE_CODE (call) == CALL_EXPR
+ || TREE_CODE (call) == AGGR_INIT_EXPR);
for (t = TREE_OPERAND (call, 1); t; t = TREE_CHAIN (t))
if (TREE_SIDE_EFFECTS (TREE_VALUE (t)))
{
tree init;
TREE_VALUE (t) = stabilize_expr (TREE_VALUE (t), &init);
- if (!init)
- /* Nothing. */;
- else if (inits)
- inits = build2 (COMPOUND_EXPR, void_type_node, inits, init);
- else
- inits = init;
+ inits = add_stmt_to_compound (inits, init);
}
*initp = inits;
t = TREE_OPERAND (t, 1);
if (TREE_CODE (t) == TARGET_EXPR)
t = TARGET_EXPR_INITIAL (t);
+ if (TREE_CODE (t) == COMPOUND_EXPR)
+ t = expr_last (t);
if (TREE_CODE (t) == CONSTRUCTOR
&& CONSTRUCTOR_ELTS (t) == NULL_TREE)
{
return true;
}
+/* Like "fold", but should be used whenever we might be processing the
+ body of a template. */
+
+tree
+fold_if_not_in_template (tree expr)
+{
+ /* In the body of a template, there is never any need to call
+ "fold". We will call fold later when actually instantiating the
+ template. Integral constant expressions in templates will be
+ evaluated via fold_non_dependent_expr, as necessary. */
+ return (processing_template_decl ? expr : fold (expr));
+}
+
\f
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
/* Complain that some language-specific thing hanging off a tree
OSDN Git Service
