pll.h

实现pl0编译 能够实现简单的编译 满足编译原理的要求

		{
			pa.i=2;
			do_genecode(opr,0,pa,integer);
			//生成加法指令.
			//下面将判断并生成减法;
		}
		else
		{
			pa.i=3;
			do_genecode(opr,0,pa,integer);
		}
	}
	//printf("have been to the deal of expession\n");
	return 0;
}
//项处理函数
int deal_term(bool *fsys,int *ptx,int lev)
{
	enum symbolset multibuffer;
	bool nextlev[keynum];
	memcpy(nextlev,fsys,sizeof(bool)*keynum);
	nextlev[multi]=true;
	nextlev[divid]=true;
	do_deal_factor(nextlev,ptx,lev);
	//处理因子
	while(sym==multi||sym==divid)
	{
		//运算式的处理
		multibuffer=sym;
		getsymdo;
		do_deal_factor(nextlev,ptx,lev);
		if(multibuffer==multi)
		{
			pa.i=4;
			//printf("/////生成乘法指令.\n");
			do_genecode(opr,0,pa,integer);
		}
		else
		{
			pa.i=5;
			do_genecode(opr,0,pa,integer);
		}
	}
	return 0;
}
int deal_factor(bool *fsys,int *ptx,int lev)
{
	int i;
	bool nextlev[keynum];
	//first集的检查
	bool factor_firstset[keynum];
	for(i=0;i<keynum;i++)
		factor_firstset[i]=false;
	factor_firstset[lparen]=true;
	factor_firstset[integersym]=true;
	factor_firstset[realsym]=true;
	factor_firstset[ident]=true;
	factor_firstset[charsym]=true;
	while(sym==ident||sym==integersym||sym==lparen||sym==charsym||sym==realsym)//sym检查是否为合法前集
	{
		if(sym==ident)///////////////////if it is the procedure should getout
		{
			i=position(id,*ptx);
			if(i==0)
			{
				printerr(30);
			}
			if(table[i].kind==procedure)
			{
				//printf("%在因子中出现了过程.\n");
			}
			else
			{
				switch(table[i].kind)
				{
				case constant:
					if(table[i].type=integer)
					{
						pa.i=table[i].val_int;
						do_genecode(lit,0,pa,integer);
						break;
					}
					else if(table[i].type=real)
					{
						pa.d=table[i].val_real;
						do_genecode(lit,0,pa,real);
						break;
					}
					else if(table[i].type=plchar)
					{
						pa.c=table[i].c;
						do_genecode(lit,0,pa,plchar);
						break;
					}
					//该处应商榷,如何在栈中存放各种类型.
					//可能要对生成代码的函数进行修改.
					else if(table[i].type=string)
					{
						strcpy(&(pa.s[0]),&(table[i].string[0]));
						do_genecode(lit,0,pa,string);//table[i].string);
						break;
					}
					/////////////////////??????????????
				case var:
						pa.i=table[i].adr;
						 do_genecode(lod,lev-table[i].level,pa,integer);
						 //get the address and lev,and put it to the stack
						 break;
				case parameter://将参数视作本层变量.同变量同样处理.
					pa.i=table[i].adr;
					do_genecode(lod,lev-table[i].level,pa,integer);
					break;
				case procedure:
					printerr(31);
					break;
				case function:
					//deal with 
					//push the parameter
					//pay attention to the parameters
					while(table[i].kind==parameter)
					{

					}
					pa.i=table[i].adr;
					do_genecode(cal,lev-table[i].level,pa,integer);//
					getsymdo;
					if(sym!=assign)
						printerr(46);
					getsymdo;
					do_deal_expression(fsys,ptx,lev);
					break;
				}
			}
			getsymdo;
		}
		else if(sym==integersym)
		{
			if(num>amax)
			{
				printerr(14);
				num=0;
				//make it to zero
			}
			pa.i=num;
			do_genecode(lit,0,pa,integer);
			//generate the lit code
			getsymdo;
		}
		else if(sym==charsym)
		{
			pa.c=char_buffer;
			do_genecode(lit,0,pa,plchar);
			getsymdo;
		}
		else if(sym==realsym)
		{
			pa.d=fnum;
			do_genecode(lit,0,pa,real);
			getsymdo;
		}
		else if(sym==lparen)
		{
			getsymdo;
			memcpy(nextlev,fsys,sizeof(bool)*keynum);
			nextlev[rparen]=true;
			//递归调用表达式处理子程序.
			deal_expression(fsys,ptx,lev);
			if(sym==rparen)
			{
				getsymdo;
			}
			else
			{
				printerr(31);/////////////???????????????????????
			}
		}
		//针对错误的跳跃处理.
		//test(fsys,factor_firstset,keynum);
	}
	return 0;
}
//对条件处理
int deal_condition(bool *fsys,int *ptx,int lev)
{
	enum symbolset relop;
	bool nextlev[keynum];
	memcpy(nextlev,fsys,sizeof(bool)*keynum);
	//fellow set 
	nextlev[eql]=true;
	//=
	nextlev[neql]=true;
	//<>
	nextlev[less]=true;
	//<
	nextlev[leql]=true;
	//<=
	nextlev[grt]=true;
	//>
	nextlev[geql]=true;
	//>=
	//调用表达处理子程序.
	do_deal_expression(nextlev,ptx,lev);
	//判断是否是关系运算符
	if(sym!=eql&&
		sym!=neql&&
		sym!=less&&
		sym!=leql&&
		sym!=grt&&
		sym!=geql)
	{
		printerr(32);
	}
	else
	{
		relop=sym;
		//buffer the sym;
		//prevent it from changing 
		getsymdo;
		deal_expression(nextlev,ptx,lev);
		switch(relop)
		{
			// =
		case eql:
			pa.i=8;
			do_genecode(opr,0,pa,integer);
			break;
			// <> !=
		case neql:
			pa.i=9;
			do_genecode(opr,0,pa,integer);
			break;
			// <
		case less:
			pa.i=10;
			do_genecode(opr,0,pa,integer);
			break;
			// <=
		case leql:
			pa.i=13;
			do_genecode(opr,0,pa,integer);
			break;
			// >=
		case geql:
			pa.i=11;
			do_genecode(opr,0,pa,integer);
			break;
			//>
		case grt:
			pa.i=12;
			do_genecode(opr,0,pa,integer);
			break;
		}
	}
	return 0;
}

