电子科技大学计算机学院编译原理实验语法分析.docx
《电子科技大学计算机学院编译原理实验语法分析.docx》由会员分享，可在线阅读，更多相关《电子科技大学计算机学院编译原理实验语法分析.docx（40页珍藏版）》请在冰点文库上搜索。
电子科技大学计算机学院编译原理实验语法分析
//SyntaxAnalyzer.cpp:
定义控制台应用程序的入口点。
//
#include
#include
#include
#defineMAX_COUNT1024
#defineSIGN_UNDEFINED_ERR1
#defineSIGN_REDEFINED_ERR2
#defineSIGN_EXECUTE_ERR3
#defineNO_SIGN_ERR4
#defineSIGN_RESERVE_ERR5
#defineNO_PARA_ERR6
/*types是支持类型的集合*/
typedefenum{integer}types;
/*记录变量信息的结构体*/
typedefstruct{
charvname[17];
charvproc[17];
boolvkind;
typesvtype;
intvlev;
intvadr;
}varRecord;
/*记录过程信息的结构体*/
typedefstruct{
charpname[17];
typesptype;
intplev;
intvarNum;
intfadr;
intladr;
intparameter;
boolparameterIsDefined;
}proRecord;
/**********文法产生式如下**********
A：
程序A->B
B：
分程序B->beginC;Mend
C：
说明与句表C->DC'
C'->;DC'|ε
D：
说明语句D->E|J
E：
变量说明E->integerF
F：
变量F->G
G：
标识符G->HG'
G'->HG'|IG'|ε
H：
字母H->a|...|z|A|...|Z
I：
数字I->0|1|...|9
J：
函数说明J->integerfunctionG（K）;L
K：
参数K->F
L：
函数体L->beginC;Mend
M：
执行语句表M->NM'
M'->;NM'|ε
N：
执行语句N->O|P|Q|W
O：
读语句O->read（F）
P：
写语句P->write（F）
Q：
赋值语句Q->F:
=R
R：
算术表达式R->SR'
R'->-SR'|ε
S：
项S->TS'
S'->*TS'|ε
T：
因子T->F|U|Z
U：
常数U->V
V：
无符号整数V->IV'
V'->IV'|ε
W：
条件语句W->ifXthenNelseN
X：
条件表达式X->RYR
Y：
关系运算符Y-><|<=|>|>=|=|<>
Z：
函数调用Z->G（R）
**********************************/
voidA（）;
voidB（）;
voidC（）;
voidC_（）;
voidD（）;
voidE（）;
voidF（）;
voidG（）;
voidJ（）;
voidK（）;
voidL（）;
voidM（）;
voidM_（）;
voidN（）;
voidO（）;
voidP（）;
voidQ（）;
voidR（）;
voidR_（）;
voidS（）;
voidS_（）;
voidT（）;
voidU（）;
voidW（）;
voidX（）;
voidY（）;
voidZ（）;
/*初始化函数：
从输入文件读取数据，建立各个文件，初始化全局变量*/
boolinit（intargc,char*argv[]）;
/*结束处理函数，将var和pro数组中的元素输出到相应文件，填充输出文件*/
boolfinal（）;
/*错误处理函数，参数分别为行号、错误码和错误符号*/
boolerror（intlineNum,interrNum,constchar*sign）;
/*获得所处目录路径，包括最后斜杠，或者为空*/
voidgetPath（char*in,char*out）;
/*获得文件名，不包括扩展*/
voidgetFilename（char*in,char*out）;
/*获得下一符号,true表示已到队尾，false表示还未到队尾*/
boolnextToken（）;
/*获得当前符号的下一字符,true表示已到'\0'*/
boolnextChar（）;
/*判断变量是否已存在*/
boolisVarExisted（char*vname,char*vproc,boolvkind）;
/*判断过程是否已存在，参数为过程名*/
boolisProExisted（char*vname）;
/*获得下一符号，指针不变*/
intgetNextToken（）;
charinput[MAX_COUNT][17];//存放输入文件所有符号的数组
intkind[MAX_COUNT];
intinputCount;//输入符号的数量
intpToken;//指向当前输入符号
intpChar;//指向当前输入符号中的当前字符
varRecordcurrentVar;//存放当前变量的信息
proRecordcurrentPro;//存放当前过程的信息
intlineNum;//当前行号
varRecordvar[MAX_COUNT];//存放变量名表项数组
proRecordpro[MAX_COUNT];//存放过程名表项数组
intvarCount;//变量的数量
intproCount;//过程的数量
FILE*inFile;//输入文件句柄
FILE*outFile;//输出文件句柄
FILE*errFile;//错误文件句柄
FILE*varFile;//变量文件句柄
FILE*proFile;//过程文件句柄
/*主函数*/
intmain（intargc,char*argv[]）
{
if（init（argc,argv））
{
A（）;
final（）;
}
return0;
}
boolinit（intargc,char*argv[]）
{
if（argc!
=2）
{
returnfalse;
}
else
{
char*inFilename=argv[1];
charoutFilename[MAX_COUNT]="";
charerrFilename[MAX_COUNT]="";
charvarFilename[MAX_COUNT]="";
charproFilename[MAX_COUNT]="";
charfilename[MAX_COUNT]="";
charpath[MAX_COUNT]="";
//获得文件名（不包括扩展名）和路径
getFilename（inFilename,filename）;
getPath（inFilename,path）;
//生成输出文件全部路径
strcat（outFilename,path）;
//strcat（outFilename,"\\"）;
strcat（outFilename,filename）;
strcat（outFilename,".dys"）;
//生成错误文件全部路径
strcat（errFilename,path）;
//strcat（errFilename,"\\"）;
strcat（errFilename,filename）;
strcat（errFilename,".err"）;
//生成变量文件全部路径
strcat（varFilename,path）;
//strcat（varFilename,"\\"）;
strcat（varFilename,filename）;
strcat（varFilename,".var"）;
//生成过程文件全部路径
strcat（proFilename,path）;
//strcat（proFilename,"\\"）;
strcat（proFilename,filename）;
strcat（proFilename,".pro"）;
//打开文件句柄
if（（inFile=fopen（inFilename,"r"））&&（outFile=fopen（outFilename,"w"））&&（errFile=fopen（errFilename,"w"））&&（varFile=fopen（varFilename,"w"））&&（proFile=fopen（proFilename,"w"）））
{
//初始化单词指针、字符指针、行号、层次
inputCount=0;
pToken=0;
pChar=0;
lineNum=1;//当前行号
//level=0;//当前层次
//varCountInPro=0;
strcpy（currentPro.pname,""）;
currentPro.plev=0;
currentPro.varNum=0;
currentPro.parameter=-1;
varCount=0;
proCount=0;
//读取输入文件内容，初始化input数组
while（!
feof（inFile））
{
charstringOfLine[MAX_COUNT];
if（fgets（stringOfLine,MAX_COUNT,inFile））
{
charlineString[20]="";
strncpy（lineString,stringOfLine,19）;
char*kindString=strrchr（lineString,''）;
kind[inputCount]=atoi（kindString+1）;
charstring[17]="";
strncpy（string,stringOfLine,16）;
char*lastString=strrchr（string,''）;
strcpy（input[inputCount],lastString+1）;
inputCount++;
}
}
returntrue;
}
else
{
fclose（inFile）;
fclose（outFile）;
fclose（errFile）;
fclose（varFile）;
fclose（proFile）;
returnfalse;
}
}
}
boolfinal（）
{
for（inti=0;i{
intvkind=var[i].vkind?
1:
0;
char*vtype=（var[i].vtype==integer）?
"integer":
"";
fprintf（varFile,"%16s%16s%d%s%d%d\n",var[i].vname,var[i].vproc,vkind,vtype,var[i].vlev,var[i].vadr）;
}
for（inti=0;i{
char*ptype=（pro[i].ptype==integer）?
"integer":
"";
fprintf（proFile,"%16s%s%d%d%d\n",pro[i].pname,ptype,pro[i].plev,pro[i].fadr,pro[i].ladr）;
}
if（fseek（inFile,0,0）==0）
{
while（!
feof（inFile））
fputc（fgetc（inFile）,outFile）;
}
boolval;
val=fclose（inFile）;
val=fclose（outFile）;
val=fclose（errFile）;
val=fclose（varFile）;
val=fclose（proFile）;
returnval;
}
boolerror（interrNum,constchar*symbol）
{
char*errInfo;
switch（errNum）
{
caseSIGN_UNDEFINED_ERR:
fprintf（errFile,"***LINE:
%d%s符号无定义\n",lineNum,input[pToken]）;
break;
caseSIGN_REDEFINED_ERR:
fprintf（errFile,"***LINE:
%d%s符号重定义\n",lineNum,input[pToken]）;
break;
caseSIGN_EXECUTE_ERR:
fprintf（errFile,"***LINE:
%d%s处不能匹配执行语句\n",lineNum,input[pToken]）;
break;
caseNO_SIGN_ERR:
fprintf（errFile,"***LINE:
%d%s处缺少%s\n",lineNum,input[pToken],symbol）;
break;
caseSIGN_RESERVE_ERR:
errInfo="以保留字开头";
break;
caseNO_PARA_ERR:
fprintf（errFile,"***LINE:
%d缺少形参%s的声明\n",lineNum,symbol）;
break;
default:
errInfo="未知错误";
}
returntrue;
}
voidgetPath（char*in,char*out）
{
char*name;
name=strrchr（in,'\\'）;
if（name!
=NULL）
strncpy（out,in,strlen（in）-strlen（name）+1）;
else
strcpy（out,""）;
}
voidgetFilename（char*in,char*out）
{
char*fullName;
char*extension;
fullName=strrchr（in,'\\'）;
extension=strrchr（in,'.'）;
if（fullName!
=NULL）
strncpy（out,fullName+1,strlen（fullName）-1-strlen（extension））;
else
strncpy（out,in,strlen（in）-strlen（extension））;
}
boolnextToken（）
{
pToken++;
pChar=0;
if（strcmp（input[pToken],"EOF"）==0）
{
returntrue;
}
while（strcmp（input[pToken],"EOLN"）==0）
{
pToken++;
lineNum++;
}
returnfalse;
}
boolnextChar（）
{
if（input[pToken][pChar]=='\0'）
{
//nextToken（）;
returntrue;
}
pChar++;
returnfalse;
}
boolisVarExisted（char*vname,char*vproc,boolvkind）
{
for（inti=0;i{
if（（strcmp（vname,var[i].vname）==0）&&（strcmp（vproc,var[i].vproc）==0）&&（var[i].vkind==vkind））
returntrue;
}
for（inti=0;i{
if（strcmp（vname,pro[i].pname）==0）
returntrue;
}
returnfalse;
}
boolisProExisted（char*vname）
{
for（inti=0;i{
if（strcmp（vname,var[i].vname）==0）
returntrue;
}
for（inti=0;i{
if（strcmp（vname,pro[i].pname）==0）
returntrue;
}
returnfalse;
}
intgetNextToken（）
{
intpNextToken=pToken+1;
while（strcmp（input[pNextToken],"EOLN"）==0）
{
pNextToken++;
}
returnpNextToken;
}
voidA（）
{
B（）;
}
voidB（）
{
if（strcmp（input[pToken],"begin"）==0）
{
nextToken（）;
}
else
{
error（NO_SIGN_ERR,"begin"）;
if（strcmp（input[pToken],"integer"）!
=0）
{
nextToken（）;
}
}
C（）;
if（strcmp（input[pToken],";"）==0）
{
nextToken（）;
}
else
{
error（NO_SIGN_ERR,";"）;
if（（strcmp（input[pToken],"integer"）!
=0）&&（strcmp（input[pToken],"read"）!
=0）&&（strcmp（input[pToken],"write"）!
=0）&&（kind[pToken]!
=10））
{
nextToken（）;
}
}
M（）;
if（strcmp（input[pToken],"end"）==0）
{
nextToken（）;
}
else
{
error（NO_SIGN_ERR,"end"）;
}
}
voidC（）
{
D（）;
C_（）;
}
voidC_（）
{
if（strcmp（input[pToken],";"）==0&&strcmp（input[getNextToken（）],"integer"）==0）
{
nextToken（）;
D（）;
C_（）;
}
else
{
if（strcmp（input[pToken],"integer"）==0）
{
error（NO_SIGN_ERR,";"）;
D（）;
C_（）;
}
}
}
voidD（）
{
if（strcmp（input[pToken+1],"function"）==0）
{
J（）;
}
else
{
E（）;
}
}
voidE（）
{
if（strcmp（input[pToken],"integer"）==0）
{
nextToken（）;
}
else
{
error（NO_SIGN_ERR,"integer"）;
//if（kind[pToken]!
=10）
//{
nextToken（）;
//}
}
strcpy（currentVar.vname,input[pToken]）;
strcpy（currentVar.vproc,currentPro.pname）;
if（pToken==currentPro.parameter）
{
currentVar.vkind=true;
currentPro.parameterIsDefined=true;
}
else
{
currentVar.vkind=false;
}
currentVar.vtype=integer;
currentVar.vlev=currentPro.plev;
currentVar.vadr=varCount;
if（isVarExisted（input[pToken],currentPro.pname,currentVar.vkind））//如果存在变量
{
error（SIGN_REDEFINED_ERR,NULL）;
}
else
{
if（currentPro.varNum==0）//如果当前过程中变量数为0，则当前变量是当前过程的第一个变量
{
currentPro.fadr=currentVar.vadr;
}
currentPro.ladr=currentVar.vadr;//过程中最后一个变量在变量表中的位置
currentPro.varNum++;//过程中变量数++
var[varCoun
升级会员 