编译原理实验

四川师范大学本科实验报告编译器前端的实现

学生姓名杨凌

院系名称数学与软件科学学院专业名称信息与计算科学

班级2008级5班

学号2008070656

指导老师王开端

实验成绩

目录

1．引言 (3)

1.1编译器的概念 (3)

1.2编译器的结构 (3)

1.3编译器的工作原理 (3)

1.4编译器前端 (3)

2．实验的目的、性质 (4)

2.1实验目的 (4)

2.2实验性质 (4)

3．语言假设 (4)

3.1字母表 (4)

3.2词法规则 (4)

3.3语法规则 (6)

4．词法分析 (6)

4.1词法分析器的任务 (6)

4.2数据结构 (6)

4.3代码实现 (7)

4.4实验结果 (12)

5．语法分析 (12)

5.1语法分析任务 (12)

5.2数据结构 (12)

5.3代码实现 (13)

5.4实验结果 (17)

编译器前端的实现

1．引言

计算机之所以能够如此广泛地被应用，应该归功于高级程序设计语言，但是计算机本身只能直接接受由0和1编码的二进制指令和数据，对于高级程序语言书写的程序，则需要先将其翻译成机器所能识别的程序。

1.1编译器的概念

编译器是将用高级语言编写的源程序转换成与之再逻辑上等价的低级语言形式的目标程序。

1.2编译器的结构

编译程序的工作过程是指从输入源程序开始到输出目标程序为止的整个过程。整个编译过程可以划分为五个阶段：词法分析阶段、语法分析阶段、语义分析和中间代码生成阶段、优化阶段和目标代码生成阶段。

1.3编译器的工作原理

编译是从源代码到能直接被计算机执行的目标代码的翻译过程。然而，也存在从低阶语言到高阶语言的编译器，这类编译器中用来从由高阶语言生成的低阶语言代码重新生成高阶语言代码的又被叫做反编译器。也有从一种高阶语言生成另一种高阶语言的编译器，或者生成一种需要进一步处理的的中间代码的编译器。

1.4 编译器前端

前端主要负责解析输入的源代码，由语法分析器和语意分析器协同工作。语法分析器负责把源代码中的‘单词’找出来,语意分析器把这些分散的单词按预先定义好的语法组装成有意义的表达式，语句，函数等等。

2．实验的目的、性质

2.1实验目的

了解和掌握词法分析的原理，明白词法分析的输入和输出，以及怎样对输入的高级语言源程序进行处理。掌握正规表达式和状态转换图，能够熟练地对给定的正规表达式画出其状态转化图。在此基础之上，假定一门高级语言，利用它写好源程序，自己用TurboC为之书写一个词法分析程序，加强对词法分析原理的了解。

2.2实验性质

用类c的语言编写出能使高级程序语言转换成与之在逻辑上等价的低级语言形式的目标程序。

3．语言假设

首先假定需要进行编译的高级语言，用c语言写一个编译程序对其进行编译，将其转化成机器所能识别的低级语言。

3.1字母表

3.2词法规则

在词法分析中用，用状态转换图来识别单词。状态转换图是有限的有向图，结点代表状态，用圆圈表示，结点之间由有向变连接，有向边可标记字符。

状态数是有限的，其中必有一初始状态以及若干终止状态，终止状态的结点用含有实心边的圆圈表示以区别其它状态，下图(a)是词法分析的状态转换图：

返回（id ，id 在符号表中的位置）或返回（保留字，-）

*

num.num 在常熟表中

的位置）

返回（relop ，LE ）

返回（relop ，LT ）

返回（relop ，EQ ）

返回（=，-）

**

图（a ） 状态转换图

3.3语法规则

所能识别的语言有if else 以及while 语言

if else 语句的文法如下： G[S]:S->iESeS|iES|a E->b

