58th Cygnus<->FSF merge

From-SVN: r9186

gcc/cp/ChangeLog

+Mon Mar 13 21:00:28 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* decl.c (grokdeclarator, case ARRAY_REF): Wrap the exp with fold,
+	and convert the size and integer_one_node to the index type.
+
+Mon Mar 13 08:01:02 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* typeck.c (get_member_function_from_ptrfunc): Save the instance
+	argument, and tack it onto the front of the COND_EXPR to make the
+	semantics come out right.  Grab the instance argument from
+	'*instance_ptrptr', rather than having it passed in separately.
+	
+	* various: Change various consed-up comparison operations to have
+	boolean type.  Remove the instance argument in calls to
+	get_member_function_from_ptrfunc.
+
+	* error.c (dump_expr): Dump true and false as "true" and "false".
+
+	* decl2.c (finish_file): Also set DECL_STATIC_FUNCTION_P on the
+	global init function.
+
+	* decl.c (finish_function): Only set DECL_EXTERNAL here if the
+	inline function is public.
+
+Sat Mar 11 00:58:03 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* init.c (is_friend): Be more careful about checking
+	DECL_CLASS_CONTEXT on non-member functions.
+
+	* decl2.c (finish_vtable_vardecl): Don't bother calling
+	assemble_external here.
+	(prune_vtable_vardecl): New function that just splices out the
+	vtable decl from the top-level decls.
+	(import_export_inline): Unset DECL_EXTERNAL at first.
+	(finish_file): Don't bother calling assemble_external here.  Do
+	splice out all of the vtables.
+
+Fri Mar 10 14:42:29 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* decl.c (finish_function): If we're not emitting the function yet,
+	call assemble_external for it.
+
+	* decl2.c (finish_prevtable_vardecl): Don't call mark_vtable_entries
+	here.
+	(finish_vtable_vardecl): Don't do the linkage deduction thing here.
+	Also don't splice out the current vtable if it is unused.
+	(finish_file): Move the second walk_vtables and the synthesis check
+	inside the 'reconsider' loop.  Move thunk emission after the
+	'reconsider' loop.
+
+Thu Mar  9 16:28:16 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* pt.c (tsubst): Don't bother calling cp_build_type_variant, since it
+	was passing bogus values for readonly and volatile from the original
+	template decl, not the resultant type of the tsubst call.
+
+	* class.c (duplicate_tag_error): Use cp_error_at to point out the
+	previous definition of the tag.
+
+Thu Mar  9 10:46:17 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* decl.c (start_function): Clear base_init_insns and protect_list.
+	(struct cp_function): Add base_init_insns field.
+	(push_cp_function_context): Also save base_init_insns.
+	(pop_cp_function_context): Also restore base_init_insns.
+
+Wed Mar  8 13:31:44 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* init.c (member_init_ok_or_else): Check for initializing a static
+	member here.
+	(emit_base_init): Instead of here.
+
+Tue Mar  7 16:03:26 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* call.c (build_method_call): Disable synthesis as needed.
+	* lex.c (cons_up_default_function): Ditto.
+
 Tue Mar  7 10:14:29 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
 
 	* parse.y: New rules to allow attributes in a prefix position.
@@ -10,6 +87,234 @@ Tue Mar  7 10:14:29 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
 	(grokdeclarator): Added code to support machine attributes.
 	* Makefile.in (stamp-parse): Expect 5 shift/reduce failures.
 
+Mon Mar  6 15:07:02 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* call.c (build_method_call): Don't synthesize methods outside of a
+	function.
+
+	Make base initialization more re-entrant so that synthesis on the
+	fly will work (and, eventually, template instantation on the fly).
+	* init.c (sort_member_init): Don't bother with members that can't be
+	initialized.  Reorganize a bit.  Don't initialize base members here.
+	(sort_base_init): New function, like sort_member_init, but for base
+	classes.  Steals some code from emit_base_init.
+	(emit_base_init): Simplify.  Call sort_{member,base}_init before
+	doing any initialization, so we don't have to save
+	current_{member,base}_init_list in push_cp_function_context.
+	(expand_aggr_vbase_init_1): Adjust for sort_base_init.
+	(expand_aggr_vbase_init): Simplify.
+	* decl.c (struct cp_function): Add protect_list field.
+	(push_cp_function_context): Also save protect_list.
+	(pop_cp_function_context): Also restore protect_list.
+	* call.c (build_method_call): Enable synthesis at point of call.
+	* lex.c (cons_up_default_function): Ditto.
+
+	* parse.y: Turn -ansi checks back into -pedantic checks.
+
+	* init.c (build_new): Fix -fcheck-new for array new.
+
+Sat Mar  4 15:55:42 1995  Fergus Henderson  <fjh@cs.mu.oz.au>
+
+	* typeck.c (build_compound_expr): warn if left-hand operand of
+	comma expression has no side-effects.
+
+Fri Mar  3 15:16:45 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* parse.y (primary): Change 'object qualified_id *' rules to 'object
+	overqualified_id *'.
+
+Fri Mar  3 12:48:17 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* parse.y (unary_expr): Catch doing sizeof an overloaded function.
+	Make the error look the same as the one we issue in c_sizeof.
+
+	* typeck.c (build_binary_op_nodefault): Give an error for trying
+	to compare a pointer-to-member to `void *'.
+
+Fri Mar  3 11:28:50 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* typeck.c (build_unary_op): Handle bool increment with smoke and
+	mirrors here, rather than in expand_increment where it belongs,
+	because Kenner doesn't agree with me.
+
+Fri Mar  3 00:08:10 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* decl.c (grokparms): Catch a PARM_DECL being used for a default
+	argument as well.
+
+Thu Mar  2 20:05:54 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* init.c (build_new): Don't allow new on a function type.
+
+	* parse.y (primary): Avoid a crash when seeing if the arg is of
+	the same type as that given for the typespec in an explicit dtor call.
+
+Thu Mar  2 00:49:38 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* decl.c (finish_function): Change test for calling
+	mark_inline_for_output.
+
+Wed Mar  1 11:23:46 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* typeck.c (build_modify_expr): Complain if
+	build_default_binary_type_conversion fails.
+
+	* init.c (expand_default_init): Handle arguments of unknown type
+	properly.
+
+	* cvt.c (build_expr_type_conversion): Only complain about ambiguity
+	if 'complain'.
+	* various: Pass 'complain'.
+
+	* typeck.c (comptypes): Be more picky about comparing UPTs.
+
+Wed Mar  1 11:03:41 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* decl.c (grokdeclarator): If declarator is null, say that the
+	type used has an incomplete type.
+
+Wed Mar  1 10:06:20 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* pt.c (instantiate_template): Copy the template arguments to the
+	permanent_obstack.  Also use simple_cst_equal to compare them when
+	looking for a previous instantiation.
+
+	* tree.c (make_deep_copy): Support copying INTEGER_TYPEs (assuming
+	they are array domain types).
+
+Tue Feb 28 23:24:55 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* cp-tree.h: Define WANT_* constants for passing to
+	build_expr_type_conversion.
+	* cvt.c (build_expr_type_conversion): New function to build
+	conversion to one of a group of suitable types.
+	(build_default_binary_type_conversion): Use it.
+	* decl2.c (grok_array_decl): Ditto.
+	* typeck.c (build_unary_op): Ditto.
+	(build_array_ref): Tidy up a bit.
+	(build_binary_op): Ditto.
+
+Tue Feb 28 19:57:31 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* decl.c (grokdeclarator): Don't allow decl of an argument as `void'.
+
+Tue Feb 28 17:23:36 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* parse.y (typed_declspecs1): Add 'typespec reserved_typespecquals
+	reserved_declspecs' rule.
+
+	* parse.y (expr_or_declarator): Remove notype_qualified_id rule.
+	(direct_notype_declarator): Ditto.
+	(complex_direct_notype_declarator): Add notype_qualified_id rule.
+
+	* lex.c (real_yylex): Handle :> digraph properly.
+
+Tue Feb 28 12:26:29 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* decl.c (grokdeclarator): Check if it's a friend, not if it's
+	non-virtual, that's being initialized.  Move the check up to
+	before FRIENDP would get cleared.  Catch an unnamed var/field
+	being declared void.  Say just `field' instead of `structure field'
+	in the error message.  Only go for the operator name if DECLARATOR
+	is non-null.
+
+Tue Feb 28 00:08:01 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* decl.c (start_function): Complain about abstract return type.
+	(grokdeclarator): Complain about declaring constructors and
+	destructors to be const or volatile.  Complain about declaring
+	destructors to be static.
+
+	* pt.c (uses_template_parms): Handle pmfs.
+
+	* decl.c (grokdeclarator): Don't call variable_size for array bounds
+	that only depend on template constant parameters.
+
+Mon Feb 27 15:38:16 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* error.c (dump_decl): Only look to see if it's a vtable if we
+	actually have a name to check out.
+
+Mon Feb 27 13:37:53 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* cvt.c (convert_to_aggr): Lose misleading shortcut.
+
+Sun Feb 26 17:27:32 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* decl.c (set_nested_typename): Always set DECL_IGNORED_P,
+	not just for dwarf.
+
+Sun Feb 26 00:10:18 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* decl.c (grokdeclarator): Don't allow a static member to be
+	declared `register'.
+
+	* init.c (make_friend_class): Move up to a pedwarn for the warning
+	about a class declaring friends with itself.
+
+	* decl.c (grokdeclarator): You can't do `volatile friend class foo'
+	or `inline friend class foo'.  Only try to make a friend out of
+	TYPE if we didn't already reset it to integer_type_node.
+
+Sat Feb 25 22:32:03 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* decl.c (grokdeclarator): Don't allow initialization of a
+	non-virtual function.
+
+	* decl.c (start_function): Do a pedwarn if we're changing `main'
+	to have an int return type.
+
+Sat Feb 25 00:02:05 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* typeck.c (build_modify_expr): Handle simple assignment from
+	TARGET_EXPRs by building up an RTL_EXPR to force expansion.  Whew.
+
+Fri Feb 24 18:27:14 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* decl.c (grokdeclarator): Also don't allow virtual outside of a
+	class decl for a scope method definition performed at global binding.
+
+	* init.c (build_offset_ref): Don't allow creation of an OFFSET_REF
+	of a bitfield.
+
+	* decl.c (grokdeclarator): Don't allow a const to be declared mutable.
+
+	* typeck.c (build_binary_op): Return an error_mark_node if either
+	one of the args turned into an error_mark_node when we tried to
+	use default_conversion.
+
+	* typeck.c (build_unary_op): Forbid using postfix -- on a bool.
+
+	* decl.c (grokdeclarator): Allow `signed' and `unsigned' to be
+	used on `__wchar_t'.
+
+Fri Feb 24 13:59:53 1995  Mike Stump  <mrs@cygnus.com>
+
+	* except.c (end_protect_partials): Do it the right way.
+
+Wed Feb 22 15:42:56 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* typeck.c (build_binary_op_nodefault): Upgrade warning about
+	comparing distinct pointer types to pedwarn.
+
+	* typeck2.c (digest_init): Cope with extra braces.
+
+	* typeck.c (build_binary_op_nodefault): Use tree_int_cst_sgn instead
+	of INT_CST_LT (..., interger_zero_node).
+
+Wed Feb 22 14:45:52 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* except.c [!TRY_NEW_EH] (end_protect_partials): Define dummy
+	function for systems that don't have EH.
+
+Tue Feb 21 19:18:31 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* call.c (can_convert_arg): Like can_convert, but takes an arg as
+	well.
+
+	* pt.c (type_unification): Allow implicit conversions for parameters
+	that do not depend on template parameters.
+
 Tue Feb 21 18:43:48 1995  Douglas Rupp  (drupp@cs.washington.edu)
 
 	* Make-lang.in, config-lang.in: ($exeext): New macro.
@@ -19,17 +324,46 @@ Tue Feb 21 18:43:48 1995  Douglas Rupp  (drupp@cs.washington.edu)
 	* cp/g++.c: Added #ifdefs for sys/file.h and process.h for NT.
 	Modified spawnvp to have to correct number of arguments for OS/2, NT.
 
-Thu Feb  2 15:07:58 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+Tue Feb 21 18:36:55 1995  Mike Stump  <mrs@cygnus.com>
+
+	* decl.c (finish_function): Add calls to end_protect_partials to end
+	the exception region that protects constructors so that partially
+	constructed objects can be partially destructed when the constructor
+	throws an exception.
+	* init.c (perform_member_init, sort_member_init, emit_base_init):
+	Added support for partially constructed objects.
+	* init.c (build_partial_cleanup_for): New routine to do partial
+	cleanups of a base class.
+	* decl2.c (finish_file): Move the emitting of the exception table
+	down, after we emit all code that might have exception regions in
+	them.
+	* except.c (end_protect_partials, might_have_exceptions_p): New
+	routines.
+	(emit_exception_table): Always output table if called.
+	* cp-tree.h (protect_list, end_protect_partials,
+	might_have_exceptions_p, emit_exception_table): Added.
+
+Tue Feb 21 16:05:59 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* gc.c (build_typeid): Pass a NULL_TREE, not the bogus, unused
+	address of a local variable.
+	* class.c (build_vfn_ref): Only try to build the PLUS_EXPR if we
+	were given a non-null PTR_TO_INSTPTR.
+
+Tue Feb 21 01:53:18 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* decl.c (duplicate_decls): Always lay out the merged decl.
+
+	* decl2.c (finish_vtable_vardecl): Don't do vtable hack on templates.
+	(finish_prevtable_vardecl): Ditto.
 
-        * class.c (build_vbase_path): Bash types to make the backend happy.
-        * cvt.c (build_up_reference): Bash the types bashed by
-        build_vbase_path to be reference types instead of pointer types.
-        (convert_to_reference): Ditto.
+	* method.c (synthesize_method): Set interface_{unknown,only}
+	according to the settings for our class, not the file where it comes
+	from.
 
-Wed Jan 25 15:02:09 1995  David S. Miller  (davem@nadzieja.rutgers.edu)
+Sat Feb 18 12:26:48 1995  Mike Stump  <mrs@cygnus.com>
 
-	* class.c (instantiate_type): Change error message text.
-	* typeck2.c (store_init_value): Likewise.
+	* except.c: Handle systems that define __i386__ but not __i386.
 
 Fri Feb 17 15:31:31 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
 
@@ -518,6 +852,11 @@ Tue Jan 24 16:36:31 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
 	* typeck2.c (build_functional_cast): Don't assume that a NOP_EXPR
 	will suffice to convert from integer_zero_node.
 
+Wed Jan 25 15:02:09 1995  David S. Miller  (davem@nadzieja.rutgers.edu)
+
+	* class.c (instantiate_type): Change error message text.
+	* typeck2.c (store_init_value): Likewise.
+
 Mon Jan 23 21:57:14 1995  Mike Stump  <mrs@cygnus.com>
 
 	* pt.c (tsubst): When we copy a node, don't forget to copy
@@ -4034,11 +4373,6 @@ Fri Apr 22 03:27:26 1994  Doug Evans  (dje@cygnus.com)
 	* Language directory reorganization.
 	See parent makefile.
 
-Fri Apr 22 03:27:26 1994  Doug Evans  (dje@cygnus.com)
-
-	* Language directory reorganization.
-	See parent makefile.
-
 Thu Apr 21 18:27:57 1994  Per Bothner  (bothner@kalessin.cygnus.com)
 
 	* cp-tree.h (THUNK_DELTA):  It is normally negative, so

gcc/cp/Makefile.in

@@ -194,14 +194,15 @@ parse.o : $(PARSE_C) $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h lex.h
 	$(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $(BIG_SWITCHFLAG) \
   `echo $(PARSE_C) | sed 's,^\./,,'`
 
+CONFLICTS = expect 5 shift/reduce confict and 38 reduce/reduce conflicts.
 $(PARSE_H) : $(PARSE_C)
 $(PARSE_C) : $(srcdir)/parse.y
-	@echo expect 5 shift/reduce confict and 39 reduce/reduce conflicts.
+	@echo $(CONFLICTS)
 	cd $(srcdir); $(BISON) $(BISONFLAGS) -d -o parse.c parse.y
 	cd $(srcdir); grep '^#define[ 	]*YYEMPTY' parse.c >>parse.h
 #$(PARSE_C) $(PARSE_H) : stamp-parse ; @true
 #stamp-parse: $(srcdir)/parse.y
-#	@echo expect 1 shift/reduce confict and 39 reduce/reduce conflicts.
+#	@echo $(CONFLICTS)
 #	$(BISON) $(BISONFLAGS) -d $(srcdir)/parse.y
 #	grep '^#define[ 	]*YYEMPTY' y.tab.c >>y.tab.h
 #	$(srcdir)/../move-if-change y.tab.c $(PARSE_C)

gcc/cp/call.c

@@ -593,6 +593,15 @@ can_convert (to, from)
   return h.code < USER_CODE;
 }
 
+int
+can_convert_arg (to, from, arg)
+     tree to, from, arg;
+{
+  struct harshness_code h;
+  h = convert_harshness (to, from, arg);
+  return h.code < USER_CODE;
+}
+
 #ifdef DEBUG_MATCHING
 static char *
 print_harshness (h)
@@ -2371,9 +2380,12 @@ build_method_call (instance, name, parms, basetype_path, flags)
   assemble_external (function);
 
 #if 0
+  /* Is it a synthesized method that needs to be synthesized?  */
   if (DECL_ARTIFICIAL (function) && ! flag_no_inline
       && DECL_SAVED_INSNS (function) == 0
-      && ! TREE_ASM_WRITTEN (function))
+      && ! TREE_ASM_WRITTEN (function)
+      /* Kludge: don't synthesize for default args.  */
+      && current_function_decl)
     synthesize_method (function);
 #endif
 

gcc/cp/class.c

@@ -240,7 +240,7 @@ build_vbase_path (code, type, expr, path, alias_this)
 		    {
 		      null_expr = build1 (NOP_EXPR, TYPE_POINTER_TO (last_virtual), integer_zero_node);
 		      expr = build (COND_EXPR, TYPE_POINTER_TO (last_virtual),
-				    build (EQ_EXPR, integer_type_node, expr,
+				    build (EQ_EXPR, boolean_type_node, expr,
 					   integer_zero_node),
 				    null_expr, nonnull_expr);
 		    }
@@ -323,7 +323,7 @@ build_vbase_path (code, type, expr, path, alias_this)
 	    expr = save_expr (expr);
 
 	  return build (COND_EXPR, type,
-			build (EQ_EXPR, integer_type_node, expr, integer_zero_node),
+			build (EQ_EXPR, boolean_type_node, expr, integer_zero_node),
 			null_expr,
 			build (code, type, expr, offset));
 	}
@@ -490,11 +490,12 @@ build_vfn_ref (ptr_to_instptr, instance, idx)
     return aref;
   else
     {
-      *ptr_to_instptr
-	= build (PLUS_EXPR, TREE_TYPE (*ptr_to_instptr),
-		 *ptr_to_instptr,
-		 convert (ptrdiff_type_node,
-			  build_component_ref (aref, delta_identifier, 0, 0)));
+      if (ptr_to_instptr)
+	*ptr_to_instptr
+	  = build (PLUS_EXPR, TREE_TYPE (*ptr_to_instptr),
+		   *ptr_to_instptr,
+		   convert (ptrdiff_type_node,
+			    build_component_ref (aref, delta_identifier, 0, 0)));
       return build_component_ref (aref, pfn_identifier, 0, 0);
     }
 }
@@ -2020,6 +2021,7 @@ duplicate_tag_error (t)
      tree t;
 {
   cp_error ("redefinition of `%#T'", t);
