Sun Dec 31 10:47:51 1989    (tiemann at calvin)

	* cplus-cvt.c (build_up_reference): Take multiple inheritance into
	account in all (instead of just some) cases.  Take virtual
	baseclasses into account in all (instead of no) cases.

	* cplus-init.c (build_vbase_delete): Convert ADDR before calling
	destructr.  Otherwise privately derived baseclasses will give
	problems.

	* cplus-init.c (expand_aggr_init_1): Distinguish case where
	initializer list fails because virtual baseclass lacks default
	initializer and other bad argument lists.

Sat Dec 30 13:09:43 1989    (tiemann at calvin)

	* cplus-tree.h (lang_type): Added bit for MARKED6.  Used to use
	MARKED3 to mean `base class initialized', but that conflicts with
	use meaning `virtual baseclass processed' in cplus-search.c.
	* cplus-init.c (finish_base_init): Use _MARKED6 instead of
	_MARKED3 to indicate a baseclass has been initialized.

	* cplus-init.c (expand_aggr_init_1): If TYPE_HAS_CONSTRUCTOR(TYPE)
	but no constructor takes the initializer, and there is no X(X&)
	constructor, generate code for X(X&) constructor by hand.

	* cplus-typeck.c (build_modify_expr_1): Substantially simplified
	using assumption that LHS and RHS are type-compatible as a
	consequence of being elements of isomorphic structures.

	* cplus-init.c (expand_aggr_init): If EXP is initialized from
	an object of its same type, and EXP does not have an X(X&)
	constructor, have build_modify_expr do the work.

Fri Dec 29 00:29:45 1989    (tiemann at calvin)

	* cplus-class.c (finish_struct): Don't build default functions by
	default.  Instead, rely on compiler doing the Right Thing when
	handling INIT_EXPR and MODIFY_EXPR.

	* cplus-typeck.c (build_modify_expr): Don't copy virtual function
	table fields or virtual baseclass fields when performing
	memberwise copying.
	Instead, split `build_modify_expr' into two functions, a recursive
	form `build_modify_expr_1' which doesn't do any copying for
	virtual baseclasses, and a non-recursive form `build_modify_expr',
	which does handle these at top level.

Thu Dec 28 12:37:37 1989    (tiemann at calvin)

	* cplus-decl.c (build_default_constructor): Typo--used
	DECL_VIRTUAL_P (...) when VFIELD_NAME_P (DECL_NAME (...)) was
	meant.  Also, take into account fact that second arg might be "in
	charge" arg.

	* cplus-class.c (finish_base_struct): Move setting of
	TYPE_USES_VIRTUAL_BASECLASSES from here...
	* cplus-decl.c (xref_tag): ...to here.  Needed because
	constructors for virtual baseclasses now need new type signatures.

	* cplus-decl2.c (grokclassfn): Rewrote code that inserts
	parameters so that SOS will work with virtual baseclasses.
	@@ But rest of SOS code must be changed to deal with this.

	* cplus-init.c (expand_aggr_vbase_init): Changed interface.  Last
	arg is no longer FUNCTION_DECL, rather, it is the list of
	initializations that the constructor must perform (if in charge).
	All virtual baseclasses, whether they need constructors or not,
	will be initialized one way or another.

	* cplus-decl.c (finish_function): Don't do special things for
	constructors with virtual baseclasses.  Leave that up to
	`finish_base_init'.
	* cplus-init.c (finish_stmt): Same change.

	* cplus-init.c (finish_base_init): Test "in charge" variable and
	conditionally do all virtual baseclass initialization.

	* cplus-class.c (build_method_call): New flag LOOKUP_HAS_IN_CHARGE
	which means that parameter list comes with the "in charge"
	parameter already set up.  If the call is to a constructor, and
	this flag is not set, then say we are "in charge" iff constructor
	called is for new object.
	* cplus-init.c (expand_aggr_init_1): Add "in charge" parameter
	when appropriate, and set FLAGS in those cases.

	* cplus-method.c (fndecl_as_string): Don't print "in charge"
	variable when formatting constructors for objects with virtual
	baseclasses.

	* cplus-tree.h (lang_decl): Add bit for constructors which build
	objects with virtual baseclasses.  These constructors take a new
	extra argument after the `this' pointer that says whether they are
	"in charge" of initializing virtual baseclass things or not.
	* cplus-decl2.c (grokclassfn): Set DECL_CONSTRUCTOR_WITH_VBASE_P
	bit when appropriate.  Also, add extra parameter in that case.
	* All GNU C++ files: Change name of AUTO_DELETE_IDENTIFIER to
	IN_CHARGE_IDENTIFIER, since that is the correct generalization of
	its function, and thus allows the same identifier to be used in
	constructors and destructors.

Thu Dec 21 12:58:05 1989  Michael Tiemann  (tiemann at hudson)

	* cplus-init.c (expand_aggr_init): If initializing from a GNU C
	CONSTRUCTOR, consider the elts in the constructor as parameters to
	an implicit GNU C++ constructor.

Wed Dec 20 10:45:46 1989  Michael Tiemann  (tiemann at hudson)

	* cplus-decl.c (duplicate_decls): Don't know why I turned off
	propagation of DECL_IN_AGGR_P bit, but it needs to be
	on--otherwise we cannot catch duplicate method declarations in
	class scope.  Was it turned off (erroneously) for efficiency
	reasons?

	* cplus-class.c (convert_harshness): Don't see two functions
	needing user-defined type conversions as ambiguous is one comes
	from immediate class, when the other comes from a base class.

	* cplus-decl.c (grokdeclarator): Don't permit storage class
	specifiers in parameter declarations.

	* cplus-typeck.c (mark_addressable): Say we're sorry if named
	return value much change from register to memory.  Also, since
	TREE_ADDRESSABLE is checked at top, no need to recheck in various
	other parts.
	* cplus-cvt.c (build_up_reference): Same change.

	* stmt.c (expand_function_start): If function value is in a
	register, set TREE_REGDECL of the DECL_RESULT.

	* cplus-class.c (convert_harshness): Conversion of enum to int
	costs an extra penalty.  Also, don't permit one kind of enum to
	convert to another.

	* cplus-search.c (dfs_pushdecls): Only set TREE_USED to zero for
	FIELD_DECLS.  If we zero it out for e.g. VAR_DECLs, they won't get
	written out at end of file.

Tue Dec 19 17:19:31 1989  Michael Tiemann  (tiemann at hudson)

	* cplus-decl.c (finish_decl): If we are at top level and
	allocation is temporary, switch to permanent allocation before
	calling `grok_reference_init'.  Also, initialization of references
	was losing when initializer was a constructor.
	@@ Problem that must be better solved: The compiler was confused
	about what NEW_EXPR meant--when it when looking for temp space for
	the reference, it was grabbing space from the file-level
	initialization function, not from static space.  What's needed is
	objects which really know how to get the kind of space they are
	looking for when they are really expanded.

	* cplus-type2.c (build_functional_cast): Check that type is
	defined before testing various constructor bits.

Thu Dec 14 15:14:12 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-tree.c (make_deep_copy,copy_to_permanent): New functions.
	* cplus-init.c (build_new): Dec 12 change was wrong.  Instead,
	call copy_to_permanent if we need to stash away the initializer.

Tue Dec 12 01:16:31 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-init.c (build_new): Check that INIT is not NULL_TREE
	before checking its permanence.

	* cplus-decl.c (decls_match): If TREE_TYPE (NEWDECL) is
	ERROR_MARK_NODE, don't call comptypes.

	* cplus-decl2.c (grokclassfn): Parameters for constructors with
	virtual baseclasses must be build on permanent_obstack.

	* cplus-parse.y (member_init): If using old-style member
	initialization for base class, remember to move allocation to the
	permaent_obstack before reading the initializer.

	* cplus-class.c (build_method_call): If global member function is
	good, record that fact in BEST.  That way our early-out for member
	functions won't accidently call an inferior member function.

	* cplus-decl.c (grokdeclarator): If TREE_CODE (decl) ==
	ERROR_MARK, then silently continue processing, rather than
	aborting compilation.

	* cplus-parse.y (except_stmts): Call `expand_start_catch' and
	`expand_end_catch' instead of `expand_exit_except' when expanding
	default catch clause.  Otherwise, we scream out to the next
	handler, not to the point after the handler.

	* cplus-class.c (build_overload_call): continue statement missing
	in TYPE_DECL case.

Sat Dec  9 23:27:56 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-decl.c (xref_tag): Mark REF in addition to all its
	basetypes so we can protect against the user declaring recursive
	types by accident.  Also fixed Braino in testing value of I after
	the BINFO loop.

Thu Dec  7 16:37:28 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-search.c (dfs_record_inheritance): Check that MI_SIZE is
	nonzero before entering loop which uses it as stride.

	* cplus-typeck.c (build_component_ref_2): Make subroutine of code
	which builds the final COMPONENT_REF structure because it must be
	recursive in the case we have a field from a base class of a
	virtual base class.

Wed Dec  6 08:05:59 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-class.c (build_scoped_method_call): Dec 2 introduced a bug
	by attempting to optimize tree node allocation.  Fixed by always
	converting EXP.

	* cplus-decl.c (grokdeclarator): If TYPE becomes ERROR_MARK_NODE,
	and we are chasing down the declarator, must chase to TREE_OPERAND
	(DECLARATOR, 1) if TREE_CODE (DECLARATOR) is SCOPE_REF.

	* cplus-class.c (finish_struct): Change criterion for building
	init list from != CONST_DECL to == FIELD_DECL.  Also, don't count
	a class as needing constructing or needing constructor based on
	static members.

	* cplus-init.c (expand_vec_init): Call itself recursively with
	FROM_ARRAY nonzero if TREE_TYPE (init) is same as TREE_TYPE (exp).
	Also, if coming FROM_ARRAY, only call `expand_aggr_init' if there
	is a constructor to call.  Otherwise, call `expand_assignment'.

	* cplus-class.c (finish_struct): Can't have a default constructor
	if the class has reference types without default initial values.

	* cplus-tree.h (TYPE_RAISES_EXCEPTIONS): Use TYPE_NAME instead of
	(tree) TYPE_LANG_SPECIFIC.
	* cplus-decl.c (duplicate_decls): Now TYPE_LANG_SPECIFIC implies
	IS_AGGR_TYPE always.

	* cplus-init.c (build_default_constructor): Don't build
	initializer for default members.

	* cplus-class.c (finish_struct): If FUNCTION_DECL has
	IDENTIFIER_ERROR_LOCUS set, then don't keep the function in the
	class.  It is evil.

	* cplus-init.c (expand_member_init): Don't permit initialization
	of member from base class--unless baseclass is virtual and has no
	constructor.
	* cplus-init.c (member_init_ok_or_else): New function
	encapsulating this and other checks for validity of member
	initialization.

	* cplus-type2.c (build_functional_cast): Try going through type
	conversion function if no constructors apply.

	* cplus-typeck.c (c_expand_return): When returning a named return
	value, call `use_variable' on the result, in case it is in a
	register.

	* cplus-class.c (compute_conversion_costs): Don't warn about
	contravariance violations (or other problems) as a result of
	calling `comp_target_types' (via call to `instantiate_type').

	* cplus-init.c (expand_aggr_init): Check that INIT is nonzero
	before accessing its TREE_TYPE.

Tue Dec  5 00:13:33 1989  Michael Tiemann  (tiemann at arkesden)

	* integrate.c (copy_rtx_and_substitute): If we folded something
	completely into a constant, don't try to make it a legitimate
	memory reference out of it.

	* cplus-class.c (propagate_basetype_offsets): Forgot to set
	ASSOC_TYPE (ASSSOC) when building the new basetype.

	* cplus-init.c (expand_aggr_init): When initializing const array,
	turn off const bits during initialization.  Otherwise constructor
	can't be called (since it is calling from const object to
	non-const member function).

	* cplus-method.c (build_overload_name): Set PARMTYPE to
	TYPE_MAIN_VARIANT (PARMTYPE) after extracting interesting bits.

Mon Dec  4 04:56:08 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-decl.c (finish_decl): wrt Nov 14 change, only change
	DECL_NAME of TTYPE if DECL is not a FUNCTION_DECL.  It screws up
	consing up of default functions.
	* cplus-decl.c (grokdeclarator): When replacing anonymous aggr
	names with reasonable aggr names, change the names of any default
	constructors and/or destructors.

	* cplus-tree.h (type_flags): Added bits for
	TREE_GETS_CONST_{ASSIGN,INIT}_REF.
	* cplus-decl.c (grok_{ctor,op}_properties): Set bits here.
	* cplus-class.c (finish_base_struct): Read bits here.
	* cplus-class.c (finish_struct): If 

	* cplus-init.c (expand_vec_init): Implement copy initialization
	from one vector to another (to make X(X&) work if members
	are vectors of X).  Added parameter FROM_ARRAY to signify this
	fact.
	* All callers changed.	

	* cplus-decl.c (grokdeclarator): Test for validity of destructor
	declaration was too harsh.  It was not allowing one to declare
	that a destructor from a base class had public visibility in the
	current class.	

	* cplus-method.c (hack_identifier): Vestigial double TREE_VALUE.
	Now that we use baselinks, everything is one level of list.

	* expr.c (expand_builtin): Fixed for BUILTIN_SAVEREGS case, again.
	This time, loop was failing because there was only one insn being
	protected.  Now, emit a note, so that loop terminates properly.

	* cplus-decl.c (build_default_constructor): Handle initialization
	of anonymous unions by bitwise copy.
	* cplus-init.c (finish_base_init): Handle wholesale initialization
	of anonymous unions, i.e., the whole union, rather than just any
	one member.

Sun Dec  3 13:32:29 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-decl.c (grok_ctor_properties): Add argument CTYPE to say
	what class type we are grokking for.

	* All GNU C++ files: Changed tests against IS_AGGR_TYPE when test
	against TYPE_LANG_SPECIFIC tests the property in which we are
	interested.

	* cplus-decl.c (grok_ctor_properties): Notice whether constructor
	can be used as default constructor, i.e., X ().
	* cplus-class.c (base_info): Add new fields `needs_default_ctor'
	and `cant_have_default_ctor'.  Set the former if any of the
	basetypes define a default constructor.  Set the latter if and of
	the basetypes define constructors, but not the default
	constructor.
	* cplus-class.c (finish_struct): If NEEDS_DEFAULT_CTOR and not
	CANT_HAVE_DEFAULT_CTOR, then cons up a default constructor for T.
	* cplus-lex.c (cons_up_default_function): Handle this new kind of
	default constructor.
	* cplus-decl.c (finish_function): Ditto.

	* cplus-typeck.c (build_modify_expr): Change assignment to this
	from error to warning if FLAG_THIS_IS_VARIABLE.

	* cplus-class.c (finish_struct): Build default X(X&) constructor
	if there are *any* constructors, not just if there are inherited
	X(X&) constructors.

	* integrate.c (function_cannot_inline_p): Raise threshold from 3
	to 4, since we copy more NOTEs now.

	* cplus-decl.c (finish_function): If DECL_CONSTRUCTOR_P (FNDECL)
	and DECL_COMPILER_GENERATED_P (FNDECL), do the default thing for
	this constructor (memberwise initialization).  Done by calling
	`build_default_constructor'.
	* cplus-decl.c (build_default_constructor): New function.

	* cplus-lex.c (cons_up_dtor_for_type): Change name to
	`cons_up_default_function'.  Takes new argument KIND saying what
	kind of default function to build.  Cons up destructor or X(X&)
	constructor depending on KIND.
	* cplus-init.c (expand_aggr_init_1): Test TYPE_HAS_INIT_REF, not
	TYPE_GETS_INIT_REF.
	* cplus-typeck.c (convert_for_initialization): Ditto.  If !HAS,
	but GETS, then abort for now.

	* cplus-class.c (finish_base_struct): Propagate
	TYPE_GETS_ASSIGN_REF.
	* cplus-class.c (finish_struct): If TYPE_GETS_ASSIGN_REF (T)
	but not TYPE_HAS_ASSIGN_REF (T), then default.
	* cplus-decl.c (grok_ctor_properties): Set TYPE_HAS_INIT_REF along
	with TYPE_GETS_INIT_REF.

	* cplus-init.c (build_delete): Don't check PROTECT when converting
	the object to be destroyed from derived type to base type.
	Leave it up to whether the destructor is visible or not
	to make that decision.

	* cplus-typeck.c (actualparameterlist): New parameter FLAGS.
	* cplus-typeck.c (convert_for_initialization): Ditto.
	* cplus-cvt.c (convert_to_reference): Change PROTECT to FLAGS.
	* cplus-cvt.c (build_up_reference): Ditto.
	* All callers changed.

	* cplus-init.c (build_delete): When deleting members, use PROTECT
	rather than 1 as value for calling `build_delete' recursively.

	* cplus-decl2.c (grokfield): If the initializer winds up being
	`error_mark_node', wrap it in a NOP so `decl_constant_value' will
	do the right thing.

	* cplus-decl.c (grokparms): If default parameter needs
	type instantiation, do it.

	* cplus-typeck.c (build_modify_expr): Cast first expression in a
	COMPOUND_EXPR to VOID_TYPE_NODE to suppress warning from
	warn_if_unused_value.

