/*ident	"@(#)cls4:src/dcl4.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.

dcl4.c:
	Declaration of class and enum

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

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

static Pname get_vf(Pname n_pvf, Pclass cl) {
/*----------------------------------------------------------------------------
	search the base hierarchy of class "cl" if n_pvf (Name of Pure Virtual 
	Function) has a definition.

	returns 0 		if no definition found in the hierarchy.
	returns Pname 		if found.
 *----------------------------------------------------------------------------
 */
	if(!n_pvf || !cl) return 0;

	if (n_pvf->tp  && 
		!cl->has_base(Pfct(n_pvf->tp)->memof)) {
		return 0;	//if pvf is not in a base of "cl"
	}
	Pname n_vf = cl->memtbl->look(n_pvf->string,0);
	if (n_vf  && n_pvf->tp  && n_vf->tp) {
		if (n_vf->tp->base == OVERLOAD) {
			for (Plist gl = Pgen(n_vf->tp)->fct_list; gl; gl = gl->l) {
				if (!Pfct(n_pvf->tp)->check(gl->f->tp, VIRTUAL))
					break;
			}
			if (!gl)
				n_vf = 0;
		}
		else {
			if (Pfct(n_pvf->tp)->check(Pfct(n_vf->tp), VIRTUAL))
				n_vf = 0;
		}
	}
//error('d',"get_vf %n in %t for pure virt. %n",n_vf, cl, n_pvf);
        if (n_vf==0) {
		for (Pbcl b=cl->baselist; b; b = b->next) {
			if (b->base == NAME || b->base == VIRTUAL) {
				n_vf = get_vf(n_pvf,b->bclass);
				if (n_vf && !n_vf->n_initializer) {
				   break;
				} else {
				   n_vf = 0;
				}
			}
    		}  //for (Pbcl b=...
	}  //if (n_vf==0)

	return n_vf;
}

Pname find_vptr(Pclass);
void fix_args(Pfct f, Pclass cl)
/*
	This function is used to cope with the case where cl::cl(cl&) is
	declared AFTER f has been declared
	set n_xref bit for f
*/
{
	for (Pname a = f->argtype; a; a = a->n_list) {
		Pname n = a->tp->is_cl_obj();
		if (n && same_class(Pclass(n->tp),cl))
			a->n_xref = 1;
	}
}

struct typedef_info {
	Pname n;
	typedef_info *next;
};
static typedef_info *typedef_info_head=0, *typedef_info_tail=0;

static Pfct get_fct_node(Pname n)
{
	Ptype t = n->tp ? n->tp->skiptypedefs() : 0;

	if (t && t->base==RPTR)
		t = Pptr(t)->typ->skiptypedefs();

	while (t && t->base==PTR)
		t = Pptr(t)->typ->skiptypedefs();

	return t && t->base==FCT ? Pfct(t) : 0;
}

static void record_typedef(Pname tn)
{
	typedef_info *p = new typedef_info;
	p->n = tn;
	if (typedef_info_head==0) {
		typedef_info_head = typedef_info_tail = p;
	} else {
		typedef_info_tail->next = p;
		typedef_info_tail = p;
	}
}

void typedef_check(Pname n)
{
	Pname cn;
	Pfct f = get_fct_node(n);

	if (!f) return;

	for (Pname a = f->argtype; a; a = a->n_list) {
		cn = a->tp ? a->tp->is_cl_obj() : 0;
		if (!a->n_xref && cn && cn->tp && !(Pclass(cn->tp)->defined&DEFINED)) {
			record_typedef(n);
			return;
		}
	}

	cn = f->returns ? f->returns->is_cl_obj() : 0;
	if ((!f->s_returns || f->s_returns!=void_type) && cn && cn->tp && !(Pclass(cn->tp)->defined&DEFINED))
		record_typedef(n);
}

static void typedef_checkall(Pclass cl)
{
	for (typedef_info *p=typedef_info_head; p; p=p->next) {
		Pfct f = get_fct_node(p->n);
		Pname cn;
		for (Pname a = f->argtype; a; a = a->n_list) {
			cn = a->tp ? a->tp->is_cl_obj() : 0;
			if (!a->n_xref && cn && cn->tp && same_class(Pclass(cn->tp),cl) && cl->has_itor()) {
				error('s', &p->n->where, "C%t used asAT inTdef%n before it was known that%t has a copyK", cl, p->n, cl);
				break;
			}
		}
		cn = f->returns ? f->returns->is_cl_obj() : 0;
		if ((!f->s_returns || f->s_returns!=void_type) && cn && cn->tp && same_class(Pclass(cn->tp),cl) && cl->has_itor())
			error('s', &p->n->where, "C%t used as returnT inTdef%n before it was known that%t has a copyK", cl, p->n, cl);
	}
}

Pname merge_conv(Pname c1, Pname c2)
{
	if (c1 == 0)
		return c2;
	if (c2 == 0)
		return c1;
	if (c1 == c2)
		return c1;
	error('s',"cannot merge lists of conversion functions");
	return c1;
}

static int Eppp;

char* get_classname(char* s)
/*
	retrieve the outermost class name in a vtable name
*/
{
// error('d',"get_classname(%s)",s);
	char* s1 = 0;

	while (*s) {
		s1 = s;
	loop:
		for ( ; s[0] && (s[0] != '_' || s[1] && s[1] != '_'); s++);
		if (*s) {
			if (strncmp(s,"___pt__",7)==0) {
				s+=7; goto loop;
			}
			if (strncmp(s,"__pt__",6)==0) { // parameterized class
				s+=6; goto loop;
			}
			if ( s[1] == 0 ) ++s;
			else s += 2;			// bypass "__"
		}
	}

	return s1;
}

char* drop_classname(char* s)
/*
	retrieve all but the outermost class name in a vtable name
*/
{
// error('d',"drop_classname(%s)",s);
	char* r = new char[strlen(s)+1];
	sprintf(r,s);
	s = r;

	char* s1 = s;
	while (*s) {
loop:
		for ( ; s[0] && (s[0] != '_' || s[1] && s[1] != '_'); s++);
		if (*s) {
			if (strncmp(s,"___pt__",7)==0) {
				s+=7; goto loop;
			}
			if (strncmp(s,"__pt__",6)==0) { // parameterized class
				s+=6; goto loop;
			}
			if ( s[1] == 0 ) { s1 = ++s; break; }
			s1 = s;
			s += 2;			// bypass "__"
		}
	}

	*s1 = '\0';
	return (*r) ? r : 0;
}

bit classdef::has_const_mem()
/*
	does this class have any constant members
*/
{
	int i;
	for (Pname m = memtbl->get_mem(i=1); m; NEXT_NAME(memtbl,m,i))  
		if (m && m->tp) 
			switch (m->tp->base) {
				case FCT: break;
				case OVERLOAD: break;
				case EOBJ: break;
				default: 
					if (m->tp->is_const_object() && m->n_stclass!=STATIC) return 1;
			}
	
	return 0;
}

Pbcl classdef::get_base( char *s )
/*
	Find the base class whose name matches the argument
*/
{
//error('d',"%t::get_base(%s) baselist%d %t",this,s,this?baselist:0,this?baselist->bclass:0);
	for (Pbcl b = baselist; b; b = b->next) {
//error('d',"  b%t s %s",b->bclass,s);
		for (
			char *s1 = s, *s2 = b->bclass->string;
			*s1 && *s2 && *s1 == *s2;
			s1++, s2++
		)
			;

		if (!(*s1 || *s2))
			break;
	}

	return b;
}

static int 
offset_magic_0(Pbcl b, Pbcl bb, short virt_count) 
{
// error('d',"offset_magic_0(%t %t %d)", b->bclass,bb->bclass,virt_count);

	Pclass bcl = bb->bclass;
	int offset = 0;
	for (Pbcl l = b; l; l=l->next) {
		if (l->base == VIRTUAL) continue; 
		Pclass bc = l->bclass;
		for (Pbcl ll = bc->baselist; ll; ll=ll->next) {
			if (ll->base != VIRTUAL) continue;
			int diff = strcmp(bcl->string,ll->bclass->string);
			// if (ll->allocated && !diff) {
			if (ll->allocated == 1 && !diff) {
				offset = ll->obj_offset + l->obj_offset; 
// error('d',"%d offset_magic_0 returning found offset of %t",offset, bcl);
				return offset;
			}
			
			// if (diff && ll->allocated) {
			if (diff && ll->allocated == 1) {
				offset = ll->bclass->has_allocated_base(bcl);
				if (offset) {
					if (!virt_count)
					    offset += l->obj_offset;
// error('d',"%d offset_magic_0 returning allocated offset of %t",offset, bcl);
					return offset;
				}
			}
		}
	}

	if (Nvbc_alloc) {
		offset = bb->obj_offset - Nvbc_alloc->obj_offset;
		if (virt_count) offset += 4;
// error('d',"nvbc: %t %d bb: %d offset: %d",Nvbc_alloc->bclass,Nvbc_alloc->obj_offset,bb->obj_offset,offset);
	}

// error('d',"offset_magic_0 offset: %d virtualBC %t",offset,bcl);
	return offset;
}

static int 
offset_magic_1(Pbcl b, Pbcl bl)
{
// error('d',"offset_magic_1( %t, %t )",b->bclass,bl->bclass);
	char *str = b->bclass->string;
	for (Pbcl bb=bl->bclass->baselist; bb; bb=bb->next) {
		if (bb->base != VIRTUAL) continue;
		char *s = bb->bclass->string;
		if (strcmp(s,str)==0) {
			int offset = bb->obj_offset - bb->ptr_offset +1;
// error('d',"str: %s offset: %d obj_offset: %d",str,offset,bl->obj_offset);
			return offset + bl->obj_offset;					
		}
	}


// error('d',"0 offset_magic_1 for virtualBC%t contained within%t",b->bclass,bl->bclass);
	return 0;
}

// cope with offsets of virtuals in deep nests: promoted, not allocated
extern int link_compat_hack;
static int Voffset;	
bit Vvtab;	
bit Vvbc_alloc;	
bit Vvbc_inher;

