编译技术课设 实验报告

课程设计报告

( 2010 -- 2011年度第 1 学期)

名称：编译技术课程设计B

题目：词法分析器设计

算符优先分析程序设计

基于算符优先分析方法的语法制导翻译程序设计院系：计算机系

班级：网络0802

学号：

学生姓名：

指导教师：黄志强阎蕾岳燕

设计周数：1周

成绩：

日期：2010年12月31

一、课程设计的目的与要求

1．词法分析器设计的目的与要求

1.1 词法分析器设计的实验目的

本实验是为计算机科学与技术专业的学生在学习《编译技术》课程后，为加深对课堂教学内容的理解，培养解决实际问题能力而设置的实践环节。通过这个实验，使学生应用编译程序设计的原理和技术设计出词法分析器，了解扫描器的组成结构，不同种类单词的识别方法。能使得学生在设计和调试编译程序的能力方面有所提高。为将来设计、分析编译程序打下良好的基础。

1.2 词法分析器设计的实验要求

设计一个扫描器，该扫描器是一个子程序，其输入是源程序字符串，每调用一次识别并输出一个单词符号。为了避免超前搜索，提高运行效率，简化扫描器的设计，假设该程序设计语言中，基本字（也称关键词）不能做一般标识符用，如果基本字、标识符和常数之间没有确定的运算符或界符作间隔，则用空白作间隔。

单词符号及其内部表示如表1-1所示，单词符号中标识符由一个字母后跟多个字母、数字组成，常数由多个十进制数字组成。单词符号的内部表示，即单词的输出形式为二元式：（种别编码,单词的属性值）。

表1-1 单词符号及其内部表示

2．算符优先分析程序设计的目的和要求

2.1 算符优先分析程序设计的实验目的

本实验是为计算机科学与技术专业的学生在学习《编译技术》课程后，为加深对课堂教学内容的理解，培养解决实际问题能力而设置的实践环节。通过这个实验，使学生应用编译程序设计的原理和技术, 设计、编写和调试算符优先分析程序，了解算符优先分析程序的组成结构，掌握实现通用算符优先分析算法的方法。能使得学生在设计和调试编译程序的能力方面有所提高。为将来设计、分析编译程序打下良好的基础。

2.2 算符优先分析程序设计的实验要求

算符优先分析属于自下而上的分析方法，该语法分析程序的输入是终结符号串（即单词符号串，以一个“#”结尾），如果输入串是句子则输出“YES”，否则输出“NO”和错误信息。

算符优先分析过程与非终结符号无关，当由文法产生了优先关系之后文法也就失去了作用,本题目给出文法的目的是为了便于对语法分析结果进行验证。

(1)文法设算符优先文法G为：

+

→

E|

E

T

T

*

T|

→

F

F

T

↑

→

F|

P

P

F

→

(

i

P|)

E

说明：i为整型常数或者为标识符表示整型变量；使用中↑用**表示。

(2)优先关系表设优先关系表如表1-2所示。

表1-2 优先关系表

3．基于算符优先分析方法的语法制导翻译程序设计的目的和要求

3.1基于算符优先分析方法的语法制导翻译程序设计的实验目的

本实验是为计算机科学与技术专业的学生在学习《编译技术》课程后，为加深对课堂教学内容的理解，培养解决实际问题能力而设置的实践环节。通过这个实验，使学生应用编译程序设计的原理和技术, 通过设计、编写和调试语法制导翻译程序，掌握从一种语句的语法和语义出发，构造相应的语义子程序，实现基于算符优先分析方法的语法制导翻译的方法。能使得学生在设计和调试编译程序的能力方面有所提高。为将来设计、分析编译程序打下良好的基础。

3.2 基于算符优先分析方法的语法制导翻译程序设计的实验要求

算符优先分析方法是通过反复把输入符号移进分析栈，使用优先关系表在分析栈顶寻找最左素短语，将其归约为一个非终结符号而实现的。这个分析过程与非终结符号无关，当由文法产生了优先关系之后文法也就失去了作用（所以本题目无需给出文法）。

基于算符优先分析方法的语法制导翻译是在算符优先语法分析的基础上进行翻译工作（即语义分析），每当将一个最左素短语归约为一个非终结符号时，就调用对应产生式的语义子程序，去完成相应的语义翻译工作，这步归约使用的产生式对非终结符号不加区分（即将所有的非终结符号用一个通用的非终结符号表示）。

语法制导翻译程序的输入是终结符号串（即单词符号串，以一个“#”结尾），如果输入符号串是句子,则按照其语义进行翻译,输出等价的四元式序列（作为练习应显示输出）。