Sat Dec  2 16:57:52 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-class.c (build_scoped_method_call): Extra TREE_TYPE around
	TREE_TYPE (decl) in two places.  Improved comments.  Make DECL be
	consistently of aggregate type.

	* cplus-tree.h (lang_type): `type_flags' substructure was not
	multiple of 4 bytes.

Fri Dec  1 05:08:57 1989  Michael Tiemann  (tiemann at arkesden)

	* integrate.c (try_fold_cc0): Argument to `emit_jump' was wrong:
	called with LABEL_REF rtx instead of underlying CODE_LABEL.

	* cplus-class.c (add_virtual_function): Handle case where virtual
	function is declared twice in the same class.

	* cplus-decl.c (finish_decl): Length argument to `bcopy' was off
	by one for anonymous aggregate names was off by one.

Thu Nov 30 16:29:42 1989  Michael Tiemann  (tiemann at arkesden)

	* expr.c (expand_builtin): In BUILTIN_SAVEREGS case, advance
	SAVING_INSNS after noting stores.

Wed Nov 29 05:35:59 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-except.c (expand_cplus_reraise): If an exception was not
	on the legal list of exceptions to reraise, don't bother
	protecting the raised object by assigning zero to its pointer.

	* cplus-class.c (build_method_call): When calling a non-const
	member function from a const member function, tell which non-const
	member function is being called.  Also, return ERROR_MARK_NODE if
	we are not looking up to complain.

	* cplus-type2.c (build_functional_cast): Due to typedefs, we must
	pull NAME from TYPE.

	* cplus-typeck.c (build_compound_expr): If TREE_VALUE of list is a
	VAR_DECL, use result of calling `decl_constant_value'.

	* stmt.c (expand_end_except): PREV was uninitialized.

	* stmt.c (expand_exit_except): New function, like
	`expand_exit_loop'.  Used to explicitly exit an except contour.
	* cplus-parse.y,cplus-except.c: Replace calls to
	`expand_exit_something' with calls to `expand_exit_except'.
	* cplus-decl.c (start_function): If FLAG_HANDLE_EXCEPTIONS, build
	an exception contour around the outermost binding level.
	* cplus-decl.c (finish_function): If FLAG_HANDLE_EXCEPTIONS, clean
	up that countour after the last binding contour goes away.
	* stmt.c (in_{try,except}_block): Added LEVEL parameter.
	* stmt.c (in_exception_handler): Added LEVEL parameter.
	* cplus-except.c: All callers to `in_try_block' as about level 1
	instead of immediate level, because outermost try block doesn't
	really count.

	* cplus-except.c (cplus_expand_end_except): Call abort if catching
	unhandled exception at outermost level.

Tue Nov 28 06:51:48 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-except.c (expand_cplus_raise): Interface changed to take
	third parameter which is the already-constructed object to be
	raised, allowing `expand_cplus_reraise' to call this function.

	* cplus-parse.y (try RERAISE raise_identifiers): Actually
	implement this now.
	* cplus-except.c (expand_cplus_reraise): Ditto.

	* cplus-decl.c (init_decl_processing): Initialize LANG_NAME_C and
	LANG_NAME_CPLUSPLUS.  Initialize CURRENT_LANG_NAME to LANG_NAME_C.
	* cplus-class.c (init_class_processing): Initialization of
	LANG_NAME_{C,CPLUSPLUS} was too late here.

	* cplus-decl.c (duplicate_decls): If NEWDECL is a FUNCTION_DECL,
	and it was the last object allocated on the permanent_obstack, cut
	the permanent_obstack back to NEWDECL, since we have OLDDECL.

	@ The following three changes are conditional on actually defining
	LANG_DECL_PERMANENT in cplus-tree.h.  It is currently not defined
	becuase a good solution for saving lang_decls might require more
	space than the space that could be reclaimed.

	@ cplus-tree.h (lang_decl): New bit LANG_DECL_PERMANENT says if
	the lang_decl was allocated on the permanent_obstack.
	@ cplus-lex.c (build_lang_decl):  Set it if appropriate.  New
	variable FREE_LANG_DECL_CHAIN holds previously freed LANG_DECLs.
	@ cplus-decl.c (duplicate_decls):  Add the lang_decl of the old
	decl to FREE_LANG_DECL_CHAIN if it was allocated on the
	permanent_obstack.

	* cplus-decl.c (duplicate_decls): Preserve DECL_LANGUAGE when
	NEWDECL is a definition.
	* cplus-decl.c (start_function): Don't set DECL_LANGUAGE here, now
	that it is properly handled in `duplicate_decls'.  Also, set
	DECL_OVERLOADED (DECL1) from DECL_OVERLOADED (OLDDECL).

Mon Nov 27 06:30:53 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-method.c (dump_init): Argument to `dump_type' was missing
	in SAVE_EXPR case.

	* cplus-class.c (compute_conversion_costs): While it is probably
	an error to permit a call from a const member function to a
	non-const member function, cfront seems to do it, grudginly.
	Change this function to make this conversion cost the heaviest of
	built-in conversion costs, to give behavior that matches cfront.
	This can easily be changed back to error-giving behavior.
	* cplus-class (build_method_call): Give warning if calling to
	non-const member function from const member function.

	* cplus-method.c,cplus-class.c: Change name of
	`do_actual_overload' to `build_overload_call', and move the
	function from cplus-method.c to cplus-class.c.  Also, rewrite
	slightly to call `build_decl_overload', removing duplicated code.
	* cplus-typeck.c (build_x_function_call): Change the name of
	called function.

	* cplus-tree.c (hash_tree_cons): Typo--set TREE_VIA_PUBLIC twice,
	instead of TREE_VIA_PUBLIC and TREE_VIA_VIRTUAL.

	* cplus-decl.c (finish_decl): It is INIT, and not
	DECL_INITIAL (DECL) which holds the real value of DECL's
	initializer.  We need INIT's value for `complete_array_type' to do
	its job.

	* expr.c (save_noncopied_parts): Deal with case of having
	`assign_stack_local' return an invalid memory reference.

	* cplus-typeck.c (build_component_ref): 11/26 fix was almost
	right, but called `value_member' in first case where should have
	called `assoc_value'.

	* cplus-init.c (expand_vec_delete): Lines were reversed in
	multi-dimensional array code.

	* version.c: Test release version 1.36.2-

	* integrate.c (expand_inline_function): Bug in use of
	CONST_EQUIV_MAP did not work correctly in the presence of loops
	for variables initialized in first basic block but modified within
	a loop body.

Sun Nov 26 17:11:08 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-init.c (build_new): Handle case when TRUE_TYPE gets
	ERROR_MARK_NODE, such as when the size expression for an ARRAY_REF
	is ERROR_MARK_NODE.

	* cplus-type2.c (digest_init): Catch case where ELEMENT is
	ERROR_MARK_NODE, which avoids calling `comptypes' with
	ERROR_MARK_NODE as our type (recall that TREE_TYPE (ERROR_MARK_NODE)
	is ERROR_MARK_NODE, not NULL_TREE).

	* cplus-typeck.c (build_component_ref): Forgot to pull offset from
	association of type once we found the field!  This causes fields
	in two separate baseclasses to overlap when referenced from a
	class deriving from the baseclasses.

	* cplus-parse.y (primary, primary_no_id): Recognize
	`SCOPE operator_name'.

	* cplus-decl.c (grok_reference_init): Code to permit references to
	arrays was somehow missing.  Also, in the case where DECL is
	TREE_STATIC and the initializer is TREE_LITERAL, no need to call
	`expand_static_init'.

	* cplus-tree.h [DECL_OVERLOADED]: User `overloaded_attr' in
	lang_decl to distinguish overloaded functions from nonoverloaded
	ones.
	* cplus-tree.h [DECL_EXTERNAL]: Use TREE_LANG_FLAG_1 instead of
	TREE_LANG_FLAG_3.  The latter was used for TREE_PRIVATE.

	* cplus-init.c (expand_vec_delete): Handle multi-dimensional
	arrays.

	* cplus-decl.c (duplicate_decls): Copying of DECL_IN_AGGR_P bit
	was backwards.
	* cplus-decl.c (start_decl): And need to turn off DECL_IN_AGGR_P
	when seeing this decl in non-aggr context.  Also, clear
	TREE_EXTERNAL if DECL_EXTERNAL is not set.

	* cplus-decl.c (grok_reference_init): Code split from
	`finish_decl' for modularity.

Sat Nov 25 06:29:08 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-decl.c (grokdeclarator): Was incorrectly rejecting
	class-local typedefs which had things like RID_LONG (thought they
	were storage class specifiers).

	* cplus-method.c (report_type_mismatch): Corrected error
	introduced by making INLINE_BUFFER non-static.

	* cplus-tree.c (build_exception_variant): Correctly handle case
	when RAISES is NULL_TREE.

	* cplus-except.c (lookup_exception_object): Switch to
	permanent_obstack when implicitly declaring an exception object.

	* cplus-class.c (instantiate_type): Handle TREE_LIST of
	FUNCTION_DECL in addition to TREE_LIST of TREE_LIST of
	FUNCTION_DECL.  The former is what a BASELINK in disguise.

	* cplus-decl.c (grokdeclarator): Don't crash if TYPE ==
	ERROR_MARK_NODE when DECL_CONTEXT == FIELD.  Happens when array
	size is undefined, for example.

Fri Nov 24 16:04:44 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-search.c (get_baselinks): When we get to end of search
	(i.e., TYPE has only one basetype), propagate BASELINKs.

	* cplus-decl.c (shadow_tag): Missing call to
	`end_exception_decls'.

Tue Nov 21 23:40:57 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-method.c: Change from static allocation of INLINE_BUFFER
	to dynamic, saving 8k static data size.
	* cplus-method.c (fndecl_as_string): Initialize INLINE_BUFFER
	always from BUF.
	* cplus-class.c, cplus-tree.c: Callers of `fndecl_as_string'
	changed.

Mon Nov 20 20:56:49 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-class.c (build_method_call): Don't check visibility on
	calls to wrappers.

	* cplus-tree.h: Delete bitfields HAS_WRAPPER and NEEDS_WRAPPER.
	Add field for TYPE_WRAP_TYPE.
	* cplus-decl.c, cplus-class.c: Set fields accordingly
	* cplus-class.c (build_method_call): Call `get_wrapper' if we need
	to be wrapping a function call.
	* cplus-search.c (get_wrapper): Implement this function.

Sat Nov 18 05:16:22 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-lex.c (check_newline): Recognize (but apologize about)
	#pragma newworld.

	* cplus-method.c (build_decl_overload): Compact encoding for
	member functions ifndef LONGERNAMES.
	* cplus-dem.c (cplus_demangle,do_args): Deal with different
	encoding ifndef LONGERNAMES.

	* cplus-tree.c (list_has_lookup_or_cons): New function optimizes
	most common case in parsing.
	* cplus-parse.y: Call in in place of `hash_tree_chain (_, NULL_TREE)'.

	* cplus-parse.y, cplus-lex.c: Gather statistics on tokens and
	reductions.

	* cplus-class.c (instantiate_type): Forgot to check COMPLAIN
	before complaining.

	* cplus-init.c (build_new,build_vec_delete): Call
	do_pending_stack_adjust before building and after finalizing
	RTL_EXPR.  Also removed bogus construct

		   emit_insn (gen_sequence ());

	which was causing circular rtl to be output.  (Thanks to rms for
	identifying the problem!).
	* cplus-type2.c (make_merged_ref): Same change.
	* cplus-parse.y (except_stmts): Same change.

	* cplus-init.c (get_member_function): Wrap a SAVE_EXPR around the
	address of MEMBER.

Fri Nov 17 20:11:19 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-type2.c (store_init_value)

	* cplus-dem.c (do_type): Initialize NON_EMPTY.

Tue Nov 14 00:19:31 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-init.c (build_vec_delete): Call `emit_note' in case no
	code is emitted by `expand_vec_delete'.

	* cplus-parse.y (operator_name): If the operator name is
	erroneous, build something signifying that fact, rather than just
	returning NULL_TREE.

	* cplus-typeck.c (target_type): New function.  Returns the target
	type of TYPE.
	* cplus-decl.c (finish_decl): Call `target_type' to figure out the
	built-in type that DECL is based on.  If we find it to be
	ANON_AGGRNAME_P, then we must change it, since nothing else will,
	and the compiler will go into loops if expand_inline_function trys
	to push it back into the environment.

	* cplus-parse.y (primary): Need to do `lookup_name' on operator
	names that come through here.

	* stmt.c (expand_end_try): Jump to after label to avoid falling
	through into default handler.

	* cplus-decl.c (define_label): Don't complain about jumps past
	initialziation of compiler-generated temporaries.  They can't be
	accessed, and by the time we get to the label, they should be
	cleaned up.

Mon Nov 13 02:34:58 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-init.c (get_member_function): If EXP_ADDR was something
	hairy (like a CALL_EXPR), make EXP indirect from it.  This saves
	writing out twice the code (once for each branch of the
	conditional).

	* cplus-dem.c (cplus_demangle): Recognize virtual function tables.
	* Also, handle operator* and operator->().

	* cplus-class.c (finish_struct): Don't warn about all class
	members being private if there are public baseclasses.

	* cplus-decl.c (grokdeclarator): Catch case where friend function
	is declared with method qualifiers.

	* cplus-typeck.c (commontype): Get the right value for BASETYPE in
	METHOD_TYPE case.

	* cplus-method.c (build_opfncall): TYPE1 was being initialized too
	late.

	* cplus-dem.c[USG]: Use this instead of #ifndef sequent.

Sun Nov 12 01:35:08 1989  Michael Tiemann  (tiemann at arkesden)

	* integrate.c (note_integrated): New function.  If insn generated
	used constants, check that it is legit.  If not, delete it and
	return zero to caller, indicating that the caller should try
	again.  If successful, set RTX_INTEGRATED_P.

	* cplus-tree.c (layout_vbasetypes): Use `int' return type to
	advantage.

	* cplus-init.c (build_delete): Don't abort if TYPE ==
	ERROR_MARK_NODE.  It can happen.

	* integrate.c: Use "iteration numbering" to propagate constants
	through inline function expansion.

	* stmt.c: Added exception stmts to nesting stack.
	* cplus-except.c: Move appropriate stuff out of here.

Sat Nov 11 10:10:59 1989  Michael Tiemann  (tiemann at arkesden)

	* integrate.c: Make `expand_inline_function' smart enough to use
	constant when safe, and not when not.

	* integrate.c: Merged changes from rms as of today.
	* varasm.c: Merged changes from rms as of today.

	* cplus-except.c: Use variable TRY_DEPTH to determine whether we
	are inside a TRY block or not.
	* cplus-except.c (cplus_expand_{start,end}_try):
	Increment/decrement that variable.
	* cplus-except.c (expand_cplus_raise_stmt): If TRY_DEPTH is
	nonzero, then simply exiting the try block does all the right
	things.  Otherwise, we must use `longjmp'.

	* cplus-init.c (build_new): Don't use the RTL_EXPR hack for static
	initializations.

	* ld.c (write_output): Unconditionally remove the old file in case
	another owns it but user has write permission.

	* cplus-decl2.c (finish_file): Set DECL_PRINT_NAME of file
	clean/initialization functions to things we might want to print.

Fri Nov 10 19:08:51 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-tree.h: Get rid of EXCEPTION_LABEL_DECL, no longer needed.
	Add EXCEPTION_THROW_DECL.  This VAR_DECL is used to determine
	whether to throw from a binding contour using the exception
	handling machinery.
	* cplus-decl.c, cplus-except.c: Changes to adapt to new model.

	* tree.c (build_op_identifier): #if 0 in this file.
	* cplus-lex.c (build_op_identifier): define this function here.
	Change interface to take `tree_code' arguments instead of `tree'
	arguments.  Use memoizing table to preserve previously allocated
	nodes.
	* cplus-parse.y, cplus-method.c: Callers changed.
	* cplus-lex.c (build_operator_fnname): Can't get by on
	side-effecting an OP_IDENTIFIER's TREE_CODE anymore.  Change
	interface to pass OP_IDENTIFIER node in as a tree*, and set that.
	* cplus-decl2.c (grokopexpr): Must also take DECLARATOR in as
	pointer.

	* cplus-init.c (build_new): After calling `start_sequence', prime
	the insn pump by calling `emit_note' to emit a NOTE_INSN_DELETED.

Wed Nov  8 15:54:32 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-type2.c (build_functional_cast): Move from cplus-class.c
	to this file.

	* cplus-class.c (build_functional_cast): Don't assume that
	TYPE_NAME (TYPE) is a TYPE_DECL; it might be an IDENTIFIER_NODE.

	* gcc.c (main): Print out the name `g++' instead of `gcc' until
	the merge is complete.

Tue Nov  7 14:56:50 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-init.c (build_new): Initialize RVAL if SOS.

Mon Nov  6 00:51:43 1989  Michael Tiemann  (tiemann at arkesden)

	* crt1.c: Changes from Eirik Fuller (Cornell Theory Center) to fix
	incremental linking.
	* gnulib3.c (__do_global_cleanup): Also from Eirik: fixed braino
	that was not reinitializing __DLI.

	* cplus-method.c (build_overload_name): Mangle member functions
	with qualifiers differently than member functions without
	qualifiers.  Also, add 'F' before argument list for METHOD_TYPE,
	since cfront 2.0 seems to do so.
	* cplus-method.c (dump_type_suffix): Make formatting of these
	kinds of METHOD_TYPEs right.
	* cplus-dem.c (do_type): Grok these changes.

	* cplus-except.c (exception_object_name): Don't crash in case
	of ``raise all'', which comes encoded as VOID_TYPE_NODE.
	@@ Handle it correctly in next release.

	* cplus-decl2.c (grok_method_quals): New function.  Incorporate
	`const' and `volatile' qualifiers into FUNCTION_DECLs and
	TYPE_DECLs.  Uses code broken out of `grokclassfn'.
	* cplus-decl2.c (grokclassfn): Caller changed.
	* cplus-decl.c (grokdeclarator): Call `grok_method_quals' when
	QUALS is non-zero in declarator grokking loop.

Sat Nov  4 20:21:54 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-init.c (build_new): If TYPE_NEEDS_CONSTRUCTING (TYPE),
	then always wrap RVAL in an RTL_EXPR, since we don't know that we
	aren't one of the arms of a ?: operation.  RVAL can now be a
	SAVE_EXPR (normally) or a VAR_DECL (in the case of array
	initialization).

	* cplus-init.c (build_new): Fix braino that was causing array
	types to be collapsed into their element types, causing
	`build_new' to return a point to the element type, rather then a
	pointer to the array type.

	* cplus-decl2.c (grokfield): Check DECL_NAME (VALUE) before
	dereferencing it.

	* cplus-init.c (expand_vec_init): Do not fail to initialize
	element of an array which receive default initialization.

	* cplus-type2.c (digest_init): If TYPE needs constructing,
	don't convert INIT to TYPE.  The only time when this happens
	is when called upon to initialize an ARRAY_TYPE, and
	`expand_vec_init' will handle that case.

	* cplus-class.c (build_method_call): Error reporting for bad
	argument list was screwed for static member functions in static
	call context.

	* config.g++: Add MIPS-based configurations.

	* toplev.c: Make up for systems which do not have unistd.h (like
	many BSD systems).
	* Makefile: Add HAVE_UNISTD_H flag.

	* cplus-dem.c: Sequentize the code.

	* cplus-init.c (expand_cplus_expr_stmt): Warn if statement is just
	a reference to, and not a call of, some function.