+  cp_error_at ("previous definition here", t);
 
   /* Pretend we haven't defined this type.  */
 

gcc/cp/cp-tree.h

@@ -1836,6 +1836,17 @@ extern tree current_class_type;	/* _TYPE: the type of the current class */
 #define CONV_C_CAST      (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \
 			  | CONV_REINTERPRET | CONV_PRIVATE | CONV_FORCE_TEMP)
 
+/* Used by build_expr_type_conversion to indicate which types are
+   acceptable as arguments to the expression under consideration.  */
+
+#define WANT_INT	1 /* integer types, including bool */
+#define WANT_FLOAT	2 /* floating point types */
+#define WANT_ENUM	4 /* enumerated types */
+#define WANT_POINTER	8 /* pointer types */
+#define WANT_NULL      16 /* null pointer constant */
+
+#define WANT_ARITH	(WANT_INT | WANT_FLOAT)
+
 /* Anatomy of a DECL_FRIENDLIST (which is a TREE_LIST):
    purpose = friend name (IDENTIFIER_NODE);
    value = TREE_LIST of FUNCTION_DECLS;
@@ -1913,8 +1924,8 @@ extern tree convert				PROTO((tree, tree));
 extern tree cp_convert				PROTO((tree, tree, int, int));
 extern tree convert_force			PROTO((tree, tree, int));
 extern tree build_type_conversion		PROTO((enum tree_code, tree, tree, int));
+extern tree build_expr_type_conversion		PROTO((int, tree, int));
 extern int build_default_binary_type_conversion	PROTO((enum tree_code, tree *, tree *));
-extern int build_default_unary_type_conversion	PROTO((enum tree_code, tree *));
 extern tree type_promotes_to			PROTO((tree));
 
 /* decl.c */
@@ -2042,9 +2053,10 @@ extern tree get_namespace_id			PROTO((void));
 /* in edsel.c */
 
 /* in except.c */
-
+extern tree protect_list;
 extern void start_protect			PROTO((void));
 extern void end_protect				PROTO((tree));
+extern void end_protect_partials		();
 extern void expand_exception_blocks		PROTO((void));
 extern void expand_start_try_stmts		PROTO((void));
 extern void expand_end_try_stmts		PROTO((void));
@@ -2053,7 +2065,8 @@ extern void expand_end_all_catch		PROTO((void));
 extern void start_catch_block			PROTO((tree, tree));
 extern void end_catch_block			PROTO((void));
 extern void expand_throw			PROTO((tree));
-extern int build_exception_table		PROTO((void));
+extern int might_have_exceptions_p		PROTO((void));
+extern void emit_exception_table		PROTO((void));
 extern tree build_throw				PROTO((tree));
 extern void init_exception_processing		PROTO((void));
 
@@ -2093,7 +2106,7 @@ extern tree get_type_value			PROTO((tree));
 extern tree build_member_call			PROTO((tree, tree, tree));
 extern tree build_offset_ref			PROTO((tree, tree));
 extern tree get_member_function			PROTO((tree *, tree, tree));
-extern tree get_member_function_from_ptrfunc	PROTO((tree *, tree, tree));
+extern tree get_member_function_from_ptrfunc	PROTO((tree *, tree));
 extern tree resolve_offset_ref			PROTO((tree));
 extern tree decl_constant_value			PROTO((tree));
 extern int is_friend_type			PROTO((tree, tree));

gcc/cp/cvt.c

@@ -903,6 +903,7 @@ convert_to_aggr (type, expr, msgp, protect)
   parmlist = tree_cons (NULL_TREE, integer_zero_node, parmlist);
   parmtypes = tree_cons (NULL_TREE, TYPE_POINTER_TO (basetype), parmtypes);
 
+#if 0
   method_name = build_decl_overload (name, parmtypes, 1);
 
   /* constructors are up front.  */
@@ -936,6 +937,7 @@ convert_to_aggr (type, expr, msgp, protect)
 	}
       fndecl = DECL_CHAIN (fndecl);
     }
+#endif
 
   /* No exact conversion was found.  See if an approximate
      one will do.  */
@@ -1548,7 +1550,7 @@ build_type_conversion (code, xtype, expr, for_sure)
 	    {
 	      cp_error ("ambiguous conversion from `%T' to `%T'", basetype,
 			xtype);
-	      cp_error ("  candidate conversion functions include `%T' and `%T'",
+	      cp_error ("  candidate conversions include `%T' and `%T'",
 			TREE_VALUE (winner), TREE_VALUE (conv));
 	      return NULL_TREE;
 	    }
@@ -1564,154 +1566,228 @@ build_type_conversion (code, xtype, expr, for_sure)
   return NULL_TREE;
 }
 
-/* Must convert two aggregate types to non-aggregate type.
-   Attempts to find a non-ambiguous, "best" type conversion.
-
-   Return 1 on success, 0 on failure.
+/* Convert the given EXPR to one of a group of types suitable for use in an
+   expression.  DESIRES is a combination of various WANT_* flags (q.v.)
+   which indicates which types are suitable.  If COMPLAIN is 1, complain
+   about ambiguity; otherwise, the caller will deal with it.  */
 
-   @@ What are the real semantics of this supposed to be??? */
-int
-build_default_binary_type_conversion (code, arg1, arg2)
-     enum tree_code code;
-     tree *arg1, *arg2;
+tree
+build_expr_type_conversion (desires, expr, complain)
+     int desires;
+     tree expr;
+     int complain;
 {
-  tree type1 = TREE_TYPE (*arg1);
-  tree type2 = TREE_TYPE (*arg2);
-
-  if (TREE_CODE (type1) == REFERENCE_TYPE
-      || TREE_CODE (type1) == POINTER_TYPE)
-    type1 = TREE_TYPE (type1);
-  if (TREE_CODE (type2) == REFERENCE_TYPE
-      || TREE_CODE (type2) == POINTER_TYPE)
-    type2 = TREE_TYPE (type2);
+  tree basetype = TREE_TYPE (expr);
+  tree conv;
+  tree winner = NULL_TREE;
 
-  if (TREE_CODE (TYPE_NAME (type1)) != TYPE_DECL)
+  if (TREE_CODE (basetype) == OFFSET_TYPE)
     {
-      tree decl = typedecl_for_tag (type1);
-      if (decl)
-	error ("type conversion nonexistent for type `%s'",
-	       IDENTIFIER_POINTER (DECL_NAME (decl)));
-      else
-	error ("type conversion nonexistent for non-C++ type");
-      return 0;
-    }
-  if (TREE_CODE (TYPE_NAME (type2)) != TYPE_DECL)
-    {
-      tree decl = typedecl_for_tag (type2);
-      if (decl)
-	error ("type conversion nonexistent for type `%s'",
-	       IDENTIFIER_POINTER (decl));
-      else
-	error ("type conversion nonexistent for non-C++ type");
-      return 0;
+      expr = resolve_offset_ref (expr);
+      basetype = TREE_TYPE (expr);
     }
 
-  if (!IS_AGGR_TYPE (type1) || !TYPE_HAS_CONVERSION (type1))
-    {
-      if (!IS_AGGR_TYPE (type2) || !TYPE_HAS_CONVERSION (type2))
-	cp_error ("no conversion from `%T' and `%T' to types with default `%O' ",
-		  type1, type2, code);
-      else
-	cp_error ("no conversion from `%T' to type with default `%O'",
-		  type1, code);
-      return 0;
-    }
-  else if (!IS_AGGR_TYPE (type2) || !TYPE_HAS_CONVERSION (type2))
-    {
-      cp_error ("no conversion from `%T' to type with default `%O'",
-		type2, code);
-      return 0;
-    }
+  if (! IS_AGGR_TYPE (basetype))
+    switch (TREE_CODE (basetype))
+      {
+      case INTEGER_TYPE:
+	if ((desires & WANT_NULL) && TREE_CODE (expr) == INTEGER_CST
+	    && integer_zerop (expr))
+	  return expr;
+	/* else fall through... */
+
+      case BOOLEAN_TYPE:
+	return (desires & WANT_INT) ? expr : NULL_TREE;
+      case ENUMERAL_TYPE:
+	return (desires & WANT_ENUM) ? expr : NULL_TREE;
+      case REAL_TYPE:
+	return (desires & WANT_FLOAT) ? expr : NULL_TREE;
+      case POINTER_TYPE:
+	return (desires & WANT_POINTER) ? expr : NULL_TREE;
+	
+      case FUNCTION_TYPE:
+      case ARRAY_TYPE:
+	return (desires & WANT_POINTER) ? default_conversion (expr)
+     	                                : NULL_TREE;
+      default:
+	return NULL_TREE;
+      }
 
-  if (code == TRUTH_ANDIF_EXPR
-      || code == TRUTH_ORIF_EXPR)
-    {
-      *arg1 = convert (boolean_type_node, *arg1);
-      *arg2 = convert (boolean_type_node, *arg2);
-    }
-  else if (TYPE_HAS_INT_CONVERSION (type1))
-    {
-      if (TYPE_HAS_REAL_CONVERSION (type1))
-	cp_pedwarn ("ambiguous type conversion for type `%T', defaulting to int",
-		    type1);
-      *arg1 = build_type_conversion (code, integer_type_node, *arg1, 1);
-      *arg2 = build_type_conversion (code, integer_type_node, *arg2, 1);
-    }
-  else if (TYPE_HAS_REAL_CONVERSION (type1))
-    {
-      *arg1 = build_type_conversion (code, double_type_node, *arg1, 1);
-      *arg2 = build_type_conversion (code, double_type_node, *arg2, 1);
-    }
-  else
-    {
-      *arg1 = build_type_conversion (code, ptr_type_node, *arg1, 1);
-      if (*arg1 == error_mark_node)
-	error ("ambiguous pointer conversion");
-      *arg2 = build_type_conversion (code, ptr_type_node, *arg2, 1);
-      if (*arg1 != error_mark_node && *arg2 == error_mark_node)
-	error ("ambiguous pointer conversion");
-    }
-  if (*arg1 == 0)
-    {
-      if (*arg2 == 0 && type1 != type2)
-	cp_error ("default type conversion for types `%T' and `%T' failed",
-		  type1, type2);
-      else
-	cp_error ("default type conversion for type `%T' failed", type1);
-      return 0;
-    }
-  else if (*arg2 == 0)
+  if (! TYPE_HAS_CONVERSION (basetype))
+    return NULL_TREE;
+
+  for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
     {
-      cp_error ("default type conversion for type `%T' failed", type2);
-      return 0;
+      int win = 0;
+
+      if (winner && TREE_PURPOSE (winner) == TREE_PURPOSE (conv))
+	continue;
+
+      switch (TREE_CODE (TREE_VALUE (conv)))
+	{
+	case BOOLEAN_TYPE:
+	case INTEGER_TYPE:
+	  win = (desires & WANT_INT); break;
+	case ENUMERAL_TYPE:
+	  win = (desires & WANT_ENUM); break;
+	case REAL_TYPE:
+	  win = (desires & WANT_FLOAT); break;
+	case POINTER_TYPE:
+	  win = (desires & WANT_POINTER); break;
+	}
+
+      if (win)
+	{
+	  if (winner)
+	    {
+	      if (complain)
+		{
+		  cp_error ("ambiguous default type conversion from `%T'",
+			    basetype);
+		  cp_error ("  candidate conversions include `%T' and `%T'",
+			    TREE_VALUE (winner), TREE_VALUE (conv));
+		}
+	      return error_mark_node;
+	    }
+	  else
+	    winner = conv;
+	}
     }
-  return 1;
+
+  if (winner)
+    return build_type_conversion_1 (TREE_VALUE (winner), basetype, expr,
+				    TREE_PURPOSE (winner), 1);
+
+  return NULL_TREE;
 }
 
-/* Must convert an aggregate type to non-aggregate type.
+/* Must convert two aggregate types to non-aggregate type.
    Attempts to find a non-ambiguous, "best" type conversion.
 
    Return 1 on success, 0 on failure.
 
-   The type of the argument is expected to be of aggregate type here.
-
    @@ What are the real semantics of this supposed to be??? */
 int
-build_default_unary_type_conversion (code, arg)
+build_default_binary_type_conversion (code, arg1, arg2)
      enum tree_code code;
-     tree *arg;
+     tree *arg1, *arg2;
 {
-  tree type = TREE_TYPE (*arg);
-
-  if (! TYPE_HAS_CONVERSION (type))
+  switch (code)
     {
-      cp_error ("type conversion required for type `%T'", type);
-      return 0;
-    }
+    case MULT_EXPR:
+    case TRUNC_DIV_EXPR:
+    case CEIL_DIV_EXPR:
+    case FLOOR_DIV_EXPR:
+    case ROUND_DIV_EXPR:
+    case EXACT_DIV_EXPR:
+      *arg1 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg1, 0);
+      *arg2 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg2, 0);
+      break;
 
-  if (code == TRUTH_NOT_EXPR)
-    *arg = convert (boolean_type_node, *arg);
-  else if (TYPE_HAS_INT_CONVERSION (type))
-    {
-      if (TYPE_HAS_REAL_CONVERSION (type))
-	cp_pedwarn ("ambiguous type conversion for type `%T', defaulting to int",
-		    type);
-      *arg = build_type_conversion (code, integer_type_node, *arg, 1);
-    }
-  else if (TYPE_HAS_REAL_CONVERSION (type))
-    *arg = build_type_conversion (code, double_type_node, *arg, 1);
-  else
-    {
-      *arg = build_type_conversion (code, ptr_type_node, *arg, 1);
-      if (*arg == error_mark_node)
-	error ("ambiguous pointer conversion");
-    }
-  if (*arg == NULL_TREE)
-    {
-      cp_error ("default type conversion for type `%T' failed", type);
-      return 0;
+    case TRUNC_MOD_EXPR:
+    case FLOOR_MOD_EXPR:
+    case LSHIFT_EXPR:
+    case RSHIFT_EXPR:
+    case BIT_AND_EXPR:
+    case BIT_XOR_EXPR:
+    case BIT_IOR_EXPR:
+      *arg1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, *arg1, 0);
+      *arg2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, *arg2, 0);
+      break;
+
+    case PLUS_EXPR:
+      {
+	tree a1, a2, p1, p2;
+	int wins;
+
+	a1 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg1, 0);
+	a2 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg2, 0);
+	p1 = build_expr_type_conversion (WANT_POINTER, *arg1, 0);
+	p2 = build_expr_type_conversion (WANT_POINTER, *arg2, 0);
+
+	wins = (a1 && a2) + (a1 && p2) + (p1 && a2);
+
+	if (wins > 1)
+	  error ("ambiguous default type conversion for `operator +'");
+
+	if (a1 && a2)
+	  *arg1 = a1, *arg2 = a2;
+	else if (a1 && p2)
+	  *arg1 = a1, *arg2 = p2;
+	else
+	  *arg1 = p1, *arg2 = a2;
+	break;
+      }
+
+    case MINUS_EXPR:
+      {
+	tree a1, a2, p1, p2;
+	int wins;
+
+	a1 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg1, 0);
+	a2 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg2, 0);
+	p1 = build_expr_type_conversion (WANT_POINTER, *arg1, 0);
+	p2 = build_expr_type_conversion (WANT_POINTER, *arg2, 0);
+
+	wins = (a1 && a2) + (p1 && p2) + (p1 && a2);
+
+	if (wins > 1)
+	  error ("ambiguous default type conversion for `operator -'");
+
+	if (a1 && a2)
+	  *arg1 = a1, *arg2 = a2;
+	else if (p1 && p2)
+	  *arg1 = p1, *arg2 = p2;
+	else
+	  *arg1 = p1, *arg2 = a2;
+	break;
+      }
+
+    case GT_EXPR:
+    case LT_EXPR:
+    case GE_EXPR:
+    case LE_EXPR:
+    case EQ_EXPR:
+    case NE_EXPR:
+      {
+	tree a1, a2, p1, p2;
+	int wins;
+
+	a1 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg1, 0);
+	a2 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg2, 0);
+	p1 = build_expr_type_conversion (WANT_POINTER | WANT_NULL, *arg1, 0);
+	p2 = build_expr_type_conversion (WANT_POINTER | WANT_NULL, *arg2, 0);
+
+	wins = (a1 && a2) + (p1 && p2);
+
+	if (wins > 1)
+	  cp_error ("ambiguous default type conversion for `%O'", code);
+
+	if (a1 && a2)
+	  *arg1 = a1, *arg2 = a2;
+	else
+	  *arg1 = p1, *arg2 = p2;
+	break;
+      }
+
+    case TRUTH_ANDIF_EXPR:
+    case TRUTH_ORIF_EXPR:
+      *arg1 = convert (boolean_type_node, *arg1);
+      *arg2 = convert (boolean_type_node, *arg2);
+      break;
+
+    default:
+      *arg1 = NULL_TREE;
+      *arg2 = NULL_TREE;
     }
