语义分析及中间代码生成程序设计原理与实现技术实验报告及源代码北京交通大学.docx

语义分析及中间代码生成程序设计原理与实现技术实验报告及源代码北京交通大学.docx

《语义分析及中间代码生成程序设计原理与实现技术实验报告及源代码北京交通大学.docx》由会员分享，可在线阅读，更多相关《语义分析及中间代码生成程序设计原理与实现技术实验报告及源代码北京交通大学.docx（17页珍藏版）》请在冰豆网上搜索。

语义分析及中间代码生成程序设计原理与实现技术实验报告及源代码北京交通大学

语义分析及中间代码生成程序设计原理与实现技术

XXX1028XXX2计科1XXX班

1.程序功能描述

完成以下描述赋值语句和算术表达式文法的语法制导生成中间代码四元式的过程。

G[A]:

A→V:

=E

E→E+T∣E-T∣

T→T*F∣T/F∣F

F→（E）∣i

V→i

说明：

终结符号i为用户定义的简单变量,即标识符的定义。

2.设计要求

（1）给出每一产生式对应的语义动作；

（2）设计中间代码四元式的结构（暂不与符号表有关）。

（3）输入串应是词法分析的输出二元式序列，即某算术表达式“实验项目一”的输出结果。

输出为输入串的四元式序列中间文件。

（4）设计两个测试用例（尽可能完备），并给出程序执行结果四元式序列。

3.主要数据结构描述：

本程序采用的是算符优先文法，文法以及算符优先矩阵是根据第四次实验来修改的，所以主要的数据结构也跟第四次差不多，主要为文法的表示，FirstVT集和LastVT集以及算符优先矩阵：

算符优先矩阵采用二维字符数组表示的：

charmtr[9][9];//算符优先矩阵

4.程序结构描述：

本程序一共有8功能函数：

voidget（）;//获取文法

voidprint（）;//打印文法

voidfun（）;//求FirstVT和LastVT

voidmatrix（）;//求算符优先矩阵

voidtest（）;//测试文法

intcmp（chara,charb）;比较两个运算符的优先级10-1

voidout（charnow,intavg1,intavg2）;//打印四元式

intope（charop,inta,intb）;//定义四元式计算方法

5.实验代码

详见附件

6.程序测试

6.1功能测试

程序运行显示如下功能菜单：

选择打印文法：

选择构造FirstVt集和LastVT集：

选择构造算符优先矩阵：

6.2文法测试

测试1:

1+2*3

测试2:

2+3+4*5+（6/2）

7.学习总结

本次实验完成了语义及中间代码生成的设计原理与实现，所采用的方法为算符优先分析方法，首先根据文法求出此文法的FirstVT集和LastVT集，然后根据他们求出此文法的算符优先矩阵。

由于此文法和第四次文法基本相同，只是多了一条赋值语句，所以采用的规则和第四次基本相同。

在分析阶段，每当遇到有规约的项目，判断一下，打印出此部运算的四元式，这样一步一步分析，知道输入的算术表达式计算分析完毕。

由于本次实验部分代码和第四次实验的代码比较相似，只需增加一点四元式的分析计算打印过程，就能够顺利完成本次实验。

通过这次实验，我对语义分析以及中间代码部分有了一定的提高，对以后的学习有了一定程度上的帮助。

//lb6.cpp:

定义控制台应用程序的入口点。

//

#include"stdafx.h"

#include

#include

#include

#include

usingnamespacestd;

structinfo{

charleft;

vectorright;

vectorfirst;

vectorlast;

};

vectorlang;

charmtr[9][9];//算符优先矩阵

stacksta;

voidget（）;//获取文法

voidprint（）;//打印文法

voidfun（）;//求FirstVT和LastVT

voidmatrix（）;//求算符优先矩阵

voidtest（）;//测试文法

intcmp（chara,charb）;//比较两个运算符的优先级10-1

voidout（charnow,intavg1,intavg2）;//打印四元式

intope（charop,inta,intb）;//定义四元式计算方法

