LR(1)实验报告

编译原理

ＬＲ（１）语法分析

09计算机（2）班

组员：

张清风030902233

刘冰静030902241

郑珊珊030902245

郭俊杰030902206

实验二：语法分析实验

I. 【实验目的】

根据给出的文法编制LR（1）分析程序，以便对任意输入的符号串进行分析。本次实验的目的主要是加深对LR（1）分析法的理解。

Ⅱ.【实验内容】

对所给语言文法，构造LR(1)分析表，编制语法分析程序，要求将错误信息输出到语法错误文件中，并输出分析句子的过程（显示栈的内容）；

实验报告必须包括采用的文法，设计的思路，LR(1)分析表，以及测试报告（输入测试例子，输出结果），设计的体会。

III.【要求的文法内容】

i. 设计简要描述

LR(1)分析表的构建：

1、调整后的文法计非终结符的first集：

2、项目集的构建

（部分展示总共有157个）：

3、语法分析输出Action表：（总共有157项）：

4、语法分析goto表：

PS：部分展示

ii :

设计思路：

1、先是进行文法的整理；采用数组的方式对文法进行存储，还有做好相关的标识；

2、构建LR(1)语法分析器，首先需要求得各个非终结first集，以便后期采用到根据搜索符进行规约判断。

3、通过分析所存储文法的数组以及相关的first集的相关标识数组，进行构建项目集。整合语法分析表。包括action表和goto表。

4、结合词法分析器得到所语法分析的输入词素，根据所构建的分析表，进行自底向上的语法分析。

5、规约得到“Accept”!

iii. 详细设计描述

项目构架：

iv. 结果分析（原始图示）

测试的源代码：实验结果：（部分截图）

V.具体分析：（部分代码展示）

变量：

/*first集,first[α][b]为真

表示b在first(α)集中*/

bool first[200][200];

int GOTO[300][300];

struct action_node

{ int v;

int op;

/*1移入2规约3接受*/ } ACTION[300][300];

/*终结符/非终结符

与编号映射增广S'编号为0*/ mapstr_map; string strs[1000];

int str_cnt = 0;

/*文法A->αβγ...*/

int G[100][100];

int G_len[100],G_rows;

int G_type[1000];

/*1 非终结符2 终结符0其他*/ int vt_list[1000],vt_cnt;

int vn_list[1000],vn_cnt;

/*项[A->α·Bβ,a]*/

struct item_node

{ int gram_id;/*第几行文法0开始*/

int dot;

/*原点在第几个符号前面0开始*/

int ahead_id; /*向前看符号*/

bool operator ==(const item_node &b)const

{return gram_id == b.gram_id && dot == b.dot && ahead_id == b.ahead_id; } }; /*项集*/

struct itemset_node{

item_node list[100];

int added[100][100];

int length;

}C[300];

int C_cnt = 0;

/*项集族*/

struct items_node{

itemset_node I[100]; };

Main函数：

int main()

{ ifstream ifile,ifile1;

ofstream ofile,ofile2,ofile3;

ifile.open("语法输入_文法表示.txt");

read_G(ifile);

get_first();

ofile.open("语法输出_项集族.txt");

ofile2.open("语法输出_GOTO表.txt");

ofile3.open("语法输出_ACTION 表.txt");

get_items(ofile,ofile2,ofile3);

ifile1.open("语法输入_词素列表.txt");

go(ifile1);

scanf(" ");

}

/*读入文法*/

