/*ident	"@(#)cls4:src/expr3.c	1.38" */
/*******************************************************************************
 
C++ source for the C++ Language System, Release 3.0.  This product
is a new release of the original cfront developed in the computer
science research center of AT&T Bell Laboratories.

Copyright (c) 1993  UNIX System Laboratories, Inc.
Copyright (c) 1991, 1992 AT&T and UNIX System Laboratories, Inc.
Copyright (c) 1984, 1989, 1990 AT&T.  All Rights Reserved.

THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE of AT&T and UNIX System
Laboratories, Inc.  The copyright notice above does not evidence
any actual or intended publication of such source code.

expr3.c:

	type check function calls, casts, and explicit coercions

************************************************************************/

#include "cfront.h"
#include "size.h"
#include "template.h"
#include "overload.h"

static Bits intersectRule(const Block(BlockPname)&, int, Pexpr);
static Bits bestMatch(const Block(Pname)&, int, Ptype);
static Bits best_const(const Block(Pname)&, int, Ptype);
static Pname breakTie(const Block(Pname)&, Bits&, Pexpr, int);
static int pr_dominate(Ptype, Ptype);

static int refd;// initialization routine called by ref_init, do not apply itor
static int no_sti;
static int miFlag;
int no_const;
extern int stat_init;
int ambig;
bit in_return=0;

int pr_dominate(Ptype t1, Ptype t2)
/*
*/
{
	Pname cn1 = t1->is_cl_obj();
	Pname cn2 = t2->is_cl_obj();

	if (cn1==0 || cn2==0) {
		Ptype p1 = t1->is_ptr();
		Ptype p2 = t2->is_ptr();
		if (p1 && p2) {			// pointers
			cn1 = Pptr(p1)->typ->is_cl_obj();
			cn2 = Pptr(p2)->typ->is_cl_obj();
			if (cn1==0 || cn2==0) return 0;
		}
		else {
			p1 = t1->is_ref();
			p2 = t2->is_ref();
			if (p1 && p2) {		// references
				cn1 = Pptr(p1)->typ->is_cl_obj();
				cn2 = Pptr(p2)->typ->is_cl_obj();
				if (cn1==0 || cn2==0) return 0;
			}
			else
				return 0;	// not the same and not classes
		}
	}
	Pclass c1 = Pclass(cn1->tp);
	Pclass c2 = Pclass(cn2->tp);

	if (c1->has_base(c2)) return 1;
	if (c2->has_base(c1)) return 2;
	return 0;
}

Pname Ntmp;
Pname Ntmp_refd;
Pname Ntmp_flag;
extern Pname Ntmp_flag_list;

Pname make_tmp(char c, Ptype t, Ptable tbl)
{
	int dt = 0;
	Pname tn = tbl->t_name;
	Pname cn = t->is_cl_obj();

	if (tn && tn->tp) error('s',"defaultA too complicated");
	if (cn && Pclass(cn->tp)->has_dtor()) dt = 1;
	if (Ntmp == 0 && dt ) Ntmp = cn;

//error('d',"tbl %d cstmt %d %d sti %d",tbl,Cstmt,Cstmt?Cstmt->memtbl:0,sti_tbl);
	if (Cstmt) {	//	make Cstmt into a block
		if (Cstmt->memtbl == 0) Cstmt->memtbl = new table(4,tbl,0);
		tbl = Cstmt->memtbl;
	}
	else if (tbl == gtbl && no_sti == 0) {
		if (sti_tbl == 0) sti_tbl = new table(8,gtbl,0);
		tbl = sti_tbl;
	}

	Pname tmpx = new name(make_name(c));
	tmpx->where = no_where;
	tmpx->tp = t;
	(void) t->tsizeof();
	if ( t->base == COBJ ) {
     		Pclass cl = Pclass(Pbase(t)->b_name->tp);
     		if ( cl->lex_level ) tmpx->lex_level = cl->lex_level;
	}

	TOK scop = ARG;
	if (stat_init && dt) { 
		tmpx->n_sto = STATIC; scop = ARGS; 
	} else if (gtbl == tbl) {
		tmpx->n_sto = STATIC;
	}

	// ARG[S]: no init; ARGS: static dtor
	Pname tmp = tmpx->dcl(tbl,scop); 
	delete tmpx;

	// n_scope == ARGS sets static dtor in simpl2.c
	tmp->n_scope = (scop==ARG) ? FCT : ARGS;
	return tmp;
}

Pexpr init_tmp(Pname tmp, Pexpr init, Ptable tbl)
{
	Pname cn = tmp->tp->is_cl_obj();
	Pname ct = cn ? Pclass(cn->tp)->has_itor() : 0;

	tmp->n_assigned_to = 1;
//error('d',"init_tmp %n ct %n refd %d",tmp,ct,refd);
	if (ct) {	// must initialize
		if (refd) {
//error('d',"'orrible %k",init->e1->base);
			switch (init->e1->base) {	// 'orrible 'ack
			case NAME:
			case REF:
			case DEREF:
				if (init->base == QUEST)
					init = init->address();
				else if (init->e1->tp->is_ptr())
					init = init->e1;
				else
					init = new expr(G_CM,init,init->e1->address());
					
			}
			if (ct->tp->base == OVERLOAD) ct = Pgen(ct->tp)->fct_list->f;	// first fct
			tbl = 0;
			// when tbl==0, call_ctor will not force declaration of ct
			if (ct->n_dcl_printed==0) ct->dcl_print(0);
		}
		return call_ctor(tbl,tmp,ct,init,DOT);
	}

	if (ansi_opt)
		tmp->tp->ansi_const=1;

	Pexpr ass;
	if(init->base == ZERO && tmp->tp->memptr())
		ass = mptr_assign(tmp,init);
	else ass = new expr(ASSIGN,tmp,init); // no ctor: can assign
	ass->tp = tmp->tp;
	return ass;
}

int exact3(Pname nn, Ptype at)
/*
	return 1 if
	match with standard conversions
*/
{
	if (nn == 0) return 0;
	Ptype nt = nn->tp->skiptypedefs();

	if (at == nt) return 1;

	switch (nt->base) {
	case RPTR:
		if (nt->base==RPTR && Pptr(nt)->typ->check(at,COERCE)==0) 
			return 1;
		if (at==zero_type && Pptr(nt)->typ->is_ptr()==0) return 0;
		if (nt->check(at,COERCE)) {
			Pptr pt = at->addrof();
			nt->base = PTR;		// handle derived classes
			if (nt->check(pt,COERCE)) {
				nt->base = RPTR;
				delete pt;
				return 0;
			}
			nt->base = RPTR;
			delete pt;
		}
		break;
	default:
		switch (at->base) {
		default: 
			if (nt->check(at,COERCE)) return 0;
			break;
		case OVERLOAD:
			// the actual argument is an overloaded function
			// we'll try each instance until one matches
			register Plist gl;
			int no_match = 1;

			for (gl = Pgen(at)->fct_list; gl; gl=gl->l) {
				if (nt->check(gl->f->tp,COERCE)==0) {
					no_match = 0;
					break;
				}
			}

			if ( no_match ) return 0;
		} 
	}
	return 1;
}

int exact1(Pname nn, Ptype at)
/*
	return 1 if
	exact match with
		T <-> const T
		X -> X&
		T* -> const T*
		T* -> T*const
	taken into account
*/
{
	if (nn == 0) return 0;
	Ptype nt = nn->tp->skiptypedefs();
	if (at == nt) return 1;
	if (at->base == ZTYPE) at = int_type;

	// if the actual argument is an overloaded function
	// we'll see if any instance matches exactly
	if (at->base == OVERLOAD) {
		register Plist gl;

		for (gl = Pgen(at)->fct_list; gl; gl=gl->l) {
			if (nt->check(gl->f->tp,0)==0) {
				return 1;
			}
		}
		return 0;
	}

	Pptr rt = nt->is_ptr();
	Pptr art = at->is_ptr();

	if (nt->check(at,0)) {
		// handle T <-> const T
		if (const_problem && nt->base != PTR)  return 1;	

		// reject ptmfs of different classes
		if (rt && rt->memof || art && art->memof) return 0;

		rt = nt->is_ref();	//handle X -> X&
		if (rt && (at->check(Pptr(rt)->typ,0)==0 || const_problem))
			return 1;

		if (rt && art) return 0; // ptrs do not match refs

		// handle T* -> const T* and
		// T* -> T*const
		if (rt || (rt = nt->is_ptr())) {
			if (art == 0) art = at->is_ref();
			if (art) {
				if (art->typ->check(rt->typ,0)) {
					if (const_problem && 
					    Pbase(art->typ)->b_const != 1)
						return 1;
				}
				else	// T* -> T*const
					 return 1;
			}
		}
		return 0;
	}
	return 1;
}

int exact2(Pname nn, Ptype at)
/*
	return 1 if
	do integral promotion and float->double on at, then match
*/
{
//error('d',"exact2 nt %t at %t",nn?nn->tp:0,at);
	at = at->skiptypedefs();
	switch (at->base) {
	case EOBJ:
		at = Penum(Pbase(at)->b_name->tp)->e_type;
		break;
	case ZTYPE:
		at = int_type;
		break;
	case CHAR:
	case SHORT:
		at =	(Pbase(at)->b_unsigned && at->tsizeof()==SZ_INT) 
			? 
			uint_type 
			: 
			int_type;
		break;
	case FLOAT:
		at = double_type;
	}

	if (nn == 0) return 0;
	return exact1(nn,at);
}

Pname Ncoerce;
static int ref_cast;
int Nstd;

