编译原理 六章 算符优先分析法
算符优先分析法
算符优先分析过程
输入串 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;}四实验结果。
C.4-算符优先分析法-实验报告
学号
成绩
实 验 报 告
实验题目：算符优先分析法
课程名称：编译原理
主讲教师：
班 级：
实验日期：
提交日期：
1、
实验目的：
采用算符优先分析法对表达式（不包含括号运算）进行分析，并给出四元式。
二、实验内容
在实验1、2的基础上，用算符优先分析法编制语法分析程序。
分析过程：先在算符栈置“＄”，然后开始顺序扫描表达式，若读来的单词符号是操作数，这直接进操作数栈，然后继续读下一个单词符号。分析过程从头开始，并重复进行；若读来的是运算符θ2 则将当前处于运算符栈顶的运算符θ1的入栈优先数f与θ2的比较优先函数g进行比较。
结果
四、我的感想
这次试验可以说是前两个试验的综合了，程序中也很多用到了前两次的代码。对于我自己来说，最难的部分在于将这些思想转换成代码实现出来，很大一部分在于自己平时没有多打代码以及就是对算符优先分析的思想理解得还不够透彻。在写main函数时，因为要调用很多函数，刚开始写的时候陷入了死循环，以及栈函数的各种调用发生错误，说明自己思路还不够清晰。因为这次实验是在考完试后做的，之前对算符优先分析以及四元式的理解不够明白，在这个实验实现成功后，自己能够透彻地了解，知道了算符文法的形式，对给定的算符文法能构造算符优先关系分析表，并判别所给出的文法是否为算符优先文法。同时我也算符优先文法的优缺点以及实际应用中的局限性。
三、程序的改写：
因为这次的实验与前面两次的实验有很大的重合，所以会用到很多之前两次的代码。首先，定义函数：
其中本次需要写的函数有：入栈优先函数f，比较优先函数g，compare，middle，栈函数以及主函数。
1.入栈优先函数f
书上已经给出了入栈优先函数的表，根据输入的符号赋予数值，以便后面方便比较。
编译原理之算符优先分析
编译原理之算符优先分析1.算符优先分析：1.1定义是⼀种简单直观、⼴泛使⽤、便于⼿⼯实现的⾃下⽽上的语法分析⽅法。
1.2原理定义算符之间的某种优先关系，寻找“归约串”，并进⾏归约1.3相关知识拓展1.3.1 算符⽂法:产⽣式的右部不包含两个相继的⾮终结符，即不包含形如：.....QR.....1.3.2 算符优先⽂法:任何终结符对(a,b)⾄多⼀种优先级关系。
1.3.3 构造优先关系表步骤：(1)写出FIRSTVT、LASTVTFIRSTVT(P)={a|P->a.....或P->Qa......}LASTVT(P)={a|P->.....a或P->......aQ} (2)列表，根据优先级填表 1.确定同⼀产⽣式的末尾终结符之间⽆优先关系 2.确定=，再使⽤FIRSTVT、LASTVT1.4 算符优先分析算法 素短语：⾄少包含⼀个终结符且不包含更⼩的终结符，如p*p或 i 最左素短语：最左侧的素短语 缺点：跳过了所有单⾮产⽣式所对应的归约步骤。
（单⾮产⽣式：形如：P->Q ,右部只有⼀个⾮终结符的产⽣式）1.5 构造优先函数使⽤构造优先函数代替优先表f:表⼊栈优先函数、g：表⽐较优先函数1.6 举例S→a|Λ|(T) T->T,S|S(1)基本了解：FIRSTVT(P)={a|P->a.... or Qa....}; LASTVT(P)={a|P->...a or P->....aQ}所以对于：S→a|Λ|(T) 则FIRSTVT(S)={a,Λ,(}对于：S→a|Λ|(T) 则LASTVT(S)={a,Λ,)}对于：T->T,S|S 则FIRSTVT(T)={, ,a,Λ,(}对于：T->T,S|S 则LASTVT(T)={, ,a,Λ,)}(2)优先关系aΛ(),a>>Λ>>(<<<=<)>>,<<<>>,<<<>>由于G[S]中任何终结符对（a,b）之多只有⼀种关系成⽴，所以，G[S]为算符优先⽂法。
编译原理算符优先语法分析实验报告
专题4_算符优先语法分析李若森 13281132 计科1301一、理论传授语法分析的设计方法和实现原理；算符优先文法、最左素短语、算符优先矩阵、优先函数的基本概念；算符优先文法句型最左素短语的确定；算符优先分析算法的实现。
二、目标任务实验项目实现算符优先分析算法，完成以下描述算术表达式的算符优先文法的算符优先分析过程。
G[E]:E→E+T|E-T|TT→T*F|T/F|FF→(E)|i设计说明终结符号i为用户定义的简单变量，即标识符的定义。
加减乘除即运算符。
设计要求(1)构造该算符优先文法的优先关系矩阵或优先函数；(2)输入串应是词法分析的输出二元式序列，即某算术表达式“专题 1”的输出结果，输出为输入串是否为该文法定义的算术表达式的判断结果；(3)算符优先分析程序应能发现输入串出错；(4)设计两个测试用例（尽可能完备，正确和出错），并给出测试结果。
任务分析重点解决算符优先矩阵的构造和算符优先算法的实现。
能力培养深入理解理论对实践的指导作用；基本原理、实现技术和方法的正确运用。
三、实现过程OPG优先关系设G是一OG（简单优先）文法，a,b∈Vt，U,V,W ∈Vn(1)a = b 当且仅当OG有形如U→….ab….或U→….aVb….的规则(2)a < b 当且仅当OG有形如U→….aW….的规则，而且W=+>b….或W=+>Vb…..(3)a > b 当且仅当OG有形如U→….Wb….的规则，而且W=+> …. a或W=+>….aV 若a,b之间至多存在上述三种优先关系之一，OG为OPG（算符优先）文法。
FIRSTVT集和LASTVT集a)FIRSTVT集▪两条原则1.若有规则U→b…或U→Vb…，则b ∈ FIRSTVT(U)2.若有规则U→V…且b ∈ FIRSTVT(V)，则b ∈ FIRSTVT(U)▪过程描述数据结构：STACK栈布尔数组F(U,b) U∈Vn，b∈VtF(U,b) 真 b∈FIRSTVT(U)假 b FIRSTVT(U)▪算法分析初始：F(U,b)初值(根据原则①)F(U,b)为真的(U,b)对进STACK栈循环：直至STACK空(根据原则②)弹出栈顶元素，记(V,b)对每一个形如U→V…的规则若F(U,b) 为假，变为真，进STACK栈若F(U,b) 为真，再循环结果：FIRSTVT(U)={b∣F(U,b)=TRUE}FIRSTVT(E)={ +, -, *, /, (, i }FIRSTVT(T)={ *, /, (, i }b)LASTVT集▪两条原则①若有规则U→…a或U→…aV，则a ∈ LASTVT (U)②若有规则U→…V且a ∈ LASTVT (V)，则a ∈ LASTVT (U) ▪过程描述数据结构：STACK栈布尔数组F(U,a) U∈Vn，a∈VtF(U,a) 真 a∈LASTVT (U)假 a LASTVT (U)▪算法分析初始：F(U,a)初值(根据原则①)F(U,a)为真的(U,a)对进STACK栈循环：直至STACK空(根据原则②)弹出栈顶元素，记(V,a)对每一个形如U→V…的规则若F(U,a) 为假，变为真，进STACK栈若F(U,a)为真，再循环结果： LASTVT (U)={a∣F(U,a)=TRUE}LASTVT(E)={ +, -, *, /, ), i }LASTVT(T)={ *, /, ), i }最左素短语算符优先文法句型的一般形式：#N1a1N2a2…… N n a n N n+1# a i∈V t N i∈V n(可有可无)最左素短语的确定：一个OPG句型的最左素短语是满足以下条件的最左子串：N j a j…..N i a i N i+1其中：a j-1 < a ja j = a j+1 = … = a i-1 = a ia i > a i+1a j-1 < a j = a j+1= … = a i-1 = a i> a i+1 所以，构造OPG优先矩阵算法根据构造OPG优先矩阵算法，可得如下优先关系：+ FIRSTVT(T) LASTVT(E) +- FIRSTVT(T) LASTVT(E) -* FIRSTVT(F) LASTVT(T) */ FIRSTVT(F) LASTVT(T) /( FIRSTVT(E) LASTVT(E) ) ( )# FIRSTVT(E) LASTVT(E) #所以，构造OPG优先矩阵如表3.3所示：+ - * / ( ) i #acc算法框架主要数据结构pair<int, string>:用pair<int, string>来存储单个二元组。
编译原理_选择题 已编辑好
第一章：用高级语言书写的源程序都必须通过编译，产生目标代码后才能投入运行。
这种说法正确的是( )A. 正确B. 不正确C. 不一定D. 都不对32．在编译过程中，组织的符号表是( )A．必须是唯一的B．应当按符号的不同属性分为几个C．可以唯一的也可按符号表不同属性分为几个D．以上均不对37．程序基本块是指( )A．一个子程序B．一个仅有一个入口和一个出口的语句C．一个没有嵌套的程序段D．一组顺序执行的程序段，仅有一个入口和一个出口48．下面不是翻译程序的是( )A．编译程序 B．源程序 C．解释程序 D．汇编程序55．面对众多的源语言的词法分析程序，总体上，超前读入和某种假读处理是( ) A．可以避免的 B．不可以避免的 C．徒劳无益的 D．以上均不对78．在编译过程中，组织的符号表是( )A必须是唯一的B应当按符号的不同属性分为几个C可以唯一的也可按符号表不同属性分为几个D以上均不对66．下面不是与机器无关的优化的是( )A．合并常量 B．消除公共子表达式C．削减运算强度 D．多处理器的优化75．下面哪个不是与机器有关的优化？( )A．寄存器的优化 B．消除公共子表达式C．无用代码的优化 D．多处理器的优化68．程序基本块是指( )A．一个子程序B．一个仅有一个入口和一个出口的语句C．一个没有嵌套的程序段D．一组顺序执行的程序段，仅有一个入口和一个出口70．编译程序根据原程序的什么区分标识符的作用域？( )A．标识符被说明的过程或函数名B．标识符被说明的过程或函数的静态层次C．标识符的行号 D．标识符被说明的过程或函数的动态层次4. 编译程序必须完成的工作有 a .(1) 词法分析(2) 语法分析(3) 语义分析(4) 代码生成(5) 之间代码生成(6) 代码优化a. (1)(2)(3)(4)b. (1)(2)(3)(4)(5)c. (1)(2)(3)(4)(5)(6)d. (1)(2)(3)(4)(6)e. (1)(2)(3)(5)(6)5．编译程序是对_d____。
编译原理 实验3 算符优先分析
编译原理实验3 算符优先分析一、实验目的通过设计编制调试构造FIRSTVT集、LASTVT集和构造算符优先表、对给定符号串进行分析的程序，了解构造算符优先分析表的步骤，对文法的要求，生成算符优先关系表的算法，对给定的符号串进行分析的方法。
二、实验内容1. 给定一文法G，输出G的每个非终结符的FIRSTVT集和LASTVT集。
2. 构造算符优先表。
3. 对给定的符号串进行分析，包含符号栈，符号栈栈顶符号和输入串当前符号的优先级，最左素短语和使用的产生式和采取的动作。
三、程序思路在文法框内输入待判断文法产生式，格式E->a|S,注意左部和右部之间是“->”，每个产生式一行，ENTER键换行。
文法结束再输入一行G->#E#1. 先做文法判断，即可判断文法情况。
2. 若是算符优先文法，则在优先表栏显示优先表。
3. 写入要分析的句子，按回车即可。
4. 在分析过程栏，可以看到整个归约过程情况四、实验结果FunctorFirst.h#include<afx.h>#include<iostream>#include<fstream>#include<string>using namespace std;#define rightlength 20#define product_num 20 // 产生式最多个数#define num_noterminal 26 // 非终结符最多个数#define num_terminal 26 // 终结符最多个数struct Production{char Left;char Right[rightlength];int num;};struct VT{bool vt[num_noterminal][num_terminal];};struct Stack{char P;char a;};class CMyDlg{public:CMyDlg();void InputRule();CString showLastVT();CString showFirstVT();CString shownoTerminal(char G[]);CString showTerminal(char g[]);CString showLeftS(char S[], int j, int k);void InitAll();CString showSentence(CString sen, int start);CString showStack(char S[], int n);void Initarry(char arry[], int n);CString ProdtoCStr(Production prod);int selectProd(int i, int j, char S[]);void preFunctor(CString sen);void insertFirstVT(Stack S[], int &sp, char P, char a);void insertLastVT(Stack S[], int &sp, char P, char a);void ShowPreTable();void createPreTable();char pretable[num_terminal][num_terminal];bool like_Q(Production prod, char Q);void createLastVT();bool likeQ_(Production prod, char Q);bool likeQa_(Production prod);bool like_aQ(Production prod);bool like_a(Production prod);bool likea_(Production prod);bool Dignose(char c);int findg(char c);int findG(char c);void createFirstVT();void createTerminal();void createnoTerminal();void buildProduction(CString s);bool test(CString s);void parse(); // 语法分析CString gram; // 存放文法；Production production[product_num];VT FirstVT;VT LastVT;int locProduct; // 已有产生式个数char G[num_noterminal];char g[num_terminal];int i_G;int i_g;CString m_sen;};FunctorFirst.cpp#include"FunctorFirst.h"CMyDlg::CMyDlg(){}bool CMyDlg::test(CString s) // 测试是否是算符优先文法{bool t = 1;for (int i = 0;i < s.GetLength() - 1;i++)if (s[i] > 64 && s[i] < 91 && s[i + 1]>64 && s[i + 1] < 91){t = 0;break;}return t;}void CMyDlg::InputRule(){string infile;string line;cout <<" 请输入语法文件的路径：";cin >> infile;cout << endl;ifstream input(infile.c_str());if (!input){cout << endl <<"###打不开文件，请确认输入的路径有效###"<< endl;cout <<"请再次运行本程序"<< endl << endl;exit(0);}while (getline(input, line)){if (test(line.c_str()) == 0){cout << endl <<"这不是算符优先文法！"<< endl;exit(0);}buildProduction(line.c_str());}cout << endl <<"这是算符优先文法！"<< endl;input.close();}void CMyDlg::buildProduction(CString s){int i = 0;int j = 0;int k = 0;for (k = 0;k < s.GetLength();k++) // 得到左部{if (s[k] != ' '){production[locProduct].Left = s[k];break;}}for (i = k + 1;i < s.GetLength();i++){if (s[i - 1] == '-'&&s[i] == '>')break;}int temp = i;for (i = temp + 1;i < s.GetLength();i++){if (s[i] != '|'){if (s[i] != ' '){production[locProduct].Right[j] = s[i];j++;production[locProduct].num = j;}}else{locProduct++;production[locProduct].Left = production[locProduct - 1].Left;j = 0;}}locProduct++;}void CMyDlg::createnoTerminal() // 建立非终结符索引{i_G = 0; // 最后一个位置的下一个下标int j = 0;for (int i = 0;i < locProduct;i++){for (j = 0;j < i_G;){if (production[i].Left != G[j])j++;elsebreak;}if (j > i_G - 1){G[i_G] = production[i].Left;i_G++;}}}void CMyDlg::createTerminal() // 建立终结符索引{i_g = 0; // 最后一个位置的下一个下标int j = 0;for (int i = 0;i < locProduct;i++){for (int k = 0;k < production[i].num;k++){char temp = production[i].Right[k];if (Dignose(temp)){for (j = 0;j < i_g;){if (temp != g[j])j++;elsebreak;}if (j > i_g - 1){g[i_g] = temp;i_g++;}}}}}void CMyDlg::createFirstVT() // production已完成，创建FirstVT{int i, j;Stack S[100];int sp = 0;for (i = 0;i < i_G;i++) // 初始化FirstVTfor (j = 0;j < i_g;j++)FirstVT.vt[i][j] = false;for (i = 0;i < locProduct;i++){if (likea_(production[i]))insertFirstVT(S, sp, production[i].Left, production[i].Right[0]);if (likeQa_(production[i]))insertFirstVT(S, sp, production[i].Left, production[i].Right[1]);}while (sp > 0){sp--;char Q = S[sp].P;char a = S[sp].a;for (i = 0;i < locProduct;i++){if (likeQ_(production[i], Q))insertFirstVT(S, sp, production[i].Left, a);}}}void CMyDlg::createLastVT() // 创建Last集{int i, j;Stack S[100];int sp = 0;for (i = 0;i < i_G;i++) // 初始化FirstVT for (j = 0;j < i_g;j++)LastVT.vt[i][j] = false;for (i = 0;i < locProduct;i++){if (like_a(production[i]))insertLastVT(S, sp, production[i].Left,production[i].Right[production[i].num - 1]);if (like_aQ(production[i]))insertLastVT(S, sp, production[i].Left,production[i].Right[production[i].num - 2]);}while (sp > 0){sp--;char Q = S[sp].P;char a = S[sp].a;for (i = 0;i < locProduct;i++){if (like_Q(production[i], Q))insertLastVT(S, sp, production[i].Left, a);}}}int CMyDlg::findG(char c) // 定位c在G中的下标{int i = 0;for (i = 0;i < i_G;i++)if (c == G[i])break;return i;}int CMyDlg::findg(char c) // 定位c在g中的下标{int i = 0;for (i = 0;i < i_g;i++)if (c == g[i])break;return i;}bool CMyDlg::Dignose(char c) // 判断c 是终结符还是非终结符，终结符true，非终结符 false{if (c > 64 && c < 91)return false;elsereturn true;}bool CMyDlg::likea_(Production prod){if (Dignose(prod.Right[0]))return true;elsereturn false;}bool CMyDlg::like_a(Production prod) // 形如P->…a型产生式{if (Dignose(prod.Right[prod.num - 1]))return true;else}bool CMyDlg::like_aQ(Production prod) // 形如P->…aQ型产生式{if (prod.num < 1)return false;else{if (Dignose(prod.Right[prod.num - 2]) && (!Dignose(prod.Right[prod.num - 1])))return true;elsereturn false;}}bool CMyDlg::likeQa_(Production prod){if (prod.num < 1)return false;else{if (Dignose(prod.Right[1]) && (!Dignose(prod.Right[0])))return true;elsereturn false;}}bool CMyDlg::likeQ_(Production prod, char Q){if (prod.Right[0] == Q)return true;elsereturn false;}bool CMyDlg::like_Q(Production prod, char Q){if (prod.Right[prod.num - 1] == Q)return true;else}void CMyDlg::createPreTable() // 创建优先表{// 初始化优先表pretableint i, j;for (i = 0;i < i_g;i++)for (j = 0;j < i_g;j++)pretable[i][j] = ' '; // 表错误for (j = 0;j < locProduct;j++){for (i = 0;i < production[j].num - 1;i++){char xi, xi1, xi2;xi = production[j].Right[i];xi1 = production[j].Right[i + 1];xi2 = production[j].Right[i + 2];if (Dignose(xi) && Dignose(xi1))pretable[findg(xi)][findg(xi1)] = '=';if (i < production[j].num - 2 && Dignose(xi) && Dignose(xi2) && (!Dignose(xi1)))pretable[findg(xi)][findg(xi2)] = '=';if (Dignose(xi) && (!Dignose(xi1))){int N = findG(xi1);for (int k = 0;k < i_g;k++)if (FirstVT.vt[N][k] == true)pretable[findg(xi)][k] = '<';}if ((!Dignose(xi)) && Dignose(xi1)){int N = findG(xi);for (int k = 0;k < i_g;k++)if (LastVT.vt[N][k] == true)pretable[k][findg(xi1)] = '>';}}}}void CMyDlg::ShowPreTable() // 显示相关集合和优先表{CString str = "";str = str +"终结符"+ showTerminal(g) +"\r\n";str = str +"非终结符"+ shownoTerminal(G) +"\r\n";str = str +"First集合：\r\n"+ showFirstVT();str = str +"Lasst集合：\r\n"+ showLastVT();str = str +" | ";int i, j;for (i = 0;i < i_g;i++)str = str + g[i] +" | ";str = str +"\r\n";for (j = 0;j < i_g;j++)str = str +"…………";str +="\r\n";for (i = 0;i < i_g;i++){str = str + g[i] +" | ";for (j = 0;j < i_g;j++)str = str + pretable[i][j] +" | ";str +="\r\n";for (j = 0;j < i_g;j++)str = str +"…………";str +="\r\n";}cout << str.GetBuffer(1000);}void CMyDlg::insertFirstVT(Stack S[], int &sp, char P, char a) {if (FirstVT.vt[findG(P)][findg(a)] == false){FirstVT.vt[findG(P)][findg(a)] = true;S[sp].P = P;S[sp].a = a;sp++;}}void CMyDlg::insertLastVT(Stack S[], int &sp, char P, char a){if (LastVT.vt[findG(P)][findg(a)] == false){LastVT.vt[findG(P)][findg(a)] = true;S[sp].P = P;S[sp].a = a;sp++;}}void CMyDlg::preFunctor(CString sen) // 算符优先分析过程实现{bool tagbreak = true;char S[100];int k = 0;S[k] = '#';int i = 0; // 表下次读入位置int j = 0;//char a;CString show = "";CString temp = "";temp.Format("%-15s %s %15s %-15s%-10s%-15s\r\n\r\n", "符号栈", "关系", "输入串", "最左素短语", "使用产生式", "下步动作");show = show + temp;temp ="";CString s_stack, s_sentence, s_lefts, s_prod, s_action;char s_presymbol;do{a = sen[i];if (Dignose(S[k]))j = k;elsej = k - 1;while (pretable[findg(S[j])][findg(a)] == '>'){s_stack = showStack(S, k);s_presymbol = pretable[findg(S[j])][findg(a)];s_sentence = showSentence(sen, i);char Q;do{Q = S[j];if (Dignose(S[j - 1]))j = j - 1;elsej = j - 2;} while (pretable[findg(S[j])][findg(Q)] == '>' ||pretable[findg(S[j])][findg(Q)] == '=');int n = selectProd(j + 1, k, S);if (n > -1 && n < locProduct){s_lefts = showLeftS(S, j + 1, k);k = j + 1;S[k] = production[n].Left;s_prod = ProdtoCStr(production[n]);s_action ="归约";temp.Format("%-15s %c %15s %-15s %-10s %-15s\r\n", s_stack, s_presymbol, s_sentence, s_lefts, s_prod, s_action);show = show + temp;s_stack ="";s_sentence ="";s_lefts ="";s_prod ="";s_action ="";s_presymbol = ' ';}else{s_stack = showStack(S, k);s_presymbol = 'n';s_prod ="出错";s_sentence = showSentence(sen, i);s_action ="无法归约";temp.Format("%-15s %c %15s %-15s %-10s %-15s\r\n",s_stack, s_presymbol, s_sentence, s_lefts, s_prod, s_action);show = show + temp;s_stack ="";s_sentence ="";s_lefts ="";s_prod ="";s_action ="";s_presymbol = ' ';tagbreak = false;break;}}if (!tagbreak)break;if (pretable[findg(S[j])][findg(a)] == '<' ||pretable[findg(S[j])][findg(a)] == '='){s_stack = showStack(S, k);s_presymbol = pretable[findg(S[j])][findg(a)];s_sentence = showSentence(sen, i);s_action ="入栈";temp.Format("%-15s %c %15s %-15s %-10s %-15s\r\n", s_stack, s_presymbol, s_sentence, s_lefts, s_prod, s_action);show = show + temp;k = k + 1;S[k] = a;s_stack ="";s_sentence ="";s_lefts ="";s_prod ="";s_action ="";s_presymbol = ' ';}else{s_stack = showStack(S, k);s_presymbol = 'n';s_prod ="出错";s_sentence = showSentence(sen, i);s_action ="出错";temp.Format("%-15s %c %15s %-15s %-10s %-15s\r\n", s_stack, s_presymbol, s_sentence, s_lefts, s_prod, s_action);show = show + temp;s_stack ="";s_sentence ="";s_lefts ="";s_prod ="";s_action ="";s_presymbol = ' ';break;}i++;} while (a != '#');show = show +"完成";cout << show.GetBuffer(1000) << endl << endl;}void CMyDlg::parse(){string sen;cout << endl << endl <<" 请输入分析的句子：";cin >> sen;cout << endl << endl;m_sen = sen.c_str();}int CMyDlg::selectProd(int i, int j, char S[]) // 查找产生式{int n = -1;int k = 0;for (k = 0;k < locProduct;k++){if (j - i == production[k].num - 1){int si = i;for (int m = 0;m < production[k].num;m++){if (S[si] == production[k].Right[m] || ((!Dignose(S[si])) &&(!Dignose(production[k].Right[m]))))si++;elsebreak;}if (si == j + 1){n = k;break;}}}return n;}CString CMyDlg::ProdtoCStr(Production prod){CString str = "";str = str +prod.Left +"->";for (int i = 0;i < prod.num;i++)str = str +prod.Right[i];return str;}void CMyDlg::Initarry(char arry[], int n)//初始化数组{for (int i = 0;i < n;i++)arry[i] = ' ';}CString CMyDlg::showStack(char S[], int n)//显示符号栈，n表栈大小{CString str = "";for (int i = 0;i <= n;i++)str = str +S[i];return str;}CString CMyDlg::showSentence(CString sen, int start){CString str = "";for (int i = start;i < sen.GetLength();i++)str = str +sen[i];return str;}void CMyDlg::InitAll(){gram ="";i_G = 0;i_g = 0;locProduct = 0;}// 以下是为了便于显示，将数组型转换成CString型CString CMyDlg::showLeftS(char S[], int j, int k) {CString str = "";for (int i = j;i <= k;i++)str = str +S[i];return str;}CString CMyDlg::showTerminal(char g[]){CString str = "{";for (int i = 0;i < i_g;i++)str = str +g[i] +" ";return str +"}";}CString CMyDlg::shownoTerminal(char G[]){CString str = "{";for (int i = 0;i < i_G;i++)str = str +G[i] +" ";return str +"}";}CString CMyDlg::showFirstVT(){CString str = "";for (int i = 0;i < i_G;i++){str = str +"FirstVT( "+ G[i] +" )={ ";for (int j = 0;j < i_g;j++){if (FirstVT.vt[i][j])str = str + g[j] +' ';}str = str +" }\r\n";}return str;}CString CMyDlg::showLastVT(){CString str = "";for (int i = 0;i < i_G;i++){str = str +"LastVT( "+ G[i] +" )={ ";for (int j = 0;j < i_g;j++){if (LastVT.vt[i][j])str = str + g[j] +' ';}str = str +" }\r\n";}return str;}FFmain.cpp#include"FunctorFirst.h"void main(){CMyDlg ff;ff.gram ="";ff.locProduct = 0; // 已有产生式个数ff.InputRule();ff.createnoTerminal(); // 建立非终结符索引ff.createTerminal(); // 建立终结符索引ff.createFirstVT(); // 建立FirstVTff.createLastVT(); // 建立LastVTff.createPreTable(); // 建立优先表ff.ShowPreTable();ff.parse();if (ff.m_sen[ff.m_sen.GetLength() - 1] != '#') ff.m_sen = ff.m_sen +'#';ff.preFunctor(ff.m_sen);}。
编译原理算符优先算法语法分析实验报告
编译原理算符优先算法语法分析实验报告实验报告：算符优先算法的语法分析一、实验目的本次实验旨在通过算符优先算法对给定的文法进行语法分析，实现对给定输入串的分析过程。
通过本次实验，我们能够了解算符优先算法的原理和实现方式，提升对编译原理的理解和应用能力。
二、实验内容1.完成对给定文法的定义和构造2.构造算符优先表3.实现算符优先分析程序三、实验原理算符优先算法是一种自底向上的语法分析方法，通过构造算符优先表来辅助分析过程。
算符优先表主要由终结符、非终结符和算符优先关系组成，其中算符优先关系用1表示优先关系，用2表示不优先关系，用0表示无关系。
算符优先分析程序的基本思路是：根据算符优先关系，依次将输入串的符号压栈，同时根据优先关系对栈内符号进行规约操作，最终判断输入串是否属于给定文法。
四、实验步骤1.定义和构造文法在本次实验中，我们假设给定文法如下：1)E->E+T，T2)T->T*F，F3)F->(E)，i2.构造算符优先表根据给定文法，构造算符优先表如下：+*()i#+212112*222112(111012222122i222222#1112203.实现算符优先分析程序我们可以用C语言编写算符优先分析程序，以下是程序的基本框架：```c#include <stdio.h>//判断是否为终结符int isTerminal(char c)//判断条件//匹配符号int match(char stack, char input)//根据算符优先关系表进行匹配//算符优先分析程序void operatorPrecedence(char inputString[]) //定义栈char stack[MAX_SIZE];//初始化栈//将#和起始符号入栈//读入输入串//初始化索引指针//循环分析输入串while (index <= inputLength)//判断栈顶和输入符号的优先关系if (match(stack[top], inputString[index])) //栈顶符号规约} else//符号入栈}//计算新的栈顶}//判断是否成功分析if (stack[top] == '#' && inputString[index] == '#')printf("输入串符合给定文法！\n");} elseprintf("输入串不符合给定文法！\n");}```五、实验结果经过实验，我们成功实现了算符优先算法的语法分析。
编译原理六章算符优先分析法
编译原理六章算符优先分析法第六章算符优先分析法课前索引【课前思考】◇什么是自下而上语法分析的策略？◇什么是移进-归约分析？◇移进-归约过程和自顶向下最右推导有何关系？◇自下而上语法分析成功的标志是什么？◇什么是可归约串？◇移进-归约过程的关键问题是什么？◇如何确定可归约串？◇如何决定什么时候移进，什么时候归约？◇什么是算符文法？什么是算符优先文法？◇算符优先分析是如何识别可归约串的？◇算符优先分析法的优缺点和局限性有哪些？【学习目标】算符优先分析法是自下而上（自底向上）语法分析的一种，尤其适应于表达式的语法分析，由于它的算法简单直观易于理解，因此，也是学习其它自下而上语法分析的基础。
通过本章学习学员应掌握：◇对给定的文法能够判断该文法是否是算符文法◇对给定的算符文法能够判断该文法是否是算符优先文法◇对给定的算符文法能构造算符优先关系表，并能利用算符优先关系表判断该文法是否是算符优先文法。
◇能应用算符优先分析算法对给定的输入串进行移进-归约分析，在分析的每一步能确定当前应移进还是归约，并能判断所给的输入串是否是该文法的句子。
◇了解算符优先分析法的优缺点和实际应用中的局限性。
【学习指南】算符优先分析法是自下而上语法分析的一种，它的算法简单、直观、易于理解，所以通常作为学习其它自下而上语法分析的基础。
为学好本章内容，学员应复习有关语法分析的知识，如：什么是语言、文法、句子、句型、短语、简单短语、句柄、最右推导、规范归约基本概念。
【难重点】◇通过本章学习后，学员应该能知道算符文法的形式。
◇对一个给定的算符文法能构造算符优先关系分析表，并能判别所给文法是否为算符优先文法。
◇分清规范句型的句柄和最左素短语的区别，进而分清算符优先归约和规范归约的区别。
◇算符优先分析的可归约串是句型的最左素短语，在分析过程中如何寻找可归约串是算符优先分析的关键问题。
对一个给定的输入串能应用算符优先关系分析表给出分析（归约）步骤，并最终判断所给输入串是否为该文法的句子。
第六章 算符优先分析文法
E’→#E# E→E+T|T T→T*F|F F→P↑F|P P→（E）|i （ ）
直接看产生式的右部， 直接看产生式的右部，若出现了 →…ab ab…或 →…a A → ab 或A → aBb，则a=b
25
求 < 关系
• 求出每个非终结符B的FIRSTVT(B) 求出每个非终结符 的 • 若A→…aB…，则∀b∈FIRSTVT(B)，a<b ， ∈ ， E’→#E# FIRSTVT(E’) ={#} E→E+T|T FIRSTVT(E) ={+,*,↑, ( , i } T→T*F|F FIRSTVT(T) ={*,↑, ( , i } F→P↑F|P FIRSTVT(F) ={↑, ( , i } P→（E）|i （ ） FIRSTVT(P) ={ ( , i } E’→#E#且P→(E)则{#,(}<FIRSTVT(E) → E#且P→(E)则{#,( FIRSTVT(E) # < + , # <* ,#<↑ , #< (,# <I, (< +,( <*, (<↑ , (<( ,( <i
16
如果Ab或 如果 或（bA）出现在算符文法的句型γ中， ）出现在算符文法的句型γ 其中A∈ ， 其中 ∈VN， b ∈ VT，则γ中任何含 的短语必 ， 中任何含b的短语必 含有A。 含有 。
* S => γ =abAβ
γ中含b的短语不含有 。 中含 的短语不含有A。 不含有
S a BB AB β b
当且仅当G中含有形如A 的产生式， a > b当且仅当G中含有形如A→…Bb…的产生式， B 的产生式 ＋ 且B＋ …a或B⇒…aC 。 ⇒ a a 所以不是算符优先文法。 所以不是算符优先文法。 21
《编译原理》第6章 (1)
…a
a >b
24
由定义直接构造：
预备知识：
定义两个集合：
+ + FIRSTVT(B)={b|B b…或B Cb…},
+ + LASTVT(B)={b|B …b或B …bC}
即最后一个终结符 即第一个终结符
25
三种优先关系的计算为： a)≡关系 条件：A…ab... A…aBb… b) <关系 条件:A…aB… bFIRSTVT(B) 结论:a<b c) >关系 条件:A…Bb… aLASTVT(B) 结论:a>b
20
定义：设G是不含产生式的算符文法,若G中任何两个终 结符号之间至多有一种优先关系存在，则G是一个算符 优先文法OPG。 注：不允许有ab、 a≡b、 ab 中的两种同时存在 要完成运算符间优先级的比较，最简单的办法是先定义 各种可能相继出现的运算符的优先级，并将其表示成矩 阵形式，即得到一个算符优先关系表。在分析过程中通 过查询矩阵元素而获得算符间的优先关系。
了解算符优先分析法的优缺点和实际应用中的局限性
2
【学习指南】
算符优先分析法是自下而上语法分析的一种，它的算
法简单、直观、易于理解，故通常作为学习其它自下 而上语法分析的基础。在学习前，应复习有关语法分 析的知识，如：什么是语言、文法、句子、句型、短 语、简单短语、句柄、最右推导、规范归约基本概念
S
A
A→Ab
最右推导 句型
abbcde
句柄 归约用规则 b A→b
S→aAcBe
aAbcde
Ab
d
A→Ab
B→d
A
A→b
B
B→d
aAcde
算符优先分析法详解
四川大学计算机学院 金军
12
2
优先表构造算法
FOR 每一条产生式P→X1X2…Xn FOR i:=1 TO n-1 DO BEGIN IF Xi 和 Xi+1 均为终结符 THEN 置 Xi=Xi+1 IF I<=n-2且Xi和Xi+2都为终结符，而Xi+1 为非终结符， THEN置Xi=Xi+2 IF Xi为终结符而Xi+1为非终结符 THEN FOR FISTVT(Xi+1)中的每个a DO 置 Xi< a IF Xi为非终结符而Xi+1为终结符THEN FOR LASTVT(Xi)中的每个a DO 置 Xi >a END
四川大学计算机学院 金军
1
算符优先文法
现在按照算符优先分析法的设计思路，构 造一种文法，通过它可以自动产生终结符 的优先关系表。
算符优先文法
一个文法，如果它的任何产生式的右部都 不含两个相继（并列）的非终结符，即不 含如下形式的产生式右部：
…QR…
则我们称该文法为算符文法。 在后面的定义中，a、b代表任意终结符； P、Q、R代表任意非终结符；‘…’代表有 终结符和非终结符组成的任意序列，包括 空字。
LASTVT(U)的构造：
若有产生式U → …a或U → …aV，则 a∈LASTVT(U)； 若a∈LASTVT(V)，且有产生式U → …V，则 a∈LASTVT(U)。
四川大学计算机学院 金军 9 四川大学计算机学院 金军 10
FIRSTVT构造算法
建立一个二维布尔数组F[P, a]，使得F[P, a]为真的条件适当且仅当a∈FIRSTVT(P)； 再用一个栈STACK，把所有初值为真的数 组元素F[P, a]的符号对(P, a)全都放到栈 中，对栈施加如下操作：
- 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矛盾，证毕。