-  return 1;
+
+  if (*arg1 == error_mark_node || *arg2 == error_mark_node)
+    cp_error ("ambiguous default type conversion for `%O'", code);
+
+  if (*arg1 && *arg2)
+    return 1;
+
+  return 0;
 }
 
 /* Implements integral promotion (4.1) and float->double promotion. */

gcc/cp/decl.c

@@ -1664,13 +1664,10 @@ set_nested_typename (decl, classname, name, type)
     type_decl = build_decl (TYPE_DECL, nested, type);
     DECL_NESTED_TYPENAME (type_decl) = nested;
     SET_DECL_ARTIFICIAL (type_decl);
-#ifdef DWARF_DEBUGGING_INFO
-    /* Mark the TYPE_DECL node created just above as a
-       gratuitous one so that dwarfout.c will know not to
-       generate a TAG_typedef DIE for it.  */
-    if (write_symbols == DWARF_DEBUG)
-      DECL_IGNORED_P (type_decl) = 1;
-#endif /* DWARF_DEBUGGING_INFO */
+    /* Mark the TYPE_DECL node created just above as a gratuitous one so that
+       dwarfout.c will know not to generate a TAG_typedef DIE for it, and
+       sdbout.c won't try to output a .def for "::foo".  */
+    DECL_IGNORED_P (type_decl) = 1;
 
     /* Remove this when local classes are fixed.  */
     SET_IDENTIFIER_TYPE_VALUE (nested, type);
@@ -2447,21 +2444,16 @@ duplicate_decls (newdecl, olddecl)
       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
 
       /* Lay the type out, unless already done.  */
-      if (oldtype != TREE_TYPE (newdecl))
-	{
-	  if (TREE_TYPE (newdecl) != error_mark_node)
-	    layout_type (TREE_TYPE (newdecl));
-	  if (TREE_CODE (newdecl) != FUNCTION_DECL
-	      && TREE_CODE (newdecl) != TYPE_DECL
-	      && TREE_CODE (newdecl) != CONST_DECL
-	      && TREE_CODE (newdecl) != TEMPLATE_DECL)
-	    layout_decl (newdecl, 0);
-	}
-      else
-	{
-	  /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
-	  DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
-	}
+      if (oldtype != TREE_TYPE (newdecl)
+	  && TREE_TYPE (newdecl) != error_mark_node)
+	layout_type (TREE_TYPE (newdecl));
+
+      if (TREE_CODE (newdecl) == VAR_DECL
+	  || TREE_CODE (newdecl) == PARM_DECL
+	  || TREE_CODE (newdecl) == RESULT_DECL
+	  || TREE_CODE (newdecl) == FIELD_DECL
+	  || TREE_CODE (newdecl) == TYPE_DECL)
+	layout_decl (newdecl, 0);
 
       /* Merge the type qualifiers.  */
       if (TREE_READONLY (newdecl))
@@ -7660,7 +7652,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 
       if (TREE_CODE (type) == REAL_TYPE)
 	error ("short, signed or unsigned invalid for `%s'", name);
-      else if (TREE_CODE (type) != INTEGER_TYPE || type == wchar_type_node)
+      else if (TREE_CODE (type) != INTEGER_TYPE)
 	error ("long, short, signed or unsigned invalid for `%s'", name);
       else if (RIDBIT_SETP (RID_LONG, specbits)
 	       && RIDBIT_SETP (RID_SHORT, specbits))
@@ -7780,6 +7772,11 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 	  error ("non-object member `%s' cannot be declared `mutable'", name);
 	  RIDBIT_RESET (RID_MUTABLE, specbits);
 	}
+      else if (constp)
+	{
+	  error ("const `%s' cannot be declared `mutable'", name);
+	  RIDBIT_RESET (RID_MUTABLE, specbits);
+	}
       else if (staticp)
 	{
 	  error ("static `%s' cannot be declared `mutable'", name);
@@ -7820,7 +7817,8 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
     }
 
   /* Give error if `virtual' is used outside of class declaration.  */
-  if (virtualp && current_class_name == NULL_TREE)
+  if (virtualp
+      && (current_class_name == NULL_TREE || decl_context != FIELD))
     {
       error ("virtual outside class declaration");
       virtualp = 0;
@@ -7972,14 +7970,20 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 	{
 	  if (decl_context == FIELD)
 	    {
-	      tree tmp = TREE_OPERAND (declarator, 0);
-	      register int op = IDENTIFIER_OPNAME_P (tmp);
+	      tree tmp = NULL_TREE;
+	      register int op = 0;
+
+	      if (declarator)
+		{
+		  tmp = TREE_OPERAND (declarator, 0);
+		  op = IDENTIFIER_OPNAME_P (tmp);
+		}
 	      error ("storage class specified for %s `%s'",
 		     IS_SIGNATURE (current_class_type)
 		     ? (op
 			? "signature member operator"
 			: "signature member function")
-		     : (op ? "member operator" : "structure field"),
+		     : (op ? "member operator" : "field"),
 		     op ? operator_name_string (tmp) : name);
 	    }
 	  else
@@ -8092,6 +8096,8 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 	  {
 	    register tree itype = NULL_TREE;
 	    register tree size = TREE_OPERAND (declarator, 1);
+	    /* The index is a signed object `sizetype' bits wide.  */
+	    tree index_type = signed_type (sizetype);
 
 	    declarator = TREE_OPERAND (declarator, 0);
 
@@ -8181,8 +8187,6 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 			cp_error ("size of array `%D' is negative", dname);
 			size = integer_one_node;
 		      }
-		    itype = build_index_type (size_binop (MINUS_EXPR, size,
-							  integer_one_node));
 		  }
 		else
 		  {
@@ -8194,15 +8198,20 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 			else
 			  cp_pedwarn ("ANSI C++ forbids variable-size array");
 		      }
-		  dont_grok_size:
-		    itype =
-		      build_binary_op (MINUS_EXPR, size, integer_one_node, 1);
 		    /* Make sure the array size remains visibly nonconstant
-		       even if it is (eg) a const variable with known value.  */
+		       even if it is (eg) a const variable with known value. */
 		    size_varies = 1;
-		    itype = variable_size (itype);
-		    itype = build_index_type (itype);
 		  }
+
+	      dont_grok_size:
+		itype =
+		  fold (build_binary_op (MINUS_EXPR,
+					 convert (index_type, size),
+					 convert (index_type,
+						  integer_one_node), 1));
+		if (! TREE_CONSTANT (itype))
+		  itype = variable_size (itype);
+		itype = build_index_type (itype);
 		resume_momentary (yes);
 	      }
 
@@ -8262,10 +8271,14 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 	    if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
 	      inner_decl = TREE_OPERAND (inner_decl, 1);
 
+	    /* Pick up type qualifiers which should be applied to `this'.  */
+	    quals = TREE_OPERAND (declarator, 2);
+
 	    /* Say it's a definition only for the CALL_EXPR
 	       closest to the identifier.  */
 	    funcdecl_p =
-	      inner_decl && TREE_CODE (inner_decl) == IDENTIFIER_NODE;
+	      inner_decl && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
+			     || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
 
 	    if (ctype == NULL_TREE
 		&& decl_context == FIELD
@@ -8289,14 +8302,9 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 		       may not be static.  */
 		    if (staticp == 2)
 		      error ("destructor cannot be static member function");
-		    if (TYPE_READONLY (type))
-		      {
-			error ("destructors cannot be declared `const'");
-			return void_type_node;
-		      }
-		    if (TYPE_VOLATILE (type))
+		    if (quals)
 		      {
-			error ("destructors cannot be declared `volatile'");
+			error ("destructors cannot be declared `const' or `volatile'");
 			return void_type_node;
 		      }
 		    if (decl_context == FIELD)
@@ -8320,16 +8328,11 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 			pedwarn ("constructors cannot be declared virtual");
 			virtualp = 0;
 		      }
-		    if (TYPE_READONLY (type))
+		    if (quals)
 		      {
-			error ("constructors cannot be declared `const'");
+			error ("constructors cannot be declared `const' or `volatile'");
 			return void_type_node;
  		      }
-		    if (TYPE_VOLATILE (type))
-		      {
-			error ("constructors cannot be declared `volatile'");
-			return void_type_node;
-		      }
 		    {
 		      RID_BIT_TYPE tmp_bits;
 		      bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof(RID_BIT_TYPE));
@@ -8358,20 +8361,22 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 		if (decl_context == FIELD)
 		  staticp = 0;
 	      }
-	    else if (friendp && virtualp)
+	    else if (friendp)
 	      {
-		/* Cannot be both friend and virtual.  */
-		error ("virtual functions cannot be friends");
-		RIDBIT_RESET (RID_FRIEND, specbits);
-		friendp = 0;
+		if (initialized)
+		  error ("can't initialize friend function `%s'", name);
+		if (virtualp)
+		  {
+		    /* Cannot be both friend and virtual.  */
+		    error ("virtual functions cannot be friends");
+		    RIDBIT_RESET (RID_FRIEND, specbits);
+		    friendp = 0;
+		  }
 	      }
 
 	    if (decl_context == NORMAL && friendp)
 	      error ("friend declaration not in class definition");
 
-	    /* Pick up type qualifiers which should be applied to `this'.  */
-	    quals = TREE_OPERAND (declarator, 2);
-
 	    /* Traditionally, declaring return type float means double.  */
 
 	    if (flag_traditional
@@ -8836,13 +8841,28 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
       /* Special case: "friend class foo" looks like a TYPENAME context.  */
       if (friendp)
 	{
-	  /* A friendly class?  */
-	  if (current_class_type)
-	    make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
-	  else
-	    error("trying to make class `%s' a friend of global scope",
-		  TYPE_NAME_STRING (type));
-	  type = void_type_node;
+	  if (volatilep)
+	    {
+	      cp_error ("`volatile' specified for friend class declaration");
+	      volatilep = 0;
+	    }
+	  if (inlinep)
+	    {
+	      cp_error ("`inline' specified for friend class declaration");
+	      inlinep = 0;
+	    }
+
+	  /* Only try to do this stuff if we didn't already give up.  */
+	  if (type != integer_type_node)
+	    {
+	      /* A friendly class?  */
+	      if (current_class_type)
+		make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
+	      else
+		error ("trying to make class `%s' a friend of global scope",
+		       TYPE_NAME_STRING (type));
+	      type = void_type_node;
+	    }
 	}
       else if (quals)
 	{
@@ -8878,7 +8898,9 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 
   if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM)
     {
-      if (TREE_CODE (declarator) == IDENTIFIER_NODE)
+      if (! declarator)
+	error ("unnamed variable or field declared void");
+      else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
 	{
 	  if (IDENTIFIER_OPNAME_P (declarator))
 #if 0				/* How could this happen? */
@@ -8921,6 +8943,11 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 	  type = build_pointer_type (type);
 	else if (TREE_CODE (type) == OFFSET_TYPE)
 	  type = build_pointer_type (type);
+	else if (type == void_type_node && declarator)
+	  {
+	    error ("declaration of `%s' as void", name);
+	    return NULL_TREE;
+	  }
 
 	decl = build_decl (PARM_DECL, declarator, type);
 
@@ -9030,7 +9057,10 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 	else if (TYPE_SIZE (type) == NULL_TREE && !staticp
 		 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
 	  {
-	    cp_error ("field `%D' has incomplete type", declarator);
+	    if (declarator)
+	      cp_error ("field `%D' has incomplete type", declarator);
+	    else
+	      cp_error ("name `%T' has incomplete type", type);
 
 	    /* If we're instantiating a template, tell them which
 	       instantiation made the field's type be incomplete.  */
@@ -9302,6 +9332,11 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
 	        staticp = 0;
 		RIDBIT_RESET (RID_STATIC, specbits);
 	      }
+	    if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
+	      {
+		cp_error ("static member `%D' declared `register'", decl);
+		RIDBIT_RESET (RID_REGISTER, specbits);
+	      }
 	    if (RIDBIT_SETP (RID_EXTERN, specbits))
 	      {
 	        cp_error ("cannot explicitly declare member `%#D' to have extern linkage",
@@ -9583,7 +9618,8 @@ grokparms (first_parm, funcdef_flag)
 		      any_init++;
 		      if (TREE_CODE (init) == SAVE_EXPR)
 			PARM_DECL_EXPR (init) = 1;
-		      else if (TREE_CODE (init) == VAR_DECL)
+		      else if (TREE_CODE (init) == VAR_DECL
+			       || TREE_CODE (init) == PARM_DECL)
 			{
 			  if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init)))
 			    {
@@ -10656,6 +10692,8 @@ start_function (declspecs, declarator, raises, pre_parsed_p)
   original_result_rtx = NULL_RTX;
   current_function_obstack_index = 0;
   current_function_obstack_usage = 0;
+  base_init_insns = NULL_RTX;
+  protect_list = NULL_TREE;
 
   clear_temp_name ();
 
@@ -10751,7 +10789,7 @@ start_function (declspecs, declarator, raises, pre_parsed_p)
 	  if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
 	    {
 	      if (pedantic || warn_return_type)
-		warning ("return type for `main' changed to integer type");
+		pedwarn ("return type for `main' changed to integer type");
 	      TREE_TYPE (decl1) = fntype = default_function_type;
 	    }
 	  warn_about_return_type = 0;
@@ -10795,6 +10833,10 @@ start_function (declspecs, declarator, raises, pre_parsed_p)
       DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, TREE_TYPE (fntype));
     }
 
+  if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype))
+      && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype)))
+    abstract_virtuals_error (decl1, TREE_TYPE (fntype));
+
   if (warn_about_return_type)
     warning ("return-type defaults to `int'");
 
@@ -10824,14 +10866,19 @@ start_function (declspecs, declarator, raises, pre_parsed_p)
 	DECL_EXTERNAL (decl1) = current_extern_inline;
       DECL_INTERFACE_KNOWN (decl1) = 1;
     }
+  else if (current_extern_inline)
+    {
+      /* `extern inline' acts like a declaration except for
+	 defining how to inline.  So set DECL_EXTERNAL in that case.  */
+      DECL_EXTERNAL (decl1) = 1;
+      DECL_INTERFACE_KNOWN (decl1) = 1;
+    }
   else
     {
       /* This is a definition, not a reference.
-	 So normally clear DECL_EXTERNAL.
-	 However, `extern inline' acts like a declaration except for
-	 defining how to inline.  So set DECL_EXTERNAL in that case.  */
-      DECL_EXTERNAL (decl1) = current_extern_inline;
-
+	 So clear DECL_EXTERNAL.  */
+      DECL_EXTERNAL (decl1) = 0;
+      
       if (DECL_INLINE (decl1) && (DECL_FUNCTION_MEMBER_P (decl1)
 				  || DECL_TEMPLATE_INSTANTIATION (decl1)))
 	/* We know nothing yet */;
@@ -11423,6 +11470,7 @@ finish_function (lineno, call_poplevel, nested)
 
       if (DECL_CONSTRUCTOR_P (current_function_decl))
 	{
+	  end_protect_partials ();
 	  expand_label (ctor_label);
 	  ctor_label = NULL_TREE;
 
@@ -11503,6 +11551,8 @@ finish_function (lineno, call_poplevel, nested)
       if (mark != get_last_insn ())
 	reorder_insns (next_insn (mark), get_last_insn (), last_parm_insn);
 
+      end_protect_partials ();
+
       /* This is where the body of the constructor ends.  */
       expand_label (ctor_label);
       ctor_label = NULL_TREE;
@@ -11643,8 +11693,14 @@ finish_function (lineno, call_poplevel, nested)
   /* Run the optimizers and output the assembler code for this function.  */
   rest_of_compilation (fndecl);
 
-  if (DECL_DEFER_OUTPUT (fndecl))
-    mark_inline_for_output (fndecl);
+  if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
+    {
+      /* Set DECL_EXTERNAL so that assemble_external will be called as
+         necessary.  We'll clear it again in import_export_inline.  */
+      if (TREE_PUBLIC (fndecl))
+	DECL_EXTERNAL (fndecl) = 1;
+      mark_inline_for_output (fndecl);
+    }
 
   if (ctype && TREE_ASM_WRITTEN (fndecl))
     note_debug_info_needed (ctype);
@@ -12121,7 +12177,9 @@ struct cp_function
   tree shadowed_labels;
   tree ctor_label;
   tree dtor_label;
+  tree protect_list;
   rtx result_rtx;
+  rtx base_init_insns;
   struct cp_function *next;
   struct binding_level *binding_level;
 };
@@ -12156,6 +12214,8 @@ push_cp_function_context (toplev)
   p->just_assigned_this = current_function_just_assigned_this;
   p->parms_stored = current_function_parms_stored;
   p->result_rtx = original_result_rtx;
+  p->base_init_insns = base_init_insns;
+  p->protect_list = protect_list;
 }
 
 /* Restore the variables used during compilation of a C++ function.  */
@@ -12197,10 +12257,12 @@ pop_cp_function_context (toplev)
   current_binding_level = p->binding_level;
   ctor_label = p->ctor_label;
   dtor_label = p->dtor_label;
+  protect_list = p->protect_list;
   current_function_assigns_this = p->assigns_this;
   current_function_just_assigned_this = p->just_assigned_this;
   current_function_parms_stored = p->parms_stored;
   original_result_rtx = p->result_rtx;
+  base_init_insns = p->base_init_insns;
 
   free (p);
 }

gcc/cp/decl2.c

@@ -1027,6 +1027,7 @@ grok_array_decl (array_expr, index_exp)
      tree array_expr, index_exp;
 {
   tree type = TREE_TYPE (array_expr);
+  tree p1, p2, i1, i2;
 
   if (type == error_mark_node || index_exp == error_mark_node)
     return error_mark_node;
@@ -1049,28 +1050,38 @@ grok_array_decl (array_expr, index_exp)
 			   array_expr, index_exp, NULL_TREE);
 
   /* Otherwise, create an ARRAY_REF for a pointer or array type.  */
-  if (TREE_CODE (type) == POINTER_TYPE
-      || TREE_CODE (type) == ARRAY_TYPE)
-    return build_array_ref (array_expr, index_exp);
 