bit can_coerce(Ptype t1, Ptype t2)
/*	
	return number of possible coercions of t2 into t1,
	Ncoerce holds a coercion function (not constructor), if found
*/
{
	int zz = 0;
	Ncoerce = 0;
	no_const = 0;
	if (t2->base == ANY) return 0;

	if (!t1->check(t2,COERCE))	// see if any std conversions
		return 1;

	//t1 = t1->skiptypedefs();

	if (t1->is_ref()) {
		if (t1->check(t2->skiptypedefs()->addrof(),COERCE) == 0) 
			return 1;

		if (!ref_cast) {		// (T&): no coercions
						// except operator T&()
			Ptype tt1 = Pptr(t1->skiptypedefs())->typ->skiptypedefs();
			int bc;
			if ( tt1->base != PTR && tt1->base != RPTR ) {
     				bc = Pbase(tt1)->b_const;
     				Pbase(tt1)->b_const = 0; 
			}
			int i = can_coerce(tt1,t2);
			if ( tt1->base != PTR && tt1->base != RPTR ) 
     				Pbase(tt1)->b_const = bc;
			if (i) return i;
			zz = 1;
		}
	}

	Pname c1 = t1->is_cl_obj();
	Pname c2 = t2->is_cl_obj();
	int val = 0;
	if (c1 && !ref_cast && !zz) {
		Pclass cl = Pclass(c1->tp);
		if (c2 && same_class(Pclass(c2->tp),cl)) return 1;

                // A more comprehensive test for template classes
		if (c2 && same_class(Pclass(c1->tp), Pclass(c2->tp)))
			 return 1 ;

		/* look for a constructor with one argument
		   or with default for second argument of
		   acceptable type */

		Pname ctor = cl->has_ctor();
		register Pfct f = ctor ? Pfct(ctor->tp) : 0;

		if(f && f->base == FCT) {
			if (f->nargs==1 
			    ||
			    f->nargs > 1 && f->argtype->n_list->n_initializer
			) {
				if (exact3(f->argtype,t2)) {
					val = 1;
				}
			}
		}
		else if (f && f->base == OVERLOAD) {
			register Plist gl;

			for (gl=Pgen(f)->fct_list; gl; gl=gl->l) {
				Pname nn = gl->f;
				Pfct ff = Pfct(nn->tp);

				if (ff->nargs==1 
				    ||
			    	    ff->nargs>1
				    &&
				    ff->argtype->n_list->n_initializer
				) {
					if (exact3(ff->argtype,t2)) {
						val = 1;
						break;
					}
				}
			}
		}
		else if (f) {
			error('i',"cannot_coerce(%k)\n",f->base);
		}
	}

	if (c2) {	
		const int REALLY_EXACT = 6;
		Block(Pname) conv;
		int found = 0;
		Pclass cl = Pclass(c2->tp);
		int best = 0;
		for (Pname ox, on=cl->conv; on; on=ox) {
			ox = on->n_list;
			Pfct f = on->get_fct();
			// const check should be here
			Ptype rt = f->returns;
			Pptr rr = rt->is_ref();
			if (rr && !t1->is_ref()) rt = rr->typ;
			Nstd = 0;
			int howgood = 0;
 			if (t1->check(rt,0) == 0) {
				howgood = REALLY_EXACT;
			}
 			else if (t1->check(rt,COERCE)==0) {
				if (!Nstd) howgood = EXACT;
				else {
					Pname t_nn = new name;
					t_nn->tp = t1->skiptypedefs();
					if(exact2(t_nn,rt)) howgood = PROM;
					else howgood = STD;
				}
			}
			// this check here for the sake of an error message
			if(t2->tconst() && f->f_const==0) {
				if(howgood) no_const++;
				continue;
			}
			if(howgood == 0 || howgood < best) continue;
			if(howgood > best) { found = 0; best = howgood; }
			conv.size(found+1);
			conv[found++] = on;
		}
		if (found) {
			if(found == 1) Ncoerce = conv[0];
			else {
				Bits b = best_conv(conv,found,t1->tconst());
				Ncoerce = conv[b.signif() - 1];
			}
			val = val + found;
		}
	}
	if (val) return val;
	if (c1 && Pclass(c1->tp)->has_itor()) return 0;
	if (t1->check(t2,COERCE)) return 0;
	return 1;
}

int matchable(Pname n, Pexpr arg, int constObj)
/*
	look to see if the argument list "arg" can match a call of "n"
	return worst kind of conversion done or NONE
*/
{
	Pfct f = n->fct_type();
	register Pexpr e;
	register Pname nn;
	int worst = EXACT; 	//for compatibilty

	if (n->is_template_fct()) return 0;

	if(constObj && n->n_oper!=CTOR && !f->f_const && !f->f_static) {
		non_const++;
		return NONE;
	}

	for(e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) {
		if (nn == 0) return f->nargs_known==ELLIPSIS;
		Pexpr a = e->e1;
		Ptype at = a->tp;
		if (at->base==ANY) return NONE;
		if (exact1(nn,at)) {worst=min(worst,EXACT);continue;}
		if (exact2(nn,at)) {worst=min(worst,PROM);continue;}
		if (exact3(nn,at)) {worst=min(worst,STD);continue;}
		int cc = can_coerce(nn->tp,at);
		if (cc != 1) return NONE;
		else worst=UDC;
	}
	if (nn && nn->n_initializer==0) return NONE;
	return min(worst,EXACT);
}

int is_arg;