其中存在公共左因子，提取公共左因子后得到文法]['

S G ：

]['S G ：a iESS S |'>-

ε|'eS S >-

b E >-

4．词法分析

词法分析是编译的第一个阶段，执行词法分析的程序称为词法分析程序，也称为词法分析器或扫描器。词法分析器的功能是输入源程序，输出单词符号。 4.1词法分析器的任务

从左到右逐个字符地对源程序进行扫描，产生一个个单词符号，把字符串形式的源程序改造成为单词符号串形式的中间程序。 4.2数据结构

存储结构：关键字表、标识符表以及常数表均以结构体数组的方式存储，结构体如下：

typedef struct {

char name[20];//单词符号 int leibie;//种别编码

char help_name[20];//助记符 char location;//内码值

}FuHao;

4.3 代码实现

用TurboC书写的词法分析源程序如下：

#include

#include

typedef struct

{

char name[20];

int leibie;

char help_name[20];

char location;

}FuHao;

int letter(char ch)//判断是否属于字符

{

if((ch>='a' && ch<='z')||(ch >='A' && ch<='Z'))

return 1;

else

return 0;

}

int digit(char ch)//判断是否属于数字

{

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

return 1;

else

return 0;

}

int reserve(char token[20],FuHao keyword[6])//判断是否是保留字{

int i,j,flag=0;

for(i=0;i<6;i++)

{

flag=0;

for(j=0;j

{

if(token[j]!=keyword[i].name[j])

{

flag=0;

break;

}

else

flag=1;

}

if(flag&&keyword[i].name[j]=='')

return 1;

}

return 0;

}

int length(char token[20])

{

int i,len=0;

for(i=0;i<20;i++)

{

if(token[i]!=' ')

len++;

}

return len;

}

void concatenation(char token[20],char ch)//将ch连接到token上{

int len=length(token);

token[len]=ch;

}

int main(void)