intmain（）{

intchoose;

while

（1）{

cout<<"****************************************"<

cout<<"获取文法请按1"<

cout<<"打印文法请按2"<

cout<<"构造FirstVT集和LastVT集请按3"<

cout<<"构造优先关系矩阵请按4"<

cout<<"文法测试请按5"<

cout<<"结束请按0"<

cout<<"****************************************"<

cout<

cin>>choose;

if（choose==0）

break;

switch（choose）{

case1:

get（）;break;

case2:

print（）;break;

case3:

fun（）;break;

case4:

matrix（）;break;

case5:

test（）;break;

default:

break;

}

}

return0;

}

voidget（）{

infotemp,temp1,temp2;

temp.left='E';

temp1.left='T';

/F"）;

temp2.left='F';

lang.push_back（temp）;

lang.push_back（temp1）;

lang.push_back（temp2）;

cout<<"****************************************"<

cout<<"文法获取完成"<

cout<<"****************************************"<

cout<

}

voidprint（）{

cout<<"****************************************"<

for（inti=0;i

for（intj=0;j

cout<";

cout<

}

}

cout<<"****************************************"<

cout<

}

voidfun（）{

inti,j,sign=0,sign1=0;

for（i=0;i

for（j=0;j

stringtemp=lang[i].right[j];//获取右部

if（temp[0]>'Z'||temp[0]<'A'）{//终结符

lang[i].first.push_back（temp[0]）;

}

elseif（temp.length（）>=2）{//终结符

if（temp[1]>'Z'||temp[1]<'A'）{

lang[i].first.push_back（temp[1]）;

}

}

}

}

for（i=0;i

for（j=0;j

stringtemp=lang[i].right[j];//获取右部

if（（temp[0]>'Z'||temp[0]<'A'）&&temp.length（）==1）{//终结符

lang[i].last.push_back（temp[0]）;

}

elseif（temp.length（）>=3）{//终结符

if（temp[1]>'Z'||temp[1]<'A'）

lang[i].last.push_back（temp[1]）;

elseif（temp[2]>'Z'||temp[2]<'A'）//终结符

lang[i].last.push_back（temp[2]）;

}

}

}

while（sign==0）{//迭代FirstVT

sign=1;

for（i=0;i

for（j=0;j

stringtemp=lang[i].right[j];//获取右部

if（temp.length（）==1&&（temp[0]<='Z'&&temp[0]>='A'））{//可以迭代

for（intk=0;k

if（lang[k].left==temp[0]）{//找到了，添加元素

for（intp=0;p

sign1=0;

charch=lang[k].first[p];

for（intq=0;q

if（lang[i].first[q]==ch）{//包含了

sign1=1;

}

}

if（sign1==0）{

lang[i].first.push_back（ch）;

sign=0;

}

}

}

}

}

}

}

}

sign=0;

while（sign==0）{//迭代LastVT

sign=1;

for（i=0;i

for（j=0;j

stringtemp=lang[i].right[j];//获取右部

if（temp.length（）==1&&（temp[0]<='Z'&&temp[0]>='A'））{//可以迭代

for（intk=0;k

if（lang[k].left==temp[0]）{//找到了，添加元素

for（intp=0;p

sign1=0;

charch=lang[k].last[p];

for（intq=0;q

if（lang[i].last[q]==ch）{//包含了

sign1=1;

}

}

if（sign1==0）{

lang[i].last.push_back（ch）;

sign=0;

}

}

}

}

}

}

}

}

cout<<"****************************************"<

cout<<"FirstVT:

"<

for（i=0;i

cout<

";

for（j=0;j

cout<

}

cout<

}

cout<

cout<<"LasttVT:

"<

for（i=0;i

cout<

";

for（j=0;j

cout<

}

cout<

}

cout<<"****************************************"<

cout<

}