Ptype expr::call_fct(Ptable tbl)
/*
	check "this" call:
		 e1(e2)
	e1->typ() and e2->typ() has been done
*/
{
	Pfct f;
	Pname fn;
	int x;
	int k;
	Pname nn;
	Pexpr e;
	Ptype t;
	Pexpr arg = e2;
	Ptype t1 = e1?e1->tp:0;
	ambig = 0;
	int argno;
	Pexpr etail = 0;
	bit no_change = 0;
	Pname no_virt = 0;	// set if explicit qualifier was used: c::f()
	Pname chk = 0;		// set if visibility check is needed
				// that is if function name might have been
				// found without use of find_name()
	int const_obj = 0;

	if (t1 == any_type) return any_type;

	switch (base) {
	case CALL:
	case G_CALL:	break;
	default:	error('i',"call_fct(%k)",base);
	}

//error('d',"call %d %k %n arg %d",this,e1->base,e1->base==NAME?e1:0,arg);
	if (t1 == 0) error('i',"call_fct(e1=%d,e1->tp=%t)",e1,t1);
	if (arg && arg->base!=ELIST) error('i',"badAL%d%k",arg,arg->base);

	switch (e1->base) {
	case DTOR: // dummy type destructor
		fn = Pname(e1);
		break;
	case NAME:
		fn = Pname(e1);
		switch (fn->n_oper) {
		case 0:
		case CTOR:
		case DTOR:
		case TYPE:
		case NEW:
		case DELETE:
			break;
		default:	// real operator: check for operator+(1,2);
			{
			if (arg == 0) break;
			Pexpr a = arg->e1;	// first operand

			if (Pfct(fn->tp)->memof	// obj.operator(1) is OK
			|| a->tp->is_cl_obj()
			|| a->tp->is_ref()) break;
			a = arg->e2;
			if (a == 0)		// unary
				error("%k of basicT",fn->n_oper);
			else {			// binary
				a = a->e1;	// second operand
				if (a->tp->is_cl_obj() || a->tp->is_ref()) break;
				error("%k of basicTs",fn->n_oper);
			}
			break;
			}
		}
		break;
	case REF:
	case DOT:
		no_virt = Pname(e1->n_initializer);
		e1->n_initializer = 0;
		if (e1 && e1->e1) {
			Ptype t = e1->e1->tp;
			Pptr tt = t->is_ref();
			t = tt ? tt->typ : t;
			Pptr p_t = t->is_ptr();
			t = e1->base==REF && p_t ? p_t->typ : t;
			tt = t->is_ref();
			t = tt ? tt->typ : t;
			const_obj = t->tconst() ;// ? 1 : e1->e1->is_const_obj();
		}
	case MDOT:
	{	Pexpr n = e1->mem;
	lxlx:
		switch (n->base) {
		case MDOT:
			// reverse mdot (see expr::print())
			//	p->a.b()  => (&p->a)->b() => b(&p->a)
			// or	p->a->b() => (p->a)->b()  => b(p->a)
			// or	oo.a.b()  => (&oo.a)->b() => b(&oo.a)
			// or	oo.a->b() => (oo.a)->b()  => b(oo.a)
		{	
			Pexpr r = e1;
			Pexpr p = r->e1;
			for (Pexpr m = r->mem; m->base==MDOT; m = r->mem) {
				p = new mdot(m->string2,p);
				p->i1 = m->i1+2;
				if (p->mem && Pexpr(p->mem) != Pexpr(1))
					p->tp = p->mem->tp;
				r->mem = m->mem;
				r->e1 = p;
			}
		}
		case REF:
		case DOT:
			n = n->mem;
			goto lxlx;
		case NAME:
		case DTOR:
			break;
		default:
			error('i',"ref %k",n->base);
		}
		fn = Pname(n);
		break;
	}
	case MEMPTR:
	default:
		fn = 0;
	}

lll:
//error('d',"lll: %t %k",t1,t1->base);
	switch (t1->base) {
	case TYPE:
		t1 = Pbase(t1)->b_name->tp;
		goto lll;

	case PTR:	// pf() allowed as shorthand for (*pf)()
		switch (Pptr(t1)->typ->skiptypedefs()->base) {
		case FCT:
		case OVERLOAD:
			if (Pptr(t1)->memof) error("O missing in call throughP toMF");
			t1 = Pptr(t1)->typ;
			fn = 0;
			goto lll;
		}

	default:
		if (fn)
			error("call of%n;%n is a%t",fn,fn,e1->tp);
		else
			error("call of%kE ofT%t",e1->base,e1->tp);

	case ANY:
		return any_type;
	
	case OVERLOAD:
	{
		Pgen g = Pgen(t1);
		Pname found = 0;

		// look for an exact match
		found = g->exactMatch(arg,const_obj);

		// code for calls with template versions 
		if(!found && arg && g->has_templ()) {
			found = has_templ_instance(fn,arg);
		}

		// one argument in call: no need for intersect rule 
		if (!found && arg && arg->e2 == 0) {
			found = g->oneArgMatch(arg,const_obj);
		}

		// multiple arguments in call: potential need for 
		// intersect rule and simple rule
		else if (!found && arg) {
			found = g->multArgMatch(arg,const_obj);
		}

		// no functions are matchable
		if (!found) {
			Block(Pname) tmp(1);
			tmp[0] = fn;
			fmError(0,tmp,arg,const_obj);
			return any_type;
		}

		overFound = chk = fn = found;
		f = fn->fct_type();
		break;
	}

        case FCT:
                f = Pfct(t1);
                if (fn) {
                        if (fn->is_template_fct()) {
                                Pname f_inst = has_templ_instance(fn,arg); 
                                if (f_inst) {
                                        e1 = f_inst; fn = f_inst;
                                        t1 = f_inst->tp; f = Pfct(f_inst->tp);
                                }
                        }
                        else
                                switch (fn->n_oper) {
                                case CTOR:
                                case TYPE:
                                        chk = fn;
                                }
                }
        }

	if (chk) {
		Ptype t = 0;
		Pexpr ee = e1->e1;

		switch (e1->base) {
		case REF:	// ptr->chk()
			if (ee == 0) {	// 0->x() fudge handling new x()
				check_visibility(chk,no_virt,Pclass(chk->n_table->t_name->tp),tbl,cc->nof);
				break;
			};
			t = ee->tp->skiptypedefs();
			t = Pptr(t)->typ;
			break;
		case DOT:	// obj.chk()
			t = ee->tp;
		}

		Pname cn = t?t->is_cl_obj():0;
		Pclass cl = cn?Pclass(cn->tp):0; // class of ``this'' for chk

		if (cl) {
			if (chk->n_oper==CTOR
				&& chk->n_protect
				&& cc->nof
				&& cc->nof->n_oper==CTOR)
					// BUG: cannot handle protected base
					// class constructor
				;
			else {
				check_visibility(chk,no_virt,cl,tbl,cc->nof);
			}
		}
	}

	if (fn && f->returns->is_cl_obj() && f->f_result==0) {
		// protect against class cn; cn f(); ... class cn { cn(cn&); ... };
		make_res(f);
		f->returns->tsizeof();	// make sure it is declared
	}

//error('d',"fn %n %t printed %d",fn,fn?fn->tp:0,fn?fn->n_dcl_printed:0);
	if (fn) {
		// ensure printout of class declaration:
		for (Pname nn=f->argtype; nn; nn=nn->n_list)
			if (nn->tp->is_cl_obj()) (void) nn->tp->tsizeof();
	}

	if (fn && fn->n_dcl_printed==0) {
		if (f->f_inline==0 && f->f_imeasure) {
			extern void uninline(Pname fn);
			uninline(fn);
		}

//		// ensure printout of class declaration:
//		for (Pname nn=f->argtype; nn; nn=nn->n_list)
//			if (nn->tp->is_cl_obj()) (void) nn->tp->tsizeof();

		fn->dcl_print(0);
	}

	if (no_virt && f->f_static==0) {
		if (e1->base==REF || e1->base==DOT) e1->n_initializer = fn;
	}
	else
		fct_name = fn;
//error('d',"fn %n %t %d %d",fn,f,f->f_this,f->f_static);
	if (f->f_this) {	//SSS call of non-static memberfunction
		switch (e1->base) {
		case MEMPTR:
		case REF:
		case DOT:
			break;
		default:
			error("O orP missing for%n ofT %t",fct_name,f);
		}
	}
	else if (fn) {	//SSS call of static function
	sss:
		switch (e1->base) {
		case REF:
		case DOT:
		case MDOT:
			e1 = e1->mem;
			goto sss;
		}
	}

	if (fn) fn->use();	// a patch: ctors are sometimes not use()d

	if (f->f_const==0 && e1->tp && !e1->tp->is_ptr()
	&& (fn==0 || (fn->n_oper!=CTOR && fn->n_oper!=DTOR))) {	//CCC
		switch (e1->base) {
		case REF:
		{	Pptr p = e1->e1->tp?e1->e1->tp->is_ptr():0;
			if (p && p->typ->tconst())
				error("non-constMF%n called for constO",fn);
			break;
		}
		case DOT:
		{
			int tc = e1->e1->tp ? e1->e1->tp->tconst() : 0;
			if (e1->tp && tc && (!strict_opt || tc!=2))
				error("non-constMF%n called for constO",fn);
			break;
		}
		case MEMPTR:
		{
			Pptr p = e1->e1->tp?e1->e1->tp->is_ptr():0;
			if (p && p->typ->tconst())
				error("non-constMF called for constO");
			break;
		}
		}
	}

	t = f->returns;
	x = f->nargs;
	k = f->nargs_known;

	e = arg;
	if (k == 0) goto rlab;

	for (nn=f->argtype, argno=1; e||nn; nn=nn->n_list, e=etail->e2, argno++) {
		Pexpr a;
		int save_base = 0;
		char* save_name = 0;
		bit mpt = (nn && nn->tp && nn->tp->skiptypedefs()->memptr());

		if (e) {
			a = e->e1;
			etail = e;

			if (nn) {	/* type check */
				Ptype t1 = nn->tp->skiptypedefs();
//error('d',"argtp %t etp %t a %k",t1,a->tp,a->base);

				switch (t1->base) {
				case RPTR:
				{	
					Ptype pt = Pptr(t1)->typ;
					if (pt->skiptypedefs()->base==VEC ) {
					   if (pt->check(a->tp,IGNORE_CONST)) {
						error("badA %dT for%n:%t (%tX)",argno,fn,a->tp,nn->tp);
						return any_type;
					   };
					}
					if (pt->base != FCT 
					    ||
					    pt->check(a->tp,0)
					) {
					    is_arg = 1;
					    a = ref_init(Pptr(nn->tp),a,tbl);
					    is_arg = 0;
					}
					goto cbcb;
				}
				case COBJ:
					if (a->base!=G_CM
					|| nn->tp->check(a->tp,ASSIGN))
						a = class_init(0,t1,a,tbl);
					else if (a->e2->tp!=nn->tp)
						a->e2=class_init(0,t1,a->e2,tbl);
					if (nn->n_xref) {
						// (temp.ctor(arg),&arg)
						a = a->address();
					}
					else {
						// defend against:
						//	int f(X); ... X(X&);
						Pname cln = Pbase(t1)->b_name;	
						if (cln && Pclass(cln->tp)->has_itor()) {
							// mark X(X&) arguments
							nn->n_xref = 1;
							a = a->address();
						}
					}
	cbcb:
//error('d',"cbcb: a %d %k %t",a->base,a->base,a->tp);
		if (a->base==G_CM) {
			if (a->e1->base==DEREF) a->e1 = a->e1->e2; // (*e1,e2) => (e1,e2)
			if (a->e1->base==G_CALL
			&& Pname(a->e1->fct_name)
			&& Pname(a->e1->fct_name)->n_oper==CTOR
			&& (a->e2->base==G_ADDROF || a->e2->base==ADDROF)) {
				a = a->e1;	// (ctor(&tmp),&tmp) => ctor(&tmp)
				goto cccc;
			}
			else if (a->e2->base==G_ADDROF
			&& a->e2->e2->base==NAME)  {
			cccc:
			    if (t1->base==RPTR && Pptr(t1)->typ->tconst()==0) {
				if (strict_opt)
				    error("temporary used for non-const%tA",nn->tp);
				else
				    error('w',"temporary used for non-const%tA; no changes will be propagated to actual argument (anachronism)",nn->tp);
			    }
			}
		}
					e->e1 = a;
					break;
				case ANY:
					goto rlab;
				case PTR:
				{
					save_base = e->e1->base;
					if(a->tp->base==OVERLOAD)
						save_name = Pgen(a->tp)->fct_list->f->string;
					Pexpr te_a = a;
					e->e1 = a = ptr_init(Pptr(t1),a,tbl);
					no_change = (te_a == a);
					if (Pchecked == 0) goto def;
					break;
				}
				case CHAR:
				case SHORT:
				case INT:
				{	Ptype t = a->tp->skiptypedefs();
					switch (t->base) {
					case LONG:
					case FLOAT:
					case DOUBLE:
					case LDOUBLE:
					    if(!ambig)
						error('w',"A%d: %t passed as %t",argno,a->tp,t1);
					}
				}
					// no break
				case LONG:
					if (Pbase(t1)->b_unsigned
					&& a->base==UMINUS
					&& a->e2->base==ICON)
						error('w',"negativeA for%n, unsignedX",fn);
				default:
				def:
				{	Pexpr x = try_to_coerce(t1,a,"argument",tbl);
					int ct = no_const;
//error('d',"x %d t1 %t nn %t a1 %t",x,t1,nn->tp,a->tp);
					if (x) {
 						if (t1->is_ptr() && Pchecked == 0 && no_change) {
							Pexpr te_x = ptr_init(Pptr(t1), x, tbl);

							if ( te_x != x ) e->e1 = a = te_x; else e->e1=x;
						}
						else
							e->e1 = x;
					}
					else if (nn->tp->check(a->tp,ARG)) {
						error('e',"badA %dT for%n:%t (%tX)",argno,fn,a->tp,nn->tp);
						if (ct) error('c'," (no usable const conversion)\n");
						else error('c',"\n");
						return any_type;
					}
				}
				}

                                Pexpr tt = e->e1;
                                while ( tt->base == CAST || tt->base == G_CAST )
                                        tt = tt->e1;
                                if ( tt->base == ILIST )
                                        e->e1 = tt;

                                if (e->e1->base == ILIST) {
                                        // memptr constant
                                        // f({1,2,f}) ==> memptr t; f((t={1,2,f},t))
					if(save_base == REF) {
						Pptr m = Pptr(a->tp);
						error(
						"address of boundF (try using ``%s::*'' forPT and ``&%s::%s'' for address)",
						m->memof->string,
						m->memof->string,
						save_name
						);
					}
					if (mpt) {
	                                        Pname temp = make_tmp('A',mptr_type,tbl);
       	                                	e->e1 = mptr_assign(temp,e->e1);
                                        	e->e1 = a = new expr(G_CM,e->e1,temp);
                                        	a->tp = temp->tp;
					}
					else {
						Ptype t = e->e1->e1->e1->tp;
						e->e1 = e->e1->e1->e1;
						a->tp = e->e1->tp = t;
					}
                                }

			}
			else {
				if (k != ELLIPSIS) {
					error("unexpected %dA for%n",argno,fn);
					return any_type;
				}
				if (!a->tp->skiptypedefs()->check(void_type, 0))
					error("badA %dT for%n:%t",argno,fn,a->tp);
				Pexpr te=e;
				while(e) {
					if (e->tp)
						e->tp->tsizeof();
                                	if (e->e1->base == ILIST) {
                                        	// memptr constant
                                        	// f({1,2,f}) ==> memptr t; f((t={1,2,f},t))
                                        	Pname temp = make_tmp('A',mptr_type,tbl);
                                        	e->e1 = mptr_assign(temp,e->e1);
                                        	e->e1 = a = new expr(G_CM,e->e1,temp);
                                        	a->tp = temp->tp;
                                	}
					e = e->e2;
				}
				e = te;
				goto rlab;
			}
		}
		else {	/* default argument? */
			a = nn->n_initializer;
			if (a == 0) {
				if (fn == 0)
				    error("A %d ofT%tX for call",argno,nn->tp);
				else
				    error("A %d ofT%tX for%n",argno,nn->tp,fn);
				return any_type;
			}
                        if (a->base == ILIST ||
			    ((a->base == CAST || a->base == G_CAST) && a->e1->base == ILIST)) {
                                // memptr constant
                                // f({1,2,f}) ==> memptr t; f((t={1,2,f},t))
                                Pname temp = make_tmp('A',mptr_type,tbl);
				if (a->base != ILIST)
					a = a->e1;
                                a = mptr_assign(temp,a);
                                a = new expr(G_CM,a,temp);
                                a->tp = temp->tp;
                        }
			a->permanent = 2;	// ought not be necessary, but it is
			e = new expr(ELIST,a,0);
			if (etail)
				etail->e2 = e;
			else
				e2 = e;
			etail = e;
		}
	}

rlab:
//error('d',"rlab fct_name %n %t",fct_name,fct_name?fct_name->tp:0);
	for (; e; e = e->e2) {	// unchecked arguments
		Pexpr a = e->e1;
		Pname cn;

		if (a->base==NAME && a->tp->base==FCT) {
			// function name that escaped the type system:
			// update use count
			a->lval(ADDROF);
		}
		else if (warning_opt && (cn = a->tp->is_cl_obj())) {
			Pclass cl = Pclass(cn->tp);
			if (cl->has_ctor() || cl->memtbl->look("__as",0))//cl->has_oper(ASSIGN)
			{
				if (fct_name)
				error('w',"O ofC%t withK or = copied asA to%n (%t)",cl,fct_name,fct_name->tp);
				else
				error('w',"O ofC%t withK or = copied asA to `...'",cl);
			}
		}
		else if (a->tp->is_ref())
			e->e1 = a->contents();
	}

	if (f->f_result) {		// f(args) => (f(&temp,args),temp)
		Pname oldNtmp = Ntmp; 
		Ntmp = 0;  // set in make_tmp if tn has associated dtor
		Pname tn = make_tmp('R',f->returns,tbl);

		extern bit in_quest;
		if (Ntmp) {
                	if (Ntmp_refd && in_quest) {
			 	tn->n_list = Ntmp_refd;	
                        	Ntmp_refd = tn;
			}
                	else Ntmp_refd = tn;
		}

		// better might be: if (Ntmp == 0 && oldNtmp)
		// but this mimics the old behavior ...
                if (oldNtmp) Ntmp = oldNtmp;

                if (Ntmp_refd && in_quest) {
                        Ntmp_flag = make_tmp('Q',int_type,tbl);
                        Ntmp_flag->n_initializer = new ival(0L);
                        Ntmp_flag->assign();
                        if (Ntmp_flag_list && in_quest) {
				Ntmp_flag->n_list = Ntmp_flag_list;
                                Ntmp_flag_list = Ntmp_flag;
			}
                        else Ntmp_flag_list = Ntmp_flag;
                }

		e2 = new expr(ELIST,tn->address(),e2);
		Pexpr ee = new expr(0,0,0);
		*ee = *this;
		base = G_CM;		// (f(&temp,args),temp)
		e1 = ee;
		if (refd == 2)
			e2 = tn->address();
		else e2 = tn;
		tp = tn->tp;
	}

	return t;
}

