布尔表达式翻译为逆波兰式的算法实现

学号：

课程设计

题目布尔表达式的翻译程序设计

学院计算机学院

专业软件工程

班级

姓名

指导教师何九周

2012 年 1 月 2 日

布尔表达式的递归下降翻译程序设计

1引言

“编译原理”是一门研究设计和构造编译程序原理和方法的课程，是计算机各专业的一门重要的专业基础课。编译原理这门课程蕴含着计算机学科中解决问题的思路、形式化问题和解决问题的方法，对应用软件和系统软件的设计与开发有一定的启发和指导作用。“编译原理”是一门实践性较强的课程，要掌握这门课程中的思想，就必须要把所学到的知识付诸实践。而课程设计是将理论与实践相互联系的一种重要方式。

2概述

2.1设计题目

布尔表达式的递归下降翻译程序设计

2.2设计目的

课程设计是对学生的一种全面综合训练，是与课堂听讲、自学和练习相辅相成的必不可少的一个教学环节。通常，设计题中的问题比平时的练习题要复杂，也更接近实际。编译原理这门课程安排的课程设计的目的是旨在要求学生进一步巩固课堂上所学的理论知识，深化理解和灵活掌握教学内容，选择合适的数据逻辑结构表示问题，然后编制算法和程序完成设计要求，从而进一步培养学生独立思考问题、分析问题、解决实际问题的动手能力。

2.3设计任务内容

布尔表达式的文法：

B → TB′

B′→ and T B′|ε

T → FT ′

T′→ or FT′|ε

F → not F |true｜false |（B）| i rop i

设计布尔表达式文法，给出该文法的属性文法，用递归下降分析法实现对布尔表达式的翻译，给出翻译的逆波兰式结果。

3设计环境与工具

Visual C++

4设计原则

4.1基本方法

在本程序中，输入一段布尔语句，使用递归下降的方法得到其推到过程，并利用递归下降翻译的方法的到四元式序列，最终根据生成的四元式序列分析得到逆波兰式。

4.2属性文法

B → TB′ B’.in=T.type

B′→ and T B′ B’.in=T.type addtype(and,entry,B.in)

B′→ε B’.val=ε

T → FT T.in=F.type.

T′→ or FT′ T’.in=F.type addtype(or,entry,B.in)

T′→ε T’val=ε

F → not F F.val= not.F.val

F → true F.val=true

F → false F.val=false

F →（B） F.val=B.val

F →i rop i F.val=i.lexval rop i.lexval addtype(i，entry，l.in)

5简要的分析与概要设计

在该程序中，总共包括3个主要功能，第一个功能是对输入的布尔语句进行递归下降的分析，从而得出从文法到该布尔语句的推导过程，第二个功能是使用递归下降的方法，该布尔语句的四元式序列，第三个功能对四元式序列进行扫描并分析每个四元式的结构特点，并据此将四元式转化为逆波兰式。

main 函数的流程图如下：

开始

递归下降分析得到推导过程并输出

递归下降分析得到四元式序列并输出

读四元式并得到逆波兰式并输出

结束

在开始进行本次实验中，本来计划在递归下降分析的过程中就得到逆波兰式，但是经过多次尝试之后总是存在错误，所以采用先得到四元式序列，再根据四元式序列生成逆波兰式这种效率比较低的方法。

6详细的算法描述，框图

6.1主要数据结构的设计

四元式类

在该类中，要包含四元式中的四个元素，运算结果，两个运算数以及一个运算符号

class quad

{

public:

char result[8];

char arg1[8];

char op[8];

char arg2[8];

void print()//输出该四元式

{

cout<

}

}q[20];

Word结构体

这个结构体的对要用来存储单个单词，包括一个字符串成员。struct word

{

char w[10];

void print()

{

cout<

}

}wr[200];

逆波兰式结构体

这个结构体的对象用来存储逆波兰式，它的成员是一个word数组struct nipolan

{

word nibolan[100];

} n;

翻译器类

用来存储翻译过程中的各个变量以及声明主要的函数：

class interpreter

{

private:

ifstream SourceFile;

char buffercode[200];//存放源码的缓冲区

int syn;

int current;//buffercode中当前读到的字符下标

char token[8];//记录当前读到的单词

public:

void scaner();

void B();

void B1();

void T();

void F();

void T1();

void run();

void read();

void bolon();

void toword();

char *factor();

char *expression();

char *term();

void bolan();

void reset()

{

current=0;

};

void run1()

{

scaner();

expression();

};

};

源程序：

/*

B TB′

B′ and T B′|ε T FT ′

T′ or FT′|ε

F not F |true｜false |（B）| i rop i

*/

