block.h

我的编译原理课程设计。类PASCAL的语法

#include<string.h>
//#include"error.h"
int dx;   //data allocation index
//int tx0;  //initial table index
int cx0;  //initial table index
int lev0;
void enter(object k) //enter object into table
{
   memcpy(table[tx0].name,id,10);
   table[tx0].kind=k;
   switch(k)
   {
   case constant:if (num>amax)
				{
					error(30);
					num=0;
				}
	            table[tx0++].val=num;     break;
   case variable:table[tx0].level=lev0;
	             table[tx0++].adr=dx;
				 dx++;                  break;
   case procedure:table[tx0++].level=lev0;break;
   default:error(100);
   }
}
int position(char id1[10])
{
	int i;
	i=tx0;
	while(i>-1&&memicmp(table[i].name,id1,10))
		i--;
	return i;

}
void print(W_GCODE out)
{
	char ch1;
	int i=0;
	if((out.flag==3)&&(out.chr=='+'||out.chr=='/'||out.chr=='-'||out.chr=='*'||out.chr=='='||out.chr=='_'))
	{
		
		str.Format("%c ",out.chr);
		f_result.Write(str,str.GetLength());
	}else if(out.flag==1)
	{   i=0;
		do
		{
			ch1=out.c_code[i++];
			if(ch1!=' ')
			{
			str.Format("%c ",ch1);
		f_result.Write(str,str.GetLength());
			}
		}while(ch1!=' ');
	}else if(out.flag==2)
	{
		
		str.Format("%d ",out.c_num);
		f_result.Write(str,str.GetLength());
	}else if(out.flag==0)
	{
	
		str.Format("T%d ",out.T);
		f_result.Write(str,str.GetLength());
	}
}