Pexpr ref_init(Pptr p, Pexpr init, Ptable tbl)
/*
	initialize the "p" with the "init"
	remember to call ptr_init to ensure that pointers to second bases
	are handled correctly.
*/
{
	register Ptype it = init->tp->skiptypedefs();
	Pptr px = Pptr(p->skiptypedefs());
	Ptype p1 = px->typ;
	Pname c1 = p1->is_cl_obj();
// error('d',"ref_init: p %t, p1 %t, px %t, init->tp %t",p,p1,px,it);
// error('d', "ref_init: nof: %n f_const: %d", cc?cc->nof:0, cc?(cc->nof?Pfct(cc->nof->tp)->f_const:0):0);

	if (init->base == ILIST) error("IrL as RIr");

	if (init->base==NAME
	&& Pname(init)->n_scope==ARG
	&& init->tp->base==FLOAT)
		error('w',"initializing a float& with floatA is non-portable");

	Ptype tt = it->addrof();
	px->base = PTR;	// allow &x for y& when y : public x
			// but not &char for int&
	int x = px->check(tt,COERCE);

	if (x == 0) {	//CCC type is fine check for constness:
		if (init->tp->tconst()
		    && vec_const==0
		    && fct_const==0) {
			// not ``it''
			if (init->base == ELIST) init = init->e1;
			if (px->typ->tconst() == 0) 
				if (cc->nof && in_return)
					error("cannot return a reference to a non-constO from const member function %n",cc->nof); 
				else error("R to constO");
			px->base = RPTR;
			// if we have a const lvalue we can still pass its address
			ignore_const++;
			if (init->lval(0)) {
				init->lval(ADDROF); // force output
				ignore_const--;
//error('d',"in1 %t",init->tp);
				return ptr_init(px,init->address(),tbl);//return init->address();
			}
			ignore_const--;
			goto xxx;
		}
		px->base = RPTR;
                if (init->lval(0)) {	// can pass the address							// no temporary needed 
			init->lval(ADDROF); // force output
//error('d',"px %t init %t ",px,init->tp);
                        {  Pname name_in_deref =0;
                           Pexpr act_param=0, ret_exp=0;
                           if ((init->base == DEREF) &&
                               (init->e1 && (init->e1->base == NAME))
                              ) {
                              name_in_deref = Pname(init->e1);
                           };

                           if (name_in_deref		&&
                               (name_in_deref->n_xref   	&&
                                name_in_deref->n_scope == ARG)
                              ) {

				//"n_xref" is set when a formal class object
				//is treated as a pointer object, in Print phase

				//let us make it as a pointer expression, so
				//ptr_init logic works correctly (generates
                                //valid MDOT expression when necessary).
                                //But have to watch out while printing "mem"
                                //of MDOT expression in expr::print (print.c).

			      if (init->e1->tp) {
                              act_param = new expr (G_ADDROF, 0, init->e1);
                              act_param->tp  = init->e1->tp->addrof(); 
//error('d',"px %t act_param %t ",px,act_param->tp);
                              ret_exp = ptr_init(px, act_param, tbl);
		  	      } else {
			   	error ("i", "No type for actual param %n",
				 	name_in_deref);
                              }
                           } else {
                           ret_exp = ptr_init(px, init->address(),tbl);
			   };
                           return ret_exp;
                        };
		}
		goto xxx;
	}

	px->base = RPTR;

//error('d',"c1 %n",c1);

	if (c1) {	// assigning to a const X & is fine
		ref_cast++;
		Pexpr x = try_to_coerce(p,init,"reference initialization",tbl);
		ref_cast--;
		if (x) {
			init = x;
			goto xxx;
		}
		if (init->tp->tconst() && !vec_const && !p1->tconst()) {
			error("R to constO");
			return init;
		}
		switch ( init->base ) {
			case STRING: case ZERO: case CCON:
			case ICON: case FCON: case IVAL:
			case NAME:
				refd = 1; 
				break;
			default:
				refd = (init->e1 && init->e1->base == NAME && 
					init->e1->tp->base != RPTR &&
					Pname(init->e1)->n_xref == 0) ? 2: 1;
				break;
		}
// error('d', "***** refd: %d", refd );
		Pexpr a = class_init(0,p1,init,tbl);
		refd = 0;
		if (a==init && init->tp!=any_type) goto xxx;
// error('d',"ri a %d %k",a->base,a->base);
		switch (a->base) {
		case G_CALL:
			init = a;
			goto xxx;
		}
		switch (init->base) {
		case CM:
		case G_CM:
			break;
		case NAME:
		case DEREF:
		case REF:
		case DOT:
			if ((it->tconst()==0 || vec_const)
		    	    &&
		    	    (fct_const==0 || p1->is_ptr()==0)
			) 
				break;
		default:
			if (p1 && p1->b_const==0) {
		    	    if (tbl == gtbl || (strict_opt && !is_arg)) 
				error("Ir for%snon-constR not an lvalue", strict_opt?"":" global ");
		    	    else if(!is_arg)
				error('w',"Ir for non-constR not an lvalue (anachronism)");
			}
		}
		a = a->address();
		a =  ptr_init(px,a,tbl);
		return a;
	}

//error('d',"p1 %t it %t",p1,it);
	if (p1->check(it,0)) {

		if (p1->check(it,ASSIGN) == 0) {
			goto def;
		}

		Pexpr x = try_to_coerce(p1,init,"reference",tbl);     // x==init
		if (x==0) 
			x = try_to_coerce(px,init,"reference",tbl); // x&=init
		if (x) {
			init = x;
			goto def;
		}
		int nc = no_const;

		Pptr p1_ptr = p1->is_ptr();

		if (p1_ptr && p1_ptr->typ->skiptypedefs()->base == FCT
		    &&
		    it->is_or_pts_to(OVERLOAD)
		) {
			Pexpr op = ptof(
				Pfct(p1_ptr->typ->skiptypedefs()),
				init,
				tbl
			);
			if(op) {init = op; goto def; }
		}

		error('e',"badIrT:%t (%tX)",it,p);
		if (nc) error('c'," (no usable const conversion)\n");
		else error('c',"\n");
		if (init->base != NAME) init->tp = any_type;
		return init;
	}
	
xxx:	/*
		here comes the test of a ``fundamental theorem'':
		a structure valued expression is
			(1) an lvalue of type T (possibly const)
		or	(2) the result of a function (a _result if X(X&) is defined)
		or	(3) a * or [] or ? or , expression
	*/
//error('d',"xxx %k %d %t",init->base,init->base,init->tp);

	switch (init->base) {
	case NAME:
	case DEREF:
	case REF:
	case DOT:			// init => &init
		{
			bit it_isconst = it->tconst();
			bit vec_const_save = vec_const;
			bit fct_const_save = fct_const;

			if (	(init->base==NAME && Pname(init)->n_stclass==ENUM)
				||
				it_isconst
				&&
				Pbase(p->typ) && !Pbase(p->typ)->tconst()
				&&
				vec_const_save==0 && fct_const_save==0
			) {
				goto def;
			}
			init->lval(ADDROF);

			if (vec_const_save) return init;
			if (fct_const_save && p1->is_ptr()) goto def;	// fptr& = fct
		}
		// no break
	case CM:
	case G_CM:			// & (f(&temp), temp)
		return ptr_init(px,init->address(),tbl);//init->address();
	default:
	def:
	{
// error('d',"def: init->tp %t p1 %t ",init->tp,p1);	
		if (p1 && p1->b_const==0) {
			if (tbl == gtbl || (strict_opt && !is_arg)) 
				error("Ir for%snon-constR not an lvalue", strict_opt?"":" global ");
			else if(!is_arg)
				error('w',"Ir for non-constR not an lvalue (anachronism)");
		}

                Pname tcl = p1->is_cl_obj ();
                if(tcl && Pclass(tcl->tp)->c_abstract) {
                       error("a temporary is needed for a parameter, but the AT is abstractC %t.", tcl->tp);
		       error('C',"%a is a pure virtualF ofC%t",Pclass(tcl->tp)->c_abstract,tcl->tp);
		}

		no_sti=1;
		Pname n = make_tmp('I', unconst_type(p1), tbl);
		no_sti=0;
		n->assign();
		if (tbl == gtbl) n->dcl_print(0);	// a hack
		Pexpr a = 0;
		Pname ic = init->tp->is_cl_obj();

		switch (p1->base) {
		case INT:
		case CHAR:
		case SHORT:
			switch (it->base) {
			case LONG:
			case FLOAT:
			case DOUBLE:
			case LDOUBLE:
				error('w',"%t assigned to %t inRIr",it,p1);
			}
		}

		if (ic && c1 && ic!=c1 && !same_class(Pclass(ic->tp),Pclass(c1->tp))) {
			// derived class1 => must cast: ``it Ix; (Ix=init,(p)&Ix);''
			n->tp = init->tp;
			a = ptr_init(px,n->address(),tbl);//n->address();
			PERM(p);
			a = new texpr(G_CAST,p,a);
			a->tp = p;
		} else if (!ic && !c1 && init->tp->is_ptr() && p1->is_ptr()) {
			Pname icx = (Pptr(init->tp->skiptypedefs()))->typ->is_cl_obj();
			Pname c1x = (Pptr(p1->skiptypedefs()))->typ->is_cl_obj();
			if (icx && c1x && icx!=c1x && !same_class(Pclass(icx->tp),Pclass(c1x->tp))) {
				// Base*const& = Derived*
				init = ptr_init(Pptr(p1->skiptypedefs()),init,tbl);
			}
		}
		if (!a)
			a = n->address();

		refd = 1;
		Pexpr as;
		if (init->tp->memptr()
		    ||
		    init->tp->base == FCT && Pfct(init->tp)->memof
		) {
			Ptype pit = p->typ->skiptypedefs();
			as = mptr_assign(n,ptof(Pfct(pit),init,tbl));
		}
		else {
			as = init_tmp(n,init,tbl);
		}
		refd = 0;
		a = new expr(G_CM,as,a);
		a->tp = a->e2->tp;
		return a;
	}
	}
}