Thu Nov  2 10:03:50 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-method.c (build_overload_name): Don't crash if we built a
	TREE_LIST which contains VOID_TYPE_NODE and which is not
	VOID_LIST_NODE.  This happens if one of the parameters is of type
	VOID_TYPE.

	* stmt.c (expand_return): Even when RETVAL has type VOID_TYPE, we
	must expand it (it may be a call to another void function).

	* integrate.c (copy_rtx_and_substitute): Moved one to many insns
	to BEFORE_INLINE_FP_RTX.

	* cplus-typeck.c (convert_for_initialization,actualparameterlist):
	Don't defaultly convert ARRAY_TYPE when converting to
	REFERENCE_TYPE.

Wed Nov  1 04:43:46 1989  Michael Tiemann  (tiemann at teacake)

	* stmt.c (init_function_start): Initialize MAX_PARM_REG to
	FIRST_PSEUDO_REGISTER.

	* cplus-init.c (expand_vec_init): This function can be called to
	initialize a non-aggregate vector.

Tue Oct 31 13:38:42 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-type2.c (process_init_constructor): Don't even try
	initializing a structure from EMPTY_INIT_NODE.

	* cplus-init.c (build_new): Handle case where SAVE_EXPR_RTL of
	new'd value is 0 by putting it CONST0_RTX.

	* cplus-typeck.c (build_component_ref): If the COMPONENT_REF is
	really a reference to a member function, do the right thing if the
	member function is virtual.

Mon Oct 30 00:39:18 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-class.c (build_method_call): Removed code that seemed to
	build (superflouously) an INDIRECT_REF for INSTANCE just before
	heading to found/found_and_ok (where INSTANCE was just
	reinitialized).  Also, fixed bug so that if INSTANCE was of fixed
	type, that fact remained known even if INSTANCE_PTR became more
	distanct due to going through a NOP_EXPR.

	* cplus-init.c (get_member_function): Add parameter EXP_ADDR_PTR
	which is a pointer to the tree representing the address of EXP.
	Also, add hairy code which does the right thing wrt. modifying
	`this' pointer when it is argument to call.
	@@ This modification causes GNU C++ to generate stupid
	conditional-branch code when optimizing.  Hopefully future
	versions of the optimizer will understand and optimize it.
	* cplus-typeck.c (build_x_function_call): Caller changed.

	* cplus-tree.h (lang_type): Added new field GOT_SEMICOLON to
	TYPE_FLAGS field, to record whether a type has been `finished' or
	not.  Attempt to catch bugs like `struct s { .. } main () { .. }'.
	* cplus-parse.y (various rules): Add call to `note_got_semicolon'.
	* cplus-decl.c (start_function): Check that we have a `finished'
	type.
	* cplus-lex.c (note_got_semicolon): Set the bit here.
	* cplus-class.c (finish_struct): Whenever we start afresh with a
	class type, zero the bit here.

	* cplus-type2.c: Rename file cplus-typeck2.c to fit brain-damaging
	SVID 14 char name limit.

	* cplus-typeck.c (build_modify_expr): Handle case where assignment
	comes from friend, rather than member function.

	* cplus-tree.c (lang_printable_name): Handle case where DECL's
	language specific field is nonexistent.
	* cplus-method.c (fndecl_as_string): Here too.

	* cplus-decl.c (finish_decl): Initialization of a reference from
	`*this' was falling down because nodes for `$this' were getting
	shared too much.

	* cplus-tree.h (TREE_HAS_CONSTRUCTOR): Reincarnate use of this
	flag--for SAVE_EXPR it means that underneath lies a call to
	`new' for a given type.
	* cplus-init.c (build_new): Set the flag.
	* cplus-method.c (dump_init): Test it.

	* cplus-tree.h (PARM_DECL_EXPR): Use this flag to distinguish
	parsing initializers for PARM_DECLs from initializers for global
	variables.
	* cplus-decl2.c (finish_file): Don't emit anything from
	STATIC_AGGREGATES that was really just for default parameters.
	* cplus-decl.c (grokparms): Set PARM_DECL_EXPR on SAVE_EXPRs.
	* cplus-method.c (dump_init): Same.

Sun Oct 29 23:23:48 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-method.c (build_opfncall): Don't check visibility here for
	operators `new' and `delete' unless within a constructor or
	destructor.
	* cplus-decl.c (finish_function): Add checks for visibility of
	those operators here instead.

	* cplus-decl2.c (groktypefield): Handle case where field name
	conflicts with a typedef.

Fri Oct 27 01:02:20 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-search.c (get_virtuals_named_this): Return a baselink
	instead of a FUNCTION_DECL.  Also, walk through FIELDS as
	baselinks.  I.e., use `next_baselink' instead of TREE_CHAIN.

	* cplus-search.c (get_first_matching_virtual): Caller changed.

Thu Oct 26 16:09:07 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-search.c (get_first_matching_virtual): Only complain about
	a particular property of a virtual function once.

	* cplus-class.c (finish_struct): If ASSOC winds up being zero,
	don't frob the vtable.

	* cplus-decl.c (shadow_tag): Handle case where exception does not
	have any fields.
	* cplus-parse.y (component_decl): Handle case where exception does
	not have any fields.

	* cplus-parse.y (structsp): Call `finish_exception' with only two
	parameters.

	* cplus-parse.y (stmt): Forgot ';' after `RAISE' stmt.

	* cplus-class.c: Gather statistics on number of elments in virtual
	function tables, number of entries we build for them, and number
	of virtual function table entries we search using linear lookup.

	* cplus-parse.y (aggr,opt.component_decl_list): Call
	`build_tree_list' instead of `decl_tree_list', because of nested
	structures.  Would be better to make TEMP_DECL_OBSTACK pushable
	like the momentary obstack, but we don't for now.

Tue Oct 24 06:26:13 1989  Michael Tiemann  (tiemann at arkesden)

	* integrate.c (copy_rtx_and_substitute): Don't change something to
	a memory address unless it really is `memory_address_p'.

	* cplus-decl.c (finish_decl): Handle array initialization if type
	of array needs constructor.  Also, implement initialization
	without INIT0 crutch.
	* cplus-init.c (expand_vec_init): Handle array initialization from
	{...} where type of array needs constructor.

	* cplus-typeck.c (build_binary_op_nodefault): Make compiler give
	error, not warning, if comparing pointers with integers.

	* cplus-typeck.c (build_component_ref): Call `lookup_fnfields' to
	get a list of methods.

Mon Oct 23 17:29:03 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-tree.h (lang_decl): Add bit `COMPILER_GENERATED' to
	indicate whether this FUNCTION_DECL was generated automatically by
	the compiler.
	* cplus-lex.c (cons_up_dtor_for_type): Set this bit.
	* cplus-decl.c (redeclaration_error_message): Give better error
	message if user redeclares something that was implicitly created
	by the compiler.

	* cplus-decl.c (finish_decl): Test DECL_LANG_SPECIFIC before
	testing DECL_IN_AGGR_P in case of init-free reference decl.

Sat Oct 21 10:29:09 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-class.c (build_method_call): Forgot to increment b_or_d as
	we go through class hierarchy.  Probably fell out as a result of
	`next_baselink' change on Friday, Oct 13.

	* cplus-cvt.c (build_up_reference): When calling
	`convert_to_nonzero_pointer', use TYPE_MAIN_VARIANT so that
	TYPE_POINTER_TO is defined.

	* cplus-search.c ({push,pop}_memoized_context): Plug memory leak
	by freeing pushing and popping the TYPE_OBSTACK irrespective of
	whether we are memoizing lookups or not.

	* cplus-decl2.c (grokclassfn): Don't make `this' TREE_READONLY
	inside of destructors.

	* cplus-search.c (get_abstract_virtuals): New function.  Returns
	the list of virtual functions that are considered abstract for a
	given type (i.e., those which are ` = 0' in declaration).
	* cplus-class.c (finish_base_struct): Call it.

	* All GNU C++ files: change names containing `UNINHERIT*' to names
	containing `ABSTRACT'.  Eliminate use of
	CLASSTYPE_HAS_ABSTRACT_VIRTUALS in favor of testing
	CLASSTYPE_ABSTRACT_VIRTUALS directly.

	* cplus-decl.c (start_function): Handle case where user names and
	internal names conflict.

	* cplus-typeck.c (build_conditional_expr): Put type instantiation
	back in.

	* cplus-decl.c (start_function): Use DECL_STATIC_CONTEXT instead
	of DECL_CONTEXT for pushing into context of static function.

	* cplus-decl.c (auto_function): Like `builtin_function', but
	builds an overloadable function.
	* cplus-decl.c (init_decl_processing): Call it for __builtin_new,
	__builtin_delete and similar functions.

Fri Oct 20 02:22:06 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-decl.c (finish_decl): Set TREE_USED bit of DECL if DECL is
	a const VAR_DECL at TOPLEVEL.

	* cplus-class.c (modify_vtable_entry): Still more fixes to code
	which computes derived vtable.

Thu Oct 19 11:14:55 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-class.c (finish_struct): Move code that sets
	TYPE_USES_MULTIPLE_INHERITANCE from here...
	* cplus-decl.c (xref_tag): ...to here.

	* cplus-decl.c (finish_decl): Oct 12 change to implement
	initialization of class members so that their initializers could
	use private members did not test DECL sufficiently.  In addition
	to checking DECL_CONTEXT, must also check that TREE_CODE (DECL) ==
	VAR_DECL.  Otherwise redeclaration of member functions cause
	crashes.

Tue Oct 17 03:34:05 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-method.c (hack_identifier): Use `error', not
	`error_with_decl' to report that a non-static member is being
	referenced in a static member function.

	* cplus-decl.c (duplicate_decls): TREE_INLINE was not being set
	for OLDDECL, which is really where it matters.

	* cplus-typeck2.c (merge_component_comparisons): Track TEM1 in
	addition to TEM0 in loop which computes BITPOS0.

	* cplus-decl2.c (grokfield): Set CLASSTYPE_LOCAL_TYPEDECLs from
	CURRENT_CLASS_TYPE rather than DECL_CONTEXT (VALUE), since the
	latter is not set up for TYPE_DECLs.

	* cplus-decl.c (xref_tag): Set CLASSTYPE_DECLARED_CLASS each time
	we see an xref to this tag until we see the actual type defined
	for this tag.

Mon Oct 16 01:48:27 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-tree.h (DECL_VIRTUAL_P): If set in an IDENTIFIER_NODE, it
	means that somebody has defined a virtual function with this name.
	* cplus-decl.c (grokfndecl): Set it.
	* cplus-search.c (get_first_matching_virtual): Use it.

	* cplus-decl.c (cplus-tree.h): Define DECL_EXTERNAL as synonym for
	TREE_LANG_FLAG_3, which means for a VAR_DECL to mean that `extern'
	was specified in for that VAR_DECL.
	* cplus-decl.c (grokvardecl): Set DECL_EXTERNAL.
	* cplus-decl.c (duplicate_decls): Set TREE_PUBLIC of `const'
	variables based on TREE_STATIC and DECL_EXTERNAL.

Sun Oct 15 00:44:01 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-decl.c (start_function): Set CURRENT_EXTERN_INLINE from
	TREE_PUBLIC of DECL1 if DECL1 came pre-parsed.

	* cplus-decl2.c (finish_file): Don't write out inline functions
	which had their address taken if they were declared
	`extern inline'.

	* cplus-decl.c (grokdeclarator): Don't set TREE_PUBLIC based on
	INLINEP here.  Also, don't treat RID_INLINE as being a storage
	class for `multiple storage classes' error message.
	* cplus-decl2.c (grokfield): Do it instead here.
	* cplus-init.c (do_friend): And here.
	* cplus-decl.c (duplicate_decls): And change this to more match
	how GCC does things.

	* cplus-lex.c [USG_STDIO]: Use this instead of USG, for turncoats
	who have enough of System V that their stdio is broken, and too
	much Berkeley for USG to be the right thing.

	* cplus-decl.c (grokdeclarator): Grok declarations of the form
	`X x(args)[size]' to mean ARGS is an initializer to the array
	constructor for X[SIZE].
	* cplus-decl2.c (finish_file): Handle new case.

	* cplus-method.c (build_opfncall): Don't abort if user makes a bad
	call to operator new.  It's not the compiler's fault.

	* cplus-init.c (finish_base_init): Unmark virtual baseclasses
	which have explicit initializers.

	* cplus-init.c (expand_aggr_init_1): Change PROTECT parameter to
	FLAGS parameter.  All callers changed.

	* cplus-decl.c (finish_function): In destructor code, it is
	CLASSTYPE_VSIZE, not TYPE_VIRTUAL_P, which is the operative
	value to test when building base destructor code.  See Sept 1
	change for more info.

	* cplus-parse.y (unary_expr): Arguments to build_vbase_delete were
	wrong: was passing POINTER_TYPE and address when should have been
	passing object type and object.

Sat Oct 14 06:45:34 1989  Michael Tiemann  (tiemann at arkesden)

	* stmt.c (expand_anon_union_decl): For anonymous unions in memory,
	don't call `change_address'.  Just cast the memory reference
	ourselves.

	* cplus-typeck2.c (store_init_value): Don't test PEDNATIC to see
	whether to permit initialization of static variable from
	non-constant, since C++ 2.0 defines it to work.

	* cplus-init.c (expand_aggr_init_1): PARM_SLOTS was allocating
	sizeof (char) instead of sizeof (struct rtx_def*).

	* cplus-decl.c (grokfndecl): Call to `get_first_matching_virtual'
	must be followed by code which, under certain cases, goes all the
	way down the inheritance hierarchy to match the virtual function.
	Otherwise, the wrong virtual function tables come in to play when
	the time comes to reconcile them (in modify_vtable_entry).  Note
	that the call to `get_first_matching_virtual' does the right thing
	within `finish_struct'.  In that case, since we pull BASE_FNDECL
	from a virtual base class's virtual function table, there is no
	issue where it should be thought of as coming from.

	* cplus-search.c (rank_mi_virtuals): Spurious TREE_TYPE made it
	look like we were trying to compare PARM_DECLs instead of _TYPE
	nodes in our list at some time.

	* cplus-search.c (get_first_matching_virtual): Friday the 13th
	change was wrong.  Instead, make `get_first_matching_virtual'
	handle the instance variable itself, and call `compparms' as
	before.

	* cplus-lex.c (reinit_parse_for_method): Null character was being
	inserted if USG hack to round up buffer length was being used.

	* cplus-class.c (compute_conversion_costs): When trying a type
	conversion, use the actual type that the function wants.  No
	reference-bashing here!

	* cplus-search.c: Add a new obstack BRIDGE_OBSTACK which contains
	the class declarations across scopes.  This is an alternative to
	building their lists on the permanant_obstack.
	* cplus-search.c (push_search_level): Record the obstack for which
	this level was pushed.
	* cplus-search.c (pop_search_level): Remove OBSTACK parameter.
	Get that value from the search level that is being popped.

	* cplus-tree.h (lang_type): Add a slot for the instance variable.
	* cplus-decl.c (start_function): Use it.

	* tree.c (build_nt0): New function.  Use this to build declarators
	instead of `build_nt'.  Uses new obstack `temp_decl_obstack'.

	* cplus-cvt.c (build_type_conversion): Distinguish void* from
	const void* if we are trying to convert from some arbitrary
	pointer to a void* variant.

	* cplus-class.c (finish_struct_bits): New function.  Code broken
	out of `finish_struct'.  Extend to handle both conversions to
	const pointers and conversions to non-const pointers.

	* cplus-tree.h (lang_type):  Extend to handle both conversions to
	const pointers and conversions to non-const pointers.

	* cplus-decl.c (start_function): FNTYPE was not re-set after
	calling `pushdecl'.  Consequently, static member functions with
	default arguments were breaking.

	* cplus-class.c (pushclass): When pushing tags into the class
	binding level, push the TYPE_DECL, not the _TYPE into the
	IDENTIFIER_CLASS_VALUE slot.

	* cplus-method.c (fndecl_as_string): Don't skip first parameter if
	FNDECL is a static member function.

	* gplus.gperf [CATCH]: Add it.

	* cplus-init.c (build_member_ref): Nodes returned from
	lookup_fnfields are not saved on the permanent obstack, regardless
	of CURRENT_OBSTACK.  This is usually ok, since they are usually
	only used as a structure through which search machinery will
	traverse looking for values that do live on the permanent obstack.
	One exception is when `build_member_ref' builds an expression
	which requires type instantiation at top-level.

	* cplus-decl.c (finish_decl): Give better error messages for
	initialization of references, and remove invalid messages as well.
	Initialization of type-qualified references is different than
	initialization of type-qualified pointers in the following way:
	you can initialization a `X&' from a `const X&', but you cannot
	initialize a `X*' from a `const X*'.  This is because the compiler
	can convert the `const X&' to a `const X', create a new temporary,
	and take a reference from that.

	* cplus-init.c (is_friend): In testing for friendly classes, allow
	for static member functions to be considered friends.

Fri Oct 13 00:03:18 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-decl.c (grokdeclarator): If DECL_CONTEXT is FIELD for
	building a TYPE_DECL, allocate using `build_lang_field_decl'
	instead of `build_decl'.

	* cplus-decl.c (xref_tag): Undo Sept 10 change.  It causes
	problems for InterViews.  Better to work around in ET++.

	* cplus-decl.c (lookup_name): When looking up NAME, if
	CURRENT_CLASS_TYPE is being defined, check its baseclasses for a
	definition of a TYPE_DECL.

	* cplus-decl.c (grok_enum_decls): Return DECL, not NULL_TREE if
	TYPE has already been recorded.

	* cplus-search.c (dfs_pushdecls): Push class-local TYPE_DECLs into
	IDENTIFIER_CLASS_VALUEs.

	* cplus-typeck.c (c_expand_return): Call `expand_cleanups_to' with
	NULL argument in case the return value generated cleanups for its
	call.

	* stmt.c (expand_anon_union_decl): Fixed so that MEM anon unions
	are correctly handled.

	* cplus-decl2.c (finish_anon_union): Handle non-global static
	anonymous unions.

	* cplus-decl.c (shadow_tag): Change int variable OK to enum
	tree_code OK_CODE, remembering the value of the code we though was
	ok.  This avoids being confused when other legitimate DECLSPECS
	(such as `static') appear after one like `union ...'.

	* cplus-class.c (popclass): When popping from a class's scope,
	back to another class's scope, restore CURRENT_VTABLE_DECL only if
	we had one before.

	* cplus-decl2.c (grokfield): Push TYPE_DECL into class level as
	soon as we see it.

	* cplus-class.c (instantiate_type): In ADDR_EXPR case, complain if
	type we are instantiating to is not POINTER_TYPE.

	* cplus-decl.c (start_method): Call `preserve_data' to save the
	parameters (which were read into the maybepermanent obstack).

	* cplus-typeck2.c (digest_init): Handle case of union with
	constructor.

	* cplus-init.c (build_member_ref): Vestigial bug from change in
	representation of method lists (from list of lists to list of
	chains).

	* cplus-class.c (instantiate_type): Rewrite TREE_LIST case to use
	`next_baselink' when appropriate, and to try overloading based on
	non-member functions if that looks appropriate.

	* cplus-search.c (next_baselink): New function.  Contains code
	broken out of `build_method_call' to advance to next chain of
	FUNCTION_DECLs.

	* cplus-init.c (build_member_ref): If member ref is a reference to
	non-unique member function, return a BASELINK (which is a list of
	lists) rather than a list containing just that type's methods with
	that name.

	* cplus-init.c (resolve_member_ref): Handle uninstantiated method
	types.

	* cplus-decl.c ({start,finish}_decl): Call pushclass/popclass for
	decls which are static class members, in order to perform
	visibility computations for initializers correctly.
	* cplus-decl.c (grokvardecl): If static class member, set
	DECL_CONTEXT of the decl to the containing class type.

	* cplus-search.c (get_first_matching_virtual): Must call comptypes
	starting from first parameter, not its TREE_CHAIN, since one
	version of the function may have a this which is `*const' while
	the other does not.

	* cplus-decl.c (finish_decl): Permit static class members of
	reference type to be uninitialized in class declaration.  They
	will get initialized elsewhere, presumably.

	* cplus-method.c (dump_type_prefix): `const' and `volatile' were
	being put in the wrong places.  Type like `const *const ...' were
	being dumped as `const const *...'.

	* cplus-decl2.c (finish_file): Don't try to initialize anything
	which has ERROR_MARK_NODE in its initializer.

Thu Oct 12 02:41:34 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-init.c (resolve_member_ref): Catch case when we are in
	static member function context by reference is to (apparently)
	non-static member.

	* cplus-method.c (fndecl_as_string): Check PARMTYPES before
	chaining down, in case of syntax error.

	* cplus-init.c (do_friend): Take QUALS parameter.  Needed for
	`grokclassfn'.  Also take CTYPE instead of CNAME parameter.
	* cplus-decl.c (grokdeclarator): Caller changed.

	* cplus-init.c (do_friend): Set DECL_CONSTRUCTOR_P bit if we get a
	constructor.

	* cplus-tree.c (layout_basetypes): Don't allocate a virtual
	baseclass pointer if we can share one with a non-virtual
	baseclass.

	* tree.c (make_node): Build PARM_DECL nodes on the
	maybepermanent_obstack, not on the permanent_obstack.

	* cplus-typeck.c (build_unary_op): If addressing a reference and
	the reference is a variable, we need to check DECL_INITIAL, in
	case the variable is being initialized by a function call at top
	level.

	* cplus-decl.c (grokdeclarator): Be more careful when looking for
	function name when giving error that parameter list is random.

	* cplus-decl.c (grokdeclarator): Change handling of STATICP for
	member functions.  Eliminate variable MEMFUNC_STATICP.

	* cplus-decl.c (init_decl_processing): Don't disable profiling
	anymore.

Wed Oct 11 05:37:12 1989  Michael Tiemann  (tiemann at arkesden)

	* c plus-except.c [_JBLEN]: More systems have more ways to fail to
	define this value.  Implement yet another way to get it.

	* cplus-typeck.c (build_component_ref): Have to really check
	whether FIELD comes from a virtual baseclass.

	* cplus-init.c (is_aggr_typedef): Renamed
	`is_aggr_typedef_or_else' to `is_aggr_typedef', and gave it
	OR_ELSE parameter.  All callers changed.
	* cplus-parse.y (member_init): Call `is_aggr_typedef' with zero
	value for OR_ELSE.  We just want to know if the member looks like
	a virtual baseclass member or not.

	* cplus-method.c (build_decl_overload): Handle case where error
	has us building an overloaded name for something with a signature
	of X::f (...).  That signature is technically erroneous, but can
	arise in the face of certain syntax errors.

	* cplus-lex.c (yylex): Handling of extern language strings was
	broken.  If we were unlucky and got a file name string while
	reading a declaration, it could cause YYLVAL.TTYPE to contain the
	filename, rather than the type that was read in.  Fixed by
	assigning to YYLVAL.TTYPE after checking for possible language
	string identifier.

	* cplus-init.c (build_new): We cannot expand `new' inside of base
	or member initializers, so instead put the expansion into an
	RTL_EXPR.  CURRENT_VTABLE_DECL is ERROR_MARK_NODE in that case.
	* cplus-parse.y (.set_base_init): Set CURRENT_VTABLE_DECL to
	ERROR_MARK_NODE to indicate we are in initialization.
	* cplus-class.c (build_vfn_ref): Don't use cached vtable if
	calling function from base or member initializer.

Tue Oct 10 22:47:47 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-typeck.c (unary_complex_lvalue): Can't take pointer to
	member through virtual baseclass.
	* cplus-typeck.c (convert_for_assignment): Same change.

	* stmt.c (assign_parms): Don't let BLKmode parameter get
	``rounded'' off its word boundary...`access_parm_map' does not
	know what to do if that should happen for an inline function.

	* cplus-decl.c (grokdeclarator): Distinguish STATICP, which has
	roughly the usual `C' meaning, from MEMFUNC_STATICP, which means
	that the declaration is a static member function.

Mon Oct  9 00:55:19 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-method.c (build_overload_name): Change naming scheme so
	that GNU calling convention (which passes objects in the stack) is
	distinct from cfront/PCC convention.

	* cplus-decl.c (push_overloaded_decl): Don't compare DECL_LANGUAGE
	of previously overloaded decl if it is not a FUNCTION_DECL.

	* cplus-decl.c (grokfndecl): Use parameter CHECK to control
	behavior of `grokclassfn' in non-constructor case (already used in
	constructor case).

	* cplus-class.c (finish_struct): Give warning if struct or union
	has no data members if PEDANTIC *or* EXTRA_WARNINGS.

	* cplus-typeck.c (convert_for_initialization): Don't forget to
	change TREE_READONLY VAR_DECLs into their constant initial value
	if they have one.

	* cplus-parse.y (.set_base_init): Change grammar to not go into
	error mode if a base initializer shows up for a non-member
	function.  Otherwise, compiler will push binding levels (in
	`start_function' and `store_parm_decls') which it will not pop,
	leaving us not at global_bindings_p at function end.

	* cplus-class.c (ideal_candidate): In the event that there is no
	ideal candidate, restore PARMS by moving value from TREE_PURPOSE
	values back into the TREE_VALUE slots.

