print.c

c 语言编译器 源代码- c compiler

	case NEW:
		puttok(NEW);
		tp2->print();
		if (e1) {
			puttok(LP);
			e1->print();
			puttok(RP);
		}
		break;

	case DELETE:
		puttok(DELETE);
		e1->print();
		break;

	case CAST:
		puttok(LP);
		if (tp2->base != VOID) {
			puttok(LP);
			bit oc = Cast;
			Cast = 1;
			tp2->print();
			Cast = oc;
			puttok(RP);
		}
		puttok(LP);
		e1->print();
		puttok(RP);
		puttok(RP);
		break;

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

	case STRING:
		fprintf(out_file,"\"%s\"",string);
		break;

	case THIS:
	case ZERO:
		puttok(base);
		break;

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

	case TEXT:
		if (string2)
			fprintf(out_file, " %s_%s", string, string2);
		else
			fprintf(out_file, " %s", string);
		break;

	case DUMMY:
		break;

	case G_CALL:
	case CALL:
	{	Pname fn = fct_name;
		Pname at;
		if (fn && print_mode==SIMPL) {
			Pfct f = (Pfct)fn->tp;
//error('d',"call%n: %t",fn,f);
			if (f->base==OVERLOAD) { /* overloaded after call */
				Pgen g = (Pgen)f;
				fct_name = fn = g->fct_list->f;
				f = (Pfct)fn->tp;
			}
			fn->print();
			at = (f->f_this) ? f->f_this : f->argtype;
		}
		else {
//error('d',"e1%k e1->tp %d %d%t",e1->base,e1->tp,e1->tp->base,e1->tp);
			eprint(e1);
			if (e1->tp) {	/* pointer to fct */
				at = Pfct(e1->tp)->argtype;
			}
			else {		/* virtual: argtype encoded */
				at = (Pname)e1->e1->tp;
			}
		}
		puttok(LP);
		if (e2) {
			if (at && print_mode==SIMPL) {
				Pexpr e = e2;
				while (at) {
					Pexpr ex;
					Ptype t = at->tp;

					if (e == 0) error('i',"A missing for %s()",(fn)?fn->string:"??");
					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
					&& t->is_cl_obj()==0
					&& eobj==0) {
						puttok(LP);
						{	bit oc = Cast;
							Cast = 1;
							t->print();
							Cast = oc;
						}
						puttok(RP);
if (ex->base == DIV) { // defend against perverse SUN cc bug
	putst("(0+");
	eprint(ex);
	putst(")");
}
else
						eprint(ex);
					}
					else
						ex->print();
					at = at->n_list;
					if (at) puttok(CM);
				}
				if (e) {
					puttok(CM);
					e->print();
				}		 
			}
			else
				e2->print();
		}
		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 = n->n_val;
			Pin il;
			for (il=curr_icall; il; il=il->i_next)
				if (il->i_table == n->n_table) goto akk;
			goto bkk;
		akk:
			if (il->local[argno] == 0) {
				e2->print();
				break;
			}
		}
	case EQ:
	case NE:
	case GT:
	case GE:
	case LE:
	case LT:
	bkk:
		eprint(e1);
		puttok(base);
		if (e1->tp!=e2->tp && e2->base!=ZERO) {	/* cast, but beware of int!=long etc */
			Ptype t1 = e1->tp;
		cmp:
			switch (t1->base) {
			default:	break;
			case TYPE:	t1 = Pbase(t1)->b_name->tp; goto cmp;
			case PTR:
			case RPTR:
			case VEC:
				if (Pptr(t1)->typ != Pptr(e2->tp)->typ) {
					puttok(LP);
					bit oc = Cast;
					Cast = 1;
					e1->tp->print();
					Cast = oc;
					puttok(RP);
				}
			}
		}
		eprint(e2);
		break;

	case DEREF:
		if (e2) {
			eprint(e1);
			puttok(LB);
			e2->print();
			puttok(RB);
		}
		else {
			puttok(MUL);
			eprint(e1);
		}
		break;

	case ILIST:
		puttok(LC);
		if (e1) e1->print();
		puttok(RC);
		break;

	case ELIST:
	{	Pexpr e = this;
		forever {
			if (e->base == ELIST) {
				e->e1->print();
				if (e = e->e2)
					puttok(CM);
				else
					return;
			}
			else {
				e->print();
				return;
			}
		}
	}
	case QUEST:
		eprint(cond);
		puttok(QUEST);
		eprint(e1);
		puttok(COLON);
		eprint(e2);
		break;

	case CM:	/* do &(a,b) => (a,&b) for previously checked inlines */
		switch (e1->base) {
		case ZERO:
		case IVAL:
		case ICON:
		case NAME:
		case DOT:
		case REF:
		case FCON:
		case FVAL:
		case STRING:
			puttok(LP);
			goto le2;
		default:
			puttok(LP);
			{	int oo = addrof_cm;	// &(a,b) does not affect a
				addrof_cm = 0;
				eprint(e1);
				addrof_cm = oo;
			}
			puttok(CM);
		le2:
//error('d',"le2 %k(%k,%k) addrof_cm %d",base,e1->base,e2->base,addrof_cm);
			if (addrof_cm) {
				switch (e2->base) {
				case CAST:
					switch (e2->e2->base) {
					case CM:
					case ICALL:	goto ec;
					}
				case NAME:
				case DOT:
				case DEREF:
				case REF:
				case ANAME:
					puttok(ADDROF);
					addrof_cm--;
					eprint(e2);
					addrof_cm++;
					break;
				case ICALL:
				case 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 UMINUS:
	case NOT:
	case COMPL:
		puttok(base);
		eprint(e2);
		break;
	case ADDROF:
	case G_ADDROF:
//error('d',"&%k",e2->base);
		switch (e2->base) {
		case DEREF:
			if (e2->e2 == 0) {
				e2->e1->print();
				return;
			}
			break;
		case ICALL:
			addrof_cm++;	// assumes inline expanded into ,-expression
			eprint(e2);
			addrof_cm--;
			return;
		}

		// suppress cc warning on &fct
		if (e2->tp==0 || e2->tp->base!=FCT) puttok(ADDROF);

		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 ASPLUS:
	case ASMINUS:
	case ASMUL:
	case ASMOD:
	case ASDIV:
	case ASLS:
	case ASRS:
	case ASOR:
	case ASER:
	case ASAND:
	case DECR:
	case INCR:
		eprint(e1);
		puttok(base);
		eprint(e2);
		break;

	default:
		error('i',"%d->expr.print%k",this,base);
	}
}

Pexpr aval(Pname a)
{
	int argno = a->n_val;
	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->arg[argno];
/*error('d',"aval(%n) -> %k",a,aa->base);*/
ll:
	switch (aa->base) {
	case CAST:	aa = aa->e1; goto ll;
	case ANAME:	return aval(Pname(aa));
	default:	return aa;
	}
}

#define putcond()	puttok(LP); e->print(); puttok(RP)

void stmt.print()
{
	if (forced_sm) {
		forced_sm = 0;
		where.putline();
	}
/*error('d',&where,"stmt.print %d:%k s %d s_list %d",this,base,s,s_list);*/

	if (memtbl && base!=BLOCK) { /* also print declarations of temporaries */
		puttok(LC);
		Ptable tbl = memtbl;
		memtbl = 0;
		Pname n;
		int i;
		int bl = 1;
		for (n=tbl->get_mem(i=1); n; n=tbl->get_mem(++i)){
			/* avoid double declarartion of temporaries from inlines */
			char* s = n->string;
			if (s[0]!='_' || s[1]!='X') {
				n->dcl_print(0);
				bl = 0;
			}
			Pname cn;
			if (bl && (cn=n->tp->is_cl_obj()) && Pclass(cn->tp)->has_dtor()) bl = 0;
		}
/*error('d',"%d (tbl=%d) list %d",this,tbl,s_list);*/
		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',"stmt.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);
		puttok(COLON);
		s->print();
		break;
	case SM:
/*if (e->base==CALL || e->base==G_CALL) error('d',"%n",(Pname)e->e1);*/
		if (e) {
			e->print();
			if (e->base==ICALL && e->e2) break;	/* a block: no SM */
		}
		puttok(SM);
		break;
	case WHILE:
		puttok(WHILE);
		putcond();
		s->print();
		break;
	case DO:
		puttok(DO);
		s->print();
		puttok(WHILE);
		putcond();
		puttok(SM);
		break;
	case SWITCH:
		puttok(SWITCH);
		putcond();
		s->print();
		break;
	case RETURN:
		if (outlined) {	// FUDGE, handle return statement of outlined inline
				// it has been simplified as an inline, that is
				// ignoring _return;
			if (e && e!=dummy) {
//error('d',"outlined %t %t => %d",outlined,e->tp,outlined != e->tp);
				if (outlined != e->tp) {
					switch (outlined->base) {
					case RPTR:
					case PTR:
						if (Pptr(outlined)->typ == Pptr(e->tp)->typ) break;
					default:
						e = new texpr(CAST,outlined,e);
					}
				}
			}
		}
		puttok(RETURN);
		if (e) e->print();
		puttok(SM);
		while (s_list && s_list->base==SM) s_list = s_list->s_list; // FUDGE!!
		break;
	case CASE:
		puttok(CASE);
		eprint(e);
		puttok(COLON);
		s->print();
		break;
	case GOTO:
		puttok(GOTO);
		d->print();
		puttok(SM);
		break;
	case LABEL:
		d->print();
		puttok(COLON);
		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 = int(arg->e1)!=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();
			if (s->s_list) {
				puttok(LC);
				s->print();
				puttok(RC);
			}
			else
				s->print();
			if (else_stmt) {
				puttok(ELSE);
				if (else_stmt->s_list) {
					puttok(LC);
					else_stmt->print();
					puttok(RC);
				}
				else
					else_stmt->print();
			}
		}
		break;
	}
	case FOR:
	{	int fi = for_init && (for_init->base!=SM || for_init->memtbl || for_init->s_list);
//error('d',"fi %d for_init %d base %d tbl %d slist %d",fi,for_init,for_init->base,for_init->memtbl,for_init->s_list);
		if (fi) {
			puttok(LC);
			for_init->print();
		}
		puttok(FOR);
		puttok(LP);
		if (fi==0 && for_init) for_init->e->print();
		putch(';');	/* to avoid newline: not puttok(SM) */
		eprint(e);
		putch(';');
		eprint(e2);
		puttok(RP);
		s->print();
	/*	if (for_init) {
		*	if (s_list) s_list->print();
			puttok(RC);
			return;*
			puttok(RC);
		}*/
		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);
		where.putline();
		if (d) d->dcl_print(SM);
		if (memtbl && own_tbl) {
			Pname n;
			int i;
			for (n=memtbl->get_mem(i=1); n; n=memtbl->get_mem(++i)) {
				if (n->tp && n->n_union==0)
					switch (n->n_scope) {
					case ARGT:
					case ARG:
						break;
					default:
						n->dcl_print(0);
					}
			}
		}
		if (s) s->print();
		puttok(RC);
	}
	if (s_list) s_list->print();
}

void table.dcl_print(TOK s, TOK pub)
/*
	print the declarations of the entries in the order they were inserted
	ignore labels (tp==0)
*/
{
	register Pname* np;
	register int i;

	if (this == 0) return;

	np = entries;
	for (i=1; i<free_slot; i++) {
		register Pname n = np[i];
		switch (s) {
		case 0:
			n->dcl_print(0);
			break;
		case EQ:
			if (n->tp && n->n_scope == pub) n->dcl_print(0);
			break;
		case NE:
			if (n->tp && n->n_scope != pub) n->dcl_print(0);
			break;
		}
	}
}