编译原理 六章 算符优先分析法
算符优先分析法
算符优先分析过程
输入串 i +i * i 的分析过程： E 结论：输入串合法
E +T
T T*F
FF
i
i
i
下推栈
# #i
#F
#F+ #F+i #F+F #F+F* #F+F*i #F+F*F #F+T #E
输入串
i+i*i#
+i*i#
+i*i#
i*i# *i# *i# i# # # # #
查分析表
#<i i>+
ABC
• 11.我会打断别人的话。
ABC
• 12.我会换个角度将心比心来看别人的做法。 A B C
• 13.我能委婉地表达我的建议或反对的观点。 A B C
• 14.交谈时，我会注视对方的眼睛。
ABC
• 15.我很注意人们无意间身体姿态所流露的心情。 A B C
• 16.别人跟我讲话时，我会东张西望。
实例
求下述文法G的算符优先关系表：
E→E+T│T
T→T*F│F
E
F→(E)│i
T
F
考察 E→E+T 中的：E 和 +，+ 和 T 考察 T→T*F 中的：T 和 *，* 和 F 考察 F→(E) 中的：( 和 E，( 和 )，E 和 ) 考察 #E# 中的：# 和 E，# 和 #，E 和 #
一、留给别人良好的第一印象
• 怎样才能给对方留下良好的第一印象呢？ • （1）发挥自己的长处。尺有所短，寸有所长。如果你发挥自己的长处，别
人就会喜欢跟你在一起，并愿意同你合作。所以，与人交往，要充满自信， 并尽可能地发挥自己的长处。 • （2）适应不同的场合。懂得与人交往的人，会因场合不同而改变自己的表 现。一成不变的状态会使人显得没有朝气，从而不会给人留下美好印象。 不管是与人亲密地倾谈，还是发表演说，都要在保持言行一致的前提下， 因时因地地有所变化。 • （3）放松心情。要想别人喜欢你，就要使别人在与你相处时感到轻松自在。 这种氛围只有你自己表现得轻松自如才能创造出来。因此，遇事时自己的 心理要尽量放松。学会幽默，不要总是神色严峻，或做出一副苦闷的样子。 • （4）善于使用眼神。不管是跟一个人还是跟一百个人说话，一定要记住用 眼睛望着对方。进入坐满人的房间时，应自然地举目四顾，微笑着用目光 照顾到所有的人。这会使你显得轻松自若。
算符优先分析编译原理演示文稿
（优选）算符优先分析编译原 理
6.3 算符优先分析法
算符优先文法的定义 算符优先关系表的构造 算符优先分析算法 算符优先分析法的局限性
6.3.1 算符优先分析
• 自下而上分析算法模型----移进归约 • 算符优先分析不是规范归约
算符优先分析的可归约 串是句型的最左素短语 定义: cfg（上下文无关文法） G 的句型的素短
2)’<‘关系
– 求出每个非终结符B的FIRSTVT(B)
– 若A→…aB…,则b∈FIRSTVT(B),则a<b
3)’>’关系
– 求出每个非终结符B的LASTVT(B)
– 若A→…Bb…,则a∈LASTVT(B),则a>b
计算算符优先关系
例文法G’[E’]： (0) E’→#E# (1) E→E+T (2) E→T (3) T→T*F (4) T→F (5) F→PF|P (6) P→(E) (7) P→i
例 G’[E]:
算符优先关表
E→E＋T|T
T→T*F|F F→P↑F｜P
P→(E)|i
+ * ( ) i#
+>< << >< >
*> > < < > < >
> > < < > < >
( < < < <=<
)>>>
>
>
i >>>
>
>
#< < < <
<=
算符优先分析大学编译原理
6.1 自底向上优先分析概述
• 有两种优先分析法： 1。 简朴优先分析法：
求出文法全部符号（终止符，非终止符） 之间优先关系，按这种关系拟定规约过 程中旳句柄。 2。算符优先分析法：考虑算符之间优先关 系旳规约（非规范规约）
2
6.3 算符优先分析法
算符优先文法旳定义 算符优先关系表旳构造 算符优先分析算法 算符优先分析法旳不足
• 比规范归约快 • 可能造成把错误旳句子得到正确旳归约。
该措施仅合用于体现式旳语法分析
17
利用算符优先分析算法分析输入串
• 举例 p115: 分析输入串i+i#
• G’[E]: E→E＋T|T T→T*F|F F→P↑F｜P P→(E)|i
+ * ( ) i#
+>< << >< >
*> > < < > < >
第6章 自低向上优先分析
• 即移进-规约分析。思想： 对符号串自左向右扫描，将输入符号移入一种 后进先出栈中，边移入边分析，一旦栈顶符号 串形成某个句型旳句柄或可规约串时（该句柄 或可规约串相应某个产生式右部），就用该产 生式旳左部非终止符替代相应右部旳文法符号 串，即规约。反复这一过程，直到栈中只剩余 文法旳开始符号时则以为分析成功，即输入旳 符号串是文法旳句子。
E E+ T E +T F
T T* F i
E
E+T
E+T F
T
i
句型T+T+F旳素短语为：T+T
5
分析程序模型
输入串#
总控程序
输出
# 算符优先关系表 产生式
实验二 编译原理语法分析(算符优先)
实验二语法分析算符优先分析程序一．实验要求⑴选择最有代表性的语法分析方法算符优先法；⑵选择对各种常见程序语言都用的语法结构，如赋值语句（尤指表达式）作为分析对象，并且与所选语法分析方法要比较贴切。
⑶实习时间为6学时。
二．实验内容及要求（1）根据给定文法，先求出FirstVt和LastVt集合，构造算符优先关系表（要求算符优先关系表输出到屏幕或者输出到文件）；（2）根据算法和优先关系表分析给定表达式是否是该文法识别的正确的算术表达式（要求输出归约过程）（3）给定表达式文法为：G(E’): E’→#E#E→E+T | TT→T*F |FF→(E)|i(4)分析的句子为:(i+i)*i和i+i)*i三.实验代码#include "stdafx.h"#include "stdio.h"#include "stdlib.h"#include "iostream.h"int k;char a;int j;char q;int r;int r1;char st[10][30];char data[20][20];char s[100];char lable[20];char input[100];char string[20][10];char first[10][10];char last[10][10];int fflag[10]={0};int lflag[10]={0};int deal();int zhongjie(char c);int xiabiao(char c);void out(int j,int k,char *s);void firstvt(char c);void lastvt(char c);void table();void main(){int i,j,k=0;printf("请输入文法规则数：");scanf("%d",&r);printf("请输入文法规则：\n");for(i=0;i<r;i++){scanf("%s",st[i]);first[i][0]=0;last[i][0]=0;}for(i=0;i<r;i++){for(j=0;st[i][j]!='\0';j++){if(st[i][0]<'A'||st[i][0]>'Z'){printf("不是算符文法!\n");exit(-1);}if(st[i][j]>='A'&&st[i][j]<='Z'){if(st[i][j+1]>='A'&&st[i][j+1]<='Z'){printf("不是算符文法!\n");exit(-1);}}}}for(i=0;i<r;i++){for(j=0;st[i][j]!='\0';j++){if((st[i][j]<'A'||st[i][j]>'Z')&&st[i][j]!='-'&&st[i][j]!='>'&&st[i][j]!='|') lable[k++]=st[i][j];}}lable[k]='#';lable[k+1]='\0';table();//输出每个非终结符的FIRSTVT集printf("每个非终结符的FIRSTVT集为：\n"); for(i=0;i<r;i++){printf("%c: ",st[i][0]);for(j=0;j<first[i][0];j++){printf("%c ",first[i][j+1]);}printf("\n");}//输出每个非终结符的LASTVT集printf("每个非终结符的LASTVT集为：\n"); for(i=0;i<r;i++){printf("%c: ",st[i][0]);for(j=0;j<last[i][0];j++){printf("%c ",last[i][j+1]);}printf("\n");}printf("算符优先分析表如下:\n");for(i=0;lable[i]!='\0';i++)printf("\t%c",lable[i]);printf("\n");for(i=0;i<k+1;i++){printf("%c\t",lable[i]);for(j=0;j<k+1;j++){printf("%c\t",data[i][j]);}printf("\n");}printf("请输入文法输入符号串以#结束:");scanf("%s",input);deal();}void table(){char text[20][10];int i,j,k,t,l,x=0,y=0;int m,n;x=0;for(i=0;i<r;i++){firstvt(st[i][0]);lastvt(st[i][0]);}for(i=0;i<r;i++){text[x][y]=st[i][0];y++;for(j=1;st[i][j]!='\0';j++){if(st[i][j]=='|'){text[x][y]='\0';x++;y=0;text[x][y]=st[i][0];y++;text[x][y++]='-';text[x][y++]='>';}else{text[x][y]=st[i][j];y++;}}text[x][y]='\0';x++;y=0;}r1=x;//输出转化后的文法规则串printf("转化后的文法为:\n");for(i=0;i<x;i++) {printf("%s\n",text[i]);}for(i=0;i<x;i++){string[i][0]=text[i][0];for(j=3,l=1;text[i][j]!='\0';j++,l++)string[i][l]=text[i][j];string[i][l]='\0';}for(i=0;i<x;i++){for(j=1;text[i][j+1]!='\0';j++){if(zhongjie(text[i][j])&&zhongjie(text[i][j+1])){m=xiabiao(text[i][j]);n=xiabiao(text[i][j+1]);data[m][n]='=';}if(text[i][j+2]!='\0'&&zhongjie(text[i][j])&&zhongjie(text[i][j+2])&&!zhongjie(text[i][j+1])) {m=xiabiao(text[i][j]);n=xiabiao(text[i][j+2]);data[m][n]='=';}if(zhongjie(text[i][j])&&!zhongjie(text[i][j+1])){for(k=0;k<r;k++){if(st[k][0]==text[i][j+1])break;}m=xiabiao(text[i][j]);for(t=0;t<first[k][0];t++){n=xiabiao(first[k][t+1]);data[m][n]='<';}}if(!zhongjie(text[i][j])&&zhongjie(text[i][j+1])){for(k=0;k<r;k++){if(st[k][0]==text[i][j])break;}n=xiabiao(text[i][j+1]);for(t=0;t<last[k][0];t++){m=xiabiao(last[k][t+1]);data[m][n]='>';}}}}m=xiabiao('#');for(t=0;t<first[0][0];t++){n=xiabiao(first[0][t+1]);data[m][n]='<';}n=xiabiao('#');for(t=0;t<last[0][0];t++){m=xiabiao(last[0][t+1]);data[m][n]='>';}data[n][n]='=';}//求FIRSTVT集void firstvt(char c) { int i,j,k,m,n;for(i=0;i<r;i++){if(st[i][0]==c)break;}if(fflag[i]==0){n=first[i][0]+1;m=0;do{if(m==2||st[i][m]=='|'){if(zhongjie(st[i][m+1])){first[i][n]=st[i][m+1];n++;}else{if(zhongjie(st[i][m+2])){first[i][n]=st[i][m+2];n++;}if(st[i][m+1]!=c){firstvt(st[i][m+1]);for(j=0;j<r;j++){if(st[j][0]==st[i][m+1])break;}for(k=0;k<first[j][0];k++){int t;for(t=0;t<n;t++){if(first[i][t]==first[j][k+1])break;}if(t==n){first[i][n]=first[j][k+1];n++;}}}}}m++;}while(st[i][m]!='\0');first[i][n]='\0';first[i][0]=--n;fflag[i]=1;}}//求LASTVT集{void lastvt(char c)int i,j,k,m,n;for(i=0;i<r;i++){if(st[i][0]==c)break;}if(lflag[i]==0){n=last[i][0]+1;m=0;do{if(st[i][m+1]=='\0'||st[i][m+1]=='|'){if(zhongjie(st[i][m])){last[i][n]=st[i][m];n++;}else{if(zhongjie(st[i][m-1])){last[i][n]=st[i][m-1];n++;}if(st[i][m]!=c){lastvt(st[i][m]);for(j=0;j<r;j++){if(st[j][0]==st[i][m])break;}for(k=0;k<last[j][0];k++){int t;for(t=0;t<n;t++){if(last[i][t]==last[j][k+1])break;}if(t==n){last[i][n]=last[j][k+1];n++;}}}}}m++;}while(st[i][m]!='\0');last[i][n]='\0';last[i][0]=--n;lflag[i]=1;}}int deal(){int i,j;int x,y;int z;k=1;s[k]='#';for(i=0;input[i]!='\0';i++);z=i--;i=0;while((a=input[i])!='\0'){if(zhongjie(s[k]))j=k;elsej=k-1;x=xiabiao(s[j]);y=xiabiao(a);if(data[x][y]=='>'){out(1,k,s);printf("%c",a);out(i+1,z,input);printf("规约\n");do{q=s[j];if(zhongjie(s[j-1]))j=j-1;else j=j-2;x=xiabiao(s[j]);y=xiabiao(q);}while(data[x][y]!='<');int m,n,N;for(m=j+1;m<=k;m++){for(N=0;N<r1;N++)for(n=1;string[N][n]!='\0';n++){if(!zhongjie(s[m])&&!zhongjie(string[N][n])) {if(zhongjie(s[m+1])&&zhongjie(string[N][n+1])&&s[m+1]==string[N][n+1]){s[j+1]=string[N][0];break;}}elseif(zhongjie(s[m]))if(s[m]==string[N][n]){s[j+1]=string[N][0];break;}}}k=j+1;if(k==2&&a=='#'){out(1,k,s);printf("%c",a);out(i+1,z,input);printf("结束\n");printf("输入串符合文法的定义！\n");return 1; } }elseif(data[x][y]=='<'||data[x][y]=='='){out(1,k,s);printf("%c",a);out(i+1,z,input);printf("移进\n");k++;s[k]=a;i++;}else{printf("\nflase");return 0;}}printf("\nflase");return 0;}void out(int j,int k,char *s){int n=0;int i;for(i=j;i<=k;i++){printf("%c",s[i]);n++;}for(;n<15;n++){printf(" ");}}//判断字符c是否是终极符int zhongjie(char c){int i;for(i=0;lable[i]!='\0';i++){if(c==lable[i])return 1;}return 0;}//求字符c在算符优先关系表中的下标{int xiabiao(char c)int i;for(i=0;lable[i]!='\0';i++){if(c==lable[i])return i;}return -1;}四、实验结果输入串为#(i+i)/i#存放于Read.txt文件中五、实验总结经过此次试验对算符优先分析的原理有了深入的理解，熟悉了算符分析的过程，掌握了算符优先分析的有关处理，能够使用一种高级语言构造算符优先的语法分析器。
编译原理--算符优先分析法研究--源程序
编译原理算符优先分析法研究源程序目录1 课程设计的目的和要求 (2)1.1 课程设计的目的 (2)1.2 课程设计的要求 (2)2 系统描述 (2)2.1 自底向上分析方法的描述: (2)2.2 算符优先文法的描述： (2)3）输入符号串，进行移进-规约分析。
(3)3 概要设计 (3)3.1 设计思路 (3)3.2 系统功能结构 (4)3.3 技术路线或实现方法 (5)3.4 开发环境 (5)4 详细设计 (5)4.1 模块划分 (5)4.2 主要算法的流程图 (7)4.3 数据分析与定义 (8)4.4 系统界面设计 (8)5 测试方法和测试结果 (9)5.1 测试用例1 (9)5.2 测试用例2 (10)5.3 测试用例3 (11)5.4 测试用例4 (12)6 结论和展望 (13)结论 (13)展望 (13)学习编译技术课程的体会和对本门课程的评价 (13)7 参考文献 (13)8 源代码 (14)1 课程设计的目的和要求1.1 课程设计的目的本次设计的时间为1周，目的是通过使用高级语言实现部分算法加强对编译技术和理论的理解。
设计的题目要求具有一定的规模，应涵盖本课程内容和实际应用相关的主要技术。
1.2 课程设计的要求1、文法使用产生式来定义；2、用大写字母和小写字母分别表示非终结符和终结符；产生式使用->；3、文法中的空字符串统一使用@表示；4、分别给出每一个非终结符的FIRSTVT集和LASTVT集；5、画出算符优先关系表6、判定给定的文法是否是算符优先文法；7、给定符号串判定是否是文法中的句子，分析过程用分析表格的方式打印出来。
2 系统描述本次实验使用windows vista操作系统下visual C++6.0平台，使用C语言，利用读文件方式将待分析的文法读入到程序中，通过定义数组和结构体作为具有一定意义或关系的表或栈，存放FIRSTVT、LASTVT、算符优先关系表的元素。
编译原理算符优先分析算法
算符优先分析算法1.该实验实现算符优先分析算法，由于时间关系，尚未实现用程序计算FIRSTVT，LASTVT，因此本实验的各种非终结符及其之间的优先关系人为初始化。
本实验参考例4.12及其优先关系表。
2.算符优先关系表参考课本74页表4.4+ * id ( ) #+ > < < < > >* > > < < > >id > > > >( < < < < =) > > > ># < < < < =3.结果如图4.源代码# include<stdio.h># include<stdlib.h># include<string.h># define MAX 50 //定义最大长度为50，可以变化struct sst{char s[MAX];int ps;//栈顶终结符指针int top;//栈顶指针};struct inputst{char in[MAX];int pin;//当前字符指针};//定义算符及其优先关系表char ch[6] = {'+','*','i','(',')','#'};char chrelation[6][6]={'>','<','<','<','>','>','>','>','<','<','>','>','>','>','@','@','>','>','<','<','<','<','=','@','>','>','@','@','>','>','<','<','<','<','@','=', };char rela(char c1,char c2){int i = 0,j = 0;while(ch[i] != c1)i++;while(ch[j] != c2)j++;return chrelation[i][j];}int is_VN(char c1){//判断是否为非终结符int i = 0;while(i < 6){if(ch[i] == c1)return 0;i++;}return 1;}void main(){struct sst S;for(int i = 0;i < MAX;i++){S.s[i] = ' ';}S.s[0] = '#';S.ps = 0;S.top = 0;struct inputst input;printf("请输入需分析的字符串，以#结尾，最大长度为%d:\n",MAX);scanf("%s",input.in);printf("%s\n",input.in);input.pin = 0;printf("s栈优先关系当前符号输入流动作\n");int cursor;while(1){if(rela(S.s[S.ps],input.in[input.pin]) == '<' || rela(S.s[S.ps],input.in[input.pin]) == '=') { for(cursor = 0;cursor <= S.top;cursor++)printf("%c",S.s[cursor]);printf(" %c ",rela(S.s[S.ps],input.in[input.pin]));printf(" %c ",input.in[input.pin]);printf(" ");for(cursor = input.pin+1;cursor < strlen(input.in);cursor++)printf("%c",input.in[cursor]);if(S.s[S.ps] == '#' && S.s[S.top] == 'N' &&rela(S.s[S.ps],input.in[input.pin]) == '=') {printf(" 接受\n");return;}else{ printf(" 移进\n");S.top++;S.ps = S.top;S.s[S.top] = input.in[input.pin++];}}else if(rela(S.s[S.ps],input.in[input.pin]) == '>'){for(cursor = 0;cursor <= S.top;cursor++)printf("%c",S.s[cursor]);printf(" %c ",rela(S.s[S.ps],input.in[input.pin]));printf(" %c ",input.in[input.pin]);printf(" ");for(cursor = input.pin+1;cursor < strlen(input.in);cursor++)printf("%c",input.in[cursor]);if(S.ps >0 && S.ps < S.top){if( is_VN(S.s[S.ps-1]) && is_VN(S.s[S.ps+1])){S.s[S.ps-1] = 'N';S.top = S.ps-1;S.ps = S.top -1;}printf(" 归约\n");}else{S.s[S.top] = 'N';S.ps = S.top -1;printf(" 归约\n");}}else{for(cursor = 0;cursor <= S.top;cursor++)printf("%c",S.s[cursor]);printf(" %c ",rela(S.s[S.ps],input.in[input.pin]));printf(" %c ",input.in[input.pin]);printf(" ");for(cursor = input.pin+1;cursor < strlen(input.in);cursor++) printf("%c ",input.in[cursor]);printf(" 出错!");return;}}}5.问题不知如何用计算机程序得到FIRSTVT，LASTVT。
编译原理实验报告6逆波兰式的翻译和计算
实验6 逆波兰式的翻译和计算一、实验目的通过实验加深对语法指导翻译原理的理解，掌握算符优先分析的方法，将语法分析所识别的表达式变换成中间代码的翻译方法。
二、实验内容设计一个表示能把普通表达式（中缀式）翻译成后缀式，并计算出结果的程序。
三、实验要求1、给出文法如下：G[E]E->T|E+T;T->F|T*F;F->i(E);对应的转化为逆波兰式的语义动作如下： E-> E (1)op E (2) {E.CODE:= E (1).CODE||E (2).CODE||op} E->(E (1)) { E.CODE := E (1).CODE}E->id { E.CODE := id}2、利用实验5中的算符优先分析算法，结合上面给出的语义动作实现逆波兰式的构造；3、利用栈，计算生成的逆波兰式，步骤如下：1） 中缀表达式，从文本文件读入，每一行存放一个表达式，为了降低难度，表达式采用常数表达式；2） 利用结合语法制导翻译的算符优先分析，构造逆波兰式；3） 利用栈计算出后缀式的结果，并输出；四、实验环境PC 微机DOS 操作系统或 Windows 操作系统Turbo C 程序集成环境或 Visual C++ 程序集成环境五、实验步骤1、了解语法制导翻译的方法，学习后缀式构造的语义动作；2、结合实验5的算符优先程序，设计程序构造后缀式；3、利用栈，编程实现后缀式的计算；4、测试程序运行效果：从文本文件中读表达式，在屏幕上输出，检查输出结果。
六、测试数据输入数据：编辑一个文本文文件expression.txt，在文件中输入如下内容：正确结果：（1）1+2;输出：1,2,+ 3（2）(1+2)*3;输出：1,2,+,3,* 9（3）(10+20)*30+(50+60*70)输出：10,20,+30,*50,60,70,*,+,+ 5150七、实验报告要求实验报告应包括以下几个部分：1、构造逆波兰式的语义动作；2、结合算符优先分析构造逆波兰式的算法和过程；3、语法制导翻译的运行方法；4、程序的测试结果和问题；5、实验总结。
编译原理 算符优先分析法 ppt课件
13
4.4.2 算符优先文法的定义 • 3 算符优先文法的定义
设有一个不含 规则的OG文法G，
如果任意两个终结符间至多有一种算符 关系存在， 则称G是算符优先文法，也称OPG文法。
结论：算符优先文法是无二义的。
编译原理 算符优先分析法
14
4.4.3 算符优先关系表的构造
• 1 FIRSTVT集、 LASTVT集
规范归约:
自上而下最右推导的逆过程。
编译原理 算符优先分析法
18
例4.12文法G[E]:
E E+T|T
E
T T*F|F
E +T
F (E)|id
句子id*id+id的
T
F
自下向上的语法分析过程。
T * F id
规范归约是最右推导的 逆过程。
*优先于＋：
＋优先于*：
(1)id+id*id
(1)id+id*id
(2)E+id*id
(2)E+id*id
(3)E+E*id
(3)E+E*id
(4)E+E*E
(4)E*id
(5)E+E
(5)E*E
(6)E
(6)E
编译原理 算符优先分析法
7
4.4.1 方法概述
• 3 优先关系种类
任何两个相邻的终结符a和b可能的优先关系有3 种： a b: a的优先级低于b
FIRSTVT
LASTVT
E
{+,*,(,id}
{+,*,),id}
T
{*,(,id}
{*,),id}
F
{(,id}
编译原理算符优先分析程序设计
编译原理算符优先分析程序设计算符优先分析（Operator Precedence Parsing）是一种基于文法的自下而上的语法分析方法，用于构造一个将输入串转化为语法分析树的分析器。
它通过根据每一个终结符号和非终结符号之间的优先级关系，来判断是否可以进行规约操作。
算符优先分析的基本思想是，为每一个终结符和非终结符分配一个优先级，然后根据这些优先级来决定如何进行规约操作。
一般来说，基本的终结符都有一个固定的优先级，而非终结符的优先级则由其所对应的产生式右部中的终结符优先级来决定。
算符优先分析的核心在于构造一个优先级关系表，用于指导规约过程。
这个表一般由产生式构造得到，每个终结符和非终结符对应一行和一列，表中的每个元素表示两个符号之间的优先级关系。
算符优先分析的步骤如下：1.根据给定的文法，确定每个终结符号和非终结符号的优先级。
2.构造优先关系表，填入每两个符号之间的优先关系。
3.初始化分析栈和输入栈，将栈底符号设为文法开始符号，并将输入串入栈。
4.重复以下步骤，直到分析完成：a.查找栈顶和当前输入符号之间的优先关系。
b.如果栈顶符号的优先级较低或相等，则进行规约操作，将栈顶的符号替换为相应的非终结符号。
c.如果栈顶符号的优先级较高，则进行移进操作，将当前输入符号移入栈中。
d.如果找不到优先关系，则出现错误，分析失败。
算符优先分析的优点是简单明了，且规约过程中不需要回溯，效率较高。
然而，由于它只适用于算符优先文法，而不是所有的上下文无关文法，因此适用范围有限。
在实际编程中，我们可以通过编写算符优先分析程序来对给定的文法进行分析。
程序可以根据文法自动生成优先关系表，然后根据输入串和优先关系表进行分析。
下面是一个简单的算符优先分析程序设计：```python#定义终结符和非终结符的优先级priority = {'+': 1, '-': 1, '*': 2, '/': 2, '(': 0, ')': 0}#构造优先关系表def build_table(:table = {}for symbol1 in priority.keys(:row = {}for symbol2 in priority.keys(:if symbol1 == '(' and symbol2 == ')':row[symbol2] = 'r'elif symbol1 == ')' and symbol2 == '(':row[symbol2] = 'e'elif priority[symbol1] > priority[symbol2]:row[symbol2] = '>'elif priority[symbol1] < priority[symbol2]:row[symbol2] = '<'else:row[symbol2] = 'e'table[symbol1] = rowreturn table#算符优先分析程序def operator_precedence_parsing(table, input_str): input_stack = list(input_str)input_stack.append('#')analysis_stack = ['#']while len(analysis_stack) > 0:top = analysis_stack[-1]if top in priority.keys( and input_stack[0] in priority.keys(:relation = table[top][input_stack[0]]if relation == '>':analysis_stack.popprint('Reduce by', top)elif relation == '<':analysis_stack.append(input_stack.pop(0)) print('Shift', analysis_stack[-1])elif relation == 'e':analysis_stack.popinput_stack.pop(0)print('Error')returnelse:print('Error')returnelse:print('Error')return#测试代码table = build_tableinput_str = input('Please enter a valid expression: ')operator_precedence_parsing(table, input_str)```以上是一个简单的算符优先分析程序设计，实现了根据输入串和优先关系表进行分析的过程。
算符优先分析算法(c语言)
编译原理实验一实验目的设计、编制并调试一个算符优先分析算法，加深对此分析法的理解二实验过程先在算符栈置“＄”，然后开始顺序扫描表达式，若读来的单词符号是操作数，这直接进操作数栈，然后继续读下一个单词符号。
分析过程从头开始，并重复进行；若读来的是运算符θ2则将当前处于运算符栈顶的运算符θ1的入栈优先数f与θ2的比较优先函数g进行比较。
2.2 各种单词符号对应的种别码2.3 算符优先程序的功能完成一个交互式面向对象的算符优先分析程序，而一个交互式面向对象的算符优先分析程序基本功能是：（1）输入文法规则（2）对文法进行转换（3）生成每个非终结符的FirstVT和LastVT（4）生成算符优先分析表（5）再输入文法符号（6）生成移进规约步骤三设计源码算符优先分析器#include "stdio.h"#include "stdlib.h"#include "iostream.h"char data[20][20]; //算符优先关系char s[100]; //模拟符号栈schar lable[20]; //文法终极符集char input[100]; //文法输入符号串char string[20][10]; //用于输入串的分析int k;char a;int j;char q;int r; //文法规则个数int r1;int m,n,N; //转化后文法规则个数char st[10][30]; //用来存储文法规则char first[10][10]; //文法非终结符FIRSTVT集char last[10][10]; //文法非终结符LASTVT集int fflag[10]={0}; //标志第i个非终结符的FIRSTVT集是否已求出int lflag[10]={0}; //标志第i个非终结符的LASTVT集是否已求出int deal(); //对输入串的分析int zhongjie(char c); //判断字符c是否是终极符int xiabiao(char c); //求字符c在算符优先关系表中的下标void out(int j,int k,char *s); //打印s栈void firstvt(char c); //求非终结符c的FIRSTVT集void lastvt(char c); //求非终结符c的LASTVT集void table(); //创建文法优先关系表void main(){int i,j,k=0;printf("请输入文法规则数：");scanf("%d",&r);printf("请输入文法规则：\n");for(i=0;i<r;i++){scanf("%s",st[i]); //存储文法规则，初始化FIRSTVT集和LASTVT集*/first[i][0]=0; /*first[i][0]和last[i][0]分别表示st[i][0]非终极符的FIRSTVT集和LASTVT集中元素的个数*/ last[i][0]=0;}for(i=0;i<r;i++) //判断文法是否合法{for(j=0;st[i][j]!='\0';j++){if(st[i][0]<'A'||st[i][0]>'Z'){printf("不是算符文法!\n");exit(-1);}if(st[i][j]>='A'&&st[i][j]<='Z'){if(st[i][j+1]>='A'&&st[i][j+1]<='Z'){printf("不是算符文法!\n");exit(-1);}}}}for(i=0;i<r;i++){for(j=0;st[i][j]!='\0';j++){if((st[i][j]<'A'||st[i][j]>'Z')&&st[i][j]!='-'&&st[i][j]!='>'&&st[i][j]!='| ')lable[k++]=st[i][j];}}lable[k]='#';lable[k+1]='\0';table();printf("每个非终结符的FIRSTVT集为：\n"); //输出每个非终结符的FIRSTVT集for(i=0;i<r;i++){printf("%c: ",st[i][0]);for(j=0;j<first[i][0];j++){printf("%c ",first[i][j+1]);}printf("\n");}printf("每个非终结符的LASTVT集为：\n"); //输出每个非终结符的LASTVT集for(i=0;i<r;i++){printf("%c: ",st[i][0]);for(j=0;j<last[i][0];j++){printf("%c ",last[i][j+1]);}printf("\n");}printf("算符优先分析表如下:\n");for(i=0;lable[i]!='\0';i++)printf("\t%c",lable[i]);printf("\n");for(i=0;i<k+1;i++){printf("%c\t",lable[i]);for(j=0;j<k+1;j++){printf("%c\t",data[i][j]);}printf("\n");}printf("请输入文法输入符号串以#结束:");scanf("%s",input);deal();}void table(){char text[20][10];int i,j,k,t,l,x=0,y=0;int m,n;x=0;for(i=0;i<r;i++){firstvt(st[i][0]);lastvt(st[i][0]);}for(i=0;i<r;i++){text[x][y]=st[i][0];y++;for(j=1;st[i][j]!='\0';j++){if(st[i][j]=='|'){text[x][y]='\0';x++;y=0;text[x][y]=st[i][0];y++;text[x][y++]='-';text[x][y++]='>';}else{text[x][y]=st[i][j];y++;}}text[x][y]='\0';x++;y=0;}r1=x;printf("转化后的文法为:\n");for(i=0;i<x;i++) //输出转化后的文法规则串{printf("%s\n",text[i]);}for(i=0;i<x;i++) /*求每个终结符的推导结果(去掉"->"后的转化文法，用于最后的规约)*/ {string[i][0]=text[i][0];for(j=3,l=1;text[i][j]!='\0';j++,l++)string[i][l]=text[i][j];string[i][l]='\0';}for(i=0;i<x;i++){for(j=1;text[i][j+1]!='\0';j++){if(zhongjie(text[i][j])&&zhongjie(text[i][j+1])){m=xiabiao(text[i][j]);n=xiabiao(text[i][j+1]);data[m][n]='=';}if(text[i][j+2]!='\0'&&zhongjie(text[i][j])&&zhongjie(text[i][j+2])&&!zhongjie(text[i][j+1])){m=xiabiao(text[i][j]);n=xiabiao(text[i][j+2]);data[m][n]='=';}if(zhongjie(text[i][j])&&!zhongjie(text[i][j+1])){for(k=0;k<r;k++){if(st[k][0]==text[i][j+1])break;}m=xiabiao(text[i][j]);for(t=0;t<first[k][0];t++){n=xiabiao(first[k][t+1]);data[m][n]='<';}}if(!zhongjie(text[i][j])&&zhongjie(text[i][j+1])){for(k=0;k<r;k++){if(st[k][0]==text[i][j])break;}n=xiabiao(text[i][j+1]);for(t=0;t<last[k][0];t++){m=xiabiao(last[k][t+1]);data[m][n]='>';}}}}m=xiabiao('#');for(t=0;t<first[0][0];t++){n=xiabiao(first[0][t+1]);data[m][n]='<';}n=xiabiao('#');for(t=0;t<last[0][0];t++){m=xiabiao(last[0][t+1]);data[m][n]='>';}data[n][n]='=';}void firstvt(char c) //求FIRSTVT集{int i,j,k,m,n;for(i=0;i<r;i++){if(st[i][0]==c)break;}if(fflag[i]==0){n=first[i][0]+1;m=0;do{if(m==2||st[i][m]=='|'){if(zhongjie(st[i][m+1])){first[i][n]=st[i][m+1];n++;}else{if(zhongjie(st[i][m+2])){first[i][n]=st[i][m+2];n++;}if(st[i][m+1]!=c){firstvt(st[i][m+1]);for(j=0;j<r;j++){if(st[j][0]==st[i][m+1])break;}for(k=0;k<first[j][0];k++)int t;for(t=0;t<n;t++){if(first[i][t]==first[j][k+1])break;}if(t==n){first[i][n]=first[j][k+1];n++;}}}}}m++;}while(st[i][m]!='\0');first[i][n]='\0';first[i][0]=--n;fflag[i]=1;}}void lastvt(char c) //求LASTVT集{int i,j,k,m,n;for(i=0;i<r;i++){if(st[i][0]==c)break;}if(lflag[i]==0){n=last[i][0]+1;m=0;do{if(st[i][m+1]=='\0'||st[i][m+1]=='|'){if(zhongjie(st[i][m])){last[i][n]=st[i][m];}else{if(zhongjie(st[i][m-1])){last[i][n]=st[i][m-1];n++;}if(st[i][m]!=c){lastvt(st[i][m]);for(j=0;j<r;j++){if(st[j][0]==st[i][m])break;}for(k=0;k<last[j][0];k++){int t;for(t=0;t<n;t++){if(last[i][t]==last[j][k+1])break;}if(t==n){last[i][n]=last[j][k+1];n++;}}}}}m++;}while(st[i][m]!='\0');last[i][n]='\0';last[i][0]=--n;lflag[i]=1;}}int deal(){int i,j;int x,y;int z; //输入串的长度k=1;s[k]='#'; //栈置初值for(i=0;input[i]!='\0';i++); //计算输入串的长度z=i--;i=0;while((a=input[i])!='\0'){if(zhongjie(s[k]))j=k;elsej=k-1;x=xiabiao(s[j]);y=xiabiao(a);if(data[x][y]=='>'){out(1,k,s);printf("%c",a);out(i+1,z,input);printf("规约\n");do{q=s[j];if(zhongjie(s[j-1]))j=j-1;else j=j-2;x=xiabiao(s[j]);y=xiabiao(q);}while(data[x][y]!='<');int m,n,N;for(m=j+1;m<=k;m++){for(N=0;N<r1;N++)for(n=1;string[N][n]!='\0';n++){if(!zhongjie(s[m])&&!zhongjie(string[N][n])){if(zhongjie(s[m+1])&&zhongjie(string[N][n+1])&&s[m+1]==string[N][n+1]){s[j+1]=string[N][0];break;}}elseif(zhongjie(s[m]))if(s[m]==string[N][n]){s[j+1]=string[N][0];break;}}}k=j+1;if(k==2&&a=='#'){out(1,k,s);printf("%c",a);out(i+1,z,input);printf("结束\n");printf("输入串符合文法的定义！\n");return 1; //输入串符合文法的定义}}elseif(data[x][y]=='<'||data[x][y]=='='){ //移进out(1,k,s);printf("%c",a);out(i+1,z,input);printf("移进\n");k++;s[k]=a;i++;}else{printf("\nflase");return 0;}}printf("\nflase");return 0;}void out(int j,int k,char *s){int n=0;int i;for(i=j;i<=k;i++){printf("%c",s[i]);n++;}for(;n<15;n++){printf(" ");}}int xiabiao(char c) //求字符c在算符优先关系表中的下标{int i;for(i=0;lable[i]!='\0';i++){if(c==lable[i])return i;}return -1;}int zhongjie(char c) //判断字符c是否是终极符{int i;for(i=0;lable[i]!='\0';i++){if(c==lable[i])return 1;}return 0;}四实验结果。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第六章算符优先分析法课前索引【课前思考】◇什么是自下而上语法分析的策略？◇什么是移进-归约分析？◇移进-归约过程和自顶向下最右推导有何关系？◇自下而上语法分析成功的标志是什么？◇什么是可归约串？◇移进-归约过程的关键问题是什么？◇如何确定可归约串？◇如何决定什么时候移进，什么时候归约？◇什么是算符文法？什么是算符优先文法？◇算符优先分析是如何识别可归约串的？◇算符优先分析法的优缺点和局限性有哪些？【学习目标】算符优先分析法是自下而上（自底向上）语法分析的一种，尤其适应于表达式的语法分析，由于它的算法简单直观易于理解，因此，也是学习其它自下而上语法分析的基础。
通过本章学习学员应掌握：◇对给定的文法能够判断该文法是否是算符文法◇对给定的算符文法能够判断该文法是否是算符优先文法◇对给定的算符文法能构造算符优先关系表，并能利用算符优先关系表判断该文法是否是算符优先文法。
◇能应用算符优先分析算法对给定的输入串进行移进-归约分析，在分析的每一步能确定当前应移进还是归约，并能判断所给的输入串是否是该文法的句子。
◇了解算符优先分析法的优缺点和实际应用中的局限性。
【学习指南】算符优先分析法是自下而上语法分析的一种，它的算法简单、直观、易于理解，所以通常作为学习其它自下而上语法分析的基础。
为学好本章内容，学员应复习有关语法分析的知识，如：什么是语言、文法、句子、句型、短语、简单短语、句柄、最右推导、规范归约基本概念。
【难重点】◇通过本章学习后，学员应该能知道算符文法的形式。
◇对一个给定的算符文法能构造算符优先关系分析表，并能判别所给文法是否为算符优先文法。
◇分清规范句型的句柄和最左素短语的区别，进而分清算符优先归约和规范归约的区别。
◇算符优先分析的可归约串是句型的最左素短语，在分析过程中如何寻找可归约串是算符优先分析的关键问题。
对一个给定的输入串能应用算符优先关系分析表给出分析（归约）步骤，并最终判断所给输入串是否为该文法的句子。
◇深入理解算符优先分析法的优缺点和实际应用中的局限性。
【知识点】短语、直接短语、句柄的定义：文法G[S]，S αAδ且A β则称β是句型α β δ相对于非终结符A的短语。
若有Aβ则称β是句型α β δ相对于A或规则A → β的直接短语。
一个句型的最左直接短语称为该句型的句柄。
算符优先分析法是一种自底向上分析方法，也称移进-归约分析法，粗略地说它的实现思想是对输入符号串自左向右进行扫描，并将输入符逐个移入一个后进先出栈中，边移入边分析，一旦栈顶符号串形成某个句型的句柄时，(该句柄对应某产生式的右部)，就用该产生式的左部非终结符代替相应右部的文法符号串，这称为一步归约。
重复这一过程直到归约到栈中只剩文法的开始符号时则为分析成功，也就确认输入串是文法的句子。
本章将在介绍自底向上分析思想基础上，着重介绍算符优先分析法。
栈顶符号串是指该符号串包含栈顶符号在内，并由栈中某个符号为该符号串的头，栈顶符号为该符号串的尾，也可以只有一个栈顶符号。
6.1 自底向上分析概述自底向上分析法，也称移进-归约分析法，或自下而上分析。
现举例说明。
例6.1设文法G[S]为：(1) S→aAcBe(2) A→b(3) A→Ab(4) B→d对输入串abbcde#进行分析，检查该符号串是否是G[S]的句子。
由于自底向上分析的移进-归约过程是自顶向下最右推导的逆过程，而最右推导为规范推导，自左向右的归约过程也称规范归约。
容易看出对输入串abbcde的最右推导是：S aAcBe aAcde aAbcde abbcde由此我们可以构造它的逆过程即归约过程。
先设一个先进后出的符号栈，并把句子左括号"#"号放入栈底，其分析过程如表6.1。
表6.1 用移进-归约对输入串abbcde#的分析过程f6-1-1.swf图6.1 自底向上构造语法树的过程推倒的逆过程为：S aAcBe aAcde aAbcde abbcde对上述分析过程也可看成自底向上构造语法树的过程，每步归约都是构造一棵子树，最后当输入串结束时刚好构造出整个语法树，图6.1(a)(b)(c)(d)给出构造过程，可与表中相应分析步骤对照。
在上述移进-归约或自底向上构造语法树的过程中，我们怎么知道何时移进，何时归约，不能只简单地看成栈顶出现某一产生式的右部就可用相应产生式归约，例如在表6.1分析到第5)步时栈中的符号串是#aAb，栈顶符号串b和Ab分别是产生式(2)，(3)的右部，这时到底用(2)归约还是用(3)归约是自底向上分析要解决的关键问题。
由于移进-归约是规范推导(最右推导)的逆过程，即规范归约(最左归约)。
当一个文法无二义性时，那么它对一个句子的规范推导是唯一的，规范归约也必然是唯一的。
因而每次归约时一定要按当前句型的句柄，也就是说，任何时候栈中的符号串和剩余的输入串组成一个句型，当句柄出现在栈顶符号串中时，则可用句柄归约，这样一直归约到输入串只剩结束符，文法符号栈中只剩开始符号。
这时才能认为输入符号串是文法的句子。
否则为出错。
由此可见自底向上分析的关键问题是在分析过程中如何确定句柄，也就是说如何知道何时在栈顶符号串中已形成某句型的句柄，那么就可以确定何时可以进行归约。
自底向上的分析算法很多，我们仅在本章和第7章介绍目前常用的算符优先分析和LR 类分析法。
小练习：用PL/0的READ(A)语句为例构造自底向上的语法分析树,以体会自底向上的归约过程。
下面为参考答案。
图6.3 自底向上的语法分析6.2 算符优先分析法算符优先分析的基本思想是只规定算符(广义为终结符)之间的优先关系，也就是只考虑终结符之间的优先关系，不考虑非终结符之间的优先关系。
在归约过程中只要找到可归约串就归约，并不考虑归约到那个非终结符名，算符优先分析的可归约串不一定是规范句型的句柄，所以算符优先归约不是规范归约。
算符优先分析的可归约串是当前符号栈中的符号和剩余的输入符号构成句型的最左素短语。
例如:若有文法G为：(1) E→E+E(2) E→E*E(3) E→i对输入串i1+i2*i3的归约过程可表示为表6.3。
表6.3 对输入串i1+i2*i3的归约过程f6-2-2.swf在分析到第6步时，栈顶的符号串为E+E，若只从移进-归约的角度讲，栈顶已出现了产生式(1)的右部，可以进行归约，但从通常四则运算的习惯来看应先乘后加，所以应移进，这就提出了算符优先的问题。
本节所给例子是二义性文法，对二义性文法不能构造确定的分析过程，但是在本例中，人为地规定了算符之间的优先关系，仍然可构造出确定的分析过程。
6.2.1 直观算符优先分析法通常在算术表达式求值过程中，运算次序是先乘除后加减，这说明了乘除运算的优先级高于加减运算的优先级，乘除为同一优先级但运算符在前边的先做，这称为左结合，同样加减运算也是如此，这也说明了运算的次序只与运算符有关，而与运算对象无关，因而直观算符优先分析法的关键是对一个给定文法G，人为地规定其算符的优先顺序，即给出优先级别和同一个级别中的结合性质，算符间的优先关系表示规定如下：a b表示a的优先性低于b。
a b表示a的优先性等于b，即与b相同。
a b表示a的优先性高于b。
但必须注意，这三个关系和数学中的＜，＝，＞是不同的。
当有关系a b时，却不一定有关系b a，当有关系a b时，却不一定有b a，例如：通常表达式中运算符的优先关系有+-，但没有-+，有'('')'，但没有')''('。
下面给出一个表达式的文法为：E→E+E|E－E|E*E|E/E|E↑E|(E)|i本文法是二义性的，由于人为地规定了算符之间的优先级别和同一个级别中的结合性质，所以可能构造出确定的分析过程。
我们可以对此表达式的文法按公认的计算顺序规定优先级和结合性如下：① ↑优先级最高。
遵循右结合，相当↑↑。
例如：2↑3↑2=2↑9=512。
（而若为左结合则2↑3↑2=8↑2=64）也就是同类运算符在归约时为从右向左归约。
即i1↑i2↑i3式先归约i2↑i3。
② *,/ 优先级其次。
服从左结合，相当** 、*/ 、// 、/* 。
③ +，- 优先级最低。
服从左结合，相当++、+- 、-+ 、-- 。
④对'('，')'规定括号的优先性大于括号外的运算符，小于括号内的运算符，内括号的优先性大于外括号。
对于句子括号'#'号规定与它相邻的任何运算符的优先性都比它大。
此外，对运算对象的终结符i其优先级最高。
综上所述，我们可对表达式运算符的优先关系构造如表6.4。
表6.4 算符优先关系表+ - * / ↑( ) i #+-*/↑( ) i #.....很显然所给表达式文法是二义性的，但我们人为直观地给出运算符之间的优先关系，由优先关系表6.4可知这种优先关系是唯一的，有了这个优先关系表我们对前面表达式的输入串i1+i2*i3归约过程就能唯一确定了，也就是说在表6.3分析到第6）步时，栈中出现了#E+E，可归约为E，但当前输入符为'*'，由于规定+*，所以应移进。
本节简单介绍直观算符优先分析法，仅仅是为了易于理解算符优先分析法的概念，下一节将介绍对任意给定的一个文法如何按形式算法的规则计算算符之间的优先关系。
6.2.2 算符优先文法的定义我们首先给出算符文法和算符优先文法的定义。
定义6.1设有一文法G，如果G中没有形如A→…BC…的产生式，其中B和C为非终结符，则称G为算符文法(Operater Grammar)也称OG文法。
例如：表达式文法E→E+E|E*E|(E)|i其中任何一个产生式中都不包含两个非终结符相邻的情况，因此该文法是算符文法。
小练习：学员可证明算符文法有如下两个性质。
性质1在算符文法中任何句型都不包含两个相邻的非终结符。
性质2如果Ab或(bA)出现在算符文法的句型γ中，其中A∈V N，b∈V T，则γ中任何含b的短语必含有A。
参考答案：证明：性质1用归纳法设γ是句型，即SγS=ω0ω1... ωn-1ωn=γ推导长度为n，归纳起点n=1时，S=ω0ω1=γ，即Sγ，必存在产生式S→γ，而由算符文法的定义，文法的产生式中无相邻的非终结符，显然满足性质1。
假设n＞1, ωn-1满足性质1。
若ωn-1=αAδ，A为非终结符。
由假设α的尾符号和δ的首符号都不可能是非终结符，否则与假设矛盾。
又若A→β是文法的产生式，则有ωn-1ωn=αβδ=γ而A→β是文法的原产生式，不含两个相邻的非终结符，所以αβγ也不含两个相邻的非终结符。
满足性质1。
证毕。
证明：性质2用反证法。
因为由算符文法的性质1知可有：Sγ=αbAβ若存在Bαb，这时b和A不同时归约，则必有S BAβ,这样在句型BAβ中存在相邻的非终结符B和A，所以与性质1矛盾，证毕。