-  /* Woops, looks like they did something like `5[a]' instead of `a[5]'.
-     We don't emit a warning or error for this, since it's allowed
-     by ARM $8.2.4.  */
+  if (TREE_CODE (type) == ARRAY_TYPE)
+    p1 = array_expr;
+  else
+    p1 = build_expr_type_conversion (WANT_POINTER, array_expr, 0);
 
-  type = TREE_TYPE (index_exp);
+  if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
+    p2 = index_exp;
+  else
+    p2 = build_expr_type_conversion (WANT_POINTER, index_exp, 0);
 
-  if (TREE_CODE (type) == OFFSET_TYPE
-      || TREE_CODE (type) == REFERENCE_TYPE)
-    type = TREE_TYPE (type);
+  i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr, 0);
+  i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp, 0);
 
-  if (TREE_CODE (type) == POINTER_TYPE
-      || TREE_CODE (type) == ARRAY_TYPE)
-    return build_array_ref (index_exp, array_expr);
+  if ((p1 && i2) && (i1 && p2))
+    error ("ambiguous conversion for array subscript");
 
-  /* The expression E1[E2] is identical (by definition) to *((E1)+(E2)).  */
-  return build_indirect_ref (build_binary_op (PLUS_EXPR, array_expr,
-					      index_exp, 1),
-			     "array indexing");
+  if (p1 && i2)
+    array_expr = p1, index_exp = i2;
+  else if (i1 && p2)
+    array_expr = p2, index_exp = i1;
+  else
+    {
+      cp_error ("invalid types `%T[%T]' for array subscript",
+		type, TREE_TYPE (index_exp));
+      return error_mark_node;
+    }
+
+  if (array_expr == error_mark_node || index_exp == error_mark_node)
+    error ("ambiguous conversion for array subscript");
+
+  return build_array_ref (array_expr, index_exp);
 }
 
 /* Given the cast expression EXP, checking out its validity.   Either return
@@ -2487,8 +2498,8 @@ import_export_vtable (decl, type, final)
     }
   else
     {
-      /* We can only do this optimization if we have real non-inline
-	 virtual functions in our class, or if we come from a template.  */
+      /* We can only wait to decide if we have real non-inline virtual
+	 functions in our class, or if we come from a template.  */
 
       int found = CLASSTYPE_TEMPLATE_INSTANTIATION (type);
 
@@ -2543,7 +2554,8 @@ finish_prevtable_vardecl (prev, vars)
   tree ctype = DECL_CONTEXT (vars);
   import_export_template (ctype);
 
-  if (CLASSTYPE_INTERFACE_UNKNOWN (ctype) && TYPE_VIRTUAL_P (ctype))
+  if (CLASSTYPE_INTERFACE_UNKNOWN (ctype) && TYPE_VIRTUAL_P (ctype)
+      && ! CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
     {
       tree method;
       for (method = CLASSTYPE_METHODS (ctype); method != NULL_TREE;
@@ -2562,19 +2574,11 @@ finish_prevtable_vardecl (prev, vars)
 
   import_export_vtable (vars, ctype, 1);
 
-  if (write_virtuals >= 0
+  if (flag_rtti && write_virtuals >= 0
       && ! DECL_EXTERNAL (vars) && (TREE_PUBLIC (vars) || TREE_USED (vars)))
     {
-      extern tree the_null_vtable_entry;
-
       /* Kick out the type descriptor before writing out the vtable.  */
-      if (flag_rtti)
-	{
-	  build_t_desc (ctype, 1);
-	}
-
-      /* Write it out.  */
-      mark_vtable_entries (vars);
+      build_t_desc (ctype, 1);
     }
 }
     
@@ -2582,39 +2586,13 @@ static void
 finish_vtable_vardecl (prev, vars)
      tree prev, vars;
 {
-  tree ctype = DECL_CONTEXT (vars);
-  import_export_template (ctype);
-
-  if (CLASSTYPE_INTERFACE_UNKNOWN (ctype) && TYPE_VIRTUAL_P (ctype))
-    {
-      tree method;
-      for (method = CLASSTYPE_METHODS (ctype); method != NULL_TREE;
-	   method = DECL_NEXT_METHOD (method))
-	{
-	  if (DECL_VINDEX (method) != NULL_TREE && !DECL_SAVED_INSNS (method)
-	      && !DECL_ABSTRACT_VIRTUAL_P (method))
-	    {
-	      SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
-	      CLASSTYPE_VTABLE_NEEDS_WRITING (ctype) = ! DECL_EXTERNAL (method);
-	      CLASSTYPE_INTERFACE_ONLY (ctype) = DECL_EXTERNAL (method);
-	      if (flag_rtti)
-		cp_warning ("compiler error: rtti entry for `%T' decided too late", ctype);
-	      break;
-	    }
-	}
-    }
-
-  import_export_vtable (vars, ctype, 1);
-
   if (write_virtuals >= 0
       && ! DECL_EXTERNAL (vars) && (TREE_PUBLIC (vars) || TREE_USED (vars)))
     {
-      extern tree the_null_vtable_entry;
-
       /* Write it out.  */
       mark_vtable_entries (vars);
       if (TREE_TYPE (DECL_INITIAL (vars)) == 0)
-	  store_init_value (vars, DECL_INITIAL (vars));
+	store_init_value (vars, DECL_INITIAL (vars));
 
 #ifdef DWARF_DEBUGGING_INFO
       if (write_symbols == DWARF_DEBUG)
@@ -2646,8 +2624,18 @@ finish_vtable_vardecl (prev, vars)
 
       rest_of_decl_compilation (vars, NULL_PTR, 1, 1);
     }
-  else if (TREE_USED (vars))
-    assemble_external (vars);
+  else if (! TREE_USED (vars))
+    /* We don't know what to do with this one yet.  */
+    return;
+
+  /* We know that PREV must be non-zero here.  */
+  TREE_CHAIN (prev) = TREE_CHAIN (vars);
+}
+
+static void
+prune_vtable_vardecl (prev, vars)
+     tree prev, vars;
+{
   /* We know that PREV must be non-zero here.  */
   TREE_CHAIN (prev) = TREE_CHAIN (vars);
 }
@@ -2731,6 +2719,8 @@ import_export_inline (decl)
   if (DECL_INTERFACE_KNOWN (decl))
     return;
 
+  DECL_EXTERNAL (decl) = 0;
+
   if (DECL_TEMPLATE_INSTANTIATION (decl))
     {
       if (DECL_IMPLICIT_INSTANTIATION (decl) && flag_implicit_templates)
@@ -2773,7 +2763,6 @@ finish_file ()
   tree fnname;
   tree vars = static_aggregates;
   int needs_cleaning = 0, needs_messing_up = 0;
-  int have_exception_handlers = build_exception_table ();
 
   if (flag_detailed_statistics)
     dump_tree_statistics ();
@@ -2788,7 +2777,7 @@ finish_file ()
      we'll need here.  */
   push_lang_context (lang_name_c);
 
-  if (static_ctors || vars || have_exception_handlers)
+  if (static_ctors || vars || might_have_exceptions_p ())
     needs_messing_up = 1;
   if (static_dtors)
     needs_cleaning = 1;
@@ -2900,7 +2889,7 @@ finish_file ()
       push_momentary ();
       expand_start_bindings (0);
 
-      if (have_exception_handlers)
+      if (might_have_exceptions_p ())
 	register_exception_table ();
 
       while (vars)
@@ -2931,6 +2920,7 @@ finish_file ()
 	      /* 9.5p5: The initializer of a static member of a class has
 		 the same acess rights as a member function.  */
 	      DECL_CLASS_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
+	      DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
 
 #if 0
 	      if (init)
@@ -3061,30 +3051,9 @@ finish_file ()
   pushdecl (vars);
 #endif
 
-  walk_vtables ((void (*)())0, finish_vtable_vardecl);
   if (flag_handle_signatures)
     walk_sigtables ((void (*)())0, finish_sigtable_vardecl);
 
-  for (vars = saved_inlines; vars; vars = TREE_CHAIN (vars))
-    {
-      tree decl = TREE_VALUE (vars);
-
-      if (DECL_ARTIFICIAL (decl)
-	  && ! DECL_INITIAL (decl)
-	  && TREE_USED (decl))
-	synthesize_method (decl);
-    }
-
-  for (vars = getdecls (); vars; vars = TREE_CHAIN (vars))
-    {
-      if (TREE_CODE (vars) == THUNK_DECL)
-	emit_thunk (vars);
-      else if (TREE_CODE (vars) == FUNCTION_DECL
-	       && ! DECL_INTERFACE_KNOWN (vars)
-	       && DECL_DECLARED_STATIC (vars))
-	TREE_PUBLIC (vars) = 0;
-    }
-
   /* Now write out inline functions which had their addresses taken and
      which were not declared virtual and which were not declared `extern
      inline'.  */
@@ -3098,10 +3067,23 @@ finish_file ()
 	tree place = TREE_CHAIN (saved_inlines);
 	reconsider = 0;
 
+	walk_vtables ((void (*)())0, finish_vtable_vardecl);
+
 	for (; place; place = TREE_CHAIN (place))
 	  {
 	    tree decl = TREE_VALUE (place);
 
+	    if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl))
+	      {
+		if (TREE_USED (decl))
+		  synthesize_method (decl);
+		else
+		  {
+		    last = place;
+		    continue;
+		  }
+	      }
+
 	    if (TREE_ASM_WRITTEN (decl) || DECL_SAVED_INSNS (decl) == 0)
 	      {
 		TREE_CHAIN (last) = TREE_CHAIN (place);
@@ -3114,9 +3096,7 @@ finish_file ()
 	      {
 		TREE_CHAIN (last) = TREE_CHAIN (place);
 
-		if (DECL_EXTERNAL (decl))
-		  assemble_external (decl);
-		else
+		if (! DECL_EXTERNAL (decl))
 		  {
 		    reconsider = 1;
 		    temporary_allocation ();
@@ -3132,6 +3112,21 @@ finish_file ()
       }
   }
 
+  walk_vtables ((void (*)())0, prune_vtable_vardecl);
+
+  for (vars = getdecls (); vars; vars = TREE_CHAIN (vars))
+    {
+      if (TREE_CODE (vars) == THUNK_DECL)
+	emit_thunk (vars);
+      else if (TREE_CODE (vars) == FUNCTION_DECL
+	       && ! DECL_INTERFACE_KNOWN (vars)
+	       && DECL_DECLARED_STATIC (vars))
+	TREE_PUBLIC (vars) = 0;
+    }
+
+  if (might_have_exceptions_p ())
+    emit_exception_table ();
+
   if (write_virtuals == 2)
     {
       /* Now complain about an virtual function tables promised

gcc/cp/error.c

@@ -585,7 +585,7 @@ dump_decl (t, v)
       break;
       
     case VAR_DECL:
-      if (VTABLE_NAME_P (DECL_NAME (t)))
+      if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
 	{
 	  OB_PUTS ("vtable for ");
 	  dump_type (DECL_CONTEXT (t), v);
@@ -933,9 +933,16 @@ dump_expr (t, nop)
 	    char *p = enum_name_string (t, type);
 	    OB_PUTCP (p);
 	  }
-	else if (type == char_type_node
-		 || type == signed_char_type_node
-		 || type == unsigned_char_type_node)
+	else if (type == boolean_type_node)
+	  {
+	    if (t == boolean_false_node)
+	      OB_PUTS ("false");
+	    else if (t == boolean_true_node)
+	      OB_PUTS ("true");
+	    else
+	      my_friendly_abort (366);
+	  }
+	else if (type == char_type_node)
 	  {
 	    OB_PUTC ('\'');
 	    dump_char (TREE_INT_CST_LOW (t));

gcc/cp/except.c

@@ -31,6 +31,8 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "obstack.h"
 #include "expr.h"
 
+tree protect_list;
+
 extern void (*interim_eh_hook)	PROTO((tree));
 
 /* holds the fndecl for __builtin_return_address () */
@@ -53,6 +55,11 @@ tree builtin_return_address_fndecl;
 #define __mips
 #endif
 #endif
+#ifdef __i386__
+#ifndef __i386
+#define __i386
+#endif
+#endif
 #if defined(__i386) || defined(__rs6000) || defined(__hppa) || defined(__mc68000) || defined (__mips) || defined (__arm) || defined (__alpha)
 #define TRY_NEW_EH
 #endif
@@ -872,11 +879,13 @@ void
 end_protect (finalization)
      tree finalization;
 {
-  struct ehEntry *entry = pop_eh_entry (&ehstack);
+  struct ehEntry *entry;
 
   if (! doing_eh (0))
     return;
 
+  entry = pop_eh_entry (&ehstack);
+
   emit_label (entry->end_label);
 
   entry->finalization = finalization;
@@ -1574,11 +1583,29 @@ expand_throw (exp)
 /* end of: my-cp-except.c */
 #endif
 
+void
+end_protect_partials () {
+  while (protect_list)
+    {
+      end_protect (TREE_VALUE (protect_list));
+      protect_list = TREE_CHAIN (protect_list);
+    }
+}
+
+int
+might_have_exceptions_p ()
+{
+#ifdef TRY_NEW_EH
+  if (eh_table_output_queue.head)
+    return 1;
+#endif
+  return 0;
+}
 
 /* Output the exception table.
  Return the number of handlers.  */
-int
-build_exception_table ()
+void
+emit_exception_table ()
 {
   int count = 0;
 #ifdef TRY_NEW_EH
@@ -1587,7 +1614,15 @@ build_exception_table ()
   tree eh_node_decl;
 
   if (! doing_eh (0))
-    return 0;
+    return;
+
+  exception_section ();
+
+  /* Beginning marker for table. */
+  ASM_OUTPUT_ALIGN (asm_out_file, 2);
+  ASM_OUTPUT_LABEL (asm_out_file, "__EXCEPTION_TABLE__");
+  output_exception_table_entry (asm_out_file,
+				const0_rtx, const0_rtx, const0_rtx);
 
  while (entry = dequeue_eh_entry (&eh_table_output_queue))
    {
@@ -1596,32 +1631,18 @@ build_exception_table ()
      if (context && ! TREE_ASM_WRITTEN (context))
        continue;
 
-     if (count == 0)
-       {
-	 exception_section ();
-
-	 /* Beginning marker for table. */
-	 ASM_OUTPUT_ALIGN (asm_out_file, 2);
-	 ASM_OUTPUT_LABEL (asm_out_file, "__EXCEPTION_TABLE__");
-	 output_exception_table_entry (asm_out_file,
-				       const0_rtx, const0_rtx, const0_rtx);
-       }
      count++;
      output_exception_table_entry (asm_out_file,
 				   entry->start_label, entry->end_label,
 				   entry->exception_handler_label);
   }
 
-  if (count)
-    {
-      /* Ending marker for table. */
-      ASM_OUTPUT_LABEL (asm_out_file, "__EXCEPTION_END__");
-      output_exception_table_entry (asm_out_file,
-				    constm1_rtx, constm1_rtx, constm1_rtx);
-    }
+  /* Ending marker for table. */
+  ASM_OUTPUT_LABEL (asm_out_file, "__EXCEPTION_END__");
+  output_exception_table_entry (asm_out_file,
+				constm1_rtx, constm1_rtx, constm1_rtx);
 
 #endif /* TRY_NEW_EH */
-  return count;
 }
 
 void

gcc/cp/init.c

@@ -157,8 +157,8 @@ expand_direct_vtbls_init (real_binfo, binfo, init_self, can_elide, addr)
 /* 348 - 351 */
 /* Subroutine of emit_base_init.  */
 static void
-perform_member_init (member, name, init, explicit)
-     tree member, name, init;
+perform_member_init (member, name, init, explicit, protect_list)
+     tree member, name, init, *protect_list;
      int explicit;
 {
   tree decl;
@@ -223,27 +223,44 @@ perform_member_init (member, name, init, explicit)
 	}
     }
   expand_cleanups_to (NULL_TREE);
-  if (flag_handle_exceptions && TYPE_NEEDS_DESTRUCTOR (type))
-    cp_warning ("caution, member `%D' may not be destroyed in the presense of an exception during construction", member);
+
+  if (TYPE_NEEDS_DESTRUCTOR (type))
+    {
+      tree expr = build_component_ref (C_C_D, name, 0, explicit);
+      expr = build_delete (type, expr, integer_zero_node,
+			   LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
+
+      if (expr != error_mark_node)
+	{
+	  start_protect ();
+	  *protect_list = tree_cons (NULL_TREE, expr, *protect_list);
+	}
+    }
 }
 
+extern int warn_reorder;
+
 /* Subroutine of emit_member_init.  */
 static tree
 sort_member_init (t)
      tree t;
 {
-  extern int warn_reorder;
   tree x, member, name, field, init;
   tree init_list = NULL_TREE;
   tree fields_to_unmark = NULL_TREE;
-  int found;
   int last_pos = 0;
   tree last_field;
 
   for (member = TYPE_FIELDS (t); member ; member = TREE_CHAIN (member))
     {
       int pos;
-      found = 0;
+
+      /* member could be, for example, a CONST_DECL for an enumerated
+	 tag; we don't want to try to initialize that, since it already
+	 has a value.  */
+      if (TREE_CODE (member) != FIELD_DECL || !DECL_NAME (member))
+	continue;
+
       for (x = current_member_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos)
 	{
 	  /* If we cleared this out, then pay no attention to it.  */
@@ -266,17 +283,9 @@ sort_member_init (t)
 
 	  if (field == member)
 	    {
-	      /* See if we already found an initializer for this field.  */
-	      if (found)
-		{
-		  if (DECL_NAME (field))
-		    cp_error ("multiple initializations given for member `%D'",
-			      field);
-		  continue;
-		}
-	      else
+	      if (warn_reorder)
 		{
-		  if (pos < last_pos && warn_reorder)
+		  if (pos < last_pos)
 		    {
 		      cp_warning_at ("member initializers for `%#D'", last_field);
 		      cp_warning_at ("  and `%#D'", field);
@@ -286,78 +295,193 @@ sort_member_init (t)
 		  last_field = field;
 		}
 
-	      init_list = chainon (init_list,
-				   build_tree_list (name, TREE_VALUE (x)));
 	      /* Make sure we won't try to work on this init again.  */
 	      TREE_PURPOSE (x) = NULL_TREE;
-	      found = 1;
-	      break;
+	      x = build_tree_list (name, TREE_VALUE (x));
+	      goto got_it;
 	    }
 	}
 
       /* If we didn't find MEMBER in the list, create a dummy entry
 	 so the two lists (INIT_LIST and the list of members) will be
 	 symmetrical.  */
-      if (! found)
-	init_list = chainon (init_list, build_tree_list (NULL_TREE, NULL_TREE));
+      x = build_tree_list (NULL_TREE, NULL_TREE);
+    got_it:
+      init_list = chainon (init_list, x); 
     }
 
+  /* Initializers for base members go at the end.  */
   for (x = current_member_init_list ; x ; x = TREE_CHAIN (x))
     {
-      if (TREE_PURPOSE (x))
+      name = TREE_PURPOSE (x);
+      if (name)
 	{
-	  name = TREE_PURPOSE (x);
-	  init = TREE_VALUE (x);
-	  /* XXX: this may need the COMPONENT_REF operand 0 check if
-	     it turns out we actually get them.  */
-	  field = IDENTIFIER_CLASS_VALUE (name);
-
-	  /* If one member shadows another, get the outermost one.  */
-	  if (TREE_CODE (field) == TREE_LIST)
+	  if (purpose_member (name, init_list))
 	    {
-	      field = TREE_VALUE (field);
-	      if (decl_type_context (field) != current_class_type)
-		cp_error ("field `%D' not in immediate context", field);
+	      cp_error ("multiple initializations given for member `%D'",
+			IDENTIFIER_CLASS_VALUE (name));
+	      continue;
 	    }
+	      
+	  init_list = chainon (init_list,
+			       build_tree_list (name, TREE_VALUE (x)));
+	  TREE_PURPOSE (x) = NULL_TREE;
+	}
+    }
 
-#if 0
-	  /* It turns out if you have an anonymous union in the
-	     class, a member from it can end up not being on the
-	     list of fields (rather, the type is), and therefore
-	     won't be seen by the for loop above.  */
+  return init_list;
+}
 
-	  /* The code in this for loop is derived from a general loop
-	     which had this check in it.  Theoretically, we've hit
-	     every initialization for the list of members in T, so
-	     we shouldn't have anything but these left in this list.  */
-	  my_friendly_assert (DECL_FIELD_CONTEXT (field) != t, 351);
-#endif
+static void
+sort_base_init (t, rbase_ptr, vbase_ptr)
+     tree t, *rbase_ptr, *vbase_ptr;
+{
+  tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
+  int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
+
+  int i;
+  tree x;
+  tree last;
+
+  /* For warn_reorder.  */
+  int last_pos = 0;
+  tree last_base = NULL_TREE;
+
+  tree rbases = NULL_TREE;
+  tree vbases = NULL_TREE;
 
-	  if (TREE_HAS_CONSTRUCTOR (field))
+  /* First walk through and splice out vbase and invalid initializers.
+     Also replace names with binfos.  */
+
+  last = tree_cons (NULL_TREE, NULL_TREE, current_base_init_list);
+  for (x = TREE_CHAIN (last); x; x = TREE_CHAIN (x))
+    {
+      tree basename = TREE_PURPOSE (x);
+      tree binfo;
+
+      if (basename == NULL_TREE)
+	{
+	  /* Initializer for single base class.  Must not
+	     use multiple inheritance or this is ambiguous.  */
+	  switch (n_baseclasses)
 	    {
-	      if (DECL_NAME (field))
-		error ("multiple initializations given for member `%s'",
-		       IDENTIFIER_POINTER (DECL_NAME (field)));
-	      continue;
+	    case 0:
+	      cp_error ("`%T' does not have a base class to initialize",
+			current_class_type);
+	      return;
+	    case 1:
+	      break;
+	    default:
+	      cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
+			current_class_type);
+	      return;
 	    }
+	  binfo = TREE_VEC_ELT (binfos, 0);
+	}
+      else if (is_aggr_typedef (basename, 1))
+	{
+	  binfo = binfo_or_else (IDENTIFIER_TYPE_VALUE (basename), t);
+	  if (binfo == NULL_TREE)
+	    continue;
 
-	  TREE_HAS_CONSTRUCTOR (field) = 1;
-	  fields_to_unmark = tree_cons (NULL_TREE, field, fields_to_unmark);
+	  /* Virtual base classes are special cases.  Their initializers
+	     are recorded with this constructor, and they are used when
+	     this constructor is the top-level constructor called.  */
+	  if (TREE_VIA_VIRTUAL (binfo))
+	    {
+	      tree v = CLASSTYPE_VBASECLASSES (t);
+	      while (BINFO_TYPE (v) != BINFO_TYPE (binfo))
+		v = TREE_CHAIN (v);
 
-	  perform_member_init (field, name, init, 1);
-	  TREE_PURPOSE (x) = NULL_TREE;
+	      vbases = tree_cons (v, TREE_VALUE (x), vbases);
+	      continue;
+	    }
+	  else
+	    {
+	      /* Otherwise, if it is not an immediate base class, complain.  */
+	      for (i = n_baseclasses-1; i >= 0; i--)
+		if (BINFO_TYPE (binfo) == BINFO_TYPE (TREE_VEC_ELT (binfos, i)))
+		  break;
+	      if (i < 0)
+		{
+		  cp_error ("`%T' is not an immediate base class of `%T'",
+			    IDENTIFIER_TYPE_VALUE (basename),
+			    current_class_type);
+		  continue;
+		}
+	    }
 	}
+      else
+	my_friendly_abort (365);
+
+      TREE_PURPOSE (x) = binfo;
+      TREE_CHAIN (last) = x;
+      last = x;
     }
+  TREE_CHAIN (last) = NULL_TREE;
 
-  /* Unmark fields which are initialized for the base class.  */
-  while (fields_to_unmark)
+  /* Now walk through our regular bases and make sure they're initialized.  */
+
+  for (i = 0; i < n_baseclasses; ++i)
     {
-      TREE_HAS_CONSTRUCTOR (TREE_VALUE (fields_to_unmark)) = 0;
-      /* XXX is this a memory leak? */
-      fields_to_unmark = TREE_CHAIN (fields_to_unmark);
+      tree base_binfo = TREE_VEC_ELT (binfos, i);
+      int pos;
+
+      if (TREE_VIA_VIRTUAL (base_binfo))
+	continue;
+
+      for (x = current_base_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos)
+	{
+	  tree binfo = TREE_PURPOSE (x);
+
+	  if (binfo == NULL_TREE)
+	    continue;
+
+	  if (binfo == base_binfo)
+	    {
+	      if (warn_reorder)
+		{
+		  if (pos < last_pos)
+		    {
+		      cp_warning_at ("base initializers for `%#T'", last_base);
+		      cp_warning_at ("  and `%#T'", BINFO_TYPE (binfo));
+		      warning ("  will be re-ordered to match inheritance order");
+		    }
+		  last_pos = pos;
+		  last_base = BINFO_TYPE (binfo);
+		}
+
+	      /* Make sure we won't try to work on this init again.  */
+	      TREE_PURPOSE (x) = NULL_TREE;
+	      x = build_tree_list (binfo, TREE_VALUE (x));
+	      goto got_it;
+	    }
+	}
+
+      /* If we didn't find BASE_BINFO in the list, create a dummy entry
+	 so the two lists (RBASES and the list of bases) will be
+	 symmetrical.  */
+      x = build_tree_list (NULL_TREE, NULL_TREE);
+    got_it:
+      rbases = chainon (rbases, x);
     }
 
-  return init_list;
+  *rbase_ptr = rbases;
+  *vbase_ptr = vbases;
+}
+
+/* Perform partial cleanups for a base for exception handling.  */
+static tree
+build_partial_cleanup_for (binfo)
+     tree binfo;
+{
+  tree expr = convert_pointer_to_real (binfo,
+				       build_unary_op (ADDR_EXPR, C_C_D, 0));
+
+  return build_delete (TREE_TYPE (expr),
+		       expr,
+		       integer_zero_node,
+		       LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
 }
 
 /* Perform whatever initializations have yet to be done on the base
@@ -385,13 +509,14 @@ emit_base_init (t, immediately)
 {
   extern tree in_charge_identifier;
 
-  tree member, vbases;
-  tree init_list;
-  int pass, start;
+  tree member, x;
+  tree mem_init_list;
+  tree rbase_init_list, vbase_init_list;
   tree t_binfo = TYPE_BINFO (t);
   tree binfos = BINFO_BASETYPES (t_binfo);
   int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-  int have_init_list = 0, from_init_list;
+
+  my_friendly_assert (protect_list == NULL_TREE, 999);
 
   if (! immediately)
     {
@@ -407,172 +532,31 @@ emit_base_init (t, immediately)
     emit_line_note_force (DECL_SOURCE_FILE (current_function_decl),
 			  DECL_SOURCE_LINE (current_function_decl));
 
-  start = ! TYPE_USES_VIRTUAL_BASECLASSES (t);
-  for (pass = start; pass < 2; pass++)
-    {
-      tree vbase_init_list = NULL_TREE;
-
-      for (init_list = current_base_init_list; init_list;
-	   init_list = TREE_CHAIN (init_list))
-	{
-	  tree basename = TREE_PURPOSE (init_list);
-	  tree binfo;
-	  tree init = TREE_VALUE (init_list);
-
-	  if (basename == NULL_TREE)
-	    {
-	      /* Initializer for single base class.  Must not
-		 use multiple inheritance or this is ambiguous.  */
-	      switch (n_baseclasses)
-		{
-		case 0:
-		  cp_error ("`%T' does not have a base class to initialize",
-			    current_class_type);
-		  return;
-		case 1:
-		  break;
-		default:
-		  cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
-			    current_class_type);
-		  return;
-		}
-	      binfo = TREE_VEC_ELT (binfos, 0);
-	    }
-	  else if (is_aggr_typedef (basename, 1))
-	    {
-	      binfo = binfo_or_else (IDENTIFIER_TYPE_VALUE (basename), t);
-	      if (binfo == NULL_TREE)
-		continue;
-
-	      /* Virtual base classes are special cases.  Their initializers
-		 are recorded with this constructor, and they are used when
-		 this constructor is the top-level constructor called.  */
-	      if (! TREE_VIA_VIRTUAL (binfo))
-		{
-		  /* Otherwise, if it is not an immediate base class, complain.  */
-		  for (i = n_baseclasses-1; i >= 0; i--)
-		    if (BINFO_TYPE (binfo) == BINFO_TYPE (TREE_VEC_ELT (binfos, i)))
-		      break;
-		  if (i < 0)
-		    {
-		      cp_error ("`%T' is not an immediate base class of `%T'",
-				IDENTIFIER_TYPE_VALUE (basename),
-				current_class_type);
-		      continue;
-		    }
-		}
-	    }
-	  else
-	    continue;
-
-	  /* The base initialization list goes up to the first
-	     base class which can actually use it.  */
-
-	  if (pass == start)
-	    {
-	      char *msgp = (! TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (binfo)))
-		? "cannot pass initialization up to class `%s'" : 0;
-
-	      while (! TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (binfo))
-		     && BINFO_BASETYPES (binfo) != NULL_TREE
-		     && TREE_VEC_LENGTH (BINFO_BASETYPES (binfo)) == 1)
-		{
-		  /* ?? This should be fixed in RENO by forcing
-		     default constructors to exist.  */
-		  SET_BINFO_BASEINIT_MARKED (binfo);
-		  binfo = BINFO_BASETYPE (binfo, 0);
-		}
-
-	      /* We used to give an error if this wasn't true, saying that
-		 there's no constructor for the initialization of basename.
-		 This turned out to be incorrect---it should use the
-		 default constructor, since a user could try to initialize
-		 the class in a derived class's base initializer list.  */
-	      if (TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (binfo)))
-		{
-		  if (msgp)
-		    {
-		      if (pedantic)
-			error_with_aggr_type (binfo, msgp);
-		      else
-			msgp = NULL;
-		    }
-		}
-
-	      if (BINFO_BASEINIT_MARKED (binfo))
-		{
-		  msgp = "class `%s' initializer already specified";
-		  error (msgp, IDENTIFIER_POINTER (basename));
-		}
-
-	      if (msgp)
-		continue;
-
-	      SET_BINFO_BASEINIT_MARKED (binfo);
-	      if (TREE_VIA_VIRTUAL (binfo))
-		{
-		  vbase_init_list = tree_cons (init, BINFO_TYPE (binfo),
-					       vbase_init_list);
-		  continue;
-		}
-	      if (pass == 0)
-		continue;
-	    }
-	  else if (TREE_VIA_VIRTUAL (binfo))
-	    continue;
+  mem_init_list = sort_member_init (t);
+  current_member_init_list = NULL_TREE;
 
-	  member = convert_pointer_to (binfo, current_class_decl);
-	  expand_aggr_init_1 (binfo, 0,
-			      build_indirect_ref (member, NULL_PTR), init,
-			      BINFO_OFFSET_ZEROP (binfo), LOOKUP_NORMAL);
-	  expand_cleanups_to (NULL_TREE);
-	}
+  sort_base_init (t, &rbase_init_list, &vbase_init_list);
+  current_base_init_list = NULL_TREE;
 