Pexpr class_init(Pexpr nn, Ptype tt, Pexpr init, Ptable tbl)
/*
	initialize "nn" of type "tt" with "init"
	if nn==0 make a temporary,
	nn may not be a name
*/
{	
	if (init == dummy) return 0;
//error('d',"class_init %t with %t init %k refd %d",tt,init->tp,init->base,refd);
	Pname c1 = tt->is_cl_obj();

        if (init == 0) {
                error("emptyIr");
                return dummy;
        }

	if (c1) {
		Pclass cl = Pclass(c1->tp);
		Pname c2 = init->tp->is_cl_obj();


		if ((c1!=c2 && (c2 == 0 || same_class(cl,Pclass(c2->tp),1) == 0))
		     || (refd==0 && cl->has_itor())) 
		{ // really ought to make a temp if refd, 
		  // but ref_init can do that

			int i = can_coerce(tt,init->tp);
//error('d',"i %d nn %n",i,nn);
			switch (i) {
			default:
				error("%d ways of making a%n from a%t",i,c1,init->tp);
				init->tp = any_type;
				return init;
			case 0:
				if (c2 && Pclass(c2->tp)->has_base(cl)) {
					init = init->address();
					Pexpr x = cast_cptr(cl,init,tbl,0);

					if (x == init) {
						Ptype pt = tt->addrof();
						PERM(pt);
						x = new cast(pt,init);
					}

					return x->contents();
				}
				error("cannot make a%t from a%t",cl,init->tp);
				init->tp = any_type;
				return init;
			case 1:
//error('d',"ncoerce %n %k %d",Ncoerce,init->base,init->base);
				if (Ncoerce == 0) {
					Pexpr a = new expr(ELIST,init,0);
					a = new texpr(VALUE,tt->skiptypedefs(),a);
					a->e2 = nn;
					a = a->typ(tbl);
//error('d',"ci a %k %d %t",a->base,a->base,a->tp);
					return a;
				}

				switch (init->base) {
				case CM:
				case G_CM:	//ddd
				case NAME:	/* init.coerce() */
	/* *ref */		case DEREF:
				{
					Pref r = new ref(DOT,init,new name(Ncoerce->string));
					Pexpr rr = r->typ(tbl);
					init = new expr(G_CALL,rr,0);
					break;
				}
				default:	// (temp=init,temp.coerce())
				{	Pname tmp = make_tmp('U',init->tp,tbl); 
					int x = refd;	
					refd = 0;	// ??
					Pexpr ass = init_tmp(tmp,init,tbl);
					refd = x;
					Pref r = new ref(DOT,tmp,new name(Ncoerce->string));
					Pexpr rr = r->typ(tbl);
					Pexpr c = new expr(G_CALL,rr,0);
					c = c->typ(tbl);
					init = new expr(CM,ass,c);
					init->tp = c->tp;
					if (refd) {	// &f() => (t=f(), &t)
						Pname tmp2 = make_tmp('L',c->tp,tbl); 
						ass = init_tmp(tmp2,init,tbl);
						init = new expr(G_CM,ass,tmp2);
					}
				}
				}
//error('d',"nn %n",nn);
				if (nn) {
					Pexpr a = new expr(ELIST,init,0);
					a = new texpr(VALUE,tt->skiptypedefs(),a);
					a->e2 = nn;
					return a->typ(tbl);
				}
			}
//error('d',"c1 %n c2 %n",c1,c2);
			return init->typ(tbl);
		}
		return init;
	}
//error('d',"ci check tt %t init->tp %t",tt,init->tp);
	if (tt->check(init->tp,ASSIGN) && refd==0) {
		error("badIrT:%t (%tX)",init->tp,tt);
		init->tp = any_type;
	}

	return init;
}

extern int bound;	// fudge for bound pointers to functions