int classdef::get_offset(char* s, bit rechk)
/*  Get offset represented by string as viewed from "this" */
{
// error('d',"%s::get_offset(%s %d)",string,s,rechk);
	if (!s) return 0;

        char *str = get_classname(s);
	Pbcl b = get_base(str);

	bit unalloc = 0; 
	char *found_virtual = 0; 

        if (rechk) {
		// unalloc = (b->promoted && (b->allocated == 0));
		unalloc = (b->promoted && (b->allocated != 1));
// error('d',"%s::get_offset unalloc: %d b->alloc: %d",string,unalloc,b->allocated);

		if (!unalloc) return 0;
	 	Vvtab = 0; // promoted virtual base contains vtbl
	 	Vvbc_inher = 0; 
	 	Vvbc_alloc = 0; // promoted virtual base contains vtbl
		Nvbc_alloc = 0; // set by has_allocated_base
		found_virtual = has_allocated_base(str);
	}

	if (unalloc) {
// error('d', "recheck get_offset: voffset: %d found_virtual: %s str: %s ps: %s",Voffset,found_virtual,str);
		if (found_virtual == 0) {
			if (Vvbc_alloc && b->bclass->baselist)
				return b->obj_offset;
			
			if (strcmp(s,str)) { 
				if (Vvbc_inher)
			 	    return 0;
				
				if (Vvtab == 0)
				    return b->bclass->get_offset(drop_classname(s));

				return b->obj_offset + b->bclass->get_offset(drop_classname(s));
			}
			else {
				if (Vvbc_inher) {
			            if (b->allocated == 2)
					link_compat_hack = b->obj_offset;
			 	    return 0;
				}
				return offset_magic_0(baselist->next,b,virt_count);
			}
		}

		if (found_virtual) {
			if (strcmp(s,str)) 
				return offset_magic_1(b,get_base(found_virtual));
			else return b->obj_offset;
		}
	}

	return b->obj_offset + b->bclass->get_offset(drop_classname(s));
}

char* vtbl_str(char* s1, char* s2)
/*
	combine two pieces of a vtbl name
*/
{
// error('d',"vtbl_str(%s,%s)",s1,s2);
	char* s3;
	if (s1)
		if (s2) {
			s3 = new char[strlen(s1)+strlen(s2)+3];
			sprintf(s3,"%s__%s",s1,s2);
			return s3;
		}
		else
			return s1;
	else
		return s2;
}

void classdef::add_vtbl(velem* v, char* s, bit virt_flag, int n_init)
/*
	add vtbl to virt_list
*/
{
// error('d',"%t->add_vtbl(%d,%s)",this,v,s);
	Pvirt vtab = new virt(this, v, s, virt_flag, n_init);

	if (virt_flag)
		has_vvtab = 1;

	if (!virt_list) {
		virt_list = vtab;
		return;
	}

	// If conficting vtable entries are made because of
	// a virtual base class, must be considered an error.
	for (Pvirt vt = virt_list; vt; vt = vt->next )
		if (vt->string && strcmp(vt->string,s)==0) {
			velem* ivec = vt->virt_init;
			Pname on = ivec[0].n;
			Pname nn = v[0].n;
			Pclass ocl,ncl;
			for (int i=0; on && nn; i++,on=ivec[i].n,nn=v[i].n) {
				ocl = Pfct(on->tp)->memof;
				ncl = Pfct(nn->tp)->memof;
				if (on != nn)
					if (!ocl->has_base(ncl))
						if (!ncl->has_base(ocl))
							break;
						else {
							ivec[i].n = nn;
							ivec[i].offset = v[i].offset;
						}
			}
			if (on || nn)
				error("virtualB: ambiguous%n and%n", on, nn);
			return;
		}

	vtab->next = virt_list->next;
	virt_list->next = vtab;
}

static int baseoffset(Pclass b, Pclass d)
/*
	find offset of base class object "b" in derived class object "d"
*/
{
	static int level=0;
	++level;

	if (!b || !d) {
		error ('i', "invalidA to baseoffset()");
	}

	if (same_class(b,d)) {	// b == d
		level--;
		return 0;
	}

	Pbcl bx;

	// is "b" a direct base of "d" or a promoted indirect virtual base ?
	for (bx = d->baselist; bx; bx = bx->next)
	{
		if (same_class(b, bx->bclass) )	{	//(b == bx->bclass)
			level--;
			return bx->obj_offset;
		}
	}

	// recursively search for "b" in bases of "d"
	for (bx = d->baselist; bx; bx = bx->next)
	{
		// don't search indirect virtual bases
		if (bx->promoted)
			continue;
		int found = baseoffset(b, bx->bclass);
		if (found != -1) {
			level--;
			return bx->obj_offset + found;
		}
	}

	if (level-- > 1)
		return -1;	// b!=d and b is not a base of d

	error('i', "fall off end of baseoffset()");
	return 0;
}

int vcounter;
static int vmax;
const int vpChunk = 32;

int classdef::do_virtuals(Pvirt vtab, char* str, int leftmost, bit virt_flag)
/*
	make vtbl for b in "this"
	match up virtuals and assign virtual indices for the base or delegate "bcl"
	first base class shares ``this'' and vtbl with this class
*/
{
	if (vmax<vcounter)
		vmax = vcounter;
	int vpsz = (vmax+vcounter)/vpChunk+1;	// fragmentation prevention
	vpsz *= vpChunk;
	Pname* vp = new Pname[vpsz];
	velem* ivec = vtab ? vtab->virt_init : 0;
	int vo = Voffset;
	int vc = 0;
	int changed = 0;

//error('d',"%t->do_virtuals(%d,%s) voffset %d",this,vtab,str,Voffset);
//error('d',"virt_count %d vpsz %d vcounter %d",virt_count,vpsz,vcounter);

	if (ivec) {	// vtbl replacement for ivec
		if (vtab->is_vbase) {
			str = 0;
			Voffset = get_offset(vtab->string);
// error('d',"vtabl->is_vbase: %s->get_offset(%s), voffset: %d",string,vtab->string,Voffset);
		}
		else
			Voffset = Voffset + vtab->vclass->get_offset(vtab->string);
		Pname vn;
		for (int i=0; vn=ivec[i].n; i++) {
		/*
			go through virtual table's list of virtuals:
			first see if the function is simply inherited
			if not, check for a match
			if not, then add as new
		*/
			if ( i >= vpsz ) {	// resize vp vector
				int tvpsz = vpsz + vpChunk;
				Pname *tvp = new Pname[ tvpsz ];
				for ( int j = 0; j < i; ++j )
					tvp[ j ] = vp[ j ];
				delete [/*vpsz*/] vp;
				vp = tvp;
//error( 'd',"resizing: i: %d vpsz: %d tvpsz: %d", i, vpsz, tvpsz );
				vpsz = tvpsz;
			}

			char* s = vn->n_gen_fct_name;
			Pname n = memtbl->look(s?s:vn->string, 0);

//error('d',"vn %n %s n %n %d",vn,s,n,Voffset);
//error('d',"n %n %k", n, n?n->base:0 );
			if (n == 0 || n->base == PUBLIC ) {	// FCT + FCT
								// base::FCT
			inher:					// inherit
				if (vn->n_initializer) {  
					if (!get_vf(vn,this)) {
						c_abstract = vn;
					}
				}  
				vp[i] = vn;
				if ( ivec[i].offset && vtab->is_vbase ) {
 //error('d',"voffset[1]: %d vo: %d ivec[%d].offset: %d",Voffset,vo,i,ivec[i].offset);
				   vp[i]->n_offset = Voffset -
						     baseoffset(Pfct(vn->tp)->
						     memof, this);
				}
				else vp[i]->n_offset = ivec[i].offset;
				continue;
			}

			Pfct f = Pfct(n->tp);
			if (f == 0 ) continue;

			if (s && f->base==OVERLOAD) {		// OVERLOAD + OVERLOAD
								// vn is overloaded
								// and s is its name
				for (Plist gl=Pgen(f)->fct_list; gl; gl=gl->l)
					if (gl->f == vn)
						goto inher;
			}

			Pfct vnf = Pfct(vn->tp);
			switch (f->base) {			// re-define?
			default:
				error('w',&n->where,"%n hides virtual%n",n,vn);
				vp[i] = vn;	// not a new overloaded: inherit 
				if (vn->n_initializer) {  
					if (!get_vf(vn,this)) {
						c_abstract = vn;
					}
				}  
				if ( ivec[i].offset && vtab->is_vbase ) {
					if (Voffset - vo != ivec[i].offset) {
// error('d',"voffset[2]: %d vo: %d ivec[%d].offset: %d",Voffset,vo,i,ivec[i].offset);

						int noffset = get_offset(vtab->string,1);
						if (noffset && noffset != Voffset) 
							noffset -= vo;
						if (noffset == 0) { 
							if (Vvbc_inher) 
								noffset = link_compat_hack 
									? link_compat_hack - ivec[i].offset
									: ivec[i].offset;
							else noffset = Voffset - vo;
						}
						vp[i]->n_offset = noffset;
					}
					else vp[i]->n_offset = Voffset - vo;
				}
				else vp[i]->n_offset = ivec[i].offset;
				break;
			case FCT:				// derived::FCT
			{
				if (vnf->check(f,VIRTUAL)==0) {	// derived::FCT match base::FCT
								// VTOK: virtual, but no index assigned
								// you can only inherit an index from your first base
					if (Vcheckerror)
						error("bad virtualT match for %n",vn);
					if (f->f_virtual==VTOK)
						f->f_virtual = i+1;
					vp[i] = n;
					vp[i]->n_offset = Voffset;
					changed = 1;
				}
				else {
					if (Vcheckerror)
						error("bad virtualT match for %n",vn);
					else {
						// if (! vn->n_initializer) // not a pure virtual ?????
						// inherits a pure virtual -- make abstract
						if (vn->n_initializer) {  
							if (!get_vf(vn,this)) {
								c_abstract = vn;
							}
						}  
						error('w',&n->where,"%n hides virtual%n",n,vn);
					}
					vp[i] = vn;	// not a new overloaded: inherit
					if ( ivec[i].offset && vtab->is_vbase ) {
						if (Voffset - vo != ivec[i].offset) {
// error('d',"voffset[3]: %d vo: %d ivec[%d].offset: %d",Voffset,vo,i,ivec[i].offset);

							int noffset = get_offset(vtab->string,1);
							if (noffset && noffset != Voffset) 
								noffset -= vo;
							if (noffset == 0) { 
								if (Vvbc_inher) 
									noffset = link_compat_hack 
										? link_compat_hack - ivec[i].offset
										: ivec[i].offset;
								else noffset = Voffset - vo;
							}
							vp[i]->n_offset = noffset;
						}
						else vp[i]->n_offset = Voffset - vo;
					}
					else vp[i]->n_offset = ivec[i].offset;
				}
				break;
			}
			case OVERLOAD:			// derived::OVERLOAD
			{				
				int hit = 0;
				for (Plist gl=Pgen(f)->fct_list; gl; gl=gl->l) {
				// try each fct from derived class
					Pname fn = gl->f;
					Pfct f = Pfct(fn->tp);

					if (f->check(vnf,VIRTUAL) == 0) {	// derived::FCT
						if (Vcheckerror)
							error("bad virtualT match for %n",vn);
						if  (f->f_virtual==VTOK)
							f->f_virtual = i+1;
						vp[i] = fn;
						vp[i]->n_offset = Voffset;
						changed = 1;
						goto found;
					}
					else {
						if (Vcheckerror)
							error("bad virtualT match for %n",vn);
					}
					if (Vcheckerror == 0)
						switch (f->f_virtual) {
						case 0:
						case VTOK:
							hit = 1;
						}
	
				}

				if (hit) {
					// inherits a pure virtual -- make it abstract
					if (vn->n_initializer) {  
						if (!get_vf(vn,this)) {
							c_abstract = vn;
						}
					}  
					error('w',&n->where,"%n hides virtual%n ofT %t",n,vn,vn->tp);
				}

				vp[i] = vn;	// not a new overloaded: inherit
				if ( ivec[i].offset && vtab->is_vbase ) {
					if (Voffset - vo != ivec[i].offset) {
// error('d',"voffset[4]: %d vo: %d ivec[%d].offset: %d",Voffset,vo,i,ivec[i].offset);

						int noffset = get_offset(vtab->string,1);
						if (noffset && noffset != Voffset) 
							noffset -= vo;
						if (noffset == 0) { 
							if (Vvbc_inher) 
								noffset = link_compat_hack 
									? link_compat_hack - ivec[i].offset
									: ivec[i].offset;
							else noffset = Voffset - vo;
						}
						vp[i]->n_offset = noffset;
					}
					else vp[i]->n_offset = Voffset - vo;
				}
				else vp[i]->n_offset = ivec[i].offset;
			found:
				break;
			}
			}
		}

		Voffset = vo;
		vc = i;
	}

// error( 'd', "do_virtuals: out of loop: vc: %d vpsz: %d changed: %d", vc, vpsz,changed );

	if (leftmost) {
		/*
			add new virtuals:
			`VTOK' marks ``new virtual, no index assigned''.
			You can only be new once (no base or first base).
		*/
		int i;
                for (Pname nn=memtbl->get_mem(i=1); nn; NEXT_NAME(memtbl,nn,i) ) {
			if ( nn->base == TNAME ) continue;
			Pfct f = Pfct(nn->tp);

			if ( vc >= vpsz ) {	// resize vp vector
				int tvpsz = vpsz + vpChunk;
				Pname *tvp = new Pname[ tvpsz ];
				for ( int j = 0; j < vc; ++j )
					tvp[ j ] = vp[ j ];
				delete [/*vpsz*/] vp;
				vp = tvp;
				vpsz = tvpsz;
			}

// error('d',"f %n %t",nn,f);
			if (f)
				switch (f->base) {
				case FCT:
//error('d',"fv %d",f->f_virtual);
					if (f->f_virtual == VTOK) {
						// declared virtual, or
						// virtual in some base
						f->f_virtual = ++vc;
						vp[f->f_virtual-1] = nn;
						vp[f->f_virtual-1]->n_offset = 0;
						f->f_vdef = 1;
						changed = 2;
					}
					break;
				case OVERLOAD:
					{
					for (Plist gl=Pgen(f)->fct_list; gl; gl=gl->l) {
						Pname fn = gl->f;
						Pfct f = Pfct(fn->tp);

		 				if ( vc >= vpsz ) {	// resize vp vector
			 				int tvpsz = vpsz + vpChunk;
			 				Pname *tvp = new Pname[ tvpsz ];
			 				for ( int j = 0; j < vc; ++j ) {
				 				tvp[ j ] = vp[ j ];
 							}
			 				delete [/*vpsz*/] vp;
			 				vp = tvp;
			 				vpsz = tvpsz;
		 				}
 
						if (f->f_virtual == VTOK) {
							f->f_virtual = ++vc;
							vp[f->f_virtual-1] = fn;
							vp[f->f_virtual-1]->n_offset = 0;
							f->f_vdef = 1;
							changed = 2;
						}
					}
					break;
					}
				}
		}
// error('d',"%s changed %d has_vvtab %d",string,changed,has_vvtab);
// error('d',"vc %d vpsz %d",vc,vpsz);
		virt_count = 0;
		if (changed)
			virt_count = vc;
		else if (has_vvtab) {
			virt_merge = 1;
			if (vc && vtab->is_vbase)
				leftmost = 0;
		}
	}

// error('d',"vc %d ch %d vp[%d] virt_count %d",vc,changed,vpsz,virt_count);
	if (changed || !leftmost) {
		// vc==0 if all explicit virtuals in fact were declared in base
		velem* v = new velem[vc+1];

		for (int i=0; i<vc; i++) {
			v[i].n = vp[i];
			v[i].offset = vp[i]->n_offset;
		}
		v[vc].n = 0;

		if (leftmost)
			add_vtbl(v,0,0,0);
		else
			add_vtbl(v,vtbl_str(vtab->string,str),virt_flag||vtab->is_vbase,vc+1);
		delete vp;
		vcounter = 0;
		return 1;
	}

	delete vp;
	vcounter = 0;
	return 0;
}

