北邮编译原理自底向上语法分析实验报告.docx

资源描述

北邮编译原理自底向上语法分析实验报告.docx

《北邮编译原理自底向上语法分析实验报告.docx》由会员分享，可在线阅读，更多相关《北邮编译原理自底向上语法分析实验报告.docx（13页珍藏版）》请在冰豆网上搜索。

北邮编译原理自底向上语法分析实验报告.docx

北邮编译原理自底向上语法分析实验报告

--本页仅作为文档封面，使用时请直接删除即可----内页可以根据需求调整合适字体及大小--

北邮-编译原理-自底向上语法分析实验报告（总13页）

自底向上语法分析器实验报告

一．问题描述

编写语法分析程序，实现对算术表达式的语法分析。

要求所分析算术表达式由如下的文法产生。

E->E+T|E-T|T

T->T*F|T/F|F

F->id|（E）|num

实验要求：

在对输入表达式进行分析的过程中，输出所采用的产生式。

编写语法分析程序实现自底向上的分析，要求如下：

（1）构造识别所有活前缀的DFA。

（2）构造LR分析表。

（3）编程实现算法，构造LR分析程序。

二．算法思想

1.大体步骤：

（1）根据题目所给出的文法构造相应的拓广文法，并求出该文法各非终结符的FIRST、FOLLOW集合；

（2）.构造拓广文法的项目集规范族，并构造出识别所有前缀的DFA；

（3）构造文法的LR分析表；

（4）由此构造LR分析程序。

2.数据结构：

1.输入缓冲区为一个字符型数组，读入输入的算术表达式并保存在此，以’$’结束；

2.构建一个相对应的整型数组，将输入缓冲区中的字符转换为相应的代号并保存；

3.构造一个结构体，以保存文法的某个产生式，该结构包括三个元素：

整形变量，保存产生式左部非终结符代号。

整型数组，保存产生式右部字符串的代号。

整型变量，保存产生式右部长度；

4.定义该结构的数组，保存文法的所有产生式；

5.定义两个二维整形数组，goto和action，其值大于零代表移进操作，小于零代表规约操作，引进的状态或规约用到的产生式又绝对值表示。

等于零代表出现错误。

等于特殊值999代表acc.状态。

3.计算过程：

文法对应的拓广文法为：

1S->E

2E->E+T

3E->E-T

4E->T

5T->T*F

6T->T/F

7T->F

8F->（E）

9F->id

10F->num

求的各个非终结符的FIRST、FOLLOW集合为：

FIRST（S）={id,num,（}FOLLOW（S）={$}

FIRST（E）={id,num,（}FOLLOW（E）={$,+,-,）}

FIRST（T）={id,num,（}FOLLOW（T）={$,+,-,*,/,）}

FIRST（F）={id,num,（}FOLLOW（F）={$,+,-,*,/,）}

构造项目集规范族：

I0=closure（{S->·E}）={S->·E,E->·E+T,E->·E-T,E->·T,T->·T*F,T->·T/F,T->·F,F->·id,F->·（E）,F->·num};

从I0出发：

I1=go（I0,E）=closure（{S->E·,E->E·+T,E->E·-T}）={S->E·,E->E·+T,E->E·-T};

I2=go（I0,T）=closure（{E->T·,T->T·*F,T->T·/F}）={E->T·,T->T·*F,T->T·/F};

I3=go（I0,F）=closure（{T->F·}）={T->F·};

I4=go（I0,id）=closure（{F->id·}）={F->id·};

I5=go（I0,（）=closure（{F->（·E）}）={F->（·E）,E->·E+T,E->·E-T,E->·T,T->·T*F,T->·T/F,T->·F,F->·id,F->·（E）,F->·num};

I6=go（I0,num）=closure（{F->num·}）={F->num·};

从I1出发：

I7=go（I1,+）=closure（{E->E+·T}）={E->E+·T,T->·T*F,T->·T/F,T->·F,F->·id,F->·（E）,F->·num};

I8=go（I1,-）=closure（{E->E-·T}）={E->E-·T,T->·T*F,T->·T/F,T->·F,F->·id,F->·（E）,F->·num};

