北邮大三上-编译原理-语义分析实验报告

编译原理第六章语义分析

班级：09211311

学号：

姓名：schnee

目录

1. 实验题目和要求 (3)

2. 实验分析和思考 (3)

3. 翻译方案 (4)

4. LR实现自底向上分析（摘自语法分析实验） (5)

4.1.构造识别所有活前缀的DFA (5)

4.2.构造LR分析表 (6)

5. S属性定义的自底向上实现 (7)

5.1.扩充分析栈 (7)

5.2.改造分析程序 (7)

5.3.编程实现 (7)

6. 运行结果截图： (13)

1. 实验题目和要求

题目：语义分析程序的设计与实现。

实验内容：编写语义分析程序，实现对算术表达式的类型检查和求值。要求所分析算术表达式由如下的文法产生。

num

E id

F F F T F T T T T E T E E |)(||/|*||→→-+→ 实验要求：用自底向上的语法制导翻译技术实现对表达式的分析和翻译。 (1) 写出满足要求的语法制导定义或翻译方案。

(2) 编写分析程序，实现对表达式的类型进行检查和求值，并输出： ① 分析过程中所有产生式。 ② 识别出的表达式的类型。 ③ 识别出的表达式的值。

(3) 实验方法：可以选用以下两种方法之一。 ① 自己编写分析程序。 ② 利用YACC 自动生成工具。

2. 实验分析和思考

由于要求进行类型检查和求值，所以可以定义两个综合属性，一个记录值一个记录类型，存放在结构中，一并传入传出。

输出的产生式可以作为虚拟综合属性，在产生式的最后打印出来。

id 认为是定义的变量名，假设是26个小写字母，它们的值存于一个数组里。 将类型检查和求值归于一次扫描，当检查类型出错时则停止，否则继续。 哈希实现输入的映射，模拟词法分析的记号流。

输入格式为每个num 和id 对应两个输入字符，其他运算符仍对应一个字符。比如第4个num,输入为num4。 由于只具有综合属性，故可以用S 属性的自底向上翻译实现，利用LR 分析程序来实现，只需扩充分析站和改造分析程序。

PS:这次实验我只是简单模拟了最简单的显式严格匹配，即没有实现隐式类型转换。

3. 翻译方案

}

..),"int(",..{}..),)"(int(",..){(}..),"int(",..{}..),"int(",..{}

;_.;..)..({)}

"/int(",./..{/}

;_.;..)..({)}

"*int(",.*..{*}..),"int(",..{}

;_.;..)..({)}

"int(",...{}

;_.;..)..({)}