int classdef::all_virt(Pclass bcl, char* s, int leftmost, bit virt_flag)
{
//error('d',"%t->all_virt( %t %s leftmost: %d",this,bcl,s,leftmost);
	int i = 0;
	if (bcl->virt_count) {
		for (Pvirt blist = bcl->virt_list; blist; blist = blist->next) {
			if (
				virt_merge
				&&
				virt_flag==0
				&&
				blist->is_vbase==0
			)
				continue;

			i += do_virtuals(blist, s, leftmost, virt_flag);
			if (i==0 && leftmost && virt_merge==0)
				return 0;

			leftmost = 0;
		}
	}

	// finding virt_list stops recursive step
	// if vtables found and updated, return number
	if (i)
		return i;

	for (Pbcl b = bcl->baselist; b; b = b->next) {
		if (b->promoted)
			continue;
// error('d',"all_virt b %t vl %d bl %d",b->bclass,b->bclass->virt_list,b->bclass->baselist);
		if (leftmost && b->base == VIRTUAL) {
			i += do_virtuals(0, 0, 1, 0);
			if (i==0 && virt_merge==0) {
				// be careful to propagate class abstraction
				if (bcl == this && b->bclass->c_abstract) 
					c_abstract = b->bclass->c_abstract; 
				return 0;
			}
			leftmost = 0;
		}
		int vo = Voffset;
		if (b->base == VIRTUAL)
		{
			Voffset = baseoffset(b->bclass,this);
		}
		else
		{
			Voffset += b->obj_offset;
		}
// error('d',"all_virt obj_offset %t voffset %d vo %d  %d",b->bclass,Voffset,vo);

		if (b->base==VIRTUAL)
			i += all_virt(b->bclass, b->bclass->string, leftmost, 1);
		else 	i += all_virt(b->bclass, vtbl_str(b->bclass->string,s), leftmost, virt_flag);

		if (i==0 && leftmost && virt_merge==0) {
			// be careful to propagate class abstraction
			if (bcl==this && !c_abstract && b->next) { 
				for (Pbcl bb = b; bb; bb = bb->next) { 
					if (bb->promoted) continue;
					if (bb->bclass->c_abstract) 
						c_abstract = bb->bclass->c_abstract; 
				}
			}
			return 0;
		}

		Voffset = vo;
		leftmost = 0;
	}

	// if recursion updated vtables, return number
	if (i)
		return i;

	// no vtables updated in recursion
	// look for new virtuals
	if (leftmost)
		return do_virtuals(0, 0, 1, 0);
	else
		return 0;
}

Pexpr copy_obj(Pexpr l, Pexpr r, int sz)
/*
	generate:
	struct _s { char[sz]; };
	*(struct _s*)this->m = *(struct _s*)arg.mem;
*/
{
	if ( !sz ) sz = 1;
// error('d',"copy_obj(%d)",sz);
	char* s = make_name('S');
	fprintf(out_file,"struct %s { char v[%d]; };\n",s,sz);
	Pname n = new name(s);
	Ptype t = new basetype(COBJ,n);
	t = new ptr(PTR,t);

	l = new texpr(G_CAST,t,l);	//new cast(t,l);
	l = l->contents();

	r = new texpr(G_CAST,t,r);	//new cast(t,r);
	r = r->contents();

	return new expr(ASSIGN,l,r);
}

Ptype find_arg_type(Pclass cl)
// first determine argument type
{
	int i;
	int mod = 0;
	for (Pbcl b = cl->baselist; b; b = b->next) {
		Pclass bcl = b->bclass;
		switch (b->base) {
		case VIRTUAL:
		case NAME:		// generate :b(*(b*)&arg)
		{
			Pname itor = bcl->has_itor();
			if (itor && itor->tp->base==FCT) {
				Pname a = Pfct(itor->tp)->argtype;
				Pptr p = a->tp->is_ref();
				if (p && p->typ->tconst()==0) {
					mod = 1;
					goto ll1;
				}
			}
		}
		}
	}
ll1:
	if (mod == 0) {
		for (Pname m=cl->memtbl->get_mem(i=1); m; NEXT_NAME(cl->memtbl,m,i) ) {
			if ( m->base == TNAME ) continue;
			if (m->n_evaluated || m->n_stclass==STATIC)	// ignore static members
				continue;
			Pname cln = ( m->base==PUBLIC ? m->n_qualifier : m )->tp->is_cl_obj();
			if ( cln ) {
				Pname itor = Pclass(cln->tp)->has_itor();
				if (itor && itor->tp->base==FCT) {
					Pname a = Pfct(itor->tp)->argtype;
					Pptr p = a->tp->is_ref();
					if (p && p->typ->tconst()==0) {
						mod = 1;
						goto ll2;
					}
				}
			}
		}
	}
ll2:
//error('d',"mod %d",mod);
	Pbase bp = new basetype(INT,0);
	*bp = *Pbase(Pptr(cl->this_type)->typ);
	if (mod == 0) bp->b_const = 1;
	return new ptr(RPTR,bp);
}

