[committed] convert gcc/cp/typeck.c to ISO C
Nathanael Nerode
neroden@twcny.rr.com
Wed Jun 18 19:29:00 GMT 2003
Tested on i686-pc-linux-gnu.
* typeck.c: Convert to ISO C.
Index: typeck.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/typeck.c,v
retrieving revision 1.465
diff -u -r1.465 typeck.c
--- typeck.c 18 Jun 2003 15:22:19 -0000 1.465
+++ typeck.c 18 Jun 2003 17:40:05 -0000
@@ -45,34 +45,32 @@
#include "diagnostic.h"
#include "target.h"
-static tree convert_for_assignment PARAMS ((tree, tree, const char *, tree,
- int));
-static tree cp_pointer_int_sum PARAMS ((enum tree_code, tree, tree));
-static tree rationalize_conditional_expr PARAMS ((enum tree_code, tree));
-static int comp_target_parms PARAMS ((tree, tree));
-static int comp_ptr_ttypes_real PARAMS ((tree, tree, int));
-static int comp_ptr_ttypes_const PARAMS ((tree, tree));
-static int comp_ptr_ttypes_reinterpret PARAMS ((tree, tree));
-static int comp_except_types PARAMS ((tree, tree, int));
-static bool comp_array_types PARAMS ((tree, tree, int));
-static tree common_base_type PARAMS ((tree, tree));
-static tree lookup_anon_field PARAMS ((tree, tree));
-static tree pointer_diff PARAMS ((tree, tree, tree));
-static tree qualify_type_recursive PARAMS ((tree, tree));
-static tree get_delta_difference PARAMS ((tree, tree, int));
-static int comp_cv_target_types PARAMS ((tree, tree, int));
-static void casts_away_constness_r PARAMS ((tree *, tree *));
-static int casts_away_constness PARAMS ((tree, tree));
-static void maybe_warn_about_returning_address_of_local PARAMS ((tree));
-static tree strip_all_pointer_quals PARAMS ((tree));
+static tree convert_for_assignment (tree, tree, const char *, tree, int);
+static tree cp_pointer_int_sum (enum tree_code, tree, tree);
+static tree rationalize_conditional_expr (enum tree_code, tree);
+static int comp_target_parms (tree, tree);
+static int comp_ptr_ttypes_real (tree, tree, int);
+static int comp_ptr_ttypes_const (tree, tree);
+static int comp_ptr_ttypes_reinterpret (tree, tree);
+static int comp_except_types (tree, tree, int);
+static bool comp_array_types (tree, tree, int);
+static tree common_base_type (tree, tree);
+static tree lookup_anon_field (tree, tree);
+static tree pointer_diff (tree, tree, tree);
+static tree qualify_type_recursive (tree, tree);
+static tree get_delta_difference (tree, tree, int);
+static int comp_cv_target_types (tree, tree, int);
+static void casts_away_constness_r (tree *, tree *);
+static int casts_away_constness (tree, tree);
+static void maybe_warn_about_returning_address_of_local (tree);
+static tree strip_all_pointer_quals (tree);
static tree lookup_destructor (tree, tree, tree);
/* Return the target type of TYPE, which means return T for:
T*, T&, T[], T (...), and otherwise, just T. */
tree
-target_type (type)
- tree type;
+target_type (tree type)
{
if (TREE_CODE (type) == REFERENCE_TYPE)
type = TREE_TYPE (type);
@@ -91,8 +89,7 @@
complete type when this function returns. */
tree
-require_complete_type (value)
- tree value;
+require_complete_type (tree value)
{
tree type;
@@ -131,8 +128,7 @@
horribly wrong, in which case the error_mark_node is returned. */
tree
-complete_type (type)
- tree type;
+complete_type (tree type)
{
if (type == NULL_TREE)
/* Rather than crash, we return something sure to cause an error
@@ -163,10 +159,7 @@
Returns NULL_TREE if the type cannot be made complete. */
tree
-complete_type_or_diagnostic (type, value, diag_type)
- tree type;
- tree value;
- int diag_type;
+complete_type_or_diagnostic (tree type, tree value, int diag_type)
{
type = complete_type (type);
if (type == error_mark_node)
@@ -184,8 +177,7 @@
/* Return truthvalue of whether type of EXP is instantiated. */
int
-type_unknown_p (exp)
- tree exp;
+type_unknown_p (tree exp)
{
return (TREE_CODE (exp) == OVERLOAD
|| TREE_CODE (exp) == TREE_LIST
@@ -199,8 +191,7 @@
signatures of T1 and T2: [expr.rel], [expr.eq]. */
static tree
-qualify_type_recursive (t1, t2)
- tree t1, t2;
+qualify_type_recursive (tree t1, tree t2)
{
if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
|| (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2)))
@@ -245,8 +236,7 @@
lists are already common. */
tree
-commonparms (p1, p2)
- tree p1, p2;
+commonparms (tree p1, tree p2)
{
tree oldargs = p1, newargs, n;
int i, len;
@@ -307,8 +297,7 @@
/* Given a type, perhaps copied for a typedef,
find the "original" version of it. */
tree
-original_type (t)
- tree t;
+original_type (tree t)
{
while (TYPE_NAME (t) != NULL_TREE)
{
@@ -328,9 +317,7 @@
T2 as described in [expr]. */
tree
-type_after_usual_arithmetic_conversions (t1, t2)
- tree t1;
- tree t2;
+type_after_usual_arithmetic_conversions (tree t1, tree t2)
{
enum tree_code code1 = TREE_CODE (t1);
enum tree_code code2 = TREE_CODE (t2);
@@ -473,12 +460,11 @@
string describing the current location, in case an error occurs. */
tree
-composite_pointer_type (t1, t2, arg1, arg2, location)
- tree t1;
- tree t2;
- tree arg1;
- tree arg2;
- const char* location;
+composite_pointer_type (tree t1,
+ tree t2,
+ tree arg1,
+ tree arg2,
+ const char* location)
{
tree result_type;
tree attributes;
@@ -561,8 +547,7 @@
differences would cause the two types to compare unalike. */
tree
-merge_types (t1, t2)
- tree t1, t2;
+merge_types (tree t1, tree t2)
{
register enum tree_code code1;
register enum tree_code code2;
@@ -709,8 +694,7 @@
if the operands have the given two types. */
tree
-common_type (t1, t2)
- tree t1, t2;
+common_type (tree t1, tree t2)
{
enum tree_code code1;
enum tree_code code2;
@@ -754,9 +738,7 @@
We implement the letter of the standard. */
static int
-comp_except_types (a, b, exact)
- tree a, b;
- int exact;
+comp_except_types (tree a, tree b, int exact)
{
if (same_type_p (a, b))
return 1;
@@ -791,9 +773,7 @@
we should try to make use of that. */
int
-comp_except_specs (t1, t2, exact)
- tree t1, t2;
- int exact;
+comp_except_specs (tree t1, tree t2, int exact)
{
tree probe;
tree base;
@@ -839,9 +819,7 @@
/* Compare the array types T1 and T2. STRICT is as for comptypes. */
static bool
-comp_array_types (t1, t2, strict)
- tree t1, t2;
- int strict;
+comp_array_types (tree t1, tree t2, int strict)
{
tree d1;
tree d2;
@@ -884,10 +862,7 @@
is a bitwise-or of the COMPARE_* flags. */
bool
-comptypes (t1, t2, strict)
- tree t1;
- tree t2;
- int strict;
+comptypes (tree t1, tree t2, int strict)
{
int orig_strict = strict;
@@ -1038,9 +1013,7 @@
only in the same direction as the target type. */
static int
-comp_cv_target_types (ttl, ttr, nptrs)
- tree ttl, ttr;
- int nptrs;
+comp_cv_target_types (tree ttl, tree ttr, int nptrs)
{
int t;
@@ -1073,9 +1046,7 @@
similar instead. (jason 17 Apr 1997) */
int
-comp_target_types (ttl, ttr, nptrs)
- tree ttl, ttr;
- int nptrs;
+comp_target_types (tree ttl, tree ttr, int nptrs)
{
ttl = TYPE_MAIN_VARIANT (ttl);
ttr = TYPE_MAIN_VARIANT (ttr);
@@ -1241,9 +1212,7 @@
/* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
int
-at_least_as_qualified_p (type1, type2)
- tree type1;
- tree type2;
+at_least_as_qualified_p (tree type1, tree type2)
{
/* All qualifiers for TYPE2 must also appear in TYPE1. */
return ((cp_type_quals (type1) & cp_type_quals (type2))
@@ -1253,9 +1222,7 @@
/* Returns 1 if TYPE1 is more qualified than TYPE2. */
int
-more_qualified_p (type1, type2)
- tree type1;
- tree type2;
+more_qualified_p (tree type1, tree type2)
{
return (cp_type_quals (type1) != cp_type_quals (type2)
&& at_least_as_qualified_p (type1, type2));
@@ -1265,9 +1232,7 @@
more cv-qualified that TYPE1, and 0 otherwise. */
int
-comp_cv_qualification (type1, type2)
- tree type1;
- tree type2;
+comp_cv_qualification (tree type1, tree type2)
{
if (cp_type_quals (type1) == cp_type_quals (type2))
return 0;
@@ -1286,9 +1251,7 @@
are similar. Returns -1 if the other way 'round, and 0 otherwise. */
int
-comp_cv_qual_signature (type1, type2)
- tree type1;
- tree type2;
+comp_cv_qual_signature (tree type1, tree type2)
{
if (comp_ptr_ttypes_real (type2, type1, -1))
return 1;
@@ -1303,8 +1266,7 @@
returns ERROR_MARK_NODE. */
static tree
-common_base_type (tt1, tt2)
- tree tt1, tt2;
+common_base_type (tree tt1, tree tt2)
{
tree best = NULL_TREE;
int i;
@@ -1360,8 +1322,7 @@
C++: See comment above about TYPE1, TYPE2. */
int
-compparms (parms1, parms2)
- tree parms1, parms2;
+compparms (tree parms1, tree parms2)
{
register tree t1 = parms1, t2 = parms2;
@@ -1394,8 +1355,7 @@
(jason 17 Apr 1997) */
static int
-comp_target_parms (parms1, parms2)
- tree parms1, parms2;
+comp_target_parms (tree parms1, tree parms2)
{
register tree t1 = parms1, t2 = parms2;
int warn_contravariance = 0;
@@ -1461,10 +1421,7 @@
}
tree
-cxx_sizeof_or_alignof_type (type, op, complain)
- tree type;
- enum tree_code op;
- int complain;
+cxx_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
{
enum tree_code type_code;
tree value;
@@ -1499,8 +1456,7 @@
}
tree
-expr_sizeof (e)
- tree e;
+expr_sizeof (tree e)
{
if (processing_template_decl)
return build_min_nt (SIZEOF_EXPR, e);
@@ -1538,8 +1494,7 @@
constants are replaced by their values. */
tree
-decay_conversion (exp)
- tree exp;
+decay_conversion (tree exp)
{
register tree type;
register enum tree_code code;
@@ -1656,8 +1611,7 @@
}
tree
-default_conversion (exp)
- tree exp;
+default_conversion (tree exp)
{
tree type;
enum tree_code code;
@@ -1681,8 +1635,7 @@
or TREE_USED. */
tree
-inline_conversion (exp)
- tree exp;
+inline_conversion (tree exp)
{
if (TREE_CODE (exp) == FUNCTION_DECL)
exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
@@ -1694,9 +1647,7 @@
decay_conversion to one. */
int
-string_conv_p (totype, exp, warn)
- tree totype, exp;
- int warn;
+string_conv_p (tree totype, tree exp, int warn)
{
tree t;
@@ -1742,9 +1693,7 @@
get it there. */
static tree
-rationalize_conditional_expr (code, t)
- enum tree_code code;
- tree t;
+rationalize_conditional_expr (enum tree_code code, tree t)
{
/* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
the first operand is always the one to be used if both operands
@@ -1772,8 +1721,7 @@
that are directly reachable. */
static tree
-lookup_anon_field (t, type)
- tree t, type;
+lookup_anon_field (tree t, tree type)
{
tree field;
@@ -2261,9 +2209,7 @@
Must also handle REFERENCE_TYPEs for C++. */
tree
-build_x_indirect_ref (ptr, errorstring)
- tree ptr;
- const char *errorstring;
+build_x_indirect_ref (tree ptr, const char* errorstring)
{
tree rval;
@@ -2278,9 +2224,7 @@
}
tree
-build_indirect_ref (ptr, errorstring)
- tree ptr;
- const char *errorstring;
+build_indirect_ref (tree ptr, const char* errorstring)
{
register tree pointer, type;
@@ -2360,8 +2304,7 @@
will inherit the type of the array, which will be some pointer type. */
tree
-build_array_ref (array, idx)
- tree array, idx;
+build_array_ref (tree array, tree idx)
{
if (idx == 0)
{
@@ -2513,9 +2456,7 @@
later has the right member. */
tree
-get_member_function_from_ptrfunc (instance_ptrptr, function)
- tree *instance_ptrptr;
- tree function;
+get_member_function_from_ptrfunc (tree* instance_ptrptr, tree function)
{
if (TREE_CODE (function) == OFFSET_REF)
function = TREE_OPERAND (function, 1);
@@ -2617,8 +2558,7 @@
}
tree
-build_function_call (function, params)
- tree function, params;
+build_function_call (tree function, tree params)
{
register tree fntype, fndecl;
register tree coerced_params;
@@ -2736,9 +2676,7 @@
default arguments, if such were specified. Do so here. */
tree
-convert_arguments (typelist, values, fndecl, flags)
- tree typelist, values, fndecl;
- int flags;
+convert_arguments (tree typelist, tree values, tree fndecl, int flags)
{
register tree typetail, valtail;
register tree result = NULL_TREE;
@@ -2898,9 +2836,7 @@
conversions on the operands. CODE is the kind of expression to build. */
tree
-build_x_binary_op (code, arg1, arg2)
- enum tree_code code;
- tree arg1, arg2;
+build_x_binary_op (enum tree_code code, tree arg1, tree arg2)
{
if (processing_template_decl)
return build_min_nt (code, arg1, arg2);
@@ -3104,10 +3040,10 @@
multiple inheritance, and deal with pointer to member functions. */
tree
-build_binary_op (code, orig_op0, orig_op1, convert_p)
- enum tree_code code;
- tree orig_op0, orig_op1;
- int convert_p ATTRIBUTE_UNUSED;
+build_binary_op (enum tree_code code,
+ tree orig_op0,
+ tree orig_op1,
+ int convert_p ATTRIBUTE_UNUSED )
{
tree op0, op1;
register enum tree_code code0, code1;
@@ -3839,9 +3775,9 @@
of pointer PTROP and integer INTOP. */
static tree
-cp_pointer_int_sum (resultcode, ptrop, intop)
- enum tree_code resultcode;
- register tree ptrop, intop;
+cp_pointer_int_sum (enum tree_code resultcode,
+ register tree ptrop,
+ register tree intop)
{
tree res_type = TREE_TYPE (ptrop);
@@ -3859,9 +3795,9 @@
The resulting tree has type int. */
static tree
-pointer_diff (op0, op1, ptrtype)
- register tree op0, op1;
- register tree ptrtype;
+pointer_diff (register tree op0,
+ register tree op1,
+ register tree ptrtype)
{
register tree result, folded;
tree restype = ptrdiff_type_node;
@@ -3915,9 +3851,7 @@
and XARG is the operand. */
tree
-build_x_unary_op (code, xarg)
- enum tree_code code;
- tree xarg;
+build_x_unary_op (enum tree_code code, tree xarg)
{
tree exp;
int ptrmem = 0;
@@ -3994,8 +3928,7 @@
-1. */
tree
-cp_truthvalue_conversion (expr)
- tree expr;
+cp_truthvalue_conversion (tree expr)
{
tree type = TREE_TYPE (expr);
if (TYPE_PTRMEM_P (type))
@@ -4007,8 +3940,7 @@
/* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
tree
-condition_conversion (expr)
- tree expr;
+condition_conversion (tree expr)
{
tree t;
if (processing_template_decl)
@@ -4068,10 +4000,7 @@
(such as from short to int). */
tree
-build_unary_op (code, xarg, noconvert)
- enum tree_code code;
- tree xarg;
- int noconvert;
+build_unary_op (enum tree_code code, tree xarg, int noconvert)
{
/* No default_conversion here. It causes trouble for ADDR_EXPR. */
register tree arg = xarg;
@@ -4522,9 +4451,7 @@
If ARG is not a kind of expression we can handle, return zero. */
tree
-unary_complex_lvalue (code, arg)
- enum tree_code code;
- tree arg;
+unary_complex_lvalue (enum tree_code code, tree arg)
{
/* Handle (a, b) used as an "lvalue". */
if (TREE_CODE (arg) == COMPOUND_EXPR)
@@ -4661,8 +4588,7 @@
C++: we do not allow `current_class_ptr' to be addressable. */
bool
-cxx_mark_addressable (exp)
- tree exp;
+cxx_mark_addressable (tree exp)
{
register tree x = exp;
@@ -4727,8 +4653,7 @@
/* Build and return a conditional expression IFEXP ? OP1 : OP2. */
tree
-build_x_conditional_expr (ifexp, op1, op2)
- tree ifexp, op1, op2;
+build_x_conditional_expr (tree ifexp, tree op1, tree op2)
{
if (processing_template_decl)
return build_min_nt (COND_EXPR, ifexp, op1, op2);
@@ -4740,8 +4665,7 @@
this function just builds an expression list. */
tree
-build_x_compound_expr (list)
- tree list;
+build_x_compound_expr (tree list)
{
tree rest = TREE_CHAIN (list);
tree result;
@@ -4784,8 +4708,7 @@
that performs them all and returns the value of the last of them. */
tree
-build_compound_expr (list)
- tree list;
+build_compound_expr (tree list)
{
register tree rest;
tree first;
@@ -4820,8 +4743,7 @@
}
tree
-build_static_cast (type, expr)
- tree type, expr;
+build_static_cast (tree type, tree expr)
{
tree intype;
int ok;
@@ -4933,8 +4855,7 @@
}
tree
-build_reinterpret_cast (type, expr)
- tree type, expr;
+build_reinterpret_cast (tree type, tree expr)
{
tree intype;
@@ -5024,8 +4945,7 @@
}
tree
-build_const_cast (type, expr)
- tree type, expr;
+build_const_cast (tree type, tree expr)
{
tree intype;
@@ -5094,8 +5014,7 @@
when doing the cast. */
tree
-build_c_cast (type, expr)
- tree type, expr;
+build_c_cast (tree type, tree expr)
{
register tree value = expr;
tree otype;
@@ -5261,10 +5180,7 @@
C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
tree
-build_modify_expr (lhs, modifycode, rhs)
- tree lhs;
- enum tree_code modifycode;
- tree rhs;
+build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
{
register tree result;
tree newrhs = rhs;
@@ -5627,10 +5543,7 @@
}
tree
-build_x_modify_expr (lhs, modifycode, rhs)
- tree lhs;
- enum tree_code modifycode;
- tree rhs;
+build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
{
if (processing_template_decl)
return build_min_nt (MODOP_EXPR, lhs,
@@ -5657,9 +5570,7 @@
a pointer to member of FROM to a pointer to member of TO. */
static tree
-get_delta_difference (from, to, force)
- tree from, to;
- int force;
+get_delta_difference (tree from, tree to, int force)
{
tree delta = integer_zero_node;
tree binfo;
@@ -5722,8 +5633,7 @@
the other components as specified. */
tree
-build_ptrmemfunc1 (type, delta, pfn)
- tree type, delta, pfn;
+build_ptrmemfunc1 (tree type, tree delta, tree pfn)
{
tree u = NULL_TREE;
tree delta_field;
@@ -5761,9 +5671,7 @@
Return error_mark_node, if something goes wrong. */
tree
-build_ptrmemfunc (type, pfn, force)
- tree type, pfn;
- int force;
+build_ptrmemfunc (tree type, tree pfn, int force)
{
tree fn;
tree pfn_type;
@@ -5848,10 +5756,7 @@
integer_type_node. */
void
-expand_ptrmemfunc_cst (cst, delta, pfn)
- tree cst;
- tree *delta;
- tree *pfn;
+expand_ptrmemfunc_cst (tree cst, tree* delta, tree* pfn)
{
tree type = TREE_TYPE (cst);
tree fn = PTRMEM_CST_MEMBER (cst);
@@ -5914,8 +5819,7 @@
given by T. */
tree
-pfn_from_ptrmemfunc (t)
- tree t;
+pfn_from_ptrmemfunc (tree t)
{
if (TREE_CODE (t) == PTRMEM_CST)
{
@@ -5935,12 +5839,11 @@
marked EXPR. */
tree
-dubious_conversion_warnings (type, expr, errtype, fndecl, parmnum)
- tree type;
- tree expr;
- const char *errtype;
- tree fndecl;
- int parmnum;
+dubious_conversion_warnings (tree type,
+ tree expr,
+ const char* errtype,
+ tree fndecl,
+ int parmnum)
{
if (TREE_CODE (type) == REFERENCE_TYPE)
type = TREE_TYPE (type);
@@ -5995,11 +5898,11 @@
FNDECL. */
static tree
-convert_for_assignment (type, rhs, errtype, fndecl, parmnum)
- tree type, rhs;
- const char *errtype;
- tree fndecl;
- int parmnum;
+convert_for_assignment (tree type,
+ tree rhs,
+ const char* errtype,
+ tree fndecl,
+ int parmnum)
{
register enum tree_code codel = TREE_CODE (type);
register tree rhstype;
@@ -6099,12 +6002,13 @@
If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
tree
-convert_for_initialization (exp, type, rhs, flags, errtype, fndecl, parmnum)
- tree exp, type, rhs;
- int flags;
- const char *errtype;
- tree fndecl;
- int parmnum;
+convert_for_initialization (tree exp,
+ tree type,
+ tree rhs,
+ int flags,
+ const char* errtype,
+ tree fndecl,
+ int parmnum)
{
register enum tree_code codel = TREE_CODE (type);
register tree rhstype;
@@ -6194,11 +6098,13 @@
up operands that are expected to be in memory. */
void
-c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
- tree string, outputs, inputs, clobbers;
- int vol;
- const char *filename;
- int line;
+c_expand_asm_operands (tree string,
+ tree outputs,
+ tree inputs,
+ tree clobbers,
+ int vol,
+ const char* filename,
+ int line)
{
int noutputs = list_length (outputs);
register int i;
@@ -6248,8 +6154,7 @@
temporary give an appropraite warning. */
static void
-maybe_warn_about_returning_address_of_local (retval)
- tree retval;
+maybe_warn_about_returning_address_of_local (tree retval)
{
tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
tree whats_returned = retval;
@@ -6309,8 +6214,7 @@
the DECL_RESULT for the function. */
tree
-check_return_expr (retval)
- tree retval;
+check_return_expr (tree retval)
{
tree result;
/* The type actually returned by the function, after any
@@ -6500,9 +6404,7 @@
const-qualified. */
static int
-comp_ptr_ttypes_real (to, from, constp)
- tree to, from;
- int constp;
+comp_ptr_ttypes_real (tree to, tree from, int constp)
{
int to_more_cv_qualified = 0;
@@ -6546,8 +6448,7 @@
types to this function. */
int
-comp_ptr_ttypes (to, from)
- tree to, from;
+comp_ptr_ttypes (tree to, tree from)
{
return comp_ptr_ttypes_real (to, from, 1);
}
@@ -6556,8 +6457,7 @@
type or inheritance-related types, regardless of cv-quals. */
int
-ptr_reasonably_similar (to, from)
- tree to, from;
+ptr_reasonably_similar (tree to, tree from)
{
for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
{
@@ -6592,8 +6492,7 @@
/* Like comp_ptr_ttypes, for const_cast. */
static int
-comp_ptr_ttypes_const (to, from)
- tree to, from;
+comp_ptr_ttypes_const (tree to, tree from)
{
for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
{
@@ -6613,8 +6512,7 @@
/* Like comp_ptr_ttypes, for reinterpret_cast. */
static int
-comp_ptr_ttypes_reinterpret (to, from)
- tree to, from;
+comp_ptr_ttypes_reinterpret (tree to, tree from)
{
int constp = 1;
@@ -6649,8 +6547,7 @@
elements for an array type. */
int
-cp_type_quals (type)
- tree type;
+cp_type_quals (tree type)
{
type = strip_array_types (type);
if (type == error_mark_node)
@@ -6661,8 +6558,7 @@
/* Returns nonzero if the TYPE contains a mutable member */
int
-cp_has_mutable_p (type)
- tree type;
+cp_has_mutable_p (tree type)
{
type = strip_array_types (type);
@@ -6674,9 +6570,7 @@
if and only if there is no implicit conversion from T1 to T2. */
static void
-casts_away_constness_r (t1, t2)
- tree *t1;
- tree *t2;
+casts_away_constness_r (tree* t1, tree* t2)
{
int quals1;
int quals2;
@@ -6735,9 +6629,7 @@
constness. */
static int
-casts_away_constness (t1, t2)
- tree t1;
- tree t2;
+casts_away_constness (tree t1, tree t2)
{
if (TREE_CODE (t2) == REFERENCE_TYPE)
{
@@ -6787,8 +6679,7 @@
above are those of the array members.) */
static tree
-strip_all_pointer_quals (type)
- tree type;
+strip_all_pointer_quals (tree type)
{
if (TREE_CODE (type) == POINTER_TYPE)
return build_pointer_type (strip_all_pointer_quals (TREE_TYPE (type)));
--
Nathanael Nerode <neroden at gcc.gnu.org>
Don't use the GNU FDL for free documentation. See
<http://home.twcny.rr.com/nerode/neroden/fdl.html>
More information about the Gcc-patches
mailing list