-      if (pass == 0)
-	{
-	  tree first_arg = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
-	  tree vbases;
+  if (TYPE_USES_VIRTUAL_BASECLASSES (t))
+    {
+      tree first_arg = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
 
-	  if (DECL_NAME (current_function_decl) == NULL_TREE
-	      && TREE_CHAIN (first_arg) != NULL_TREE)
-	    {
-	      /* If there are virtual baseclasses without initialization
-		 specified, and this is a default X(X&) constructor,
-		 build the initialization list so that each virtual baseclass
-		 of the new object is initialized from the virtual baseclass
-		 of the incoming arg.  */
-	      tree init_arg = build_unary_op (ADDR_EXPR, TREE_CHAIN (first_arg), 0);
-	      for (vbases = CLASSTYPE_VBASECLASSES (t);
-		   vbases; vbases = TREE_CHAIN (vbases))
-		{
-		  if (BINFO_BASEINIT_MARKED (vbases) == 0)
-		    {
-		      member = convert_pointer_to (vbases, init_arg);
-		      if (member == init_arg)
-			member = TREE_CHAIN (first_arg);
-		      else
-			TREE_TYPE (member) = build_reference_type (BINFO_TYPE (vbases));
-		      vbase_init_list = tree_cons (convert_from_reference (member),
-						   vbases, vbase_init_list);
-		      SET_BINFO_BASEINIT_MARKED (vbases);
-		    }
-		}
-	    }
-	  expand_start_cond (first_arg, 0);
-	  expand_aggr_vbase_init (t_binfo, C_C_D, current_class_decl,
-				  vbase_init_list);
-	  expand_end_cond ();
-	}
+      expand_start_cond (first_arg, 0);
+      expand_aggr_vbase_init (t_binfo, C_C_D, current_class_decl,
+			      vbase_init_list);
+      expand_end_cond ();
     }
-  current_base_init_list = NULL_TREE;
 
-  /* Now, perform default initialization of all base classes which
-     have not yet been initialized, and unmark baseclasses which
-     have been initialized.  */
+  /* Now, perform initialization of non-virtual base classes.  */
   for (i = 0; i < n_baseclasses; i++)
     {
       tree base = current_class_decl;
       tree base_binfo = TREE_VEC_ELT (binfos, i);
+      tree init = void_list_node;
+
+      if (TREE_VIA_VIRTUAL (base_binfo))
+	continue;
 
 #if 0 /* Once unsharing happens soon enough.  */
       my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo) == t_binfo);
@@ -580,109 +564,113 @@ emit_base_init (t, immediately)
       BINFO_INHERITANCE_CHAIN (base_binfo) = t_binfo;
 #endif
 
-      if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo)))
-	{
-	  if (! TREE_VIA_VIRTUAL (base_binfo)
-	      && ! BINFO_BASEINIT_MARKED (base_binfo))
-	    {
-	      tree ref;
+      if (TREE_PURPOSE (rbase_init_list))
+	init = TREE_VALUE (rbase_init_list);
+      else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo)))
+	init = NULL_TREE;
 
-	      if (BINFO_OFFSET_ZEROP (base_binfo))
-		base = build1 (NOP_EXPR,
-			       TYPE_POINTER_TO (BINFO_TYPE (base_binfo)),
-			       current_class_decl);
-	      else
-		base = build (PLUS_EXPR,
-			      TYPE_POINTER_TO (BINFO_TYPE (base_binfo)),
-			      current_class_decl, BINFO_OFFSET (base_binfo));
-
-	      ref = build_indirect_ref (base, NULL_PTR);
-	      expand_aggr_init_1 (base_binfo, 0, ref, NULL_TREE,
-				  BINFO_OFFSET_ZEROP (base_binfo),
-				  LOOKUP_NORMAL);
-	      expand_cleanups_to (NULL_TREE);
-	    }
+      if (init != void_list_node)
+	{
+	  member = convert_pointer_to (base_binfo, current_class_decl);
+	  expand_aggr_init_1 (base_binfo, 0,
+			      build_indirect_ref (member, NULL_PTR), init,
+			      BINFO_OFFSET_ZEROP (base_binfo), LOOKUP_NORMAL);
+	  expand_cleanups_to (NULL_TREE);
 	}
-      CLEAR_BINFO_BASEINIT_MARKED (base_binfo);
 
-      if (! TYPE_USES_VIRTUAL_BASECLASSES (t))
+      if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
 	{
-	  while (! TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (base_binfo))
-		 && BINFO_BASETYPES (base_binfo) != NULL_TREE
-		 && TREE_VEC_LENGTH (BINFO_BASETYPES (base_binfo)) == 1)
-	    {
-	      /* ?? This should be fixed in RENO by forcing
-		 default constructors to exist.  It is needed for symmetry
-		 with code above.  */
-	      base_binfo = BINFO_BASETYPE (base_binfo, 0);
-	      CLEAR_BINFO_BASEINIT_MARKED (base_binfo);
-	    }
+	  start_protect ();
+	  protect_list = tree_cons (NULL_TREE,
+				    build_partial_cleanup_for (base_binfo),
+				    protect_list);
 	}