Mon Oct  2 02:28:43 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-lex.c (cons_up_dtor_for_type): Call to `start_method'
	could yield VOID_TYPE_NODE in case of errors.  Handle that.
	* cplus-class.c (finish_struct): Caller of `cons_up_dtor_for_type'
	changed.

	* cplus-decl.c (pushtag): Don't call `pushdecl' on for tags which
	are TREE_NONLOCAL.
	* cplus-class.c (pushclass): Set TREE_NONLOCAL before calling
	`pushtag'.

Sun Oct  1 00:05:49 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-tree.h [DECL_VINDEX]: Change definition from being a
	FUNCTION_DECL to being a list of FUNCTION_DECLs, in the event that
	multiple baseclasses define the same virtual function.  This only
	affects code where DECL_VINDEX was assumed to be a FUNCTION_DECL,
	namely in cplus-decl.c (grokfndecl) and cplus-class.c
	(add_virtual_function).

	* cplus-typeck.c (convert_for_initialization): If we are
	converting to an ARRAY_TYPE, don't call `default_conversion' on an
	initializer which is also of ARRAY_TYPE.

	* cplus-decl.c (finish_decl): If FIELD_DECL is of type ARRAY_TYPE
	that has not yet been laid out, we must go through the code which
	calls `complete_array_type' for TYPE and `layout_decl' for DECL.

	* cplus-init.c (expand_aggr_init_1): See whether initializer can
	go through a type-conversion operator rather than an X(X&)
	constructor, since wel will save one constructor that way.  I.e.,
	trying to go through an X(X&) constructor may lead us to needing
	to go through a type-conversion operator, but the result of that
	conversion must still go through the original X(X&) constructor.

	* cplus-decl.c (finish_decl): For FUNCTION_DECLs with default
	argument, we build sub-FUNCTION_DECLs to catch calls to this
	function with fewer than the total number of arguments.  We set
	TREE_USED of the sub-FUNCTION_DECLs to keep GNU C++ from
	complaining about the function being when compiling with -Wall.
	We also need to set TREE_ASM_WRITTEN and DECL_INITIAL of the
	function to really ensure that GNU C++ does not spuriously
	complain about these sun-FUNCTION_DECLs.
	* cplus-decl.c (grokdeclarator): Set TREE_PUBLIC of after calling
	`grokfndecl' on all paths.

	* cplus-typeck.c (build_function_call): Set TREE_USED for
	FUNCTION_DECL if TREE_INLINE is zero.

	* cplus-decl2.c (grok_enum_decls): Move to cplus-decl.c since it
	now needs access to `struct binding_level'.
	* cplus-decl.c (grok_enum_decls): When looking for class-local
	enum tags, warning if we find them in a class binding level other
	than the current one.  It probably indicates a parse error in the
	file.

	* cplus-decl.c (lang_decode_option): Recognize new option
	-Wenum-clash, which gives warnings when enumeral types are
	used in suspect ways, such as assigning from one enumeral
	type to another.

	* cplus-typeck.c (message_2_types): Was previously called
	`error_2_types'.  Now takes argument PFN which is pointer to
	the function which will actually print the message.
	* cplus-typeck.c (convert_for_assignment): Give error for
	passing incompatible enums only if pedantic.  Otherwise, give
	warning.

	* cplus-init.c (finish_base_init): Add argument T which is the
	type for which the base initialization is being finalized.  When
	finished initializing fields which come from anonymous unions,
	call `finish_base_init' on that anonymous union, which will unmark
	interesting fields recursively.
	* cplus-decl.c (finish_function): Caller changed.

	* cplus-method.c (hack_identifier): Permit calls through
	REFERENCE_TYPE fields which overload `operator ()'.

	* cplus-cvt.c (convert): Remove warning ``assignment to virtual
	aggregate type''.

	* cplus-decl.c (finish_decl): Make sure to destroy function-local
	static objects if they had been initialized.  Set TREE_STATIC bit
	for elements of STATIC_AGGREGATES which are function-local
	objects.
	* cplus-decl2.c (finish_file): Rest of that implementation.

Sat Sep 30 20:34:52 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-typeck.c (actualparameterlist): Don't let objects with
	operator= or X(X&) constructors be passing into `...'.  If
	PEDANTIC, give error, otherwise, give warning.

	* cplus-typeck.c (convert_for_assignment): Get tougher on
	conversions to/from enumeral data types.

	* cplus-typeck.c (build_modify_expr): Make `operator=' an
	inheritable operator.

	* cplus-decl.c (push_overloaded_decl): Give error message if
	overloaded functions from different language contexts have the
	same type signature.

	* cplus-cvt.c (build_default_binary_type_conversion): If the types
	are not C++ types, then give error message saying that no type
	conversion operator exists.  Call function `typedecl_for_tag' to
	get name for error message.
	* cplus-decl.c (typedecl_for_tag): New function.  Return the
	TYPE_DECL (if any) assoicated with TAG.

	* cplus-class.c (build_functional_cast): Handle case where `A (B)'
	does not mean pass `B' to A's constructor, but rather call
	B.operator A ().

	* cplus-search.c (get_first_matching_virtual): If argument types
	differ only in their qualifiers, admit a match, but warn the user
	that this match was made.

	* cplus-lex.c (yyungetc): New function.  Give parser routines the
	ability to adjust input tokens if initial lexing was a little bit
	wrong.

	* cplus-method.c (build_overload_name): Distinguish reference
	types from non-reference types.

	* cplus-typeck.c (process_init_constructor): Give error messages
	about types of objects which cannot be initialized from an
	initializer list.

Wed Sep 27 00:22:16 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-class.c, cplus-init.c (various places): Handle cases that
	fields of struct are really local type declarations.

	* cplus-decl2.c (grokclassfn): Added new parameter CTYPE, in order
	to remove dependence on class name-class type equivalence.  This
	was done for exception handling.
	* cplus-decl.c, cplus-init.c, cplus-except.c: All callers changed.
	* cplus-lex.c (cons_up_dtor_for_type): Added parameter NAME, for
	same reason.
	* cplus-class.c (finish_struct): Caller changed.

	* cplus-decl.c (duplicate_decls): If OLDDECL's type must change,
	remove OLDDECL from STATIC_AGGREGATES if it was there.
	* cplus-decl2.c (finish_file): Handle VARS being ERROR_MARK_NODE.

	* cplus-class.c (build_method_call): When calling `build_new',
	pass BASETYPE, not NAME, as the thing to be new'd.

	* cplus-parse.y (raise_identifiers): Permit qualified names, i.e.,
	`raises List::NotFound'.
	* cplus-decl.c (grokdeclarator): Handle nested exception scopes.
	* cplus-except.c (finish_exception_decl): Ditto.
	* cplus-class.c (build_method_call): Ditto.

	* cplus-except.c (init_exception_processing): Build in `setjmp'
	and `longjmp'.

	* cplus-except.c (expand_cplus_{start,end}_exception): If the
	exception object has elements which need cleanpus, call those
	cleanups after handling the exception.

	* cplus-except.c (finish_exception_decl): Set TYPE_HAS_CONSTRUCTOR
	bit, since call to `grokdeclarator' is subverted.

	* cplus-except.c (init_exception_processing): Size of `handler'
	field in built-in `ExceptionHandler' type was too big by one.

	* cplus-init.c (build_delete): Don't call non-virtual destructor
	with first argument of zero.

	* cplus-parse.y (except_stmts): Handle default exception as last
	exception (so that fall-through does the right thing).  Also, give
	error message if multiple `default' clauses appear within an
	`except_stmt'.

	* cplus-decl.c (finish_decl): If a variable needs a cleanup, pass
	the cleanup to `expand_decl', whether or not that variable has RTL
	or not.
	* cplus-except.c (expand_start_try): Call `finish_decl' instead of
	`expand_aggr_init' to initialize the exception handler for the
	try.  Otherwise, the exception handler's destructor will not be
	called at the end of the try.

	* cplus-decl.c (store_parm_decls): Don't call `__main' from `main'
	until after the parameters have been dealt with.

Tue Sep 26 09:41:29 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-parse.y (stmt): Deal with case of TRY statement without
	corresponding EXCEPT clause.

	* cplus-decl.c (duplicate_decls): Don't call `compexcepttypes'
	until after calling `commontype', lest default parameters cause
	identical exception lists to look different.

	* cplus-except.c (end_exception_decl): New function clears
	exception declaration state.
	* cplus-parse.y (datadef): Call end_exception_decl when we are at
	the end of a declaration which could be an exception declaration.

	* cplus-class.c (modify_vtable_entry): Reenable stubbed out code
	which is used when baseclass is virtual.
	* cplus-class.c (finish_struct): When base class is virtual, check
	CLASSTYPE_VBASECLASSES using `value_member' instead of
	CLASSTYPE_ASSOC using `assoc_value'.

	* dbxout.c (dbxout_tags): Ensure that fully output types have
	their typedefs output as well.  Needed to support -fminimal-debug.

Sun Sep 24 11:22:41 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-method.c (report_type_mismatch): Don't tweak I if the
	function was FUNCTION_TYPE.  Let TTF and TTA be advanced according
	to CP->U.BAD_ARG only.

	* expr.c (expand_expr): PROTECT argument missing in call to
	`expand_delete'.
	* cplus-init.c (build_delete): Call `convert_force' instead of
	`convert' if PROTECT is 0.

	* cplus-typeck2.c (digest_init): When initializing a RECORD_TYPE
	object, call `convert_for_initialization' as a last resort.

	* cplus-tree.c (build_exception_variant): Used TREE_CHAIN for look
	when should have used TYPE_NEXT_VARIANT.

	* cplus-decl.c ({start,finish}_decl): Handle decls which are
	CLASSTYPE_DECLARED_EXCEPTION.  For `start_decl', nothing needs to
	be done.  For `finish_decl', call `finish_exception_decl'.

	* cplus-except.c (finish_exception): When user defines an
	exception, make the compiler generate that exception's constructor
	automatically.

	* cplus-typeck.c (build_binary_op_nodefault): Associate
	(((a && b) && c) && d) to ((a && b) && (c && d)) to get better
	merging of component references when possible.
	* cplus-typeck2.c (merge_component_comparisons): Permit
	non-contiguous bitfield tests if bitfields are comparisons against
	integers.

	* cplus-tree.c (layout_basetypes): Give each basetype the
	alignment it wants.

	* cplus-lex.c (yylex): Recognize >?= and <?= operators (like +=
	for min and max operators).

	* cplus-decl.c (grokdeclarator): Set TREE_PUBLIC bit of
	FUNCTION_DECLs in FIELD_CONTEXT if they are !INLINEP.

	* cplus-decl.c (finish_function): Don't pay attention to
	`current_function_returns_null' when compiling constructors.

Sat Sep 23 00:03:52 1989  Michael Tiemann  (tiemann at arkesden)

	* stmt.c (assign_parms): Take care of case where parm arrives on
	the stack, but `__builtin_saveregs' might be called.  In that
	case, get bits from stack into registers, so that
	`__builtin_saveregs' will not overwrite with garbage.
	* expr.c (expand_builtin): Modify expansion of BUILT_IN_SAVEREGS
	to protect stack args that need protecting.

	* cplus-decl.c (grokdeclarator): Never build a METHOD_TYPE if
	CTYPE is NULL_TREE.  Was doing that when declaration of illegal
	construct ``virtual friend'' was parsed.

	* cplus-parse.y (do_array:): Don't try to call `build_array_ref'
	if $3 is ERROR_MARK_NODE (cuts down on spurious error messages).

	* cplus-decl.c (grokfndecl): Move setting of DECL_VIRTUAL_P bit to
	after we know whether the function is virtual.  Remove setting
	CLASSTYPE_VSIZE.  This will be set more accurately by
	`finish_struct'.

Fri Sep 22 15:36:32 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-cvt.c (convert_to_pointer): PATH was reversed for
	computing nested virtual base accesses.

	* cplus-except.c (finish_exception): Call POPCLASS at end.

	* cplus-class.c (build_field_call): New function containing code
	broken out of `build_method_call'.  Extended to grok calls through
	fields of exception objects which overload `operator()()', or are
	otherwise callable.
	* cplus-class.c (build_method_call): Now about 100 lines shorter.

	* cplus-decl.c (grokdeclarator): Take new argument RAISES
	specifying the exceptions that a function will raise.
	* cplus-decl.c (grokfield): Implement RAISES semantics by passing
	them to `grokdeclarator'.

	* cplus-decl.c (grok{fn,var}decl): Two new functions containing
	code broken out of `grokdeclarator'.
	* cplus-decl.c (grokdeclarator): Now about 250 lines shorter.

Thu Sep 21 16:51:11 1989  Michael Tiemann  (tiemann at arkesden)

	* cplus-search.c (get_vbase_types): Sort was totally broken.
	Completely rewritten.

Wed Sep 20 00:47:36 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-decl2.c (finish_file): Change !defined(SDB_DEBUGGING_INFO)
	to defined(DBX_DEBUGGING_INFO).

	* cplus-class.c (finish_struct): Argument to `alloca' was off by
	9.

	* cplus-init.c (build_new): If type requires alignment >
	BITS_PER_WORD (which is what ``__builtin_new'' is supposed to
	give), then get more space and round manually.