void read_G(ifstream &ifile){

int str_id = 0;

string str;

str_map.clear();

memset(G_type,0,sizeof(G_type));

vt_list[0] = 2;

vt_cnt = 1;

/*增广文法*/

strs[0] = ""; /* 增广S'*/

strs[1] = "<$>"; /* 结束$ */

strs[2] = "<ε>"; /* 空ε*/

str_map["<$>"] = 1; str_map["<#>"] = 2;

str_cnt = 2;

G[0][0] = 0;/*S' -> S*/

G[0][1] = str_cnt+1;

G_len[0] = 2;

G_rows = 1;

while(ifile >> str){

if((str_id = str_map[str]) == 0){

str_id = str_map[str] = ++str_cnt;

strs[str_cnt] = str;

G_type[str_id] = 1; /*非终结符*/

vn_list[ vn_cnt++ ] = str_id; } G[ G_rows ][0] = str_id;

G_len[ G_rows ] = 1;

ifile >> str;

while(ifile >> str){

if(str == "<$>")break;

if((str_id = str_map[str]) == 0){

str_id = str_map[str] = ++str_cnt;

strs[str_cnt] = str;

if(str != "<>" && str[0] == '<' && str[str.length()-1] == '>'){

G_type[str_id] = 1; /*非终结符*/

vn_list[ vn_cnt++ ] = str_id; } else{

G_type[str_id] = 2; /*终结符*/

vt_list[ vt_cnt++ ] = str_id; } }

G[ G_rows ][ G_len[G_rows]++ ] = str_id;

}G_rows++; }

cout<<"输入语法:"<

for(int i=0;i

cout< ";

for(int j=1;j

cout<

cout<

/*获取first集*/

void get_first(){

bool flag1 = true, flag2;

int i, j, k, x, y;

memset(first, 0, sizeof(first));

while(flag1)

{ flag1 = false;

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

{ x = G[i][0];

for(j = 1, flag2 = true; flag2 && j < G_len[i]; j++) {

flag2 = false; y = G[i][j];

if(G_type[y] == 1)

/* 如果是非终结符*/

{for(k = 0;k < vt_cnt;k++)

if(vt_list[k]!=2&&first[y][vt_list[k]]

== true && first[x][vt_list[k]] ==

false){

first[x][vt_list[k]] = true;

flag1 = true; }

if(first[y][2]){flag2 = true; }

}else if(first[x][y] == false){/* 如

果第一个是终结符,加入first[x]

集*/

first[x][y] = true; flag1 = true;} }

/*如果first[Y]都含有ε,将ε加入

first[x]集*/

if(flag2 == true && j == G_len[i]

&& first[x][2] == false)

{ first[x][2] = true; flag1 =

true; } }

/*在屏幕上打印输出first集*/

cout<

集:"<

/*获得项目*/

void get_closure(itemset_node &I){

bool flag = true;

int i,j,k,A,B,beta;

item_node add_item;

int first_buf[1000],first_buf_len = 0;

while(flag){

flag = false;

for(i=0;i

/*I中每个项I.list[i] [A -> α·Bβ,a] */

A = I.list[i].gram_id; /*A -> α·Bβ*/

if(I.list[i].dot+1

B = G[ A ][ I.list[i].dot+1 ]; memset(first_buf,0,sizeof(first_buf));

get_first_buf(A,I.list[i].dot,I.list[i].ahead_id,first_bu f,first_buf_len);

for(j=1;j

if(G[j][0] == B){

/*所有B -> γ*/

for(k = 0;k

if(!I.added[j][ first_buf[k] ]){

add_item.gram_id = j;

add_item.dot = 0;

add_item.ahead_id = first_buf[k];

I.list[I.length++] = add_item;

I.added[j][ first_buf[k] ] = true;

flag = true; }}}}} }

/*获得项目集*/

voidget_items(ofstream&ofile,ofstream

&ofile2,ofstream &ofile3){

int flag = true,X,i,j,A;

memset(GOTO,0,sizeof(GOTO));

memset(ACTION,0,sizeof(ACTION));

/*初始化C*/

C[0].length = 1;

item_node tmp; tmp.gram_id = 0;

tmp.dot = 0; tmp.ahead_id = 1;

C[0].list[0] = tmp;

memset(C[0].added,0,sizeof(C[0].added));

C_cnt = 1;get_closure(C[0]);

while(flag){ flag = false;

for(i=0;i

for(X = 3;X<=str_cnt;X++)

{get_goto(i,X); } } }

for(i=0;i

print_closure(C[i],i,ofile);

ofile<

for(i=0;i

for(X = 3;X<=str_cnt;X++){

if(G_type[X]==1)

ofile2<

else if(G_type[X]==2&&GOTO[i][X]) {

ACTION[i][X].op = 1;

ACTION[i][X].v = GOTO[i][X];} } }

ACTION[1][1].op = 3;

ACTION[1][1].v = 0;

for(i=0;i

for(j=0;j

{A = C[i].list[j].gram_id;

if(A!=0 && (C[i].list[j].dot+1 >= G_len[A] || C[i].list[j].dot+2==G_len[A]&&G[A][C[i].list[j].dot+1 ]==2)){

ACTION[i][C[i].list[j].ahead_id].op = 2;

ACTION[i][C[i].list[j].ahead_id].v = A;}}}

for(i=0;i

for(X = 1;X<=str_cnt;X++){

if(ACTION[i][X].op)

{ofile3<

ofile3<

if(ACTION[i][X].op==1)ofile3<<"移入";

else if(ACTION[i][X].op==2)ofile3<<"规约";

else if(ACTION[i][X].op==3) ofile3<<"接受";

ofile3<

}}}

/*进行规约分析*/

int go(ifstream &ifile){

string str;

int stack[1000],ss[1000],st2[1000],top= 0,top2 = 0;

int status = 0;

int str_id,v,op,len,i,flag;

stack[0]=1;

ss[0]=0;

top = 1;

while(ifile>>str){

str_id = str_map[str];

flag = true;

st2[0] = str_id;

top2 = 1;

while(top2){

flag = false;

str_id = st2[top2-1];

cout<

if(G_type[str_id] == 1){

stack[top] = str_id;

status= GOTO[status][str_id];

ss[top++] = status;

top2--;}

else{

v = ACTION[status][str_id].v;

op = ACTION[status][str_id].op;

if(op==1){

stack[top] = str_id;

ss[top++] = v;

status = v;

top2--;

}

else if(op==2){

len = G_len[v]-1;

if(len ==1 && G[v][1] == 2)

{ len = 0; }

while(len--){top--;}

status=ss[top-1];

st2[top2++] = G[v][0];

flag = true;

}

else if(op==3)

{ cout<<"Accept!"<

top2--; }

else

{cout<<"Wrong!"<

top2--; }}

scanf("%*c");

cout<

for(i=0;i

cout<

cout<

cout<

for(i=0;i

cout<

cout<

}

}

return 0;

}

IV、实验的评价、收获与体会

做了这个实验以后主要有以下几点收获：

1. 通过本次实验，初步掌握了语法分析的基本方法。由于本次实验确实有一定难度，使我们在不断调试中，进一步理解了lr（1）算法，对闭包和goto（）函数都有了更进一步的认识。对于编译器的分层结构也有了更深一步的了解。

2．学会了从整体把握程序中的函数，更深入地理解了C中数组的应用；在分析过程中，我们出现了许多错误，其中很大部分是在运用c的问题，因此，通过实验感觉到不仅应该加强现在所学知识的应用，还要定时复习以前的知识，补缺补漏，只有基础稳固了，才能为今后的发展提供有力的保证。

3、通过写程序，不仅使自己发现了不足之处，培养了细心严谨的态度，以及发现问题，分析问题，解决问题的能力，而且使自己可以把程序带到实际的应用中，对于所学的知识融会贯通。