+
+      rbase_init_list = TREE_CHAIN (rbase_init_list);
     }
 
   /* Initialize all the virtual function table fields that
      do come from virtual base classes. */
   if (TYPE_USES_VIRTUAL_BASECLASSES (t))
     expand_indirect_vtbls_init (t_binfo, C_C_D, current_class_decl, 0);
-  for (vbases = CLASSTYPE_VBASECLASSES (t); vbases; vbases = TREE_CHAIN (vbases))
-    CLEAR_BINFO_BASEINIT_MARKED (vbases);
 
   /* Initialize all the virtual function table fields that
      do not come from virtual base classes.  */
   expand_direct_vtbls_init (t_binfo, t_binfo, 1, 1, current_class_decl);
 
-  if (current_member_init_list)
-    {
-      init_list = sort_member_init (t);
-      have_init_list = 1;
-    }
-
   for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
     {
       tree init, name;
-      from_init_list = 0;
+      int from_init_list;
+
+      /* member could be, for example, a CONST_DECL for an enumerated
+	 tag; we don't want to try to initialize that, since it already
+	 has a value.  */
+      if (TREE_CODE (member) != FIELD_DECL || !DECL_NAME (member))
+	continue;
 
       /* See if we had a user-specified member initialization.  */
-      if (have_init_list)
+      if (TREE_PURPOSE (mem_init_list))
 	{
-	  if (TREE_PURPOSE (init_list))
-	    {
-	      name = TREE_PURPOSE (init_list);
-	      init = TREE_VALUE (init_list);
-	      from_init_list = 1;
+	  name = TREE_PURPOSE (mem_init_list);
+	  init = TREE_VALUE (mem_init_list);
+	  from_init_list = 1;
 
-	      if (TREE_STATIC (member))
-		{
-		  cp_error ("field `%#D' is static; only point of initialization is its declaration",
-			    member);
-		  continue;
-		}
-
-	      /* Also see if it's ever a COMPONENT_REF here.  If it is, we
-		 need to do `expand_assignment (name, init, 0, 0);' and
-		 a continue.  */
-	      my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 349);
-	    }
-
-	  init_list = TREE_CHAIN (init_list);
+	  /* Also see if it's ever a COMPONENT_REF here.  If it is, we
+	     need to do `expand_assignment (name, init, 0, 0);' and
+	     a continue.  */
+	  my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 349);
 	}
-
-      if (! from_init_list)
+      else
 	{
-	  /* member could be, for example, a CONST_DECL for an enumerated
-	     tag; we don't want to try to initialize that, since it already
-	     has a value.  */
-	  if (TREE_CODE (member) != FIELD_DECL || !DECL_NAME (member))
-	    continue;
-
 	  name = DECL_NAME (member);
 	  init = DECL_INITIAL (member);
+
+	  from_init_list = 0;
 	}
 
-      perform_member_init (member, name, init, from_init_list);
+      perform_member_init (member, name, init, from_init_list, &protect_list);
+      mem_init_list = TREE_CHAIN (mem_init_list);
     }
 
-  current_member_init_list = NULL_TREE;
+  /* Now initialize any members from our bases.  */
+  while (mem_init_list)
+    {
+      tree name, init, field;
+
+      if (TREE_PURPOSE (mem_init_list))
+	{
+	  name = TREE_PURPOSE (mem_init_list);
+	  init = TREE_VALUE (mem_init_list);
+	  /* XXX: this may need the COMPONENT_REF operand 0 check if
+	     it turns out we actually get them.  */
+	  field = IDENTIFIER_CLASS_VALUE (name);
+
+	  /* If one member shadows another, get the outermost one.  */
+	  if (TREE_CODE (field) == TREE_LIST)
+	    {
+	      field = TREE_VALUE (field);
+	      if (decl_type_context (field) != current_class_type)
+		cp_error ("field `%D' not in immediate context", field);
+	    }
+
+#if 0
+	  /* It turns out if you have an anonymous union in the
+	     class, a member from it can end up not being on the
+	     list of fields (rather, the type is), and therefore
+	     won't be seen by the for loop above.  */
+
+	  /* The code in this for loop is derived from a general loop
+	     which had this check in it.  Theoretically, we've hit
+	     every initialization for the list of members in T, so
+	     we shouldn't have anything but these left in this list.  */
+	  my_friendly_assert (DECL_FIELD_CONTEXT (field) != t, 351);
+#endif
+
+	  perform_member_init (field, name, init, 1, &protect_list);
+	}
+      mem_init_list = TREE_CHAIN (mem_init_list);
+    }
 
   if (! immediately)
     {
@@ -750,14 +738,13 @@ static void
 expand_aggr_vbase_init_1 (binfo, exp, addr, init_list)
      tree binfo, exp, addr, init_list;
 {
-  tree init = value_member (BINFO_TYPE (binfo), init_list);
+  tree init = purpose_member (binfo, init_list);
   tree ref = build_indirect_ref (addr, NULL_PTR);
   if (init)
-    init = TREE_PURPOSE (init);
+    init = TREE_VALUE (init);
   /* Call constructors, but don't set up vtables.  */
   expand_aggr_init_1 (binfo, exp, ref, init, 0, LOOKUP_COMPLAIN);
   expand_cleanups_to (NULL_TREE);
-  CLEAR_BINFO_VBASE_INIT_MARKED (binfo);
 }
 
 /* Initialize this object's virtual base class pointers.  This must be
@@ -781,38 +768,14 @@ expand_aggr_vbase_init (binfo, exp, addr, init_list)
       if (result)
 	expand_expr_stmt (build_compound_expr (result));
 
-      /* Mark everything as having an initializer
-	 (either explicit or default).  */
-      for (vbases = CLASSTYPE_VBASECLASSES (type);
-	   vbases; vbases = TREE_CHAIN (vbases))
-	SET_BINFO_VBASE_INIT_MARKED (vbases);
-
-      /* First, initialize baseclasses which could be baseclasses
-	 for other virtual baseclasses.  */
-      for (vbases = CLASSTYPE_VBASECLASSES (type);
-	   vbases; vbases = TREE_CHAIN (vbases))
-	/* Don't initialize twice.  */
-	if (BINFO_VBASE_INIT_MARKED (vbases))
-	  {
-	    tree tmp = result;
-
-	    while (BINFO_TYPE (vbases) != BINFO_TYPE (TREE_PURPOSE (tmp)))
-	      tmp = TREE_CHAIN (tmp);
-	    expand_aggr_vbase_init_1 (vbases, exp,
-				      TREE_OPERAND (TREE_VALUE (tmp), 0),
-				      init_list);
-	  }
-
-      /* Now initialize the baseclasses which don't have virtual baseclasses.  */
-      for (; result; result = TREE_CHAIN (result))
-	/* Don't initialize twice.  */
-	if (BINFO_VBASE_INIT_MARKED (TREE_PURPOSE (result)))
-	  {
-	    my_friendly_abort (47);
-	    expand_aggr_vbase_init_1 (TREE_PURPOSE (result), exp,
-				      TREE_OPERAND (TREE_VALUE (result), 0),
-				      init_list);
-	  }
+      for (vbases = CLASSTYPE_VBASECLASSES (type); vbases;
+	   vbases = TREE_CHAIN (vbases))
+	{
+	  tree tmp = purpose_member (vbases, result);
+	  expand_aggr_vbase_init_1 (vbases, exp,
+				    TREE_OPERAND (TREE_VALUE (tmp), 0),
+				    init_list);
+	}
     }
 }
 
@@ -862,7 +825,7 @@ member_init_ok_or_else (field, type, member_name)
   if (field == NULL_TREE)
     {
       cp_error ("class `%T' does not have any field named `%s'", type,
-		  member_name);
+		member_name);
       return 0;
     }
   if (DECL_CONTEXT (field) != type
@@ -872,6 +835,13 @@ member_init_ok_or_else (field, type, member_name)
 		field);
       return 0;
     }
+  if (TREE_STATIC (field))
+    {
+      cp_error ("field `%#D' is static; only point of initialization is its declaration",
+		field);
+      return 0;
+    }
+
   return 1;
 }
 
@@ -1209,7 +1179,8 @@ expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags)
   tree rval;
   tree parms;
 
-  if (init == NULL_TREE || TREE_CODE (init) == TREE_LIST)
+  if (init == NULL_TREE
+      || (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
     {
       parms = init;
       if (parms)
@@ -2044,6 +2015,12 @@ build_offset_ref (cname, name)
       return t;
     }
 
+  if (TREE_CODE (t) == FIELD_DECL && DECL_BIT_FIELD (t))
+    {
+      cp_error ("illegal pointer to bit field `%D'", t);
+      return error_mark_node;
+    }
+
   /* static class functions too.  */
   if (TREE_CODE (t) == FUNCTION_DECL && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
     my_friendly_abort (53);
@@ -2085,7 +2062,7 @@ get_member_function (exp_addr_ptr, exp, member)
       if (UNITS_PER_WORD <= 1)
 	my_friendly_abort (54);
 
-      e1 = build (GT_EXPR, integer_type_node, e0, integer_zero_node);
+      e1 = build (GT_EXPR, boolean_type_node, e0, integer_zero_node);
       e1 = build_compound_expr (tree_cons (NULL_TREE, exp_addr,
 					   build_tree_list (NULL_TREE, e1)));
       e1 = save_expr (e1);
@@ -2240,7 +2217,7 @@ resolve_offset_ref (exp)
     }
   else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member)))
     {
-      return get_member_function_from_ptrfunc (&addr, base, member);
+      return get_member_function_from_ptrfunc (&addr, member);
     }
   my_friendly_abort (56);
   /* NOTREACHED */
@@ -2322,7 +2299,13 @@ is_friend (type, supplicant)
     {
       tree list = DECL_FRIENDLIST (TYPE_NAME (type));
       tree name = DECL_NAME (supplicant);
-      tree ctype = DECL_CLASS_CONTEXT (supplicant);
+      tree ctype;
+
+      if (DECL_FUNCTION_MEMBER_P (supplicant))
+	ctype = DECL_CLASS_CONTEXT (supplicant);
+      else
+	ctype = NULL_TREE;
+
       for (; list ; list = TREE_CHAIN (list))
 	{
 	  if (name == TREE_PURPOSE (list))
@@ -2353,8 +2336,14 @@ is_friend (type, supplicant)
     }      
 
   {
-    tree context = declp ? DECL_CLASS_CONTEXT (supplicant)
-			 : DECL_CONTEXT (TYPE_NAME (supplicant));
+    tree context;
+
+    if (! declp)
+      context = DECL_CONTEXT (TYPE_NAME (supplicant));
+    else if (DECL_FUNCTION_MEMBER_P (supplicant))
+      context = DECL_CLASS_CONTEXT (supplicant);
+    else
+      context = NULL_TREE;
 
     if (context)
       return is_friend (type, context);
@@ -2508,7 +2497,7 @@ make_friend_class (type, friend_type)
     }
   if (type == friend_type)
     {
-      warning ("class `%s' is implicitly friends with itself",
+      pedwarn ("class `%s' is implicitly friends with itself",
 	       TYPE_NAME_STRING (type));
       return;
     }
@@ -2803,7 +2792,7 @@ build_new (placement, decl, init, use_global_new)
 {
   tree type, true_type, size, rval;
   tree nelts;
-  tree alloc_expr;
+  tree alloc_expr, alloc_temp;
   int has_array = 0;
   enum tree_code code = NEW_EXPR;
 
@@ -2927,6 +2916,12 @@ build_new (placement, decl, init, use_global_new)
       type = true_type = TREE_TYPE (type);
     }
 
+  if (TREE_CODE (type) == FUNCTION_TYPE)
+    {
+      error ("new cannot be applied to a function type");
+      return error_mark_node;
+    }
+
   /* When the object being created is an array, the new-expression yields a
      pointer to the initial element (if any) of the array.  For example,
      both new int and new int[10] return an int*.  5.3.4.  */
@@ -2956,7 +2951,7 @@ build_new (placement, decl, init, use_global_new)
 
   if (true_type == void_type_node)
     {
-      error ("invalid type for new: `void'");
+      error ("invalid type `void' for new");
       return error_mark_node;
     }
 
@@ -3032,12 +3027,19 @@ build_new (placement, decl, init, use_global_new)
       TREE_CALLS_NEW (rval) = 1;
     }
 
-  if (flag_check_new)
+  if (flag_check_new && rval)
     {
-      if (rval)
-	rval = save_expr (rval);
-      alloc_expr = rval;
+      /* For array new, we need to make sure that the call to new is
+	 not expanded as part of the RTL_EXPR for the initialization,
+	 so we can't just use save_expr here.  */
+
+      alloc_temp = get_temp_name (TREE_TYPE (rval), 0);
+      alloc_expr = build (MODIFY_EXPR, TREE_TYPE (rval), alloc_temp, rval);
+      TREE_SIDE_EFFECTS (alloc_expr) = 1;
+      rval = alloc_temp;
     }
+  else
+    alloc_expr = NULL_TREE;
 
   /* if rval is NULL_TREE I don't have to allocate it, but are we totally
      sure we have some extra bytes in that case for the BI_header_size
@@ -3184,10 +3186,17 @@ build_new (placement, decl, init, use_global_new)
 
  done:
 
-  if (flag_check_new && alloc_expr && rval != alloc_expr)
+  if (alloc_expr)
     {
-      tree ifexp = build_binary_op (NE_EXPR, alloc_expr, integer_zero_node, 1);
-      rval = build_conditional_expr (ifexp, rval, alloc_expr);
+      /* Did we modify the storage?  */
+      if (rval != alloc_temp)
+	{
+	  tree ifexp = build_binary_op (NE_EXPR, alloc_expr,
+					integer_zero_node, 1);
+	  rval = build_conditional_expr (ifexp, rval, alloc_temp);
+	}
+      else
+	rval = alloc_expr;
     }
 
   if (rval && TREE_TYPE (rval) != build_pointer_type (type))
@@ -3354,7 +3363,7 @@ expand_vec_init (decl, base, maxindex, init, from_array)
 	    }
 	}
 
-      expand_start_cond (build (GE_EXPR, integer_type_node,
+      expand_start_cond (build (GE_EXPR, boolean_type_node,
 				iterator, integer_zero_node), 0);
       expand_start_loop_continue_elsewhere (1);
 
@@ -3394,7 +3403,7 @@ expand_vec_init (decl, base, maxindex, init, from_array)
 	expand_assignment (base2,
 			   build (PLUS_EXPR, TYPE_POINTER_TO (type), base2, size), 0, 0);
       expand_loop_continue_here ();
-      expand_exit_loop_if_false (0, build (NE_EXPR, integer_type_node,
+      expand_exit_loop_if_false (0, build (NE_EXPR, boolean_type_node,
 					   build (PREDECREMENT_EXPR, integer_type_node, iterator, integer_one_node), minus_one));
 
       if (obey_regdecls)
@@ -3975,7 +3984,7 @@ build_vec_delete (base, maxindex, elt_size, auto_delete_vec, auto_delete,
 
   body = tree_cons (NULL_TREE,
 		    build (EXIT_EXPR, void_type_node,
-			   build (EQ_EXPR, integer_type_node, base, tbase)),
+			   build (EQ_EXPR, boolean_type_node, base, tbase)),
 		    body);
 
   loop = build (LOOP_EXPR, void_type_node, build_compound_expr (body));
@@ -4031,7 +4040,7 @@ build_vec_delete (base, maxindex, elt_size, auto_delete_vec, auto_delete,
 
   /* Outermost wrapper: If pointer is null, punt.  */
   body = build (COND_EXPR, void_type_node,
-		build (NE_EXPR, integer_type_node, base, integer_zero_node),
+		build (NE_EXPR, boolean_type_node, base, integer_zero_node),
 		body, integer_zero_node);
   body = build1 (NOP_EXPR, void_type_node, body);
 

gcc/cp/lex.c

@@ -4541,8 +4541,6 @@ real_yylex ()
 	  { value = '}'; goto done; }
 	else if (c == '%' && c1 == ':')
 	  { value = '#'; goto done; }
-	else if (c == ':' && c1 == '>')
-	  { value = ']'; goto done; }
 
 	nextchar = c1;
 	token_buffer[1] = 0;
@@ -4560,6 +4558,11 @@ real_yylex ()
 	  value = SCOPE;
 	  yylval.itype = 1;
 	}
+      else if (c == '>')
+	{
+	  value = ']';
+	  goto done;
+	}
       else
 	{
 	  nextchar = c;

gcc/cp/method.c

@@ -2211,12 +2211,14 @@ synthesize_method (fndecl)
   int nested = (current_function_decl != NULL_TREE);
   int toplev = (decl_function_context (fndecl) == NULL_TREE);
   char *f = input_filename;
+  tree base = DECL_CLASS_CONTEXT (fndecl);
 
   if (nested)
     push_cp_function_context (toplev);
 
   input_filename = DECL_SOURCE_FILE (fndecl);
-  extract_interface_info ();
+  interface_unknown = CLASSTYPE_INTERFACE_UNKNOWN (base);
+  interface_only = CLASSTYPE_INTERFACE_ONLY (base);
   start_function (NULL_TREE, fndecl, NULL_TREE, 1);
   store_parm_decls ();
 

gcc/cp/parse.y

@@ -1074,8 +1074,10 @@ unary_expr:
 	            {
 		      tree t = TREE_VALUE ($2);
 		      if (t != NULL_TREE
-			  && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
-			pedwarn ("ANSI C++ forbids using sizeof() on a function");
+			  && ((TREE_TYPE (t)
+			      && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
+			      || is_overloaded_fn (t)))
+			pedwarn ("ANSI C++ forbids taking the sizeof a function type");
 		    }
 		  $$ = c_sizeof (TREE_TYPE ($2)); }
 	| SIZEOF '(' type_id ')'  %prec HYPERUNARY
@@ -1142,7 +1144,7 @@ new_initializer:
 	   syntactically valid but semantically invalid.  */
 	| '=' init
 		{
-		  if (flag_ansi)
+		  if (pedantic)
 		    pedwarn ("ANSI C++ forbids initialization of new expression with `='");
 		  $$ = $2;
 		}
@@ -1169,7 +1171,7 @@ cast_expr:
 		{ 
 		  tree init = build_nt (CONSTRUCTOR, NULL_TREE,
 					nreverse ($3)); 
-		  if (flag_ansi)
+		  if (pedantic)
 		    pedwarn ("ANSI C++ forbids constructor-expressions");
 		  /* Indicate that this was a GNU C constructor expression.  */
 		  TREE_HAS_CONSTRUCTOR (init) = 1;
@@ -1289,7 +1291,6 @@ unqualified_id:
 
 expr_or_declarator:
 	  notype_unqualified_id
-	| notype_qualified_id
 	| '*' expr_or_declarator %prec UNARY
 		{ $$ = build_parse_node (INDIRECT_REF, $2); }
 	| '&' expr_or_declarator %prec UNARY
@@ -1301,9 +1302,6 @@ expr_or_declarator:
 direct_notype_declarator:
 	  complex_direct_notype_declarator
 	| notype_unqualified_id
-	| notype_qualified_id
-		{ push_nested_class (TREE_TYPE (OP0 ($$)), 3);
-		  TREE_COMPLEXITY ($$) = current_class_depth; }
 	| '(' expr_or_declarator ')'
 		{ $$ = finish_decl_parsing ($2); }
 	;
@@ -1360,7 +1358,7 @@ primary:
 		  $<ttype>$ = expand_start_stmt_expr (); }
 	  compstmt ')'
 		{ tree rtl_exp;
-		  if (flag_ansi)
+		  if (pedantic)
 		    pedwarn ("ANSI C++ forbids braced-groups within expressions");
 		  rtl_exp = expand_end_stmt_expr ($<ttype>2);
 		  /* The statements have side effects, so the group does.  */
@@ -1554,7 +1552,7 @@ primary:
 	| object unqualified_id  %prec UNARY
 		{ got_object = NULL_TREE;
 		  $$ = build_component_ref ($$, $2, NULL_TREE, 1); }
-	| object qualified_id %prec UNARY
+	| object overqualified_id %prec UNARY
 		{ got_object = NULL_TREE;
 		  $$ = build_object_ref ($$, OP0 ($2), OP1 ($2)); }
 	| object unqualified_id '(' nonnull_exprlist ')'
@@ -1589,7 +1587,7 @@ primary:
 					  (LOOKUP_NORMAL|LOOKUP_AGGR));
 #endif
 		}
-	| object qualified_id '(' nonnull_exprlist ')'
+	| object overqualified_id '(' nonnull_exprlist ')'
 		{
 		  got_object = NULL_TREE;
 		  if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (OP0 ($2))))
@@ -1601,7 +1599,7 @@ primary:
 		  else
 		    $$ = build_scoped_method_call ($$, OP0 ($2), OP1 ($2), $4);
 		}
-	| object qualified_id LEFT_RIGHT
+	| object overqualified_id LEFT_RIGHT
 		{
 		  got_object = NULL_TREE;
 		  if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (OP0 ($2))))
@@ -1617,8 +1615,9 @@ primary:
 	| object '~' TYPESPEC LEFT_RIGHT
 		{
 		  got_object = NULL_TREE;
-		  if (TREE_CODE (TREE_TYPE ($1)) 
-		      != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($3))))
+		  if (IDENTIFIER_GLOBAL_VALUE ($3)
+		      && (TREE_CODE (TREE_TYPE ($1)) 
+			  != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($3)))))
 		    cp_error ("`%E' is not of type `%T'", $1, $3);
 		  $$ = convert (void_type_node, $1);
 		}
