li.cpp

设计SAMPLE语言的词法分析器 检查要求： a] 启动程序后

/*  
Windows 下c语言PL/0编译程序 
在Visual C++ 6.0和Visual C.NET上运行通过 
使用方法： 
运行后输入PL/0源程序文件名 
回答是否输出虚拟机代码 
回答是否输出名字表 
fa.tmp输出虚拟机代码 
fa1.tmp输出源文件及其各行对应的首地址 
fa2.tmp输出结果 
fas.tmp输出名字表 
*/ 
#include   <stdlib.h>  
#include <stdio.h> 
#include<iostream.h>
#include "lin.h" 
#include "string.h" 
#include<string>
/* 解释执行时使用的栈 */ 
#define stacksize 500  






int main() 
{ 

bool nxtlev[symnum]; 
init(); /* 初始化 */ 
//fas=fopen("fas.tmp","w"); 
fa1=fopen("fa1.tmp","w"); 
printf("Input file?   "); 
fprintf(fa1,"Input file?   "); 
scanf("%s",fname); /* 输入文件名 */ 
fin=fopen(fname,"r"); 
if(fin) 
{ 

err=0; 
cc=cx=ll=0; 
ch=' '; 
kk=al-1; 

if(-1!=getsym()) 
{ 


block(0,0,nxtlev);
 for(int i=0;i<dx;i++)
cout<<"("<<i<<") ("<<cd[i].w<<","<<cd[i].x<<","<<cd[i].y<<","<<cd[i].z<<")"<<endl; 

if(-1==block(0,0,nxtlev)) /* 调用编译程序 */ 
{ 


fclose(fin); 
 
return 0; 
} 
 



} 
fclose(fin); 
} 
else 
{ 
printf("Can't open file!\n"); 
fprintf(fa1,"Can't open file!\n"); 

} 


return 0; 


}



/*
for(int i=0;i<10;i++)
cout<<"("<<i<<") ("<<cd[i].a<<","<<cd[i].b<<","<<cd[i].c<<","<<cd[i].d<<")"<<endl; 

*/





/* 在适当的位置显示错误 */ 
void error(int n) 
{ 
char space[81]; 
memset(space,32,81); 
space[cc-1]=0; /* 出错时当前符号已经读完，所以cc-1 */  
//printf("****%s!%d\n",space,n); 
fprintf(fa1,"****%s!%d\n",space,n); 
err++; 

} 

/* 词法分析，获取一个符号 */ 
int getsym() 
{ 
int i,j,k; 
while(ch==' '||ch==10||ch==9) /* 忽略空格、换行和TAB */ 
{ 
getchdo; 
} 
if(ch>='a'&&ch<='z'||ch>='A'&&ch<='Z') 
{ /* 名字或保留字以a..z开头 */ 
k=0; 
do 
{ 
if(k<al) 
{ 
a[k]=ch; 
k++; 
} 
getchdo; 
} 
while(ch>='a'&&ch<='z'||ch>='0'&&ch<='9'||ch>='A'&&ch<='Z'); 
a[k]=0; 
strcpy(id,a); 
i=0; 
j=norw-1; 
do /* 搜索当前符号是否为保留字 */ 
{ 
k=(i+j)/2; 
 if(strcmp(id,word[k])<=0)j=k-1; 
if(strcmp(id,word[k])>=0)i=k+1; 
} 
while(i<=j); 
if(i-1>j){sym=wsym[k]; }else {sym=ident; 
strcpy(b,a);}
/* 搜索失败则，是名字或数字 */ 
} 
else 
{ 
if(ch>='0'&&ch<='9') 
{ /* 检测是否为数字：以0..9开头 */ 
k=0; 
num=0; 
sym=number; 
do 
{ 
num=10*num+ch-'0'; 
k++; 
getchdo; 
} 
while(ch>='0'&&ch<='9'); /* 获取数字的值 */ 
k--; 
if(k>nmax)error(30); 
} 
else 
{ 
if(ch==':') /* 检测赋值符号 */ 
{ 
getchdo; 
if(ch=='=') 
{ 
sym=becomes; 
getchdo; 
} 
else 
{ 
sym=colon; /* 不能识别的符号 */ 
} 
} 
else  
{ 
if(ch=='<') /* 检测小于或小于等于符号 */ 
{ 
getchdo; 
if(ch=='=') 
{ 
sym=leq; 
getchdo; 
} 
else 
{ 
sym=lss; 
} 
} 
else
{ 
if(ch=='>') /* 检测大于或大于等于符号 */ 
{ 
getchdo; 
if(ch=='=') 
{ 
sym=geq; 
getchdo; 
} 
else 
{ 
sym=gtr; 
} 
} 
else 
{ 
sym=ssym[ch]; /* 当符号不满足上述条件时，全部按照单字符符号处理 */ 
getchdo; 
} 
} 
} 
} 
} 

return 0; 
} 




