print.c

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

			while (*p++) ;
			*(p-1) = SDEL;
			break;
	case FIELD:
	default:
		error('i',"signature of %k",t->base);
	}

	*p = 0;
	return p;
}

void basetype.dcl_print()
{
	Pname nn;
	Pclass cl;

	if (print_mode != SIMPL) {
		if (b_virtual) puttok(VIRTUAL);
		if (b_inline) puttok(INLINE);
		if (b_const) puttok(CONST);
	}
	if (b_unsigned) puttok(UNSIGNED);

	switch (base) {
	case ANY:
		putst("any");
		break;

	case ZTYPE:
		putst("zero");
		break;

	case VOID:
		if (print_mode == SIMPL) {
			puttok(INT);
			break;
		}
	case CHAR:
	case SHORT:
	case INT:
	case LONG:
	case FLOAT:
	case DOUBLE:
		puttok(base);
		break;

	case EOBJ:
		nn = b_name;
	eob:
		if (print_mode == SIMPL)
			puttok(INT);
		else {
			puttok(ENUM);
			nn->print();
		}
		break;

	case COBJ:
		nn = b_name;
	cob:
		cl = (Pclass)nn->tp;
		switch (cl->csu) {
		case UNION:
		case ANON:	puttok(UNION); break;
		default:	puttok(STRUCT);
		}
		putst(cl->string);
		break;

	case TYPE:
		if (print_mode == SIMPL) {
			switch (b_name->tp->base) {
			case COBJ:
				nn = Pbase(b_name->tp)->b_name;
				goto cob;
			case EOBJ:
				nn = Pbase(b_name->tp)->b_name;
				goto eob;
			}
		}
		b_name->print();
		break;

	default:
		if (print_mode == ERROR) {
			if (0<base && base<MAXTOK && keys[base])
				fprintf(out_file," %s",keys[base]);
			else
				fprintf(out_file,"?");
		}
		else
			error('i',"%d->basetype.print(%d)",this,base);
	}
}

void type.dcl_print(Pname n)
/*
	"this" type is the type of "n". Print the declaration
*/
{
	Ptype t = this;
	Pfct f;
	Pvec v;
	Pptr p;
	TOK pre = 0;

	if (t == 0) error('i',"0->dcl_print()");
	if (n && n->tp!=t) error('i',"not %n'sT (%d)",n,t);

	if (base == OVERLOAD) {
		if (print_mode == ERROR) {
			puttok(OVERLOAD);
			return;
		}
		Pgen g = (Pgen) this;
		Plist gl;
		fprintf(out_file,"\t/* overload %s: */\n",g->string);
		for (gl=g->fct_list; gl; gl=gl->l) {
			Pname nn = gl->f;
			nn->tp->dcl_print(nn);
			if (gl->l) puttok(SM);
		}
		return;
	}

	tbuf = tbufvec[freetbuf];
	if (tbuf == 0) {
		if (freetbuf == NTBUF-1) error('i',"AT nesting overflow");
		tbufvec[freetbuf] = tbuf = new class dcl_buf;
	}
	freetbuf++;
	tbuf->init(n);

	while (t) {
		TOK k;

		switch (t->base) {
		case PTR:
			p = (Pptr)t;
			k = (p->rdo) ? CONST_PTR : PTR;
			goto ppp;
		case RPTR:
			p = (Pptr)t;
			k = (p->rdo) ? CONST_RPTR : RPTR;
		ppp:
			tbuf->front(k);
			pre = PTR;
			t = p->typ;
			break;
		case VEC:
			v = (Pvec)t;
			if (Cast) {
				tbuf->front(PTR);
				pre = PTR;
			}
			else {
				if (pre == PTR) tbuf->paran();
				tbuf->back(VEC,v);
				pre = VEC;
			}
			t = v->typ;
			break;
		case FCT:
			f = (Pfct)t;
			if (pre == PTR) tbuf->paran();
			tbuf->back(FCT,f);
			pre = FCT;
			t = (f->s_returns) ? f->s_returns : f->returns;
			break;
		case FIELD:
			tbuf->back(FIELD,t);
			tbuf->base( Pbase(Pbase(t)->b_fieldtype) );
			t = 0;
			break;
		case CLASS:
		case ENUM:
			error('i',"unX%k asBT",t->base);
		case 0:
			error('i',"noBT(B=0)%s",Cast?" in cast":"");
		case TYPE:
			if (Cast) { // unravel type in case it contains vectors
				t = Pbase(t)->b_name->tp;
				break;
			}
		default: // the base has been reached
			tbuf->base( Pbase(t) );
			t = 0;
			break;
		} // switch
	} // while

	tbuf->put();
	freetbuf--;
}