"int(",...{111111111111type num type F num F pr val num val F num F type E type F E F pr val E val F E F type id type F id F pr val id val F id F type F type T F T pr val F val T F T error type type T else

type F type T type F type T if F T T pr val F val T val T F T T error type type T else

type F type T type F type T if F T T pr val F val T val T F T T type T type E T E pr val T val E T E error type type E else

type T type E type T type E if T E E pr val T val E val E T E E error type type E else

type T type E type T type E if T E E pr val T val E val E T E E =→=→=→=→=→=→=→=→====→=→====→=→=→=→====-→-=-→====+→+=+→

4. LR 实现 自底向上分析（摘自语法分析实验）

4.1. 构造识别所有活前缀的DFA

构造扩展文法 E E →'

num

E id

F F F T F T T T T E T E E |)(||/|*||→→-+→ FIRST 和FOLLOW 集如下

E

T

F

FIRST id, (, num id, (, num id, (, num FOLLOW

$, ), +, -

$, ), +, -, *, /

$, ), +, -, *, /

构造识别所有活前缀的DFA 如下

4.2. 构造LR 分析表

T E E +→ (1) F T T *→ (4) id F → (7) T E E -→ (2) F T T /→ (5) )(E F → (8) T E → (3) F T → (6) num F → (9)

状态

action

goto

+

-

*

/

id

num

(

)

$

E

T

F

0 s4 S6 S5 1 2 3 1 s7 s8 acc 2 r3 r3 s9 s10 r3 r3 3 r6 r6 r6 r6 r6 r6 4 r7 r7 r7 r7 r7 r7 5 s4 s6 s5 11 2 3 6 r9 r9 r9 r9 r9 r9 7 s4 s6 s5 12 3 8 s4 s6 s5 13 3 9 s4 s6 s5 14 10 s4 s6 s5 15 11 s7 s8 s16 16 12 r1 r1 s9 s10 r1 r1 13 r2 r2 s9 s10 r2 r2 14 r4 r4 r4 r4 r4 r4 15 r5 r5 r5 r5 r5 r5 16 r8

r8

r8

r8

r8

r8

5.S属性定义的自底向上实现

5.1.扩充分析栈

多定义一个结构栈数组，结构里有两个变量，一个为val, 一个为type。实现时，val其实是定义了两个变量，一个表示int时的值，一个表示real时的值，因为无法公用一个类型的变量。

定义type只有三种，一种为int, 一种为real, 一种为type_error。

val由外部提供。可通过数组搜索。

5.2.改造分析程序

在归约时完成类型检查和求值。

之所以与归约联系，是因为每一次归约决定着所用的是哪一个产生式。

acc时打印最终求值结果和表达式类型。

5.3.编程实现

#include

#include

#include

#include

#include

#include

#include

#include

#include

using namespace std;

const int S =1;//移进

const int R =2;//归约

const int ACC =3;//分析成功

const int Vt_num =9;//终结符和$数

const int Vn_num =3;//非终结符数

const int State_num =17;//状态数

const int formula_num =10;//扩展文法产生式数目

const int Max_input =1024;//输入记号流长度

const int max_stack =2500;//栈的最大高度

int token[Max_input];//记号流

int len;//记号流长度

int pointer;//定义指向输入串的指针

stack st;//定义栈

struct action

{

int rs; //初始化表项的动作为0即出错，R归约S移进ACC成功

int no;

}act[State_num][Vt_num];//action表表项

int gto[State_num][Vn_num];//goto表表项

struct attri

{

int type;//int-1, real-2, type_error-0

int i_val;

double r_val;

}val[max_stack];

int v_top;

void initial_table()

{

//初始化分析表

memset(act,0,sizeof(act));

memset(gto,-1,sizeof(gto));

//动作表action

act[0][4]={S,4}; act[0][5]={S,6}; act[0][6]={S,5};

act[1][0]={S,7}; act[1][1]={S,8}; act[1][8].rs = ACC;

act[5][4]={S,4}; act[5][5]={S,6}; act[5][6]={S,5};

act[7][4]={S,4}; act[7][5]={S,6}; act[7][6]={S,5};

act[8][4]={S,4}; act[8][5]={S,6}; act[8][6]={S,5};

act[9][4]={S,4}; act[9][5]={S,6}; act[9][6]={S,5};

act[10][4]={S,4}; act[10][5]={S,6}; act[10][6]={S,5};

act[11][0]={S,7}; act[11][1]={S,8}; act[11][7]={S,16};

act[3][0]= act[3][1]= act[3][2]= act[3][3]= act[3][7]= act[3][8]={R,6};

act[4][0]= act[4][1]= act[4][2]= act[4][3]= act[4][7]= act[4][8]={R,7};

act[6][0]= act[6][1]= act[6][2]= act[6][3]= act[6][7]= act[6][8]={R,9};

act[14][0]= act[14][1]= act[14][2]= act[14][3]= act[14][7]= act[14][8]={R,4};

act[15][0]= act[15][1]= act[15][2]= act[15][3]= act[15][7]= act[15][8]={R,5};

act[16][0]= act[16][1]= act[16][2]= act[16][3]= act[16][7]= act[16][8]={R,8};

act[2][2]={S,9}; act[2][3]={S,10};act[2][0]= act[2][1]= act[2][7]= act[2][8] ={R,3};

act[12][2]={S,9};act[12][3]={S,10};act[12][0]=act[12][1]=act[12][7]=act[12][8]= {R,1};

act[13][2]={S,9};act[13][3]={S,10};act[13][0]=act[13][1]=act[13][7]=act[13][8]= {R,2};

gto[11][2]=16;

gto[7][1]=12; gto[7][2]=3;

gto[8][1]=13; gto[8][2]=3;

gto[5][0]=11; gto[5][1]=2; gto[5][2]=3;

gto[0][0]=1; gto[0][1]=2; gto[0][2]=3;

//产生式存入fm数组

//记录产生式对应的左部的非终结符f_vn

//记录产生式右部的长度flen

fm[1]="E -> E+T \n"; f_vn[1]=0; flen[1]=3;

fm[2]="E -> E-T \n"; f_vn[2]=0; flen[2]=3;

fm[3]="E -> T \n"; f_vn[3]=0; flen[3]=1;

fm[4]="T -> T*F \n"; f_vn[4]=1; flen[4]=3;

fm[5]="T -> T/F \n"; f_vn[5]=1; flen[5]=3;

fm[6]="T -> F \n"; f_vn[6]=1; flen[6]=1;

fm[7]="F -> id \n"; f_vn[7]=2; flen[7]=1;

fm[8]="F -> (E) \n"; f_vn[8]=2; flen[8]=3;

fm[9]="F -> num \n"; f_vn[9]=2; flen[9]=1;

}

/*初始化num和id表项的值*/

void initial_entry()

{

//id: A-M为int,N-Z为real

//num:a-m为int,n-z为real

//值为A/a:0, N/n:0.00

}

void lexi_input()

{

//调用词法分析程序

//+ - * / id num ( ) $分别对应从0到8的整数

//A-Z为id(4), a-z为num(5)

//'a'-97, 'A'-65

//处理输入字符串将记号流存到token[]数组里

//并将记号流长度赋给len

//eg: (a+b)*c/(L-E)

//token={6, 97, 0, 98, 7, 2, 99, 3, 6, 76, 1, 69, 7};

//len=13;

//eg:O-N+n

//token={79, 1, 78, 0, 110};

//len=5;

//eg:O-M+m

void error()

{

puts("E R R O R !!!");

//错误处理程序

}

int main()

{

initial_table();

initial_entry();

lexi_input();

token[len]=Vt_num-1;

len++;

while(!st.empty())

st.pop();//清空栈

st.push(0);//0状态入栈

pointer=0;//指针指向输入记号流的第一个记号

v_top=1;//属性值指针

int cur_state, cur_token;

int i, j;

do{

cur_state = st.top();//栈顶状态

cur_token = token[pointer];//当前指针指向的输入符号

if(cur_token>='a'&& cur_token<='z') cur_token=5;

else if(cur_token>='A'&& cur_token<='Z') cur_token=4;

if(act[cur_state][cur_token].rs == S)

{

/*移进，只需让val也同步移进*/

st.push(cur_token);

st.push(act[cur_state][cur_token].no);

if(cur_token==5)

{

if(token[pointer]<'n')val[v_top].type=1,

val[v_top].i_val=token[pointer]-'a';

else val[v_top].type=2, val[v_top].r_val=token[pointer]-'a'+0.0;

}

else if(cur_token==4)

{

if(token[pointer]<'N')val[v_top].type=1,

val[v_top].i_val=token[pointer]-'A';

else val[v_top].type=2, val[v_top].r_val=token[pointer]-'A'+0.0;

pointer++;

printf("s%d\n",act[cur_state][cur_token].no);

}

else if(act[cur_state][cur_token].rs == R)

{

/*归约，检查类型并计算属性值*/

j=act[cur_state][cur_token].no;

i=2*flen[j];

while(i-->0)

{

st.pop();

}

printf("r%d ", act[cur_state][cur_token].no); cout<

cur_state=st.top();

st.push(f_vn[j]+ Vt_num);

st.push(gto[cur_state][f_vn[j]]);

if(j==1)//E->E+T

{

if(val[v_top-2].type==val[v_top-6].type)

{

if(val[v_top-6].type==1)

val[v_top-6].i_val+=val[v_top-2].i_val;

else

val[v_top-6].r_val+=val[v_top-2].r_val; v_top-=4;

}

else

{

printf("TYPE_ERROR !!!\n");

break;

}

}

else if(j==2)//E->E-T

{

if(val[v_top-2].type==val[v_top-6].type)

{

if(val[v_top-6].type==1)

val[v_top-6].i_val-=val[v_top-2].i_val;

else

val[v_top-6].r_val-=val[v_top-2].r_val; v_top-=4;

}

else

}

}

else if(j==4)//T->T*F

{

if(val[v_top-2].type==val[v_top-6].type)

{

if(val[v_top-6].type==1)

val[v_top-6].i_val*=val[v_top-2].i_val;

else

val[v_top-6].r_val*=val[v_top-2].r_val; v_top-=4;

}

else

{

printf("TYPE_ERROR !!!\n");

break;

}

}

else if(j==5)//T->T/F

{

if(val[v_top-2].type==val[v_top-6].type)

{

if(val[v_top-6].type==1)

val[v_top-6].i_val/=val[v_top-2].i_val;

else

val[v_top-6].r_val/=val[v_top-2].r_val; v_top-=4;

}

else

{

printf("TYPE_ERROR !!!\n");

break;

}

}

else if(j==8)//F->(E)

{

val[v_top-6]=val[v_top-4];

v_top-=4;

}

}

else if(act[cur_state][cur_token].rs == ACC)

{/*表达式类型检查无误，输出类型及值*/

puts("S U C C E S S !!!");

printf("The expression type is ");

if(val[v_top-2].type==1)printf("integer");

else printf("%lf\n\n", val[v_top-2].r_val);

break;

}

else

{

error();

break;

}

}while(1);

return0;

}

6.运行结果截图：

①输入符号串为O-N+n

即token={79, 1, 78, 0, 110};

len=5;

②输入符号串为(a+b)*c/(L-E)

即token={6, 97, 0, 98, 7, 2, 99, 3, 6, 76, 1, 69, 7};

len=13;

③输入符号串O-M+m

即token={79, 1, 77, 0, 109};

len=5;