/* 编译程序主体 */ 
int block(int lev,  /* 当前分程序所在层 */ 
  int tx, /* 名字表当前尾指针 */ 
  bool* fsys /* 当前模块后跟符号集合 */ 
  ) 
{ 
bool nxtlev[symnum];




 


while(sym==procsym) /* 收到过程声明符号，开始处理过程声明 */ 
{ 

strcpy(cd[dx].w,a);
getsymdo; 
if(sym==ident) 
{ 


strcpy(cd[dx].x,b);
	

getsymdo; 
} 
else error(4); /* procedure后应为标识符 */ 
if(sym==semicolon) 
{ 
	gen(cd[dx].w,cd[dx].x,"-","-");
getsymdo; 
} 
else error(5); /* 漏掉了分号 */ 
} 
if(sym==constsym) 
{ 
getsymdo; 
do

{ 
constdeclarationdo(&tx,lev,&dx); 
while(sym==comma)  
{ 
getsymdo; 
constdeclarationdo(&tx,lev,&dx); 
} 
if(sym==semicolon) 
{ 
getsymdo; 
} 
else error(5); 
} 
while(sym==ident); 
}
if(sym==varsym) /* 收到变量声明符号，开始处理变量声明 */ 
 
 { 
	
getsymdo; 
do 
{    
vardeclarationdo(&tx,lev,&dx); 
while(sym==comma)  
{ 
	i++;
getsymdo; 
vardeclarationdo(&tx,lev,&dx); 
} 
if(sym==colon) 
{ 
getsymdo; 
} 
else error(5); 
if(sym==ident)
getsymdo;
else error(5);
if(sym==semicolon)
getsymdo;
else error(5);
} 
while(sym==ident); 
} 

statement(nxtlev,0,lev); 
gen("sys","-","-","-");




/* 语句后跟符号为分号或end */ 



return 0; 
} 