{

char ch;

FILE * fp;

char fname[20];

char token[20];

int c;

FuHao keyword[6]={{"int",1,"int",''},{"main",2,"main",''}, {"void",3,"void",''},{"while",4,"while",''},{"printf",5,"print f",''},{"return",6,"return",''}};

FuHao *Identify;

int i,j,len;

char p[150];

clrscr();

printf("fname=");

scanf("%s",fname);

fp=fopen(fname,"r");

i=0;

while((ch=getc(fp))!=EOF)

{

p[i]=ch;

i++;

}

len=i;

i=0;

while(i

{

for(j=0;j<20;j++)

token[j]=' ';

switch(p[i])

{

case 'a':

case 'b':

case 'c':

case 'd':

case 'e':

case 'f':

case 'g':

case 'h':

case 'i':

case 'j':

case 'k':

case 'l':

case 'm':

case 'n':

case 'o':

case 'p':

case 'q':

case 'r':

case 's':

case 't':

case 'u':

case 'v':

case 'w':

case 'x':

case 'y':

case 'z':

case 'A':

case 'B':

case 'C':

case 'D':

case 'E':

case 'F':

case 'G':

case 'H':

case 'I':

case 'J':

case 'K':

case 'L':

case 'M':

case 'N':

case 'O':

case 'P':

case 'Q':

case 'R':

case 'S':

case 'T':

case 'U':

case 'V':

case 'W':

case 'X':

case 'Y':

case 'Z':

concatenation(token,p[i]);

i=i+1;

while(letter(p[i])||digit(p[i]))

{

concatenation(token,p[i]);

i++;

}

i--;

printf("(");

for(j=0;j

printf("%c",token[j]);

printf(",");

c=reserve(token,keyword);

if(c==1)

printf("Key word!)\n");

else

printf("Identifier!)\n");

break;

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

case '8':

case '9':

concatenation(token,p[i]);

i=i+1;

while(digit(p[i]))

{

concatenation(token,p[i]);

i++;

}

i--;

printf("(");

for(j=0;j

printf(",");

printf("num)\n");

break;

case '+':

printf("(+,null)\n");

break;

case '-':

printf("(-,null)\n");

break;

case '*':

printf("(*,null)\n");

break;

case '/':

printf("(/,null)\n");

break;

case '<':

i++;

if(p[i]=='=')

printf("(<=,null)\n");

else

{

i--;

printf("(<,null)\n");

}

break;

case '=':

i++;

if(p[i]=='=')

printf("(EQ,null)\n");

else

{

i--;

printf("(=,null)\n");

}

break;

case ';':

printf("(;,null)\n");

break;

}

i++;

}

return 0;

}

int main(void)

{

int sum=398;

printf("%d",sum);

return 0;

}

4.4实验结果

5．语法分析

语法分析是编译过程的核心部分。再描述程序语言的语法结构时，需要借助上下文无关文法，而文法是描述程序语言的依据。

5.1 语法分析任务

根据语言的语法规则进行语法分析，若不存在语法错误则给出正确的语法结构并为语义分析和代码生成做准备。

5.2数据结构

typedef struct

{

char *base;//栈底

char *top;//栈顶

int StackSize;

}SqStack;

typedef struct

{

char line;//代表矩阵行所对应的非终结符

char column;//代表矩阵列所对应的终结符或界符

char con[20];//产生式

}LAT;

5.3 代码实现

#include

#include

#define INIT_SIZE 40

#define INCREAMENT 5

typedef struct

{

char *base;

char *top;

int StackSize;

}SqStack;

typedef struct

{

char line;

char column;

char con[20];

}LAT;

void Init(SqStack **s)//初始化堆栈

{

(*s)->base=(char *)malloc(INIT_SIZE*sizeof(char)); if(!(*s)->base) exit(-1);

(*s)->top=(*s)->base;

(*s)->StackSize=INIT_SIZE;

return ;

}

void Push(SqStack **s,char ch)//进栈

{

if((*s)->top-(*s)->base>=(*s)->StackSize)

{

(*s)->base=(char

*)realloc((INIT_SIZE+INCREAMENT)*sizeof(char)); if((*s)->base) exit(-1);

(*s)->top=(*s)->base+(*s)->StackSize;

(*s)->StackSize+=INCREAMENT;

}

*(*s)->top=ch;

(*s)->top++;

return ;

}

char Pop(SqStack **s)//出栈

{

char e;

if((*s)->top==(*s)->base) return '@';

e=*(--(*s)->top);

return e;

}

void Show(SqStack **s)//显示栈中的元素

{

char *p;

p=(*s)->base;

for(;p!=(*s)->top;p++)

printf("%c",*p);

return ;

}

int length(char final[])

{

int i=0;

while(final[i]!='\0')

{

i++;

}

return i;

}

int In(char x,char final[])//判断字符x是否是终结符{

int i;

int len=length(final);

for(i=0;i

{

if(x==final[i])

return 1;

}

return 0;

}

char* get_con(char x,char cur_char,LAT ALT[7])//得到产生式

M[x,cur_char] {

int i=0;

for(i=0;i<7;i++)

{

if(ALT[i].line==x&&ALT[i].column==cur_char)

return ALT[i].con;

}

return "error";

}

void ContProc()

{

SqStack *s;

int i=0,j;

char cur_char;

char x;

LAT

ALT[7]={{'A','a',"aB"},{'B','a',"ACi"},{'D','b',"bD"},{'D','i',"n ull"},{'B','d',"null"},{'C','d',"dD"},{'B','#',"null"}};

char in_char[]={'a','a','d','i','#','\0'};

char final[]={'a','b','i','d','#','\0'};

char *con;

s=(SqStack *)malloc(sizeof(SqStack));

if(!s) exit(-1);

Init(&s);

Push(&s,'#');

Push(&s,'A');

printf("stack\tcurrent_char\n");

printf("--------------------------\n");

do

{

Show(&s);

printf("\t|");

x=Pop(&s);

cur_char=in_char[i];

printf("current_char:%c\n",cur_char);

if(In(x,final)==1)

{

if(x==cur_char)

{

if(cur_char!='#')

{

i++;

}

else

{

printf("The input string is legal!\n");

return ;

}

}

else

{

printf("There is some thing wrong with it!\n");

return ;

}

}

else

{

con=get_con(x,cur_char,ALT);

if(strcmp(con,"null")!=0)

{

for(j=length(con)-1;j>=0;j--)

{

Push(&s,con[j]);

}

}

}

}while(x!='#');

return ;

}

int main(void)

{

clrscr();

ContProc();

return 0;

}

5.4 实验结果