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

print.c:

	print statements and expressions

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

#include "cfront.h"

static int addrof_cm ;
extern void puttok(TOK);

#define eprint(e) if (e) Eprint(e)

static long lab_cnt = 0;
static long curr_lab = 0;

void Eprint(Pexpr e)
{

	switch (e->base) {
	case DOT:
	case REF:
		if (
			Pref(e)->mem
			&&
			Pref(e)->mem->tp
			&&
			Pref(e)->mem->tp->base == FCT
		) {		// suppress ``this'' in ``this->f''
			Pref(e)->mem->print();
			break;
		}
	case NAME:
	case MDOT:
	case ID:
	case ZERO:
	case ICON:
	case CCON:
	case FCON:
	case STRING:
	case IVAL:
	case TEXT:
	case CM:
	case G_CM:
	case ELIST:
	case COLON:
	case ILIST:
	case THIS:
	case CALL:
	case G_CALL:
	case ICALL:
	case ANAME:
		e->print();
		break;
	case DTOR:  // dummy type destructor
		error('i',"T destructor in %cprint()",'E');
	case DUMMY: // null or error
		break;
	default:
		putch('(');
		e->print();
		putch(')');
	}
}

void expr::print()
{
	if (this == 0) error('i',"0->E::print()");
	if ((this==e1 || this==e2)&&base!=NAME) error('i',"(%p%k)->E::print(%p %p)",this,base,e1,e2);
// error('d',"(%d %k)->expr::print(%d %d)",this,base,e1,e2);

	switch (base) {
	case MDOT:
	{
// error('d',"mdot %s i1 %d %t",string2,i1,mem->tp);
		int not_allocated = 0;
		switch (i1) {
		case 0:
			putcat('O',string2);
			puttok(DOT);	// use sub-object directly
			mem->print();
			break;
		case 1:
			putcat('P',string2);
			puttok(REF);	// use through pointer
			mem->print();
			break;
		case 2:
			if (mem->tp->is_ptr_or_ref()==0) {
				mem->print();
				puttok(DOT);
				putcat('O',string2);
			}
			else {
				putch('(');	// REF turns pointer into object: add &
				putch('&');	// ``this'' is a pointer
				putch('(');
				eprint(mem);
				puttok(REF);	// call sub-object directly
				putcat('O',string2);
				putch(')');
				putch(')');
			}
			break;
		case 5:
			not_allocated = 1;
			// no break;	
		case 3:
			if (mem->tp->is_ptr_or_ref()==0) {
				putch('(');	// Px is a pointer (T*) turn it back to a T
				putch('*');	// *Px
				putch('(');
				eprint(mem);	// mem->print();
				puttok(DOT);	// call through pointer
				putcat('P',string2);
				putch(')');
				putch(')');
			}
			else {
				TOK m = mem->base;
				if (m == ADDROF || m == G_ADDROF) {
					if (mem->e2->base == DEREF && !mem->e2->e2)
						m = mem->e2->e1->base;
				}
				if (not_allocated) {
					putch('(');
					mem->print();
					if ( m == NAME || m == ANAME || m==REF ) 
						puttok(REF);
					else
						puttok(DOT);
					putcat('O',string4);
					putch(')');
				}
				else
					eprint(mem);
				if ((m == NAME || m == ANAME || m == REF) && not_allocated)
					puttok(DOT);
				else
					puttok(REF);	// call through pointer
				putcat('P',string2);
			}
			break;
		case 9:	// vtbl entry:	(p->_vtbl).f, (p->_vtbl).i, (p->_vtbl).d
			// or memptr: mp.f, mp.i, mp.d
			eprint(mem);
			putch('.');
			putstring(string2);
		} // end switch(i1)
		break;
	} // end MDOT

	case NAME:
	{	Pname n = Pname(this);
		if (n->n_evaluated && n->n_scope!=ARG) {
			Ptype t = tp->skiptypedefs();
			if (t->base == EOBJ)
				t = Penum(Pbase(t)->b_name->tp)->e_type;
			if (t->base!=INT || t->is_unsigned()) {
				putstring("((");
				bit oc = Cast;
				Cast = 1;
				t->print();
				Cast = oc;
				fprintf(out_file,")%d)",n->n_val);
			}
			else
				fprintf(out_file,"%d",n->n_val);
		}
		else
			n->print();
		break;
	}

	case ANAME:
		if (curr_icall) {	// in expansion: look it up
			Pname n = Pname(this);
			int argno =  n->argno;

			for (Pin il=curr_icall; il; il=il->i_next)
				if (n->n_table == il->i_table)
					goto aok;
			goto bok;
		aok:
			if (n = il->i_args[argno].local) {
				n->print();
			}
			else {
				Pexpr ee = il->i_args[argno].arg;
				Ptype t = il->i_args[argno].tp;
				if (ee==0 || ee==this)
					error('i',"%p->E::print(A %p)",this,ee);
				if (
					ee->tp==0
					||
					(
						t!=ee->tp
						&&
						t->check(ee->tp,0)
						&&
						t->is_cl_obj()==0
					)
				) {
					putstring("((");
					bit oc = Cast;
					Cast = 1;
					t->print();
					Cast = oc;
					putch(')');
					eprint(ee);
					putch(')');
				}
				else
					eprint(ee);
			}
		}
		else {
		bok:	/* in body: print it: */
			Pname(this)->print();
		}
		break;

	case ICALL:
	{
		if (il == 0)
			error('i',"E::print: iline missing");
		il->i_next = curr_icall;
		curr_icall = il;

//error('d',"icall %n",il->fct_name);
		eprint(e1);
		if (e2) {
			long save = curr_lab;
			curr_lab = ++lab_cnt;
			Pstmt(e2)->print();
			curr_lab = save;
		}
		curr_icall = il->i_next;
		break;
	}

	case REF:
	case DOT:
		eprint(e1);
		puttok(base);
		if (mem == 0) {
			fprintf(out_file,"MEM0");
			break;
		}
		if (mem->base == NAME)
			Pname(mem)->print();
		else
			mem->print();
		break;

	case MEMPTR:
		error("P toMF not called");
		break;

	case VALUE:
		tp2->print();
		puttok(LP);
		if (e1)
			e1->print();
		puttok(RP);
		break;

	case SIZEOF:
		puttok(SIZEOF);
		if (e1 && e1!=dummy && e1->base != ILIST && ((e1->base != CAST && e1->base != G_CAST) || e1->e1->base != ILIST)) {
			eprint(e1);
		}
		else if (tp2) {
			putch('(');
			if (tp2->base == CLASS) {
				Pclass cl = Pclass(tp2);
				putstring((cl->csu == UNION)?"union ":"struct ");
				char *str = 0;
				// nested local class does not encode name
				if ( cl->lex_level && cl->nested_sig == 0 ) 
					str = cl->local_sig;
		//		putstring(str?str:(cl->nested_sig?cl->nested_sig:cl->string));
				if (str)
					putstring(str);
				else if (cl->nested_sig)
					fprintf(out_file,"__%s",cl->nested_sig);
				else putstring(cl->string);
			}
			else
				tp2->print();
			putch(')');
		}
		else {
			error('i', "missingE for sizeof");
		}
		break;

	case CAST:
	case G_CAST:
		if (e1->base == ILIST) {
			eprint(e1);
			break;
		}
		putch('(');
//error('d',"print cast %t",tp2);
		if (tp2 != mptr_type && (tp2->base != VOID || ansi_opt) && tp2->memptr() == 0 ) {
			// when VOID is represented as CHAR not everything
			// can be cast to VOID
			putch('(');
			bit oc = Cast;
			Cast = 1;
			if (tp2->base==TYPE || tp2->base==VEC)
				TCast = 1;
			else TCast = 0;
			tp2->print();
			TCast=0;
			Cast = oc;
			putch(')');	
		}
		eprint(e1);
		putch(')');
		break;

	case ICON:
	case FCON:
	case CCON:
	case ID:
		if (string)
			putst(string);
		break;

	case STRING:
		// avoid printing very long lines
		ntok += 4;
		fprintf(out_file,"\"%s\"",string);
		break;

	case THIS:
	case ZERO:
		putstring("0 ");
		break;

	case IVAL:
		fprintf(out_file,"%d",i1);
		break;

	case TEXT:
	{
		int oo = vtbl_opt;	// make `simulated static' name
		vtbl_opt = -1;	
		char* s = vtbl_name(string,string2);
		vtbl_opt = oo;
		s[2] = 'p';	// pointer, not tbl itself
		char* t = ptbl_lookup(s);
		fprintf(out_file, " %s",t);
		delete t;

		char *str = 0;
		if ( string ) { 
			str = new char[ strlen(string) + strlen(string2) + 1 ];
			strcpy( str, string );
			strcat( str, string2 );
		}

		if (
			ptbl->look( str?str:string2, 0 ) == 0
			&&
			ptbl->look( str?str:string2, HIDDEN ) == 0
		) {
			Pname nn = ptbl->insert(new name(str?str:string2),0);
			nn->string2 = new char[strlen(s)+1];
			strcpy(nn->string2,s);
		}

		delete str;
		delete s;
	}
		break;

	case DTOR:  // dummy type destructor
		error('i',"T destructor in expr::print()");
	case DUMMY: // null or error
		break;

	case G_CALL:
	case CALL:
	{	Pname fn = fct_name;
		Pname at;
		int m_ptr = 0;
		int comflag = 0;

		if (fn) {
			Pfct f = Pfct(fn->tp);

			if (f->base==OVERLOAD) {	// overloaded after call
				fct_name = fn = Pgen(f)->fct_list->f;
				f = Pfct(fn->tp);
			}

			if (e1->base == CM || e1->base == G_CM) {
				comflag = 1;
				puttok(LP);
				e1->e1->print();
				puttok(CM);
			}
			fn->print();
			at = f->f_args;
		}
		else {
			Pfct f = Pfct(e1->tp);

			if (f) {	// pointer to fct
				Pexpr exex = e1;
				if ( exex->base == DEREF ) {
					exex = exex->e1;
					while ( exex->base == CAST ||
					    exex->base == G_CAST)
						exex = exex->e1;
					if ( exex->base == MDOT )
						m_ptr = 1;
				}

				if (f->base == OVERLOAD) {	// overloaded after call
					fct_name = fn = Pgen(f)->fct_list->f;
					f = Pfct(fn->tp);
				}

				f = Pfct(f->skiptypedefs());
				if (f->base == PTR) {
					putstring("(*(");
					e1->print();
					putstring("))");
					f = Pfct(Pptr(f)->typ->skiptypedefs());
				}
				else
					eprint(e1);

				at = f->f_args;
			}
			else {	// virtual: argtype encoded
				// f_this already linked to f_result and/or argtype
				at = (e1->base==QUEST) ? Pname(e1->e1->tp2) : Pname(e1->tp2);
				eprint(e1);
			}
		}

		puttok(LP);

		if (e2) {
			if (at) {
				Pexpr e = e2;
				while (at) {
					Pexpr ex;
					Ptype t = at->tp;

					if (t == 0)
						error('i',"T ofA missing for%n",fn);
					if (e == 0)
						error('i',"%tA missing for%n",t,fn);
					if (e->base == ELIST) {
						ex = e->e1;
						e = e->e2;
					}
					else
						ex = e;

					if (ex == 0)
						error('i',"A ofT%t missing",t);
					if (
						t!=ex->tp
						&&
						ex->tp
						&&
						t->check(ex->tp,0)
						&&
						t->is_cl_obj()==0
						&&
						eobj==0
						&&
						m_ptr == 0
						&&
						(
							t->is_ptr()==0 
							|| 
							Mptr==0
						)
					) {
						putch('(');
						bit oc = Cast;
						Cast = 1;
						t->print();
						Cast = oc;
						putch(')');
#ifdef sun
						if (ex->base == DIV) {	// defend against perverse SUN cc bug
							putstring("(0+");
							eprint(ex);
							putch(')');
						}
						else {
#endif
						if (ex->tp->is_cl_obj() && 
						   ((ex->base!=NAME && ex->base!=ANAME) || Pname(ex)->n_xref==0) &&	// beware of reference arguments
						   (t->is_ptr()||t->is_ref())) {
						   // trying to cast a class object to its pointer type
						   // add `&' to compensate from use of constructor call
						   // rewritten to use temporaty in ?: expression.
//error('d',"t %t ex->tp %t",t,ex->tp);
							ex = ex->address();
						    }
						eprint(ex);
#ifdef sun
						}
#endif
					}
					else
						ex->print();

					// if m_ptr is set, then don't advance at
					// at does not know about generated `this'
					if ( m_ptr ) {
						m_ptr = 0;
						if (at)
							puttok(CM);
						continue;
					}

					at = at->n_list;
					if (at)
						puttok(CM);
				}
				if (e) {
					puttok(CM);
					e->print();
				}		 
			}
			else
				e2->print();
		}
		puttok(RP);
		if (comflag)
			puttok(RP);
		break;
	}

	case ASSIGN:
		if (
			e1->base==ANAME
			&&
			Pname(e1)->n_assigned_to==FUDGE111
		) {				// suppress assignment to "this"
						// that has been optimized away
			Pname n = Pname(e1);
			int argno = int(n->n_val);
			for (Pin il=curr_icall; il; il=il->i_next)
				if (il->i_table == n->n_table)
					goto akk;
			goto bkk;
		akk:
			if (il->i_args[argno].local == 0) {
				e2->print();
				break;
			}
		}
		//no break
	case EQ:
	case NE:
	case GT:
	case GE:
	case LE:
	case LT:
	bkk:
	{

		eprint(e1);
		puttok(base);

		if (
			e1->tp
			&&
			e1->tp!=e2->tp
			&&
			e2->base!=ZERO
		) {				// cast, but beware of int!=long etc.
			Ptype t1 = e1->tp->skiptypedefs();
			switch (t1->base) {
			default:
				break;
			case PTR:
			case RPTR:
			case VEC:
			{
				Ptype t2 = e2->tp->skiptypedefs();

				if (
					e2->tp==0
					||
					( !ansi_opt 
					  && 
					  Pptr(t1)->typ
					  && 
					  Pptr(t1)->typ->skiptypedefs()->base==VEC
					  && 
					  e2->base != G_CAST 
					  && 
					  e2->base != CAST
					)
					||
					(
						Pptr(t1)->typ!=Pptr(t2)->typ
						&&
						t1->check(t2,0)
						&& (
						    t1->memptr() == 0
						    ||
						    t2->memptr() == 0
						    ||
						    t1->check(t2,COERCE)
						)
					)
				) {
					putch('(');
					bit oc = Cast;
					Cast = 1;
					e1->tp->print();
					Cast = oc;
					putch(')');	
				}
			}
			}
		}

		eprint(e2);
		break;
	}

	case DEREF:
		if (e2) {
			eprint(e1);
			putch('[');
			eprint(e2);
			putch(']');
		}
		else {
			putch('(');
			putch('*');
			eprint(e1);
			putch(')');
		}
		break;

	case ILIST: {
		static int level = 0;
		level++;
		bit flag = (level > 1 && tp && (tp == zero_type || tp->memptr()));
		if (!flag)
			puttok(LC);
		if (e1)
			e1->print();
		if (e2) {	// member pointer initiliazers
			puttok(CM);
			e2->print();
		}
		if (!flag)
			puttok(RC);
		level--;
		break;
	}

	case ELIST:
	{	Pexpr e = this;
		for(;;) {
			if (e->base == ELIST) {
				e->e1->print();
				if (e = e->e2) {
					puttok(CM);
				}
				else
					return;
			}
			else {
				e->print();
				return;
			}
		}
	}

	case QUEST:
	{	// look for (&a == 0) etc.
		Neval = 0;
		binary_val = 1;
		long i = cond->eval();
		binary_val = 0;
		if (Neval == 0)
			(i?e1:e2)->print();
		else {
			eprint(cond);
			putch('?');
			if (!ansi_opt) {
				if ((e1->base == CAST || e1->base == G_CAST) &&
				    e1->tp && !e1->tp->check(void_type, 0)) {
					e1 = new expr(G_CM, e1->e1, zero);
					e1->tp = zero_type;
				}
				if ((e2->base == CAST || e2->base == G_CAST) &&
				    e2->tp && !e2->tp->check(void_type, 0)) {
					e2 = new expr(G_CM, e2->e1, zero);
					e2->tp = zero_type;
				}
			}
			eprint(e1);
			putch(':');
			eprint(e2);
		}
		break;
	}

	case CM:	// do &(a,b) => (a,&b) for previously checked inlines
	case G_CM:
		puttok(LP);
		switch (e1->base) {
		case ZERO:
		case IVAL:
		case ICON:
		case NAME:
		case DUMMY:
		case MDOT:
		case DOT:
		case REF:
		case FCON:
		case STRING:
			goto le2;	// suppress constant a: &(a,b) => (&b)
		case DTOR:
			error('i',"T destructor in expr::print()");
		default:
		{
			int oo = addrof_cm;	// &(a,b) does not affect a
			addrof_cm = 0;
			eprint(e1);
			addrof_cm = oo;
		}
			puttok(CM);
		le2:
			if (addrof_cm) {
				switch (e2->base) {
				case CAST:
				case G_CAST:
					if (e2->e2)
						switch (e2->e2->base) {
						case CM:
						case G_CM:
						case ICALL:	goto ec;
						}
				case NAME:
				case MDOT:
				case DOT:
				case DEREF:
				case REF:
				case ANAME:
					if (e2->base != ADDROF &&
					    e2->base != G_ADDROF)
						puttok(ADDROF);
					addrof_cm--;
					eprint(e2);
					addrof_cm++;
					break;
				case ICALL:
				case CM:
				case G_CM:
				ec:
					eprint(e2);
					break;
				case G_CALL:
					/* & ( e, ctor() ) with temporary optimized away */
					if (e2->fct_name && e2->fct_name->n_oper==CTOR) {
						addrof_cm--;
						eprint(e2);
						addrof_cm++;
						break;
					}
				default:
					error('i',"& inlineF call (%k)",e2->base);
				}
			}
			else
				eprint(e2);
			puttok(RP);
		}
		break;

	case ADDROF:
	case G_ADDROF:
                {
		switch (e2->base) {	// & *e1 or &e1[e2]
		case DEREF:
			if (e2->e2 == 0) {	// &*e == e
				e2->e1->print();
				return;
			}
			break;
		case ICALL:
			addrof_cm++;	// assumes inline expanded into ,-expression
			eprint(e2);
			addrof_cm--;
			return;
		case ASSIGN:		// &(a=b)	??? works on many cc s
			eprint(e2);	// make sure it breaks!
			return;
                case ANAME:             
		case NAME: {
                        Pname n = Pname (e2);

			if(n->n_evaluated) {
				n->n_evaluated=0;
				if (e2->base != ADDROF &&
				    e2->base != G_ADDROF)
					puttok(ADDROF);
				eprint(e2);
				n->n_evaluated=1;
				return;
			}

			if ((e2->tp) && (e2->tp->is_cl_obj()) &&
				n->n_xref) {
				eprint (e2);
				return;
			}
			if (!ansi_opt && (e2->tp && 
				e2->tp->skiptypedefs()->base==VEC ) ) {
			  //no "ADDROF" ('&') if not ANSI C generation.
                          eprint(e2);  
  			  return;
                        }
			break;
			}
		}

		// suppress cc warning on &fct
		if ((e2->base != ADDROF && e2->base != G_ADDROF) && 
		    (e2->tp==0 || (e2->tp->base!=FCT && e2->tp->base!=OVERLOAD)))
			puttok(ADDROF);
		if (e2->tp && e2->tp->base==OVERLOAD)
			e2->tp = Pfct((Pgen(e2->tp)->fct_list->f)->tp);

		eprint(e2);
                }               
		break;

	case PLUS:
	case MINUS:
	case MUL:
	case DIV:
	case MOD:
	case LS:
	case RS:
	case AND:
	case OR:
	case ER:
	case ANDAND:
	case OROR:
	case DECR:
	case INCR:
	case ASOR:
	case ASER:
	case ASAND:
	case ASPLUS:
	case ASMINUS:
	case ASMUL:
	case ASMOD:
	case ASDIV:
	case ASLS:
	case ASRS:
		eprint(e1);
		// no break
	case UPLUS:			// only preserved for ansi_opt==1
	case UMINUS:
	case NOT:
	case COMPL:
		puttok(base);
		eprint(e2);
		break;

	default:
		error('i',"%p->E::print%k",this,base);
	}
}

