(完整word版)IF-ELSE条件语句的翻译程序设计(LR方法、输出四元式)

目录
1 系统描述（问题域描述） (2)
2 文法及属性文法的描述 (2)
2.1文法 (2)
2.2 属性文法 (2)
3 语法分析方法描述及语法分析表设计 (3)
3.1语法分析方法描述 (3)
3.1．1 LR方法的基本思想 (3)
3.1.2 LR分析器模型 (4)
3.2语法分析表设计 (5)
4中间代码形式的描述及中间代码序列的结构设计 (6)
4.1中间代码形式的描述 (6)
4.2中间代码序列的结构设计 (6)
5 编译系统的概要设计 (6)
6 详细的算法描述 (7)
6.1系统流程图 (7)
6.2算法描述 (7)
7 软件的测试方法和测试结果 (18)
7.1软件的测试方法 (18)
7.2测试结果 (18)
8设计的特点、不足、收获与体会 (21)
8.1特点与不足 (21)
8.2收获与体会 (21)
9 参考文献 (21)
10本科生课程设计成绩评定表 (22)
IF-ELSE条件语句的翻译程序设计（LR方法、输出四元式）
1 系统描述（问题域描述）
对条件语句： if 〈布尔表达式〉then〈赋值语句〉 else 〈赋值语句〉，进行词法，LR(1)语法分析，并根据语法制导翻译方法将条件语句翻译成四元式中间代码形式，最后输出翻译后的四元式代码。

2 文法及属性文法的描述
2.1文法
G[S]: S->CS
S->TS
S->A
C->if E then
T->CS else
T->else
其中，E代表布尔表达式，可由界符（）括起来，A代表赋值表达式。

在这里E、A都代表终结符，具体的表达式在程序会判断其类型。

2.2 属性文法
S->C S
{S.clain:=merge(C.clain,S.clain)}
S->T S
{S.clain:=merge(T.clain,S.clain)}
S->A
{S.clain:0/* 空链*/}
C->if E then
{backpatch(E.true,nextstat) C.clain:=E.false}
T->C S else
{ q:=nextstat
Emit(‘GOTO’—)
Backpatch(C.clain,nextstat)
T.clain:=merge(S.clain,q)}
3 语法分析方法描述及语法分析表设计
3.1语法分析方法描述
3.1．1 LR方法的基本思想
一个LR分析器实质上是一个带先进后出存储器的确定有限状态自动机。

我们将把“历史”和“展望”材料综合地抽象成某些“状态”。

分析栈用来存放状态。

栈里的每个状态概括了从分析开始直到某一归约阶段的全部“历史”和“展望”资料。

任何时候，栈顶的状态都代表了整个的历史和已推测出的展望。

因此，在任何时候都可从栈顶状态得知所想了解的一切，而绝对没有必要从称底而上翻阅整个栈。

LR分析器的每一步工作都是由栈顶
状态和现行输入符号所唯一决定的。

为了有助于明确归约手续，我们把已归约出的文法符号串也同时放在栈里。

于是，我们可以把栈的结构看成是:
栈的每一项内容包括状态S和文法符号X两部分。

（S0，#）为分析开始前预先放到栈里的初始状态和句子括号。

栈顶状态为SM，符号串X1X2….XM是至今已移进归约出的部分。

3.1.2 LR分析器模型
LR分析器模型如下图:
LR分析器的核心部分是一张分析表。

这张分析表包括两部分，一是“动作”（ACTION）表，另一个是“状态转换表”（GOTO）表。

它们都是二维数组。

ACTION[s，a]规定了当状态s面临输入符号a时应采取什么动作。

GOTO[s，a]规定了状态s 面对文法符号X（终结符或非终结符）时下一个状态是什么。

显然GOTO[S，x]定义了一个以文法符号为字母表的DFA。

每一项ACTION[s，a]所规定的动作不外是下述四种可能之一：
1. 移进把（S，A）的下一状态S＝GOTO[S，A]和输入符号A推进栈，下一输入符号变成现行输入状态。

2. 规约指用某一产生式A－> 进行规约。

假若的长度为r，归约动作是A，去除栈顶的r个项，使状态Sm-r变成栈顶状态，然后把（Sm-r，A）的下一状态S1＝GOTO[Sm-r,A]和文法符号A推进栈。