Tue Sep 19 03:08:58 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-decl.c (finish_decl): Don't call `comptypes' if INIT is
	error_mark_node.

	* cplus-cvt.c (convert_to_reference): Set TREE_VOLATILE bit for
	assignment from one reference to another (for
	build_compound_expr).

	* cplus-decl2.c (finish_file): If we are compiling on Suns, bind
	local label ``_fini'' to static file cleanup function and
	``_init'' to static file initialization function. STUBBED OUT FOR
	NOW.

	* cplus-parse.y: Put `type_quals' in 3rd operand position of a
	CALL_EXPR.  Interface to `start_function', `start_method'
	and `grokfield' changed.
	* cplus-decl.c (grokdeclarator): Get QUALS from
	TREE_OPERAND (CALL_EXPR, 2). [n.b.: First operand is
	TREE_OPERAND (CALL_EXPR, 0)].

	* cplus-tree.h (TYPE_RAISES_EXCEPTIONS): For FUNCTION_TYPE and
	METHOD_TYPE, a list of the exceptions that may be raised.
	* cplus-decl.c (duplicate_decls): Remove assumption that
	TYPE_LANG_SPECIFIC implies that type IS_AGGR_TYPE.

Mon Sep 18 14:08:02 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-class.c (add_virtual_function): If WRITE_VIRTUALS == 2,
	only set the TREE_ADDRESSABLE bit on a virtual function if the
	virtual function table is actually being output in this file.
	* cplus-decl.c (grokdeclarator): If WRITE_VIRTUALS == 2, make
	inline virtual functions TREE_PUBLIC if we are writing out this
	virtual function's virtual function table.
	* cplus-lex.c (reinit_parse_for_method): Don't clobber the above
	setting of TREE_PUBLIC for virtual functions.

	* cplus-lex.c: Process inline functions in declaration order.

Sun Sep 17 01:46:14 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-declc. (grokdeclarator,start_method,start_function): Merge
	``extern inline'' change.

	* cplus-typeck2.c (merge_component_comparisons): New function.
	Optimizes operations on contiguous component references provided
	that operations and alignments permit.
	* cplus-typeck2.c (make_merged_ref): Subroutine of above function
	to actually get the combined references.

	* cplus-typeck2.c: New file.  Contains error-reporting
	functionality from cplus-typeck.c, and other functionality which
	could be easily moved out.

	* cplus-typeck.c (unary_complex_lvalue): Must test against
	{FUNCTION,METHOD,OFFSET}_TYPE before testing whether ARG is a
	MEMBER_REF.  If the former holds, then we have an expression like
	X::Y.  In the latter case, we have an expression like (X->*Y).

Sat Sep 16 11:31:21 1989  Michael Tiemann  (tiemann at teacake)

	* toplev.c (main): Recognize `+' options again.

	* cplus-decl.c (lang_decode_option): Implement `+e2' option, which
	writes out only virtual function tables specified in #pragma
	vtable.
	* cplus-decl2.c (finish_file): Implement semantics of `+e2'
	option.
	* cplus-lex.c (yylex): Recognize `#pragma vtable'.

	* cplus-decl2.c (finish_file): Charge time used against
	VARCONST_TIME, not PARSE_TIME.

Thu Sep 14 18:04:10 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-init.c (build_new): If FLAG_THIS_IS_VARIABLE is non-zero,
	then generate call to constructor with zero as first argument.
	Otherwise, use `expand_aggr_init' to initialize the storage
	returned from whatever storage allocator was called.
	Initialization of virtual baseclasses simplified.  Memory
	management made more complex (though more general) because we may
	have `new' expressions not being evaluated until `finish_file' is
	called.
	* cplus-decl2.c (finish_file): Handle a `new' expreesion at top
	level.

	* cplus-decl.c (finish_function): Change call from `build_x_new'
	to `build_new'.
	* cplus-init.c (build_x_new): Deleted.

	* cplus-init.c (build_new): Give error if arguments are given to a
	`new' expression for which no constructor is defined.

	* cplus-decl.c (decode_lang_option): Use option table from
	toplev.c to decode -f options.

	* cplus-method.c (flush_repeats,build_overload_name): Change
	naming convention to avoid ambiguous names if type index or number
	of repeats is more than nine.

	* cplus-except.c (init_exception_processing): Use <setjmp.h> to
	find length of setjmp buffer.

Wed Sep 13 05:32:50 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-decl.c (start_method): Set TREE_INLINE bit if
	FLAG_DEFAULT_INLINE is nonzero.
	* cplus-decl.c (lang_decode_option): Recognize -fdefault-inline.

	* cplus-init.c (do_friend): Call `pushdecl_top_level' instead of
	`pushdecl'.

	* cplus-decl.c (start_method): Only need to copy node if it is not
	a friend.
	* cplus-decl.c (finish_method): In that case, return
	VOID_TYPE_NODE if the method was really a friend, but save it to
	CLASSTYPE_INLINE_FRIENDS so it can be processed properly later.
	It would be nice to have an obstack for this list so it could be
	freed at the end of this class's processing.

Tue Sep 12 05:22:03 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-decl.c (start_function): Make C++ FUNCTION_DECL inherit
	DECL_ASSEMBLER_NAME from old C FUNCTION_DECL if their types are
	identical.  This makes C<->C++ calls *much* easier to deal with.

	* cplus-decl.c (xref_tag): Don't set CLASSTYPE_DECLARED_CLASS bit
	if REF is CURRENT_CLASS_TYPE (??? or on the CURRENT_CLASS_STACK).

	* cplus-search.c (lookup_field_1): Give the user the virtual
	function table field if the name is `_vptr'.
	* cplus-decl2.c (grokfield): Don't let user declare anything with
	that name.

	* cplus-cvt.c (build_type_conversion): If we are trying to convert
	to type `void*' and no conversion to ptr_type_node exists, but a
	some other pointer conversion for TYPE exists, then convert to
	that pointer type, unless there is more than one such conversion,
	in which case return ERROR_MARK_NODE.  The caller will emit an
	error message in that case.  All callers changed.
	* cplus-cvt.c (convert_to_{integer,real,pointer}): Removed `saving
	throw' case which would try converting aggregate to a default type
	if requested conversion did not succeed.  `build_type_conversion'
	knows how to perform such `saving throws'.
	* cplus-tree.h (lang_type): New field `ptr_type_conversion'.
	* cplus-decl.c (grokdeclarator): Record whether a type has a
	type conversion operator here.
	* cplus-class.c (finish_struct): Set up `ptr_type_conversion'.
	Also, don't need to trudge through all methods to find out there
	are no type conversion methods.

Mon Sep 11 10:45:01 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-class.c (finish_struct): If we must cons up a destructor
	for a type, and METHOD_VEC was 0, set TREE_VEC_LENGTH (METHOD_VEC)
	to 1 after allocating METHOD_VEC.

	* cplus-class.c (finish_struct): Finish processing METHOD_VEC
	before making other calls out which may call `hash_tree_chain'.

	* cplus-class.c (finish_struct): Add BASE_LAYOUT_DECL to eliminate
	need for callback in stor-layout.c.

	* cplus-typeck.c (build_binary_op): Special case situation where
	we compare ARG1 with INTEGER_ZERO_NODE and ARG1 is of aggregate
	type.  This is what comes from `truthvalue_conversion'.

	* cplus-cvt.c (build_type_conversion): New argument CODE says for
	what purpose the conversion is taking place.  Important ones are
	truthvalue operations, which permit us to convert to different
	types then the ones we asked for.  All callers changed.
	* cplus-cvt.c (build_default_{binary,unary}_type_conversion): Same
	change.  All callers changed.

	* cplus-class.c (finish_{base_}struct): Set
	TYPE_NEEDS_CONSTRUCTING bits when basetype or member type needs
	constructing.

	* cplus-search.c (compute_visibility): Use TYPE_MAIN_VARIANT to
	see if field is public member of private baseclass.

	* cplus-init.c (expand_aggr_init_1): When bad arguments were
	passed to constructors for base initialization, only half the
	error message would appear.

	* Makefile: Remove dependencies on unexec.c and unex-addr.c.

	* cplus-decl.c (push_overloaded_decl): Can't use `value_member' to
	find previously declared function.  Use DECL_NAME of function
	instead, since that must be unique (as a type signature/name
	combination).

	* cplus-lex.c (yylex): typo in assert macro.
	* cplus-cvt.c (convert_to_nonzero_pointer): Ditto

	* All GNU C++ files: implement initialized constant fields.  Make
	them non-static, non-addressable VAR_DECLs.

Sun Sep 10 09:19:22 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-method.c (build_opfncall): Remove METHOD_REF case.
	* tree.def: Remove definition of METHOD_REF.

	* cplus-decl.c (finish_decl): If a static member needs
	constructing, but it does not have an initializer, make it
	TREE_EXTERNAL.
	* cplus-decl2.c (grokfield): Set DECL_IN_AGGR_P before calling
	`finish_decl' for VAR_DECLs.

	* cplus-parse.y (forhead.2): New rule to keep GNU C++ gives better
	error handling when multiple variables are declared in the first
	part of a `for' stmt.

	* cplus-lex.c (finish_method): Handle case when `start_method'
	returns VOID_TYPE_NODE (two definitions of the same method in the
	same class.

	* cplus-decl.c (grok_op_properties): Make static operators (other
	than new and delete) trigger error messages.  If operator new or
	delete has no arguments (due to syntax errors), rebuild their
	types.  They have the right names, because `build_operator_fnname'
	knows how to do that.

	* stor-layout.c (make_{un}signed_type): Cache size nodes for
	pointers, functions, and methods.
	* stor-layout.c (layout_type): Use cached types.

	* cplus-decl{2}.c: Use `hash_tree_chain' instead of `tree_cons'
	where possible.

	* cplus-decl.c (expand_static_init): If variable has already been
	initialized, give complaint, but don't store the initializer.
	That way we don't have to preserve it on the temporary obstack.

	* cplus-parse.y (identifier_or_opname): Accept new C++ destructor
	syntax, which is effectively "scoped_identifier '~' identifier".
	* cplus-class.c (build_scoped_method_call): Accept calls using new
	C++ destructor syntax here.
	* cplus-class.c (build_method_call): Reject calls through here
	which don't use a leading `scoped_identifier'.

	* cplus-init.c (build_new): Don't permit arrays of `void'.  Better
	error message emitted for newing `void'.

	* cplus-typeck.c (build_conditional_expr): Don't call
	`default_conversion' on the arms of the conditional if both are of
	the same enumeral type.  Otherwise, if EXTRA_WARNINGS, give
	warning if enumeral type appears in either (or both) arm(s) of the
	conditional.

	* cplus-cvt.c (build_type_conversion): Don't convert from `int' to
	`void*'.  Don't convert a `void*' to an `int'.

	* cplus-decl.c (xref_tag): If we get an old reference to a C
	struct name, and we are in C++ langauge context, give it a
	TYPE_DECL.

	* cplus-class.c (build_method_call): Don't call
	`default_conversion' on MEMBER_REFs because they might be enums.
	Instead, call `resolve_member_ref', and then if the type is
	something we would rather convert before calling
	compute_conversion_costs, convert that.

	* cplus-init.c: Set TREE_VOLATILE bit after all
	``build (CALL_EXPR, ...)'' calls.

	* cplus-init.c (expand_vec_init): If at global binding level,
	return a TREE_VEC which contains the initialization parameters for
	the vector.  `expand_vec_init' is no longer static.
	* cplus-decl.c (finish_decl): Handle INIT being result of
	`expand_vec_init' at top-level.
	* cplus-decl2.c (finish_file): Ditto.

Sat Sep  9 12:44:48 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-class.c (finish_struct): Move error message about static
	members in unions from stor-layout.c to here.

	* varasm.c, stor-layout.c: Merged with GCC.
	* cplus-class.c (finish_struct): Use special FIELD_DECL in
	TYPE_FIELDS of T before calling `layout_type' to have effect of
	passing basetype layout information to `layout_record'.

	* cplus-typeck.c (build_c_cast): Typo in call to
	cleanup_after_call.

Fri Sep  8 11:16:01 1989  Michael Tiemann  (tiemann at teacake)

	* All GNU C++ files: replaced calls to `abort' with assertion
	macros where appropriate.  Also removed some unneccessary tests
	against ERROR_MARK_NODE in various function calls.

	* cplus-lex.c (check_newline): Changed to take NEXTCHAR into
	account.

Thu Sep  7 06:15:56 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-decl.c (store_parm_decls): Change where
	DECL_REFERENCE_SLOT is initialized.  Eliminate a second loop
	through the parms.

	* cplus-method.c (hack_identifier): Don't need to test against
	FUNCTION_DECL before testing if the TREE_TYPE is REFERENCE_TYPE.

	* cplus-lex.c (yylex): If reading `0' or `1', return
	INTEGER_ZERO_NODE or INTEGER_ONE_NODE respectively.
	* cplus-decl.c (build_enumerator): If we got one of these two
	as a value, make a copy.

	* tree.c,cplus-lex.c,cplus-class.c,cplus-search.c
	[GATHER_STATISTICS]: Now only gather statistics if this macro is
	defined.

	* tree.c (make_node,build_int_2,tree_cons,build_tree_list): Merge
	Bryan Boreham's ``deluxe'' memory profiling code.

	* cplus-decl.c (finish_decl): Only complain about uninitialized
	refs and consts if there is no constructor for the type.  If there
	is a constructor, then that constructor should say whether it did
	not initializer certain fields or not.

	* cplus-init.c (expand_aggr_init): When initializing, nothing is
	`const'.

	* cplus-decl.c (store_parm_decls): No need to call
	expand_decl_init on a PARM_DECL.  In fact, now it is wrong.

	* tree.h: rearranged tree_decl layout and defined
	tree_function_decl type for FUNCTION_DECLs.  Now space
	requirements for FUNCTION_DECLs do not impose on other kinds of
	_DECL nodes.  Also, PARM_DECL nodes use less than a full decl
	node's worth of space.
	* toplev.c (rest_of_decl_compilation): Don't permit ASMSPEC to
	appliy to PARM_DECL nodes.
	* varasm.c (make_decl_rtl): Abort if called for a PARM_DECL node.
	* print-tree.c (dump): PARM_DECL nodes are not full.
	FUNCTION_DECL nodes have more fields then regular _DECLs now.
	* tree.c (make_node): Use TREE_CODE_LENGTH when allocating _DECL
	nodes.  Also, don't set DECL_SOURCE_* for PARM_DECL nodes.
	Instead, set their DECL_CONTEXT to CURRENT_FUNCTION_DECL.
	* tree.c (build_decl): Don't set DECL_ASSEMBLER_NAME for PARM_DECL
	nodes.
	* cplus-decl.c (start_decl): Don't not push DECL if DECL is a
	PARM_DECL.

	* cplus-lex.c (yylex): Remove tests about whether we *really* saw
	a keyword or not.  Instead, use `init_lex' to do most of the work
	for us (since lang_c's reserved word set is a subset of
	lang_cplusplus).

	* cplus-decl.c,cplus-decl2.c,cplus-typeck.c,cplus-class.c,
	cplus-lex.c, cplus-method.c: change tests of the form
	(TREE_VALUE (t) == void_type_node) to (t == void_list_node).

	* cplus-decl2.c (grokopexpr): Added argument CTYPE to help
	distinguish whether operators NEW and DELETE belong to a class, or
	are the global operators NEW and DELETE.
	* cplus-decl.c (grokdeclarator): Caller changed.
	* cplus-method.c (hack_operator): Caller changed.

Wed Sep  6 10:29:45 1989  Michael Tiemann  (tiemann at teacake)

	* dbxout.c (dbxout_type): Handle static member functions.

	* cplus-typeck.c (c_expand_return): Change test from
	TYPE_NEEDS_CONSTRUCTING to TYPE_NEEDS_CONSTRUCTOR to see whether
	`expand_aggr_init' must be called.

	* cplus-decl2.c (grokfield): Use `digest_init' to digest
	CONSTRUCTOR initializers of fields.

	* cplus-decl.c (grokdeclarator): Permit ARRAY_TYPE field decls to
	get their types from their initializer (if they were incomplete).

	* cplus-lex.c (build_operator_fnname): If there is more than one
	parameter to NEW_EXPR, then it is `__user_new'.

	* cplus-decl.c (store_parm_decls): Remove code to deal with case
	that function was declared without prototypes.  It is never
	executed.

	* cplus-typeck.c (unary_complex_lvalue): Handle (x->*y) as an
	lvalue.

	* cplus-decl.c (start_decl): Put in check that temporary obstack
	starts out empty when we start parsing an initializer.
	* cplus-decl.c (expand_static_init): If the initializer was read
	into the temporary obstack, preserve all space that it used.  I
	don't think it is safe to always read the initializer into the
	permanent_obstack and then free the space if it doesn't look
	interesting, because types may be created dynamically as a result
	of reading it in (such as array types), and we don't want them to
	get freed.

	* cplus-decl.c (finish_decl): Don't set DECL_ASSEMBLER_NAME of the
	decl to ASMSPEC if ASMSPEC is 0.

	* cplus-decl.c (finish_function): Set named_label_uses to
	NULL_TREE at end of function.

Tue Sep  5 05:24:18 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-except.c: New file.  Implements exception handling scheme
	designed by Michael Powell.

	* cplus-method.c (build_overload_name): Overload constructor names
	as '__' instead of whatever their original name was.
	* cplus-method.c (build_decl_overload): Distinguish constructors
	from other kinds of member functions.
	* cplus-decl2.c (grokclassfn): Call changed to
	`build_decl_overload' to take this into account.

	* cplus-decl.c (duplicate_decls): Don't crash if NEWDECL is a
	VAR_DECL, and there is an old VAR_DECL on the chain.  Happens for
	strange parse errors.