void fct.dcl_print()
{
	Pname nn;

	if (print_mode == ERROR) {
		puttok(LP);
		for (nn=argtype; nn;) {
			nn->tp->dcl_print(0);
			if (nn=nn->n_list) puttok(CM); else break;
		}
		switch (nargs_known) {
		case 0:		//	putst("?"); break;
		case ELLIPSIS:	puttok(ELLIPSIS); break;
		}
		puttok(RP);
		return;
	}

	Pname at = (f_this) ? f_this : argtype;
//fprintf(stderr,"f_this %d argtype %d body %d\n",f_this,argtype,body); fflush(stderr);
	puttok(LP);
	if (body && Cast==0) {

		for (nn=at; nn;) {
			nn->print();
			if (nn=nn->n_list) puttok(CM); else break;
		}
		puttok(RP);
	
		if (at) at->dcl_print(SM);

		if (b_init && print_mode!=SIMPL) {
			puttok(COLON);
			puttok(LP);
			b_init->print();
			puttok(RP);
		}

		if (MAIN) {
			putst("{ _main();");
			body->print();
			putst("}");
		}
		else
			body->print();
	}
	else
		puttok(RP);
}

void classdef.print_members()
{
	int i;
	Pname nn;

	if (clbase) {
		Pclass bcl = (Pclass)clbase->tp;
		bcl->print_members();
	}
	for (nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i)) {
//error('d',"mem %n: base(%d %d) union=%d tp=%d stc(%d %k)",nn,nn->base,nn->base,nn->n_union,nn->tp->base,nn->n_stclass,nn->n_stclass);
		if (nn->base==NAME
		&& nn->n_union==0
		&& nn->tp->base!=FCT
		&& nn->tp->base!=OVERLOAD
		&& nn->tp->base!=CLASS
		&& nn->tp->base!=ENUM
		&& nn->n_stclass != STATIC) {
			Pexpr i = nn->n_initializer;
			nn->n_initializer = 0;
			nn->dcl_print(0);
			nn->n_initializer = i;
		}
	}
}
	