/* 初始化 */ 
void init() 
{ 
int i; 

/* 设置单字符符号 */ 
for(i=0;i<=255;i++)ssym[i]=nul; 
ssym['+']=plus; 
ssym['-']=minus; 
ssym['*']=times; 
ssym['/']=slash; 
ssym['(']=lparen; 
ssym[')']=rparen; 
ssym['=']=eql; 
ssym[',']=comma; 
ssym['.']=period; 
ssym['#']=neq; 
ssym[';']=semicolon; 
ssym[':']=colon;
/* 设置保留字名字 */ 
strcpy(&(word[0][0]),"begin"); 
strcpy(&(word[1][0]),"repeat"); 
strcpy(&(word[2][0]),"const"); 
strcpy(&(word[3][0]),"do"); 
strcpy(&(word[4][0]),"end"); 
strcpy(&(word[5][0]),"if"); 
strcpy(&(word[6][0]),"odd"); 
strcpy(&(word[7][0]),"program"); 
strcpy(&(word[8][0]),"read"); 
strcpy(&(word[9][0]),"then"); 
strcpy(&(word[10][0]),"var"); 
strcpy(&(word[11][0]),"while"); 
strcpy(&(word[12][0]),"and"); 
strcpy(&(word[13][0]),"until");
strcpy(&(word[14][0]),"else");
/* 设置保留字符号 */ 
wsym[0]=beginsym; 
wsym[1]=repeatsym; 
wsym[2]=constsym; 
wsym[3]=dosym; 
wsym[4]=endsym; 
wsym[5]=ifsym; 
wsym[6]=oddsym; 
wsym[7]=procsym; 
wsym[8]=readsym; 
wsym[9]=thensym; 
wsym[10]=varsym; 
wsym[11]=whilesym;   
wsym[12]=andsym; 
wsym[13]=untilsym; 
wsym[14]=elsesym; 

/* 设置指令名称 */ 
strcpy(&(mnemonic[lit][0]),"lit"); 
strcpy(&(mnemonic[opr][0]),"opr"); 
strcpy(&(mnemonic[lod][0]),"lod"); 
strcpy(&(mnemonic[sto][0]),"sto"); 
strcpy(&(mnemonic[cal][0]),"cal"); 
strcpy(&(mnemonic[inte][0]),"int"); 
strcpy(&(mnemonic[jmp][0]),"jmp"); 
strcpy(&(mnemonic[jpc][0]),"jpc"); 
/* 设置符号集 */ 
for(i=0;i<symnum;i++) 
{ 
declbegsys[i]=false; 
statbegsys[i]=false; 
facbegsys[i]=false; 
} 

/* 设置声明开始符号集 */ 
declbegsys[constsym]=true; 
declbegsys[varsym]=true; 
declbegsys[procsym]=true; 

/* 设置语句开始符号集 */ 
statbegsys[beginsym]=true; 
statbegsys[repeatsym]=true; 
statbegsys[ifsym]=true; 
statbegsys[whilesym]=true; 

/* 设置因子开始符号集 */ 
facbegsys[ident]=true; 
facbegsys[number]=true; 
facbegsys[lparen]=true; 

} 



/* 供getsym取一个字符，每次读一行，存入line缓冲区，line被getsym取空时 再读一行*/ 
int getch() 
{ 
if(cc==ll) 
{ 
if(feof(fin)) 
{ 
printf("program incomplete"); 
return -1; 
} 
ll=0; 
cc=0; 
//printf("%d ",cx); 
//fprintf(fa1,"%d ",cx); 
ch=' '; 
while(ch!=10) 
{ 
fscanf(fin,"%c",&ch); 
//printf("%c",ch); 
//fprintf(fa1,"%c",ch); 
line[ll]=ch; 
ll++; 
} 

//printf("\n"); 
//fprintf(fa1,"\n"); 
} 
ch=line[cc]; 
cc++; 
return 0; 
} 
int gen(char a[],char b[],char c[],char d[])
{
	if(dx>20){cout<<"too long";return -1;}
	
	strcpy(cd[dx].w,a);
    strcpy(cd[dx].x,b);
    strcpy(cd[dx].y,c);
    strcpy(cd[dx].z,d);
	dx++;
	return 0;



}




/* 常量声明处理 */ 
int constdeclaration(int* ptx, 
 int lev, 
 int* pdx) 
{ 
if(sym==ident) 
{ 
getsymdo; 
if(sym==eql||sym==becomes) 
{ 
if(sym==becomes)error(1); /* 把=写成了:= */ 
getsymdo;
 if(sym==number) 
{ 

getsymdo; 
} 
else error(2); /* 常量说明=后应是数字 */ 
} 
else error(3); /* 常量说明标识后应是= */ 
} 
else error(4); /* const后应是标识 */ 
return 0; 
} 

/* 变量声明处理 */ 
int vardeclaration(int* ptx,int lev,int* pdx) 
{ 

if(sym==ident) 
{ 


getsymdo; 
} 
else error(4); /* var后应是标识 */ 
return 0; 
} 