Pexpr expr::docast(Ptable tbl)
{	
	// check cast against value, INCOMPLETE

//error('d',"docast %d %t %k",this,tp2,e1->base);
	if (e1 == dummy) {
		error("E missing for cast");
		tp = any_type;
		return this;
	}

	int pmf = 0;
	int ptom_cast = 0;
	int noconst = 0;
	Pexpr ee = e1;

//error('d',"ee %k %d",ee->base,ee->base);
	switch (ee->base) {
	case ADDROF:
		ee = ee->e2;
		switch (ee->base) {
		case NAME:	goto nm;
		case REF:	goto rf;
		}
		break;

	case NAME:
	nm:
		if (Pname(ee)->n_qualifier) pmf = 1;
		break;
		
	case REF:
	rf:
		if (ee->e1->base == THIS) bound = 1;
		break;
	}

	e1 = e1->typ(tbl);

	int b = bound;	// distinguish between explicit and implicit THIS
	bound = 0;
	//pmf = pmf && e1->base==CAST;
	pmf = pmf && ((e1->base==CAST || e1->base==G_CAST) || e1->base==ILIST);

	Ptype etp = e1->tp->skiptypedefs();
	Ptype tt = tp2;
	Ptype t = tt;
	tt->dcl(tbl);

	tt = tt->skiptypedefs();
	
//error('d',"e1 %k etp %t tt %t",e1->base,etp,tt);
	bit isptm = 0;
	switch (etp->base) {
	case PTR:
		if (!etp->memptr())
			break;
		if (etp->memptr()->f_static)
			break;
		isptm = 1;
		break;
	case FCT:
		if (!Pfct(etp)->memof)
			break;
		if (Pfct(etp)->f_static)
			break;
		isptm = 1;
		break;
	case ILIST:
		isptm = 1;
		break;
	}
	if (isptm && !tt->memptr() && tt->base != VOID)
		error(strict_opt ? 0 : 'w', "cast to%t ofP toM (anachronism)", tt);

	switch (etp->base) {
	case PTR:
	case RPTR:
		if (Pptr(etp)->typ->base == OVERLOAD) goto over;
		if (Pptr(etp)->typ->base == FCT && Pfct(Pptr(etp)->typ)->fct_base)
			goto over;
		if (warning_opt && i2==0 && Pptr(etp)->typ->tconst()) {
			switch (tt->base) {
			case FCT:
				break;
			case PTR:
			case RPTR:
				if (Pptr(tt)->typ->tconst()) break;
			default:
				// casting away const
				// should be an error
				// but ANSI says OK so I chicken out
				// to be able to compile strtok(), etc.
				error('w',"const cast away:%t->%t",e1->tp,tp2);
			}
		}
		else
			i2 = 0; // to allow cfront to escape its own checking
		break;
	case COBJ:
	{	ref_cast = 1;
		Pexpr x = try_to_coerce(tt,e1,"cast",tbl);
		if (!x && tt->base == EOBJ)
			x = try_to_coerce(int_type, e1, "cast", tbl);
		noconst = no_const;
		ref_cast = 0;
//error('d',"x %k %t tt %d %t",x?x->base:0,x?x->tp:0,tt,tt);
		if (x) {
			if (x!=e1 && x->base==DEREF && tt->is_ref()) x = x->e1;
			if (tt==x->tp || tt->check(x->tp,0)==0 || const_problem)
				return x;
			else
				return new cast(tt,x);
		}
		break;
	}
	case VOID:
		if (tt->base == VOID) {
			tp = t;
			return this;
		}
		error("cast of void value");
		// no break;
	case ANY:
	any:
		tp = any_type;
		return this;
	case FCT:
		if (tt->base == PTR && Pptr(tt)->typ->base != FCT)
			error('w',"P toF cast toP to nonF");
		if (Pfct(etp)->fct_base)
			goto over;
		break;
	case OVERLOAD:
	over:
		error("cast of overloaded");
		goto any;
	}

//error('d',"tt %t",tt);
	switch (tt->base) {
	case VEC:
		error("cast to arrayT %t", tt);
		break;
	case PTR:
		if (tt->memptr()) {
			if (etp->memptr() == 0
			    &&
			    (etp->base!=FCT || Pfct(etp)->memof == 0)
			) {
				if (etp->base == ZTYPE) {
					e1 = new expr(ELIST,zero,zero);
					e1 = new expr(ILIST,e1,zero);
					e1->tp = tt;
					return e1;
				}
				error("cast toP toM %t",tt);
			}

			else {	// adjust delta in MI case
				// for the moment just suppress the cast
				// all pmfs are the same to cc
				ptom_cast = 1;
				tp2 = mptr_type;
			}
		}

		switch (etp->base) {
		case COBJ:
			error('e',"cannot castCO toP");
			if (noconst) error('c'," (no usable const conversion)\n");
			else error('c',"\n");
			break;
		case FCT:
			e1 = new expr(G_ADDROF,0,e1);
			bound = b;
			e1 = e1->typ(tbl);
			bound = 0;
			if (e1->base == CAST || e1->base == G_CAST)
				pmf = 1;
			else
				break;
			// no break;

		case RPTR:
		case PTR:
		{	Pname cn = Pptr(tt)->typ->is_cl_obj();
			if (cn) {
				Pexpr x = cast_cptr(Pclass(cn->tp),e1,tbl,base==CAST?1:0);

				if (x == e1) {
					PERM(tt);
					e1 = new cast(tt,e1);
					e1->i2 = i2;
				}
				else
					e1 = x;
			}
			if (pmf) {
				tt = tt->skiptypedefs();

				switch (tt->base) {
				case PTR:
					if (Pptr(tt)->memof) break;
				default:
					error("%t cast to%t (%t is not aP toM)",e1->tp,tp2,tp2);
				}
			}
		}
		}
		break;

	case RPTR:		// (x&)e: pretend e is an x
	{	Ptype er = etp;
		Ptype cr = tt;
		do {
			if (er = er->is_ptr_or_ref()) er = Pptr(er)->typ;
			if (cr = cr->is_ptr_or_ref()) cr = Pptr(cr)->typ;
		} while (er && cr);
		int pp = er!=0;	//	if `e' is a suitable pointer cast it:
				// 	(x&)e => (x*)e, otherwise
				//	(x&)e => *(x*)&e
// error('d',"rptr tt %t e1->base %k e1->tp %t",tt,e1->base,e1->tp);
		if (e1->base==G_CM
		|| e1->base==CALL
		|| e1->base==G_CALL
		|| e1->lval(0))
			;
		else if (e1->tp->tconst()) {
				// casting away const
				// should be an error
				// but ANSI says OK so I chicken out
				// to be able to compile strtok(), etc.
			if (warning_opt && Pptr(tt)->typ->tconst()==0)
				error('w',"const cast away:%t->%t",e1->tp,tp2);

		}
		else
			error("cannot cast%t to%t",etp,t);
//error('d',"e1 %k %t %d",e1->base,e1->tp,pp);
		if (pp == 0) e1 = e1->address();	// *(x*)&e
		tp = t;

		// do proper pointer manipulation for multiple inheritance
		Pname cn = Pptr(tt)->typ->is_cl_obj();
		if (cn) {
			Pexpr x = cast_cptr(Pclass(cn->tp),e1,tbl,base==CAST?1:0);

			if (x == e1) {
				PERM(tt);
				e1 = new cast(tt,e1);
				e1->i2 = i2;
			}
			else
				e1 = x;
		}

		return pp ? this : contents();
	}
	case COBJ:
		base = VALUE;	// (x)e => x(e): construct an x from e
		e1 = new expr(ELIST,e1,0);
		return typ(tbl);

	case CHAR:
	case INT:
	case SHORT:
	case LONG:
	case EOBJ:
		switch (etp->base) {
		case FCT:
			e1 = new expr(ADDROF,0,e1);
			e1 = e1->typ(tbl);
		case PTR:
			if(!e1->tp->memptr() && e1->tp->tsizeof()>tt->tsizeof())
				error("type ``%t'' not large enough for values of ``%t ''",tt,etp);
			break;
		case COBJ:
			error('e',"cannot castCO to%k",tt->base);
			if (noconst) error('c'," (no usable const conversion)\n");
			else error('c',"\n");
			break;
		}	
		break;

	case FLOAT:
	case DOUBLE:
	case LDOUBLE:
		switch (etp->base) {
		case FLOAT:
		case DOUBLE:
		case LDOUBLE:
		case CHAR:
		case INT:
		case SHORT:
		case LONG:
		case EOBJ:
		case ZTYPE:
			break;
		default:
			error("cannot cast ``%t '' to ``%t''",etp,tt);
			break;
		}	
		break;

	case FCT:
		error("cannot cast toFT");
		break;
	}

	tp = t;

	if (e1->base==ILIST && ptom_cast==0) { // ptm constant
		Pexpr ee = e1->e1;	// ELIST
		int i;
		switch (ee->e2->base) {
		case IVAL:
			i = int(ee->e2->i1);
			break;
		case ZERO:
			i = 0;
		}

		if (i<0)
			e1 = e1->e2;	// just the function
		else
			e1 = ee->e2;	// just the index
		return this;
	}

	if (etp->memptr()) {
		Pclass cl = Pptr(etp)->memof;

		if (Pptr(tt)->memof==0 && b == 0 ) {
			Pexpr y;
			if((e1->base == G_CAST || e1->base == CAST) && 
			    e1->e1->base == ILIST) {
				e1 = e1->e1;
				y = e1->e2;
			}
			else  {
				y = new mdot("f",e1);
				y->i1 = 9;
			}
			y = new cast(tt,y);
			if (cl->virt_count && b==0) {
				// ERROR: no check for side effects
				Pexpr z = new mdot("i",e1);
				Pexpr x = new mdot("i",e1);
				x->i1 = 9;
				x = new cast(tt,x);
				z->i1 = 9;
				Pexpr q = new expr (QUEST,x,y);
				q->cond = new expr(LE,zero,z);
				q->tp = tt;
				delete this;
				return q;
			}
			delete this;
			return y;
		}
	}

	return this;
}

Pexpr expr::dovalue(Ptable tbl)
{
	Ptype tt = tp2;
	Pclass cl;
	Pname cn;

// error('d',"value %d %t e1 %d e2 %d",tt,tt,e1,e2);
	
	tt->dcl(tbl);

	tt = tt->skiptypedefs();

	switch (tt->base) {
	case EOBJ:
	default:
		if (e1 == 0) {
			//error("value missing in conversion to%t",tt);
			e1 = zero;
		} else { // convert elist to expr 
			if ( e1->e2 == 0 ) {
				e1 = e1->e1;
                                if (e1->base==NAME && e1->permanent == 0)
                                        PERM(e1);
			}
			else { // int( x, y )
				error("more than oneA for basicTK");
				for ( Pexpr e = e1;  e->e2->e2;  e = e->e2 )
					e->base = CM;
				e->base = CM;
				e->e2 = e->e2->e1;
			}
		}
		base = G_CAST;
		return typ(tbl);

	case CLASS:
		cl = Pclass(tt);
		if (cl->this_type)
		tp2 = Pptr(cl->this_type)->typ;
		break;

	case COBJ:
		cn = Pbase(tt)->b_name;
		cl = Pclass(cn->tp);
	}

	Pname ctor = cl->has_ctor();

//error('d',"e1 %k e1->e2 %k",e1->base,e1?e1->e2->base:0);
	if (e1 && e1->e2==0) {		// single argument
		if (e1->e1->base==ELIST) e1->e1 = e1->e1->e1;	// spurious elist
		e1->e1 = e1->e1->typ(tbl);
		if (tt->base==COBJ) {
			Pexpr x = try_to_coerce(tt,e1->e1,"type conversion",tbl);
			if (cl->has_itor()==0) {
				if (x)
					return x;
			}
			else {
				if (x && x->base != DEREF)
					return x;
			}
		}

		Pname acn = e1->e1->tp->is_cl_obj();
//error('d',"acn %n %d",acn,cl->has_itor());
		if (acn && cl->has_itor()==0) {
			Pclass acl = Pclass(acn->tp);
			int hb = acl->has_base(cl);

			// special case handling: Base(Derived);
			if (ctor && hb) {
				Pname n = 0;
				switch (ctor->tp->base) {
				case OVERLOAD:
   					n = Pgen(ctor->tp)->exactMatch(e1,0);
   					if (n) ctor = n;
   					break;
				case FCT: // improbable ever be traversed
					{
   					Pfct f = Pfct(ctor->tp);
   					if ( f->nargs != 1 ) break;
   					n = exact1(f->argtype,e1->e1->tp) ? ctor : 0;
   					break;
					}
				}
				if (n) goto mk_ctor_call;
			}

			if (same_class(acl,cl) || hb) {
				vcllist->clear();
				vcllist=0;
				if (1<is_unique_base(acl,cl->string,0)) error("ambiguous assignment to base %t",cl);
				Pexpr ee = e1->e1;
				if (ee->base == ELIST) ee = ee->e1;	// ???
				if (hb) {	// ee => *(tp2*)&ee
						// remember = may be overloaded
//error('d',"hb %k %t %d",ee->base,ee->tp,ee->lval(0));
					ignore_const++;
					if (ee->lval(0)==0) {
						Pname tmp = make_tmp('T',ee->tp,tbl);
						ee = init_tmp(tmp,ee,tbl);
						ee = new expr(G_CM,ee,tmp->address());
					}
					else
						ee = ee->address();
					ignore_const--;
					ee = new texpr(G_CAST,new ptr(PTR,tp2),ee); //new cast(new ptr(PTR,tp2),ee);
					ee = ee->contents();
					ee->typ(tbl);
				}

				if (e2) {	// x(x_obj) => e2=x_obj
					base = ASSIGN;
					e1 = e2;
					e2 = ee;
					tp = tp2;
					return this;
				}
				return ee;	// strip ELIST: x(x_obj) => x_obj
			}
		}
	}


	/* x(a) => obj.ctor(a); where e1==obj */
	if (ctor == 0) {
		error("cannot make a%t",cl);
		return dummy;
	}

// error('d',"e2 %k",e2?e2->base:0);
mk_ctor_call: // beats duplicating the code

	if (e2 == 0) {		// x(a) => x temp; (temp.x(a),temp)
		if (e1 && e1->e1 && !e1->e2) {
			char* s = e1->e1->string;
			if (s && s[0] == '_' && s[1] == '_' && s[2] == 'V' &&
			    e1->e1->tp && tp2 && !e1->e1->tp->check(tp2, 0))
				return e1;
		}
		no_sti = 1;
		Ntmp = 0;
		Pname n = make_tmp('V',tp2,tbl);
		no_sti = 0;
		n->assign();
		if (tbl == gtbl) n->dcl_print(0);	// a hack
		Pexpr c = call_ctor(tbl,n,ctor,e1,DOT);
		extern bit in_quest;
		if (Ntmp && in_quest) {
                	if (Ntmp_refd) {
			 	n->n_list = Ntmp_refd;	
                        	Ntmp_refd = n;
			}
                	else Ntmp_refd = n;

  			Ntmp_flag = make_tmp('Q',int_type,tbl);
  			Ntmp_flag->n_initializer = new ival(0L);
  			Ntmp_flag->assign();

                        if (Ntmp_flag_list) {
				Ntmp_flag->n_list = Ntmp_flag_list;
                                Ntmp_flag_list = Ntmp_flag;
			}
                        else Ntmp_flag_list = Ntmp_flag;

			Pexpr e = new expr(ASSIGN,Ntmp_flag,one);
			e->tp = int_type;
			Ptype t = c->tp;
			Ntmp_flag = 0;
			c = new expr(G_CM,e,c);
			c->tp = t;
		}

		c = new expr(G_CM,c,n);
		c->tp = n->tp;
		return c;
	}
	else {
		Pexpr c = call_ctor(tbl,e2,ctor,e1,DOT);
		c = new expr(DEREF,c,0); // deref value returned by constructor
		c->tp = c->e1->tp;
		return c;
	}
}