voidmatrix（）{

inti,j;

for（i=0;i<9;i++）{//初始化

for（j=0;j<9;j++）{

mtr[i][j]='n';

}

}

stringtemp="+-*/（）i#";

for（i=1;i<9;i++）{

mtr[i][0]=temp[i-1];

mtr[0][i]=temp[i-1];

}

vectorstr;

for（i=0;i

for（j=0;j

stringss=lang[i].right[j];

stringok="";

if（ss.length（）>2）{

if（（ss[0]>'Z'||ss[0]<'A'）&&（ss[1]<='Z'&&ss[1]>='A'））{//aU

ok="";

ok+=ss[0];

ok+=ss[1];

str.push_back（ok）;

}

if（（ss[1]>'Z'||ss[1]<'A'）&&（ss[2]<='Z'&&ss[2]>='A'））{//aU

ok="";

ok+=ss[1];

ok+=ss[2];

str.push_back（ok）;

}

}

}

}

for（i=0;i

for（j=1;j<9;j++）{

if（mtr[j][0]==str[i][0]）{//FindaThenFindFirstVt（U）

for（intk=0;k

if（lang[k].left==str[i][1]）{//FindU

for（intp=0;p

for（intq=1;q<9;q++）{

if（mtr[q][0]==lang[k].first[p]）{

mtr[j][q]='<';

}

}

}

}

}

}

}

}

str.clear（）;

for（i=0;ia

for（j=0;j

stringss=lang[i].right[j];

stringok="";

if（ss.length（）>2）{

if（（ss[1]>'Z'||ss[1]<'A'）&&（ss[0]<='Z'&&ss[0]>='A'））{//Ua

ok="";

ok+=ss[0];

ok+=ss[1];

str.push_back（ok）;

}

if（（ss[2]>'Z'||ss[2]<'A'）&&（ss[1]<='Z'&&ss[1]>='A'））{//Ua

ok="";

ok+=ss[1];

ok+=ss[2];

str.push_back（ok）;

}

}

}

}

for（i=0;i

for（j=1;j<9;j++）{

if（mtr[0][j]==str[i][1]）{//FindaThenFindLastVt（U）

for（intk=0;k

if（lang[k].left==str[i][0]）{//FindU

for（intp=0;p

for（intq=1;q<9;q++）{

if（mtr[0][q]==lang[k].last[p]）{

mtr[q][j]='>';

}

}

}

}

}

}

}

}

str.clear（）;

for（i=0;i

for（j=0;j

stringss=lang[i].right[j];

stringok="";

if（ss.length（）>2）{

if（（ss[1]>'Z'||ss[1]<'A'）&&（ss[0]>'Z'||ss[0]<'A'））{//aa

ok="";

ok+=ss[0];

ok+=ss[1];

str.push_back（ok）;

}

if（（ss[2]>'Z'||ss[2]<'A'）&&（ss[1]>'Z'||ss[1]<'A'））{//aa

ok="";

ok+=ss[1];

ok+=ss[2];

str.push_back（ok）;

}

if（（ss[2]>'Z'||ss[2]<'A'）&&（ss[0]>'Z'||ss[0]<'A'））{//aUa

ok="";

ok+=ss[0];

ok+=ss[2];

str.push_back（ok）;

}

}

}

}

for（i=0;i

for（j=1;j<9;j++）{

if（str[i][0]==mtr[j][0]）{

for（intk=1;k<9;k++）{

if（mtr[0][k]==str[i][1]）{

mtr[j][k]='=';

}

}

}

}

}

for（i=0;i

for（j=1;j<9;j++）{

if（lang[0].first[i]==mtr[0][j]）{

mtr[8][j]='<';

}

}

}

for（i=0;i

for（j=1;j<9;j++）{

if（lang[0].first[i]==mtr[j][0]）{

mtr[j][8]='>';

}

}

}

mtr[8][8]='=';

cout<<"****************************************"<

for（i=0;i<9;i++）{

for（j=0;j<9;j++）{

if（mtr[i][j]!

='n'）

cout<

else

cout<<"";

}

cout<

}

cout<<"****************************************"<

cout<

}

voidtest（）{

cout<<"****************************************"<

cout<<"请输入算术表达式：

"<

stringstr;

cin>>str;

str+='#';

inti,j,k;

stackdata;

stackop;

op.push（'#'）;

charnow='n';//记录当前栈顶操作符

intsign=0;

for（i=0;i