二、课程设计正文

1．词法分析器设计

1.1 以文件流的方式对词法进行输入句子。

1.2 标识符和常数的属性值

（1）标识符和常数的属性值为该单词在名次表或常数表中登机项的相对地址；

（2）当识别出一个标识符或常数时，要查名字表或常数表，若表中有其登记项，则把得到的登记项地址作为其属性值；

（3）若表中没有其登记项，则建立一个新登记项，该登记项地址作为其属性值，此处的地址为在表中的下标。

1.3 主要数据结构

（1）属性类Dog，内含某一单词的显示字符串和类别，类别包括关键字、标识符、常数；

（2）输入缓冲区Buffer[100]，类型为字符型；

（3）关键字表Letter[]，类型为Dog；

（4）标识符表Varible[]，类型为Dog，存储在句子中出现过的标识符；

（5）常数表Constant[]，类型为Dog，存储在句子中出现过的常数；

（6）设置全局变量b，v，c，l记录输入缓冲区、标识符表、常数表、关键字表的当前最后一个指针。

1.4 词法错误处理：出错则显示错误所在字符位置。

2．算符优先分析程序设计

2.1 以文件流的方式对词法进行输入句子。

2.2 主要数据结构

（1）优先关系表XX[]，全局变量，事先设定；

（2）分析栈类Stack，内含数组array[]存储终结符号、“#”、非终结符N，和数组array[]的长度size；

（3）数组str[]，用于存放输入字符串。

2.3 算法主要使用两个while嵌套循环，外层为当前字符a不为#则继续，内层循环当前

字符a与其后一个终结符的相对优先关系为大于时，则进行规约，否则执行移入操作；

2.4 当分析栈中进入‘#’，且分析栈中只剩三个字符时，表示分析成功，否则失败。

2.5 出错则显示错误所在字符位置。

3．基于算符优先分析方法的语法制导翻译程序的设计

3.1 该实验算法是在第二个实验的基础上，将规约后产生的N变为临时变量Ei或中间变量Ti，当产生中间变量的四元式时，则输出该四元式。

3.2 为实现算法，这里用到词法分析的思想，将输入字符串先通过词法分析，转化为各单词的属性值或地址值。此做法便于实现数组的输出和查看。

三、课程设计总结或结论

1．词法分析器设计

在做这个实验以前一直认为编译的词法分析器是计算机内部某个硬件部分。由于该门课程结课较早，有些内容需要重新翻书查找。

通过这次实验，我对之前学过的内容有了更深的理解，了解了扫描器的组成结构、不同种类单词的识别方法，掌握了由单词的语法规则触发、画出识别单词的状态转换图、然后再用程序实现的扫描器设计方法。

2．算符优先分析程序设计

该程序的主要难点在于何时规约和何地规约，以及规约前后对几个指针位置的处理。通过本次实验一定程度上提高了软件开发能力，对编译原理这一门课程也有了比较

深刻的了解，掌握了算符优先分析方法。最后，由于所学知识不够全面，实验在很多方面还有待完善，在以后的学习过程中，会掌握更多知识，力求做到更好。

3．基于算符优先分析方法的语法制导翻译程序的设计

关于语法制导的内容之前未在课堂上有学过，首先锻炼了我的自学能力，通过学习和实践掌握了从一种语句的语法和语义出发，构造相应的语义子程序，实现语法制导翻译的方法。

这个实验有着第二个实验的基础，保持算符优先分析的整体思想，在此基础上利用词法分析器的思想设计了一段模数转换程序，将字符串转换为数字形式。通过自己思考摸索，不断调试，最终使程序得以正常运行。

四、参考文献

[1] 陈火旺，刘春林. 程序设计语言编译原理. 北京：国防工业出版社，第三版. 2008，

9

[2] 宋雨，程晓荣，黄志强. 计算机综合实践指导. 北京：清华大学出版社，第一版.

2004，2

附录（设计流程图、程序、运行结果等）（一）流程图

1．词法分析器设计

2．算符优先分析程序设计

3.基于算符优先分析方法的语法制导翻译程序的设计

（二）程序代码

1．词法分析器设计

#include

#include

#include

#include

using namespace std;

char strToken[20];//存当前构成字符串

class Dog

{

char info[20];

int race;

public:

Dog(char cc[20],int rr)//构造函数

{

strcpy(info,cc);

race=rr;

}

int comp(char ss[20])//比较strToken是否为此类别，否返回0

{

if(strcmp(info,ss)==0)

return race;

return 0;

}

};

char Buffer[100];//输入缓冲区