Pname 
gen::exactMatch(Pexpr arg, int constObj)
/*
	look through this gen for an exact match with arg
	if found, return it;
	if ambiguous, issue error and return dummy function
	if not found, return 0;
*/
{
	if (pure_templ()) return 0; // only holds templates
	register Plist gl;
	register int ok;
	Block(Pname) funVec;

	register int numEx = 0;
	for (gl=fct_list; gl; gl=gl->l) {
		register Pname nn = gl->f;
		if (nn->is_template_fct()) continue;
		Pfct f = nn->fct_type();
		register Pname n = f->argtype;
		if(constObj && nn->n_oper!=CTOR && !f->f_const && !f->f_static){
			non_const++;
			continue;
		}
		ok = 0;
		if (!arg) ok = 1;
		else {
		    for(Pexpr e=arg; e; e=e->e2, n=n->n_list) {
			if (!n && f->nargs_known!=ELLIPSIS) break;
			Pexpr a = e->e1;
			Ptype at = a->tp;
			if(at->base == ANY) break;
			if (at->base == ZTYPE) at = int_type;
			if (!exact1(n,at)) break;
			if (!e->e2) ok = 1;
		    }
		}
		if(!ok || n && !n->n_initializer) continue;

		funVec.reserve(numEx+1);
		funVec[numEx++] = nn;
	}

	if (!numEx) return 0;
	if (numEx==1) return funVec[0];

	// see if ``const'' break ties
	Bits bestOnes = ~(Bits(0,numEx));
	return breakTie(funVec,bestOnes,arg,constObj);
}

Pname 
gen::oneArgMatch(Pexpr aarg, int constObj) 
/*
	for a call with one argument:
	look through this gen for the best match for arg
	if found, return it;
	if ambiguous, issue error and return dummy function
	if not found, return 0;
*/
{
	if (pure_templ()) return 0;
	register Plist gl;
	int numFunc = 0;
	Block(Pname) ArgVec;
	Block(Pname) funVec;
	Pname fn = fct_list->f;

	for (gl=fct_list; gl; gl=gl->l) {
		Pname nn = gl->f;
		Pfct ft = nn->fct_type();
		Pname nnargs = ft->argtype;

		if (nn->is_template_fct()) continue;

		if(constObj && fn->n_oper!=CTOR && 
		    !ft->f_const && !ft->f_static) {
			non_const++;
			continue;
		}
		if (!nnargs && ft->nargs_known != ELLIPSIS)
			continue;
		if (nnargs && nnargs->n_list && !nnargs->n_list->n_initializer) 
			continue;
		ArgVec.reserve(numFunc+1);
		funVec.reserve(numFunc+1);
		ArgVec[numFunc] = nnargs ? nnargs : (Pname)ELLIPSIS;
		funVec[numFunc++] = nn;
	}
	if(!numFunc) return 0;

	Bits bestOnes = bestMatch(ArgVec, numFunc, aarg->e1->tp);

	int numFuncs = bestOnes.count();
	if(!numFuncs) return 0;
	if(numFuncs == 1)
		return funVec[bestOnes.signif() - 1];

	return breakTie(funVec,bestOnes,aarg,constObj);
}

Pname 
gen::multArgMatch(Pexpr arg, int constObj)
/*
	for a call with multiple arguments:
	look through this gen for the best match for arg
	if found, return it;
	if ambiguous, issue error and return dummy function
	if not found, return 0;
*/
{
	if (pure_templ()) return 0;
	int numargs = 1;
	Pexpr tmp = arg;
	if(!tmp) return 0;
	while((tmp=tmp->e2)) numargs++;
	Block(BlockPname) intFun(numargs);

	miFlag = 0;
	register int numFunc = 0;
	Block(Pname) funVec;

	for (Plist gl=fct_list; gl; gl=gl->l) {
		register Pname nn = gl->f;

		if (nn->is_template_fct()) continue;

		// first weed out unmatchable functions
		if (!matchable(nn,arg,constObj)) continue;

		// store types in ``matrix'' for bestMatching
		register int ai = 0;
		Pfct tf = nn->fct_type();

		funVec.reserve(numFunc+1);
		funVec[numFunc] = nn;
		for (Pname x=tf->argtype; x&&ai<numargs; x=x->n_list) {
			intFun[ai].reserve(numFunc+1);
			intFun[ai][numFunc] = x;
			ai++;
		} 

		// extend ellipsis arguments
		if(tf->nargs_known == ELLIPSIS) {
			while(ai < numargs) {
			    intFun[ai].reserve(numFunc+1);
			    intFun[ai++][numFunc] = (Pname)ELLIPSIS;
			}
		}
		numFunc++;
	}

	// no matchable functions
	if(numFunc == 0) return 0;

	// finished: only one matchable function
	if(numFunc == 1) return funVec[0];

	// more matchable functions: need intersect rule
	if(numFunc > 1) {  

		Bits bestFuncs = intersectRule(intFun,numFunc,arg);

		Pname best = 0;
		register int sigbit = bestFuncs.signif() - 1;

		switch(bestFuncs.count()) {
		    case 0:	// null intersection
			fmError(1,funVec,arg,constObj);
			best = funVec[0];
			break;

		    default:	//multiple elements in intersection
			best = breakTie(funVec,bestFuncs,arg,constObj);
			sigbit = bestFuncs.signif() - 1;

		    case 1:	// one element in intersection
		    		// before or after breakTie
			if (miFlag==1 && numFunc > 2) {  
				// suspect: need simple rule
				for(int K = 0; K < numFunc; K++) {
					if(K == sigbit) continue;
			    		int gotit = 0;
					Pexpr targ = arg;
					for(int I=0;I<numargs;I++) {
					    if(bestOfPair(intFun[I][sigbit],
						intFun[I][K],targ->e1->tp)) {
						gotit = 1;
						break;
					    }
					    targ = targ->e2;
					}
					if(!gotit) {
					    if(!best) {
						fmError(1,funVec,arg,constObj);
						break;
					    }
					    Bits temp = bestFuncs;
					    bestFuncs.set(K);
			   		    if(breakTie(
						funVec,
						temp,
						arg,
						constObj)!=funVec[sigbit]) {
						    fmError(1,funVec,arg,constObj);
						    break;
					    }
					}
				}
			}
			best = funVec[sigbit];
		}
		return best;
	}

	error('i', "fall off end of gen::multArgMatch()");
	return 0;
}