归约动作不改变现行输入符号。

执行归约动作意味着（＝Xm-r+1….Xm）已呈现于栈顶而且是一个相对于A的句柄。

3. 接受宣布分析成功，停止分析器的工作。

4. 报错发现源程序含有错误，调用出错处理程序。

LR分析器的总控程序本身的工作是非常简单。

它的任何一步只需要按栈顶状态和现行输入符号a执行ACTION[S，a]所规定的动作。

不管什么分析表，总控程序都是一样地工作。

一个LR分析器的工作过程可看成是栈里的状态序列，已归约串和输入串所构成的三元式的变化过程。

分析地的初始三元式（S0,#,a1a2…an#）其中，S0为分析器的初态；#为句子的左括号；a1a2…an为输入串；其后的#为结束符。

分析
过程每步的结果可表示为（s0s1…sm,# X1X2…,ai….an#）分析器的下一步动作是由栈顶状态Sm和现行输入符号ai所唯一决定。

即，执行ACTION[Sm,ai]所规定的动作。

经执行每种可能的动作之后，三元式的变化的情形是：
（1）若ACTION[Sm,ai]为移进，且S=GOTO[Sm,ai],则三元式变成：
（S0S1…Sm,#X1X2…Xmaian#）
（2）若ACTION[Sm,ai]＝{A－> }，则按产生式A－> 进行归约。