Pname classdef::make_itor(int def)
/*
	make cn::cn(const cn&) :bases_and_members_of_cn {}
*/
{
// error('d',"%t->make_itor(%d) %d",this,def,obj_size);
	Pstmt s;
	Pname e;
	int i;
	Pname arg = new name(make_name('A'));
	arg->tp = find_arg_type(this);

	c_xref |= C_XREF;	// now it has X(X&)

	if (def) {		// define itor
		int slow = 0;	// slow==0 => copy using vector copy
		int first = 1;
		Pexpr es = 0;
		s = new estmt(SM,no_where,0,0);
		e = 0;

		if (warning_opt && 128<obj_size)
			error('w',"copying a %d byte object (ofC %s)",obj_size,string);

		if (baselist)
			slow = 1;

		// initialize bases:
		if (slow) {
			for (Pbcl b = baselist; b; b = b->next) {
				Pclass bcl = b->bclass;
				Ptype pt = bcl->this_type;
				if (b->base==VIRTUAL || b->base==NAME) {	// generate :b(*(b*)&arg)
					Pexpr b2 = new name(arg->string);
					b2 = b2->address();
					b2 = new texpr(G_CAST,pt,b2);//new cast(pt,b2);
					b2->i2 = 1;
					b2 = b2->contents();

					Pname ee = new name(bcl->string);
					ee->base = TNAME;
					ee->n_initializer = b2;
					if (e)
						ee->n_list = e;
					e = ee;
				}
			}
		}

		for (Pname mm=memtbl->get_mem(i=1); mm; NEXT_NAME(memtbl,mm,i)) {	
			Ptype t = mm->tp;
			if (t && (t=t->skiptypedefs())->base==COBJ) {
					Pclass mcl = Pclass(Pbase(t)->b_name->tp);
					if (mcl->c_xref&(C_VBASE|C_XREF)) slow=1;
			}
		}


		for (Pname m=memtbl->get_mem(i=1); m; NEXT_NAME(memtbl,m,i)) {	// initialize members
			if ( m->base == TNAME ) continue;
			if (m->n_evaluated || m->n_stclass==STATIC)		// ignore static members
				continue;

			if (strcmp(m->string,"__vptr")==0) {
				if (slow==0 && first==0 && m->n_offset) {
					Pexpr th = new expr(THIS,0,0);
					Pexpr a = new name(arg->string);
					a = a->address();
					Pexpr ee = copy_obj(th,a,m->n_offset);
					es = es ? new expr(CM,es,ee) : ee;
				}
				slow = 1;
				first = 0;
				continue;
			}
			Ptype mt = m->tp;
			if ( mt )
		tx:	switch (mt->base) {
			case TYPE:
				mt = Pbase(mt)->b_name->tp;
				goto tx;
			case VEC:
			{
				Pname cn = Pvec(mt)->typ->is_cl_obj();
				if (cn && Pclass(cn->tp)->c_xref&(C_XREF|C_VBASE)) {
					error('s',"copy of %n[], no memberwise copy for%n",cn,cn);
					slow = 1;	// make sure an assignment operator
							// is generated so that there will
							// be no more error messages
				}

				if (slow && mt->tsizeof()) {
				/*
					generate:
					struct _s { char[sizeof(m)]; };
					*(struct _s*)this->m = *(struct _s*)arg.mem;
				*/
					Pexpr l = new name(m->string);
					Pexpr r = new name(m->string);
					r = new ref(DOT,new name(arg->string),r);
					Pexpr ee = copy_obj(l,r,mt->tsizeof());
					es = es ? new expr(CM,es,ee) : ee;
					break;
				}
			}
			case FCT:
			case OVERLOAD:
			case CLASS:
			case ENUM:
				break;
			case COBJ:
			{
				Pclass mcl = Pclass(Pbase(mt)->b_name->tp);
				if (
					slow==0		// if slow, previous members have already been copied
					&&
					mcl->c_xref&(C_VBASE|C_XREF)
				) {
					slow = 1;
					if (first==0 && m->n_offset) {
							//AAA copy up to here
						Pexpr th = new expr(THIS,0,0);
						Pexpr a = new name(arg->string);
						a = a->address();
						Pexpr ee = copy_obj(th,a,m->n_offset);
						es = es ? new expr(CM,es,ee) : ee;
					}
				}
				// no break
			}

			default:
				if (slow) {
// error('d',"slow %s %s",m->string,arg->string);
					Pname ee = new name(m->string);
					ee->n_initializer = new ref(DOT,new name(arg->string),new name(m->string));
					if (e)
						ee->n_list = e;
					e = ee;
				}
			}
			first = 0;
		}

		if (slow == 0) {
		/*	really simple just copy:
			the only problem was a vptr which can be
			ignored since X(X&) is going to reset it anyway
			don't use assignment of this struct to avoid operator=
		*/
			Pexpr th = new expr(THIS,0,0);
			Pexpr a = new name(arg->string);
			a = a->address();
			Pexpr ee = copy_obj(th,a,obj_size);
			es = es ? new expr(CM,es,ee) : ee;
		}

		s->e = es;
		Pname cn = this->k_tbl->find_cn(string);//SYM
		if (cn)
			cn = Pbase(cn->tp)->b_name;
		cc->stack();
		cc->not = cn;
		cc->cot = this;
	}
	Pname fn = new name(string);
	Pfct f = new fct(defa_type,arg,1);
	fn->tp = f;
	fn->n_oper = TNAME;

	Pfct(f)->f_inline = def?1:ITOR;		// ITOR means ``define itor() if used''
	Pfct(f)->f_is_inline = 1;
	if (def) {
		f->body = new block(curloc,0,s);
		f->f_init = e;
	}

	Pname nn = fn->dcl(memtbl,PUBLIC);
	delete fn;

	if (def) {
		cc->unstack();
		nn->simpl();
		if (debug_opt)
			nn->dcl_print(0);
	}
	return nn;
}

Ptype is_op_ass(Pfct f, Pclass tcl)
/*	is the operator an assignment operator? */
{
 	Ptype t = f->argtype->tp;
 	Pname an = t->is_cl_obj();        // X::operator=(X)
 	if (an==0 && (t=t->is_ref())) {   // X::operator=(X&)
 		t = Pptr(t)->typ;
 
 		Ptype nt = t;
 		while (nt->base == TYPE)
 			nt = Pbase(nt)->b_name->tp;
 
 		if (nt->base == COBJ)
 			an = Pbase(nt)->b_name;
 	}
	if (an && same_class(Pclass(an->tp),tcl)) return t;
 	return 0;
}

int make_assignment(Pname cn)
/*
	write the function:

	X& X::operator=(const X&) { assign all bases and members }

	return 1 is a function is really synthesized
*/
{
	Pclass cl = Pclass(cn->tp);
	Pstmt s = new estmt(SM,no_where,0,0);
	Pexpr e = 0;
	Pname arg = new name(make_name('A'));
	arg->tp = find_arg_type(cl);
//error('d',"make_assignment %t %d",cl,cl->obj_size);

	if (warning_opt && 128<cl->obj_size)
		error('w',"copying a %d byte object (ofC %s)", cl->obj_size,cl->string);
	int slow = 0;			// slow==0 => copy using vector copy
	int first = 1;			// first==1 => first member of (derived) class
	bit unconst=0;

	if (cl->baselist)
		slow = 1;		// be dumb and safe

	if (slow) {
		for (Pbcl b = cl->baselist; b; b = b->next) {
			Pclass bcl = b->bclass;
			Ptype pt = bcl->this_type;
			switch (b->base) {
			case NAME:
			{	// generate: *(bcl*)this = *(bcl*)&arg;
//error('d',"base %t",bcl);
				Pexpr b1 = new expr(THIS,0,0);
				b1 = new texpr(G_CAST,pt,b1);
				b1 = b1->contents();

				Pexpr b2 = new name(arg->string);
				b2 = b2->address();
				b2 = new texpr(G_CAST,pt,b2);
				b2->i2 = 1;
				b2 = b2->contents();

				Pexpr ee = new expr(ASSIGN,b1,b2);
				e = e ? new expr(CM,e,ee) : ee;
				break;
			}
			case VIRTUAL:
				if (warning_opt)
					error('w',"copying an object ofC%n with a virtualBC",cn);
				if (b->ptr_offset) {
					// copy object, but not pointer
					// generate: *(bcl*)this->Pw = *(bcl*)arg->Pw;

					// I don't know how to avoid copying the object
					// once for each pointer

					Pexpr b1 = new expr(THIS,0,0);
					b1 = new mdot(bcl->string,b1);
					b1->i1 = 3;
					b1->tp = pt;
					b1 = new expr(DEREF,b1,0);//b1->contents();

					Pexpr b2 = new name(arg->string);
					b2 = b2->address();
					b2 = new mdot(bcl->string,b2);
					b2->i1 = 3;
					b2->tp = pt;
					b2 = new expr(DEREF,b2,0);//b2->contents();

					Pexpr ee = new expr(ASSIGN,b1,b2);
					e = e ? new expr(CM,e,ee) : ee;
				}
				break;
			}
		}
	}

	int i;
	for (Pname m=cl->memtbl->get_mem(i=1); m; NEXT_NAME(cl->memtbl,m,i) ) {
		if ( m->base == TNAME ) continue;
		// ignore static members
		if (m->n_evaluated || m->n_stclass==STATIC)
			continue;

		if (strcmp(m->string,"__vptr")==0) {	// don't copy vptrs
							// we may be copying
							// into a base class object
			if (first==0 && m->n_offset && !e) {
						// copy up to (but not including) vptr
						// don't copy if first member
					Pexpr th = new expr(THIS,0,0);
					Pexpr a = new name(arg->string);
					a = a->address();
					e = copy_obj(th,a,m->n_offset);
			}
			slow = 1;
			first = 0;
			continue;
		}
		Ptype mt = m->tp;
		if (mt)
	tx:	switch (mt->base) {
		case TYPE:
			mt = Pbase(mt)->b_name->tp;
			goto tx;
		case VEC:
		{
			Pname cn = Pvec(mt)->typ->is_cl_obj();
			if (cn && Pclass(cn->tp)->c_xref&(C_ASS|C_VBASE)) {
				error('s',"copy of %n[], no memberwise copy for%n",cn,cn);
				slow = 1;	// make sure an assignment operator
						// is generated so that there will
						// be no more error messages
			}

			if (slow && mt->tsizeof()) {
			/*
				protect against sizeof(mt)==0: char[]
				generate:
					struct _s { char[sizeof(m)]; };
					*(struct _s*)this->m = *(struct _s*)arg.mem;
			*/	
				Pexpr l = new name(m->string);
				Pexpr r = new name(m->string);
				r = new ref(DOT,new name(arg->string),r);
				Pexpr ee = copy_obj(l,r,mt->tsizeof());
				e = e ? new expr(CM,ee,e) : ee;
				break;
			}
		}
		case FCT:
		case OVERLOAD:
		case CLASS:
		case ENUM:
			break;
		case COBJ:
//error('d',"cobj %n %d %d",m,slow,Pclass(Pbase(mt)->b_name->tp)->c_xref);
			{
			Pclass tempcl=Pclass(Pbase(mt)->b_name->tp);
			if (
				slow==0
				&&
				Pclass(Pbase(mt)->b_name->tp)->c_xref&(C_VBASE|C_ASS)
			) {					// must use its assignment operation
				if (first==0 && m->n_offset) {	// copy up to this member 
					Pexpr th = new expr(THIS,0,0);
					Pexpr a = new name(arg->string);
					a = a->address();
					e = copy_obj(th,a,m->n_offset);
				}
				slow = 1;
			}

			suppress_error++;
			Pname nn = tempcl->has_oper(ASSIGN);
			suppress_error--;
 			if( nn && nn->tp->base == FCT ) {
 			Pptr atp=Pptr(nn->fct_type()->argtype->tp);
 				if( atp && atp->typ && atp->typ->b_const==0) {
 					unconst = 1;
 				}
 			}
 			else if (nn && nn->tp->base == OVERLOAD) {
 				Plist pl = Pgen(nn->tp)->fct_list;
 				while (pl) {
 					Pfct ff = pl->f->fct_type();
					Ptype t = is_op_ass(ff,tempcl);
 				        if(t && t->b_const==0) {
 					    unconst = 1;
 					    break;
 					}
 					pl = pl->l;
 				}
 			}
			}
			// no break: copy cobj itself
		case RPTR:
			if (mt->base==RPTR)
				if (cl->c_xref!=C_REFM) {
					error("cannot assignC%t:RM%n",cl,m);
					break;
				}
				else slow=1;
		default:
 //error('d',"defa %n %d",m,slow);
			if (slow) {
				if (m->tp->tconst())
					error("cannot assignC%t: const M%n",cl,m);
				Pname ms = new name(m->string);
				Pname as = new name(arg->string);
				Pexpr ee = new ref(DOT,as,new name(m->string));
				ee = new expr(ASSIGN,ms,ee);
				e = e ? new expr(CM,e,ee) : ee;
			}
		}
		first = 0;
	}

	if (slow == 0) {		// really simple just copy:
		return 0;
	}

	Pexpr rv = new expr(THIS,0,0);
	rv = new expr(DEREF,rv,0);	//b1->contents();
	
	s->e = e ? new expr(CM,e,rv) : e;
	s->s_list = new estmt(RETURN,no_where,rv,0);

	cc->stack();
	cc->not = cn;
	cc->cot = cl;

	cl->c_xref |= C_ASS;		// now it has X::operator=(const X&)

	Pname fn = new name(oper_name(ASSIGN));
	Pfct f = new fct(new ptr(RPTR,Pptr(cl->this_type)->typ),arg,1);
	f->f_inline = 1;
	f->f_is_inline = 1;
	if (unconst)
		Pptr(f->argtype->tp)->typ->b_const=0;
	fn->tp = f;
	fn->n_oper = ASSIGN;
	fn->n_sto = STATIC;
	Pname nn = fn->dcl(cl->memtbl,PUBLIC);
	delete fn;
	Pfct(nn->tp)->body = new block(curloc,0,s);
	Pfct(nn->tp)->dcl(nn);

	cc->unstack();
	nn->simpl();
//error('d',"make_assign->");
	return 1;
}