从I2出发：

I9=go（I2,*）=closure（{T->T*·F}）={T->T*·F,F->·id,F->·（E）,F->·num};

I10=go（I2,/）=closure（{T->T/·F}）={T->T/·F,F->·id,F->（E）,F->·num};

从I5出发：

I11=go（I5,E）=closure（{F->（E·）,E->E·+T,E->E·-T}）={F->（E·）,E->E·+T,E->E·-T};

从I7出发：

I12=go（I7,T）=closure（{E->E+T·,T->T·*F,T->T·/F}）={E->E+T·,T->T·*F,T->T·/F};

从I8出发：

I13=go（I8,T）=closure（{E->E-T·,T->T·*F,T->T·/F}）={E->E-T·,T->T·*F,T->T·/F};

从I9出发：

I14=go（I9,F）=closure（{T->T*F·}）={T->T*F·};

从I10出发：

I15=go（I10,F）=closure（{T->T/F·}）={T->T/F·};

从I11出发：

I16=go（I11,））=closure（{F->（E）·}）={F->（E）·};

下面构造文法的LR分析表：

goto[0,E]=1;goto[0,T]=2;goto[0,F]=3;

action[0,id]=S4;action[0,（]=S5;action[0,num]=S6;

action[1,$]=ACC.;action[1,+]=S7;action[1,-]=S8;

;

action[2,）]=action[2,+]=action[2,-]=action[2,$]=R4;

action[2,*]=S9;action[2,/]=S10;

action[3,）]=action[3,+]=action[3,-]=action[3,*]=action[3,/]=action[3,$]=R7;

action[4,）]=action[4,+]=action[4,-]=action[4,*]=action[4,/]=action[4,$]=R8;

goto[5,E]=11;goto[5,T]=2;goto[5,F]=3;

action[5,id]=S4;action[5,（]=S5;action[5,num]=S6;

action[6,）]=action[6,+]=action[6,-]=action[6,*]=action[6,/]=action[6,$]=R10;

goto[7,T]=12;goto[7,F]=3;

action[7,id]=S4;action[7,（]=S5;action[7,num]=S6;

goto[8,T]=13;goto[8,F]=3;

action[8,id]=S4;action[8,（]=S5;action[8,num]=S6;

goto[9,F]=14;

action[9,id]=S4;action[9,（]=S5;action[9,num]=S6;

goto[10,F]=15;

action[10,id]=S4;action[10,（]=S5;action[10,num]=S6;

action[11,）]=S16;action[11,+]=S7;action[11,-]=S8;

action[12,）]=action[12,+]=action[12,-]=action[12,$]=R2;action[12,*]=S9;action[12,/]=S10;

action[13,）]=action[13,+]=action[13,-]=action[13,$]=R3;action[13,*]=S9;action[13,/]=S10;

action[14,）]=action[14,+]=action[14,-]=action[14,*]=action[14,/]=action[14,$]=R5;

action[15,）]=action[15,+]=action[15,-]=action[15,*]=action[15,/]=action[15,$]=R6;

action[16,）]=action[16,+]=action[16,-]=action[16,*]=action[16,/]=action[16,$]=R9;

（1）分析表为：

E1:

缺少运算对象。

认为加入一个Id入栈并转移至相应状态

E2:

括号不匹配删掉右括号，则删去右括号并转移至相应状态

E3:

缺少运算符，添加运算符并转移至相应状态

action

goto

（

）

num

Acc.

s10

r10

s16

s10

三、实验程序设计说明

1.主要函数说明

voidTRANS（）;/*将读入的buffer数组内容按字符转换为相应代号存入code数组*/

voidGetFromCode（）;/*取得当前输入符号串的元素*/

voidPUSH（intA,intS）;/*入栈操作*/

voidPOP（）;/*出栈操作*/

voidSHITF（）;/*移入操作*/

voidREDUCE（）;/*规约操作*/

voidACC（）;/*接受操作*/

voidERROR（）;/*错误处理*/

voidE1（）;/*错误处理*/

voidE2（）;

voidE3（）;

2.源程序代码

