语法分析自下而上分析
第5章 语法分析(2)自下而上分析
则成功，达不到这种格局则输入串有错误。
栈中符号串+剩余输入串 = 规范句型。
26
规范归约分析算法
1. 在栈底放入# ，在输入串尾附上#; 2. 逐个移入输入符号,当栈顶形成句柄时，进行归约; 3. 重复2 直到输入串已全部进栈，仅剩#, 4. 若栈中归约为#S, 表示分析成功，输入串为合法的 句子,否则为非法句子.
2
5.1 自下而上分析的基本问题
自下而上分析法的基本思想：
从输入串出发，反复利用产生式逐步进行 ‚归约‛，如果最后能归约到文法的开始符 号，则输入串是句子，否则输入串有语法错 误。
各种不同自下而上分析法一个共同特点是：
边输入单词符号（移进栈），边归约；
3
5.1 自下而上分析的基本问题
自下而上分析的基本技术是采用归约栈,如下图所示: #
或者说从文法的开始符号产生句子。
自下而上分析采用的方法是归约，从叶子到根构造分析树。
或者说从句子开始归约出文法的开始符号。
语法树的一个子树：由该树的某个结连同它的所有子孙组成。 在自下而上分析过程中，每一步归约都可画出一棵子树。
例如,上例中的归约过程可描述为如下分析树:
9
例5.2：文法G[S], 其4条产生式如下： ① S→aABe ② A→b ③ A→Abc ④ B→d 对句子abbcde的分析 最右推导 SaABeaAdeaAbcdeabbcde 最左归约 abbcde，aAbcde ，aAde，aABe ，S S S aABe aAde aAbcde abbcde
S （2）每次归约用的句柄： ， (a,(a))， ， ， ， ， ， ( (L,(S)) (L,(L)) (L,S) (L) S (S,(a)) (L,(a)) L )
实验5---语法分析器(自下而上)：LR(1)分析法
实验5---语法分析器（自下而上）：LR(1)分析法一、实验目的构造LR(1)分析程序，利用它进行语法分析，判断给出的符号串是否为该文法识别的句子，了解LR（K）分析方法是严格的从左向右扫描，和自底向上的语法分析方法。
二、实验内容程序输入/输出示例（以下仅供参考）：对下列文法，用LR（1）分析法对任意输入的符号串进行分析：（1）E->E+T（2）E->E—T（3）T->T*F（4）T->T/F（5）F-> (E)（6）F->i输出的格式如下：(1)LR（1）分析程序，编制人：姓名，学号，班级(2)输入一个以#结束的符号串(包括+—*/（）i#)：在此位置输入符号串(3)输出过程如下：3.对学有余力的同学，测试用的表达式事先放在文本文件中，一行存放一个表达式，同时以分号分割。
同时将预期的输出结果写在另一个文本文件中，以便和输出进行对照。
三、实验方法1．实验采用C++程序语言进行设计，文法写入程序中，用户可以自定义输入语句；2．实验开发工具为DEV C++。
四、实验步骤1．定义LR(1)分析法实验设计思想及算法①若ACTION[sm , ai] = s则将s移进状态栈，并把输入符号加入符号栈，则三元式变成为：(s0s1…sm s , #X1X2…Xm ai , ai+1…an#)；②若ACTION[sm , ai] = rj则将第j个产生式A->β进行归约。
此时三元式变为(s0s1…sm-r s , #X1X2…Xm-rA , aiai+1…an#)；③若ACTION[sm , ai]为“接收”，则三元式不再变化，变化过程终止，宣布分析成功；④若ACTION[sm , ai]为“报错”，则三元式的变化过程终止，报告错误。
2．定义语法构造的代码，与主代码分离，写为头文件LR.h。
3．编写主程序利用上文描述算法实现本实验要求。
五、实验结果1. 实验文法为程序既定的文法，写在头文件LR.h中，运行程序，用户可以自由输入测试语句。
第5章 语法分析——自下而上
B d
e
SaAcBeaAcdeaAbcdeabbcde SS→aAcBeB→d A→Ab A→b
每次归约的都是句型中的句柄。
22
算符优先分析法
LR分析法
23
1. LR分析法介绍
2. LR(0)分析表的构造
3. SLR分析表的构造
24
从左（Left,L）向右扫描输入串，构造一 个最右推导（Rightmost,R）的逆过程 进行规范归约（最左归约），每次归约 的都是真正的句柄； 对文法限制最少，是识别效率较强的方 法； 出错处理能力较强； 采用自动构造技术（构造LR分析表）
B
e
A
b
d
S → aAcBe A → Ab A→b B→d
b
分 析 树
输入串：abbcde
7
短语 直接短语 句柄
8
定义：设文法G的开始符号为S，是文法 *则称β是 的一个句型，若有SA且Aβ, + 相对于非终结符A的一个短语。 句型
短语是指句型中的某个部分，这部分可以由某 个非终结符推出。 可以利用语法树来找出句型中的所有短语。
查表 A[0,a]=s2，进栈 A[2,a]=s2，进栈 A[2,b]=s5，进栈 A[5,b]=r2，按第2条产生式归约 G[2,A]=3，进入状态3 A[3,b]=s4，进栈 A[4,#]=r1，归约 G[0,A]=1，进入状态1 A[1,#]=acc 31
对于一个文法，如果能够构造一张分析表， 使得它的每个入口均是唯一确定的，则我们 把这个文法称为LR文法。
33
前缀：字的任意首部。即移去符号尾
部零个或多于零个符号得到的一个符
号串。 例：abc的前缀有ε,a, ab, abc
第04章-语法分析自上而下分析
输入符号串是否为一个句子。 ▪ 语法分析器在编译器中的地位：
源程序
单词符号
词法分析器
取下一个单 词符号
语法分析器
语法分析树
编译器的 后继部分
2021/4/6
符号表
3
4.1 语法分析器的功能
▪ 语法分析方法
➢ 自上而下分析法
从文法的开始符号出发，反复使用文法的产生式， 寻找与输入符号串匹配的推导。
分析输入串x*y(记为)。
xx**yy
SS
IPIPIP xx A y * **
2021/4/6
7
4.2 自上而下分析面临的问题
▪ 当某个非终结符有多个产生式候选时，可 能带来如下问题：
➢ 1.分析过程中，当一个非终结符用某一个候选 匹配成功时，这种匹配可能是暂时的。这时， 不得不“回溯”。
➢ 2.文法左递归问题。一个文法是含有左递归的 ，如果存在非终结符P
➢ 最后所得的无左递归文法是： S→Qc | c Q→Rb | b R→bcaR | caR |a R R→ bca R |
➢ 不同排序所得的文法的等价性是显然的。
2021/4/6
17
4.3.2 消除回溯、提左因子
▪ 为了消除回溯就必须保证：对文法的任何 非终结符，当要它去匹配输入串时，能够 根据它所面临的输入符号准确地指派它的 一个候选去执行任务，并且此候选的工作 结果应是确信无疑的。
2021/4/6
14
4.3.1 左递归的消除
▪ 例4.3 考虑文法G(S)
S→Qc|c Q→Rb|b R→Sa|a
➢ 令它的非终结符的排序为R、Q、S。 ➢ 对于R，不存在直接左递归。 ➢ 把R代入到Q的有关候选后，把Q的规则变为
第四章 语法分析——自上而下分析
解二： 规定顺序：S、Q、R
则等价的无左递归的文法： SQc | c QRb| b RbcaR’ | caR’ | aR’ R’bcaR’ |
RSa | a RQca | ca | a
RRbca|bca | ca | a
RbcaR’|caR’ | aR’ R’ bcaR’|
（因为不需要试探某个候选式，而是准确地指派 某个候选式）
17
终结首符集FIRST
令文法G不含左递归，对它的所有非终结符的每 个候选式定义终结首符集 FIRST(): * FIRST()={a | a , a∈VT }
特别地 * 若 ，则规定 ∈ FIRST()
显然， FIRST()是从推导出的所有可能的开头终 结符a或 。
3
§4.2 自上而下分析面临的问题
一、带‚回溯‛的自上而下分析方法：
自上而下分析方法，就是对任何输入串，试 图用一切可能的方法，从文法的开始符号出发， 自上而下地为输入串建立一个语法树（或最左推 导）。 这种分析过程实质上是一种试探过程，即反 复使用不同的产生式以求能匹配输入串。
4
例4.1 设有文法： SxAy
解： S iCtSA | a
A | eS
C b
22
4.3.3 LL（1）分析条件 当一个文法不含左递归，并且满足每个非终结 符的所有候选首符集两两不相交，是不是一定能进 行有效的自上而下的语法分析呢？
若存在 ∈ FIRST() ，则问题较复杂，需要进 一步考虑。 定义：非终结符A的 FOLLOW 集：
* FOLLOW（A）= { a| S …Aa… ，a∈VT } 特别地， * 若S …A，则规定，构造FIRST（X）
a) 若X∈VT，则 FIRST(X)={X}。
程序设计语言与编译原理_自下而上的语法分析
第8章 自下而上的语法分析 第一节 引言
自下而上分析：从输入串出发，归约， 直至开始符 方法：采用栈，在移进的过程中，观察栈顶是否 形成某个产生式的一个候选
程序设计语言与编译
自下而上分析法(Bottom-up)
» 基本思想：
从输入串开始，逐步进行“归约”，直到文法的开 始符号。所谓归约，是指根据文法的产生式规则， 把产生式的右部替换成左部符号。
程序问设题计的语提言出与：编译
① 在构造语法树的过程中，何时归约？ 当可归约串出现在栈顶时就进行归约。
② 如何知道在栈顶符号串中已经形成可归约串？ 如何进行归约？ 通过不同的自底向上的分析算法来解释，不同的
算法对可归约串的定义是不同的，但分析过程都有一 个共同的特点：边移进 边归约。
规范归约：使用句柄来定义可归约串。 算符优先：使用最左素短语来定义可归约串
E1
8个内部节点—— 8棵子树 句型η 有8个短语：
E2 + T3
i1*i2+i3是句型η 相对于E1的短语
T4
F5
i1*i2是句型η 相对于E2 ,T4的短语
i1是句型η 相对于T6 ，F8的短语 i2是句型η 相对于F7的短语
T6 * F7
i3
i3是句型η 相对于T3,F5的短语
步骤: 1 2 3 4 5 6 7 8 9 10 动作: 进a 进b 归(2) 进b 归(3) 进c 进d 归(4) 进e 归(1)
e
dBB
b
cccc
bAAAAAAA
aaaaaaaaaS
程序设计语言与编译
S
分析树
aA c
Be
A
bd
b
分析树和语法树不一定一致。 自下而上分析过程：边输入单词符号，边 归约。 核心问题：识别可归约串
语法分析—自上而下分析
9
§4.2 自上而下面临的问题
例：文法 SxAy A**|*
输入串α :x*y
S x Ay
S x Ay **
S x Ay
*
10
注：
• 回溯法也称试探法，它的基本思想是：从问题的 某一种状态（初始状态）出发，搜索从这种状态 出发所能达到的所有“状态”，当一条路走到“ 尽头”的时候（不能再前进），再后退一步或若 干步，从另一种可能“状态”出发，继续搜索， 直到所有的“路径”（状态）都试探过。这种不 断“前进”、不断“回溯”寻找解的方法，就称 作“回溯法”。
三、分析条件
1.当一个文法不含左递归,并且满足每个非终结符的 所有候选首符集两两不相交的条件,是不是就一定能 进行有效的自上而下分析了呢?
28
§4.3 LL(1)分析法
例：文法
EE+T|T TT*F|F F（E）|i
Ｅ T E’
经消去直接左递归后变成 ETE’ E’+TE’|ℇ TFT’ T’*FT’|ℇ F（E） ｜i
FIRST(A)
2.A→ε
3.A→X1 X2......XK
*
(1) * a..X2....... FIRST(X1)/{ε}
(2) * ε X2.......
FIRST(X2)/{ε}
ε
(3) * εε......ε
36
FIRST集
1.First(X)集合构造，X∈VT∪VN
例：求下题的FIRST集
25
§4.3 LL(1)分析法
3.提取公共左因子 A.事实上，许多文法均存在这样的非终结符，
其所有候选的终结首符集并非两两不相交。
编译原理实验三-自下而上语法分析及语义分析.docx
电力学院编译原理课程实验报告实验名称：实验三自下而上语法分析及语义分析院系：计算机科学与技术学院专业年级：学生：学号：指导教师：实验日期：实验三自上而下的语法分析一、实验目的：通过本实验掌握LR分析器的构造过程，并根据语法制导翻译，掌握属性文法的自下而上计算的过程。
二、实验学时：4学时。
三、实验容根据给出的简单表达式的语法构成规那么〔见五〕，编制LR分析程序，要求能对用给定的语法规那么书写的源程序进展语法分析和语义分析。
对于正确的表达式，给出表达式的值。
对于错误的表达式，给出出错位置。
四、实验方法采用LR分析法。
首先给出S-属性文法的定义〔为简便起见，每个文法符号只设置一个综合属性，即该文法符号所代表的表达式的值。
属性文法的定义可参照书137页表6.1〕，并将其改造成用LR分析实现时的语义分析动作〔可参照书145页表6.5〕。
接下来给出LR分析表。
然后程序的具体实现：●LR分析表可用二维数组〔或其他〕实现。
●添加一个val栈作为语义分析实现的工具。
编写总控程序，实现语法分析和语义分析的过程。
注：对于整数的识别可以借助实验1。
五、文法定义简单的表达式文法如下：(1)E->E+T(2)E->E-T(3)E->T(4)T->T*F(5)T->T/F(6)T->F(7)F->(E)(8)F->i五、处理程序例和处理结果例例如1：20213191*(20213191+3191)+ 3191#六、源代码【cifa.h】//cifa.h#include<string>using namespace std;//单词构造定义struct WordType{int code;string pro;};//函数声明WordType get_w();void getch();void getBC();bool isLetter();bool isDigit();void retract();int Reserve(string str); string concat(string str); 【Table.action.h】//table_action.hclass Table_action{int row_num,line_num;int lineName[8];string tableData[16][8]; public:Table_action(){row_num=16;line_num=8;lineName[0]=30;lineName[1]=7;lineName[2]=13;lineName[3]=8;lineName[4]=14;lineName[5]=1;lineName[6]=2;lineName[7]=15;lineName[8]=0;for(int m=0;m<row_num;m++)for(int n=0;n<line_num;n++)tableData[m][n]="";tableData[0][0]="S5";tableData[0][5]="S4";tableData[1][1]="S6";tableData[1][2]="S12";tableData[1][7]="acc";tableData[2][1]="R3";tableData[2][3]="S7"; tableData[2][4]="S13"; tableData[2][6]="R3"; tableData[2][7]="R3"; tableData[3][1]="R6"; tableData[3][2]="R6"; tableData[3][3]="R6"; tableData[3][4]="R6"; tableData[3][6]="R6"; tableData[3][7]="R6"; tableData[4][0]="S5"; tableData[4][5]="S4"; tableData[5][1]="R8"; tableData[5][2]="R8"; tableData[5][3]="R8"; tableData[5][4]="R8"; tableData[5][6]="R8"; tableData[5][7]="R8"; tableData[6][0]="S5"; tableData[6][5]="S4"; tableData[7][0]="S5";tableData[8][1]="S6"; tableData[8][2]="S12"; tableData[8][6]="S11"; tableData[9][1]="R1"; tableData[9][2]="R1"; tableData[9][3]="S7"; tableData[9][4]="S13"; tableData[9][6]="R1"; tableData[9][7]="R1"; tableData[10][1]="R4"; tableData[10][2]="R4"; tableData[10][3]="R4"; tableData[10][4]="R4"; tableData[10][6]="R4"; tableData[10][7]="R4"; tableData[11][1]="R7"; tableData[11][2]="R7"; tableData[11][3]="R7"; tableData[11][4]="R7"; tableData[11][6]="R7"; tableData[11][7]="R7";tableData[12][5]="S4";tableData[13][0]="S5";tableData[13][5]="S4";tableData[14][1]="R2";tableData[14][2]="R2";tableData[14][3]="S7";tableData[14][4]="S13";tableData[14][6]="R2";tableData[14][7]="R2";tableData[15][1]="R5";tableData[15][2]="R5";tableData[15][3]="R5";tableData[15][4]="R5";tableData[15][5]="R5";tableData[15][6]="R5";tableData[15][7]="R5";}string getCell(int rowN,int lineN) {int row=rowN;int line=getLineNumber(lineN);if(row>=0&&row<row_num&&line>=0&&line<=line_num) return tableData[row][line];elsereturn"";}int getLineNumber(int lineN){for(int i=0;i<line_num;i++)if(lineName[i]==lineN)return i;return -1;}};【Table_go.h】//table_go.hclass Table_go{int row_num,line_num;//行数、列数string lineName[3];int tableData[16][3];public:Table_go(){row_num=16;line_num=3;lineName[0]="E";lineName[1]="T";lineName[2]="F";for(int m=0;m<row_num;m++)for(int n=0;n<line_num;n++)tableData[m][n]=0;tableData[0][0]=1;tableData[0][1]=2;tableData[0][2]=3;tableData[4][0]=8;tableData[4][1]=2;tableData[4][2]=3;tableData[6][1]=9;tableData[6][2]=3;tableData[7][2]=10;tableData[12][1]=14;tableData[12][2]=3;tableData[13][2]=15;}int getCell(int rowN,string lineNa){int row=rowN;int line=getLineNumber(lineNa);if(row>=0&&row<row_num&&line<=line_num) return tableData[row][line];elsereturn -1;}int getLineNumber(string lineNa){for(int i=0;i<line_num;i++)if(lineName[i]==lineNa)return i;return -1;}};【Stack_num.h】class Stack_num{int i; //栈顶标记int *data; //栈构造public:Stack_num() //构造函数{data=new int[100];i=-1;}int push(int m) //进栈操作{i++;data[i]=m;return i;}int pop() //出栈操作{i--;return data[i+1];}int getTop() //返回栈顶{return data[i];}~Stack_num() //析构函数{delete []data;}int topNumber(){return i;}void outStack(){for(int m=0;m<=i;m++)cout<<data[m];}};【Stack_str.h】class Stack_str{int i; //栈顶标记string *data; //栈构造public:Stack_str() //构造函数{data=new string[50];i=-1;}int push(string m) //进栈操作{i++;data[i]=m;return i;}int pop() //出栈操作{data[i]="";i--;return i;}string getTop() //返回栈顶{return data[i];}~Stack_str() //析构函数{delete []data;}int topNumber(){return i;}void outStack(){for(int m=0;m<=i;m++)cout<<data[m];}};【cifa.cpp】//cifa.cpp#include<iostream>#include<string>#include"cifa.h"using namespace std;//关键字表和对应的编码string codestring[10]={"main","int","if","then","else","return","void","cout","endl"}; int codebook[10]={26,21,22,23,24,25,27,28,29};//全局变量char ch;int flag=0;/*//主函数int main(){WordType word;cout<<"请输入源程序序列:";word=get_w();while(word.pro!="#")//#为自己设置的完毕标志{cout<<"("<<word.code<<"，"<<"“"<<word.pro<<"〞"<<")"<<endl;word=get_w();};return 0;}*/WordType get_w(){string str="";int code;WordType wordtmp;getch();//读一个字符getBC();//去掉空白符if(isLetter()){ //以字母开头while(isLetter()||isDigit()){str=concat(str);getch();}retract();code=Reserve(str);if(code==-1){wordtmp.code=0;wordtmp.pro=str;}//不是关键字else{wordtmp.code=code;wordtmp.pro=str;}//是关键字}else if(isDigit()){ //以数字开头while(isDigit()){str=concat(str);getch();}retract();wordtmp.code=30;wordtmp.pro=str;}else if(ch=='(') {wordtmp.code=1;wordtmp.pro="(";} else if(ch==')') {wordtmp.code=2;wordtmp.pro=")";}else if(ch=='{') {wordtmp.code=3;wordtmp.pro="{";} else if(ch=='}') {wordtmp.code=4;wordtmp.pro="}";} else if(ch==';') {wordtmp.code=5;wordtmp.pro=";";}else if(ch=='=') {wordtmp.code=6;wordtmp.pro="=";} else if(ch=='+') {wordtmp.code=7;wordtmp.pro="+";} else if(ch=='*') {wordtmp.code=8;wordtmp.pro="*";} else if(ch=='>') {wordtmp.code=9;wordtmp.pro=">";} else if(ch=='<') {wordtmp.code=10;wordtmp.pro="<";} else if(ch==',') {wordtmp.code=11;wordtmp.pro=",";} else if(ch=='\'') {wordtmp.code=12;wordtmp.pro="\'";} else if(ch=='-') {wordtmp.code=13;wordtmp.pro="-";} else if(ch=='/') {wordtmp.code=14;wordtmp.pro="/";} else if(ch=='#') {wordtmp.code=15;wordtmp.pro="#";} else if(ch=='|') {wordtmp.code=16;wordtmp.pro="|";}else {wordtmp.code=100;wordtmp.pro=ch;}return wordtmp;}void getch(){if(flag==0) //没有回退的字符ch=getchar();else //有回退字符，用回退字符，并设置标志flag=0;}void getBC(){while(ch==' '||ch=='\t'||ch=='\n')ch=getchar();}bool isLetter(){if(ch>='a'&&ch<='z'||ch>='A'&&ch<='Z')return true;elsereturn false;}bool isDigit(){if(ch>='0'&&ch<='9')return true;elsereturn false;}string concat(string str){return str+ch;}void retract(){flag=1;}int Reserve(string str){int i;for(i=0;i<=8;i++){if(codestring[i]==str) //是某个关键字，返回对应的编码return codebook[i];}if(i==9) //不是关键字return -1;}【LR.cpp】#include<iostream>#include<string>#include<cstdlib>#include"cifa.h"#include"stack_num.h"#include"stack_str.h"#include"table_action.h"#include"table_go.h"using namespace std;void process(){int stepNum=1;int topStat;Stack_num statusSTK; //状态栈Stack_str symbolSTK; //符号栈Stack_num valueSTK; //值栈WordType word;Table_action actionTAB; //行为表Table_go goTAB; //转向表cout<<"请输入源程序，以#完毕：";word=get_w();//总控程序初始化操作symbolSTK.push("#");statusSTK.push(0);valueSTK.push(0);cout<<"步骤\t状态栈\t符号栈\t值栈\t当前词\t动作\t转向"<<endl;//分析while(1){topStat=statusSTK.getTop(); //当前状态栈顶string act=actionTAB.getCell(topStat,word.code);//根据状态栈顶和当前单词查到的动作//输出cout<<stepNum++<<"\t";statusSTK.outStack(); cout<<"\t";symbolSTK.outStack(); cout<<"\t";valueSTK.outStack(); cout<<"\t";cout<<word.pro<<"\t";//行为为“acc〞，且当前处理的单词为#，且状态栈里就两个状态//说明正常分析完毕if(act=="acc"&&word.pro=="#"&&statusSTK.topNumber()==1){cout<<act<<endl;cout<<"分析成功！"<<endl;cout<<"结果为："<<valueSTK.getTop()<<endl;return;}//读到act表里标记为错误的单元格else if(act==""){cout<<endl<<"不是文法的句子！"<<endl;cout<<"错误的位置为单词"<<word.pro<<"附近。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
(2) 规范归约 a. 短语 （P85） 例子见P85 设G是一文法，S是文法的开始符，若是G的 一个句型，如果 S *=> A 且 A +=> , 则说为 相对于非终结符A的短语. 特别地, 若 A => , 则说 是句型相对于规则 A-> 的直接短语. 一个句型的最左直接短语称该句 型的句柄.
b. 分析树 (分析过程可用一棵树表示) 等同语法树：采用规范归约方法（句柄归约） 自下而上分析过程,每步归约都可画一棵子树,随着 归约的完成,这些子树被连成一棵统一的树称分析树. 如移进归约过程 A A B S b A b 第3步 5步 8步 b b d a A A c B e b d 第10步
b. 规范归约(最左归约)
设 是文法G的一个句子,我们称序列n, n1, …, 0是的一个规范归约,如果此序列满足: (1) n= (2) 0 为文法开始符,即0 = S (3) 对任何i(0 < i n), i-1是从i经把句柄替换 为相应产生式的左部符号而得. c. 规范推导(最范归约是规范推导的逆过程
第九讲 语法分析—自下而上分析
1 概念与基本问题 • 自下而上分析法 ---- 从输入串开始，逐步进行归约， 直到归到文法的开始符；或者说，从语法树的末端开 始，步步向上“归约”，直到根结点。 算符优先分析法 句柄归约法 • 自上而下 递归下降分析法 预测分析
（1）归约与分析树
a.
归约 “移进—归约” ---- 将输入符号一个个地移进到栈 里，当栈顶形成某个产生式的一个候选式时，即把 栈顶的这一部分替换为该产生式的左部符号 E.G. 设有文法G: (1) S -> aAcBe (2) A -> b (3) A -> Ab (4) B -> d 希望将输入串abbcde归约到S. 解释P84图5.1的归约过程 关键概念: 引进可归约串概念: 句柄 最左素短语
b为句柄(剪去)
(3) 符号栈的使用与分析树的表示
a. 分析器工作过程(使用符号栈) P88 初始： 符号栈 输入串 # # 过程：移进、归约 //反复进行 终态：符号栈 输入串 #S # //S表示开始符号 总之，语法分析对符号栈的使用有四类操作：“移进”、 “归约”、“接受”和“出错处理”。 移进----由输入串吃进一个符号到栈中； 归约----栈顶可归约串用适当符号去替换； 接受----宣布分析成功。可看作特殊归约形式
b.
分析树 自学
e. 句柄和归约可通过修剪语法树而得(P87) 一个句型的句柄是这个句型的语法树中最左那棵 子树端末结的自左至右排列.该子树只有(而且必须有) 父子两代, 没有第三代. S S S S a A c B e A b b d a A c B e A b d 其余类推 a A c B e a A c B e d S