W_GCODE gen(W_GCODE op,W_GCODE arg1,W_GCODE arg2)
{
	W_GCODE buffer1;

	str.Format("(%d) ",cx++);
		f_result.Write(str,str.GetLength());
	print(op);print(arg1);print(arg2);
	buffer1.flag=0;
	buffer1.T=TT++;
	print(buffer1);
	str.Format("%c%c",chr1,chr2);
		f_result.Write(str,str.GetLength());
	
	return buffer1;
}
bool constdeclaration()
{
	getsym();
	if(sym==ident)
	{  if(position(id)<0)
	   {
		getsym();
		if(sym==becomes)
		{
			
			getsym();
			if(sym==number)
			{
				
				enter(constant);
				return true;
			}else error(3);//there should be a number follow '='
		}
		else error(1);//there should be  a '=' follow ident
	}else 
	{
		error(4);//The ident already exists
		//next_line();
	}
		
	}else error(2);//there should be a ident follow const
   return false;
}
bool vardeclaration()
{
	getsym();
	if(sym==ident)
	{
		if(position(id)==-1)
		{
			enter(variable);
			return true;
		}
		else 
		{
			error(4);
			//next_line();
		}
	}else error(6);
	return false;
}
void boland(int f)
{
	getsym();
    char stack[20];
	int top=-1,flag=0;
	int g_num;
	W_GCODE stack1[20];
	int top1=-1;
	W_GCODE buffer;
	while(1)
	{
		if(sym==ident)
		{
			if(position(id)>-1)
			{
				gcode[g].flag=1;//char
				memcpy(gcode[g++].c_code,id,10);
			}else
			{
				error(10);
				return;
			}
		}else if(sym==number)
		{
			gcode[g].flag=2;
			gcode[g++].c_num=num;
		}else if(sym==plus||sym==minus)
		{
			while(top>-1)
			{
				if(stack[top]=='(')
					break;
				gcode[g].flag=3;
				gcode[g++].chr=stack[top--];
			}
			if(sym==plus)
				stack[++top]='+';
			else stack[++top]='-';
		}else if(sym==lparen)
		{
			stack[++top]='(';
			flag++;
		}else if(sym==times||sym==divsym)
		{
			while(stack[top]=='*'||stack[top]=='/')
			{
				gcode[g].flag=3;
				gcode[g++].chr=stack[top--];
				//if(stack[top]=='(')
					//break;
			}
			if(sym==times)
				stack[++top]='*';
			else stack[++top]='/';
		}else if(sym==rparen&&flag)
		{
				while(stack[top]!='(')
				{
					gcode[g].flag=3;flag--;
					gcode[g++].chr=stack[top--];
					/*if(top<0)
					{
						error(9);     //missing '('
						break;
					}*/
				}
				if(stack[top]='(')
					stack[top--]=' ';
		}else if(sym==rparen&&!flag&&f)
		{
			error(9);
			return ;
			break;
		}else if(sym==semicolon)
		{
			break;
		}
		else 
		{
			if(f)
			{
				error(10);//     expresion  error
				return ;
			}
			break;
		}
		getsym();
	}
	while (top>-1)
	{
		gcode[g].flag=3;
		gcode[g++].chr=stack[top--];
	}
	g_num=0;
	while(g>g_num)
	{
		if(gcode[g_num].flag<3)
			stack1[++top1]=gcode[g_num++];
		else if(gcode[g_num].flag==3)
		{
			if(top1>0&&stack1[top1-1].flag<3&&stack1[top1].flag<3)
			{
			buffer=gen(gcode[g_num++],stack1[top1-1],stack1[top1]);
			
			stack1[--top1]=buffer;
			}else
			{   if(f)
				error(11);
			    else error(19);
				return ;
			}
		}
	}
	if(top1>0)
	{
		if(f)
		error(11);
		else error(19);
		return ;
	}
}
symbol condition()
{
	W_GCODE ccode[2];
	getsym();
	symbol b_sym;
	int sym_TT;
	if(sym==lparen)
	{
		boland(0);
		if(TT>0)
		{
			ccode[0].flag=0;
			ccode[0].T=TT-1;
		}
		else 
		{
			ccode[0]=gcode[0];
		}
		g=0;sym_TT=TT;
		b_sym=sym;
		if(sym==lss||sym==eql||sym==neq||sym==leq||sym==gtr||sym==geq)
		{
			boland(0);
			if(TT>sym_TT)
			{
				ccode[1].flag=0;
			    ccode[1].T=TT;
			}
		    else 
			{
				ccode[1]=gcode[0];
			}
		    TT=0;g=0;
		}
		if(sym!=rparen)
			error(13);// missing ")" in condition
		gcode[0]=ccode[0];gcode[1]=ccode[1];
	}else error(12);   //missing '(' follow if
   return b_sym;
}
void statement()
{
	//getsym();
	symbol state[2];state[1]=endsym;state[0]=semicolon;
	int f_state=0,s_num,jmp_break;
	if(sym==beginsym)
	{
		f_state=1;depth++;
		getsym();
	}
    W_GCODE s_buffer;
	symbol b_sym;
	int jmp_if=0,jmp_while=0;     //record the beginning of the break which to jmp
	while(sym!=state[f_state]&&sym!=period)    //statement end with ';' or 'end'
	{
    if(sym==ident)
	{  
		if(position(id)!=-1&&table[position(id)].kind==variable)
		{		
			memcpy(s_buffer.c_code,id,10);
			getsym();
			if(sym==becomes)
			{
				boland(1);
				s_buffer.flag=1;
				str.Format("(%d) ",cx++);
		f_result.Write(str,str.GetLength());
				print(s_1);
				if(TT>0)
				{
					
					str.Format("T%d ",--TT);
		f_result.Write(str,str.GetLength());
				}
				else print(gcode[0]);
				print(blank);print(s_buffer);
				str.Format("%c%c",chr1,chr2);
		f_result.Write(str,str.GetLength());
				
				TT=0;g=0;
			}else error(7);   //赋值语句后应跟“＝”
		}else error(8); //the ident is unidentifered
		if(f_state==0)
			return;
		getsym();
	}else if(sym==ifsym)
	{   
		b_sym=condition();
		str.Format("(%d) ",cx++);
		f_result.Write(str,str.GetLength());
		if(b_sym==lss)
		{
			str.Format("j< ");
		f_result.Write(str,str.GetLength());
		}
		else if(b_sym==eql)
		{
			
			str.Format("j= ");
		f_result.Write(str,str.GetLength());
		}
		else if(b_sym==leq)
		{
			
			str.Format("j<= ");
		f_result.Write(str,str.GetLength());
		}
		else if(b_sym==neq)
		{
			str.Format("j<> ");
		f_result.Write(str,str.GetLength());
		}
		else if(b_sym==gtr)
		{
		
			str.Format("j> ");
		f_result.Write(str,str.GetLength());
		}
		else if(b_sym==geq)
		{
			
			str.Format("j>= ");
		f_result.Write(str,str.GetLength());
		}
        print(gcode[0]);print(gcode[1]);
		str.Format("(%d) %c%c",cx+1,chr1,chr2);
		f_result.Write(str,str.GetLength());
		//jmp_break=f_result.GetLength();jmp_if=cx;
		str.Format("(%d) j _ _       %c%c",cx++,chr1,chr2);
		f_result.Write(str,str.GetLength());
		jmp_break=f_result.GetLength();jmp_if=cx;
		getsym();
		if(sym==beginsym||sym==ident)
		{
			statement();getsym();
		}
		f_result.Seek(jmp_break-8,CFile::begin);
        str.Format("(%d)",cx);
		f_result.Write(str,str.GetLength());
		f_result.SeekToEnd();
	}else if(sym==readsym)
	{int flag=0;
		getsym();
		if(sym==lparen)
		{flag=1;
			do
			{
				getsym();
				if(sym==ident||position(id)>-1)
				{
					gcode[0].flag=1;memcpy(gcode[0].c_code,id,10);
					str.Format("(%d) r _ _",cx++);
		f_result.Write(str,str.GetLength());print(gcode[0]);
		            str.Format("%c%c",chr1,chr2);
					f_result.Write(str,str.GetLength());
					
				}else error(15);  //error in reading
				getsym();
			}while(sym==comma&&cc>1);
		}else error(12);   //there should be a char '(' following read
		if(sym!=rparen&&flag)
				error(13);  //missing ')' in reading statement
		getsym();
		if(sym==semicolon&&flag)
		{
			if(f_state==0)
			return;
			getsym();
		}
		else 
		{
			error(18);  //miissing ';' in the end of reading
		}
	}else if(sym==writesym)
	{int flag1=0;
		getsym();
		if(sym==lparen)
		{flag1=1;
			do
			{
				getsym();
				if(sym==ident||position(id)>-1)
				{
					gcode[0].flag=1;memcpy(gcode[0].c_code,id,10);
                    str.Format("(%d) w _ _",cx++);
					f_result.Write(str,str.GetLength());print(gcode[0]);
					str.Format("%c%c",chr1,chr2);
					f_result.Write(str,str.GetLength());
					
				}else error(15);  //error in writing
				getsym();
			}while(sym==comma&&cc>1);
		}else error(12);   //there should be a char '(' following read
		if(sym!=rparen&&flag1)
				error(13);  //missing ')' in condition statement
		getsym();
		if(sym==semicolon&&flag1)
		{if(f_state==0)
			return;
		getsym();
		}
		else 
		{
			error(18);  //miissing ';' in the end of reading
		}
	}else if(sym==whilesym)
	{
		b_sym=condition();
		str.Format("(%d) ",cx++);
		f_result.Write(str,str.GetLength());
		if(b_sym==lss)
		{
		str.Format("j< ");
	    f_result.Write(str,str.GetLength());
		}
		else if(b_sym==eql)
		{
			
			str.Format("j= ");
					f_result.Write(str,str.GetLength());
		}
		else if(b_sym==leq)
		{
			
			str.Format("j<= ");
					f_result.Write(str,str.GetLength());
		}
		else if(b_sym==neq)
		{
			
			str.Format("j<> ");
					f_result.Write(str,str.GetLength());
		}
		else if(b_sym==gtr)
		{
			
			str.Format("j> ");
					f_result.Write(str,str.GetLength());
		}
		else if(b_sym==geq)
		{
			
			str.Format("j>= ");
					f_result.Write(str,str.GetLength());
		}
        print(gcode[0]);print(gcode[1]);
		str.Format("(%d) %c%c",cx+1,chr1,chr2);
					f_result.Write(str,str.GetLength());
		jmp_while=cx;
		str.Format("(%d) j _ _       %c%c",cx++,chr1,chr2);
		f_result.Write(str,str.GetLength());jmp_break=f_result.GetLength();
					getsym();
		statement();
		f_result.Seek(jmp_break-8,CFile::begin);
        str.Format("(%d)",cx+1);
		f_result.Write(str,str.GetLength());
		f_result.SeekToEnd();
        str.Format("(%d) j _ _ (%d)%c%c",cx++,jmp_while-2,chr1,chr2);
		f_result.Write(str,str.GetLength());
		getsym();
	}else if(sym==forsym)
	{
		getsym();
		if(sym==lparen)
		{
			getsym();
			if(sym==ident&&position(id)>-1)
			{
				memcpy(s_buffer.c_code,id,10);
				getsym();
				if(sym==becomes)
				{
					boland(1);
					s_buffer.flag=1;
					str.Format("(%d) ",cx++);
					f_result.Write(str,str.GetLength());
					
					print(s_1);
					if(TT>0)
					{
						
						str.Format("T%d ",--TT);
					f_result.Write(str,str.GetLength());
					}
					else print(gcode[0]);
					print(blank);print(s_buffer);
					str.Format("%c%c",chr1,chr2);
					f_result.Write(str,str.GetLength());
					
					TT=0;g=0;
					if(f_state==0)
						return;
					getsym();
					if(sym==number)
					{
						s_num=num;
						getsym();
						if(sym!=rparen)
							error(17);//misssing ")"
						getsym();
						str.Format("(%d) j< ",cx++);
					   f_result.Write(str,str.GetLength());
					   for(int j=0;j<10;j++)
					   {   if(s_buffer.c_code[j]==' ')
					          break;
						   str.Format("%c",s_buffer.c_code[j]);
						   f_result.Write(str,str.GetLength());
					   }jmp_while=cx;
					   str.Format(" %d  (%d)%c%c(%d) j _ _        %c%c",s_num,cx+1,chr1,chr2,cx++,chr1,chr2);
					   f_result.Write(str,str.GetLength());
					   jmp_break=f_result.GetLength();
						statement();
						//
                        f_result.Seek(jmp_break-8,CFile::begin);
                        str.Format("(%d)",cx+3);
		                f_result.Write(str,str.GetLength());
	 	                f_result.SeekToEnd();
                        str.Format("(%d) + ",cx++);
		                f_result.Write(str,str.GetLength());
						for(int j1=0;j1<10;j1++)
					   {   if(s_buffer.c_code[j1]==' ')
					          break;
						   str.Format("%c",s_buffer.c_code[j1]);
						   f_result.Write(str,str.GetLength());
					   }
						str.Format(" 1 TO%c%c(%d) = TO _ ",chr1,chr2,cx++);
		                f_result.Write(str,str.GetLength());
                        for(int j2=0;j2<10;j2++)
					   {   if(s_buffer.c_code[j2]==' ')
					          break;
						   str.Format("%c",s_buffer.c_code[j2]);
						   f_result.Write(str,str.GetLength());
					   }
                        str.Format("%c%c(%d) j _ _ (%d)%c%c",chr1,chr2,cx++,jmp_while-1,chr1,chr2);
		                f_result.Write(str,str.GetLength());
						//
						getsym();
					}
				}else error(23);//there should be "=" in for sentence following ident;
			}else error(24); //there should be ident following "for"
		}else error(22);  //missing "("
	}
	}
	if(sym==endsym)
	{
		depth--;getsym();
		if(!(sym==semicolon||sym==period))
			error(15);    //missing ";" following end
	}else getsym();
}
void block(int lev,int tx)  //分程序，语法分析
{
	dx=3;tx0=tx;table[tx].adr=cx;
	if(lev>levmax)
		error(32);
	for(int i=0;i<15;i++)//while(sym!=period)
	{
		if(sym==constsym)
		{
			int flag=0;
			if(constdeclaration())
			{
			getsym();
			while(sym==comma)
			{
				
			    if(constdeclaration())
				{
			    getsym();
				if(sym==semicolon)
				{
					break;
				}
				}else 
				{
					flag=1;break;
				}
			}
			if(sym!=semicolon&&!flag)
			{
				error(5);  //lack of ';'
			}
			}
			if(!(sym!=semicolon&&!flag))
			getsym();
		}else if(sym==varsym)
		{int flag1=0;
			if(vardeclaration())
			{
			getsym();
			while(sym==comma)
			{
				if(vardeclaration())
				{
				getsym();
				if(sym==semicolon)
				{
					break;
				}
				}else 
				{
					flag1=1;break;
				}
			}
			if(sym!=semicolon&&!flag1)
			{
				error(5);    //lack of ';'
			}
			}
			if(!(sym!=semicolon&&!flag1))
			getsym();
		}else if(sym==beginsym)
		{
			depth=0;        //one begin in the begining
			statement();
		}else
		{   if(sym==period||feof(fp))
		    break;
			error(21);
			getsym();
		}

	}
}