void prnt_all_in_scope(Pclass cl) {
//
// Lays out all members  (visible from an inner _nested_ class)
// traversing the in_class chain  (up to the outer most class).
//
int   i;

   if (cl->in_class)
      prnt_all_in_scope(cl->in_class);
    	for (Pname nn=cl->memtbl->get_mem(i=1); nn; NEXT_NAME(cl->memtbl,nn,i))
        {
		if ( nn->base == TNAME ) continue;
		if (
			((nn->base) && nn->base==NAME)
			&&
			(nn->n_anon==0)
			&&
			(nn->n_stclass == STATIC)
			&&
                        ((nn->tp) &&
                         (
			  nn->tp->base!=FCT
			  &&
			  nn->tp->base!=OVERLOAD
			  &&
			  nn->tp->base!=CLASS
			  &&
			  nn->tp->base!=ENUM
                         )
                        )
		   ) {
			nn->dcl_print(0);
		     }
	}
}

bit simpl_friend;

void classdef::dcl(Pname cname, Ptable tbl)
{
	int bvirt = 0;
	int dvirt = 0;
	int scope = PUBLIC;
	int protect = 0;
	int st = 1;		// nothing private or protected seen: a struct

	int byte_old = byte_offset;
	int bit_old = bit_offset;
	int max_old = max_align;
	int boff = 0;

	int in_union = 0;
	int usz;
	int make_ctor = 0;
	int make_dtor = 0;

	if (this == 0)		// this is the place for paranoia
		error('i',"0->Cdef::dcl(%p)",tbl);
	if (base != CLASS)
		error('i',"Cdef::dcl(%d)",base);
	if (cname == 0)
		error('i',"unNdC");
	if (cname->tp != this)
		error('i',"badCdef");
	if (tbl == 0)
		error('i',"Cdef::dcl(%n,0)",cname);
	if (tbl->base != TABLE)
		error('i',"Cdef::dcl(%n,tbl=%d)",cname,tbl->base);
	DB( if(Ddebug>=1) error('d',&cname->where,"classdef::dcl %s tbl %d gtbl %d",string,tbl,gtbl); );
// error('d',&cname->where,"classdef::dcl %s tbl %d gtbl %d",string,tbl,gtbl); 

	switch (csu) {
	case UNION:
		in_union = UNION;
		break;
	case ANON:
		in_union = ANON;
		break;
	case CLASS:
		scope = 0;
	}

	max_align = AL_STRUCT;

	if ( local_sig ) {
		c_context = tbl;
		in_fct = cc->nof;
	} else in_fct = 0;

	if (baselist) {
		/*
			check base classes.
			duplicates were removed in start_cl() in norm.c.
			remove bad classes.
			add virtual bases from bases to the list.

			check against
				class b : a {}
				class c : a, b {}	// first a inaccessible
		*/
		
		Pbcl ll = 0;
		Pbcl lll = 0;
		Pbcl vlist = 0;
		for (Pbcl lx, l=baselist; l; l=lx) {	// remove bad bases
			Pclass cl = l->bclass;

			lx = l->next;

//error('d',"base1 %t %k init %d",cl,l->ppp,l->init);
			if (l->ppp == 0) {		// ``class'' => private base ``struct'' => public base
				l->ppp = csu==CLASS ? PRIVATE : PUBLIC;
#ifndef OLD
				if (l->ppp == PRIVATE)
					error('w',"B%t private by default: please be explicit ``: private%t",cl,cl);
#endif
			}
			// if you have a ``class'' as base you cannot remain a ``mere struct''
			if (cl && cl->csu == CLASS)
				st = 0;

			if ((cl->defined&(DEFINED|SIMPLIFIED)) == 0) {
				error("BC %tU",cl);
				continue;
			}
			else
				(void)cl->tsizeof();	// ensure printout

			if (cl->csu==UNION || cl->csu==ANON) {
				error("C derived from union");
				continue;
			}

			if (in_union) {
				error("derived union");
				continue;
			}

			if (warning_opt &&
			    (l->base==VIRTUAL || l != baselist) &&
			    cl->has_dtor() && cl->has_dtor()->tp &&
			    !Pfct(cl->has_dtor()->tp)->f_virtual)
				error('w', "second or virtualBC%tWout virtual destructor", cl);

			if (l->base==VIRTUAL) {		// order of virtual classes doesn't matter
				l->next = vlist;
				vlist = l;
			}
			else {				// keep ordinary base classes in order
				if (ll == 0) {
					lll = l;
					l->next = 0;
				}
				else
					ll->next = l;
				ll = l;
			}
		}
		if (ll) {
			ll->next = vlist;	// put virtual bases at end
			baselist = lll;
		}
		else
			baselist = vlist;

		lll = 0;
		for (l=baselist; l; l=l->next) {	// detect unmanageable duplicates
			Pclass b = l->bclass;

			for (ll=baselist; ll; ll=ll->next)
				if (!::same_class(b,ll->bclass) && ll->bclass->check_dup(b,l->base)) {
					if (lll)
						lll->next = l->next;
					else
						baselist = l->next;
					goto mmm;
				}

			lll = l;
			mmm:;
		}

		for (l=baselist; l; l=l->next) {	// promote virtual bases
			Pclass b = l->bclass;
			for (ll=b->baselist; ll; ll=ll->next) {
				if (ll->base == VIRTUAL) {
					Pclass v = ll->bclass;
  					for (Pbcl lll=baselist; lll; lll=lll->next) 
						if (::same_class(lll->bclass,v)) {
  							// promoted virtual base class
  							// takes on most accessible level
  							if (ll->ppp < lll->ppp) 
  								lll->ppp = ll->ppp;
							goto nnn;
						}
					baselist = new basecl(v,baselist);
					baselist->base = VIRTUAL;
					baselist->promoted = 1;
// needs a more complete check of visibility rules
//error('d',"promote %t %k",v,ll->ppp);
					baselist->ppp = ll->ppp;
				}
				nnn:;
			}
		}

		ll = 0;
		lll = 0;
		l=baselist;
		baselist = 0;
		vlist = 0;
		for (; l; l=lx) {
					// sort virtual bases so that no virtual base
					// is ahead of its own virtual base
			lx = l->next;
			if (l->base == VIRTUAL) { // add to sorted vlist
						  // each class before its bases
				if (vlist == 0) {
					vlist = l;
					l->next = 0;
				}
				else {
					Pclass lb = l->bclass;
					Pbcl v_prev = 0;
					for (Pbcl vx, v = vlist; v; v=vx) {
						Pclass vb = v->bclass;
						vx = v->next;

						if (lb->has_base(vb)) {	// put l ahead of v
							l->next = v;
							if (v_prev)
								v_prev->next = l;
							else
								vlist = l;
							break;
						}
						if (vx == 0) {	// stick l at end
							v->next = l;
							l->next = 0;
							break;
						}	
						v_prev = v;
					}
				}
			}
			else {			// keep in order
				if (ll == 0) {
					lll = l;
					l->next = 0;
				}
				else
					ll->next = l;
				ll = l;
			}
		}

		if (ll) {
			ll->next = vlist;	// put virtual bases at end
			baselist = lll;
		}
		else
			baselist = vlist;

		for (l=baselist; l; l=l->next) {	// allocate base class objects
			Pclass cl = l->bclass;
// error('d',"classdef::dcl base %t %k %k",cl,l->ppp,l->base);
			if (l->base == VIRTUAL) {	// : virtual bclass
							// pointer and object for virtual base MAY
							// be allocated at the end - but not here
				c_xref |= C_VBASE;
				dvirt += cl->virt_count;
			}
			else {				// : bclass =>allocate
				int ba = cl->align();
				if (max_align<ba)
					max_align = ba;

				if (::same_class(cl,baselist->bclass)) {   // pad to ensure alignment:
					boff = cl->real_size;
								// not obj_size-real_size, we can
								// optimize vbase object away
					int xtra = boff%ba;
								// align
					if (xtra)
						boff += ba-xtra;
				}
				else {				// let C handle the padding:
					int xtra = boff%ba;
					if (xtra)
						boff += ba-xtra;	// align
					l->obj_offset = boff;
								// don't use waste
					boff += cl->obj_size;
				}
				bvirt += cl->virt_count;
			}

			if (cl->has_vvtab)
				has_vvtab = 1;
			c_xref |= cl->c_xref;

//error('d',"%t: base %t conv %d base conv %d",this,cl,conv,cl->conv);
			conv = merge_conv(conv,cl->conv);
		}
	}

	memtbl->set_name(cname);

	int nmem = 0;
	int fct_mem = 0;
	{
		for (Pname m = mem_list; m; m=m->n_list) {
			nmem++;
			if (m->tp && m->tp->base==FCT)
				fct_mem++;
			else if (m->base == TNAME)
				;
			else { 
				if (m->tp && m->tp->base==RPTR && c_xref==0)
					c_xref=C_REFM;
				if (ansi_opt && m->tp && m->tp->tconst() && m->n_sto!=STATIC)
					Pbase(m->tp)->ansi_const=1;
			}
		}
	}

	if (nmem)
		memtbl->grow((nmem<=2)?3:nmem);

	cc->stack();
	cc->not = cname;
	cc->cot = this;

	byte_offset = usz = boff;
	bit_offset = 0;
	
	int real_virts = 0;
	Pbase bt = new basetype(COBJ,cname);
	bt->b_table = memtbl;
	Ptype cct = bt->addrof();
						// for strict opt type of `this': X *const
						// '2' distinguishes this case from a real constant object
	if (strict_opt && perf_opt)
		Pptr(cct)->b_const = 2;
	this_type = cc->tot = cct;
	this_type->ansi_const = 1;
	PERM(cct);
	PERM(bt);

	for (Pname px, p=mem_list; p; p=px) {
	/*
		look at each member;
		declare it and determine its visibility
		calculate offsets and sizes
	*/
		px = p->n_list;
// error( 'd', "p: %n %k n_scope: %d", p, p->base, p->n_scope );

		switch (p->base) {
		case PUBLIC:
			scope = PUBLIC;
			protect = 0;
			goto prpr;

		case PRIVATE:
			scope = 0;
			protect = 0;
			goto prpr;

		case PROTECTED:
			scope = 0;
			protect = PROTECTED;
		prpr:
			if (in_union == ANON)
				error(&p->where,"%k in anonymous unionD",p->base);
			continue;

		case PR:	// visibility control:	C::M
		{
			char* qs = p->n_qualifier->string;
			char* ms = p->string;
			TOK ppp = scope?PUBLIC:(protect?PROTECTED:PRIVATE);

			p->base = NAME;
			p->n_scope = scope;
			p->n_protect = protect;

			if (strcmp(ms,qs) == 0)
				ms = "__ct";

			ppbase = PUBLIC;

			if (is_base(qs) == 0) {
				error("%kQr %s not aBC of %t",ppp,qs,this);
				continue;
			}

			mex = 1; // print error messages for access violations 
			tcl = mec = this;
			Pname os = Cdcl;
			Cdcl = p; // for line #s in error messages 
			Pexpr ee = find_name(ms,0,1);
			Cdcl = os;

// error('d', "ee: %k ", ee->base );

			if ( ee && ee->base != NAME && ee->base != TNAME )
			    error('i',"bad returnE%k from %t->find_name(%s,0,1)",ee->base,this,ms);
			Pname mx = Pname(ee);

// error('d', "ee: %k mx: %n", ee->base, mx );

			if (mx == 0) {
				error("C %s does not have aM %s",qs,ms);
				continue;
			}

			if (mx->tp->base == OVERLOAD) {
				error('s',"%k specification of overloaded%n",ppp,mx);
				continue;
			}

			TOK pp = mx->n_scope?PUBLIC:mx->n_protect?PROTECTED:PRIVATE;
			
// error('d',"mx %n pp %k ppp %k",mx,pp,ppp);
			if (ppp != pp) {
				error(&p->where,"%kM%n specified%k",pp,mx,ppp);
				continue;
			}	

			p->n_qualifier = mx;
			Pname m = memtbl->insert(p,0);
			m->base = PUBLIC;
			if (Nold)
				error("twoDs ofCM%n",p);
			continue;
		}
		}

// error('d',"mem%n tp %d %k scope %d",p,p->tp->base,p->tp->base,scope);

/* XXXXX: 
		if (class_base == INSTANTIATED && templ_base == CL_TEMPLATE) {
			if ( p->base == TNAME || p->tp->base == CLASS
    				|| p->tp->base == ENUM )
					error('s',"nestedT%nWin specializedYC%t",p,this);
		}
*/

		if (scope==0) { 
			if (p->n_sto != STATIC)
				st = 0;
		}
		else if ( p->tp->base == TYPE ) {
			Pname nn = p->tp->is_cl_obj();
			if (nn) { 
// error( 'd', "nn: %n %k tp %t %k", nn, nn->base, nn->tp, nn->tp->base );
				if (
					Pclass(nn->tp)->csu == CLASS
					&&
					strcmp(this->string,nn->string)
				)
					st = 0;
			}
		}

//error('d',&p->where,"p%n base%k tp%k: ll %d",p,p->base,p->tp->base,p->lex_level);
//if(px)error('d',&p->where,"px%n base%k tp%k:%t",px,px->base,px->tp->base,px->tp);
		//if ( p->tp->base == CLASS && Pclass(p->tp)->csu == ANON ) {
		//    if ( px == 0
		//    ||   px->tp->base != COBJ
		//    ||   px->tp->classtype() != p->tp )
		//	error('i',&p->where,"missing anon object");
		//}
		if ( in_union == ANON ) {
		    if ( p->tp->base == CLASS && Pclass(p->tp)->csu == ANON ) {
			// anon inside an anon; lift members to enclosing class
			Pname pu = Pclass(p->tp)->mem_list;
			while ( pu ) {
//error('d',&p->where,"pu%n base%k tp%k: ll %d",pu,pu->base,pu->tp->base,pu->lex_level);
				Ptype tx = 0;
				if ( pu->base == TNAME ) tx = pu->tpdef;
				else if ( pu->tp->base == CLASS 
				     ||   pu->tp->base == ENUM )
					tx = pu->tp;
				else --pu->lex_level;
				if ( tx ) {
					tx->in_class = this;
					delete tx->nested_sig;
					tx->nested_sig = make_nested_name(pu->string,this);
				}
				if ( !pu->n_list ) break;
				pu = pu->n_list;
			}
			if ( pu ) {
				pu->n_list = px->n_list;
				px = Pclass(p->tp)->mem_list;
			}
			Pclass(p->tp)->mem_list = 0;
			continue;
		    } // p is anon class
		    if ( p->base != TNAME 
		    &&   p->tp->base != CLASS
		    &&   p->tp->base != ENUM )
			--p->lex_level;
		} // if this is anon
//error('d',&p->where," -- p%n base%k tp%k: ll %d",p,p->base,p->tp->base,p->lex_level);

		if (p->base == TNAME) {
			p->dcl(memtbl,scope);
			// typedefs need to be generated outside class
			if ( p->tp && Pbase(p->tp)->base != COBJ ) {
				if (p->n_dcl_printed == 2)
					; // don't print
			        else p->dcl_print(0);
			}
			continue;
		} // if TNAME 

		if (p->tp->base == FCT) {
			int ff = 0;
			Pfct f = Pfct(p->tp);
			Pblock b = f->body;
			f->body = 0;
			if (b) {
				f->f_inline = 1;
				f->f_is_inline = 1;
			}
			else if (lex_level) 
				error('w',&p->where,"non-inlineMF%n in localC %t",p,this);
			else if (csu != ANON && string && string[0] == '_' && string[1] == '_' && string[2] == 'C')
				error("non-inlineMF%n in unnamedC", p);
			switch (p->n_sto) {
			case FRIEND:
				ff = 1;
				break;
			case STATIC:	// accept static member functions
//error('d',"inline %d",f->f_inline);
				if (lex_level) 
					error('w',&p->where,"staticMF%n in localC %t",p,this);
				f->f_static = 1;
				p->n_sto = 0;
				break;
			case AUTO:
			case REGISTER:
			case EXTERN:
				error(&p->where,"M%n cannot be%k",p,p->n_sto);
				p->n_sto = 0;
			}

			if (f->f_virtual) real_virts++;
			if (ff && f->fct_base==FCT_TEMPLATE) continue; // already handled

			Pname m = p->dcl(memtbl,scope);
			if (m == 0 || m->tp->base != FCT)
				continue;
			if (m->n_initializer) {
				c_abstract = m;
				if (m->n_oper == DTOR)
					error('w',"please provide an out-of-line definition: %n {}; which is needed by derived classes",m);
			}
			if (ff == 0)
				m->n_protect = protect;
			if (b) {
				if (m->tp->defined&DEFINED || Pfct(m->tp)->body )
					error(&p->where,"two definitions of%n",m);
				else {
					Pfct(m->tp)->body = b;
					Pfct(m->tp)->def_context = f->def_context;
				}
			}
			if (ff==0 && p->tp!=m->tp)
				error(&p->where,"%n cannot be redeclared inCD",p);
		}
		else {
			Eppp = scope?scope:protect?protect:0;

			if (p->n_initializer) {
				error(&p->where,"Ir forM%n",p);
				p->n_initializer = 0;
			}

			if (p->tp->base==OVERLOAD) {
				for (Plist gl=Pgen(p->tp)->fct_list; gl; gl=gl->l) { 
					Pname nn = gl->f;
					Pfct ff = Pfct(nn->tp);
					if ( ff->f_virtual ) real_virts++;
				}
			}

// error('d',"lex_level %d p %n lex %d nested_scope: %k",lex_level,p,p->lex_level, nested_scope);

			TOK is_friend = p->n_sto;
			if (
				protect
				&&
				p->tp->base == COBJ
				&&
				Pclass(Pbase(p->tp)->b_name->tp)->csu == ANON
			)
				p->n_protect = protect;

			Pname m = p->dcl(memtbl,scope);
			Eppp = 0;
			if (m == 0)
				continue;

			m->n_protect = protect;

			if (m->n_stclass==STATIC) {
				if (in_union && is_friend != FRIEND)
					error(&m->where,"staticM%n in union",m);
				if ( is_friend != FRIEND ) {
					if (lex_level)
						error(&m->where,"staticM%n in localC %t",m,this);
				}
				m->n_sto = EXTERN;
				if (tbl == gtbl)
					stat_mem_list = new name_list(m,stat_mem_list);
				if (m->n_initializer)
					error('s',"staticM%nWIr",m);
			}

			if (in_union) {
				if (usz < byte_offset)
					usz = byte_offset;
				byte_offset = 0;
				if(in_union==ANON)
					m->n_offset+=byte_old;
			}
		}
	}

	if (st && csu==CLASS)
		csu = STRUCT;	// nothing private => STRUCT
	if (st==0 && csu==STRUCT)
		csu = CLASS;	// all is not public => CLASS

	if (in_union)
		byte_offset = usz;

	// now look look at the members

	Pname ct = has_ctor();
	Pname dt = has_dtor();

	int i;

	int omex = mex; mex = 0;
	Pname on = has_oper(NEW);
	Pname od = has_oper(DELETE);
	mex = omex;

	if (dt && ct==0 && Pfct(dt->tp)->f_virtual == 0 )
		error('w',"%t has%n but noK",this,dt);
	if (on && od==0)
		error('w',"%t has%n but no operator delete()",this,on);
	if (od && on==0)
		error('w',"%t has%n but no operator new()",this,od);

	if (dt==0 && od && od && od->n_table==memtbl)
		make_dtor = 1;

	for (Pname m=memtbl->get_mem(i=1); m; NEXT_NAME(memtbl,m,i) ) {
		if ( m->base == TNAME ) continue;
	/*
		The members have been declared.
		now look at each to see if it needs defining
	*/
		Ptype t = m->tp;

		if (t == 0)
			continue;	// public declarations
// error('d', "m %n %d", m, m->n_scope );

		switch (t->base) {
		default:
			if (
				ct==0
				&&
				m->n_stclass!=ENUM
				&&
				m->n_stclass!=STATIC
			) {
				if (t->is_ref())
					error("R%n inC%tWoutK",m,this);
				if (
					t->tconst()
					&&
					vec_const==0
					&&
					m->n_evaluated==0
				)
					error("const%n inC%tWoutK",m,this);
			}
			// no break
		case VEC:
			break;

		case FCT:
		case OVERLOAD:
		case CLASS:
		case ENUM:
			continue;
		}

		Pname cn = t->is_cl_obj();
		if (cn == 0)
			cn = cl_obj_vec;
		if (cn == 0)
			continue;

		Pclass cl = Pclass(cn->tp);
		c_xref |= cl->c_xref;
//error('d',"m %n %t %d",m,cl,cl->c_xref);
		if (cl->has_ctor()) {
			if (m->n_stclass == STATIC)
				;
			else if (in_union) {
				if (strncmp("__C",string,3) == 0)
					error("M %s ofC%tWK in union",m->string,cl); // tagless union
				else
					error("M%n ofC%tWK in union",m,cl);
			}
			else if (ct == 0) {
				// does mctor have a default constructor?
				if (make_ctor==0 && cl->has_ictor()==0)
					error("%t needs aK; it has aMWK requiringAs",this);
				make_ctor = 1;
			}
		}
		if (in_union && (c_xref & C_ASS))
			error("M%n ofC%tW assignment operator in union",m,cl);

		if (cl->has_dtor()) {
			if (m->n_stclass==STATIC)
				;
			else if (in_union) {
				if (strncmp("__C",string,3) == 0) // tagless union
					error("M %s ofC%tW destructor in union",m->string,cl);
				else
					error("M%n ofC%tW destructor in union",m,cl);
			}
			else if (dt==0)
				make_dtor = 1;
		}
	}

	if (has_dtor()==0 && make_dtor==0) {
		// can dtor be inherited (from single base class)?
		Pclass bcl = 0;
		for (Pbcl b = baselist; b; b = b->next) {
			switch (b->base) {
			case NAME:
				if (bcl == 0) {
					Pname d = b->bclass->has_dtor();
					if (d==0)
						break;
/*
this breaks CC884232
					if (strict_opt == 0) {
						if (
							d->n_scope==PUBLIC
							&&
							Pfct(d->tp)->f_virtual==0
						) {
							bcl = b->bclass;
							break;
						}
					}
*/
				}
				// two dtors or non-public dtors force creation
				make_dtor = 1;
				goto zbzb;
			case VIRTUAL:
				if (b->bclass->has_dtor())
					make_dtor = 1;
				goto zbzb;
			}
		}
		if (bcl)
			c_dtor = bcl->has_dtor();
	zbzb:;
	}

	if (make_dtor && dt==0) {	// make x::~x() {}
		// must be done before vtbls are made in case dtor is virtual
//error('d',"%t: make_dtor",this);
		Pname n = new name(string);
		Pfct f = new fct(defa_type,0,1);
		f->f_inline = 1;
		f->f_is_inline = 1;
		n->tp = f;
		n->n_oper = DTOR;
		dt = n->dcl(memtbl,PUBLIC);
		delete n;
		Pfct(dt->tp)->body = new block(curloc,0,0);
		dt = has_dtor();
	}

	if (virt_count && find_vptr(this)==0) {
		// we only need a vptr if this class has virtual
		// functions and none of its first bases have vptrs
//error('d',"%s virt_count %d",string,virt_count);
		Pname vp = new name("__vptr");
		vp->tp = Pvptr_type;
		(void) vp->dcl(memtbl,0);
		delete vp;
		c_xref |= C_VPTR;
	}
	else {
//error("byte_offset %d bit_offset %d bitsinbyte %d",byte_offset,bit_offset,BI_IN_BYTE);
//error("   div %d mod %d",bit_offset/BI_IN_BYTE,bit_offset%BI_IN_BYTE);
		// no more bit fields. absorb bit_offset
		if (bit_offset) {
			byte_offset += (bit_offset/BI_IN_BYTE + (bit_offset%BI_IN_BYTE?1:0));
			bit_offset = 0;
		}
	}
//error("byte_offset %d bit_offset %d",byte_offset,bit_offset);

	for (Pbcl b = baselist; b; b = b->next) { // allocate virtual base pointers
		if (b->base != VIRTUAL)
			continue;
		Pclass bcl = b->bclass;

		// search non-virtual bases for this virtual base
		for (Pbcl bb = baselist; bb; bb = bb->next)
			if (bb->base == NAME) {
				for (Pbcl l = bb->bclass->baselist; l; l=l->next)
					if (l->base==VIRTUAL && ::same_class(l->bclass,bcl))
						goto eee;
			}

		{
// error('d',"classdef::dcl vbc* allocation: bcl: %t bb: %t",bcl,bb?bb->bclass:0);
			if (int(obj_align)<AL_WPTR)
				obj_align = AL_WPTR;
			if (max_align<AL_WPTR)
				max_align = AL_WPTR;
			int waste = byte_offset%AL_WPTR;
			if (waste)
				byte_offset += AL_WPTR-waste;		// align
			b->ptr_offset = byte_offset+1;			// ensure != 0
			byte_offset += SZ_WPTR;
		}
	eee:;
	}

	real_size = byte_offset;	// the rest may be optimized away

	for (b = baselist; b; b = b->next) {	// allocate virtual class objects
		if (b->base != VIRTUAL)
			continue;
		Pclass bcl = b->bclass;

		// if necessary
		link_compat_hack = 0;
		if (b->obj_offset = has_allocated_base(bcl))
			continue;

// error('d',"%t->dcl: allocating vbc %t link_compat_hack: %d",this,bcl,link_compat_hack);
		int ba = bcl->align();
		if (int(obj_align)<ba)
			obj_align = ba;
		if (max_align<ba)
			max_align = ba;
		int waste = byte_offset%ba;
		if (waste)
			byte_offset += ba-waste;	// align
		b->obj_offset = byte_offset;		// offset in this
		b->allocated = 1 + link_compat_hack;
		link_compat_hack = 0;
// error('d',"virtual object allocation %t in %t at %d",bcl,this,b->obj_offset);
		byte_offset += bcl->tsizeof();
	}

	// no more data members.
	// pad object (so that copying into a base object
	// doesn't destroy derevid class members):
	if (byte_offset==0) {	// empty struct: waste a member
		Pname c = new name (make_name('W'));
		c->where = cname->where;
		c->tp = char_type;
		(void) c->dcl(memtbl,0);
		real_size = byte_offset = 1;
	}
	if (byte_offset < SZ_STRUCT)
		byte_offset = SZ_STRUCT;
	int waste = byte_offset%max_align;
//error('d',"max_align %d waste %d byte_offset %d",max_align,waste,byte_offset);
	if (waste)
		byte_offset += max_align-waste;
	obj_size = byte_offset;
	obj_align = max_align;

	// make vtbls
	// this cannot be done until the bases
	// have been allocated in this class
	// so that the offsets (deltas) are known
	if (all_virt(this,0,1,0)) {
		if (has_ctor()==0)
			make_ctor = 1;
	}
	else if (has_vvtab)
		error("virtualB: conflicting vtable initialization");

// error('d',"%t->classdef: virt_count: %d virt_merge: %d",this,virt_count,virt_merge);


	Pname hito = has_itor();

	if (hito)
		c_xref |= C_XREF;	// has user defined X(X&)
//error('d',"%t hito %d ctor %d",this,hito,make_ctor);
	if (hito==0 && c_xref&(C_VPTR|C_VBASE|C_XREF)) {
						// X(X&) needed if bitwise copy is illegal
						// or if any constructor is defined

		hito = make_itor(0);
						// if the base has B::B(void)
						// the derived should have D::D(void)
		if (baselist) {
			int mc = 1;		// can make and ictor
			for (Pbcl b = baselist; b; b = b->next) {
				if (b->bclass->has_ctor() && b->bclass->has_ictor()==0)
						mc = 0;
			}
			make_ctor = mc;
		}
		else
			make_ctor =  1;
	}

	if (c_ctor==0 && make_ctor==0) {	// can ctor be inherited (from single base class)?
		Pname btor = 0;
		Pclass bc = 0;
		for (Pbcl b = baselist; b; b = b->next) {
			switch (b->base) {
			case NAME:
			{
				Pname c = b->bclass->has_ctor();
				if (c == 0)
					break;
				if (c->n_scope==PUBLIC && b==baselist) {
					bc = b->bclass;
					btor = bc->has_ictor();
					break;
				}
			}
				// no break: two bases: needs ctor
			case VIRTUAL:
				make_ctor = 1;	// virtual base: need ctor
				goto zaza;
			}
		}
//error('d',"btor %n",btor);
		if (bc) {
			if (btor)
				make_ctor = 1;
			else
				error("K needed for%t, BC%t hasK",this,bc);
		}
	zaza:;
	}

	if (make_ctor && ct==0) {	// make x::x() {}
//error('d',"%t: make_ctor",this);
		Pname n = new name(string);
		Pfct f = new fct(defa_type,0,1);
		f->f_inline = 1;
		f->f_is_inline = 1;
		n->tp = f;
		n->n_oper = TNAME;
		ct = n->dcl(memtbl,PUBLIC);
		delete n;
		Pfct(ct->tp)->body = new block(curloc,0,0);
	}


	if (pt_opt && !nested_sig && !local_sig && !is_probably_temp(string)
		&& !tempdcl) 
		if (csu==UNION)
			fprintf(pt_file,"u %s %s\n",string,curr_filename());
		else if (csu==STRUCT) {
			fprintf(pt_file,"s %s %s\n",string,curr_filename());
		}
		else if (csu==CLASS)
			fprintf(pt_file,"c %s %s\n",string,curr_filename());


//	if (ansi_opt && (defined&(DEFINED))==0) {
//		char* s = csu==UNION || csu==ANON ? "union" : "struct";
//		if ( nested_sig )
//			fprintf(out_file,"%s __%s;\n",s,nested_sig);
//		else
//			fprintf(out_file,"%s %s;\n",s,local_sig?local_sig:string);
//	}

	defined |= DEFINED;
	typedef_checkall(this);

//error('d',"defined %s",string);

	// fix argument lists for inlines
	for (p=memtbl->get_mem(i=1); p; NEXT_NAME(memtbl,p,i)) {
		if ( p->base == TNAME ) continue;
		Pfct f = Pfct(p->tp);
		if (f==0)
			continue;	// public declarations

		switch (f->base) {
		case FCT:
			//SYM remove transitional stuff
			if (hito && f->argtype)
				fix_args(f,this);
			if (p->n_oper == CTOR)
				f->s_returns = this_type;
			if (f->body)
				p->n_sto = STATIC;
			break;
		case OVERLOAD:
		{
			Pgen g = Pgen(f);
			for (Plist gl=g->fct_list; gl; gl=gl->l) {
				Pname n = gl->f;
				Pfct f = Pfct(n->tp);

				if (hito && f->argtype)
					fix_args(f,this);
				if (n->n_oper == CTOR)
					f->s_returns = this_type;
				if (f->body)
					n->n_sto = STATIC;
			}
		}
		}
	}

	// define members defined inline
	for (p=memtbl->get_mem(i=1); p; NEXT_NAME(memtbl,p,i)) {
		if ( p->base == TNAME ) continue;
		Pfct f = Pfct(p->tp);
		if (f==0)
			continue;	// public declarations

		switch (f->base) {
		case FCT:
			if (f->body) {
				f->dcl(p);
				p->simpl();
			}
			break;
		case OVERLOAD:
		{
			Pgen g = Pgen(f);
			for (Plist gl=g->fct_list; gl; gl=gl->l) {
				Pname n = gl->f;
				Pfct f = Pfct(n->tp);

				if (f->body) {
					f->dcl(n);
					n->simpl();
				}
			}
		}
		}
	}

	byte_offset = byte_old;
	bit_offset = bit_old;
	max_align = max_old;

	cc->unstack();			// friends are not in class scope

					// fix arguments lists for friends defined inline 
	// set global context to match current behavior in dcl.c 
	//    for declaration of friends (needed for find_name())
	cc->stack();
	cc->cot = 0; cc->not = 0; cc->tot = 0; cc->c_this = 0;
	for (Plist fl=friend_list; fl; fl=fl->l) {
		Pname p = fl->f;
		Pfct f = Pfct(p->tp);

		switch (f->base) {
		case FCT:
			if (hito && f->argtype)
				fix_args(f,this);
			if (f->body && (f->defined&(DEFINED|SIMPLIFIED)) == 0) 
				p->n_sto = STATIC;
			else if (p->n_scope == STATIC)
				error(strict_opt?0:'w',"static%n declared friend toC%t",p,this);
			break;
		case OVERLOAD:
		{
			Pgen g = Pgen(f);
			for (Plist gl=g->fct_list; gl; gl=gl->l) {
				Pname n = gl->f;
				Pfct f = Pfct(n->tp);

				if (hito && f->argtype)
					fix_args(f,this);
				if (f->body && (f->defined&(DEFINED|SIMPLIFIED)) == 0) 
					n->n_sto = STATIC;
				else if (p->n_scope == STATIC)
					error(strict_opt?0:'w',"static%n declared friend toC%t",p,this);
			}
		}
		}
	}

	// define friends defined inline and modify return types if necessary
	simpl_friend=0;
	for (fl=friend_list; fl; fl=fl->l) {
		Pname p = fl->f;
		Pfct f = Pfct(p->tp);
		simpl_friend=1;

		switch (f->base) {
		case FCT:
			if (f->body && (f->defined&(DEFINED|SIMPLIFIED)) == 0) {
				f->dcl(p);
				p->simpl();
			}
			break;
		case OVERLOAD:
		{
			Pgen g = Pgen(f);
			for (Plist gl=g->fct_list; gl; gl=gl->l) {
				Pname n = gl->f;
				Pfct f = Pfct(n->tp);

				if (f->body && (f->defined&(DEFINED|SIMPLIFIED)) == 0) {
					f->dcl(n);
					n->simpl();
				}
			}
		}
		}
	}
	simpl_friend=0;
	cc->unstack(); // global context for friends

	if (tbl != gtbl)
		this->simpl();

	//SYM removed statStat stuff

// error('d',"classdef::dcl defined: %d",defined);
	// catch refs to this class in body of nested class function
	// (i.e., ref to member of this class...)
	if ( (defined&REF_SEEN) != 0 )
		dcl_print(0);

	if ( debug_opt ) {
           if (nested_sig) {
              prnt_all_in_scope(in_class);
           }
	   void dump_func(Pclass);
	   if (in_fct || !in_class)
	      dump_func(this);
	}

	void check_abst(Pclass);
	if (!in_class)
		check_abst(this);
}