Mon Sep  4 01:36:07 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-decl2.c: New file.  Contains functions which used to be
	defined in cplus-decl.c, but could be easily broken out. Also
	moved some functions out of cplus-tree.c which did not really
	belong there, but were put there to make compilation less painful.

	* cplus-class.c (build_method_call): Use ERR_NAME in more places
	when printing error messages.

	* cplus-decl.c (grokdeclarator): Special case NEW_EXPR and
	DELETE_EXPR when grokking an OP_IDENTIFIER.  Make these guys
	static member functions.  Callers in cplus-init.c changed.
	* cplus-tree.c (coerce_new_type,coerce_delete_type): Force the
	type of `operator new' and `operator delete' to wind up with the
	right types.
	* cplus-lex.c (build_operator_fnname): Handle `operator new' and
	`operator delete' correctly, warning when the wrong number of
	parameters show up.

	* expr.c (expand_expr): Add NEW_EXPR to the list of tree codes
	for which INIT_EXPR and MODIFY_EXPR don't need to deal with
	noncopied_parts.

	* cplus-class.c (finish_struct): Initialize TREE_PURPOSE of
	TYPE_NONCOPIED_PARTS to the virtual function table for the type.

	* cplus-cvt.c (build_type_conversion_1): Compiler was getting into
	infinite recursion when asked to convert something from its own
	type to its own type.

	* cplus-parse.y: Added RERAISE statement.
	* cplus-lex.c: Added __reraise keyword.

	* cplus-cvt.c (build_type_conversion): Build type conversions to
	type variants (i.e., given `operator char * ()', convert to a
	`const char *').

	* dbxout.c (dbxout_tags): Callback to language-specific files to
	see whether a type should actually be output.
	* dbxout.c (dbxout_symbol): Same change.
	* cplus-tree.c (lang_output_debug_info): New function.
	* cplus-decl.c (finish_function): Memoize information for
	lang_output_debug_info.

	* Merged latest changes from Bryan Boreham for incremental
	compilation via dumping.

	* cplus-parse.y: Recognize `::new' and `::delete'.
	* cplus-init.c (build_new): Handle `::new' by new interpretation
	of USER_PARMS.  Only callers in cplus-parse.y needed changing.
	* cplus-init.c (build_{x_}delete): Handle `::delete' by accepting
	new argument USE_GLOBAL_DELETE.  All callers changed.

Sun Sep  3 12:42:38 1989  Michael Tiemann  (tiemann at teacake)

	* expr.c (expand_cleanups_to): New function.
	* cplus-init.c (expand_cplus_expr_stmt): Call it after all is said
	and done.

	* expr.c (expand_expr): When encountering a NEW_EXPR, it is
	possible that the NEW_EXPR did not know (when it was built) what
	its cleanup needed to be.  If its cleanup is 0, try building one
	if a new temporary was built for it.

	* cplus-decl.c (duplicate_decls): Warn if function type qualifiers
	don't match only if PEDANTIC (following change made by rms).

	* cplus-typeck.c (build_function_call): If pedantic, don't permit
	`main' to be called.

	* cplus-typeck.c (convert_for_assignment): Don't let ints
	convert to enums.

	* cplus-decl.c (start_function): Ensure that `main' is
	always declared to return an integer type.
	* cplus-decl.c (finish_function): Make it so that `main' always
	returns 0 by default.

	* cplus-decl.c (grokdeclarator): Make it now an error to specify
	return types for constructors and destructors.

	* cplus-typeck.c (comp_target_{parms,types}): Loosen up to permit
	contravariance violations, though not without warning.

	* cplus-method.c (build_overload_name): Change from old
	overloading scheme to one more or less compatible with type-safe
	linkage scheme proposed in Stroustrup's 1988 USENIX paper.

Sat Sep  2 09:16:01 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-typeck.c (convert_for_initialization): Permit
	initialization of reference from incomplete type: that type will
	be converted to REFERENCE_TYPE, and that is just as good as a
	pointer to incomplete type.

	* cplus-decl.c (finish_decl): Handle case of static reference
	initialized from non-constant initializer.  Break out code to
	initialize static variables as function `expand_static_init'.

	* cplus-decl.c (finish_decl): Don't call constructors on external
	variables.

	* integrate.c (copy_for_inline): Canonicalize PLUS expressions so
	that CONST_INTs appear on the right, and `FRAME_POINTER_RTX'
	and/or `ARG_POINTER_RTX' on the left.
	* integrate.c (copy_rtx_and_substitute): Take advantage of this
	fact and test fewer things while integrating.

	* cplus-typeck.c (c_expand_return): Try to get away with not
	issuing a call to `use_variable' for the DECL_RESULT of the
	function.  If that fails, calling it only if
	`any_pending_cleanups' returns nonzero.

	* cplus-init.c (expand_recursive_init_1): Handle multi-demensional
	arrays which need constructing.
	* cplus-init.c (expand_vec_init): Handle multi-demensional arrays.
	Say sorry if we try to use an explicit initializer in that case,
	however.

	* cplus-parse.y: Permit the integer zero to be deleted (though who
	would want to?).

	* varasm.c (make_function_rtl): Replace call to lang_rtl_name with
	use of DECL_ASSEMBLER_NAME.
	* cplus-decl.c (lang_rtl_name): Removed.

	* cplus-decl.c (grokclassfn): Set DECL_ASSEMBLER_NAME after
	changing DECL_NAME.
	* cplus-init.c (do_friend): Ditto.

	* cplus-decl.c (start_function): If CURRENT_FUNCTION_DECL is a
	destructor, set up DESTRUCTOR_LABEL.
	* cplus-decl.c (finish_function): If DESTRUCTOR_LABEL is nonzero,
	expand just before calling base destructors.
	* cplus-typeck.c (c_expand_return): If DESTRUCTOR_LABEL is
	nonzero, jump there instead of just expanding the return.

	* collect.c (process): Change from
	(andrew%frip.wv.tek.com@relay.cs.net) to skip auxiliary entries.

	* All GNU C++ files merged from 1.35.97+ to 1.35.98.

	* cplus-decl.c (define_label): If a newly declared variable in the
	label's binding contour will need a cleanup, it must live in a new
	binding contour.
	* cplus-decl.c (define_case_label): New function.  Same goes for
	case labels.
	* cplus-parse.y (stmt): Call `define_case_label' for CASE
	statements.

	* cplus-decl.c (lookup_label): Record in variable NAMED_LABEL_USES
	for each label the variables currently in scope at the use of the
	label.
	* cplus-decl.c (define_label): Give error message if jump to label
	crosses variable initialization in the current scope.

	* cplus-decl.c (struct binding_level): Change field
	`more_cleanups_ok' from char to bitfield.  Added field
	`have_cleanups'.  Change other fields to bitfields so that
	`struct binding_level' fits in 7 words, which can be
	malloc'd in total of 32 bytes.
	* cplus-decl.c (PUSH_BINDING_LEVEL,maybe_build_cleanup):
	Initialize and set field `have_cleanups'.
	* cplus-decl.c (expand_label): Set `more_cleanups_ok' to zero when
	we cross a label.

	* stmt.c (struct stack_block): Added field `initialized_decls_p'
	for blocks which need their decls expanded before used.
	* stmt.c (expand_decl{_init}): Set field initialized_decls_p when
	appropriate.

Fri Sep  1 04:29:44 1989  Michael Tiemann  (tiemann at teacake)

	* Exception handling constructs recognized (but nothing working).

	* cplus-decl.c (init_decl_processing): Call `set_identifier_size'
	with a length, not a number of bytes.

	* cplus-class.c (build_class_init_list): Braino.

	* cplus-init.c (expand_aggr_init_1): Reinitialize virtual base
	class virtual function tables if they are set to wrong values by
	their constructors.
	* cplus-init.c (expand_aggr_init): Initialize virtual base class
	virtual function tables if they are not set any other way.

	* cplus-class.c (finish_struct): Use CLASSTYPE_VSIZE instead of
	TYPE_VIRTUAL_P to determine whether a particular class has virtual
	functions which belong in its vtable.  A type can be
	TYPE_VIRTUAL_P, meaning that *somewhere* it relies on virtual
	functions, but CLASSTYPE_VSIZE could be zero, meaning that it
	itself may not even have a virtual function table pointer.
	* cplus-decl.c (finish_file): Same changes.
	* cplus-decl.c (setup_vtbl_ptr): Same changes.
	* dbxout.c (dbxout_type): Same changes.
	* cplus-tree.c (layout_basetypes): Same changes.

	* cplus-class.c (finish_base_struct): Return 0 if all virtual
	functions come only from virtual baseclasses.  Also, do not put
	into VFIELDS those fields which come from virtual baseclasses.
	* cplus-class.c (modify_vtable_entry): Instead, run through by
	hand the virtual baseclasses whose virtual function tables need to
	be modified.  This means really using exactly the right
	associations for both base, context, and derived types.
	* cplus-class.c (prepare_fresh_vtable): Change parameter TYPE to
	CONTEXT_ASSSOC.  All callers changed.

Thu Aug 31 08:17:45 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-class.c (finish_struct): Test MAX_HAS_VIRTUAL, not
	HAS_VIRTUAL to assign TYPE_VIRTUAL_P (T).

	* integrate.c (save_for_inline): Add new variable
	PARM_INITIALIZATION which is nonzero during parameter
	initialization (either from the stack or registers).
	* integrate.c (copy_for_inline): Only zero TREE_READONLY of parm
	if PARM_INITIALIZATION is zero.
	* integrate.c (expand_inline_function): Back out Aug 30
	TREE_INLINE change for PARM_DECLs.
	* cplus-decl.c, cplus-typeck.c: Ditto.

	* cplus-decl.c (finish_decl): Take into account case where static
	variable must be initialized ``by hand''.

	* cplus-typeck.c (store_init_value): Return VALUE if
	initialization could not be trivially performed for static
	variable.  Otherwise return NULL_TREE.

	* cplus-decl.c (get_temp_name): Add parameter STATICP.  All
	callers changed.

	* integrate.c (copy_rtx_and_substitute): Significantly simplify
	PLUS and MEM case after finding out that code from tList.cc could
	break the complex cases on Sparc.  Net effect: maybe more work for
	optimizer in later passes, and maybe more space occupied by inline
	insns during compilation.

	* expr.c (store_one_arg): Add test to see if we can avoid calling
	convert_units if possible.

Wed Aug 30 04:01:15 1989  Michael Tiemann  (tiemann at teacake)

	* toplev.c (main): Change +e[01] to -f+e[01], and move to
	lang_decode_option.
	* cplus-decl.c (lang_decode_option): Incorporate new flags.

	* integrate.c (copy_rtx_and_substitute): Don't build a SUBREG of a
	CONST_INT.

	* integrate.c (expand_inline_function): Change test of FORMAL from
	TREE_READONLY to TREE_INLINE.
	* cplus-typeck.c (build_modify_expr,build_unary_op): When
	modifying a PARM_DECL, set TREE_INLINE to 0.
	* cplus-decl.c (store_parm_decls): Set TREE_INLINE of PARM_DECL to
	1.

	* cplus-decl.c (finish_function): When finishing constructors, if
	simple case holds (no cleanups), just store CURRENT_CLASS_DECL
	into the DECL_RESULT of FNDECL and fall through.

	* integrate.c (expand_inline_function): Don't emit
	NOTE_INSN_DELETED notes.

	* cplus-parse.y (compstmt): Only save binding contour information
	if there actually were decls.

	* cplus-decl.c (finish_file): Argument LINENO was missing in calls
	to finish_function.

Tue Aug 29 23:03:17 1989  Michael Tiemann  (tiemann at teacake)

	* cplus-typeck.c (unary_complex_lvalue): Treat INIT_EXPR like
	MODIFY_EXPR.  Also, handle WITH_CLEANUP_EXPR case.

	* expr.c (expand_expr): Brainos in WITH_CLEANUP_EXPR case.

	* cplus-cvt.c (build_up_reference): Handle case where ARG is a
	WITH_CLEANUP_EXPR.

	* stmt.c (expand_function_end): *Don't* set REG_FUNCTION_VALUE_P.

	* tree.def [NEW_EXPR]: Change from 2 arguments to 3.  Third
	argument, if non-NULL, is cleanup expression to run after the
	new'd expression is used.  All users of NEW_EXPR changed.

Sun Aug 27 01:13:09 1989  Michael Tiemann  (tiemann at hobbes.ai.mit.edu)

	* stor-layout.c (layout_basetypes): Move from this file.
	* cplus-tree.c (layout_basetypes): To this one.

	* make-links.g++ (borrowed_files): typeclass.h is now a
	borrowed file.

	* cplus-decl.c (cleanup_after_call): New function.
	* cplus-typeck.c (build_compound_expr): Call it if neccesary.
	* cplus-typeck.c (build_c_cast): Ditto.
	* cplus-init.c (expand_cplus_expr_stmt): Ditto.
	* expr.c (expand_call): Remove code to allocate destructable stack
	slot if function return value is not used.

	* cplus-decl.c (init_decl_processing): `built_in_vec_delete' is
	NOT_BUILT_IN.
	* expr.c (expand_builtin): Don't try to expand EXPAND_VEC_DELETE.

	* cplus-init.c (build_vec_delete): Build the vector delete here;
	don't make a call to `__builtin_vec_delete'.

	* expr.c (expand_expr): Merge INIT_EXPR and MODIFY_EXPR.
	* expr.c (init_noncopied_parts): New function.

	* gcc.c: Merged completely.  Use GCC from standard distribution.

Sat Aug 26 10:38:14 1989  Michael Tiemann  (tiemann at hobbes.ai.mit.edu)

	* cplus-typeck.c (build_binary_op): Perform type instantiation if
	necessary.

	* cplus-class.c (instantiate_type,build_instantiated_decl): Change
	"type instantiation" to "overload" in various error messages.
	* cplus-class.c (instantiate_type): Also fix error message to
	report overload resolution failure only if function has more than
	one type signature declared.

	* cplus-class.c (instantiate_type): Call `mark_addressable' on
	result of instantiating something for an ADDR_EXPR.

	* 1.35.96 to 1.35.97+ changes:
	* Makefile: Change name of `cplus-parse.tab.*' to `cplus-tab.*'.
	* cplus-lex.c: Change #includes to reflect this.
	* cplus-decl.c: All merged except CURRENT_EXTERN_INLINE.
	* toplev.c: Changes for extern inlines not merged.

	* cplus-decl.c (finish_file): Reset FNNAME from DECL_NAME of the
	current function, since `start_function' may cause it to change if
	overloaded.  Also, push into C language context during the
	generation of file-level initializer/cleanup functions, since we
	don't want the extra-long names that overloading will give us.

	* cplus-decl.c,cplus-class.c,cplus-search.c: #include "obstack.h"
	instead of "cplus-obstack.h".

	* gnulib3.c: New file.  Provides initialization and cleanup
	services for GNU C++.  This should obviate the need for crt0.c.
	* crt1.c: Changed completely for new initialization/cleanup model.
	* cplus-decl.c (store_parm_decls): Put in special hooks to call
	`__main' from `main' for such purposes.

Thu Aug 24 02:11:42 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-lex.c (check_newline): Only call unexec #ifndef
	DONT_HAVE_UNEXEC.

	* cplus-lex.c (reinit_parse_for_method)[USG]: If the buffer given
	to setvbuf is shorter than eight bytes long, setvbuf will (in
	violation of its man page) ignore the buffer and call malloc to
	get a bigger one.  Fixed.

	* cplus-typeck.c (comp_target_types): Permit converting from a T**
	to a T** which has different qualifiers.

	* gcc.c (collect_spec): Changes for sun386.
	* collect.c: Ditto.
	* config.g++: Ditto.

	* cplus-parse.y (primary): Handle case where unfound
	identifier comes from base class during class declaration.

	* cplus-init.c (build_member_ref): Handle uses of class-local
	enums and static members before type is completed.

	* cplus-decl.c (pushdecl_class_level): Put enums and static
	members into class scope as soon as they are seen.
	* cplus-decl.c (poplevel_class): Make sure to take them out upon
	leaving scope.

	* cplus-lex.c (build_lang_field_decl): Take new argument CODE to
	say what kind of decl to build.
	* cplus-decl.c,cplus-parse.y: All callers changed.
	* cplus-decl.c (grok_enum_decls): Call `build_lang_field_decl'
	instead of `build_lang_decl'.  Saves memory.
	* cplus-decl.c (grokdeclarator): Same change for VAR_DECLs local
	to structs.
	
	* cplus-typeck.c (build_modify_expr): Fix logic so that when
	assigning to `this', the error message about not being within a
	constructor or destructor is only emitted at the appropriate time.

	* cplus-tree.h [OPERATOR_NEW_FORMAT,OPERATOR_DELETE_FORMAT]:
	Define these.
	* cplus-method.c (build_opfncall): Use them.

	* cplus-tree.h [OPERATOR_MODIFY_FORMAT,OPERATOR_MODIFY_LENGTH,
	OPERATOR_CALL_FORMAT,OPERATOR_CALL_LENGTH,OPERATOR_ARRAY_FORMAT,
	OPERATOR_ARRAY_LENGTH]
	Define these.
	* cplus-decl.c (grok_op_properties): Use them.
	* cplus-init.c (add_friends): Ditto.

	* cplus-tree.h [VTBL_PTR_TYPE]: Define this.
	* cplus-decl.c (init_decl_processing): Use it.

	* cplus-tree.h [OPERATOR_METHOD_FORMAT,OPERATOR_METHOD_LENGTH]:
	Define these.
	* cplus-class.c (build_method_call): Use them.

	* cplus-class.c (compute_conversion_costs): Fix typo which would
	cause error message to be generated for calling a const member
	function with a non-const object.

	* Aug 24 03:10 g++.xtar.Z on ~ftp/pub

	* cplus-init.c (build_new): Braino involving -fthis-is-variable
	removed.

Wed Aug 23 00:12:29 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-decl.c (finish_decl): Cannot forever remove READONLY
	attribute from decl needing initialization.

	* cplus-method.c (report_type_mismatch): Report error if calling
	non-const member function with const object.

	* cplus-class.c (convert_harshness,build_method_call): Finish
	implementing code to catch calls to non-const member functions
	with const objects.

	* cplus-class.c (build_method_call): No longer need to get to
	TYPE_MAIN_VARIANT for type information, such as TYPE_NEEDS_....

	* cplus-class.c (finish_struct): Set flags in all type variants.
	* cplus-parse.y (various places): Ditto.

	* integrate.c (expand_inline_function): No longer call abort if
	TREE_TYPE (arg) != TREE_TYPE (formal) for BLKmode parameter.  This
	can happen when TREE_TYPE (formal) == ERROR_MARK_NODE.

Tue Aug 22 09:06:32 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-class.c (ideal_candidate): Use `function' member instead
	of `u.field' member of candidates.  The former is always properly
	set up, whereas the latter is set to 0 if the function used is a
	non-member function.

	* cplus-decl.c (groktypefield): Handle case where IDENTIFIER_NODE
	comes in which is not an aggregate type name.

	* cplus-method.c (hack_operator): Return ERROR_MARK_NODE if
	operator name is missing.
	* cplus-parse.y: Callers changed to deal with this.

	* cplus-search.c (various places): Most calls to
	`error_with_aggr_type' were wrong, leading to backward error
	messages (such as `member `A' not found for class `memfunc').
	Changed back to call `error' with appropriate parameters.

	* cplus-search.c (lookup_fnfields): Braino in printing error
	message: TREE_VALUE (entry) is a BASELINK (a TREE_LIST of
	TREE_LISTs), not a TREE_LIST.

	* cplus-decl.c (grokdeclarator): Handle missing operator name for
	for OP_IDENTIFIER case.

	* cplus-init.c (finish_base_init): If the vtable installed by the
	constructor was not the right one, fix after call to base
	constructor, before derived initialization.

	* cplus-decl.c (store_parm_decls): New parm PRESERVE is nonzero if
	we should preserve the data containing the function parameters.
	This is normally done for inline functions, but also needs to be
	done for constructors of classes which use virtual baseclasses.
	* cplus-decl.c (finish_function): Don't set DECL_ARGUMENTS (FNDECL)
	to zero if above condition holds.
	* cplus-decl.c, cplus-parse.y: all callers of store_parm_decls
	modified.

	* cplus-tree.c (hash_tree_chain): New function.  Simplified
	version of hash_tree_cons.
	* cplus-parse.y (declmods): Use `hash_tree_chain' to build up
	lists which are not destroyed during parsing.  They can be reused
	throughout the rest of the parse.

Mon Aug 21 09:51:47 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-init.c (expand_aggr_init_1): Replace PARM_DECL rtl's with
	actual values to parameters.

	* cplus-init.c (expand_aggr_vbase_init): Only try initializing
	base classes here if FNDECL is nonzero.
	* cplus-init.c (expand_aggr_init_1): Try initializing them here in
	that case instead.

	* cplus-decl.c (finish_decl): We can initialize a const& from a
	const int, etc.

	* cplus-init.c (expand_vec_delete): Only warn about ignored array
	size expressions if EXTRA_WARNINGS.

	* cplus-init.c (build_new): Don't forget to allocate space for
	vectors.

	* cplus-init.c (add_friend): If the friend is not of METHOD_TYPE,
	set CTYPE = ERROR_MARK_NODE.  This prevents false friend matches
	due to fact that `is_friend' assumes that if CURRENT_CLASS_TYPE ==
	TREE_PURPOSE (friends), that a class-match has occured.

	* stmt.c (expand_end_bindings): Don't let cleanups affect ({...})
	constructs.

	* cplus-decl.c (finish_decl): When initializing one reference from
	another, make sure that we wrap the initializer in a SAVE_EXPR if
	it is TREE_VOLATILE.

	* cplus-class.c (compute_conversion_costs): Check that FORMAL_TYPE
	is not ERROR_MARK_NODE.

	* tree.h (tree_type): Delete unused field `parse_info'.

	* cplus-decl.c (setup_vtbl_ptr): Add tests for OPTIMIZE and that
	CURRENT_FUNCTION_DECL is not DECL_STATIC_FUNCTION_P.

Sun Aug 20 12:09:30 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-decl.c,cplus-typeck.c (various places): Check for
	CONST_DECL in addition to TREE_READONLY VAR_DECLs when needing
	constants for various purposes.

Sat Aug 19 12:27:41 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-class.c (build_method_call): Handle case where
	INSTANCE_PTR is integer_zerop.  This can happen with casts like
	{ return ((Object*)0)->Object::IsA(); }

Fri Aug 18 01:14:02 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-class.c (build_method_call): Complain about using abstract
	function only if INSTANCE is of known abstract type.

	* cplus-class.c (add_method): Don't crash if FIELDS is 0.

	* dbxout.c (dbxout_type): Don't crash if type only defines
	constructors and destructors.

	* cplus-typeck.c (build_component_ref): If METHOD_VEC is 0, break
	out of loop.

	* cplus-decl.c (finish_file): Don't abort if INIT is 0.

Thu Aug 17 21:55:35 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-parse.y (LC): If the type we get left of a '{'
	!IS_AGGR_TYPE, then make a fake node which can hold our types for
	us.

	* cplus-init.c (do_friend): Argument missing in call to
	grokclassfn.

	* cplus-decl.c (poplevel): Only call `expand_end_bindings' if the
	level being popped needed an `expand_start_bindings' to get going.
	This only happens if the level is specifically to hold
	temporaries (i.e., when the KEEP field is < 0).

	* cplus-decl.c (finish_decl): Emit a sorry message if the _DECL
	needs constructing, and is not at toplevel.

	* cplus-class.c (build_method_call): Complain about incomplete
	types only if (FLAGS&LOOKUP_COMPLAIN).

Wed Aug 16 17:11:22 1989  Michael Tiemann  (tiemann at yahi)

	* toplev.c (compile_file), cplus-lex.c (yylex): Use setjmp/longjmp
	to communicate fact that dump was just performed.  This prevents
	duplicate bytes being written to the asm file, due to inline
	functions being written out by both original and dumped compilers.

	* toplev.c (compile_file): Hack to make dumped compiler move bytes
	quickly from old asm file to new.

	* cplus-search.c (build_mi_virtuals,free_mi_matrix): Pointer
	arithmetic for mi_vmatrix accesses were off by 1.

	* cplus-class.c (build_method_call): Handle case where INSTANCE
	has a POINTER_TYPE type.  This is when it is a dummy argument for
	`operator new ()'.

Tue Aug 15 00:05:49 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-decl.c (grokclassfn): `const' member function information
	was being lost.

	* cplus-class.c (build_method_call): Generate error message when
	passing const objects to non-const member functions.

	* cplus-class.c (finish_struct): METHOD_VEC must track the object
	being grown on the class obstack.

	* cplus-method.c (dump_type{_prefix}): Print `class' instead of
	`struct' if declared as class.

	* cplus-method.c (build_{decl,typename}_overload,do_actual_overload,
	fndecl_as_string): Distinguish `const' member functions from
	normal member functions.

	* cplus-search.c (get_base_type): Distinguish whether we want to
	know if a public field of baseclass is protected, or whether a
	conversion from derived to base class is protected by passing
	either 1 or 2 to the argument PROTECT.
	* cplus-search.c (get_base_distance): If protect is non-zero,
	always emit an error message if conversion from derived to base
	class is across a private visibility boundary.

	* cplus-cvt.c (convert_to_reference): Don't violate visibility
	rules when converting to references.  Add parameter PROTECT to
	control this behavior.  All callers changed.
	* cplus-cvt.c (build_up_reference): Ditto.

Mon Aug 14 00:03:46 1989  Michael Tiemann  (tiemann at yahi)

	* stmt.c (expand_end_case): Incorporate rfg's bugfix for
	optimizing case statements with signed negative test term.

	* cplus-search.c (reinit_search_statistics): New function.
	* toplev.c (compile_file): Call that function if BEEN_HERE_BEFORE.

	* cplus-decl.c: Remove explicit initializations from static
	variables--let them sit in common rather than data space.
	* cplus-method.c: Ditto.

	* Makefile,toplev.v, cplus-decl.c, cplus-lex.c: Incorporated
	changes from Bryan Boreham <kewill!bryan@uunet.uu.net> to dump a
	running GNU C++ for later reexecing.
	* unexec.c,lastfile.c: borrowed from GNU Emacs
	* unex-addr.c,getpagesize.h: New files

	* Aug 14 13:07 g++.xtar.Z on ~ftp/pub

	* cplus-decl.c (finish_file): Handle case where initializer for
	one static aggregate is another.  Do so by disabling code which
	assumed the wrong thing in that case.

	* cplus-search.c, cplus-tree.c, cplus-class.c: Major surgery on
	assoc lists.  Virtual baseclasses are no longer represented in the
	main assoc list of a type.  CLASSTYPE_VBASECLASSES already holds
	such information.  Various functions changed and/or simplified to
	use value from that assoc list when needed.

	* cplus-decl.c (grokdeclarator): Don't get confused by
	non-storageclass bits in SPECBITS when DECL_CONTEXT == FIELD.

	* cplus-init.c (expand_aggr_init_1): Only check whether a new
	value has been assigned to `this' by the base class if
	FLAG_THIS_IS_VARIABLE is nonzero.

	* cplus-init.c (expand_aggr_init_1,build_new): Function
	`expand_aggr_vbase_init_1' was the wrong thing.  Change these
	functions to call `expand_aggr_vbase_init' instead.
	Also, #ifdef'd out `expand_aggr_vbase_init_1'.

	* cplus-search.c: Move assoc code from here...
	* cplus-tree.c: ...to here.

	* cplus-decl.c (lang_printable_name): Don't print return type for
	constructors or destructors.

	* cplus-class.c (finish_struct): Set TYPE_NEEDS_CONSTRUCTING bit
	if any default members.

	* cplus-decl.c (finish_file): Remove test for
	TYPE_NEEDS_CONSTRUCTING when considering vars in
	STATIC_AGGREGATES.  If something made it to this list, it should
	be initialized.

Sun Aug 13 14:25:55 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-decl.c: Rename static variable GLOBAL_AGGREGATES to
	STATIC_AGGREGATES.
	* cplus-decl.c (finish_decl): Put static aggregates on the
	STATIC_AGGREGATES list if the VAR_DECL is TREE_STATIC.  It does
	not have to be at the global_binding_level to get this treatment.
	Also, rename variable OLDGLOBAL to OLDSTATIC, and remove error
	messages which are no longer needed due to this change.

	* cplus-typeck.c (comptypes): Qualifiers must match.  (Fix taken
	from GCC).

	* cplus-init.c (expand_aggr_{vbase}_init,expand_recursive_init):
	provide arguments INPUT_FILENAME and LINENO to
	`expand_asm_operands'.
	* cplus-search.c (init_vbase_pointers,build_vbase_vtables_init):
	Ditto.

	* cplus-class.c (push_lang_context): Don't set current_lang_name
	if it is not a name we recognize.

	* All GNU C++ files: Merged changes from 1.35.95 to 1.35.96.

Sat Aug 12 00:27:43 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-decl.c (finish_function): Call use_variable on
	CURRENT_VTABLE_DECL if it is non-NULL.

	* cplus-decl.c (finish_decl): Call build_indirect_ref instead of
	building the INDIRECT_REF by hand when setting the decl reference
	slot.

	* cplus-obstack.h: New file.  Defines obstack_int_grow and
	obstack_ptr_grow.  Cuts many calls to bcopy.
	* cplus-class.c: Use cplus-obstack.h instead of obstack.h.
	* cplus-search.c: Ditto.

	* cplus-parse.y (aggr): Fix minor nits in error messages.

	* cplus-class.c (finish_struct): Removed code which redundantly
	called `finish_decl' on static class members.

	* cplus-decl.c (finish_decl): C++ 2.0 now permits static class
	members to be of types with constructors.

	* cplus-search.c (bfs_unmark_finished_struct): Don't call
	assoc_value if TYPE == CURRENT_CLASS_TYPE.

	* cplus-search.c (assoc_value): Call compiler_error if we have
	multiple baseclass hits.  Also, make this function look for
	matches recursively.  This saves having to flatten out the
	hierarchy all the time, saving storage.

	* cplus-init.c (expand_recursive_init_1): Take into account fact
	that there is no virtual function table initialization needed if
	CLASSTYPE_NEEDS_VIRTUAL_REINIT set TREE_VALUE (init_list) to
	NULL_TREE.
	* cplus-class.c (build_class_init_list): Set up init lists
	correctly if the derived class just takes virtual function table
	initialization from the base class.

	* cplus-init.c (finish_base_init): Unmark fields initialized which
	belong to base classes.

	* cplus-decl.c (grokdeclarator,duplicate_decls): Implement C++ 2.0
	interpretation of `const'.

	* Aug 12 08:33 g++.xtar.Z on ~ftp/pub

	* cplus-typeck.c (commontype): Case for REFERENCE_TYPE appeared to
	be missing.
	* cplus-typeck.c (comptypes): Ditto.

	* cplus-typeck.c (comp_target_parms): Braino caused this function
	to return after processing just the first argument!

	* cplus-typeck.c (comp_target_parms,compparms): Take
	contravariance into account for argument lists.

Fri Aug 11 04:58:40 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-tree.c (list_hash): Implement hashing scheme for
	unchanging list nodes, such as compose TYPE_BASELINKS.
	Several new functions and data structures implement this.
	* cplus-search.c (get_baselinks): Call hash_tree_cons instead of
	tree_cons to get fresh nodes.

	* tree.c (init_tree): Remove call to bzero for hash_table.

	* cplus-init.c (expand_aggr_init): Typo in call to
	expand_vec_init.

	* newld.c (decode_command): Fix failure to bzero all entries in
	FILE_TABLE.

	* cplus-lex.c (cons_up_dtor_for_type): Add missing QUALS
	parameter in call to start_method.

	* cplus-decl.c (start_function): Set TREE_READONLY and
	TREE_VOLATILE bits of C_C_D.
	* cplus-class.c (popclass): Ditto.

	* cplus-tree.c (build_cplus_method_type): New function.  Like
	`build_method_type', but permits qualifiers for the instance
	variable.
	* cplus-tree.h: Declare it.
	* cplus-decl.c (grokdeclarator,grokclassfn): Call this function
	instead of build_method_type.

	* tree.c (build_method_type): Set TYPE_METHOD_BASETYPE from the
	TYPE_MAIN_VARIANT of BASETYPE.

	* cplus-lex.c (gplus.input): Change `friend' from TYPE_QUAL to
	SCSPEC.

	* cplus-parse.y (fn.def1): Permit const and volatile member
	functions.
	* cplus-method.c (stash_inline_prefix): Handle case of const and/or
	volatile member functions declared inside class.
	* cplus-decl.c (start_{method,function}): Grok const and volatile
	member functions.
	* cplus-decl.c (grokdeclarator): New parameter QUALS.

	* cplus-typeck.c (readonly_warning_or_error): If ARG is a
	PARM_DECL, print its name.  Also, if the message is due to the
	underlying structure of a COMPONENT_REF, tell user the
	member name instead of trying to hunt down the structure name.
	also, if ARG is a reference variable or parameter, name the
	reference as well.

	* cplus-cvt.c (build_up_reference): Handle case where we build a
	reference to a sub-object of an object which uses multiple
	inheritance.

	* cplus-class.c (finish_struct): Simplify conditions under which
	CLASSTYPE_NEEDS_VIRTUAL_REINIT is used, and use it.

Thu Aug 10 00:13:03 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-parse.y (member_init): If base class is virtual, save the
	intializer on the permanent_obstack.

	* cplus-init.c (expand_aggr_vbase_init_1): New function.  Called
	to actually walk the virtual baseclass initialization list.

	* cplus-init.c (expand_aggr_vbase_init): New argument DECL is
	the FUNCTION_DECL for the constructor by which this object is
	initialized.  From that constructor comes the virtual base class
	initialization list.

	* cplus-init.c (finish_base_init): Store initializers for virtual
	base classes.

	* cplus-tree.h (lang_decl): Add new field `vbase_init_list'.
	Holds initializers for virtual base classes.

	* cplus-init.c (build_new): Arrange to initialize virtual
	baseclasses before calling constructor if FLAG_THIS_IS_VARIABLE
	is zero.  Otherwise, constructor will call it on allocation.

	* cplus-cvt.c (convert_to_nonzero_pointer): If EXPR is already
	of type TYPE, don't build a NOP_EXPR; instead, just return
	EXPR.

	* cplus-class.c (build_method_call): If INSTANCE is NULL_TREE,
	then pre-allocate storage for the constructor.  After that, if
	there are virtual baseclasses to initialize, initialize them right
	away.  Then call constructor with resulting argument.

	* cplus-decl.c (flag_this_is_variable): Change default from 1 to 0.
	* cplus-decl.c (lang_decode_option): Recognize
	`-fthis-is-variable' on command line.
	* cplus-decl.c (finish_function): Don't emit test for whether `this'
	is zero if FLAG_THIS_IS_VARIABLE is zero.  Check both constructor
	and destructor case.
	* cplus-decl.c (grokclassfn): Make `this' a *const if
	!FLAG_THIS_IS_VARIABLE.

	* cplus-search.c (build_mi_matrix): Initialize MI_SIZE when
	reusing an old mi-matrix.

	* cplus-cvt.c (convert_to_nonzero_pointer): Abort if argument is
	integer_zerop.

	* cplus-class.c (build_method_call): Simplify code, mostly for
	speed.

	* cplus-search.c (lookup_field): Use my_tree_cons instead of
	tree_cons for looking up fields.

	* cplus-search.c (my_{tree_cons,build_string}): Use SET_TREE_CODE
	to set tree code.

	* cplus-decl.c (finish_decl): Initialize globals whose type needs
	constructing, but ! IS_AGGR_TYPE (type), with empty_init_node to
	keep assemble_variable from crashing.

	* cplus-search.c (build_mi_matrix): Take into account
	CLASSTYPE_N_VBASECLASSES when computing MI_SIZE.
	* cplus-class.c (finish_struct): Braino: set
	CLASSTYPE_N_VBASECLASSES after calling layout_vbasetypes.

	* cplus-class.c (finish_base_struct): Set MAX_HAS_VIRTUAL
	regardless of whether base class is a virtual baseclass or not.
	* cplus-class.c (finish_struct): Also, set MAX_HAS_VIRTUAL
	taking into account virtual baseclasses.
	* cplus-tree.c (layout_vbasetypes): Takes new arg PMAX which
	passes info of maximum number of virtual functions defined in
	virtual baseclasses from this function to finish_struct.

	* cplus-class.c (finish_struct): Set MAX_HAS_VIRTUAL if
	HAS_VIRTUAL is set.

	* cplus-class.c (modify_vtable_entry): If VFIELD can be
	NULL_TREE, if the current class has no virtual function except
	those inherited from a virtual baseclass.  In such a case,
	NORMAL will be zero.

	* cplus-lex.c (copy_type_lang_specific): Copy the array of
	basetypes so that CLASSTYPE_BASECLASS (t, i) gives the right
	baseclass.

Wed Aug  9 10:41:17 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-typeck.c (c_expand_return): Don't pass return value though
	a temporary if there are no pending cleanups.
	* stmt.c (no_pending_cleanups): New function to support above
	change.

	* stmt.c (assign_parms): Add test to see if we can avoid calling
	convert_units if possible.

	* cplus-decl.c (grokparms): Use variables LAST_RESULT and
	LAST_DECL to eliminate need to call `chainon'.

	* stmt.c (expand_fixup,expand_start_bindings): Use static variable
	EMPTY_CLEANUP_LIST to short-circuit cleanup checking, and also
	cut down on calls to tree_cons, in new binding contours, which are
	quite frequent in C++ (20% of calls to tree_cons, and 5% of total
	TREE_LIST nodes).

	* stmt.c (expand_start_*): Build new nesting level structure on
	obstack instead of calling malloc.  New variable STMT_OBSTACK.
	New function `init_stmt'.
	* toplev.c: Call `init_stmt'.

	* obstack.h (obstack_{ptr,int}_grow): New macros.

	* cplus-cvt.c (build_default_{binary,unary}_type_conversion):
	Handle case where one (or both) incoming types are "C" types, not
	"C++" types.

	* cplus-cvt.c (convert_to_pointer): If we go through any virtual
	base pointers, make sure that casts to BASETYPE from the last
	virtual base class use the right value for BASETYPE.

	* cplus-search.c (dfs_find_vbases): VBASES are now TREE_VECs,
	not TREE_LISTS.  Change variable named OFFSET_INFO to ASSOC,
	and use accordingly.

	* cplus-search.c (dfs_get_vbase_types): Make assocs in VBASE_TYPES
	contain the true basetype, not its MAIN_VARIANT.

Tue Aug  8 00:19:43 1989  Michael Tiemann  (tiemann at yahi)

	* stor-layout.c (layout_basetypes): Don't inherit assoc info.
	Synthesize it instead.

	* cplus-class.c (finish_struct): Reenable code which fills in
	virtual function tables of virtual baseclasses.

	* cplus-class.c (finish_struct): Fill in virtual function table
	with values which come from virtual or non-leftmost baseclasses.
	These are not filled in correctly by `modify_vtable_entry', which
	for these cases, only correctly allocates their skeleton.

	* cplus-class.c (modify_vtable_entry): Only call get_base_distance
	when BASE != CONTEXT.

	* cplus-search.c (get_base_distance): Don't push a search_stack
	level until we know we need it and will use it.

	* cplus-class.c (modify_vtable_entry): Once we know what vtable is
	of interest, set BASE to the best approximation of T's vtable we
	know.  I.e., set it to the vtable for the immediate super-class of
	T.

Mon Aug  7 17:12:31 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-class.c (finish_struct): When extending the bounds of the
	virtaul function table, keep VFIELDS as it was; don't move it up
	the inheritance tree.

	* cplus-class.c (finish_struct): No need to allocate a lang_decl
	for the virtual function table pointer FIELD_DECL.  Others need
	bits, but not bytes that FUNCTION_DECLs need.

	* cplus-init.c (build_virtual_init): For now, assume that FOR_TYPE
	and TYPE may be distinct, so use assoc lists to find the right
	vtable.

	* cplus-init.c (expand_recursive_init_1): Initialize the virtual
	function table of sub-components of aggregates driven by
	sub-component.  Otherwise, we have to initialize the virtual
	function table driven by the caller who knows what sub-components
	must be initialized.  Question: will this cause multiple
	initialization of vtables which are not down the left-hand side?
	Answer is probably yes.

	* tree.c (make_tree_vec): New function.

	* tree.c (copy_node): Now handles TREE_VEC correctly.

	* cplus-search.c ({make,copy}_assoc,assoc_value,debug_dump_assoc):
	Change representation of assoc list from TREE_LIST to TREE_VEC
	representation.
	* cplus-tree.h (ASSOC_* macros): Also here.

	* cplus-typeck.c (process_init_constructor): Don't complain about
	non-initialization of static class members, regardless of whether
	they are in global scope or not.  (Previously only complained when
	at global scope.)

	* cplus-class.c (finish_struct): Allocate method_vec if members
	need destructors.

Sun Aug  6 10:23:31 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-class.c (finish_struct): Eliminate redundant
	initialization of class fields to 0.

	* cplus-parse.y (parm rules): Use void_list_node instead of
	build_tree_list (NULL_TREE, void_type_node) where possible.

	* print-tree.c (dump): Handle TREE_VEC case.

	* cplus-init.c (add_method): Modified, and moved to cplus-class.c.

	* cplus-tree.h (lang_type): Change representation of list of
	member functions from list of lists to vector of lists.
	* cplus-class.c (finish_struct,build_method_call): Also here.
	* cplus-method.c (do_inline_function_hair): Also here.
	* cplus-decl.c (grokclassfn): Also here.
	* cplus-init.c (build_delete,build_member_ref): Also here
	* cplus-ptree.c (walk_lang_type): Also here.
	* cplus-search.c (lookup_fnfields{_1},get_baselinks,dfs_pushdecls,
	dfs_compress_decls,dfs_popdecls): Also here.
	* cplus-typeck.c (build_component_ref): Also here.
	* dbxout.c (dbxout_type): Also here.

	* cplus-class.c (build_method_call): Remove vestigal use of
	OVERLOAD_MAX_LEN.

Sat Aug  5 09:49:48 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-decl.c (grokparms): Reuse TREE_LIST node in usual case of
	parameter processing.

	* cplus-decl.c (init_decl_processing): Do things here which used
	to be done in toplev.c
	* toplev.c (various places): Merge with GCC.

Fri Aug  4 17:47:24 1989  Michael Tiemann  (tiemann at yahi)

	* stor-layout.c (genop): Avoid creating new nodes when old ones
	will do.
	* stor-layout.c (build_int): Cache sizes we have made for types.

Thu Aug  3 21:44:04 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-decl.c (pushdecl): Canonicalize enum typedefs same as
	struct, class, and unions.

	* cplus-init.c (resolve_member_ref): When member is of
	METHOD_TYPE, return logical address of the member, not the member
	itself.  The member itself has type METHOD_TYPE, which has mode
	EPmode, which is not a valid mode for expand_expr.

	* cplus-init.c (expand_vec_delete): When calling vector delete on
	store which does not need destructors, just ignore the argument,
	and delete the container (array) instead.

	* cplus-decl.c (start_function): Handle case where OLDDECL comes
	back as a TREE_LIST.

Wed Aug  2 10:54:54 1989  Michael Tiemann  (tiemann at yahi)

	* collect.c (process): Initialize ldptr to NULL if COFF is defined.

	* cplus-method.c (stash_inline_prefix): String name of function is
	IDENTIFIER_POINTER (DECL_NAME (...)), not DECL_NAME.

Mon Jul 31 12:14:35 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-decl.c (finish_decl): Handle case where INIT can be a
	TREE_LIST when initializing a named return value.  Specifically,
	translate a TREE_LIST into a COMPOUND_EXPR when initializing a
	referece.

	* toplev.c (compile_file): Gripe about *non*-extern functions
	declared static but not defined.

	* cplus-init.c (build_delete): Keep ADDR parameter from being
	evaluated multiple times if TREE_VOLATILE.

	* cplus-decl.c (grok_function_init): Note whether DECL is an
	uninheritable virtual (i.e., a virtual function of an "abstract
	class").
	* cplus-tree.h (lang_decl): Add bit to record above info.
	* cplus-class.c (build_method_call): Give error if compiler can
	detect that user is attempting to call this function for an object
	whose type is that of the "abstract class".

	* gcc.c (link_spec): Make libg++.a available via %s rather than
	from -lg++.

Fri Jul 28 00:22:14 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-typeck.c (comp_target_types): Take contravariance into
	account for OFFSET_TYPE.

	* cplus-decl.c (grokdeclarator): When declaring an array, always
	call suspend momentary, since the TYPE_DOMAIN of the array may be
	needed later, for instance by expand_vec_delete.
	* cplus-parse.y (nonmomentary_expr): Second change needed to
	ensure that above condition is met.

	* cplus-decl.c (grokdeclarator): Handle case of derived class
	declaring member function static when derived class declared
	member function virtual.

	* cplus-decl.c (grokparms): Permit functions which have default
	arguments to end with `...'.
	cplus-typeck.c (actualparameterlist): Handle this new case.

	* cplus-typeck.c (c_expand_return): Handle case where conversion
	to return type of function returns ERROR_MARK_NODE.

	* cplus-init.c (build_delete): Handle case where member type is
	ARRAY_TYPE.

	* cplus-parse.y (component_decl): Handle case of missing ';'
	before '}'.

	* cplus-typeck.c (c_expand_start_case): Handle case where switch
	quantity is a MEMBER_REF.

	* cplus-method.c (build_component_type_expr): Handle case of
	calling non-virtual type conversion operators.

	* cplus-decl.c (shadow_tag): Make permanent any type created here.

	* gcc.c (struct compiler compilers[]): add -D__GNUC__ to files
	which are compiled using GNU C++.

	* cplus-parse.y (primary <- IDENTIFIER): If the identifier is a
	class-local enumeral value, check visibility--it may be a private
	member of a base class.

	* cplus-cvt.c (convert_force): New function.  Permit conversion from
	sub-type to private super-type.
	* cplus-typeck.c (build_c_cast): Call convert_force instead of
	convert.

	* cplus-typeck.c (build_x_function_call): Don't crash if asked to
	resolve a function which has been declared overloaded, but does
	not yet have any signatures.

	* cplus-class.c (finish_decl): Don't crash when warning (or
	flagging as error) that array types in static objects cannot need
	constructors.