///寻址程序
int base(int lev,struct stacktable *stack,int b)
{
	int b1;
	b1=b;
	while(lev>0)
	{
		b1=stack[b1].i;
		lev--;
	}
	return b1;
}

////////////////////


//解释程序
void interpret_exec()
{
	int p,b,t;
	struct instruction i;
	struct stacktable stack[512];
	//maxsum
	printf("Interpretor start execute...\n");
	t=0;
	b=0;
	p=0;
	//在下面的代码中将前三项赋为零,这与bx初值为3有关.

	stack[0].i=0;
	stack[1].i=0;
	stack[2].i=0;
	////////////////////////////////////////

	do
	{
		i=code[p];
		p++;
		//get the code;
		switch(i.vc)
		{
		case lit:
			switch(i.flag)
			{
				case 0:
					stack[t].i=i.a;
					break;
				case 1:
					stack[t].c=i.c;
					break;
				case 2:
					stack[t].d=i.d;
					break;
			}
			t++;
			break;
    	case opr:
			switch(i.a)
			{
			case 0:
				t=b;
				p=stack[t+2].i;
				b=stack[t+1].i;
				break;
			case 1:
				//minus
				if(i.flag==0)
				{
					stack[t-1].i=-stack[t-1].i;
				}
				if(i.flag==2)
				{
					//double or real 
					stack[t-1].d=-stack[t-1].d;
				}
				break;
			case 2://add
				t--;
				if(i.flag==0)
				{
					//int 
					stack[t-1].i=stack[t-1].i+stack[t].i;
				}
				if(i.flag==2)
				{
					//double or real;
					stack[t-1].d=stack[t-1].d+stack[t].d;//
				}
				break;
			case 3://minus
				t--;
				if(i.flag==0)
				{
					//int 
					stack[t-1].i=stack[t-1].i-stack[t].i;
				}
				if(i.flag==2)
				{
					//double or real
					stack[t-1].d=stack[t-1].d-stack[t].d;
				}
				break;
			case 4:
				t--;
				if(i.flag==0)
				{
					stack[t-1].i=stack[t-1].i*stack[t-1].i;
				}
				if(i.flag==2)
				{
					stack[t-1].d=stack[t-1].d*stack[t-1].d;
				}
				break;
			case 5:
				t--;
				if(i.flag==0)
				{
					stack[t-1].i=stack[t-1].i/stack[t].i;
				}
				if(i.flag==2)
				{
					stack[t-1].d=stack[t-1].d/stack[t].d;
				}
				break;
			case 6:
				//
				break;//not use the  !
			case 8:
				t--;
				//==
				//对于所有的逻辑运算,应将integer i 作为运算结果.
				if(i.flag==0)
					stack[t-1].i=(stack[t-1].i==stack[t].i);
				if(i.flag==2)
					stack[t-1].i=(stack[t-1].d==stack[t].d);
				if(i.flag==1)
					stack[t-1].i=(stack[t-1].c==stack[t].c);
				break;
			case 9:
				//<>
				t--;
				if(i.flag==0)
					stack[t-1].i=(stack[t-1].i!=stack[t].i);
				if(i.flag==1)
					stack[t-1].i=(stack[t-1].c!=stack[t].c);
				if(i.flag==2)
					stack[t-1].i=(stack[t-1].d!=stack[t].d);
				break;
			case 10:
				//<
				t--;
				if(i.flag==0)
					stack[t-1].i=(stack[t-1].i<stack[t].i);
				if(i.flag==1)
					stack[t-1].i=(stack[t-1].c<stack[t].c);
				if(i.flag==2)
					stack[t-1].i=(stack[t-1].d<stack[t].d);
				break;
			case 11:
				//>=
				t--;
				if(i.flag==0)
					stack[t-1].i=(stack[t-1].i>=stack[t].i);
				if(i.flag==1)
					stack[t-1].i=(stack[t-1].c>=stack[t].c);
				if(i.flag==2)
					stack[t-1].i=(stack[t-1].d>=stack[t].d);
				break;
			case 12:
				//>
				t--;
				if(i.flag==0)
					stack[t-1].i=(stack[t-1].i>stack[t].i);
				if(i.flag==1)
					stack[t-1].i=(stack[t-1].c>stack[t].c);
				if(i.flag==2)
					stack[t-1].i=(stack[t-1].d>stack[t].d);
				break;
			case 13:
				//<=
				t--;
				if(i.flag==0)
					stack[t-1].i=(stack[t-1].i<=stack[t].i);
				if(i.flag==1)
					stack[t-1].i=(stack[t-1].c<=stack[t].c);
				if(i.flag==2)
					stack[t-1].i=(stack[t-1].d<=stack[t].d);
				break;
			case 14:
				//print command
				//print to the file out
				if(i.flag==0)
				{
					printf("%d\n",stack[t-1].i);
					//fprintf(fout,"%d",stack[t-1].i);
				}
				if(i.flag==1)
				{
					printf("%c\n",stack[t-1].c);
					//fprintf(fout,"%c",stack[t-1].c);
				}
				if(i.flag==2)
				{
					printf("%f\n",stack[t-1].d);
					//fprintf(fout,"%f",stack[t-1].d);
				}
				t--;
				break;
			case 15:
				//print \n
				printf("\n");
				//fprintf(fout,"%c",'\n');
				break;
			case 16:
				printf(">");
				//fprintf(fout,"%c",'>');
				if(i.flag==0)
				{
					scanf("%d",&(stack[t].i));
					//fprintf(fout,"%d",stack[t].i);
					printf("%d\n",stack[t].i);
				}
				if(i.flag==1)
				{
					scanf("%c",&(stack[t].c));
					//fprintf(fout,"%c",stack[t].c);
					printf("%c\n",stack[t].c);
				}
				if(i.flag==2)
				{
					scanf("%f",&(stack[t].d));
					//fprintf(fout,"%f",stack[t].d);
					printf("%f\n",stack[t].d);
				}
				t++;//vip
				break;
			case 17:
				printf(">");
				//fprintf(fout,"%c",'>');
				if(i.flag==0)
				{
					scanf("%d",&(stack[t].i));
				//	fprintf(fout,"%d",stack[t].i);
					printf("%d\n",stack[t].i);
				}
				if(i.flag==1)
				{
					scanf("%c",&(stack[t].c));
					//fprintf(fout,"%c",stack[t].c);
					printf("%c\n",stack[t].c);
				}
				if(i.flag==2)
				{
					scanf("%f",&(stack[t].d));
					//fprintf(fout,"%f",stack[t].d);
					printf("%f\n",stack[t].d);
				}
				t++;//vip
				break;
			case 18:
				if(i.flag==0)
				{
					if(stack[t].i==stack[t-1].i)
						{
							//ok
							t--;
						}
					else
						{
							stack[t].i=0;
						}
				}
				else if(i.flag==1)
				{
					if(stack[t].c==stack[t-1].c)
						t--;
					else
						stack[t].c='\0';
				}
				else if(i.flag==2)
				{
					if(stack[t].d==stack[t-1].d)
						t--;
					else
						stack[t].d=0.;
				}
				break;
			case 19:
				break;
			default :
				break;
			}
			break;
			case lod:
				//base function 
				if(i.flag==0)
					stack[t].i=stack[base(i.l,stack,b)+i.a].i;//find and load the value in the mem
				if(i.flag==1)
					stack[t].c=stack[base(i.l,stack,b)+i.a].c;
				if(i.flag==2)
					stack[t].d=stack[base(i.l,stack,b)+i.a].c;
				t++;//top add
				break;
			case sto:
				//指针下移.
				t--;
				//将栈顶值上载到内存变量中.
				if(i.flag==0)
					//int
					stack[base(i.l,stack,b)+i.a].i=stack[t].i;
				if(i.flag==1)
					//int 
					stack[base(i.l,stack,b)+i.a].c=stack[t].c;
				if(i.flag==2)
					//int
					stack[base(i.l,stack,b)+i.a].d=stack[t].d;
				//base function
				break;
			case cal:
				stack[t].i=base(i.l,stack,b);
				stack[t+1].i=b;
				stack[t+2].i=p;
				b=t;
				p=i.a;
				break;
			case inte:
				//分配内存
				t+=i.a;
				break;
			case jmp:
				p=i.a;
				break;
			case jpc:
				t--;
				if(stack[t].i==0)
				{
					p=i.a;
				}
				break;
			}
		}while(p!=0);
}