/* 语句处理 */ 
int statement(bool* fsys,int* ptx,int lev) /* 参数意义见block和enter函数 */ 
{ 
int i,cx1,cx2; 
bool nxtlev[symnum]; /*　意义见block函数 */ 

if(sym==beginsym) /* 准备按照赋值语句处理 */ 
{ 
	getsymdo;
	while(sym==ident)
	{	strcpy(cd[dx].z,b);

getsymdo; 
if(sym==becomes)  
{ 
	strcpy(cd[dx].w,":=");
getsymdo; 
} 
else error(13); /* 检测赋值符号 */ 

expression(nxtlev,ptx,lev); /* 处理赋值符号右侧表达式 */ 
gen(cd[dx].w,b,"-",cd[dx].z);
getsymdo;
	}
statement(nxtlev,0,lev); 

} 

else 
{ if(sym==ident) /* 准备按照赋值语句处理 */ 
{ 
	while(sym==ident)
	{	strcpy(cd[dx].z,b);

getsymdo; 
if(sym==becomes)  
{ 
	strcpy(cd[dx].w,":=");
getsymdo; 
} 
else error(13); /* 检测赋值符号 */ 

expression(nxtlev,ptx,lev); /* 处理赋值符号右侧表达式 */ 
gen(cd[dx].w,b,"-",cd[dx].z);

	}


} 
 
else 
{ 
if(sym==andsym) /* 准备按照write语句处理，与read类似 */ 
{ 
getsymdo; 
if(sym==lparen) 
{ 
do 
{ 
getsymdo; 
memcpy(nxtlev,fsys,sizeof(bool)*symnum); 
nxtlev[rparen]=true; 
nxtlev[comma]=true; /* write的后跟符号为) or , */ 
expression(nxtlev,ptx,lev); /* 调用表达式处理，此处与read不同，read为给变量赋值 */ 

} 
while(sym==comma);  
if(sym!=rparen)error(33); /* write()中应为完整表达式 */ 
else 
{ 
getsymdo; 
} 
} 

} 
else 
{ 
if(sym==repeatsym) /* 准备按照call语句处理 */ 
{ 
getsymdo;
 expression(nxtlev,ptx,lev); 
 if(sym==untilsym){getsymdo;conditiondo(nxtlev,ptx,lev);}
 else error(3);
statement(fsys,0,lev); 

} 
else 
{ 
if(sym==ifsym) /* 准备按照if语句处理 */ 
{ 
getsymdo; 

conditiondo(nxtlev,ptx,lev); /* 调用条件处理（逻辑运算）函数 */ 
if(sym==thensym)  
{ 
getsymdo; 
} 
else error(16); /* 缺少then */ 


statement(fsys,0,lev); /* 处理then后的语句 */
cout<<b;
if(sym==elsesym){cout<<"sdjfafsj";getsymdo;
statement(fsys,0,lev);} 
} 
else 

{ 
if(sym==beginsym) 
{ 
	
getsymdo; 



statement(nxtlev,0,lev); 
while(sym==semicolon)  
{ 
if(sym==semicolon) 
{ 
getsymdo; 
} 
else error(10); 
statement(nxtlev,ptx,lev); 
} 
if(sym==endsym)  
{ 
getsymdo; 
} 
else error(17);
} 
else 
{ 
if(sym==whilesym) /* 准备按照while语句处理 */ 
{ 

	
cx1=cx; /* 保存判断条件操作的位置 */ 
getsymdo; 

conditiondo(nxtlev,ptx,lev); /* 调用条件处理 */ 
cx2=cx; /* 保存循环体的结束的下一个位置 */ 
if(sym==andsym){getsymdo; getsymdo; getsymdo; }
if(sym==dosym) 
{ 
	
getsymdo; 
re=dx;

gen("j","-","-",cd[dx].z);
}
else error(18); /* 缺少do */ 
statement(fsys,0,lev); /* 循环体 */ 
sprintf(cd[re].z,"%d",dx);

  
} 

} 
} 
} 
} 
} 
} 

return 0; 
} 