Thu Jul 27 02:26:27 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-tree.c (build_cplus_array_type): Make array type permanent
	if ELT_TYPE is permanent.  This is needed because the array type
	may exist within an inline function, and that inline function may
	be expanded at any future time.

	* cplus-typeck.c (build_scoped_ref): Typo caused fn call to have
	virtually no effect.

	* cplus-init.c (expand_recursive_init): Make usage of global
	INIT_PTR reentrant.

	* cplus-search.c (dfs_pushdecls): Don't try initializing a
	TYPE_DECL, just continue through it.

	* integrate.c (access_parm_map): Don't compensate for
	BYTES_BIG_ENDIAN if parm is BLKmode.

	* stmt.c (various places): Make stmt.c agree much more closely
	with GCC's stmt.c.  Now only a few places where there are
	differences.  These have to do with calling do_pending_adjust
	before running cleanups, and using `lang_printable_name' instead
	of DECL_PRINT_NAME to assign to `current_function_name'.

Wed Jul 26 15:04:45 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-decl.c (finish_decl): If decl is static, but initialized
	by non-static initializer (such as an object initialized by a
	constructor), use a special initializer to make the decl lay down
	in data rather than bss space.
	* varasm.c (assemble_variable): Remove C++-specific code for above
	case.

Tue Jul 25 13:10:19 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-class.c (modify_vtable_entry): If the base fndecl is
	not contained in the vtable, don't try to modify the vtable.
	This automatically includes virtual functions from virtual base
	classes.
	* cplus-class.c (modify_vtable_entry): If the virtual function
	does come from a virtual base class, remember to change its
	DECL_VINDEX from a FUNCTION_DECL to an INTEGER_CST before
	continuing with the loop.  Use the DECL_VINDEX of the base
	FUNCTION_DECL.

	* cplus-search.c (debug_dump_assoc): New function.

