编译原理ex3over.docx
《编译原理ex3over.docx》由会员分享，可在线阅读，更多相关《编译原理ex3over.docx（35页珍藏版）》请在冰豆网上搜索。
编译原理ex3over
实验报告
学院（系）名称：
计算机与通信工程学院
姓名
孟于杰
学号
20091985
专业
计算机科学与技术
班级
2009级1班
实验项目
实验三：
语义分析与中间代码生成
课程名称
编译原理
课程代码
0668056
实验时间
2012年5月11日第1、2节
2012年5月15日第9、10节
2012年5月18日第1、2节
实验地点
计算机软件实验室7-219
批改意见
成绩
教师签字：
实验内容：
可选择LL1分析法、算符优先分析法、LR分析法之一，实现如下表达式文法的语法制导翻译过程。
文法G[E]如下所示：
E→E+T|E-T|T
T→T*F|T/F|F
F→P^F|P
P→（E）|i
要求构造出符合语义分析要求的属性文法描述，并在完成实验二（语法分析）的基础上，进行语义分析程序设计，最终输出与测试用例等价的四元式中间代码序列。
实验目的：
1．掌握语法制导翻译的基本功能。
2．巩固对语义分析的基本功能和原理的认识。
3．能够基于语法制导翻译的知识进行语义分析。
4．掌握类高级语言中基本语句所对应的语义动作。
5．理解并处理语义分析中的异常和错误。
实验要求：
1．在实验二的基础上，实现语法制导翻译功能，输出翻译后所得四元式序列；
2．要求详细描述所选分析方法进行制导翻译的设计过程；
3．完成对所设计分析器的功能测试，并给出测试数据和实验结果；
4．为增加程序可读性，请在程序中进行适当注释说明；
5．整理上机步骤，总结经验和体会；
6．认真完成并按时提交实验报告。
【实验过程记录（源程序、测试用例、测试结果及心得体会等）】
算符优先文法
构造FIRSTVT、LASTVT、算符优先关系表:
在构造FIRSTVT表时，通过循环找出每条产生式中的非终结符的FIRSTVT集，并把该非终结符和终结符压栈，设置标志位，标志一对非终结符和终结符具有对应关系。
LASTVT表的构造则是将求FIRSTVT的过程翻转过来，可以仅仅将函数中的参数稍作修改就能够完成。
算符优先关系表是一个二维数组，用来存放任意两个终结符之间的优先关系。
首先构造表头，通过扫描所有产生式将终结符不重复的存放在一个一维数组中并置为优先关系表的行和列，并将优先关系表其他内容全部初始化为空。
接着遍历所有产生式，找出任意两个终结符之间存在的关系（可以没有关系），并判断任意两终结符是否至多存在一种优先关系，如发现优先关系表不为空，则证明该文法不是算符优先文法，否则，将相应的关系填入到相应的行列对应的单元中。
输入串分析过程的设计。
首先将大于、小于、等于和无关系分别定义成一种类型的数据表示，通过查询符号栈栈顶以及当前符号之间的优先关系来判断移进和规约的操作。
计算FirstVT和LastVT
否
是
是
规约过程
开始时，将"#"和文法开始符号放入栈底。
总控程序在任何时候都是根据栈顶符号X和当前的输入符号进行工作的，它与文法无关
总控程序根据现行栈顶符号X和当前输入符号a，执行下列三种动作之一:
1.若X＝a＝‘＃’，则宣布分析成功，停止分析。
2.若X＝a‘＃’，则把X从STACK栈顶逐出，让指针指向下一个输入符号。
3.若X是一个非终结符，则查看分析表M。
若M[X，a]中存放着关于X的一个产生式，把X逐出STACK栈顶，把产生式的右部符号串按反序一一推进STACK栈（若右部符号为，则意味不推什么东西进栈）。
在把产生式的右部符号推进栈的同时应做这个产生式相应的语义动作。
若M[X，a]中存放着“出错标志”，则调用出错诊察程序ERROR。
//要分析的文法
stringE[10]={"E->E+T","E->E-T","E->T","T->T*F","T->T/F","T->F","F->P^F","F->P","P->（E）","P->i"};
charupper[4]={'E','T','F','P'};
charlower[8]={'+','-','/','*','^','（','）','i'};
voidinsert（charT,charn）;//入栈操作
boolSignArray[20][20];//标记数组，标记每一个是FIRSTVT、LastVT
voidCreateFIRSTVT（）;//构造FIRSTVT的函数
voidPrintFirstvt（）;
boolIsT（char）;//判断是否为终结符
boolIsN（char）;//判断是否为非终结符
程序结构：
重要代码
voidzh（intn）
{if（n>=300）
cout<<"T"<elsecout<}
intp（charn）
{
if（n=='='）
return0;
elseif（n=='）'）
return10;
elseif（n=='+'||n=='-'）
return20;
elseif（n=='*'||n=='/'）
return30;
elseif（n=='（'）
return40;
elsereturn-1;
}
classCreateFirstvt//构造FIRSTVT的类
{
public:
CreateFirstvt（）;
~CreateFirstvt（）
{}
voidinsert（charT,charn）;
boolSignArray[20][20];//标记数组，标记每一个是FIRSTVT
voidCreateFIRSTVT（）;//构造FIRSTVT的函数
voidPrintFirstvt（）;
boolIsT（char）;//判断是否为终结符
boolIsN（char）;//判断是否为非终结符
private:
stringstack[50];//栈
inttop;
};
CreateFirstvt:
:
CreateFirstvt（）//初始化SignArray
{
top=0;
for（inti=0;i<20;i++）
{
for（intj=0;j<20;j++）
{
SignArray[i][j]=false;
}
}
}
voidCreateFirstvt:
:
insert（charT,charn）
{
for（intj=0;j<4;j++）//判断是否为VT，并标记位置
{
if（T==upper[j]）
break;
}
for（intk=0;k<8;k++）//判断是否为VN，并标记位置
{
if（n==lower[k]）
break;
}
if（SignArray[j][k]==false）
{
SignArray[j][k]=true;
stack[top]="（";
stack[top].append（1,T）;
stack[top]+=",";
stack[top].append（1,n）;
stack[top]+="）";
top++;//不在栈中，则将“（P,a）”入栈
}
}
voidCreateFirstvt:
:
CreateFIRSTVT（）
{
for（inti=0;i<10;i++）
{
if（IsT（E[i].at（3）））//处理P->a.....这种情况
{
charpos1,pos2;
pos1=E[i].at（0）;//P->a...将P给pos1
pos2=E[i].at（3）;//p->a...将a给pos2
insert（pos1,pos2）;//a属于P的首符集
}
if（IsN（E[i].at（3））&&E[i].length（）>4&&IsT（E[i].at（4）））//处理P->Qa.......这种情况
{
charpos1,pos2;
pos1=E[i].at（0）;
pos2=E[i].at（4）;
insert（pos1,pos2）;
}
}
while（top!
=0）//处理P->Q......这种情况
{
stringPopElement=stack[--top];
stack[top]="";
charpos1,pos2;
for（i=0;i<10;i++）
{
if（PopElement.at
（1）==E[i].at（3））//（T,n）中的T和p->Q...中的Q相等
{
pos1=E[i].at（0）;//p->Q...的P和（T,n）中的n入栈
pos2=PopElement.at（3）;
insert（pos1,pos2）;
}
}
}
}
voidCreateFirstvt:
:
PrintFirstvt（）
{
cout<<"*********************************************"<cout<<"打印文法的FIRSTVT:
"<cout<<"文法的FIRSTVT（E）:
"<for（inti=0;i<4;i++）
{
for（intj=0;j<8;j++）
{
if（SignArray[i][j]==true&&upper[i]=='E'）
{
cout<}
}
if（upper[i]=='E'）
break;
}
cout<cout<<"文法的FIRSTVT（T）:
"<for（i=0;i<4;i++）
{
for（intj=0;j<8;j++）
{
if（SignArray[i][j]==true&&upper[i]=='T'）
{
cout<}
}
if（upper[i]=='T'）//如果找到了，就退出本次循环
break;
}
cout<cout<<"文法的FIRSTVT（F）:
"<for（i=0;i<4;i++）
{
for（intj=0;j<8;j++）
{
if（SignArray[i][j]==true&&upper[i]=='F'）
{
cout<}
}
if（upper[i]=='F'）
break;
}
cout<cout<<"文法的FIRSTVT（P）:
"<for（i=0;i<4;i++）
{
for（intj=0;j<8;j++）
{
if（SignArray[i][j]==true&&upper[i]=='P'）
{
cout<}
}
if（upper[i]=='P'）
break;
}
cout<}
boolCreateFirstvt:
:
IsT（charch）
{
for（inti=0;i<8;i++）
{
if（ch==lower[i]）
{
returntrue;
}
}
returnfalse;
}
boolCreateFirstvt:
:
IsN（charch）
{
for（inti=0;i<4;i++）
{
if（ch==upper[i]）
{
returntrue;
}
}
returnfalse;
}
classCreateLastvt//构造LASTVT的类
{
public:
CreateLastvt（）;
~CreateLastvt（）
{}
voidinsert（charT,charn）;
boolSignArray[20][20];
voidCreateLASTVT（）;//构造LASTVT的函数
voidPrintLastvt（）;
boolIsT（char）;//判断是否为终结符
boolIsN（char）;//判断是否为非终结符
private:
stringstack[50];
inttop;
};
CreateLastvt:
:
CreateLastvt（）
{
top=0;
for（inti=0;i<20;i++）
{
for（intj=0;j<20;j++）
{
SignArray[i][j]=false;
}
}
}
voidCreateLastvt:
:
insert（charT,charn）
{
for（intj=0;j<4;j++）
{
if（T==upper[j]）
break;//查出非终结符的位置
}
for（intk=0;k<8;k++）
{
if（n==lower[k]）
break;//查出终结符的位置
}
if（SignArray[j][k]==false）//如果再SignArray中没有，则将其入栈
{
SignArray[j][k]=true;
stack[top]="（";
stack[top].append（1,T）;
stack[top]+=",";
stack[top].append（1,n）;
stack[top]+="）";
top++;//将"（P,a）"入栈
}
}
voidCreateLastvt:
:
CreateLASTVT（）
{
for（inti=0;i<10;i++）
{
if（IsT（E[i].at（E[i].length（）-1））==true）//处理P->.....a这种情况
{
charpos1,pos2;
pos1=E[i].at（0）;
pos2=E[i].at（E[i].length（）-1）;
insert（pos1,pos2）;
}
if（IsT（E[i].at（E[i].length（）-2））==true&&IsN（E[i].at（E[i].length（）-1））==true）//处理P->.......aQ这种情况
{
charpos1,pos2;
pos1=E[i].at（0）;
pos2=E[i].at（E[i].length（）-2）;
insert（pos1,pos2）;
}
}
while（top!
=0）//处理P->......Q这种情况
{
stringPopElement=stack[--top];
stack[top]="";
charpos1,pos2;
for（i=0;i<10;i++）
{
if（PopElement.at
（1）==E[i].at（E[i].length（）-1））
{
pos1=E[i].at（0）;
pos2=PopElement.at（3）;
insert（pos1,pos2）;
}
}
}
}
voidCreateLastvt:
:
PrintLastvt（）
{
cout<<"****************************************"<cout<<"打印文法的LASTVT:
"<cout<<"文法的LASTVT（E）:
"<for（inti=0;i<4;i++）
{
for（intj=0;j<8;j++）
{
if（SignArray[i][j]==true&&upper[i]=='E'）
{
cout<}
}
if（upper[i]=='E'）
break;
}
cout<cout<<"文法的LASTVT（T）:
"<for（i=0;i<4;i++）
{
for（intj=0;j<8;j++）
{
if（SignArray[i][j]==true&&upper[i]=='T'）
{
cout<}
}
if（upper[i]=='T'）
break;
}
cout<cout<<"文法的LASTVT（F）:
"<for（i=0;i<4;i++）
{
for（intj=0;j<8;j++）
{
if（SignArray[i][j]==true&&upper[i]=='F'）
{
cout<}
}
if（upper[i]=='F'）
break;
}
cout<cout<<"文法的LASTVT（P）:
"<for（i=0;i<4;i++）
{
for（intj=0;j<8;j++）
{
if（SignArray[i][j]==true&&upper[i]=='P'）
{
cout<}
}
if（upper[i]=='P'）
break;
}
cout<}
boolCreateLastvt:
:
IsT（charch）
{
for（inti=0;i<8;i++）
{
if（ch==lower[i]）
{
returntrue;
}
}
returnfalse;
}
boolCreateLastvt:
:
IsN（charch）
{
for（inti=0;i<4;i++）
{
if（ch==upper[i]）
{
returntrue;
}
}
returnfalse;
}
classCreatePreTable
{
public:
CreatePreTable（）;
~CreatePreTable（）
{}
voidCreatePreCedentTable（）;
voidPrintPreTable（）;
boolIsT（char）;
boolIsN（char）;
intGetLocation（char）;
private:
charPreTable[8][8];//算符优先关系表
};
CreatePreTable:
:
CreatePreTable（）//初始化
{
for（inti=0;i<8;i++）
for（intj=0;j<8;j++）
{
PreTable[i][j]='';
}
}
boolCreatePreTable:
:
IsT（charch）
{
for（inti=0;i<8;i++）
{
if（ch==lower[i]）
returntrue;
}
}
boolCreatePreTable:
:
IsN（charch）
{
for（inti=0;i<4;i++）
{
if（ch==upper[i]）
returntrue;
}
}
voidCreatePreTable:
:
CreatePreCedentTable（）//
{
CreateFirstvtfirstvt;
firstvt.CreateFIRSTVT（）;
CreateLastvtlastvt;
lastvt.CreateLASTVT（）;
for（inti=0;i<10;i++）
for（intj=1;j<（E[i].length（）-3）;j++）
{
if（IsT（E[i].at（j+2））==true）
{
if（IsT（E[i].at（j+3））==true）
{
PreTable[GetLocation（E[i].at（j+2））][GetLocation（E[i].at（j+3））]='=';//判定为等于关系
}
if（IsN（E[i].at（j+3））==true&&j<=（E[i].length（）-5）&&IsT（E[i].at（j+4））==true）
{
PreTable[GetLocation（E[i].at（j+2））][GetLocation（E[i].at（j+4））]='=';//判定为等于关系
}
if（IsN（E[i].at（j+3））==true）
{
intloc=GetLocation（E[i].at（j+2））;
for（intm=0;m<4;m++）
{
for（intk=0;k<8;k++）
{
if（firstvt.SignArray[m][k]==true&&upper[m]==E[i].at（j+3））
{
PreTable[loc][k]='<';
}
}
if（upper[m]==E[i].at（j+3））
break;
}
}
}
else
{
if（IsT（E[i].at（j+3））==true）
{
intloc=GetLocation（E[i].at（j+3））;
for（intm=0;m<4;m++）
{
for（intk=0;k<8;k++）
{
if（lastvt.SignArray[m][k]==true&&u
升级会员 