/* 表达式处理 */ 
char expression(bool* fsys,int* ptx,int lev) /* 参数意义见block和enter函数 */ 
{ 
enum symbol addop; /* 用于保存正负号 */ 
bool nxtlev[symnum]; 

if(sym==plus||sym==minus) /* 开头的正负号，此时当前表达式被看作一个正的或负的项 */ 
{ 
addop=sym; /* 保存开头的正负号 */ 
getsymdo; 

term(nxtlev,ptx,lev); /* 处理项 */ 
}

else /* 此时表达式被看作项的加减 */ 
{ 
term(nxtlev,ptx,lev); /* 处理项 */
 strcpy(e,cd[dx-1].z);

/* 处理项 */ 
} 
while(sym==plus||sym==minus) 
{ 
addop=sym; 
getsymdo; 
term(nxtlev,ptx,lev); /* 处理项 */
strcpy(cd[dx].y,cd[dx-1].z); /* 处理项 */ 

 
if(addop==plus) 
{ 
	
	gen("+",e,cd[dx].y,"T");

} 
else 
{
gen("-",e,cd[dx].y,"T");
}
} 
return sym; 
} 

/* 条件处理 */ 
int condition(bool* fsys,int* ptx,int lev) /* 参数意义见block和enter函数 */ 
{ 
enum symbol relop; 
bool nxtlev[symnum]; 
if(sym==oddsym) /* 准备按照odd运算处理 */ 
{ 
getsymdo; 
expression(fsys,ptx,lev); 

} 
else 
{ 
/* 逻辑表达式处理 */ 

strcpy(e,b);
expression(nxtlev,ptx,lev);  
 
if(sym!=eql&&sym!=neq&&sym!=lss&&sym!=leq&&sym!=gtr&&sym!=geq)error(20); 
else 
{ 
relop=sym; 

getsymdo;

expression(fsys,ptx,lev);  strcpy(cd[dx].y,b);
gen("<",e,cd[dx].y,cd[dx].z);

} 
} 
return 0; 
} 

/* 项处理 */ 
char term(bool* fsys,int* ptx,int lev) /* 参数意义见block和enter函数 */ 
{ 
enum symbol mulop; /* 用于保存乘除法符号 */ 
bool nxtlev[symnum]; 



factor(nxtlev,ptx,lev); /* 处理因子 */ 
strcpy(cd[dx].x,b);
while(sym==times||sym==slash) 
{ 
mulop=sym; 
getsymdo; strcpy(cd[dx].y,b);
factor(nxtlev,ptx,lev); 
if(mulop==times) 
{ 

	gen("*",cd[dx].x,cd[dx].y,"T");
	

} 
else 
{ 

gen("/",cd[dx].x,cd[dx].y,"T");

} 
} 
return sym; 
} 

/* 因子处理 */ 
char factor(bool* fsys,int* ptx,int lev) /* 参数意义见block和enter函数 */ 
{ 
int i; 
bool nxtlev[symnum]; 

while(1) /* 循环直到不是因子开始符号 */ 
{ 
if(sym==ident) /* 因子为常量或变量 */ 
{ 
	

if(i==0)error(11); /* 名字未声明 */ 
else 
{ 

} 
getsymdo; 
return ident;
} 
else 
{ 
if(sym==number) /* 因子为数 */ 
{ 

 sprintf(b,"%d",num);  



if(num>amax) 
{ 
error(31); 
num=0; 
} 


getsymdo; 
return num;
} 
else 
{ 
if(sym==lparen) /* 因子为表达式 */ 
{ 
getsymdo; 

expression(nxtlev,ptx,lev); 
if(sym==rparen) 
{ 
getsymdo; 
} 
else error(22); /* 缺少右括号 */ 
} 

} 
} 
} 
return  expression(nxtlev,ptx,lev); 
}