@@ -1654,7 +1653,7 @@ primary_no_id:
 		    }
 		  $<ttype>$ = expand_start_stmt_expr (); }
 	  compstmt ')'
-		{ if (flag_ansi)
+		{ if (pedantic)
 		    pedwarn ("ANSI C++ forbids braced-groups within expressions");
 		  $$ = expand_end_stmt_expr ($<ttype>2); }
 	| primary_no_id '(' nonnull_exprlist ')'
@@ -1816,6 +1815,8 @@ typed_declspecs1:
 		{ $$ = decl_tree_cons (NULL_TREE, $2, $$); }
 	| typespec reserved_declspecs	%prec HYPERUNARY
 		{ $$ = decl_tree_cons (NULL_TREE, $$, $2); }
+	| typespec reserved_typespecquals reserved_declspecs
+		{ $$ = decl_tree_cons (NULL_TREE, $$, chainon ($2, $3)); }
 	| declmods typespec reserved_declspecs
 		{ $$ = decl_tree_cons (NULL_TREE, $2, chainon ($3, $$)); }
 	| declmods typespec reserved_typespecquals
@@ -1902,11 +1903,11 @@ typespec: structsp
 	| complete_type_name
 	| TYPEOF '(' expr ')'
 		{ $$ = TREE_TYPE ($3);
-		  if (flag_ansi)
+		  if (pedantic)
 		    pedwarn ("ANSI C++ forbids `typeof'"); }
 	| TYPEOF '(' type_id ')'
 		{ $$ = groktypename ($3);
-		  if (flag_ansi)
+		  if (pedantic)
 		    pedwarn ("ANSI C++ forbids `typeof'"); }
 	| SIGOF '(' expr ')'
 		{ tree type = TREE_TYPE ($3);
@@ -2763,7 +2764,7 @@ new_type_id:
 	   non-constant dimension.  */
 	| '(' type_id ')' '[' expr ']'
 		{
-		  if (flag_ansi)
+		  if (pedantic)
 		    pedwarn ("ANSI C++ forbids array dimensions with parenthesized type in new");
 		  $$ = build_parse_node (ARRAY_REF, TREE_VALUE ($2), $5);
 		  $$ = build_decl_list (TREE_PURPOSE ($2), $$);
@@ -2905,6 +2906,9 @@ complex_direct_notype_declarator:
 		{ $$ = build_parse_node (ARRAY_REF, $$, $3); }
 	| direct_notype_declarator '[' ']'
 		{ $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
+	| notype_qualified_id
+		{ push_nested_class (TREE_TYPE (OP0 ($$)), 3);
+		  TREE_COMPLEXITY ($$) = current_class_depth; }
 	;
 
 qualified_id:
@@ -3107,7 +3111,7 @@ errstmt:  error ';'
 maybe_label_decls:
 	  /* empty */
 	| label_decls
-		{ if (flag_ansi)
+		{ if (pedantic)
 		    pedwarn ("ANSI C++ forbids label declarations"); }
 	;
 
@@ -3323,7 +3327,7 @@ simple_stmt:
 		  register tree label
 		    = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
 
-		  if (flag_ansi)
+		  if (pedantic)
 		    pedwarn ("ANSI C++ forbids range expressions in switch statement");
 		  if (value1 != error_mark_node
 		      && value2 != error_mark_node)

gcc/cp/pt.c

@@ -755,6 +755,8 @@ uses_template_parms (t)
     case REFERENCE_TYPE:
       return uses_template_parms (TREE_TYPE (t));
     case RECORD_TYPE:
+      if (TYPE_PTRMEMFUNC_FLAG (t))
+	return uses_template_parms (TYPE_PTRMEMFUNC_FN_TYPE (t));
     case UNION_TYPE:
       if (!TYPE_NAME (t))
 	return 0;
@@ -1153,9 +1155,8 @@ tsubst (t, args, nargs, in_decl)
       && type != integer_type_node
       && type != void_type_node
       && type != char_type_node)
-    type = cp_build_type_variant (tsubst (type, args, nargs, in_decl),
-				 TYPE_READONLY (type),
-				 TYPE_VOLATILE (type));
+    type = tsubst (type, args, nargs, in_decl);
+
   switch (TREE_CODE (t))
     {
     case RECORD_TYPE:
@@ -1679,12 +1680,16 @@ instantiate_template (tmpl, targ_ptr)
   my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 283);
   len = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (tmpl));
 
+  i = len;
+  while (i--)
+    targ_ptr[i] = copy_to_permanent (targ_ptr[i]);
+
   for (fndecl = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
        fndecl; fndecl = TREE_CHAIN (fndecl))
     {
       tree *t1 = &TREE_VEC_ELT (TREE_PURPOSE (fndecl), 0);
       for (i = len - 1; i >= 0; i--)
-	if (t1[i] != targ_ptr[i])
+	if (simple_cst_equal (t1[i], targ_ptr[i]) <= 0)
 	  goto no_match;
 
       /* Here, we have a match.  */
@@ -2036,6 +2041,15 @@ type_unification (tparms, targs, parms, args, nsubsts, subr)
 	return 1;
       if (arg == unknown_type_node)
 	return 1;
+
+      if (! uses_template_parms (parm)
+	  && TREE_CODE_CLASS (TREE_CODE (arg)) != 't')
+	{
+	  if (can_convert_arg (parm, TREE_TYPE (arg), arg))
+	    continue;
+	  return 1;
+	}
+	
 #if 0
       if (TREE_CODE (arg) == VAR_DECL)
 	arg = TREE_TYPE (arg);

gcc/cp/tree.c

@@ -1740,6 +1740,9 @@ make_deep_copy (t)
     case ARRAY_TYPE:
       return build_array_type (make_deep_copy (TREE_TYPE (t)),
 			       make_deep_copy (TYPE_DOMAIN (t)));
+    case INTEGER_TYPE:
+      return build_index_type (make_deep_copy (TYPE_MAX_VALUE (t)));
+
     case OFFSET_TYPE:
       return build_offset_type (make_deep_copy (TYPE_OFFSET_BASETYPE (t)),
 				make_deep_copy (TREE_TYPE (t)));
@@ -1749,6 +1752,7 @@ make_deep_copy (t)
 	 build_function_type
 	 (make_deep_copy (TREE_TYPE (t)),
 	  make_deep_copy (TREE_CHAIN (TYPE_ARG_TYPES (t)))));
+
     case RECORD_TYPE:
       if (TYPE_PTRMEMFUNC_P (t))
 	return build_ptrmemfunc_type

gcc/cp/typeck.c

@@ -719,7 +719,28 @@ comptypes (type1, type2, strict)
       return 1;
 
     case UNINSTANTIATED_P_TYPE:
-      return UPT_TEMPLATE (t1) == UPT_TEMPLATE (t2);
+      if (UPT_TEMPLATE (t1) != UPT_TEMPLATE (t2))
+	return 0;
+      {
+	int i = TREE_VEC_LENGTH (UPT_PARMS (t1));
+	tree *p1 = &TREE_VEC_ELT (UPT_PARMS (t1), 0);
+	tree *p2 = &TREE_VEC_ELT (UPT_PARMS (t2), 0);
+	
+	while (i--)
+	  {
+	    if (TREE_CODE_CLASS (TREE_CODE (p1[i])) == 't')
+	      {
+		if (! comptypes (p1[i], p2[i], 1))
+		  return 0;
+	      }
+	    else
+	      {
+		if (simple_cst_equal (p1[i], p2[i]) <= 0)
+		  return 0;
+	      }
+	  }
+      }
+      return 1;
     }
   return attrval == 2 && val == 1 ? 2 : val;
 }
@@ -1834,26 +1855,6 @@ build_array_ref (array, idx)
     return error_mark_node;
 
   itype = TREE_TYPE (idx);
-  /* We must check here for the reference, so we can do the possible
-     conversions immediately afterwards.  */
-  if (TREE_CODE (itype) == REFERENCE_TYPE)
-    {
-      idx = convert_from_reference (idx);
-      itype = TREE_TYPE (idx);
-    }
-
-  if (IS_AGGR_TYPE (itype))
-    {
-      if (TYPE_HAS_INT_CONVERSION (itype))
-	idx = build_type_conversion (CONVERT_EXPR,
-				     integer_type_node, idx, 1);
-      else
-	{
-	  error_with_aggr_type (itype,
-				"type `%s' requires integer conversion for array indexing");
-	  return error_mark_node;
-	}
-    }
 
   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
       && TREE_CODE (array) != INDIRECT_REF)
@@ -1902,19 +1903,19 @@ build_array_ref (array, idx)
 	    return error_mark_node;
 	}
 
-      /* Note in C++ we don't bother warning about subscripting a
-	 `register' array, since it's valid in C++ to take the address
-	 of something with that storage specification.  */
       if (pedantic && !lvalue_p (array))
 	pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
 
-      if (pedantic)
+      /* Note in C++ it is valid to subscript a `register' array, since
+	 it is valid to take the address of something with that
+	 storage specification.  */
+      if (extra_warnings)
 	{
 	  tree foo = array;
 	  while (TREE_CODE (foo) == COMPONENT_REF)
 	    foo = TREE_OPERAND (foo, 0);
 	  if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
-	    pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
+	    warning ("subscripting array declared `register'");
 	}
 
       type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
@@ -2122,7 +2123,7 @@ build_x_function_call (function, params, decl)
 	decl = C_C_D;
 
       decl_addr = build_unary_op (ADDR_EXPR, decl, 0);
-      function = get_member_function_from_ptrfunc (&decl_addr, decl,
+      function = get_member_function_from_ptrfunc (&decl_addr,
 						   TREE_OPERAND (function, 1));
       params = tree_cons (NULL_TREE, decl_addr, params);
       return build_function_call (function, params);
@@ -2184,9 +2185,8 @@ build_x_function_call (function, params, decl)
    instance to use, if the member points to a virtual member.  */
 
 tree
-get_member_function_from_ptrfunc (instance_ptrptr, instance, function)
+get_member_function_from_ptrfunc (instance_ptrptr, function)
      tree *instance_ptrptr;
-     tree instance;
      tree function;
 {
   if (TREE_CODE (function) == OFFSET_REF)
@@ -2200,7 +2200,7 @@ get_member_function_from_ptrfunc (instance_ptrptr, instance, function)
       tree index = save_expr (build_component_ref (function,
 						   index_identifier,
 						   0, 0));
-      tree e1 = build (GT_EXPR, delta_type_node, index,
+      tree e1 = build (GT_EXPR, boolean_type_node, index,
 		       convert (delta_type_node, integer_zero_node));
       tree delta = convert (ptrdiff_type_node,
 			    build_component_ref (function, delta_identifier, 0, 0));
@@ -2209,9 +2209,16 @@ get_member_function_from_ptrfunc (instance_ptrptr, instance, function)
       tree e3;
       tree aref, vtbl;
 
+      tree instance;
+      tree instance_ptr = *instance_ptrptr;
+
+      if (TREE_SIDE_EFFECTS (instance_ptr))
+	instance_ptr = save_expr (instance_ptr);
+
       /* convert down to the right base, before using the instance. */
-      instance = convert_pointer_to_real (TYPE_METHOD_BASETYPE (TREE_TYPE (fntype)),
-					  build_unary_op (ADDR_EXPR, instance, 0));
+      instance
+	= convert_pointer_to_real (TYPE_METHOD_BASETYPE (TREE_TYPE (fntype)),
+				   instance_ptr);
       if (instance == error_mark_node)
 	return instance;
 
@@ -2238,9 +2245,8 @@ get_member_function_from_ptrfunc (instance_ptrptr, instance, function)
 				   delta, 1);
 	}
 
-      *instance_ptrptr = build (PLUS_EXPR, TREE_TYPE (*instance_ptrptr),
-				*instance_ptrptr,
-				delta);
+      *instance_ptrptr = build (PLUS_EXPR, TREE_TYPE (instance_ptr),
+				instance_ptr, delta);
       if (flag_vtable_thunks)
 	e2 = aref;
       else
@@ -2249,6 +2255,12 @@ get_member_function_from_ptrfunc (instance_ptrptr, instance, function)
       e3 = PFN_FROM_PTRMEMFUNC (function);
       TREE_TYPE (e2) = TREE_TYPE (e3);
       function = build_conditional_expr (e1, e2, e3);
+
+      /* Make sure this doesn't get evaluated first inside one of the
+         branches of the COND_EXPR.  */
+      if (TREE_CODE (instance_ptr) == SAVE_EXPR)
+	function = build (COMPOUND_EXPR, TREE_TYPE (function),
+			  instance_ptr, function);
     }
   return function;
 }
