pas.c

PASCAL语言子集编译器

		return 4;
	case op_and:
		return 5;
	case op_or:
		return 6;
	case jinghao:
		return 7;
	case tempsy:
		return 8;
	case EA:
		return 9;
	case EO:
		return 10;
	}
}
/********************赋值语句的分析******************************/

lrparse1(int num)
{
	lr1=action1[stack1[sp1]][change1(n1.sy1)];
	if(lr1==-1)
	{
		printf("\n算术表达式或赋值语句出错！\n");
		getch();
		exit(0);
	}
	if((lr1<10)&&(lr1>=0))
	{
		sp1++;
		stack1[sp1]=lr1;
		if(n1.sy1!=tempsy)
		{
			ssp++;
			num++;
			sstack[ssp].sy1=n1.sy1;
			sstack[ssp].pos=n1.pos;
		}
		n1.sy1=ibuf[num].sy1;
		n1.pos=ibuf[num].pos;
		lrparse1(num);
	}
	if((lr1>=100)&&(lr1<105))
	{
		switch(lr1)
		{
		case 100:
			break;
		case 101:
			E.pos=newtemp();
			gen("+",sstack[ssp-2],sstack[ssp],E.pos+100);
			ssp=ssp-2;
			sstack[ssp].sy1=tempsy;
			sstack[ssp].pos=E.pos;
			sp1=sp1-3;
			break;
			//E->E+E
		case 102:
			E.pos=newtemp();
			gen("*",sstack[ssp-2],sstack[ssp],E.pos+100);
			ssp=ssp-2;
			sstack[ssp].sy1=tempsy;
			sstack[ssp].pos=E.pos;
			sp1=sp1-3;
			break;
			//E->E*E
		case 103:
			E.pos=sstack[ssp-1].pos;
			ssp=ssp-2;
			sstack[ssp].sy1=tempsy;
			sstack[ssp].pos=E.pos;
			sp1=sp1-3;
			break;
			//E->(E)
		case 104:
			E.pos=sstack[ssp].pos;
			sp1--;
			break;
			//E->i
		}
		n1.sy1=tempsy;   //规约后为非终结符
		n1.pos=E.pos;
		lrparse1(num);
	}
	if((lr1==ACC)&&(stack1[sp1]==1))
	{
		//归约A->i:=E
		gen(":=",sstack[ssp],oth,ibuf[0].pos);
		ssp=ssp-3;
		sp1=sp1-3;
	}

}
/***************布尔表达式的分析*****************************/

lrparse2(int num)
{
	int templabel;
	lr1=action2[stack1[sp1]][change2(n1.sy1)];
	if(lr1==-1)
	{
		if(sign==2)printf("\nwhile语句出错！\n");
		if(sign==3)printf("\nif语句出错！\n");
		getch();
		exit(0);
	}
	if((lr1<16)&&(lr1>=0))
	{
		sp1++;
		stack1[sp1]=lr1;
		ssp++;
		sstack[ssp].sy1=n1.sy1;
		sstack[ssp].pos=n1.pos;
		if((n1.sy1!=tempsy)&&(n1.sy1!=EA)&&(n1.sy1!=EO))num++;
		n1.sy1=ibuf[num].sy1;
		n1.pos=ibuf[num].pos;
		lrparse2(num);
	}
	if((lr1>=100)&&(lr1<109))
	{
		switch(lr1)
		{
		case 100:
			break;
		case 101:
			ntab2[label].tc=nxq;
			ntab2[label].fc=nxq+1;
			gen("jnz",sstack[ssp],oth,0);
			gen("j",oth,oth,0);
			sp1--;
			ssp--;
			label++;
			n1.sy1=tempsy;
			break;
			//E->i
		case 102:
			ntab2[label].tc=nxq;
			ntab2[label].fc=nxq+1;
			switch(sstack[ssp-1].pos)
			{
			case 0:
				gen("j<=",sstack[ssp-2],sstack[ssp],0);
				break;
			case 1:
				gen("j<",sstack[ssp-2],sstack[ssp],0);
				break;
			case 2:
				gen("j>=",sstack[ssp-2],sstack[ssp],0);
				break;
			case 3:
				gen("j>",sstack[ssp-2],sstack[ssp],0);
				break;
			case 4:
				gen("j<>",sstack[ssp-2],sstack[ssp],0);
				break;
			case 5:
				gen("j=",sstack[ssp-2],sstack[ssp],0);
                break;
			}
		    gen("j",oth,oth,0);
		    ssp=ssp-3;
		    sp1=sp1-3;
		    label++;
		    n1.sy1=tempsy;
		    break;
		    //E->i rop i
		case 103:
			label=label-1;
			ssp=ssp-3;
			sp1=sp1-3;
			label++;
			n1.sy1=tempsy;
			break;
			//E->(E)
		case 104:
			label=label-1;
			templabel=ntab2[label].tc;
			ntab2[label].tc=ntab2[label].fc;
			ntab2[label].fc=templabel;
			ssp=ssp-2;
			sp1=sp1-2;
			label++;
			n1.sy1=tempsy;
			break;
			//E->not E
		case 105:
			backpatch(ntab2[label-1].tc,nxq);
			label=label-1;
			ssp=ssp-2;
			sp1=sp1-2;
			label++;
			n1.sy1=EA;
			break;
			//EA->E(1)and
		case 106:
			label=label-2;
			ntab2[label].tc=ntab2[label+1].tc;
			ntab2[label].fc=merg(ntab2[label].fc,ntab2[label+1].fc);
			ssp=ssp-2;
			sp1=sp1-2;
			label++;
			n1.sy1=tempsy;
			break;
			//E->EA E(2)
		case 107:
			backpatch(ntab2[label-1].fc,nxq);
			label=label-1;
			ssp=ssp-2;
			sp1=sp1-2;
			label++;
			n1.sy1=EO;
			break;
		case 108:
			label=label-2;
			ntab2[label].fc=ntab2[label+1].fc;
			ntab2[label].tc=merg(ntab2[label].tc,ntab2[label+1].tc);
			ssp=ssp-2;
			sp1=sp1-2;
			label++;
			n1.sy1=tempsy;
			break;
		}
		lrparse2(num);
	}
	if(lr1==ACC) return 1;
}
/**********************测试字符是否为表达式中的值（不包括“;”)*************/