void classdef.dcl_print(Pname)
{ 
	Plist l;
	TOK c = csu;
	if (c==CLASS && print_mode==SIMPL) c = STRUCT;

	if (print_mode == SIMPL) {	/* cope with nested classes */
		int i;
		Pname nn;

		for ( nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
/*fprintf(stderr, "mem %d %s %d union %d tp %d %d\n", nn, nn->string, nn->base, nn->n_union, nn->tp, nn->tp->base);*/
			if (nn->base==NAME && nn->n_union==0) {
				if (nn->tp->base == CLASS) Pclass(nn->tp)->dcl_print(nn);
			}
		}
	}

	puttok(c);
	putst(string);

	if (c_body == 0) return;
	c_body = 0;

	if (print_mode == SIMPL) {
		int i;
		int sm = 0;
		Pname nn;
		int sz = tsizeof();

		puttok(LC);
		fprintf(out_file,"/* sizeof = %d */\n",sz);
		if (real_size)
			print_members();
		else
			putst("char _dummy;");
		puttok(RC);
		puttok(SM);

	
		if (virt_count) {	/* print initialized jump-table */

			for (nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
				if (nn->base==NAME && nn->n_union==0) {	/* declare function names */
					Ptype t = nn->tp;
					switch (t->base) {
					case FCT:
					{	Pfct f =(Pfct) t;
//error('d',"%n i==%d v==%d returns (%d %d)%t",nn,f->f_inline,f->f_virtual,f->s_returns,f->returns,f->s_returns?f->s_returns:f->returns);
						if (f->f_virtual == 0) break;
						if (f->f_inline) puttok(STATIC);
						f->returns->print();
						nn->print();
						putst("()");
						puttok(SM);
						break;
					}
					case OVERLOAD:
					{	Pgen g = (Pgen)t;
						Plist gl;
						for (gl=g->fct_list; gl; gl=gl->l) {
							Pfct f = (Pfct) gl->f->tp;
							if (f->f_virtual == 0) break;
							if (f->f_inline) puttok(STATIC);
							f->returns->print();
							gl->f->print();
							putst("()");
							puttok(SM);
						}
					}
					}
				}
			}

			fprintf(out_file,"static int (*%s__vtbl[])() =",string);
			puttok(LC);
			for (i=0; i<virt_count; i++) {
				fprintf(out_file," (int(*)()) ");
				virt_init[i]->print();
				puttok(CM);
			}
			puttok(ZERO);
			puttok(RC);
			puttok(SM);
		}

		for (nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
			if (nn->base==NAME && nn->n_union==0) {
				Ptype t = nn->tp;
				switch (t->base) {
				case FCT:
				case OVERLOAD:
					break;
				default:
					if (nn->n_stclass == STATIC) {
					//	nn->n_sto = 0;
						nn->dcl_print(0);
					}
				}
			}
		}

		for (nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
			if (nn->base==NAME && nn->n_union==0) {
				Pfct f = (Pfct)nn->tp;
				switch (f->base) {
				case FCT:
					/* suppress duplicate or spurious declaration */
					if (debug==0 && f->f_virtual) break;
					if (debug==0 && f->f_inline) break;
					nn->dcl_print(0);
					break;
				case OVERLOAD:
					nn->dcl_print(0);
					break;
				}
			}
		}

		for (l=friend_list; l; l=l->l) {
			Pname nn = l->f;
//error('d',"friend%n %d%k",nn,nn->tp,nn->tp->base);
			switch (nn->tp->base) {
			case FCT:
				putst("/* friend */");
				Cast = 1;
				nn->dcl_print(0);
				Cast = 0;
				break;
			case OVERLOAD: /* first fct */
				l->f = nn = Pgen(nn->tp)->fct_list->f;
				putst("/* friend */");
				nn->dcl_print(0);
				break;
			}
		}
		return;
	}

	if (clbase) {
		puttok(COLON);
		if (pubbase) puttok(PUBLIC);
		clbase->print();
	}
	puttok(LC);

		for (l=friend_list; l; l=l->l) {
			Pname fr = l->f;
			puttok(FRIEND);
			switch (fr->tp->base) {
			case FCT:
			default:
				fr->print();
				puttok(SM);
			}
		}

	if (privmem) privmem->dcl_print(SM);
	if (memtbl) memtbl->dcl_print(NE,PUBLIC);
	puttok(PUBLIC);
	puttok(COLON);
	if (pubmem) pubmem->dcl_print(SM);
	if (memtbl) memtbl->dcl_print(EQ,PUBLIC);

	if (pubdef) {
		puttok(PUBLIC);
		puttok(COLON);
		pubdef->print();
		puttok(SM);
	}

	puttok(RC);
}

void enumdef.dcl_print(Pname n)
{
	if (print_mode == SIMPL) {
		if (mem) {
			fprintf(out_file,"/* enum %s */\n",n->string);
			mem->dcl_print(SM);
		}
	}
	else {
		puttok(ENUM);
		if (n) n->print();
		puttok(LC);
		if (mem) mem->dcl_print(SM);
		puttok(RC);
	}
}

int addrof_cm = 0;