此时三元式变为
(S0S1…Sm-rS,#X1…Xm-rA,aiai+1…an#)
此处S ＝GOTO[Sm-r,A]，r为的长度，＝Xm-r+1…Xm。

（3）若ACTION[Sm,ai]为：接受，则三元式不再变化，变化过程终止，宣布分析成功。

（4）若ACTION[Sm,ai]为“报错”，则三元式的变化过程终止，报告错误。

一个LR分析器的工作过程就是一步一步地变换三元式，直至执行“接受”或“报错”为止。

3.2语法分析表设计
（1）Sj 把下一状态j和现行输入符号移进栈；
（2）rj 按第j个产生式进行规约；
（3）acc 接受；
（4）空白格出错标志，报错；
4中间代码形式的描述及中间代码序列的结构设计4.1中间代码形式的描述
四元式是一种比较普遍采用的中间代码形式。

四元式的四个组成部分是：操作符OP，第一个和第二个运算对象ARG1和ARG2及运算结果RESULT。

运算对象和运算结果有时指用户自己定义的变量，有时指编译程序引进的临时变量。

例如a:=b*c+b*d的四元式表示如下：
(1)(*,b,c,t1)
(2)(*,b,d,t2)
(3)(+,t1,t2,t3)
(4)(:=,t3,-,a)
4.2中间代码序列的结构设计
If E then A1else A2
100 （关于E的布尔表达式）
101 （goto, - , - ,104）
102 (关于A1的赋值表达式)
103 （goto, - , - ,105）
104 (关于A2的赋值表达式)
105 exit
5 编译系统的概要设计
本课程设计需要写一个条件语句的LR文法及其属性文法，运用LR分析方法对此文法进行语法和语义分析，中间代码采用四元式输出。

在这个条件语句的翻译分析程序设计中，主要通过以下四个过程来完成：
1.词法分析。

由于编译程序是在单词的级别上来分析和翻译源程序的，那么在这里，词法分析的任务是：从左至右逐个字符地对源程序进行扫描，产生一个一个的单词符号，把作为字符串的源程序改造成为单词符号串的中间程序。

所以词法分析是编译的基础。

在此程序中是将词法分析作为一遍处理的，通过一次分析把全部的字符串都分析完成，并将其保存在数组中便于下一步进行语法分析。

2.语法分析。

在完成词法分析的基础上对条件语句进行语法分析，在这里我采用了自下而上分析法SLR(1)分析方法，来分析判定程序的语法结构是否符合语法规则，在分析前首先要构造SLR(1)分析表，然后在进行语法分析，在此程序中，以‘；’为结束符号来判断一条条的条件语句，并且独立的对每条语句进行语法分析。

并把算法中的移近、规约操作
3.语义分析、输出四元式。

在进行语法分析的同时进行语义分析，在此次设计中式将二者结合起来作为一遍进行处理的。

在进行语义时同时生成中间语言四元
式。

4.出错处理。

如果在词法分析时遇到非法字符就会输出出错信息，同时输出从出错点开始往后的一串字符，但是它仍然能跳过该非法字符继续分析；如果在语法分析中有错误的话，就会显示在DOS环境下输出“ERROR”,但是它能跳过出错的地方继续往后执行，分析出一部分结果并保存在文件中。

6 详细的算法描述
6.1系统流程图
6.2算法描述
本程序中，选用C++程序设计语言的部分常用的单词作为词法分析的对象，词法分析后，将识别的所有单词符号以及相关信息保存在数组中，以便后面语法分析和语意分析及中间代码生成使用，同时将识别出的单词符号输出到文件中，
并分类别地存储到相应的数组中一便进行查看。

采用SLR(1)分析法，生成状态表，然后根据栈的移近、移出生成分析过程表。

在经过语法、语义分析之后，生成中间代码四元式，同时进行出错管理。

void initGrammar();//初始化产生式表
bool isJchar(char c)//检测是否为分界符
int word() //进行词法分析，并存到fenxi.txt文件中
wnode* lexcial(wnode *head)//把词法分析得来的词分类别放到表达式数组int check(int s,char v);//查LR分析表
void gammarAnalysis(wnode *head);//语法分析及进行相应的语义操作并产生四元式
void showS(int opS[],int tops,char opC[],int topc,wnode *hp);//显示分析栈的内
源程序代码：
# include<iostream>
#include<fstream>
#include<math.h>
# include<string>
#include<iomanip>
#include<fstream>
using namespace std;
char Filename[100];
struct wnode
{
char id;
int n;//编号
char text[20];
wnode * next;
};
struct Gnode//存储产生式
{
string gen;
int id;
};
Gnode grammar[6];
void initGrammar();//初始化产生式表
wnode* lexcial(wnode *head);
int check(int s,char v);//查LR分析表
void gammarAnalysis(wnode *head);//语法分析及进行相应的语义操作并产生四元式
void showS(int opS[],int tops,char opC[],int topc,wnode *hp);//显示分析栈的内容
//用于if-else分析
int LR[11][9]={
//________ACTION_________|___GOTO___
// i t e A E # S C T
{105, 0, 0,104, 0, 0,101,102,103},//0
{ 0, 0, 0, 0, 0, -1, 0, 0, 0},//1
{105, 0, 0,104, 0, 0,106,102,103},//2
{105, 0, 0,104, 0, 0,110,102,103},//3
{ 0, 0, 3, 0, 0, 3, 0, 0, 0},//4
{ 0, 0, 0, 0,108, 0, 0, 0, 0},//5
{ 0, 0,107, 0, 0, 1, 0, 0, 0},//6
{ 5, 0, 0, 5, 0, 0, 0, 0, 0},//7
{ 0,109, 0, 0, 0, 0, 0, 0, 0},//8
{ 4, 0, 0, 4, 0, 0, 0, 0, 0},//9
{ 0, 0, 2, 0, 0, 2, 0, 0, 0} //10
};
void initGrammar()
{
grammar[0].gen="S'->S";
grammar[0].id=0;
grammar[1].gen="S->CS";
grammar[1].id=1;
grammar[2].gen="S->TS";
grammar[2].id=2;
grammar[3].gen="S->A";
grammar[3].id=3;
grammar[4].gen="C->if E then";
grammar[4].id=4;
grammar[5].gen="T->CS else";
grammar[5].id=5;
cout<<"所用文法:"<<endl;
int i,j;
for(i=1;i<6;i++)
cout<<grammar[i].id-1<<'\t'<<grammar[i].gen<<endl;
cout<<"5"<<'\t'<<"T->else"<<endl;
cout<<"注：i--if t--then e--else"<<endl;
cout<<" E——布尔表达式（在语法分析中看成是终结符）"<<endl;
cout<<" A——赋值语句（在语法分析中看成是终结符）"<<endl;
cout<<"SLR(1)分析表："<<endl;
cout<<setw(22)<<"ACTION"<<setw(18)<<"|"<<setw(10)<<"GOTO"<<endl;
cout<<setw(8)<<"i"<<setw(6)<<"t"<<setw(6)<<"e"<<setw(6)<<"A"<<setw(6)<<"E"
<<setw(6)<<"#"<<setw(6)<<"S"<<setw(6)<<"C"<<setw(6)<<"T"<<endl;
for(i=0;i<11;i++)
{
cout<<setw(2)<<i;
for(j=0;j<9;j++)
{
if(LR[i][j]>=110)
cout<<setw(4)<<"S"<<LR[i][j]-100;
else if(LR[i][j]>100)
cout<<setw(5)<<"S"<<LR[i][j]-100;
else if(LR[i][j]>0)
cout<<setw(5)<<"r"<<LR[i][j];
else if(LR[i][j]==0)
cout<<setw(6)<<" ";
else
cout<<setw(6)<<"ACC";
}
cout<<endl;
}
}
bool isJchar(char c)//检测是否为分界符
{
bool r=false;
switch(c)
{
case' ':
case'\n':
case';':r=true;break;
default:;
}
return r;
}
int word()
{
char ch=' ';
int num=0;
ifstream source("source.txt");
ofstream fenxi("fenxi.txt");
char yunsuanfu[11]={'+','-','*','/','<','>','=','!','%','&','|'};
char jiefu[9]={',',';','(',')','{','}','[',']','#'};
char
*guanjianzi[20]={"int","if","else","then","do","while","break","continue","switch","ret urn","when","for","double","main","break","include","short","long","float","char",};
char *biaoshifu[100]={"\0"};
/////////////////////////////////
while(!source.eof())
{
source.get(ch);
char shuzi[20]="";
int i=1;
if(ch>='0'&&ch<='9') //判断数字
{
shuzi[0]=ch;
source.get(ch);
while(((ch>='0'&&ch<='9')||ch=='.')&&!source.eof())
{
cout<<ch;
shuzi[i++]=ch;
source.get(ch);
}
fenxi<<shuzi<<"数字"<<endl;
}
for(i=0;i<=10;i++) //运算符判断
{
if(ch==yunsuanfu[i])
{
fenxi<<ch<<"运算符"<<endl;
}
}
for(i=0;i<9;i++) //界符
{
if(ch==jiefu[i])
{
fenxi<<ch<<"界符"<<endl;
}
}
if(ch>='a'&&ch<='z') //关键字判断
{
char str1[20];
int sign=0;
int n=0;
while(((ch>='a'&&ch<='z')||(ch>='0'&&ch<='9')||ch=='_')&&!source.eof())
{
str1[n]=ch;
source.get(ch);
n++;
}
str1[n]='\0';
for(i=0;i<20;i++)
{
if(!strcmp(str1,guanjianzi[i]))
{
fenxi<<str1<<"关键字"<<endl;
sign=1;
}
}
if(sign==0)
{
fenxi<<str1<<"标识符"<<endl;
}
for(i=0;i<=10;i++) //运算符判断
{
if(ch==yunsuanfu[i])
{
fenxi<<ch<<"运算符"<<endl;
}
}
for(i=0;i<9;i++) //界符
{
if(ch==jiefu[i])
{
fenxi<<ch<<"界符"<<endl;
}
}
}
}
fenxi.close();
source.close();
return 0;
}
wnode* lexcial(wnode *head)
{
string str;
int loc=-1;
char c;
int i,k=0,mark=0;
int Acount=0,Ecount=0;
wnode *p,*q;
p=head;
q=new wnode;
q->text[0]='\0';
q->n=0;
q->next=NULL;
fstream infile(Filename);//根据输入的路径名来打开这个文件while (infile.get(c))
{
if(isJchar(c))
{
if(mark==1)
{
q->text[k]='\0';
for(i=0;q->text[i]!='\0';i++)
if(q->text[i]=='=')
loc=i;
if(p->id=='i')
{q->id='E';q->n=++Ecount;}
else if(loc!=-1)
{q->id='A';q->n=++Acount;}
else
{
q->id=q->text[0];
if(q->id=='i')
head->n++;
}
p->next=q;
p=q;
mark=0;
}
}else
{
if(mark==0)
{
q=new wnode;
q->n=0;
q->next=NULL;
loc=-1;
k=0;
mark=1;
}
q->text[k++]=c;
}
}
//在末尾加上一个'#'
q=new wnode;
q->next=NULL;
q->id='#';
q->text[0]='\0';
q->n=0;
p->next=q;
return head;
}
//语法分析
void gammarAnalysis(wnode *head)
{
char E[20];
char A[20];
char r,d1,d2;
int tn=0,en=head->n;
ofstream table;
table.open("siyuanshi.txt");
if(!table)
{
cout<<"Cannot open output file!"<<endl;
exit(1);
}
cout<<"语法分析过程："<<endl;
cout<<"分析栈输入串操作"<<endl;
int opS[20];//记录状态，状态栈
char opC[20];//记录符号，符号栈
int mark=-1,i,count=0;
int loc=99;//指示程序指令地址
char c;
wnode *p;
p=head->next;
int tops=0;
int topc=0;
opS[tops]=0;
opC[topc]='#';
while(p)
{
showS(opS,tops,opC,topc,p);
if(tops<topc)
c=opC[tops+1];
else
{
c=p->id;
if(c=='E')
{
for(i=0;i<20&&p->text[i]!='\0';i++)
E[i]=p->text[i];
E[i]='\0';
}
if(c=='A')
{
for(i=0;i<20&&p->text[i]!='\0';i++)
A[i]=p->text[i];
A[i++]=';';
A[i]='\0';
}
}
mark=check(opS[tops],c);
switch(mark)
{
case -1:cout<<'\t'<<"语法分析,翻译成功
~~~"<<endl;table<<++loc;table.close();return;
case 1:tops=tops-2;topc=topc-1;opC[topc]='S';
cout<<'\t'<<'\t'<<" 归约 "<<grammar[1].gen<<endl;break;
case 2:tops=tops-2;topc=topc-1;opC[topc]='S';
cout<<'\t'<<'\t'<<" 归约 "<<grammar[2].gen<<endl;break;
case 3:tops=tops-1;topc=topc-0;opC[topc]='S';
cout<<'\t'<<'\t'<<" 归约 "<<grammar[3].gen<<endl;
r=A[3];d1=A[2];d2=A[4];
table<<++loc<<"\t("<<r<<'\t'<<d1<<'\t'<<d2<<'\t'<<'T'<<++tn<<')'<<endl;
table<<++loc<<"\t("<<'='<<'\t'<<'T'<<tn<<'\t'<<'\t'<<A[0]<<')'<<endl;
break;
case 4:tops=tops-3;topc=topc-2;opC[topc]='C';cout<<'\t'<<'\t'<<" 归约
"<<grammar[4].gen<<endl;
r=E[2];d1=E[1];if(r=='=')d2=E[4];else d2=E[3];
table<<++loc<<"\t("<<r;
if(r=='=')table<<r<<'\t'<<d1<<'\t'<<d2<<'\t'<<loc+2<<')'<<endl;
else table<<'\t'<<d1<<'\t'<<d2<<'\t'<<loc+2<<')'<<endl;
if(en==1)
table<<++loc<<"\t("<<"goto"<<'\t'<<'\t'<<'\t'<<loc+4<<')'<<endl;
else
table<<++loc<<"\t("<<"goto"<<'\t'<<'\t'<<'\t'<<loc+4+2*(en)<<')'<<endl;
break;
case 5:tops=tops-3;topc=topc-2;opC[topc]='T';cout<<'\t'<<'\t'<<" 归约
"<<grammar[5].gen<<endl;
table<<++loc<<"\t("<<"goto"<<'\t'<<'\t'<<'\t'<<loc+3<<')'<<endl;
break;
case 101:
case 102:
case 103:
case 104:
case 105:
case 106:
case 107:
case 108:
case 109:
case
110:if(tops==topc)p=p->next;opS[++tops]=mark-100;if(tops>topc)opC[++topc]=c;
cout<<'\t'<<'\t'<<" 移入"<<endl;break;
case 0:cout<<"ERROR!"<<endl;return;
}
}
}
void showS(int opS[],int tops,char opC[],int topc,wnode *hp)
{
// cout<<endl;
int i=0,j=0;
wnode *tp=hp;
for(i=0;i<=topc;i++)
cout<<opC[i];
cout<<'\t';
while(tp)
{
cout<<tp->id;
tp=tp->next;
}
cout<<endl;
for(i=0;i<=tops;i++)
cout<<opS[i];
//cout<<endl;
}
int check(int s,char v)
{
int t=-1;
switch(v)
{
case'i':t=0;break;
case't':t=1;break;
case'e':t=2;break;
case'A':t=3;break;
case'E':t=4;break;
case'#':t=5;break;
case'S':t=6;break;
case'C':t=7;break;
case'T':t=8;break;
default:;
}
int r=LR[s][t];
return r;
}
int main()
{
FILE *fp;
int n=100;
cout<<"\n***IF-ELSE条件语句的翻译程序设计（LR方法、输出四元式）***"<<endl; initGrammar();
cout<<"请输入文件名:";
cin.getline(Filename,n);
fp=fopen(Filename,"r");
while (fp==NULL)//若打入的文件没有，则提示继续打入有效的路径名
{
cout<<"Sorry,文件不存在!"<<endl;
cout<<"请重新输入文件名:";
cin.getline(Filename,n);
fp=fopen(Filename,"r");
}
wnode *wlist;
wlist=new wnode;
wlist->id='#';
wlist->n=0;
wlist->text[0]='\0';
wlist->next=NULL;
wlist=lexcial(wlist);
fclose(fp);
word();
gammarAnalysis(wlist);
ifstream fin("siyuanshi.txt");
string s;
cout<<"输出四元式为："<<endl;
while( getline(fin,s) )
{
cout<< s << endl;
}
return 0;
}
7 软件的测试方法和测试结果
7.1软件的测试方法
程序刚写完时，有几个错误，根据系统的提示，合理设置断点进行调试7.2测试结果
运行程序出现DOS界面，显示所用语法与SLR（1）分析表
输入保存已写好的程序的文件名source.txt,回车键，词法分析生成单词表，语法分析生成语法分析过程和中间代码四元式
条件语句代码：
词法分析单词表：
8设计的特点、不足、收获与体会
8.1特点与不足
在此次课程设计中，我运用C++语言实现了用LR分析方法对条件语句的翻译分析程序设计，最后输出中间代码形式为四元式。

在此次课程设计中，对于词法分析这一块，由于以前在做实验时就做过，所以此次的语法分析只是在以前的基础上添加了一些关键字，没有做太多的改变，因此很快就完成了。

对于语法分析这一块，我感觉是最复杂的。

刚开始对各种字符的判定容易出错，后来我采用先把词法分析来的字符分成关键字和表达式来对待，在语法分析过程中就变简单了些。

对于语义分析这一块，它是结合语法分析同时进行的，这是此次课程设计的最大的特点，在进行规约时我想出了用栈来保存规约出来的信息，使用栈结构可以保证当前进行规约的所有的信息都在栈的顶部，然后将规约后的信息再保存到栈顶，以便进行下一次规约。

这次课程设计的过程中不足主要是在语法分析时，当遇到语法错误时，只能输出出错信息，但是不能指出出错的位置。

对于输入程序中，多重赋值语句的识别还有些问题，在四元式中不会显示出来，而且对于if-else语句的嵌套，四元式会出错，有待改进。

8.2收获与体会
通过这次的课程设计使我在各个方面都得到了很大的提高。

首先，在此次课程设计的初期，查阅了很多的书籍，进而编译原理这门课有了更深的理解，并且对以前遗漏的知识点进行了补充。

并且对LR分析法有了更加深刻的理解，同时也学会了构造SLR(1)分析表。

其次，在此次课程设计的中期，自己对语义分析这一块进行了全面的分析，使我掌握了语法制导翻译的方法。

总之，在这次课程设计后我的理论知识，动手动脑能力，有了一定的提高，经过这次课程设计，我从中学到了很多东西，这是以前在书上学不到的，同时也使我认识到同学之间的相互帮助是多么的重要。

9 参考文献
编译原理（第二版）张素琴主编清华大学出版社
数据结构（C语言版）严蔚敏主编清华大学出版社
C++程序设计闵联营主编清华大学出版社
Visual C++ 编程宝典刘锐宁主编人民邮电出版社
本科生课程设计成绩评定表
班级：计科1006姓名：柯文达学号：0121010340605
及格（60-69分）、60分以下为不及格
指导教师签名：
2013年月日。