Pexpr aval(Pname a)
{
	int argno = a->argno;
	Pin il;
	for (il=curr_icall; il; il=il->i_next)
		if (il->i_table == a->n_table)
			goto aok;
	return 0;
aok:
	Pexpr aa = il->i_args[argno].arg;
ll:
	switch (aa->base) {
	case G_CAST:
	case CAST:	aa = aa->e1; goto ll;
	case ANAME:	return aval(Pname(aa));
	default:	return aa;
	}
}

static void reprint(Plist ll)
/* prints a name list in reverse order */
{
	if (ll->l)
		reprint(ll->l);
	ll->f->dcl_print(0);
}

#define putcond(e)	putch('('); e->print(); putch(')')

static loc csloc = { 0, 0 };	// loc of last stmt with line!=0

void stmt::print()
{
//error('d',"S::print %d:%k s %d s_list %d",this,base,s,s_list);
	if (where.line == 0) {
		if (csloc.line)
			csloc.putline();
	}
	else {
		csloc = where;
		if (where.line!=last_line.line)
		if (last_ll = where.line)
			where.putline();
		else
			last_line.putline();
	}

	if (memtbl && base!=BLOCK) { /* also print declarations of temporaries */
		puttok(LC);
		Ptable tbl = memtbl;
		memtbl = 0;
		int i;
		int bl = 1;
		for (Pname n=tbl->get_mem(i=1); n; NEXT_NAME(tbl,n,i)) {
			if (n->tp == any_type)
				continue;
			/* avoid double declarartion of temporaries from inlines */
			char* s = n->string;
			if (
				s[0]!='_'
				||
				s[1]!='_'
				||
				s[2]!='X'
			) {
				n->dcl_print(0);
				bl = 0;
			}
			Pname cn;
			if (
				bl
				&&
				(cn=n->tp->is_cl_obj())
				&&
				Pclass(cn->tp)->has_dtor()
			)
				bl = 0;
		}
		if ( last_ll==0 && (last_ll = where.line) )
			where.putline();
		if (bl) {
			Pstmt sl = s_list;
			s_list = 0;
			print();
			memtbl = tbl;
			puttok(RC);
			if (sl) {
				s_list = sl;
				sl->print();
			}
		}
		else {
			print();
			memtbl = tbl;
			puttok(RC);
		}
		return;
	}

	switch (base) {
	default:
		error('i',"S::print(base=%k)",base);

	case ASM:
		fprintf(out_file,"asm(\"%s\");\n",(char*)e);
		break;

	case DCL:
		d->dcl_print(SM);
		break;

	case BREAK:
	case CONTINUE:
		puttok(base);
		puttok(SM);
		break;

	case DEFAULT:
		puttok(base);
		putch(':');
		s->print();
		break;

	case SM: {
		Pexpr ee = e;
		while (ee && (ee->base == CAST || ee->base == G_CAST))
			ee = ee->e1;
		if (ee && ee->base == ILIST) {
			puttok(SM);
			break;
		}
		if (e) {
DB(if(Pdebug>=4)display_expr(e,"SM_e"););
			e->print();
			if (e->base==ICALL && e->e2) break;	/* a block: no SM */
		}
		puttok(SM);
		break;
	}

	case WHILE:
		puttok(WHILE);
		putcond(e);
		if (s->s_list) {
			puttok(LC);
			s->print();
			puttok(RC);
		}
		else
			s->print();
		break;

	case DO:
		puttok(DO);
		s->print();
		puttok(WHILE);
		putcond(e);
		puttok(SM);
		break;

	case SWITCH:
		puttok(SWITCH);
		putcond(e);
		s->print();
		break;

	case RETURN:
		if (gt) {
			gt->print();
			break;
		}
		puttok(RETURN);
		if (e) {
//error('d',"print return rt %t etp %t",ret_tp,e->tp);
			if (ret_tp && ret_tp!=e->tp) {
				Ptype tt = ret_tp->skiptypedefs();
			
				switch (tt->base) {
				case COBJ:
					break;	// cannot cast to struct
				case RPTR:
				case PTR:
					if (Pptr(tt)->typ==Pptr(e->tp)->typ)
						break;
					if (Pptr(tt)->memof)
						break;
				default:
					if (e->tp==0 || ret_tp->check(e->tp,0)) {
						int oc = Cast;
						putch('(');
						Cast = 1;
						ret_tp->print();
						Cast = oc;
						putch(')');
					}
				}
			}
			eprint(e);
		}
		puttok(SM);
		while (s_list && s_list->base==SM)
			s_list = s_list->s_list;		// FUDGE!!
		break;

	case CASE:
		puttok(CASE);
		eprint(e);
		putch(':');
		s->print();
		break;

	case GOTO:
		puttok(GOTO);
		if (curr_lab)
			printf("_%ld__", curr_lab);
		d->print();
		puttok(SM);
		break;

	case LABEL:
		if (curr_lab)
			printf("_%ld__", curr_lab);
		d->print();
		putch(':');
		s->print();
		break;

	case IF:
	{	int val = QUEST;
		if (e->base == ANAME) {
			Pname a = Pname(e);
			Pexpr arg = aval(a);
//error('d',"arg %d%k %d (%d)",arg,arg?arg->base:0,arg?arg->base:0,arg?arg->e1:0);
			if (arg)
				switch (arg->base) {
				case ZERO:	val = 0; break;
				case ADDROF:
				case G_ADDROF:	val = 1; break;
				case IVAL:	val = arg->i1!=0;
				}
		}
//error('d',"val %d",val);
		switch (val) {
		case 1:
			s->print();
			break;
		case 0:
			if (else_stmt)
				else_stmt->print();
			else
				puttok(SM);	/* null statement */
			break;
		default:
			puttok(IF);
			putcond(e);
			if (s->s_list) {
				puttok(LC);
				s->print();
				puttok(RC);
			}
			else
				s->print();
			if (else_stmt) {
				puttok(ELSE);
				if (else_stmt->where.line == 0) {
					if (csloc.line)
						csloc.putline();
				}
				else {
					csloc = else_stmt->where;
					if (else_stmt->where.line!=last_line.line)
						if (last_ll = else_stmt->where.line)
							else_stmt->where.putline();
						else
							last_line.putline();
				}
				if (else_stmt->s_list) {
					puttok(LC);
					else_stmt->print();
					puttok(RC);
				}
				else
					else_stmt->print();
			}
		}
		break;
	}

	case FOR:
	{
		int fi = 0;			// is the initializer statement an expression?
		if (for_init) {
			fi = 1;
			if (for_init->memtbl==0 && for_init->s_list==0)
				if (for_init->base==SM)
					if (for_init->e->base!=ICALL || for_init->e->e1)
						fi = 0;
		}
//error('d',"for(; %d%k; %d%k)",e,e->base,e2,e2->base);
		if (fi) {
			puttok(LC);
			for_init->print();
		}
		putstring("for(");
		if (fi==0 && for_init)
			for_init->e->print();
		putch(';');			// to avoid newline: not puttok(SM)
		if (e)
			e->print();
		putch(';');
		if (e2)
			e2->print();
		puttok(RP);
		s->print();
		if (fi)
			puttok(RC);
		break;
	}

	case PAIR:
		if (s&&s2) {
			puttok(LC);
			s->print();
			s2->print();
			puttok(RC);
		}
		else {
			if (s)
				s->print();
			if (s2)
				s2->print();
		}
		break;

	case BLOCK:
		puttok(LC);
//error('d',"block %d d %d memtbl %d own_tbl %d",this,d,memtbl,own_tbl);
		if (d)
			d->dcl_print(SM);
		if (memtbl && own_tbl) {
			Pname n;
			int i;
			Plist aglist=0;
			for (n=memtbl->get_mem(i=1); n; NEXT_NAME(memtbl,n,i)) {
DB(if(Pdebug>=1)error('d',&n->where,"print local%n base%k tp%t scope%k",n,n->base,n->tp,n->n_scope));
				if (
					n->tp
					&&
					n->n_anon==0
					&&
					n->tp!=any_type
				)
					switch (n->n_scope) {
					case ARGT:
					case ARG:
						break;
					default:
// error('d', "n: %s %k n_key: %k", n->string, n->base, n->n_key);
						if ( n->base == TNAME
						&&   n->tpdef
						&&   n->tpdef->nested_sig
						)
							continue;	// printed from nested class
						if (ansi_opt==0 || !n->n_initializer)
							n->dcl_print(0);
						else
							aglist=new name_list(n,aglist);
					}
			}
			if (aglist)
				reprint(aglist);

			if (
				last_ll==0
				&&
				s
				&&
				(last_ll=s->where.line)
			)
				s->where.putline();
		}

		if (s)
			s->print();
		if (where2.line == 0) {
			if (csloc.line)
				csloc.putline();
		}
		else {
			csloc = where2;
			if (where2.line!=last_line.line)
				if (last_ll = where2.line)
					where2.putline();
				else
					last_line.putline();
		}
		putstring("}\n");
		if (last_ll && where.line)
			last_line.line++;
	}

	if (s_list)
		s_list->print();
}

