+2002-01-23 Craig Rodrigues <rodrigc@gcc.gnu.org>
+
+ * call.c, class.c, decl.c, decl2.c, error.c, expr.c, friend.c,
+ init.c, lex.c, mangle.c, method.c, pt.c, repo.c, rtti.c, search.c,
+ semantics.c, spew.c, tree.c, typeck.c, typeck2.c, xref.c:
+ Change my_fancy_abort() to abort().
+
2002-01-23 Jason Merrill <jason@redhat.com>
PR c++/5453
else if (DECL_CLASS_TEMPLATE_P (name))
return 0;
else
- my_friendly_abort (980605);
+ abort ();
if (name && TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (name))
return 1;
|| !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "__", 2))
mark_used (decl);
else
- my_friendly_abort (990125);
+ abort ();
}
/* Don't pass empty class objects by value. This is useful
return candidates;
default:
- my_friendly_abort (367);
+ abort ();
}
type1 = build_reference_type (type1);
break;
return candidates;
default:
- my_friendly_abort (367);
+ abort ();
}
/* If we're dealing with two pointer types or two enumeral types,
case VEC_DELETE_EXPR:
case DELETE_EXPR:
/* Use build_op_new_call and build_op_delete_call instead. */
- my_friendly_abort (981018);
+ abort ();
case CALL_EXPR:
return build_object_call (arg1, arg2);
return NULL_TREE;
default:
- my_friendly_abort (367);
+ abort ();
return NULL_TREE;
}
}
/* This function should only be called with one of the names listed
above. */
- my_friendly_abort (20000411);
+ abort ();
return NULL_TREE;
}
|| TREE_CODE (t) == IDENTITY_CONV)
return TREE_TYPE (t);
}
- my_friendly_abort (1823);
+ abort ();
}
/* Note a warning about preferring WINNER to LOSER. We do this by storing
--len;
}
else
- my_friendly_abort (42);
+ abort ();
}
for (i = 0; i < len; ++i)
if (IS_AGGR_TYPE (t))
error ("redefinition of `%#T'", t);
else
- my_friendly_abort (172);
+ abort ();
popclass ();
return;
}
case SAVE_EXPR:
case CONSTRUCTOR:
case BUFFER_REF:
- my_friendly_abort (177);
+ abort ();
return error_mark_node;
case INDIRECT_REF:
case CALL_EXPR:
/* This is too hard for now. */
- my_friendly_abort (183);
+ abort ();
return error_mark_node;
case PLUS_EXPR:
return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
}
case ENTRY_VALUE_EXPR:
- my_friendly_abort (184);
+ abort ();
return error_mark_node;
case ERROR_MARK:
return error_mark_node;
default:
- my_friendly_abort (185);
+ abort ();
return error_mark_node;
}
}
break;
default:
- my_friendly_abort (0);
+ abort ();
}
}
return NULL_TREE;
}
/* We should always find the primary base. */
- my_friendly_abort (20000729);
+ abort ();
}
/* For a primary virtual base, we have to scan the entire hierarchy
if (same_type_p (BINFO_TYPE (base_binfo),
BINFO_TYPE (BINFO_BASETYPE (derived, ix))))
return BINFO_BASETYPE (derived, ix);
- my_friendly_abort (20010223);
+ abort ();
return NULL;
}
/* The vbase offset had better be the same. */
if (!tree_int_cst_equal (delta,
BINFO_VPTR_FIELD (orig_vbase)))
- my_friendly_abort (20000403);
+ abort ();
}
/* The next vbase will come at a more negative offset. */
{
/* Cannot pop a level, if there are none left to pop. */
if (current_binding_level == global_binding_level)
- my_friendly_abort (123);
+ abort ();
}
/* Pop the current level, and free the structure for reuse. */
#if defined(DEBUG_CP_BINDING_LEVELS)
{
/* Cannot suspend a level, if there are none left to suspend. */
if (current_binding_level == global_binding_level)
- my_friendly_abort (123);
+ abort ();
}
/* Suspend the current level. */
#if defined(DEBUG_CP_BINDING_LEVELS)
break;
default:
- my_friendly_abort (20000309);
+ abort ();
}
}
else if (BINDING_TYPE (binding) == decl)
BINDING_TYPE (binding) = NULL_TREE;
else
- my_friendly_abort (0);
+ abort ();
if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
{
else if (TREE_CODE (decl) == OVERLOAD)
pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
else
- my_friendly_abort (0);
+ abort ();
}
}
}
/* We should always find a previous binding in this case. */
- my_friendly_abort (0);
+ abort ();
}
/* Install the new binding. */
return error_mark_node;
}
if (TREE_CODE (name) != IDENTIFIER_NODE)
- my_friendly_abort (2000);
+ abort ();
if (TREE_CODE (context) == NAMESPACE_DECL)
{
else if (DECL_P (name))
name = DECL_NAME (name);
if (TREE_CODE (name) != IDENTIFIER_NODE)
- my_friendly_abort (20010902);
+ abort ();
if (!uses_template_parms (context)
|| currently_open_class (context))
break;
default:
- my_friendly_abort (20000408);
+ abort ();
break;
}
TREE_COMPLEXITY (declarator) = current_class_depth;
}
else
- my_friendly_abort (16);
+ abort ();
if (TREE_OPERAND (declarator, 0) == NULL_TREE)
{
declarator = sname;
}
else if (TREE_CODE (sname) == SCOPE_REF)
- my_friendly_abort (17);
+ abort ();
else
{
done_scoping:
break;
default:
- my_friendly_abort (158);
+ abort ();
}
}
}
else
/* Unexpected declarator format. */
- my_friendly_abort (990210);
+ abort ();
/* If this is declaring a typedef name, return a TYPE_DECL. */
else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
{
if (IDENTIFIER_OPNAME_P (declarator))
- my_friendly_abort (356);
+ abort ();
else
error ("variable or field `%s' declared void", name);
}
#include "operators.def"
#undef DEF_OPERATOR
- my_friendly_abort (20000527);
+ abort ();
}
while (0);
my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
break;
default:
- my_friendly_abort (20000527);
+ abort ();
}
SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
case enum_type:
return "enum";
default:
- my_friendly_abort (981122);
+ abort ();
}
}
code = ENUMERAL_TYPE;
break;
default:
- my_friendly_abort (18);
+ abort ();
}
/* If a cross reference is requested, look up the type
have declarations (from inline functions) that need to go into
this function's blocks. */
if (current_binding_level->parm_flag != 1)
- my_friendly_abort (122);
+ abort ();
poplevel (1, 0, 1);
/* Set up the named return value optimization, if we can. Here, we
DECL_IN_AGGR_P (value) = 1;
return value;
}
- my_friendly_abort (21);
+ abort ();
/* NOTREACHED */
return NULL_TREE;
}
parent_rtx = XEXP (DECL_RTL (parent), 0); /* strip the mem ref */
}
else
- my_friendly_abort (980826);
+ abort ();
assemble_vtable_inherit (child_rtx, parent_rtx);
}
/* Overflow occurred. That means there are at least 4 billion
initialization functions. */
sorry ("too many initialization functions required");
- my_friendly_abort (19990430);
+ abort ();
}
/* Create the parameters. */
return build_x_compound_expr
(build_expr_from_tree (TREE_OPERAND (t, 0)));
else
- my_friendly_abort (42);
+ abort ();
case METHOD_CALL_EXPR:
if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF)
case TEMPLATE_ID_EXPR:
return decl;
default:
- my_friendly_abort (5);
+ abort ();
return NULL_TREE;
}
}
return 0;
/* else fall through */
default:
- my_friendly_abort (390);
+ abort ();
}
return 0;
}
return NULL_TREE;
}
else
- my_friendly_abort (382);
+ abort ();
if (DECL_P (*name))
*name = DECL_NAME (*name);
/* Make a USING_DECL. */
else if (DECL_GLOBAL_DTOR_P (t))
p = "destructors";
else
- my_friendly_abort (352);
+ abort ();
output_printf (scratch_buffer, "(static %s for %s)", p, input_filename);
}
break;
case TYPE_EXPR:
- my_friendly_abort (69);
+ abort ();
break;
/* These special cases are duplicated here so that other functions
else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
else if (TREE_TYPE (t) == NULL_TREE)
- my_friendly_abort (353);
+ abort ();
else
switch (NEXT_CODE (t))
{
return "Java";
default:
- my_friendly_abort (355);
+ abort ();
return 0;
}
}
case OFFSET_REF:
/* Offset refs should not make it through to here. */
- my_friendly_abort (20010724);
+ abort ();
return const0_rtx;
case THROW_EXPR:
default:
return c_expand_expr (exp, target, tmode, modifier);
}
- my_friendly_abort (40);
+ abort ();
/* NOTREACHED */
return NULL;
}
}
if (TREE_CODE (decl) != FUNCTION_DECL)
- my_friendly_abort (990513);
+ abort ();
is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P ();
/* static class functions too. */
if (TREE_CODE (t) == FUNCTION_DECL
&& TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
- my_friendly_abort (53);
+ abort ();
/* In member functions, the form `type::name' is no longer
equivalent to `this->type::name', at least not until
{
return get_member_function_from_ptrfunc (&addr, member);
}
- my_friendly_abort (56);
+ abort ();
/* NOTREACHED */
return NULL_TREE;
}
nelts = integer_one_node;
if (absdcl && TREE_CODE (absdcl) == CALL_EXPR)
- my_friendly_abort (215);
+ abort ();
while (absdcl && TREE_CODE (absdcl) == INDIRECT_REF)
{
last_absdcl = absdcl;
else if (from)
elt_init = build_modify_expr (to, NOP_EXPR, from);
else
- my_friendly_abort (57);
+ abort ();
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
break;
default:
- my_friendly_abort (20000524);
+ abort ();
}
return build_method_call (exp, name, NULL_TREE, NULL_TREE, flags);
}
else if (yylval.ttype == enum_type_node)
fprintf (file, " `enum'");
else
- my_friendly_abort (80);
+ abort ();
break;
case CONSTANT:
tree type;
{
if (!TYPE_P (type))
- my_friendly_abort (60);
+ abort ();
if (CLASS_TYPE_P (type))
CLASSTYPE_GOT_SEMICOLON (type) = 1;
}
SET_DECL_LANGUAGE (t, lang_c);
else if (current_lang_name == lang_name_java)
SET_DECL_LANGUAGE (t, lang_java);
- else my_friendly_abort (64);
+ else abort ();
#ifdef GATHER_STATISTICS
tree_node_counts[(int)lang_decl] += 1;
else if (rid == ridpointers[(int) RID_RESTRICT])
return TYPE_QUAL_RESTRICT;
- my_friendly_abort (0);
+ abort ();
return TYPE_UNQUALIFIED;
}
|| (TYPE_P (node)
&& TYPE_P (candidate)
&& same_type_p (node, candidate)))
- my_friendly_abort (20000524);
+ abort ();
}
}
#endif /* ENABLE_CHECKING */
|| TREE_CODE (context) == FUNCTION_DECL)
write_unqualified_name (decl);
else
- my_friendly_abort (20000521);
+ abort ();
}
/* <unscoped-template-name> ::= <unscoped-name>
template = CLASSTYPE_TI_TEMPLATE (type);
else
/* Oops, not a template. */
- my_friendly_abort (20000524);
+ abort ();
/* For a member template, though, the template name for the
innermost name must have all the outer template levels
else if (DECL_BASE_CONSTRUCTOR_P (ctor))
write_string ("C2");
else
- my_friendly_abort (20001115);
+ abort ();
}
/* Handle destructor productions of non-terminal <special-name>.
else if (DECL_BASE_DESTRUCTOR_P (dtor))
write_string ("D2");
else
- my_friendly_abort (20001115);
+ abort ();
}
/* Return the discriminator for ENTITY appearing inside
break;
default:
- my_friendly_abort (20000409);
+ abort ();
}
}
tree t = type_for_mode (TYPE_MODE (type), TREE_UNSIGNED (type));
if (type == t)
/* Couldn't find this type. */
- my_friendly_abort (20000408);
+ abort ();
type = t;
goto iagain;
}
else if (type == long_double_type_node)
write_char ('e');
else
- my_friendly_abort (20000409);
+ abort ();
break;
default:
- my_friendly_abort (20000509);
+ abort ();
}
}
else if (value == boolean_true_node)
write_unsigned_number (1);
else
- my_friendly_abort (20000412);
+ abort ();
}
else
write_integer_cst (value);
#endif
}
else
- my_friendly_abort (20000412);
+ abort ();
write_char ('E');
}
break;
default:
- my_friendly_abort (20000523);
+ abort ();
}
write_char ('T');
else if (type == java_boolean_type_node)
write_char ('b');
else
- my_friendly_abort (20001207);
+ abort ();
}
fndecl = TREE_VALUE (fields);
my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 251);
/* I could not trigger this code. MvL */
- my_friendly_abort (980325);
+ abort ();
#ifdef DEAD
if (DECL_CHAIN (fndecl) == NULL_TREE)
{
break;
}
default:
- my_friendly_abort (59);
+ abort ();
}
TREE_PARMLIST (args) = 1;
break;
default:
- my_friendly_abort (0);
+ abort ();
}
}
}
break;
default:
- my_friendly_abort (20000309);
+ abort ();
}
if (specialization || member_specialization)
default:
/* All non-type parameters must have one of these types. */
- my_friendly_abort (0);
+ abort ();
break;
}
break;
default:
- my_friendly_abort (0);
+ abort ();
}
}
return 1;
tsubst_friend_function (TREE_VALUE (friends),
args));
else
- my_friendly_abort (20000216);
+ abort ();
}
for (t = CLASSTYPE_FRIEND_CLASSES (pattern);
break;
default:
- my_friendly_abort (0);
+ abort ();
}
/* Restore the file and line information. */
else
type = TREE_TYPE (t);
if (type == unknown_type_node)
- my_friendly_abort (42);
+ abort ();
if (type && TREE_CODE (t) != FUNCTION_DECL
&& TREE_CODE (t) != TYPENAME_TYPE
}
}
else
- my_friendly_abort (981018);
+ abort ();
if (level == 1)
/* This can happen during the attempted tsubst'ing in
break;
default:
- my_friendly_abort (0);
+ abort ();
}
return r;
/* We didn't find the name. That should never happen; if
name-lookup found it during preliminary parsing, we
should find it again here during instantiation. */
- my_friendly_abort (0);
+ abort ();
}
return t;
if (DECL_NAME (clone) == DECL_NAME (tmpl))
return clone;
/* We should always have found the clone by now. */
- my_friendly_abort (20000411);
+ abort ();
return NULL_TREE;
}
}
break;
default:
- my_friendly_abort (0);
+ abort ();
}
if (TREE_CODE (*parm) != REFERENCE_TYPE)
break;
default:
- my_friendly_abort (0);
+ abort ();
}
if (xlen == 0)
}
}
else
- my_friendly_abort (981006);
+ abort ();
/* [temp.deduct.type] A template-argument can be deduced from a pointer
to function or pointer to member function argument if the set of
return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
default:
- my_friendly_abort (0);
+ abort ();
return 0;
}
}
else if (i == 0)
return 1;
else
- my_friendly_abort (42);
+ abort ();
}
/* [temp.deduct.type] If, in the declaration of a function template
the vtable, so going ahead would give the wrong answer.
See g++.pt/instantiate4.C. */
if (!COMPLETE_TYPE_P (t) || TYPE_BEING_DEFINED (t))
- my_friendly_abort (981113);
+ abort ();
vtable = get_vtbl_decl_for_binfo (TYPE_BINFO (t));
0);
}
else
- my_friendly_abort (1);
+ abort ();
if (! IDENTIFIER_REPO_USED (id))
{
var_init = generic_initializer (var_type, target_type);
break;
}
- my_friendly_abort (20000117);
+ abort ();
}
return create_real_tinfo_var (target_type,
980827);
}
else
- my_friendly_abort (97);
+ abort ();
complete_type (type);
break;
default:
- my_friendly_abort (19990810);
+ abort ();
break;
}
}
nth_token (1)->yychar = IDENTIFIER_DEFN;
break;
default:
- my_friendly_abort (102);
+ abort ();
}
}
lastiddecl = trrr;
break;
default:
- my_friendly_abort (20000907);
+ abort ();
}
}
else
/* A currently unresolved scope ref. */
case SCOPE_REF:
- my_friendly_abort (103);
+ abort ();
case OFFSET_REF:
if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
return clk_ordinary;
return i;
}
- my_friendly_abort (359);
+ abort ();
return 0;
}
if (ring_counter == PRINT_RING_SIZE)
ring_counter = 0;
if (decl_ring[ring_counter] == current_function_decl)
- my_friendly_abort (106);
+ abort ();
}
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))
- my_friendly_abort (20000727);
+ abort ();
slot = htab_find_slot (*statements, t, INSERT);
*slot = t;
if (t == error_mark_node)
return t;
- my_friendly_abort (42);
+ abort ();
/* Stop compiler from complaining control reaches end of non-void function. */
return 0;
case REAL_TYPE:
/* We should have called type_after_usual_arithmetic_conversions
above. */
- my_friendly_abort (19990725);
+ abort ();
break;
case POINTER_TYPE:
case OFFSET_TYPE:
/* Pointers to members should now be handled by the POINTER_TYPE
case above. */
- my_friendly_abort (990325);
+ abort ();
default:
return build_type_attribute_variant (t1, attributes);
return error_mark_node;
}
if (code == METHOD_TYPE)
- my_friendly_abort (990506);
+ abort ();
if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
return build_unary_op (ADDR_EXPR, exp, 0);
if (code == ARRAY_TYPE)
if (TREE_CODE (component) == TREE_LIST)
{
/* I could not trigger this code. MvL */
- my_friendly_abort (980326);
+ abort ();
#ifdef DEAD
my_friendly_assert (!(TREE_CHAIN (component) == NULL_TREE
&& DECL_CHAIN (TREE_VALUE (component)) == NULL_TREE), 309);
}
/* Unexpected node type? */
else
- my_friendly_abort (116);
+ abort ();
if (decl == NULL_TREE)
{
if (current_function_decl
&& same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0), type1))
|| (TYPE_PTRMEMFUNC_P (type1)
&& same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1), type0)))
- my_friendly_abort (20000221);
+ abort ();
break;
case MAX_EXPR:
if (TREE_CODE (arg) == IDENTIFIER_NODE
&& IDENTIFIER_OPNAME_P (arg))
{
- my_friendly_abort (117);
+ abort ();
/* We don't know the type yet, so just work around the problem.
We know that this will resolve to an lvalue. */
return build1 (ADDR_EXPR, unknown_type_node, arg);
register enum tree_code coder;
if (codel == OFFSET_TYPE)
- my_friendly_abort (990505);
+ abort ();
if (TREE_CODE (rhs) == OFFSET_REF)
rhs = resolve_offset_ref (rhs);
break;
default:
- my_friendly_abort (108);
+ abort ();
}
}
{
if (! TYPE_HAS_TRIVIAL_INIT_REF (type)
&& TREE_CODE (init) != CONSTRUCTOR)
- my_friendly_abort (109);
+ abort ();
if (TREE_CODE (init) == TREE_LIST)
{
next1 = digest_init (TREE_TYPE (field),
TREE_VALUE (tail), &tail1);
if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
- my_friendly_abort (357);
+ abort ();
tail = tail1;
}
else
else if (TREE_CODE (DECL_RESULT (decl)) == VAR_DECL)
cls = "VARTEMP";
else
- my_friendly_abort (358);
+ abort ();
uselin = TRUE;
}
else cls = "UNKNOWN";
git://gcc.gnu.org / gcc.git / commitdiff