#include<>

intsymbol,status;/*移入或规约时压入分析栈的符号、移入或规约操作后转而进入的状态*/

intanalysis_stack[50];/*定义分析栈*/

intip=-1;/*ip为栈顶元素下标*/

charbuffer[30];/*将输入符号串w保存于数组中*/

intcode[30];/*将读入的字符串转换为代号形式*/

intposition=0;/*position为code数组的下标*/

intX;/*X为当前获取的输入符号的代号*/

intflag=1;/*循环标志*/

typedefstruct{/*定义文法产生式的结构*/

intVn;/*文法产生式的左部非终结符的代码*/

intStr[4];/*文法产生式右部的代码串*/

intsize;/*文法产生式右部的长度*/

}G;

Gproduction[11]={/*该文法的所有产生式*/

{0},

{101,{0,102},1},/*S->E*/

{102,{0,102,3,103},3},/*E->E+T*/

{102,{0,102,4,103},3},/*E->E-T*/

{102,{0,103},1},/*E->T*/

{103,{0,103,5,104},3},/*T->T*F*/

{103,{0,103,6,104},3},/*T->T/F*/

{103,{0,104},1},/*T->F*/

{104,{0,7},1},/*F->id*/

{104,{0,1,101,2},3},/*F->（E）*/

{104,{0,8},1},/*F->num*/

};

intGOTO[17][5]={/*LR分析表goto*/

{0,0,1,2,3},/*0*/

{0,0,0,0,0},/*1*/

{0,0,0,0,0},/*2*/

{0,0,0,0,0},/*3*/

{0,0,0,0,0},/*4*/

{0,0,11,2,3},/*5*/

{0,0,0,0,0},/*6*/

{0,0,0,12,3},/*7*/

{0,0,0,13,3},/*8*/

{0,0,0,0,14},/*9*/

{0,0,0,0,15},/*10*/

{0,0,0,0,0},/*11*/

{0,0,0,0,0},/*12*/

{0,0,0,0,0},/*13*/

{0,0,0,0,0},/*14*/

{0,0,0,0,0},/*15*/

{0,0,0,0,0}/*16*/

};

intACTION[17][9]={/*LR分析表action*/

{51,5,52,51,51,51,51,4,6},n",x）;

}

voidREDUCE（）{/*规约操作*/

intx,y,z;

x=-ACTION[analysis_stack[ip]][X];/*查找action表以确定当前规约操作，即用哪个产生式规约*/

printf（"r%d\tReduceby\t",x）;

switch（production[x].Vn）{

case101:

printf（"S->"）;break;

case102:

printf（"E->"）;break;

case103:

printf（"T->"）;break;

case104:

printf（"F->"）;break;

}

for（inti=1;i<=production[x].size;i++）{

POP（）;/*将栈中元素，按规约产生式的右部长度进行弹出操作*/

switch（production[x].Str[i]）{

case0:

printf（"$"）;break;

case1:

printf（"（"）;break;

case2:

printf（"）"）;break;

case3:

printf（"+"）;break;

case4:

printf（"-"）;break;

case5:

printf（"*"）;break;

case6:

printf（"/"）;break;

case7:

printf（"id"）;break;

case8:

printf（"num"）;break;

case101:

printf（"S"）;break;

case102:

printf（"E"）;break;

case103:

printf（"T"）;break;

case104:

printf（"F"）;break;

}

printf（"\n"）;

y=GOTO[analysis_stack[ip]][production[x].Vn-100];/*查找goto表以确定规约完成后需要转换的状态*/

PUSH（production[x].Vn,y）;/*将规约产生式的左部压入栈中，并将相应的转移状态压入栈中*/

}

voidACC（）{

flag=0;

printf（"ACC!

\n"）;

}

voidE1（）

{序测试与运行结果：

测试用例：

35$

测试用例：

x+y$

测试用例：

40+6*（3-sum/x）$

测试用例：

10*3++4$（错误的事例）

测试用例：

7+6）+6$（错误的事例）

测试用例：

6*7（+4$（错误的事例）

四．心得体会以及完成的功能

展开阅读全文