struct ptbl_rec {
	char* pname;
	char* vname;
	ptbl_rec* next;
};

static char* ptbl_name;
static ptbl_rec* ptbl_rec_lookup_head = 0;
static ptbl_rec* ptbl_rec_pair_head = 0;

void ptbl_init(int flag)
{
	if (!flag) {
		char *p = st_name( "__ptbl_vec__" );	
		ptbl_name = new char[strlen(p)+1];
		strcpy(ptbl_name, p);
		delete p;
		Loc old = curloc;
		curloc.file = 0;
		curloc.line = 1;
		curloc.putline();
		curloc = old;
		fprintf(out_file, "extern struct __mptr* %s[];\n", ptbl_name);
		if (last_ll)
			last_line.line++;
	}
	else {
		ptbl_rec *r, *p = ptbl_rec_lookup_head;
		if ( p == 0 )
			return;		// don't generate an empty object
		fprintf(out_file, "struct __mptr* %s[] = {\n", ptbl_name);
		if (last_ll)
			last_line.line++;
		while (p != 0) {
			r = ptbl_rec_pair_head;
			while (r && strcmp(r->pname, p->pname))
				r = r->next;
			fprintf(out_file, "%s,\n", r->vname);
			if (last_ll)
				last_line.line++;
			p = p->next;
		}
		fprintf(out_file, "\n};\n");
		if (last_ll)
			last_line.line += 2;
	}
}

char* ptbl_lookup(char *name)
{
	ptbl_rec *r, *s, *p = ptbl_rec_lookup_head;
	int i = 0;

	while (p && strcmp(name, p->pname)) {
		r = p;
		p = p->next;
		i++;
	}

	if (p == 0) {
		s = new ptbl_rec;
		s->pname = new char[strlen(name) + 1];
		s->vname = 0;
		s->next = 0;
		strcpy(s->pname, name);
		if (ptbl_rec_lookup_head == 0) 
			ptbl_rec_lookup_head = s;
		else
			r->next = s;
	}

	char *pp = new char[ strlen(ptbl_name) + 10 ];
	sprintf(pp, "%s[%d]", ptbl_name, i);
	return(pp);
}

void ptbl_add_pair(char* ptbl, char* vtbl)
{
// error('d', "ptbl_add_pair: ptbl: %s, vtbl: %s", ptbl, vtbl );
	ptbl_rec *p = new ptbl_rec;

	p->pname = new char[strlen(ptbl) + 1];
	strcpy(p->pname, ptbl);
	p->vname = new char[strlen(vtbl) + 1];

	strcpy(p->vname, vtbl);
	p->next = ptbl_rec_pair_head;

	ptbl_rec_pair_head = p;
}