#include

#include

#include

int kk;

int tear=51;

int head=50;

int numberoftemp=0;

int numberofquad=0;

class quad

{

public:

char result[8];

char arg1[8];

char op[8];

char arg2[8];

void print()

{

cout<

}

}q[20];

void qemit(char a[],char b[],char c[],char d[])

{

strcpy(q[numberofquad].result,a);

strcpy(q[numberofquad].arg1,b);

strcpy(q[numberofquad].op,c);

strcpy(q[numberofquad].arg2,d);

numberofquad++;

}

char* newtemp()

{

char *p;

int temp=numberoftemp;

p=new char[8];

p[0]='t';

for(int i=0;;i++)

{

p[++i]=char(temp%10+48);

temp=temp/10;

if (temp==0) {p[i+1]='\0'; break;} }

numberoftemp++;

return p;

};

struct word

{

char w[10];

void print()

{

cout<

}

}wr[200];

struct nipolan

{

word nibolan[100];

} n;

int tcount=0;

int wcount=0;

char *rwtab[9]={"true","not","false","(",")","rop","i","or","and"}; class tuidao

{

public:

char a[10];

char b[10];

char c[10];

char d[10];

void emit(char *m,char *n,char *p,char *q);

void print() {cout<"<

}t[100];

void tuidao::emit(char *m,char *n,char *p,char *q)

{

strcpy(a,m);

strcpy(b,n);

strcpy(c,p);

strcpy(d,q);

}

class interpreter

{

private:

ifstream SourceFile;

char buffercode[200];

int syn;

int current;

char token[8];

public:

void scaner();

void B();

void B1();

void T();

void F();

void T1();

void run();

void read();

void bolon();

void toword();

char *unit();

char *expression();

char *term();

void bolan();

void reset()

{

current=0;

};

void run1()

{

scaner();

expression();

};

};

void bolan()

{

strcpy(n.nibolan[tear].w,q[0].arg1);tear++;

strcpy(n.nibolan[tear].w,q[0].arg2);tear++;

strcpy(n.nibolan[tear].w,q[0].op);tear++;

for(int i=0;i

{

for (int j=i-1;j>=0;j--)

{

if (strcmp(q[i].arg1,q[j].result)==0)

{

if (strcmp(q[i].arg2,q[j+1].result)==0) {strcpy(n.nibolan[tear].w,q[i].op);tear++;break;}

else

{

strcpy(n.nibolan[tear].w,q[i].arg2);tear++;

strcpy(n.nibolan[tear].w,q[i].op);tear++;

break;

}

}

if

((strcmp(q[i].arg1,q[j].result)!=0)&&(strcmp(q[i].arg2,q[j+1].result) ==0))

{

strcpy(n.nibolan[tear].w,q[i].op);tear++;

strcpy(n.nibolan[head].w,q[i].arg1);head--;

break;

}

if

((strcmp(q[i].arg1,q[j].result)!=0)&&(strcmp(q[i].arg2,q[j].result)!= 0))

{

strcpy(n.nibolan[tear].w,q[i].arg1);tear++;

strcpy(n.nibolan[tear].w,q[i].arg2);tear++;

strcpy(n.nibolan[tear].w,q[i].op);tear++;

break;

}

}

}

}

void interpreter::toword()

{

current=0;

int i=0;

while (buffercode[current]!='#')

{

scaner();

strcpy(wr[wcount].w,token);

wcount++;

i++;

}

};

void interpreter::read()

{

cin.getline(buffercode,200);

cout<

}

void interpreter::run()

{

current=0;

{

scaner();

B();

}

}

void interpreter::B()

{

t[tcount].emit("B"," ","T","B'");

tcount++;

T();

B1();

}

void interpreter::B1()

{

if

(strcmp(token,rwtab[8])==0){t[tcount].emit("B'","and","T","B'");tcoun t++;scaner();T();B1();scaner();}

else t[tcount].emit("B'","empty","","");

}

void interpreter::T()

{

t[tcount].emit("T","","F","T'");

tcount++;

F();

T1();

}

void interpreter::T1()

{

if

(strcmp(token,rwtab[7])==0){t[tcount].emit("T'","or","F","T''");tcoun t++;scaner();F();T1();}

else t[tcount].emit("T'","empty","","");

}

// F not F |true｜false |（B）| i rop i

void interpreter::F()

{

if(strcmp(token,rwtab[1])==0){t[tcount].emit("F","not","F","");tc ount++;scaner();F();}

else

if(strcmp(token,rwtab[0])==0){t[tcount].emit("F","","true","");tcount ++;scaner();}

else if(strcmp(token,rwtab[2])==0) {t[tcount].emit("F","","false","");tcount++;scaner();}

else

if(strcmp(token,rwtab[3])==0){t[tcount].emit("F","(","B",")");tcount+ +;scaner();B();}

else

if(strcmp(token,rwtab[6])==0){t[tcount].emit("F","i","rop","i");tcoun t++;scaner();scaner();scaner();}

}

void interpreter::scaner()

{

int m=0;

for(int i=0;i<8;i++) token[i]=' ';

while (buffercode[current]==' ') current++;

if(((buffercode[current]>='a')&&(buffercode[current]<='z'))||((bu

ffercode[current]>='A')&&(buffercode[current]<='Z')))

{

while

((((buffercode[current]>='a')&&(buffercode[current]<='z'))||((bufferc ode[current]>='A')&&(buffercode[current]<='Z')))||((buffercode[curren t]>='0')&&(buffercode[current]<='9')))

{

token[m]=buffercode[current];m++;

current++;

}

token[m++]='\0';

}

else if (buffercode[current]=='(') {token[0]='(';token[1]='\0';current++;}

else if (buffercode[current]==')') {token[0]=')';token[1]='\0';current++;}

}

char*interpreter::expression()

{

char *tp,*ep2,*eplace,*tt;

tp=new char[8];

ep2=new char[8];

eplace=new char[8];

tt=new char[8];

strcpy(eplace,term());

while(strcmp(token,"or")==0)

{

strcpy(tt,token);

scaner();

strcpy(ep2,term());

strcpy(tp,newtemp());

qemit(tp,eplace,tt,ep2);

strcpy(eplace,tp);

}

return eplace;

}

char*interpreter::term()

{

char *tp,*ep2,*eplace,*tt;

tp=new char[8];

ep2=new char[8];

eplace=new char[8];

tt=new char[8];

strcpy(eplace,unit());

while (strcmp(token,"and")==0)

{

strcpy(tt,token);

scaner();

strcpy(ep2,unit());

strcpy(tp,newtemp());

qemit(tp,eplace,tt,ep2);

strcpy(eplace,tp);

}

// scaner();

return eplace;

}

char* interpreter::unit()

{

char *fplace;

fplace=new char[8];

if ((strcmp(token,"true")==0)||(strcmp(token,"false")==0)) {

strcpy(fplace,token);

scaner();

}

if(strcmp(token,"i")==0)

{strcpy(fplace,newtemp());qemit(fplace,"i","rop","i");}

if(strcmp(token,"(")==0)

{

scaner();

strcpy(fplace,expression());

if (syn==28){return fplace;}

}

if(strcmp(token,"not")==0)

{

char *fplace1=new char[8];

scaner();

if (strcmp(token,"(")==0)

strcpy(fplace1,expression());

else strcpy(fplace1,token);

strcpy(fplace,newtemp());qemit(fplace,"","not",fplace1);

if (syn==28){return fplace;}

}

// else{error(4);}

return fplace;

}

void main()

{

interpreter in;

cout<<"请输入源代码:"<

in.read();

in.run();

cout<<"推导过程为："<

for(int i=0;i

t[i].print();

in.toword();

cout<<"分析的单词为："<

for (i=0;i

wr[i].print();

cout<

cout<<"四元式为："<

in.reset();

// cout<<"here"<

in.run1();

for(i=0;i

q[i].print();

cout<<"逆波兰式为:"<

bolan();

for(i=head;i

cout<

cout<

}

6.2全局变量设计

int tear=51;//逆波兰式尾部

int head=50;//逆波兰是首部

int numberoftemp=0;//临时变量个数

int numberofquad=0;//四元式个数

6.3递归下降得到推导过程

根据递归下降的思想，对于文法中的每个非终结符编写一个函数，每个函数的功能是识别由该非终结符所表示的语法成分。由于描述语言的文法常常是递归定义的，因此相应的这组函数必然以相互递归的方式进行调用。该过程的基本思想为每执行一个非终结符对应的函数就根据读入的单词符号来写入该非终结符对应的推出式。

该功能的入口函数run1的流程图如下：

开始

scaner()

B()

end

非终结符B对应的函数B（）

该函数首先要写入B=>TB’，然后执行T（）与B1（）

流程图为

非终结符T对应的函数T（）

该函数首先要写入T=>FT’，然后执行F（）与T1（）

流程图为：

非终结符B’对应的函数B1（）

在该函数中如果读入的下一个单词是“and”则写入B’=>and T B’.否则，要写入B’推出了空串。