int b;//Buffer指针

char ch;//当前读进字符

Dog* Varible[20];//符号表

Dog* Constant[20];//常数表

Dog* Letter[20];//已有单词表

int v,c,l;//对应尾指针的后一个

int a[2];

void init0()

{

b=0;

v=0;

c=0;

l=0;

Letter[l++]=new Dog("BEGIN",1);

Letter[l++]=new Dog("IF",2);

Letter[l++]=new Dog("THEN",3);

Letter[l++]=new Dog("ELSE",4);

Letter[l++]=new Dog("END",5);

}

void init()

{

ch=' ';

a[0]=-1;

a[1]=-1;

strcpy(strToken,"");

}

void GetChar()//取当前字符

{

ch=Buffer[b];

b++;

}

void GetBC()//取字符直到不为空格

{

while(ch==' ')

GetChar();

}

bool IsLetter()//判断是否为字母

{

if(ch>='A'&&ch<='Z')

return 1;

else if(ch>='a'&&ch<='z')

return 1;

return 0;

}

bool IsDigit()//判断是否为数字

{

if(ch>='0'&&ch<='9')

return 1;

return 0;

}

void Concat()//把字符连接到当前短语后边

{

strcat(strToken,&ch);

}

void Retract()//回退一个字符

{

ch=' ';

b--;

}

int Reserve()/*整型函数过程，对strToken则可回送0值中的字符串查找保留字表，若它是一个保留字则返回它的编码;否则返回非保留字信息，譬如若0不是保留字的编码*/

{

int i,x;

for(i=0;i

{

x=Letter[i]->comp(strToken);

if(x>0)

return x;

}

return 0;

}

int InsertId()//整型函数过程，将strToken中的标识符插入符号表，返回符号表指针{

Varible[v]=new Dog(strToken,v+1);

v++;

int i=v;

return i;

}

int InsertConst()//整型函数过程，将strToken中的常数插入常数表，返回常数表指针{

Constant[c]=new Dog(strToken,c+1);

c++;

return c;

}

void ProError()

{

cout<

}

void f()//词法分析器

{

int code, value;

init();

// int a[2];//作为return（种别，属性）

GetChar(); GetBC();

if(IsLetter())

{

while (IsLetter()||IsDigit())

{

Concat(); GetChar();

}

Retract();

code=Reserve();

if (code==0)

{

value=InsertId();

a[0]=6;//该单词为标识符

a[1]=value;

return;//return a;

}

else

{

a[0]=code;//该单词为保留字

a[1]=-1;

return;//return a;

}

}

else if (IsDigit())

{

while(IsDigit())

{

Concat();GetChar();

}

Retract();

value=InsertConst();

a[0]=7;//该单词为常数

a[1]=value;

return;//return a;

}

else if (ch=='=')

{

a[0]=8;

a[1]=-1;

return;//return a;

}

else if (ch=='+')

{

a[0]=9;

a[1]=-1;

return;//return a;

}

else if (ch=='*')

{

GetChar();

if (ch=='*')

{

a[0]=11;

a[1]=-1;

return;//return a;

}

Retract();

a[0]=10;

a[1]=-1;

return;//return a;

}

else if (ch==',')

{

a[0]=12;

a[1]=-1;

return;//return a;

}

else if (ch=='(')

{

a[0]=13;

a[1]=-1;

return;//return a;

}

else if (ch==')')

{

a[0]=14;

a[1]=-1;

return;//return a;

}

else ProError(); /*错误处理*/

a[0]=-1;

a[1]=-1;

return;//return a;

}

void disp()