Bits bestMatch(const Block(Pname)& AV, int nav, Ptype at)
/*
	find the indices of the elements of AV which best match at.
	return a Bits with bits set which correspond to these indices
*/
{
	Bits zeroBits(0,nav);

	Bits result = zeroBits;
	Block(int) rate(nav);
	Block(Pname) udcBlock(nav);

	int i = -1;
        while(++i < nav) {

		Pname aa = AV[i];

		if(aa == 0) continue;
		
		if(aa == (Pname)ELLIPSIS) {
			rate[i] = ELLIP;
			continue;
		}
		Ptype t1 = aa->tp;

		if (t1==at || exact1(aa,at)) {
			rate[i] = EXACT;
			continue;
		}
		if (exact2(aa,at)) {
			rate[i] = PROM;
			continue;
		}
		if (exact3(aa,at)) {
			rate[i] = STD;
			continue;
		}

		int cc = can_coerce(t1,at);
		if (cc == 1) {
			udcBlock[i] = Ncoerce;
			rate[i] = UDC;
			continue;
		}

		rate[i] = NONE;
	}

	int max = NONE;
	for(i=0;i<nav;i++) {
		if( rate[i] > max ) {
			max = rate[i];
			result = zeroBits;
		}
		if( rate[i] && rate[i] == max ) {
			result.set(i);
		}
	}

	if (result.count() <= 1) return result;

	// break ties for STD's involving inheritance
	if (max == STD ) {
		if(at->is_ptr_or_ref()) at = Pptr(at)->typ;
		if (!at->is_cl_obj()) return result;  

		Bits tempBits = result;
		tempBits.reset(tempBits.signif() - 1);

		// nice little algo to find ``real'' best matches
		// taking derivation and MI into account
		while(tempBits.count()) {
			int tempPtr = tempBits.signif() - 1;
			Ptype t1  = AV[tempPtr]->tp;
			Pptr p_t1 = t1->is_ptr();
			for(int k = nav - 1; k > tempPtr; k--) {
				if(!result[k]) continue;
				Ptype t2 = AV[k]->tp;
				if (t1->check(t2,0)==0 || const_problem)
					continue;
				int r = pr_dominate(t1,t2);
				Pptr p_t2 = t2->is_ptr();
				if (r==1 || p_t2 && p_t2->typ->base==VOID) {
					result.reset(k);
				}
				if (r==2 || p_t1 && p_t1->typ->base==VOID) {
					result.reset(tempPtr);
					break;
				}
				if(r==0 && miFlag==0) miFlag = 1;
			}
			tempBits.reset(tempPtr);
		}
	}

	// find UDC sequences which are prefix's of others
	if (max == UDC ) {
		Bits tempBits = result;
		int sigbit = tempBits.signif() - 1;
		tempBits.reset(sigbit);

		while(tempBits.count()) {
			int tempPtr = tempBits.signif() - 1;
			Pname tname  = AV[tempPtr];
			bit done = 0;
			for(int k = nav - 1; k > tempPtr; k--) {
				if(!result[k] || !udcBlock[k]) continue;
				if (udcBlock[k]->tp->base == OVERLOAD) {
					for (Plist gl = Pgen(udcBlock[k]->tp)->fct_list; gl; gl=gl->l) {
						Ptype tt = gl->f->fct_type()->returns;
						Pname r = udcBlock[tempPtr]==udcBlock[k] ?
							bestOfPair(tname,AV[k],tt) : 0;
						if (r==tname)
							result.reset(k);
						if (r==AV[k]) {
							result.reset(tempPtr);
							done = 1;
							break;
						}
					}
				}
				else {
					Ptype tt = udcBlock[k]->fct_type()->returns;
					Pname r = udcBlock[tempPtr]==udcBlock[k] ?
						bestOfPair(tname,AV[k],tt) : 0;
					if (r==tname)
						result.reset(k);
					if (r==AV[k]) {
						result.reset(tempPtr);
						break;
					}
				}
				if (done)
					break;
			}
			tempBits.reset(tempPtr);
		}
	}

	return result;
}

Pname bestOfPair(Pname a1, Pname a2, Ptype at)
/*
    return the bestMatch of a pair of names to at if
    one exists.
    otherwise, return 0;
*/
{
	if(a1->tp == a2->tp) return 0;

	Block(Pname) tryBlock(3);
	tryBlock[0] = a1;
	tryBlock[1] = a2;
	Bits bestBits = bestMatch(tryBlock,2,at);
	if (bestBits.count()==1) {
		return tryBlock[bestBits.signif() - 1];
	}
	return 0;
}

Bits intersectRule(const Block(BlockPname)& intFun, int numFunc, Pexpr arg)
/*
	intersect rule
*/
{
	Bits zeroBits(0,numFunc);
	Bits result = ~zeroBits;

	int ai = 0;
	for(Pexpr aargu = arg; aargu; aargu = aargu->e2) {
		Ptype at = aargu->e1->tp;
		Bits tryit = bestMatch(intFun[ai++],numFunc,at);
		if(tryit.count()==1) miFlag = -1;
		result &= tryit;
		if(!result.count()) { return zeroBits; }
	}
	return result;
}

Pname breakTie(const Block(Pname)& FV,Bits& bestOnes,Pexpr arg,int cO)
/*
	all functions in Block are equal after the intersect rule
	use a mini-intersect rule on the array to see if one dominates 
	all others when trivial conversions involving const are 
	considered.

	if so, return it;
	if not, issue ambiguity error and return any function
*/
{
	register int numFunc = bestOnes.size();
	Bits zeroBits(0,numFunc);
	Bits result = ~zeroBits;

	Block(Pname) rfunc(numFunc);

	int i = 0;
	while(FV[i]) {
		if(bestOnes[i]) rfunc[i]=FV[i]->fct_type()->argtype;
		i++;
	}

	int stat = FV[bestOnes.signif()-1]->fct_type()->f_static;
	for(int k = 0; k < numFunc; k++) {
		if(bestOnes[k]) {
			if(stat != FV[k]->fct_type()->f_static) {
				fmError(1,FV,arg,cO);
				miFlag = 0;
				return FV[bestOnes.signif() - 1];
			}
		}
	}

	// see if ``const'' breaks tie
	for(Pexpr aargu = arg; aargu; aargu = aargu->e2) {
		Ptype at = aargu->e1->tp;

		// best_const
		Bits temp = best_const(rfunc,numFunc,at);
		if(temp.count()) result &= temp;
		if(!result.count()) break;

		for(int k = 0; k < numFunc; k++) {
			if(rfunc[k]) rfunc[k] = rfunc[k]->n_list;
		}
	}

	Pfct pf = FV[0]->fct_type();
	if(result.count()>=1 && pf->memof) { // && FV[0]->n_oper != CTOR) {
		Bits temp = zeroBits;
		for(int k = 0; k < numFunc; k++) {
                        if(bestOnes[k]) {
			    if(stat != FV[k]->fct_type()->f_static) {
				result = zeroBits;
				break;
			    }
			    if(cO == FV[k]->fct_type()->f_const) temp.set(k);
                        }
                }
		if(temp.count()) result &= temp;
	}

	if(result.count()==0 || result.count()>=2) {
		fmError(1,FV,arg,cO);
		miFlag = 0;
	}
	else  bestOnes = result; 

	return FV[bestOnes.signif() - 1];
}

Bits best_const(const Block(Pname)& CONV, int nfound, Ptype at)
{
	Bits zeroBits(0,nfound);
	Bits result = ~zeroBits;
	
	Bits tempBits = ~zeroBits;
	int sigbit = tempBits.signif() - 1;
	tempBits.reset(sigbit);

	for (int i=0; i<nfound; i++) {
		if (CONV[i] == 0) {
			tempBits.reset(i);
			result.reset(i);
		}
	}

	while(tempBits.count()) {
		int tempPtr = tempBits.signif() - 1;
		Pname t1name = CONV[tempPtr];
		for(int k = nfound - 1; k > tempPtr; k--) {
			if(!result[k]) continue;
			Pname t2name  = CONV[k];
			Ptype t1 = t1name->tp;
			Ptype t2 = t2name->tp;
			Pptr p1=t1->is_ref(),p2=t2->is_ref();
			if (p1 && !p2) t1 = p1->typ;
			if (p2 && !p1) t2 = p2->typ;
			p1=t1->is_ptr(),p2=t2->is_ptr();
			if (p1 && p2) {
			    if (at->check(t1,OVERLOAD)==0
				&&
				at->check(t2,OVERLOAD)
			    )
				result.reset(k);
			    else if (at->check(t1,OVERLOAD)
				&&
				at->check(t2,OVERLOAD)==0
			    ) {
				result.reset(tempPtr);
				break;
			    }
			}
			else {
			    Pptr p1=t1->is_ref();
			    Pptr p2=t2->is_ref();

			    if (p1 && p2) {
				if (at->check(p1->typ,OVERLOAD)==0
				    &&
				    at->check(p2->typ,OVERLOAD)
				)
				    result.reset(k);
				else if (
				    at->check(p1->typ,OVERLOAD)
				    &&
				    at->check(p2->typ,OVERLOAD)==0
				) {
				    result.reset(tempPtr);
				    break;
				}
			    }
			}
		}
		tempBits.reset(tempPtr);
	}
	return result;
}

void fmError(int errorKind, const Block(Pname)& FV, Pexpr arg, bit co)
{
	Pname fn = FV[0]->tp->base==OVERLOAD ? 
			Pgen(FV[0]->tp)->fct_list->f : FV[0];

	switch (errorKind) {
	    case 0:
		error('e',"no match for call: ");
		break;
	    case 1:
		ambig = 1;
		error('e',"ambiguous call: ");
		break;
	}

	// call
	Pclass tmp = fn->get_fct()->memof;

	if (tmp) error('c',"%s %t* -> ",co?"const":"",tmp);
	if(fn->n_oper && fn->n_oper!=CTOR) 
		error('c',"operator %s(",keys[fn->n_oper]);
	else if(fn->n_oper==CTOR) {
		error('c',"%t::%t(",tmp,tmp);
	}
	else error('c',"%s(",fn->string);

	if(arg) {
		Pexpr tmp = arg;
		error('c',"%t",tmp->e1->tp->skiptypedefs());
		while((tmp=tmp->e2)) {
			error('c',",%t",tmp->e1->tp->skiptypedefs());
		}
	}
	error('c',")\n");

	// possible functions
	error('C',"choice of%ns:\n",fn);

	if(FV[0]->tp->base == OVERLOAD) {
		int num_templ=0;
		int no_const=0;
		int num_all=0;
		for(Plist gl = Pgen(FV[0]->tp)->fct_list;gl;gl=gl->l) {
			if(gl->f->is_template_fct()) {
				num_templ++;
			}
			else error('C',"	%a;\n",gl->f);
			if (co && !Pfct(gl->f->tp)->f_const) no_const++;
			num_all++;
		}
		if(num_templ) {
			error(
			    'C',
			    "	%d template version%s;\n",
			    num_templ,
			    num_templ==1 ? "" : "s"
			);
		}
		if(no_const == num_all)
			error('C',"(no usable const member function)\n");

		return;
	}

	int numFunc = FV.size();
	for(int i=0; i<numFunc; i++) {
		if(FV[i]) error('C',"	%a;\n",FV[i]);
	}
}