void dump_func(Pclass th)
{
	int i;
	for (Pname p=th->memtbl->get_mem(i=1); p; NEXT_NAME(th->memtbl,p,i)) {
		if (p->base == TNAME || !p->tp) continue;
		Ptype t = p->tp->skiptypedefs();
		if (t->base == CLASS) {
			dump_func(Pclass(t));
			continue;
		}
		Pfct f = Pfct(t);
		if (f==0)
			continue;	// public declarations

		switch (f->base) {
			case FCT:
				if (f->body) {
					if ( th->c_body == 1 ) {
						if (th->class_base == INSTANTIATED)	
							current_instantiation = th;
						th->dcl_print(0);
						if (th->class_base == INSTANTIATED)	
							current_instantiation = 0;
					}
					p->dcl_print(0);
				}
				break;
			case OVERLOAD: 
			{	
				Pgen g = Pgen(f);
				for (Plist gl=g->fct_list; gl; gl=gl->l) {
					Pname n = gl->f;
					Pfct f = Pfct(n->tp);
					if (f->body) {
						if ( th->c_body == 1 ) {
							if (th->class_base == INSTANTIATED)	
								current_instantiation = th;
							th->dcl_print(0);
							if (th->class_base == INSTANTIATED)	
								current_instantiation = 0;
						}
						p->dcl_print(0);
					}
				}
			}
		}
	}

	for (Plist fl=th->friend_list; fl; fl=fl->l) {
		Pname p = fl->f;
		Pfct f = Pfct(p->tp);

		switch (f->base) {
			case FCT:
				if (f->body && (f->defined&(DEFINED|SIMPLIFIED)) == 0) 
					p->dcl_print(0);
				break;
			case OVERLOAD:
			{	
				Pgen g = Pgen(f);
				for (Plist gl=g->fct_list; gl; gl=gl->l) {
					Pname n = gl->f;
					Pfct f = Pfct(n->tp);

					if (f->body && (f->defined&(DEFINED|SIMPLIFIED)) == 0) 
						p->dcl_print(0);
				}
			}
		}
	}
}