@@ -2325,7 +2337,7 @@ build_function_call_real (function, params, require_complete, flags)
     {
       tree instance_ptr = build_unary_op (ADDR_EXPR, C_C_D, 0);
       fntype = TYPE_PTRMEMFUNC_FN_TYPE (fntype);
-      function = get_member_function_from_ptrfunc (&instance_ptr, C_C_D, function);
+      function = get_member_function_from_ptrfunc (&instance_ptr, function);
     }
 
   is_method = (TREE_CODE (fntype) == POINTER_TYPE
@@ -2715,7 +2727,6 @@ build_binary_op (code, arg1, arg2, convert_p)
      tree arg1, arg2;
      int convert_p;
 {
-  tree type1, type2;
   tree args[2];
 
   args[0] = arg1;
@@ -2724,64 +2735,39 @@ build_binary_op (code, arg1, arg2, convert_p)
   if (convert_p)
     {
       tree args_save [2];
+      tree type0, type1;
       args[0] = args_save [0] = default_conversion (args[0]);
       args[1] = args_save [1] = default_conversion (args[1]);
 
+      if (args[0] == error_mark_node || args[1] == error_mark_node)
+	return error_mark_node;
+
+      type0 = TREE_TYPE (args[0]);
+      type1 = TREE_TYPE (args[1]);
+
       if (type_unknown_p (args[0]))
 	{
-	  args[0] = instantiate_type (TREE_TYPE (args[1]), args[0], 1);
+	  args[0] = instantiate_type (type1, args[0], 1);
 	  args[0] = default_conversion (args[0]);
 	}
       else if (type_unknown_p (args[1]))
 	{
-	  args[1] = require_instantiated_type (TREE_TYPE (args[0]),
-					       args[1],
+	  args[1] = require_instantiated_type (type0, args[1],
 					       error_mark_node);
 	  args[1] = default_conversion (args[1]);
 	}
 
-      type1 = TREE_TYPE (args[0]);
-      type2 = TREE_TYPE (args[1]);
-
-      if (IS_AGGR_TYPE_2 (type1, type2))
+      if (IS_AGGR_TYPE (type0) || IS_AGGR_TYPE (type1))
 	{
 	  /* Try to convert this to something reasonable.  */
 	  if (! build_default_binary_type_conversion(code, &args[0], &args[1]))
-	    return error_mark_node;
-	}
-      else if (IS_AGGR_TYPE (type1) || IS_AGGR_TYPE (type2))
-	{
-	  int convert_index = IS_AGGR_TYPE (type2);
-	  /* Avoid being tripped up by things like (ARG1 != 0).  */
-	  tree types[2], try;
-	  
-	  types[0] = type1; types[1] = type2;
-	  if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
-	    try = build_type_conversion (code, boolean_type_node,
-					 args[convert_index], 1);
-	  else
-	    {
-	      try = build_type_conversion (code, types[convert_index ^ 1],
-					   args[convert_index], 1);
-	  
-	      if (try == 0
-		  && args[1] == integer_zero_node
-		  && (code == NE_EXPR || code == EQ_EXPR))
-		try = build_type_conversion (code, ptr_type_node,
-					     args[convert_index], 1);
-	    }
-
-	  if (try == 0)
 	    {
 	      cp_error ("no match for `%O(%#T, %#T)'", code,
 			TREE_TYPE (arg1), TREE_TYPE (arg2));
 	      return error_mark_node;
 	    }
-	  if (try == error_mark_node)
-	    error ("ambiguous pointer conversion");
-	  args[convert_index] = try;
 	}
-
+      
       if (args[0] == args_save[0])
 	args[0] = arg1;
       if (args[1] == args_save[1])
@@ -3094,7 +3080,7 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	    {
 	      tree base = common_base_type (tt0, tt1);
 	      if (base == NULL_TREE)
-		cp_warning ("comparison of distinct object pointer types `%T' and `%T'", type0, type1);
+		cp_pedwarn ("comparison of distinct object pointer types `%T' and `%T'", type0, type1);
 	      else if (base == error_mark_node)
 		{
 		  cp_error ("comparison of pointer types `%T' and `%T' requires conversion to ambiguous supertype", type0, type1);
@@ -3119,6 +3105,8 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	      if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE
 		  && tree_int_cst_lt (TYPE_SIZE (type0), TYPE_SIZE (type1)))
 		pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
+	      else if (TREE_CODE (tt1) == OFFSET_TYPE)
+		pedwarn ("ANSI C++ forbids conversion of a pointer to member to `void *'");
 	    }
 	  else if (tt1 == void_type_node)
 	    {
@@ -3291,18 +3279,10 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	}
       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
 	       && integer_zerop (op1))
-	{
-	  op1 = null_pointer_node;
-	  if (pedantic)
-	    pedwarn ("ordered comparison of pointer with integer zero");
-	}
+	op1 = null_pointer_node;
       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
 	       && integer_zerop (op0))
-	{
-	  op0 = null_pointer_node;
-	  if (pedantic)
-	    pedwarn ("ANSI C++ forbids ordered comparison of pointer with integer zero");
-	}
+	op0 = null_pointer_node;
       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
 	{
 	  if (pedantic)
@@ -3482,14 +3462,10 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	  /* Do the checking based on the original operand trees, so that
 	     casts will be considered, but default promotions won't be.  */
 	  if (TREE_UNSIGNED (comp_type)
-	      && ((op0_signed
-		   && (TREE_CODE (op0) != INTEGER_CST
-		       || (TREE_CODE (op0) == INTEGER_CST
-			   && INT_CST_LT (op0, integer_zero_node))))
-		  || (op1_signed
-		      && (TREE_CODE (op1) != INTEGER_CST
-			  || (TREE_CODE (op1) == INTEGER_CST
-			      && INT_CST_LT (op1, integer_zero_node))))))
+	      && ((op0_signed && (TREE_CODE (orig_op0) != INTEGER_CST
+				  || tree_int_cst_sgn (orig_op0) == -1))
+		  || (op1_signed && (TREE_CODE (orig_op1) != INTEGER_CST
+				     || tree_int_cst_sgn (orig_op1) == -1))))
 	    warning ("comparison between signed and unsigned");
 
 	  /* Warn if two unsigned values are being compared in a size
@@ -3830,121 +3806,46 @@ build_unary_op (code, xarg, noconvert)
   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
   register tree arg = xarg;
   register tree argtype = 0;
-  register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
   char *errstring = NULL;
   tree val;
-  int isaggrtype;
 
-  if (typecode == ERROR_MARK)
+  if (arg == error_mark_node)
     return error_mark_node;
 
-  if (typecode == REFERENCE_TYPE && code != ADDR_EXPR && ! noconvert)
-    {
-      arg = convert_from_reference (arg);
-      typecode = TREE_CODE (TREE_TYPE (arg));
-    }
-
-  if (typecode == ENUMERAL_TYPE)
-    typecode = INTEGER_TYPE;
-
-  if (typecode == BOOLEAN_TYPE && ! noconvert)
-    typecode = INTEGER_TYPE;
-
-  isaggrtype = IS_AGGR_TYPE_CODE (typecode);
-
   switch (code)
     {
     case CONVERT_EXPR:
       /* This is used for unary plus, because a CONVERT_EXPR
 	 is enough to prevent anybody from looking inside for
 	 associativity, but won't generate any code.  */
-      if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
-        errstring = "wrong type argument to unary plus";
-      else if (!noconvert)
-	arg = default_conversion (arg);
-      arg = build1 (NON_LVALUE_EXPR, TREE_TYPE (arg), arg);
-      break;
-
-    case NEGATE_EXPR:
-      if (typecode == OFFSET_TYPE)
-	{
-	  arg = resolve_offset_ref (arg);
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	  isaggrtype = IS_AGGR_TYPE_CODE (typecode);
-	}
-
-      if (isaggrtype)
+      if (!(arg = build_expr_type_conversion
+	    (WANT_ARITH | WANT_ENUM | WANT_POINTER, arg, 1)))
+	errstring = "wrong type argument to unary plus";
+      else
 	{
 	  if (!noconvert)
-	    arg = default_conversion (arg);
-	  else
-	    {
-	      cp_error ("type conversion for type `%T' not allowed",
-			  TREE_TYPE (arg));
-	      return error_mark_node;
-	    }
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	  noconvert = 1;
+	   arg = default_conversion (arg);
+	  arg = build1 (NON_LVALUE_EXPR, TREE_TYPE (arg), arg);
 	}
+      break;
 
-      if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
-        errstring = "wrong type argument to unary minus";
+    case NEGATE_EXPR:
+      if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, 1)))
+	errstring = "wrong type argument to unary minus";
       else if (!noconvert)
 	arg = default_conversion (arg);
       break;
 
     case BIT_NOT_EXPR:
-      if (typecode == OFFSET_TYPE)
-	{
-	  arg = resolve_offset_ref (arg);
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	  isaggrtype = IS_AGGR_TYPE_CODE (typecode);
-	}
-
-      if (isaggrtype)
-	{
-	  if (!noconvert)
-	    arg = default_conversion (arg);
-	  else
-	    {
-	      cp_error ("type conversion for type `%T' not allowed",
-			  TREE_TYPE (arg));
-	      return error_mark_node;
-	    }
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	  noconvert = 1;
-	}
-
-      if (typecode != INTEGER_TYPE)
-        errstring = "wrong type argument to bit-complement";
+      if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM, arg, 1)))
+	errstring = "wrong type argument to bit-complement";
       else if (!noconvert)
 	arg = default_conversion (arg);
       break;
 
     case ABS_EXPR:
-      if (typecode == OFFSET_TYPE)
-	{
-	  arg = resolve_offset_ref (arg);
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	  isaggrtype = IS_AGGR_TYPE_CODE (typecode);
-	}
-
-      if (isaggrtype)
-	{
-	  if (!noconvert)
-	    arg = default_conversion (arg);
-	  else
-	    {
-	      cp_error ("type conversion for type `%T' not allowed",
-			  TREE_TYPE (arg));
-	      return error_mark_node;
-	    }
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	  noconvert = 1;
-	}
-
-      if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
-        errstring = "wrong type argument to abs";
+      if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, 1)))
+	errstring = "wrong type argument to abs";
       else if (!noconvert)
 	arg = default_conversion (arg);
       break;
@@ -3973,21 +3874,8 @@ build_unary_op (code, xarg, noconvert)
 
       /* Report invalid types.  */
 
-      if (typecode == OFFSET_TYPE)
-	{
-	  arg = resolve_offset_ref (arg);
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	  isaggrtype = IS_AGGR_TYPE_CODE (typecode);
-	}
-
-      if (isaggrtype)
-	{
-	  arg = default_conversion (arg);
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	}
-
-      if (typecode != POINTER_TYPE
-	  && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
+      if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
+					      arg, 1)))
 	{
 	  if (code == PREINCREMENT_EXPR)
 	    errstring ="no pre-increment operator for type";
@@ -4024,7 +3912,7 @@ build_unary_op (code, xarg, noconvert)
 	    
 	/* Compute the increment.  */
 
-	if (typecode == POINTER_TYPE)
+	if (TREE_CODE (argtype) == POINTER_TYPE)
 	  {
 	    enum tree_code tmp = TREE_CODE (TREE_TYPE (argtype));
 	    if (TYPE_SIZE (TREE_TYPE (argtype)) == 0)
@@ -4081,7 +3969,37 @@ build_unary_op (code, xarg, noconvert)
 				   ? "increment" : "decrement")))
 	  return error_mark_node;
 
-	val = build (code, TREE_TYPE (arg), arg, inc);
+	/* Forbid using -- on `bool'.  */
+	if (TREE_TYPE (arg) == boolean_type_node)
+	  {
+	    if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
+	      {
+		cp_error ("invalid use of `--' on bool variable `%D'", arg);
+		return error_mark_node;
+	      }
+#if 0
+	    /* This will only work if someone can convince Kenner to accept
+	       my patch to expand_increment. (jason)  */
+	    val = build (code, TREE_TYPE (arg), arg, inc);
+#else
+	    if (code == POSTINCREMENT_EXPR)
+	      {
+		arg = stabilize_reference (arg);
+		val = build (MODIFY_EXPR, TREE_TYPE (arg), arg,
+			     boolean_true_node);
+		TREE_SIDE_EFFECTS (val) = 1;
+		arg = save_expr (arg);
+		val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
+		val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
+	      }
+	    else
+	      val = build (MODIFY_EXPR, TREE_TYPE (arg), arg,
+			   boolean_true_node);
+#endif
+	  }
+	else
+	  val = build (code, TREE_TYPE (arg), arg, inc);
+
 	TREE_SIDE_EFFECTS (val) = 1;
 	return convert (result_type, val);
       }
@@ -4090,7 +4008,8 @@ build_unary_op (code, xarg, noconvert)
       /* Note that this operation never does default_conversion
 	 regardless of NOCONVERT.  */
 
-      if (typecode == REFERENCE_TYPE)
+      argtype = TREE_TYPE (arg);
+      if (TREE_CODE (argtype) == REFERENCE_TYPE)
 	{
 	  arg = build1 (CONVERT_EXPR, build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg);
 	  TREE_REFERENCE_EXPR (arg) = 1;
@@ -4194,13 +4113,12 @@ build_unary_op (code, xarg, noconvert)
 	;
       /* Anything not already handled and not a true memory reference
 	 is an error.  */
-      else if (typecode != FUNCTION_TYPE
-	       && typecode != METHOD_TYPE
+      else if (TREE_CODE (argtype) != FUNCTION_TYPE
+	       && TREE_CODE (argtype) != METHOD_TYPE
 	       && !lvalue_or_else (arg, "unary `&'"))
 	return error_mark_node;
 
       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
-      argtype = TREE_TYPE (arg);
       /* If the lvalue is const or volatile,
 	 merge that into the type that the address will point to.  */
       if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'd'
@@ -4900,10 +4818,25 @@ build_compound_expr (list)
 
   rest = build_compound_expr (TREE_CHAIN (list));
 
-  /* When pedantic, a compound expression can be neither an lvalue
-     nor an integer constant expression.  */
-  if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)) && ! pedantic)
-    return rest;
+  if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
+    {
+      /* the left-hand operand of a comma expression is like an expression
+         statement: we should warn if it doesn't have any side-effects,
+         unless it was explicitly cast to (void).  */
+      if ((extra_warnings || warn_unused)
+           && !(TREE_CODE (TREE_VALUE(list)) == CONVERT_EXPR
+                && TREE_TYPE (TREE_VALUE(list)) == void_type_node))
+        warning("left-hand operand of comma expression has no effect");
+
+      /* When pedantic, a compound expression can be neither an lvalue
+         nor an integer constant expression.  */
+      if (! pedantic)
+        return rest;
+    }
+#if 0 /* this requires a gcc backend patch to export warn_if_unused_value */
+  else if (warn_unused)
+    warn_if_unused_value (TREE_VALUE(list));
+#endif
 
   return build (COMPOUND_EXPR, TREE_TYPE (rest),
 		break_out_cleanups (TREE_VALUE (list)), rest);
@@ -5629,8 +5562,6 @@ build_modify_expr (lhs, modifycode, rhs)
 	cp_error ("`%T' does not define operator=", lhstype);
       else if (! TYPE_HAS_REAL_ASSIGNMENT (lhstype)
 	       && ! TYPE_HAS_COMPLEX_ASSIGN_REF (lhstype)
-	       /* FIXME find some way to deal with TARGET_EXPRs here.  */
-	       && TREE_CODE (newrhs) != TARGET_EXPR
 	       && TYPE_MAIN_VARIANT (lhstype) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs)))
 	/* Do the default thing */;
       else
@@ -5697,7 +5628,11 @@ build_modify_expr (lhs, modifycode, rhs)
 	  newrhs = build_binary_op (modifycode, lhs, rhs_tmp, 1);
 	}
       else
-	return error_mark_node;
+	{
+	  cp_error ("no match for `%O(%#T, %#T)'", modifycode,
+		    TREE_TYPE (lhs), TREE_TYPE (rhs));
+	  return error_mark_node;
+	}
     }
   else
     {
@@ -6008,18 +5943,32 @@ build_modify_expr (lhs, modifycode, rhs)
 	}
       else
 	newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
-				       NULL_TREE, 0);
-      if (flag_elide_constructors == 0
-	  && TREE_CODE (newrhs) == CALL_EXPR
-	  && TREE_ADDRESSABLE (lhstype))
+					 NULL_TREE, 0);
+      if (TREE_CODE (newrhs) == CALL_EXPR
+	  && TYPE_NEEDS_CONSTRUCTING (lhstype))
+	newrhs = build_cplus_new (lhstype, newrhs, 0);
+
+      if (TREE_CODE (newrhs) == TARGET_EXPR)
 	{
-	  /* Can't initialized directly from a CALL_EXPR, since
-	     we don't know about what doesn't alias what.  */
+	  /* Can't initialize directly from a TARGET_EXPR, since that would
+	     cause the lhs to be constructed twice.  So we force the
+	     TARGET_EXPR to be expanded.  expand_expr should really do this
+	     by itself.  */
+
+	  tree xval = make_node (RTL_EXPR);
+	  rtx rtxval;
 
-	  tree temp = get_temp_name (lhstype, 0);
-	  newrhs = build (COMPOUND_EXPR, lhstype,
-			  build_modify_expr (temp, INIT_EXPR, newrhs),
-			  temp);
+	  do_pending_stack_adjust ();
+	  start_sequence_for_rtl_expr (xval);
+	  emit_note (0, -1);
+	  rtxval = expand_expr (newrhs, NULL, VOIDmode, 0);
+	  do_pending_stack_adjust ();
+	  TREE_SIDE_EFFECTS (xval) = 1;
+	  RTL_EXPR_SEQUENCE (xval) = get_insns ();
+	  end_sequence ();
+	  RTL_EXPR_RTL (xval) = rtxval;
+	  TREE_TYPE (xval) = lhstype;
+	  newrhs = xval;
 	}
     }
 
@@ -6172,7 +6121,7 @@ get_delta_difference (from, to, force)
 	}
       if (TREE_VIA_VIRTUAL (binfo))
 	{
-	  warning ("pointer to member conversion to virtual base class will only work if your very careful");
+	  warning ("pointer to member conversion to virtual base class will only work if you are very careful");
 	}
       return build_binary_op (MINUS_EXPR,
 			      integer_zero_node,
@@ -6180,7 +6129,7 @@ get_delta_difference (from, to, force)
     }
   if (TREE_VIA_VIRTUAL (binfo))
     {
-      warning ("pointer to member conversion from virtual base class will only work if your very careful");
+      warning ("pointer to member conversion from virtual base class will only work if you are very careful");
     }
   return BINFO_OFFSET (binfo);
 }
@@ -6241,7 +6190,7 @@ build_ptrmemfunc (type, pfn, force)
 					force);
 	  delta = build_binary_op (PLUS_EXPR, delta, ndelta, 1);
 	  delta2 = build_binary_op (PLUS_EXPR, ndelta2, delta2, 1);
-	  e1 = fold (build (GT_EXPR, integer_type_node, index, integer_zero_node));
+	  e1 = fold (build (GT_EXPR, boolean_type_node, index, integer_zero_node));
 	  
 	  u = build_nt (CONSTRUCTOR, 0, tree_cons (delta2_identifier, delta2, NULL_TREE));
 	  u = build_nt (CONSTRUCTOR, 0, tree_cons (NULL_TREE, delta,

gcc/cp/typeck2.c

@@ -329,7 +329,7 @@ ack (s, v, v2)
    silly.  So instead, we just do the equivalent of a call to fatal in the
    same situation (call exit).  */
 
-/* First used: 0 (reserved), Last used: 364.  Free: */
+/* First used: 0 (reserved), Last used: 366.  Free: */
 
 static int abortcount = 0;
 
@@ -855,6 +855,14 @@ digest_init (type, init, tail)
 	    }
 	  init = element;
 	}
+      while (TREE_CODE (init) == CONSTRUCTOR)
+	{
+	  cp_pedwarn ("braces around scalar initializer for `%T'", type);
+	  init = CONSTRUCTOR_ELTS (init);
+	  if (TREE_CHAIN (init))
+	    cp_pedwarn ("ignoring extra initializers for `%T'", type);
+	  init = TREE_VALUE (init);
+	}
 
       return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
 					 "initialization", NULL_TREE, 0);