+Mon Feb 2 00:57:38 1998 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
+
+ * call.c (user_harshness): Initialize `code' to 0.
+ (build_method_call): Initialize `candidates', `cp' and `len' to 0.
+ (null_ptr_cst_p): Add parentheses around && within ||.
+ (standard_conversion): Likewise.
+ (z_candidate): Likewise.
+ (build_user_type_conversion_1): Initialize `args' to NULL_TREE.
+ (build_object_call): Likewise for `mem_args'.
+ (build_new_op): Likewise for `mem_arglist'. Add `return' from
+ default case in enumeration switch.
+
+ * class.c (build_vtable_entry): Add explicit braces to avoid
+ ambiguous `else'.
+ (build_class_init_list): Likewise.
+ (finish_struct_1): Initialize `width' to 0.
+ (instantiate_type): Initialize `name' to NULL_TREE. Add
+ explicit braces to avoid ambiguous `else'.
+
+ * cvt.c (convert_to_aggr): Add explicit braces to avoid ambiguous
+ `else'.
+
+ * decl.c (grok_reference_init): Eliminate unused parameter, all
+ callers changed.
+ (record_builtin_type): Initialize `tdecl' to NULL_TREE.
+ (init_decl_processing): Initialize `vb_off_identifier' to NULL_TREE.
+ (cp_finish_decl): Initialize `ttype' to NULL_TREE.
+ (grokdeclarator): Add parentheses around && within ||. Add
+ explicit braces to avoid ambiguous `else'.
+ (grokparms): Initialize `type' to NULL_TREE.
+ (xref_tag): Remove unused label `just_return'.
+ (finish_enum): Initialize `minnode' and `maxnode' to NULL_TREE.
+ (finish_function): Initialize `cond' and `thenclause' to NULL_TREE.
+ (hack_incomplete_structures): Add parentheses around assignment
+ used as truth value.
+
+ * decl2.c (coerce_delete_type): Hide definition of `e3'.
+
+ * error.c: Include <stdlib.h>.
+ (dump_expr): Change the type of `i' to size_t. Remove unused
+ label `error'.
+
+ * except.c (init_exception_processing): Remove unused variable `d'.
+ (expand_throw): Likewise for `label'.
+
+ * friend.c (add_friends): Add explicit braces to avoid ambiguous
+ `else'.
+
+ * init.c (sort_member_init): Initialize `last_field' to NULL_TREE.
+ (sort_base_init): Likewise for `binfo'.
+ (expand_member_init): Likewise for `rval'.
+ (build_member_call): Add parentheses around assignment used as
+ truth value.
+ (build_offset_ref): Add explicit braces to avoid ambiguous `else'.
+ (build_new): Initialize `nelts' to NULL_TREE. Initialize
+ `old_immediate_size_expand' to 0.
+ (build_new_1): Initialize `nelts' and `alloc_node' to NULL_TREE.
+ (build_vec_delete_1): Remove unused variable `block'.
+ (expand_vec_init): Initialize `itype' to NULL_TREE.
+
+ * lex.c: Include <strings.h> if we don't have <string.h>. Protect
+ declaration of `index' and `rindex' with autoconf macros.
+ (reinit_parse_for_expr): Remove unused variables
+ `look_for_semicolon' and `look_for_lbrac'.
+ (cons_up_default_function): Initialize `args' to NULL_TREE.
+ (readescape): Initialize `firstdig' to 0.
+ (real_yylex): Add parentheses around assignment used as truth value.
+
+ * method.c: Include <strings.h> if we don't have <string.h>.
+ Protect declaration of `index' with autoconf macro.
+
+ * parse.y (primary): Add explicit braces to avoid ambiguous `else'.
+ Initialize `type' to NULL_TREE.
+ (structsp): Remove unused variable `id'.
+
+ * pt.c (coerce_template_parms): Add explicit braces to avoid
+ ambiguous `else'.
+ (lookup_template_class): Initialize `template' to NULL_TREE.
+ (instantiate_class_template): Remove unused variable `name' and `e'.
+ (tsubst): Likewise for `i'. Initialize `last' to NULL_TREE.
+ (do_poplevel): Initialize `saved_warn_unused' to 0.
+ (type_unification): Remove unused varable `parm'.
+ (unify): Likewise for `j'.
+
+ * repo.c (init_repo): Add parentheses around assignment used as
+ truth value.
+ (finish_repo): Remove unused varable `p'.
+
+ * search.c (get_binfo): Initiize `type' to NULL_TREE.
+ (get_base_distance): Likewise.
+ (lookup_field): Initialize `rval_binfo_h', `type', `basetype_path'
+ and `new_v' to NULL_TREE.
+ (lookup_fnfields): Likewise for `rval_binfo_h'.
+ (breadth_first_search): Add parentheses around assignment used as
+ truth value.
+ (get_template_base): Initialize `type' to NULL_TREE.
+
+ * sig.c (append_signature_fields): Initialize `last_mfptr' to
+ NULL_TREE.
+ (build_signature_table_constructor): Likewise for
+ `last_rhs_field', `pfn' and `vt_off'.
+ (build_sigtable): Likewise for `init'.
+
+ * tree.c (break_out_calls): Initialize `t2' to NULL_TREE.
+ (propagate_binfo_offsets): Likewise for `delta'.
+ (hash_tree_cons): Initialize hashcode to 0.
+ (can_free): Likewise for `size'.
+ (cp_tree_equal): Add explicit braces to avoid ambiguous `else'.
+
+ * typeck.c (convert_sequence): Hide prototype.
+ (common_type): Add explicit braces to avoid ambiguous `else'.
+ (comp_target_types): Likewise.
+ (build_x_function_call): Initialize `ctypeptr' to NULL_TREE.
+ (build_function_call_real): Add explicit braces to avoid ambiguous
+ `else'.
+ (convert_arguments): Initialize `called_thing' to 0.
+ (convert_for_initialization): Initialize `savew' and `savee' to 0.
+
+ * typeck2.c (incomplete_type_error): Initialize `errmsg' to 0.
+ (digest_init): Initialize `old_tail_contents' to NULL_TREE.
+ (build_x_arrow): Likewise for `last_rval'.
+
+ * xref.c (GNU_xref_decl): Initialize `cls' to 0.
+
Sun Feb 1 12:45:34 1998 J"orn Rennecke <amylaar@cygnus.co.uk>
* decl.c (init_decl_processing): Use set_sizetype.
{
tree conv;
tree winner = NULL_TREE;
- int code;
+ int code = 0;
{
tree typename = build_typename_overload (type);
for (pass = 0; pass < 2; pass++)
{
- struct candidate *candidates;
- struct candidate *cp;
- int len;
+ struct candidate *candidates = 0;
+ struct candidate *cp = 0;
+ int len = 0;
unsigned best = 1;
baselink = result;
tree t;
{
if (t == null_node
- || integer_zerop (t) && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE)
+ || (integer_zerop (t) && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE))
return 1;
return 0;
}
return 0;
conv = build_conv (STD_CONV, to, conv);
- if (fcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (from)
- && ICS_STD_RANK (conv) < PBOOL_RANK)
+ if (fcode == POINTER_TYPE
+ || (TYPE_PTRMEMFUNC_P (from) && ICS_STD_RANK (conv) < PBOOL_RANK))
ICS_STD_RANK (conv) = PBOOL_RANK;
}
/* We don't check for ENUMERAL_TYPE here because there are no standard
case EQ_EXPR:
case NE_EXPR:
- if (TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2)
- || TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
+ if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
+ || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
break;
if ((TYPE_PTRMEMFUNC_P (type1) || TYPE_PTRMEM_P (type1))
&& null_ptr_cst_p (args[1]))
case GE_EXPR:
case MAX_EXPR:
case MIN_EXPR:
- if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)
- || TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
+ if ((ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
+ || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2)))
break;
if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
{
struct z_candidate *candidates, *cand;
tree fromtype = TREE_TYPE (expr);
tree ctors = NULL_TREE, convs = NULL_TREE, *p;
- tree args;
+ tree args = NULL_TREE;
tree templates = NULL_TREE;
if (IS_AGGR_TYPE (totype))
tree obj, args;
{
struct z_candidate *candidates = 0, *cand;
- tree fns, convs, mem_args;
+ tree fns, convs, mem_args = NULL_TREE;
tree type = TREE_TYPE (obj);
tree templates = NULL_TREE;
tree arg1, arg2, arg3;
{
struct z_candidate *candidates = 0, *cand;
- tree fns, mem_arglist, arglist, fnname;
+ tree fns, mem_arglist = NULL_TREE, arglist, fnname;
enum tree_code code2 = NOP_EXPR;
tree templates = NULL_TREE;
tree conv;
default:
my_friendly_abort (367);
+ return NULL_TREE;
}
}
{
struct z_candidate *candidates = 0, *cand;
tree explicit_targs = NULL_TREE;
- tree basetype, mem_args, fns, instance_ptr;
+ tree basetype, mem_args = NULL_TREE, fns, instance_ptr;
tree pretty_name;
tree user_args = args;
tree templates = NULL_TREE;
< TREE_INT_CST_LOW (delta))
|| (TREE_INT_CST_LOW (delta)
< TREE_INT_CST_LOW (TYPE_MIN_VALUE (delta_type_node))))
- if (flag_huge_objects)
- sorry ("object size exceeds built-in limit for virtual function table implementation");
- else
- sorry ("object size exceeds normal limit for virtual function table implementation, recompile all source and use -fhuge-objects");
-
+ {
+ if (flag_huge_objects)
+ sorry ("object size exceeds built-in limit for virtual function table implementation");
+ else
+ sorry ("object size exceeds normal limit for virtual function table implementation, recompile all source and use -fhuge-objects");
+ }
+
TREE_CONSTANT (entry) = 1;
TREE_STATIC (entry) = 1;
TREE_READONLY (entry) = 1;
}
if (base_init_list)
- if (member_init_list)
- CLASSTYPE_BASE_INIT_LIST (type) = build_tree_list (base_init_list, member_init_list);
- else
- CLASSTYPE_BASE_INIT_LIST (type) = base_init_list;
+ {
+ if (member_init_list)
+ CLASSTYPE_BASE_INIT_LIST (type) =
+ build_tree_list (base_init_list, member_init_list);
+ else
+ CLASSTYPE_BASE_INIT_LIST (type) = base_init_list;
+ }
else if (member_init_list)
CLASSTYPE_BASE_INIT_LIST (type) = member_init_list;
}
if (DECL_INITIAL (x))
{
tree w = DECL_INITIAL (x);
- register int width;
+ register int width = 0;
/* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
STRIP_NOPS (w);
case TREE_LIST:
{
- tree elem, baselink, name;
+ tree elem, baselink, name = NULL_TREE;
int globals = overloaded_globals_p (rhs);
/* First look for an exact match. Search either overloaded
lhstype = TYPE_PTRMEMFUNC_FN_TYPE (lhstype);
if (TREE_CODE (lhstype) == POINTER_TYPE)
- if (TREE_CODE (TREE_TYPE (lhstype)) == FUNCTION_TYPE
- || TREE_CODE (TREE_TYPE (lhstype)) == METHOD_TYPE)
- lhstype = TREE_TYPE (lhstype);
- else
- {
- if (complain)
- error ("invalid type combination for overload");
- return error_mark_node;
- }
+ {
+ if (TREE_CODE (TREE_TYPE (lhstype)) == FUNCTION_TYPE
+ || TREE_CODE (TREE_TYPE (lhstype)) == METHOD_TYPE)
+ lhstype = TREE_TYPE (lhstype);
+ else
+ {
+ if (complain)
+ error ("invalid type combination for overload");
+ return error_mark_node;
+ }
+ }
if (TREE_CODE (lhstype) != FUNCTION_TYPE && globals > 0)
{
can match. */
if (explicit_targs == NULL_TREE)
while (elem)
- if (! comptypes (lhstype, TREE_TYPE (elem), 1))
- elem = DECL_CHAIN (elem);
- else
- {
- mark_used (elem);
- return elem;
- }
+ {
+ if (! comptypes (lhstype, TREE_TYPE (elem), 1))
+ elem = DECL_CHAIN (elem);
+ else
+ {
+ mark_used (elem);
+ return elem;
+ }
+ }
/* No exact match found, look for a compatible template. */
{
else if (msgp)
{
if (saw_private)
- if (saw_protected)
- *msgp = "only private and protected conversions apply";
- else
- *msgp = "only private conversions apply";
+ {
+ if (saw_protected)
+ *msgp = "only private and protected conversions apply";
+ else
+ *msgp = "only private conversions apply";
+ }
else if (saw_protected)
*msgp = "only protected conversions apply";
else
static tree maybe_build_cleanup_1 PROTO((tree, tree));
static tree lookup_name_real PROTO((tree, int, int));
static void warn_extern_redeclared_static PROTO((tree, tree));
-static void grok_reference_init PROTO((tree, tree, tree, tree *));
+static void grok_reference_init PROTO((tree, tree, tree));
static tree grokfndecl PROTO((tree, tree, tree, tree, int,
enum overload_flags,
tree, tree, tree, int, int, int, int, int, int));
tree type;
{
tree rname = NULL_TREE, tname = NULL_TREE;
- tree tdecl;
+ tree tdecl = NULL_TREE;
if ((int) rid_index < (int) RID_MAX)
rname = ridpointers[(int) rid_index];
tree temp;
tree array_domain_type;
extern int flag_strict_prototype;
- tree vb_off_identifier;
+ tree vb_off_identifier = NULL_TREE;
/* Function type `char *(char *, char *)' and similar ones */
tree string_ftype_ptr_ptr, int_ftype_string_string;
tree sizetype_endlink;
Quotes on semantics can be found in ARM 8.4.3. */
static void
-grok_reference_init (decl, type, init, cleanupp)
+grok_reference_init (decl, type, init)
tree decl, type, init;
- tree *cleanupp;
{
tree tmp;
int flags;
{
register tree type;
- tree cleanup = NULL_TREE, ttype;
+ tree cleanup = NULL_TREE, ttype = NULL_TREE;
int was_incomplete;
int temporary = allocation_temporary_p ();
char *asmspec = NULL;
make_decl_rtl (decl, NULL_PTR,
toplevel_bindings_p ()
|| pseudo_global_level_p ());
- grok_reference_init (decl, type, init, &cleanup);
+ grok_reference_init (decl, type, init);
init = NULL_TREE;
}
}
if (! IDENTIFIER_OPNAME_P (dname)
/* GNU/Linux headers use '__op'. Arrgh. */
- || IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname))
+ || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
name = IDENTIFIER_POINTER (dname);
else
{
/* Note that the grammar rejects storage classes
in typenames, fields or parameters. */
if (constp || volatilep)
- if (IS_SIGNATURE (type))
- error ("`const' or `volatile' specified with signature type");
- else
- type = cp_build_type_variant (type, constp, volatilep);
+ {
+ if (IS_SIGNATURE (type))
+ error ("`const' or `volatile' specified with signature type");
+ else
+ type = cp_build_type_variant (type, constp, volatilep);
+ }
/* Special case: "friend class foo" looks like a TYPENAME context. */
if (friendp)
for (parm = first_parm; parm != NULL_TREE; parm = chain)
{
- tree type, list_node = parm;
+ tree type = NULL_TREE, list_node = parm;
register tree decl = TREE_VALUE (parm);
tree init = TREE_PURPOSE (parm);
if (binfo)
xref_basetypes (code_type_node, name, ref, binfo);
- just_return:
-
/* Until the type is defined, tentatively accept whatever
structure tag the user hands us. */
if (TYPE_SIZE (ref) == NULL_TREE
finish_enum (enumtype, values)
register tree enumtype, values;
{
- register tree minnode, maxnode;
+ register tree minnode = NULL_TREE, maxnode = NULL_TREE;
/* Calculate the maximum value of any enumerator in this type. */
if (values)
}
else if (DECL_CONSTRUCTOR_P (fndecl))
{
- tree cond, thenclause;
+ tree cond = NULL_TREE, thenclause = NULL_TREE;
/* Allow constructor for a type to get a new instance of the object
using `build_new'. */
tree abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type);
for (list = ¤t_binding_level->incomplete; *list; )
{
tree decl = TREE_VALUE (*list);
- if (decl && TREE_TYPE (decl) == type
+ if ((decl && TREE_TYPE (decl) == type)
|| (TREE_TYPE (decl)
&& TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
&& TREE_TYPE (TREE_TYPE (decl)) == type))
coerce_delete_type (type)
tree type;
{
- int e1 = 0, e2 = 0, e3 = 0;
+ int e1 = 0, e2 = 0;
+#if 0
+ e3 = 0;
+#endif
tree arg_types = TYPE_ARG_TYPES (type);
if (TREE_CODE (type) == METHOD_TYPE)
#include "config.h"
#include <stdio.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
#include "tree.h"
#include "cp-tree.h"
#include "obstack.h"
#else
{
unsigned char *p = (unsigned char *) &TREE_REAL_CST (t);
- int i;
+ size_t i;
strcpy (digit_buffer, "0x");
for (i = 0; i < sizeof TREE_REAL_CST (t); i++)
sprintf (digit_buffer + 2 + 2*i, "%02x", *p++);
/* fall through to ERROR_MARK... */
case ERROR_MARK:
- error:
OB_PUTCP ("{error}");
break;
}
void
init_exception_processing ()
{
- tree d;
-
/* void vtype () */
tree vtype = build_function_type (void_type_node, void_list_node);
expand_throw (exp)
tree exp;
{
- rtx label;
tree fn;
static tree cleanup_type;
while (friends && TREE_PURPOSE (friends) != friend_type)
friends = TREE_CHAIN (friends);
if (friends)
- if (friend_type)
- warning ("method `%s::%s' is already a friend of class",
- TYPE_NAME_STRING (friend_type),
- IDENTIFIER_POINTER (name));
- else
- warning ("function `%s' is already a friend of class `%s'",
- IDENTIFIER_POINTER (name),
- IDENTIFIER_POINTER (DECL_NAME (typedecl)));
+ {
+ if (friend_type)
+ warning ("method `%s::%s' is already a friend of class",
+ TYPE_NAME_STRING (friend_type),
+ IDENTIFIER_POINTER (name));
+ else
+ warning ("function `%s' is already a friend of class `%s'",
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (DECL_NAME (typedecl)));
+ }
else
TREE_VALUE (list) = tree_cons (friend_type, NULL_TREE,
TREE_VALUE (list));
tree x, member, name, field;
tree init_list = NULL_TREE;
int last_pos = 0;
- tree last_field;
+ tree last_field = NULL_TREE;
for (member = TYPE_FIELDS (t); member ; member = TREE_CHAIN (member))
{
for (x = TREE_CHAIN (last); x; x = TREE_CHAIN (x))
{
tree basetype = TREE_PURPOSE (x);
- tree binfo;
+ tree binfo = NULL_TREE;
if (basetype == NULL_TREE)
{
tree basetype = NULL_TREE, field;
tree parm;
- tree rval, type;
+ tree rval = NULL_TREE, type;
if (exp == NULL_TREE)
return; /* complain about this later */
if (method_name == constructor_name (type)
|| method_name == constructor_name_full (type))
return build_functional_cast (type, parmlist);
- if (t = lookup_fnfields (basetype_path, method_name, 0))
+ if ((t = lookup_fnfields (basetype_path, method_name, 0)))
return build_method_call (decl,
TREE_CODE (name) == TEMPLATE_ID_EXPR
? name : method_name,
decl = current_class_ref;
if (constructor_name (BINFO_TYPE (basebinfo)) == name)
- if (dtor)
- name = dtor_identifier;
- else
- name = ctor_identifier;
+ {
+ if (dtor)
+ name = dtor_identifier;
+ else
+ name = ctor_identifier;
+ }
else
if (dtor)
my_friendly_abort (999);
int use_global_new;
{
tree type, rval;
- tree nelts, t;
+ tree nelts = NULL_TREE, t;
int has_array = 0;
tree pending_sizes = NULL_TREE;
{
tree absdcl = TREE_VALUE (decl);
tree last_absdcl = NULL_TREE;
- int old_immediate_size_expand;
+ int old_immediate_size_expand = 0;
if (current_function_decl
&& DECL_CONSTRUCTOR_P (current_function_decl))
{
tree placement, init, t;
tree type, true_type, size, rval;
- tree nelts;
- tree alloc_expr, alloc_node;
+ tree nelts = NULL_TREE;
+ tree alloc_expr, alloc_node = NULL_TREE;
int has_array = 0;
enum tree_code code = NEW_EXPR;
int use_cookie, nothrow, check_new;
This is also the containing expression returned by this function. */
tree controller = NULL_TREE;
- /* This is the BLOCK to record the symbol binding for debugging. */
- tree block;
-
if (! IS_AGGR_TYPE (type) || ! TYPE_NEEDS_DESTRUCTOR (type))
{
loop = integer_zero_node;
iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
init_by_default:
+ itype = NULL_TREE;
/* If initializing one array from another,
initialize element by element. */
#ifdef HAVE_STRING_H
#include <string.h>
#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#endif
+
+#ifdef NEED_DECLARATION_INDEX
extern char *index ();
+#endif
+
+#ifdef NEED_DECLARATION_RINDEX
extern char *rindex ();
#endif
int starting_lineno = lineno;
char *starting_filename = input_filename;
int len;
- int look_for_semicolon = 0;
- int look_for_lbrac = 0;
int plev = 0;
if (nextchar != EOF)
{
extern tree void_list_node;
tree declspecs = NULL_TREE;
- tree fn, args;
+ tree fn, args = NULL_TREE;
tree argtype;
int retref = 0;
tree name = constructor_name (full_name);
register int c = getch ();
register int code;
register unsigned count;
- unsigned firstdig;
+ unsigned firstdig = 0;
int nonnull;
switch (c)
{
register struct resword *ptr;
- if (ptr = is_reserved_word (token_buffer, p - token_buffer))
+ if ((ptr = is_reserved_word (token_buffer, p - token_buffer)))
{
if (ptr->rid)
{
#ifdef HAVE_STRING_H
#include <string.h>
#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#endif
+
+#ifdef NEED_DECLARATION_INDEX
extern char *index ();
#endif
if (TREE_CODE (yyval.ttype) == BIT_NOT_EXPR)
yyval.ttype = build_x_unary_op (BIT_NOT_EXPR, TREE_OPERAND (yyval.ttype, 0));
else if (TREE_CODE (yyval.ttype) != TEMPLATE_ID_EXPR)
- if (processing_template_arg)
- {
- tree id;
- arg_looking_for_template = processing_template_arg;
- id = lookup_name (yyval.ttype, 0);
- arg_looking_for_template = 0;
+ {
+ if (processing_template_arg)
+ {
+ tree id;
+ arg_looking_for_template = processing_template_arg;
+ id = lookup_name (yyval.ttype, 0);
+ arg_looking_for_template = 0;
- if (!id || id == error_mark_node
- || (TREE_CODE (id) != TEMPLATE_DECL
- && TREE_CODE (id) != TEMPLATE_TEMPLATE_PARM))
- id = do_identifier (yyval.ttype, 1);
- yyval.ttype = id;
- }
- else
- yyval.ttype = do_identifier (yyval.ttype, 1);
+ if (!id || id == error_mark_node
+ || (TREE_CODE (id) != TEMPLATE_DECL
+ && TREE_CODE (id) != TEMPLATE_TEMPLATE_PARM))
+ id = do_identifier (yyval.ttype, 1);
+ yyval.ttype = id;
+ }
+ else
+ yyval.ttype = do_identifier (yyval.ttype, 1);
+ }
;
break;}
case 284:
case 296:
#line 1511 "parse.y"
{
- tree type;
+ tree type = NULL_TREE;
tree id = yyval.ttype;
/* This is a C cast in C++'s `functional' notation. */
#line 2307 "parse.y"
{
int semi;
- tree id;
yyval.ttype = yyvsp[-4].ttype;
#if 0
if (TREE_CODE ($$) == BIT_NOT_EXPR)
$$ = build_x_unary_op (BIT_NOT_EXPR, TREE_OPERAND ($$, 0));
else if (TREE_CODE ($$) != TEMPLATE_ID_EXPR)
- if (processing_template_arg)
- {
- tree id;
- arg_looking_for_template = processing_template_arg;
- id = lookup_name ($$, 0);
- arg_looking_for_template = 0;
+ {
+ if (processing_template_arg)
+ {
+ tree id;
+ arg_looking_for_template = processing_template_arg;
+ id = lookup_name ($$, 0);
+ arg_looking_for_template = 0;
- if (!id || id == error_mark_node
- || (TREE_CODE (id) != TEMPLATE_DECL
- && TREE_CODE (id) != TEMPLATE_TEMPLATE_PARM))
- id = do_identifier ($$, 1);
- $$ = id;
- }
- else
- $$ = do_identifier ($$, 1);
+ if (!id || id == error_mark_node
+ || (TREE_CODE (id) != TEMPLATE_DECL
+ && TREE_CODE (id) != TEMPLATE_TEMPLATE_PARM))
+ id = do_identifier ($$, 1);
+ $$ = id;
+ }
+ else
+ $$ = do_identifier ($$, 1);
+ }
}
| CONSTANT
| boolean.literal
}
| CV_QUALIFIER '(' nonnull_exprlist ')'
{
- tree type;
+ tree type = NULL_TREE;
tree id = $$;
/* This is a C cast in C++'s `functional' notation. */
opt.component_decl_list '}' maybe_attribute
{
int semi;
- tree id;
$<ttype>$ = $1;
#if 0
}
if (arglist && TREE_CODE (arglist) == TREE_VEC)
- if (nargs == nparms)
- vec = copy_node (arglist);
- else
- {
- /* We arrive here when a template with some default arguments
- is used as template template argument. */
- is_tmpl_parm = 1;
- vec = make_tree_vec (nparms);
- for (i = 0; i < nparms; i++)
- {
- tree arg;
-
- if (i < nargs)
+ {
+ if (nargs == nparms)
+ vec = copy_node (arglist);
+ else
+ {
+ /* We arrive here when a template with some default arguments
+ is used as template template argument. */
+ is_tmpl_parm = 1;
+ vec = make_tree_vec (nparms);
+ for (i = 0; i < nparms; i++)
+ {
+ tree arg;
+
+ if (i < nargs)
arg = TREE_VEC_ELT (arglist, i);
- else if (TREE_CODE (TREE_VALUE (TREE_VEC_ELT (parms, i)))
- == TYPE_DECL)
- arg = tsubst (TREE_PURPOSE (TREE_VEC_ELT (parms, i)),
- vec, i, in_decl);
- else
- arg = tsubst_expr (TREE_PURPOSE (TREE_VEC_ELT (parms, i)),
- vec, i, in_decl);
-
- TREE_VEC_ELT (vec, i) = arg;
- }
- }
+ else if (TREE_CODE (TREE_VALUE (TREE_VEC_ELT (parms, i)))
+ == TYPE_DECL)
+ arg = tsubst (TREE_PURPOSE (TREE_VEC_ELT (parms, i)),
+ vec, i, in_decl);
+ else
+ arg = tsubst_expr (TREE_PURPOSE (TREE_VEC_ELT (parms, i)),
+ vec, i, in_decl);
+
+ TREE_VEC_ELT (vec, i) = arg;
+ }
+ }
+ }
else
{
vec = make_tree_vec (nparms);
tree in_decl;
tree context;
{
- tree template, parmlist;
+ tree template = NULL_TREE, parmlist;
char *mangled_name;
tree id, t;
for (t = CLASSTYPE_TAGS (pattern); t; t = TREE_CHAIN (t))
{
- tree name = TREE_PURPOSE (t);
tree tag = TREE_VALUE (t);
/* These will add themselves to CLASSTYPE_TAGS for the new type. */
if (TREE_CODE (tag) == ENUMERAL_TYPE)
{
- tree e, newtag = tsubst_enum (tag, args,
- TREE_VEC_LENGTH (args), field_chain);
+ tree newtag =
+ tsubst_enum (tag, args, TREE_VEC_LENGTH (args), field_chain);
while (*field_chain)
{
tree new_decl;
tree parms;
tree spec;
- int i;
/* We might already have an instance of this template. */
spec = retrieve_specialization (t, args);
/* This should probably be rewritten to use hash_tree_cons for
the memory savings. */
tree first = NULL_TREE;
- tree last;
+ tree last = NULL_TREE;
for (; values && values != void_list_node;
values = TREE_CHAIN (values))
do_poplevel ()
{
tree t;
- int saved_warn_unused;
+ int saved_warn_unused = 0;
if (processing_template_decl)
{
{
int ntparms = TREE_VEC_LENGTH (tparms);
tree arg;
- tree parm;
int i;
int r;
tree argvec = CLASSTYPE_TI_ARGS (arg);
tree argtmplvec
= DECL_INNERMOST_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (arg));
- int i, j;
+ int i;
/* The parameter and argument roles have to be switched here
in order to handle default arguments properly. For example,
if (repo_file == 0)
return;
- while (buf = afgets (repo_file))
+ while ((buf = afgets (repo_file)))
{
switch (buf[0])
{
finish_repo ()
{
tree t;
- char *p;
int repo_changed = 0;
char *dir, *args;
register tree parent, binfo;
int protect;
{
- tree type;
+ tree type = NULL_TREE;
int dist;
tree rval = NULL_TREE;
{
int rval;
int rval_private = 0;
- tree type;
+ tree type = NULL_TREE;
tree new_binfo = NULL_TREE;
int via_virtual;
int watch_access = protect;
int protect, want_type;
{
int head = 0, tail = 0;
- tree rval, rval_binfo = NULL_TREE, rval_binfo_h;
- tree type, basetype_chain, basetype_path;
+ tree rval, rval_binfo = NULL_TREE, rval_binfo_h = NULL_TREE;
+ tree type = NULL_TREE, basetype_chain, basetype_path = NULL_TREE;
tree this_v = access_default_node;
tree entry, binfo, binfo_h;
tree own_access = access_default_node;
/* If is possible for one of the derived types on the path to
have defined special access for this field. Look for such
declarations and report an error if a conflict is found. */
- tree new_v;
+ tree new_v = NULL_TREE;
if (this_v != access_default_node)
new_v = compute_access (TREE_VALUE (TREE_CHAIN (*tp)), rval);
int complain;
{
int head = 0, tail = 0;
- tree type, rval, rval_binfo = NULL_TREE, rvals = NULL_TREE, rval_binfo_h;
- tree entry, binfo, basetype_chain, binfo_h;
+ tree type, rval, rval_binfo = NULL_TREE, rvals = NULL_TREE;
+ tree rval_binfo_h = NULL_TREE, entry, binfo, basetype_chain, binfo_h;
int find_all = 0;
/* rval_binfo is the binfo associated with the found member, note,
binfo = search_stack->first[head++];
i = (HOST_WIDE_INT) search_stack->first[head++];
- if (rval = (*testfn) (binfo, i))
+ if ((rval = (*testfn) (binfo, i)))
break;
binfo = BINFO_BASETYPE (binfo, i);
}
get_template_base (template, binfo)
register tree template, binfo;
{
- tree type, rval;
+ tree type = NULL_TREE, rval;
if (TREE_CODE (binfo) == TREE_VEC)
type = BINFO_TYPE (binfo);
tree l, x;
tree last_x = NULL_TREE;
tree mfptr;
- tree last_mfptr;
+ tree last_mfptr = NULL_TREE;
tree mfptr_list = NULL_TREE;
/* For signatures it should actually be only a list with one element. */
tree sig_field = TYPE_FIELDS (sig_ty);
tree result = NULL_TREE;
tree first_rhs_field = NULL_TREE;
- tree last_rhs_field;
+ tree last_rhs_field = NULL_TREE;
int sig_ptr_p = IS_SIGNATURE (rhstype);
int offset_p = sig_ptr_p;
}
else
{
- tree tag, vb_off, delta, idx, pfn, vt_off;
+ tree tag, vb_off, delta, idx, pfn = NULL_TREE, vt_off = NULL_TREE;
tree tag_decl, vb_off_decl, delta_decl, index_decl;
tree pfn_decl, vt_off_decl;
}
if (decl == NULL_TREE)
{
- tree init;
+ tree init = NULL_TREE;
/* We allow only one signature table to be generated for signatures
with opaque types. Otherwise we create a loophole in the type
break_out_calls (exp)
tree exp;
{
- register tree t1, t2;
+ register tree t1, t2 = NULL_TREE;
register enum tree_code code;
register int changed = 0;
register int i;
{
int j;
tree base_binfos = BINFO_BASETYPES (base_binfo);
- tree delta;
+ tree delta = NULL_TREE;
for (j = i+1; j < n_baselinks; j++)
if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos, j)))
{
struct obstack *ambient_obstack = current_obstack;
tree t;
- int hashcode;
+ int hashcode = 0;
if (! debug_no_list_hash)
{
struct obstack *obstack;
tree t;
{
- int size;
+ int size = 0;
if (TREE_CODE (t) == TREE_VEC)
size = (TREE_VEC_LENGTH (t)-1) * sizeof (tree) + sizeof (struct tree_vec);
code2 = TREE_CODE (t2);
if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
- if (code2 == NOP_EXPR || code2 == CONVERT_EXPR || code2 == NON_LVALUE_EXPR)
- return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
- else
- return cp_tree_equal (TREE_OPERAND (t1, 0), t2);
+ {
+ if (code2 == NOP_EXPR || code2 == CONVERT_EXPR || code2 == NON_LVALUE_EXPR)
+ return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
+ else
+ return cp_tree_equal (TREE_OPERAND (t1, 0), t2);
+ }
else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
|| code2 == NON_LVALUE_EXPR)
return cp_tree_equal (t1, TREE_OPERAND (t2, 0));
tree, int));
static tree build_ptrmemfunc1 PROTO((tree, tree, tree, tree, tree));
static tree common_base_type PROTO((tree, tree));
+#if 0
static tree convert_sequence PROTO((tree, tree));
+#endif
static tree lookup_anon_field PROTO((tree, tree));
static tree pointer_diff PROTO((tree, tree, tree));
static tree qualify_type PROTO((tree, tree));
/* One that completely contains the other? Take it. */
else if (a2 && !attribute_list_contained (a1, a2))
- if (attribute_list_contained (a2, a1))
+ {
+ if (attribute_list_contained (a2, a1))
attributes = a2;
- else
- {
- /* Pick the longest list, and hang on the other list. */
- /* ??? For the moment we punt on the issue of attrs with args. */
+ else
+ {
+ /* Pick the longest list, and hang on the other list. */
+ /* ??? For the moment we punt on the issue of attrs with args. */
- if (list_length (a1) < list_length (a2))
- attributes = a2, a2 = a1;
+ if (list_length (a1) < list_length (a2))
+ attributes = a2, a2 = a1;
- for (; a2; a2 = TREE_CHAIN (a2))
- if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
- attributes) == NULL_TREE)
- {
- a1 = copy_node (a2);
- TREE_CHAIN (a1) = attributes;
- attributes = a1;
- }
- }
+ for (; a2; a2 = TREE_CHAIN (a2))
+ if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
+ attributes) == NULL_TREE)
+ {
+ a1 = copy_node (a2);
+ TREE_CHAIN (a1) = attributes;
+ attributes = a1;
+ }
+ }
+ }
}
/* Treat an enum type as the unsigned integer type of the same width. */
if (TREE_CODE (ttr) == ARRAY_TYPE)
return comp_array_types (comp_target_types, ttl, ttr, 0);
else if (TREE_CODE (ttr) == FUNCTION_TYPE || TREE_CODE (ttr) == METHOD_TYPE)
- if (comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), -1))
- switch (comp_target_parms (TYPE_ARG_TYPES (ttl), TYPE_ARG_TYPES (ttr), 1))
- {
- case 0:
- return 0;
- case 1:
- return 1;
- case 2:
- return -1;
- default:
- my_friendly_abort (112);
- }
- else
- return 0;
-
+ {
+ if (comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), -1))
+ switch (comp_target_parms (TYPE_ARG_TYPES (ttl), TYPE_ARG_TYPES (ttr), 1))
+ {
+ case 0:
+ return 0;
+ case 1:
+ return 1;
+ case 2:
+ return -1;
+ default:
+ my_friendly_abort (112);
+ }
+ else
+ return 0;
+ }
/* for C++ */
else if (TREE_CODE (ttr) == OFFSET_TYPE)
{
if (is_method)
{
tree fntype = TREE_TYPE (function);
- tree ctypeptr;
+ tree ctypeptr = NULL_TREE;
/* Explicitly named method? */
if (TREE_CODE (function) == FUNCTION_DECL)
params, fndecl, 0);
if (coerced_params == error_mark_node)
- if (flags & LOOKUP_SPECULATIVELY)
- return NULL_TREE;
- else
- return error_mark_node;
+ {
+ if (flags & LOOKUP_SPECULATIVELY)
+ return NULL_TREE;
+ else
+ return error_mark_node;
+ }
/* Check for errors in format strings. */
{
register tree typetail, valtail;
register tree result = NULL_TREE;
- char *called_thing;
+ char *called_thing = 0;
int i = 0;
if (! flag_elide_constructors)
{
/* This should eventually happen in convert_arguments. */
extern int warningcount, errorcount;
- int savew, savee;
+ int savew = 0, savee = 0;
if (fndecl)
savew = warningcount, savee = errorcount;
tree value;
tree type;
{
- char *errmsg;
+ char *errmsg = 0;
/* Avoid duplicate error message. */
if (TREE_CODE (type) == ERROR_MARK)
{
enum tree_code code = TREE_CODE (type);
tree element = NULL_TREE;
- tree old_tail_contents;
+ tree old_tail_contents = NULL_TREE;
/* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR
tree node which has no TREE_TYPE. */
int raw_constructor;
tree types_memoized = NULL_TREE;
register tree rval = datum;
tree type = TREE_TYPE (rval);
- tree last_rval;
+ tree last_rval = NULL_TREE;
if (type == error_mark_node)
return error_mark_node;
tree decl;
{
XREF_FILE xf,xf1;
- char *cls;
+ char *cls = 0;
char *name;
char buf[10240];
int uselin;
projects / gcc.git / commitdiff