void check_abst(Pclass th)
{
	int i;
	for (Pname p=th->memtbl->get_mem(i=1); p; NEXT_NAME(th->memtbl,p,i)) {
		if (p->base == TNAME || !p->tp) continue;
		Ptype t = p->tp->skiptypedefs();
		if (t->base == CLASS) {
			check_abst(Pclass(t));
			continue;
		}
		Pfct f = Pfct(t);
		void check_abst_func(Pname, Pfct);
		if (f == 0)
			continue;
		switch (f->base) {
			case FCT:
				check_abst_func(p, f);
				break;
			case OVERLOAD: {
				Pgen g = Pgen(f);
				for (Plist gl = g->fct_list; gl; gl = gl->l) {
					Pfct f = Pfct(gl->f->tp);
					check_abst_func(gl->f, f);
				}
				break;
			}
		}
	}

}

void check_abst_func(Pname p, Pfct f)
{
	if (f->returns->is_cl_obj()) {
		Pclass cl = f->returns->skiptypedefs()->classtype();
		if (cl->c_abstract) {
			error(&p->where, "abstractC%t cannot be used as aF returnT", cl);
			error('C', &p->where, "\t%a is a pure virtualF ofC%t\n", cl->c_abstract, cl);
		}
	}

	for (Pname a = f->argtype; a; a = a->n_list) {
		if (a->tp && a->tp->is_cl_obj()) {
			Pclass cl = a->tp->skiptypedefs()->classtype();
			if (cl->c_abstract) {
				error(&p->where, "abstractC%t cannot be used as anAT", cl);
				error('C', &p->where, "\t%a is a pure virtualF ofC%t\n", cl->c_abstract, cl);
			}
		}
	}
}