{

char x;

// if(a[0]==-1)

// ProError();

if(a[1]==-1)

{

x='-';

cout<<"("<

}

else

cout<<"("<

void main()

{

init0();

// strcpy(Buffer,"BEGIN IF ELSE abcde 1234");

////////////////////////////////////////////////////////////////////

char in[100]; //用于接收输入文件名

// char str[100];//存句子

FILE *fin; //用于指向输入文件的指针

cout<<"请输入所需文件名(xxx.txt)：";

cin>>in;

while((fin=fopen(in,"r"))==NULL) //判断输入文件名是否正确

{

cout<

cout<<"请重新输入：";

strcpy(in,"");

cin>>in;

}

int m=0;//记录str句子串的长度

char ch1='a';

while (ch1!='#')//从文件中读入一串字符

{

ch1=getc(fin);

Buffer[m++]=ch1;

}

// cin>>Buffer;

int lllong=m-1;

// cout<

while(b

{

init();

f();

disp();

}

cout<

// return;

}

2．算符优先分析程序设计

#include

#include

#include

#include

using namespace std;

const int maxsize=100; //为数组str[]、in[]分配的最大存储空间

const int length=100;//为数组array[]分配的最大存储空间

char XX[8][8]={' ','+','*','!','i','(',')','#',

'+','>','<','<','<','<','>','>',

'*','>','>','<','<','<','>','>',

'!','>','>','<','<','<','>','>',

'i','>','>','>',' ',' ','>','>',

'(','<','<','<','<','<','=',' ',

')','>','>','>',' ',' ','>','>',

'#','<','<','<','<','<',' ','='};

class Stack

{

private:

int size;//size为当前数组array[]的大小

char array[length];//用于存储读入的字符public:

Stack()

{

size=0;//数组array[]的初始长度为0 }

void push(char ch)

{

if(size

{

array[size]=ch;

size++;

}

else//若数组已满，则给出出错信息

cout<<"overflow!"<

}

int pop(char ch[],int len)//弹出字符准备规约{

if(size-len>=0)

{

for(int i=0;i

ch[i]=array[size-len+i];

size-=len;

return len;

}

else

{

cout<<"参数错误!"<

return 0;

}

}

char judge(int pos)//判断大小是否合法

{

if(pos>=0&&pos

return array[pos];

return '\0';

}

void disp_all()//输出当前数组中的字符

{

for(int i=0;i

{

if(judge(i)=='!')

cout<<"**";

else

cout<

}

if(size>7)

cout<<'\t'<<'\t';

else

cout<<'\t'<<'\t'<<'\t';

}

int getsize()//返回当前数组大小

{

return size;

}

};

char guiyue(char ch[])//规约为'N'

{

return 'N';

}

int isnumch(char ch)//判断ch是不是数字或小写字母

{

return (ch>='0'&&ch<='9'||ch>='a'&&ch<='z');

}

int getrank(char ch1,char ch2)//根据算符优先分析矩阵设置读入优先次序

{ //0表示等于，1表示大于，-1表示小于，2表示没有优先关系

int i,j;

if(isnumch(ch1))

ch1='i';

if(isnumch(ch2))

ch2='i';

switch(ch1)

{

case '+':i=1;break;

case '*':i=2;break;

case '!':i=3;break;

case 'i':i=4;break;

case '(':i=5;break;

case ')':i=6;break;

case '#':i=7;break;

}

switch(ch2)

{

case '+':j=1;break;

case '*':j=2;break;

case '!':j=3;break;

case 'i':j=4;break;

case '(':j=5;break;

case ')':j=6;break;

case '#':j=7;break;

}

if(XX[i][j]=='>')

return 1;

else if(XX[i][j]=='<')

return -1;

else if(XX[i][j]=='=')

return 0;

else

return 2;

}

int isvt(char ch)//区别参加规约的资格

{

if(ch>='a'&&ch<='z')

return 1;

if(ch>='0'&&ch<='9')

return 1;

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

{

if(ch==XX[0][i])

return 1;

}

return 0;

}

/****************主函数**************/

void main()

{

cout<<"====================该文法的算符优先矩阵如下==================="<

int i;

for(i=0;i<8;i++) //输出算符优先矩阵

{

for(int j=0;j<8;j++)

{

if(XX[i][j]=='!')

cout<<"**"<<'\t';

else

cout<

}

cout<

}

char in[maxsize]; //用于接收输入文件名

char str[maxsize];//存句子

FILE *fin; //用于指向输入文件的指针

cout<<"请输入所需文件名(xxx.txt)：";

cin>>in;

while((fin=fopen(in,"r"))==NULL) //判断输入文件名是否正确

{

cout<

cout<<"请重新输入：";

strcpy(in,"");

cin>>in;

}

int m=0;//记录str句子串的长度

char ch1='a';

while (ch1!='#')//从文件中读入一串字符

{

ch1=getc(fin);

str[m++]=ch1;

}

str[m]='#';//将'#'赋给字符串尾

Stack s;//定义Stack类的变量s

int len;

len=int(strlen(str));//取出输入字符串的长度

s.push('#');//先把'#'压入数组array[]

int k=s.getsize()-1;//k为当前数组array[]读入已读入字符的位置标识,

int t=0;//t为输入字符串数组str[]即将被读的字符位置标识,

int j;//j用于记录当前数组array[]中的最后一个非终结符的位置

char a=str[0];//a用于传递即将读入的字符

char ch[10];//存规约串

while(a!='#')//如果a不等于'#',则继续读入操作或规约操作

{

a=str[t];

if(a=='*')

{

if(str[t+1]=='*')

{

a='!';

t++;

}

}

if(isvt(s.judge(k)))

j=k;

else

j=k-1;

while(isvt(a)&&getrank(s.judge(j),a)==1)//判断是否满足规约的条件>

{

s.disp_all();//规约后输出当前数组array[]中的字符

int h=j,low=j-1;//h记录要规约的位置，low记录规约后数组array[]中的最qian一个非终结符的位置

if(!isvt(s.judge(low)))

low--;

while(getrank(s.judge(low),s.judge(h))!=-1)//寻找最前一个非终结符的位置用low记录

{

h=low;

low--;

if(!isvt(s.judge(low)))

low--;

}

h=s.getsize();//array的长度

low++;//规约的起始位置

int len=h-low; //len记录要规约的长度

for(int p=0;p<10;p++)

ch[p]='\0';

s.pop(ch,len);//弹出要规约的字符用字符串ch存储

char c=guiyue(ch);//将ch规约为N

s.push(c);//再将规约后的N压入数组中

cout<<" 规约: ";

for(i=0;i

{

if(ch[i]=='!')

cout<<"**";

else

cout<

}

cout<<" --> "<

j=s.getsize()-1;

if(!isvt(s.judge(j)))

j--;

}

// s.disp_all();

if(!(a>='A'&&a<='Z')&&getrank(s.judge(j),a)==2)//当待输入字符不是大写字母且与前一个

{ //非终结符无优先关系则提示出错并给出提示

cout<<"出错!"<

cout<<"错误为第"<

exit(0);

}

else

{

s.disp_all();

if(a=='!')

cout<<"移进: **"<

else

cout<<"移进: "<

s.push(a);//将a压入数组array[]//读入后输出当前数组array[]中的字符

t++;

k=s.getsize()-1;

}

}

s.disp_all();

char temp[10];

s.pop(temp,3);

if(s.getsize()==0)//如果最后数组array[]的长度size的值为0，则分析成功cout<<"成功!"<

else//否则，分析失败

cout<<"失败!"<

fclose(fin);//关闭输入文件

}

3．基于算符优先分析方法的语法制导翻译程序的设计

#include

#include

#include

#include

using namespace std;

typedef class Four *C;

char XX[8][8]={' ','+','*','!','i','(',')','#',

'+','>','<','<','<','<','>','>',

'*','>','>','<','<','<','>','>',

'!','>','>','<','<','<','>','>',

'i','>','>','>',' ',' ','>','>',

'(','<','<','<','<','<','=',' ',

')','>','>','>',' ',' ','>','>',

'#','<','<','<','<','<',' ','='};

const int maxsize=100; //为数组str[]、in[]分配的最大存储空间

const int length=100;//为数组array[]分配的最大存储空间

int digital[maxsize];

int d_len=0;

char B[21];//标识符,b[0]记录最后一个的下标

int E[21];//临时变量,e[0]记录最后一个的下标,1xx为标识符地址，2xx为临时变量地址

C Gama[21];//一个中间变量即一个四元式，gama[i]记录最后一个下标

int a=0,b=0,c=0;//B,E,Gama的最后一个下标

int ATD(char ch);//将单个字符转为为数字

int entry(char ch);//查找ch是否在名字表内，返回名字表内的下标+100，如没有则将其加入表中----------ok

int newtemp(int t[3]);//新建一个临时变量，返回其在临变表中的下标+200

void fuzhi(int m,int n);//m.place:=n.place

int guiyue(int ch[],int ll);//规约为'N'

int getrank(int i,int j);//根据算符优先分析矩阵设置读入优先次序

int isword(char ch);//判断是否为字母//////////////////////////gai!!

void disp_one(int i);//输出单个i代码的字符，标识符或符号

void disp_deep_one(int i);//输出单个i代码的字符，标识符或符号

typedef class Four//四元式

{

char fuhao;//

int s2,s3,s4;//(fuhao,s2,s3,s4)

public:

Four(int f,int a1,int a2)//双目运算符,本题只有双目运算符...a1,a2均为地址位移量

{

fuhao=XX[0][f];

s2=a1;

s3=a2;

s4=c+300;

}

void disp_four()

{

cout<<"产生"<

if(fuhao=='!')

cout<<"**,";

else

cout<

disp_deep_one(s2);

cout<<",";

disp_deep_one(s3);

cout<<",";

disp_deep_one(s4);

cout<<")";

}

void disp_simple()

{

cout<<"(";

if(fuhao=='!')

cout<<"**,";

else

cout<

disp_deep_one(s2);