test(int value)
{
	switch(value)
	{
	case intconst:
	case ident:
	case plus:
	case times:
	case becomes:
	case lparent:
	case rparent:
	case rop:
	case op_and:
	case op_or:
	case op_not:
		return 1;
	default:
		return 0;
	}
}
/***************************************************************/

lrparse()
{
	int i1=0;
	int num=0;
	//指向表达式缓冲区
	if(test(n.sy1))
	{
		if(stack[sp].sy1==sy_while) sign=2;
		else
		{
			if(stack[sp].sy1==sy_while) sign=3;
			else sign=1;
		}
		do
		{
			ibuf[i1].sy1=n.sy1;
			ibuf[i1].pos=n.pos;
			readnu();
			i1++;
		}
		while(test(n.sy1));
		//把表达式放入缓冲区
		ibuf[i1].sy1=jinghao;
		pbuf--;
		//指针后退1，需要吗？
		sstack[0].sy1=jinghao;
		ssp=0;
		//符号栈底的初始化
		if(sign==1)
		{
			sp1=0;
			stack1[sp1]=0;
			//状态栈1的栈底初始化
			num=2;
			//指向:=
			n1.sy1=ibuf[num].sy1;
			n1.pos=ibuf[num].pos;
			lrparse1(num);
			//处理赋值语句
			n.sy1=a;
			//当前文法符号置为a(赋值语句)
		}
		if((sign==2)||(sign==3))
		{
			pointmark++;
			labelmark[pointmark].nxq1=nxq;
			sp1=0;
			stack1[sp1]=0;
			num=0;
			n1.sy1=ibuf[num].sy1;
			n1.pos=ibuf[num].pos;
			lrparse2(num);
			labelmark[pointmark].tc1=ntab2[label-1].tc;
			labelmark[pointmark].fc1=ntab2[label-1].fc;
			//处理布尔语句
			//在处理完E,要回填真值链
			backpatch(labelmark[pointmark].tc1,nxq);
			n.sy1=e;
			//当前文法符号置为e(赋值语句)
		}
	}
	lr=action[stack[sp].pos][n.sy1];
	printf("stack[%d]=%d\t\tn=%d\t\tlr=%d\n",sp,stack[sp].pos,n.sy1,lr);
	if((lr<19)&&(lr>=0))
	{
		sp++;
		stack[sp].pos=lr;
		stack[sp].sy1=n.sy1;
		readnu();
		lrparse();
	}
	if((lr<=106)&&(lr>=100))
	{
		switch(lr)
		{
		case 100:
			break;
			//S'->S*
		case 101:
			printf("S->if e then S then S else S 归约\n");
			sp=sp-6;
			n.sy1=S;
			//归约完if后，填then后面的无条件转移语句
			fexp[labeltemp[pointtemp]].result=nxq;
			pointtemp--;
			if(stack[sp].sy1==sy_then)
			{
				gen("j",oth,oth,0);
				backpatch(labelmark[pointmark].fc1,nxq);
				pointtemp++;
				labeltemp[pointtemp]=nxq-1;
			}
			pointmark--;
			if(stack[sp].sy1==sy_do)
			{
				gen("j",oth,oth,labelmark[pointmark].nxq1);
				backpatch(labelmark[pointmark].fc1,nxq);
			}
			break;
			//S->if e then S then S else S
		case 102:
			printf("S->while e do S 归约\n");
			sp=sp-4;
			n.sy1=S;
			pointmark--;
			if(stack[sp].sy1==sy_do)
			{
				gen("j",oth,oth,labelmark[pointmark].nxq1);
				backpatch(labelmark[pointmark].fc1,nxq);
			}

			if(stack[sp].sy1==sy_then)
			{
				gen("j",oth,oth,0);
				fexp[labelmark[pointmark].fc1].result=nxq;
				pointtemp++;
				labeltemp[pointtemp]=nxq-1;
			}
			break;
			//S->while e do S
		case 103:
			printf("S->begin L end 归约\n");
			sp=sp-3;
			n.sy1=S;
			if(stack[sp].sy1==sy_then)
			{
				gen("j",oth,oth,0);
				backpatch(labelmark[pointmark].fc1,nxq);
				pointtemp++;
				labeltemp[pointtemp]=nxq-1;
			}
			if(stack[sp].sy1==sy_do)
			{
				gen("j",oth,oth,labelmark[pointmark].nxq1);
				backpatch(labelmark[pointmark].fc1,nxq);
			}
			getch();
			break;
			//S->begin L end
		case 104:
			printf("S->a归约\n");
			sp=sp-1;
			n.sy1=S;
			if(stack[sp].sy1==sy_then)
			{
				gen("j",oth,oth,0);
				backpatch(labelmark[pointmark].fc1,nxq);
				pointtemp++;
				labeltemp[pointtemp]=nxq-1;
			}
			if(stack[sp].sy1==sy_do)
			{
				gen("j",oth,oth,labelmark[pointmark].nxq1);
				backpatch(labelmark[pointmark].fc1,nxq);
			}
			break;
			//S->a
		case 105:
			printf("归约\n");
			sp=sp-1;
			n.sy1=L;
			break;
			//L->S
		case 106:
			printf("L->S;L 归约\n");
			sp=sp-3;
			n.sy1=L;
			break;
			//L->S;L
		}
		getch();
		pbuf--;
		lrparse();
	}
	if(lr==ACC)return ACC;
}
/*****************************disp1************************/