void expr.print()
{
	if (this == 0) error('i',"0->expr.print()");
	if (this==e1 || this==e2) error('i',"(%d%k)->expr.print(%d %d)",this,base,e1,e2);
/*error('d',"expr %d%k e1=%d e2=%d tp2=%d",this,base,e1,e2,tp2);*/
	switch (base) {
	case NAME:
	{	Pname n = (Pname) this;
		if (n->n_evaluated && n->n_scope!=ARG) {
			if (n->tp->base != INT) {
				puttok(LP);
				puttok(LP);
				bit oc = Cast;
				Cast = 1;
				n->tp->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->n_val;
			Pin il;
			for (il=curr_icall; il; il=il->i_next)
				if (n->n_table == il->i_table) goto aok;
			goto bok;
		aok:
			if (n = il->local[argno]) {
//error('d',"n   %d %s",n,n->string);
				n->print();
			}
			else {
				Pexpr ee = il->arg[argno];
				Ptype t = il->tp[argno];
				if (ee==0 || ee==this) error('i',"%d->expr.print(A %d)",this,ee);
//error('d',"ee  %d %d",ee,ee->base);
				if (t!=ee->tp && t->is_cl_obj()==0 && eobj==0) {
					puttok(LP);
					puttok(LP);
					{	bit oc = Cast;
						Cast = 1;
						t->print();
						Cast = oc;
					}
					puttok(RP);
					eprint(ee);
					puttok(RP);
				}
				else
					eprint(ee);
			}
		}
		else {
		bok:	/* in body: print it: */
//error('d',"bok %d %d",this,base);
			Pname(this)->print();
		}
		break;

	case ICALL:
	{	il->i_next = curr_icall;
		curr_icall = il;
		if (il == 0) error('i',"expr.print: iline missing");
		Pexpr a0 = il->arg[0];
		int val = QUEST;
		if (il->fct_name->n_oper != CTOR) goto dumb;

		/*
			find the value of "this"
	   		if the argument is a "this" NOT assigned to
			by the programmer, it was initliazed
		*/

		switch (a0->base) {
		case ZERO:
			val = 0;
			break;
		case ADDROF:
		case G_ADDROF:
			val = 1;
			break;
		case CAST:
			if (a0->e1->base == ANAME) {
				Pname a = (Pname)a0->e1;
				if (a->n_assigned_to == FUDGE111) val = FUDGE111;
			}
		}
		if (val==QUEST) goto dumb;
//error('d',"%n's this == %d",il->fct_name,val);
		/*
			now find the test:  "(this==0) ? _new(sizeof(X)) : 0"

			e1 is a comma expression,
			the test is either the first sub-expression
				or the first sub-expression after the assignments
					initializing temporary variables
		 */

	{	Pexpr e = e1;
	lx:
		switch (e->base) {
		case CM:
		/*	if (val==1 && e->e1->base==ASSIGN) {
				Pexpr ass = e->e1;
				Pname a = e->e1->e1;
				if (a->base==ANAME && 1) {
				}
			}
		*/
			e = (e->e2->base==QUEST || e->e1->base==ASSIGN) ? e->e2 : e->e1;
			goto lx;

		case QUEST:
		{	Pexpr q = e->cond;
			if (q->base==EQ && q->e1->base==ANAME && q->e2==zero) {
				Pname a = (Pname)q->e1;
				Pexpr saved = new expr(0,0,0);
				*saved = *e;
				*e = (val==0) ? *e->e1 : *e->e2;
				eprint(e1);
				*e = *saved;
				delete saved;
				curr_icall = il->i_next;
				return;
			}
		}
		}
	}
	dumb:
//error('d',"dumb%n",il->fct_name);
		eprint(e1);
		if (e2) Pstmt(e2)->print();
		curr_icall = il->i_next;
//error('d',"end%n",il->fct_name);
		break;
	}
	case REF:
	case DOT:
		eprint(e1);
		puttok(base);
		mem->print();
		break;

	case VALUE:
		tp2->print();
		puttok(LP);
		if (e2) {
			putst("/* &");
			e2->print();
			putst(", */");
		}
		if (e1) e1->print();
		puttok(RP);
		break;

	case SIZEOF:
		puttok(SIZEOF);
		if (e1 && e1 != dummy) {
			eprint(e1);
		}
		else if (tp2) {
			puttok(LP);
			tp2->print();
			puttok(RP);
		}
		break;