Mon Jul 24 11:22:50 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-class.c (finish_struct): Break out code to initialize a
	struct with information deriving from its base classes.
	* cplus-class.c (finish_base_struct): New function where that code
	now lives.

	* cplus-search.c (dfs_get_vbase_types): Make full association
	list; Don't do so only when TREE_VIRTUAL bit is set.

Sun Jul 23 20:31:57 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-class.c (modify_vtable_entry): Braino caused base
	association to overwrite derived associate, causing base
	virtual functions to appear in derived virtual function tables
	when they shouldn't have.

Sat Jul 22 14:48:51 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-lex.c (yylex): Characters are of type `char'
	* cplus-decl.c (lang_decode_option): No longer a need for
	flag_char_charconst.
	* flags.h: ditto.

	* All GNU C++ files: Merged changes from 1.35 to 1.35.95.

Thu May 25 02:56:16 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-init.c (expand_aggr_init_1): make sure to emit error
	  message when following an error path.

	* stor-layout.c (layout_decl): call this function instead of
	  cplus_size_in_bytes.  This saves many calls to `convert_units'.

	* cplus-typeck.c (cplus_size): new function, just returns the size
	  of the type we are interested in (no units conversion is done).

	* cplus-decl.c (init_decl_processing): preallocate
	  IDENTIFIER_NODES for `this' and `__delete_me__'; saves calls to
	  get_identifier.

	* cplus-parse.y, cplus-lex.c: tried to speed things up.  Removed
	  vestigial `@' construct from cplus-parse.y.  Also parse '(' ')'
	  as a single token.

	* cplus-init.c (add_friend): make sure to return void_type_node if
	  we want our callers not to see anything.  Also, undo having set
	  TREE_GETS_{NEW,DELETE} if the friend we get is global operator new or
	  global operator delete.

Tue May 23 01:10:51 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-typeck.c (build_modify_expr): Recursive memberwise
	  assignment must work on all type variants, not just the main
	  variant.  Otherwise, we can't assign a const B& to a B&.

	* cplus-cvt.c (convert_to_pointer): convert to virtual baseclasses
	  through virtual baseclass pointers.  Also, give error if
	  converting up from a virtual baseclass type.

Mon May 22 22:03:24 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-class.c (finish_struct): remember to give dynamic classes
	  a vfield even if they don't define virtual functions (-fSOS).

	* cplus-decl.c (init_decl_processing): fixed typo: TYPE_POINTER_TO
	  does not build a pointer type, but build_pointer_type does.

	* cplus-decl.c, cplus-init.c: allow builtin functions to be
	  declared friends.

	* cplus-class.c (ideal_candidate): if the best candidates require
	  user-defined type conversions, don't reject as ambiguous the
	  case where one candidate comes from one class, and the other
	  candidates come from base classes of that class.

	* stor-layout.c (layout_type): after laying out a type, make sure
	  that all type variants get the type's size.

Fri May 19 13:20:07 1989  Michael Tiemann  (tiemann at yahi)

	* cplus-class.c (popclass): don't kill out prev_class_type's decls
	  if not at the global binding level.

	* cplus-decl.c: added new field `class_shadowed', which may some
	  day be used to implement nested clases.

	* newld.c (various places): round up size to double word boundary
	  if defined(sparc) || defined(sun).

	* tree.c (lvalue_p): A CALL_EXPR is an lvalue if the return type
	  is an addressable type.

	* cplus-init.c (make_friend_class): fix typo in error message.

	* cplus-class.c (finish_struct): Don't give error message if class
	  is does not define virtual functions which must be defined if
	  that class has some of its own.

	* cplus-class.c (instantiate_type): handle case where user
	  requests member function using object, i.e., `x.f'.  If f is
	  virtual, return the function found in the virtual function table.

	* stor-layout.c (layout_basetypes): language dependent code
	  removed, put in cplus-class.c

	* stmt.c (expand_goto_internal, expand_end_bindings,
	  fixup_cleanups): if cleanups were called on leaving a binding
	  contour, and EXIT_IGNORE_STACK is not defined, call
	  do_pending_stack_adjust.

	* gcc.c: recognize ".cxx" as a C++ file name extension.

	* cplus-typeck.c (convert_for_initialization,
	  convert_for_assignment): convert MEMBER_REFs, if possible, to
	  members or component refs as appropriate.

	* cplus-typeck.c (build_member_ref): recognize member refs which
	  are not associated with any object in particular (i.e., could
	  be, but need not be `this').

	* cplus-search.c (get_vbase_types): orders the virtual base
	  classes so that initialization and anti-initialization are 
	  performed in correct order.  A virtual baseclass is not
	  destroyed until all parts of the object which could be using
	  that virtual base class are destroyed.

	* cplus-parse.y: call build_vbase_delete if appropriate.

	* cplus-init.c (expand_delete): call build_vbase_delete if
	  appropriate.  No longer deletes parts of objects via virtual
	  base classes.

	* cplus-init.c: new function build_vbase_delete, performs
	  destructors on objects with virtual base classes.  new function
	  build_x_delete calls free-store deallocator on objects without
	  running destructors.

	* cplus-decl.c (pushdecl, shadow_tag, and xref_tag): implement
	  C-like behavior in "C" language scope vis a vis type
	  declarations.

	* cplus-decl.c: define macros PUSH_BINDING_LEVEL and
	  POP_BINDING_LEVEL.  Use these macros where appropriate.  Fixed
	  bug in popping binding contours in the presence of syntax
	  errors.

	* README, config.g++, make-links.g++: fixed minor glitches

Wed May 17 20:34:29 1989  Michael Tiemann  (tiemann at yahi)

	* stor-layout.c: move code which deletes an incomplete base type
	  to cplus-class.c.

	* cplus-class.c (finish_struct): call `propagate_basetype_offsets'.

	* cplus-class.c: new function `propagate_basetype_offsets' gives
	  correct offsets to base types which are not immediate base types
	  in a multiple inheritance lattice.

Tue May 16 09:40:00 1989  Michael Tiemann  (tiemann at yahi)

	* Started using ChangeLog for version 1.35.0