disp1()
{
	int temp1=0;
	printf("\n********************词法分析结果*******************\n");
	for(temp1=0;temp1<count;temp1++)
	{
		printf("%d\t%d\n",buf[temp1].sy1,buf[temp1].pos);
		if(temp1==20)
		{
			printf("Press any key to continue……\n");
			getch();
		}
	}
	getch();
}
/***************************************************************/

disp2()
{
	int temp1=100;
	printf("\n******************四元式分析结果*********************\n");
	for(temp1=100;temp1<nxq;temp1++)
	{
		if(temp1>100)
			fprintf(mfile,"\n");
		fprintf(mfile,"%d\t",temp1);
		fprintf(mfile,"%s\t,",fexp[temp1].op);
		if(fexp[temp1].arg1.sy1==ident)
			fprintf(mfile,"%s\t,",ntab1[fexp[temp1].arg1.pos]);
		else
		{
			if(fexp[temp1].arg1.sy1==tempsy)
				fprintf(mfile,"T%d\t,",fexp[temp1].arg1.pos);
			else
			{
				if(fexp[temp1].arg1.sy1==intconst)
					fprintf(mfile,"%d\t,",fexp[temp1].arg1.pos);
				else fprintf(mfile,"\t,");
			}
		}
		if(fexp[temp1].arg2.sy1==ident)
			fprintf(mfile,"%s\t,",ntab1[fexp[temp1].arg2.pos]);
		else
		{
			if(fexp[temp1].arg2.sy1==tempsy)
				fprintf(mfile,"T%d\t,",fexp[temp1].arg2.pos);
			else
			{
				if(fexp[temp1].arg2.sy1==intconst)
					fprintf(mfile,"%d\t,",fexp[temp1].arg2.pos);
				else fprintf(mfile,"\t,");
			}
		}
		if(fexp[temp1].op[0]!='j')
		{
			if(fexp[temp1].result>=100)
				fprintf(mfile,"T%d\t)",fexp[temp1].result-100);
			else
				fprintf(mfile,"%s\t)",ntab1[fexp[temp1].result]);
		}
		else 
			fprintf(mfile,"%d\t)",fexp[temp1].result);
		if(temp1==20)
		{
			printf("\nPress any key to continue……\n");
			getch();
		}
	}
	getch();
}
/********************************************************************/

disp3()
{
	int tttt;
	printf("\n\n程序总共%d行，产生了%d个二元式！\n",lnum,count);