void enumdef::dcl(Pname n, Ptable tbl)
{
	Pname px;
	Pname p = mem;
	DB( if(Ddebug>=1) error('d',&n->where,"enumdef(%n,%d)",n,tbl); );
	Pbase b = new basetype(EOBJ,n);
	b->b_const = 1;

	if ( local_sig ) {
		in_fct = cc->nof;
	} else in_fct = 0;

#define FIRST_ENUM 0
	int enum_count = FIRST_ENUM;
	no_of_enumerators = mem->no_of_names();
	int largest = 0;

	if (p == 0)
		mem = new name(make_name('e'));

	for (; p; p=px) {
		px = p->n_list;
// error( 'd', "p %n", p );
		if (p->n_initializer) {
			Pexpr i = p->n_initializer->typ(tbl);
			Neval = 0;
			long ii = i->eval();
//			if (largest_int<ii)
//				error("long enumerator");
			if (i->tp) {
				bit u = i->tp->skiptypedefs()->is_unsigned();
				bit ok = 0;
				int smallest_int = -largest_int;
				switch (i->tp->skiptypedefs()->base) {
#define CHECKU(t) {ok = (unsigned t)ii <= largest_int;}
#define CHECKS(t) {ok = (t)ii >= smallest_int && (t)ii <= largest_int;}
					case CHAR:
						if (u)
							CHECKU(char)
						else
							CHECKS(char)
						break;
					case SHORT:
						if (u)
							CHECKU(short)
						else
							CHECKS(short)
						break;
					case ZTYPE:
					case INT:
					case ENUM:
					case EOBJ:
						if (u)
							CHECKU(int)
						else
							CHECKS(int)
						break;
					case LONG:
						if (u)
							CHECKU(long)
						else
							CHECKS(long)
						break;
					default:
						// for error checking
						// enum E {e = (void)0};
						ok = 1;
						break;
				}
				if (!ok)
					error("long enumerator");
			}
			enum_count = int(ii);
			if (Neval)
				error(&p->where,"%s",Neval);
			DEL(i);
			p->n_initializer = 0;
		}
		p->n_evaluated = 1;
		largest |= enum_count;
		if (enum_count == largest_int && px && !px->n_initializer)
			error("enumerator too large");
		p->n_val = enum_count++;
		p->tp = b;

		Pname nn;
		if ( tbl == gtbl || tbl->t_name )
			nn = tbl->look(p->string,0);
		else
			nn = curr_block->memtbl->look(p->string,0);
		if (
			nn
			&&
			( tbl==gtbl || tbl->t_name
			  ||
			   nn->n_table->real_block==curr_block->memtbl->real_block
			   && nn->lex_level == p->lex_level
			)
		) {
			if (nn->n_stclass == ENUM)
				error("enumerator%n declared twice",nn);
			else
				error("incompatibleDs of%n",nn);
		}
		else {
			nn = tbl->insert(p,0);
			nn->n_stclass = ENUM; // no store will be allocated
			if (Eppp == PROTECTED)
				nn->n_protect = PROTECTED;
			else if (Eppp == PUBLIC)
				nn->n_scope = PUBLIC;
		}
		p->string = nn->string;
	}

	e_type = int_type;

	defined |= DEFINED;

	if (pt_opt && !nested_sig && !local_sig && !is_probably_temp(string)) 
		fprintf(pt_file,"e %s %s\n",string,curr_filename());
}