默认的规则

$V_N$是非终结符集合
$V_T$是终结符集合
终结符和非终结符的集合是互斥的
一般字母的大写是非终结符，小写是终结符
$V=V_N\bigcup V_T$
$G$是文法/语言
$P$是产生式，也就是推导的式子$a\to bc$
$S$是开始符号
$a\to bc是推导bc\to a是规约$
$::=和\to$或者其他的箭头符号是一样意思
$字母后的\ast$表示0个或多个
$字母后的+$表示1个或多个

0型文法

设 $G=(V_N,V_T,P,S)$,如果$G$的每个产生式$\alpha \to \beta$ 都满足 $\alpha ,\beta \in (V_N\bigcup V_T{)}^{\ast }$, 并且$\alpha$至少有一个非终结符！
这样的文法$G$就是一个0型文法！

• 0型文法的能力相当于Turing Machine
• 任何0型文法语言都是递归可枚举的；属于递归可枚举集的文法，一定是0型语言
• 0型文法对文法规则的表示形式不作任何限制，从而为定义的语言提供充分的描述功能
• 但是，0型文法不保证语言的递归性，不能确定语句是否合法，所以很少用于定义自然语言！

1型文法（上下文有关文法）

上下文有关文法对应线性有界自动机，在0型文法的基础上，规定了
$\forall \alpha \to \beta ,have|\alpha |\le |\beta |$

• 上下文有关意味着产生式左部不只有一个非终结符！

2型文法（上下文无关文法）

上下文物管文法对应下推自动机——下推自动机比其他有限状态自动机复杂，除了有限状态组成部分外，还包括一个长度不受限制的栈！
2型文法在1型文法的基础上，规定了
$\forall \alpha \to \beta ,have\alpha \in V_N$

• 上下文无关意味着产生式左部只有一个非终结符！
• 2型文法已经广泛用于定义程序设计语言，这种文法规定了左部必须只能是单一的非终结符——非终结符通过文法规则的扩展性重写是相互独立的，不受其他符号的影响，所以称为上下文无关文法！<.font>

3型文法（正则文法）

正则文法对应有限状态自动机，在2型文法的基础上，规定了
$A\to \alpha |\alpha B$ （右线性）
$or$
$A\to \alpha |B\alpha$ （左线性）

• 3型文法规则表示形式高度受限制，这使得正则语言可以用有限状态自动机程序做高效分析。

• 有限状态自动机有若干状态，其中肯定有一个起始状态，并至少有一个结束状态

• 有限状态自动机的输入会导致状态变化，并在到达目标状态时停机

• 有限状态自动机以文法左部的非终结符指示当前状态，右部的终结符作为输入，终结符后的非终结符(右线性)就是自动机到达的下一状态 —— 状态原来就是非终结符 ！

• 如果输入结束并且此时自动机处于结束状态，则输入就作为一个合法语句被接受，否则输入语句就是非法语句

• 虽然正则文法简单，但是规则限制太多，无法用于描述自然语言

BNF

$::=是定义$
$|是或$
$<>是用于括起非终结符$

EBNF

扩展BNF是描述编程语言和形式语言的正规方式的上下文物管文法的元语法符号表示法
$()内看做一项$
$.是一条生成规则的结束$
{      } 内 是 零 次 或 任 意 多 次 的 项 \{\;\; \} 内是零次或任意多次的项 { }内是零次或任意多次的项
$[]内是0次或一次的项$
$""内是终结符$

• 要用当然都是用的EBNF啦，BNF只有三个怎么用？

LL

LL分析器是一种自顶向下的上下文无关语法分析器。第一个L是Left to right，第二个L是Leftmost derivation，即分析中使用最左推导。
使用LL分析的就是LL文法！

LL(k)

LL(k)是向前看k个符号才可以决定如何推导，即选择哪个产生式！

在语句的推导过程中，某个阶段可能出现有多个产生式可以选择的情况，如果选择了某个产生式，并且在之后的过程中出错，那么就要进行回溯!!!

为了不进行回溯，需要进行预测，即向前看k个符号来决定选择哪个产生式！

——所以，不会回溯的文法就是LL(k)文法！

   \;
   \;
   \;
下面是几个不同的LL(k)：
$LL(0)：<A>::=<b>$ 不需要向前看（不需要选择），当前的符号只有一个
$LL(1)：<A>::=<b>|<c>|<d>$ 需要向前看一个，才能决定选择哪个
$LL(2)：<A>::=<bd>|<c>|<bc>$ 需要向前看两个，才能决定选择哪个

   \;
   \;

FIRST集

设$G=(V_N,V_T,P,S)$是上下文无关文法， F I R S T ( X ) = { a ∣ X ⇒ ∗ a β , a ∈ V T ,    X , β    ∈    V ∗ }      。 若 X ⇒ ∗ ε , FIRST(X)=\{ a| X \Rightarrow ^{\ast} a\beta ,a \in V_T ,\; X, \beta \; \in\;V^*\} \;\;。若 X \Rightarrow ^{\ast} \varepsilon , FIRST(X)={ a∣X⇒∗aβ,a∈VT​,X,β∈V∗}。若X⇒∗ε, 则规定 $\epsilon \in FIRST(X)$，称 $FIRST(X)$是$X$的开始符号集或者首字符集！！！

X有若干的产生式，在这些产生式中部分产生式的右部的第一个字符是终结符，则这个终结符就是FIRST集中的元素！！！

计算FIRST集

计算FIRST集就是找出属于FIRST集的元素（话说，这一通集合计算后，就是集合论集大拿了吧）

1. $ifX\in V_T,soFIRST(X)=X$
2. $ifX\in V_N,andX\to a...,a\in V_T,soa\in FIRST(x)$
3. $ifX\in V_N,X\to ϵ,soϵ\in FIRST(X)$
4. 若$X\in V_N;Y_1,Y_2,...,Y_i\in V_N,$且有产生式$X\to Y_1{Y}_2...Y_i$都可以${\Rightarrow }^{\ast }ϵ$ 时（$1\le i\le n$），则 $FIRST(X)=FIRST(Y_1)\bigcup FIRST(Y_2)\bigcup ......\bigcup FIRST(Y_i)$
5. 当(4)中所有的$Y_i{\Rightarrow }^{\ast }ϵ,(i=1,2,...,n),$则 F I R S T ( X ) = F I R S T ( Y 1 ) ⋃ F I R S T ( Y 2 ) ⋃ . . . . . . ⋃ F I R S T ( Y n ) ⋃ { ϵ } FIRST(X)=FIRST(Y_1)\bigcup FIRST(Y_2)\bigcup ... ...\bigcup FIRST(Y_n)\bigcup \{\epsilon\} FIRST(X)=FIRST(Y1​)⋃FIRST(Y2​)⋃......⋃FIRST(Yn​)⋃{ ϵ}
6. 左右都只有一个符号的话，左右的$FIRST$集等价
7. 遇到右部第一个符号是非终结符时，需要迭代进去！！！

   \;
   \;

FOLLOW集

设$G=(V_N,V_T,P,S)$是上下文无关文法，$X\in V_N,S$是开始符号， F O L L O W ( X ) = { a ∣ S ⇒ ∗ μ X β , FOLLOW(X) = \{ a|S\Rightarrow ^{\ast} \mu X \beta, FOLLOW(X)={ a∣S⇒∗μXβ, 并且 $a\in V_T,a\in FIRST(\beta ),\mu \in V_T^{\ast },\beta \in V^{+}\}$ ,
若 $S\Rightarrow \mu X\beta ,$并且 $\beta {\Rightarrow }^{\ast }\epsilon ,$则 $\#\in FOLLOW(X)$

• $\#$作为输入串的结束符——因为FOLLOW是空嘛，所以自然要结束了！！！

X是产生式的右部，前面的符号是终结符或空，后面的符号中的第一个符号就是X的FOLLOW

计算FOLLOW集

1. 设$S$为文法开始符号， { # } \{\#\} { #}加入$FOLLOW(S)$中
2. 若$A\to aB\beta$是一个产生式，则把$FIRST(\beta )$的非空元素加入$FOLLOW(B)$中。如果$\beta {\Rightarrow }^{\ast }\epsilon$，则把$FOLLOW(A)$也加入$FOLLOW(B)$中
3. 反复使用(2)直到每个非终结符的$FOLLOW$集不再增大为止

   \;
   \;

SELECT集

有上下文无关文法的产生式$X\to a,X\in V_N,a\in V^{\ast }$
$如果a{\nRightarrow }^{\ast }\epsilon ,则SELECT(X\to a)=FIRST(X)$
如 果 a ⇒ ∗ ε , 则 S E L E C T ( X → a ) = ( F I R S T ( a ) − { ε } ) ⋃ F O L L O W ( X ) 如果a\Rightarrow ^* \varepsilon,则SELECT(X\rightarrow a)=(FIRST(a) - \{\varepsilon\} )\bigcup FOLLOW(X) 如果a⇒∗ε,则SELECT(X→a)=(FIRST(a)−{ ε})⋃FOLLOW(X)

$SELECT(X\to a)$要么是$X$右部第一个符号，要么是X跟着的符号中的第一个符号

计算SELECT集

有产生式$A\to a$，这个$a$就是单个符号，不是几个符号的或！！！

1. 求$FIRST(a)$
2. 若$\epsilon \notin FIRST(a),$则令$SELECT(A\to a)=FIRST(a)$，否则求$FOLLOW(A),$令$SELECT(A\to a)=FIRST(a)\bigcup FOLLOW(A)$

   \;
   \;

计算三种集合的例子

有下面几个产生式
$E\to T{E}^{\prime }$
$E^{\prime }\to +T{E}^{\prime }|\epsilon$
$T\to F{T}^{\prime }$
$T^{\prime }\to \ast F{T}^{\prime }|\epsilon$
$F\to id|(E)$
求这几个产生式的三种集合！

$解:$

求FIRST集

1)先看看简单的右部第一个符号是终结符的产生式
F I R S T ( F ) = { i d , ( } FIRST(F) = \{id,(\} FIRST(F)={ id,(}
F I R S T ( T ′ ) = { ∗ , ε } FIRST(T')=\{*,\varepsilon\} FIRST(T′)={ ∗,ε}
F I R S T ( E ′ ) = { + , ε } FIRST(E')=\{+,\varepsilon\} FIRST(E′)={ +,ε}
2)再看右部第一个符号是非终结符的产生式
$E$的右部第一个是$T$,$T$的右部第一个是$F$
由于$F$不能推导出$\epsilon$，所以 F I R S T ( T ) = F I R S T ( F ) = { i d , ( } FIRST(T)=FIRST(F)=\{id,(\} FIRST(T)=FIRST(F)={ id,(}
由于$T$不能推导出$\epsilon$，所以 F I R S T ( E ) = F I R S T ( T ) = { i d , ( } FIRST(E)=FIRST(T)=\{id,(\} FIRST(E)=FIRST(T)={ id,(}

求FOLLOW集

1)先看$E$，$E$后面的第一个符号只有 { ) } \{)\} { )}, 则 F O L L O W ( E ) = { ) , # } FOLLOW(E)=\{),\#\} FOLLOW(E)={ ),#}
2)再看$E^{\prime }$，$E^{\prime }$后面的第一个符号是空， 即$E^{\prime }\to \epsilon$,则 F O L L O W ( E ′ ) = F O L L O W ( E ) = { ) , # } FOLLOW(E')=FOLLOW(E)=\{),\#\} FOLLOW(E′)=FOLLOW(E)={ ),#}
3)$T$后面第一个符号是$E^{\prime }$,则$FOLLOW(T)$要算上$FIRST(E^{\prime })$，还有$E^{\prime }\to \epsilon$，则$FOLLOW(E^{\prime })$该加入$FOLLOW(T)$中，则 F O L L O W ( T ) = { + , ) , # } FOLLOW(T)=\{+,),\#\} FOLLOW(T)={ +,),#}
4)$T^{\prime }$后面是空， 则 F O L L O W ( T ′ ) = F O L L O W ( T ) = { + , ) , # } FOLLOW(T')=FOLLOW(T)=\{+,),\#\} FOLLOW(T′)=FOLLOW(T)={ +,),#}
5)$F$后面是$T^{\prime }$,则$FIRST(T^{\prime })$的非空元素该加入$FOLLOW(F)$。由于$T^{\prime }\to \epsilon$,则$FOLLOW(T^{\prime })$要加入$FOLLOW(f)$,则 F O L L O W ( F ) = { ∗ , + , ) , # } FOLLOW(F)=\{*,+,),\#\} FOLLOW(F)={ ∗,+,),#}

求SELECT集

select处理的式子右部必须只有一个符号

1)因为$FIRST(T{E}^{\prime })$中没有空，所以 S E L E C T ( E → T E ′ ) = F I R S T ( E ) = { i d , ( } SELECT(E\rightarrow TE')=FIRST(E)=\{id,(\} SELECT(E→TE′)=FIRST(E)={ id,(}

2)因为$FIRST(+T{E}^{\prime })$中没有空，所以 S E L E C T ( E ′ → + T E ′ ) = F I R S T ( + T E ′ ) = { + } SELECT(E'\rightarrow +TE')=FIRST(+TE') =\{ +\} SELECT(E′→+TE′)=FIRST(+TE′)={ +}

3)因为$FIRST(\epsilon )$是空，所以 S E L E C T ( E ′ → ε ) = ( F I R S T ( ε ) − { ε } ) ⋃ F O L L O W ( E ′ ) = { ) , # } SELECT(E'\rightarrow \varepsilon)=(FIRST(\varepsilon) - \{\varepsilon\})\bigcup FOLLOW(E')=\{ ),\#\} SELECT(E′→ε)=(FIRST(ε)−{ ε})⋃FOLLOW(E′)={ ),#}

4)因为$FIRST(F{T}^{\prime })$中没有空，所以 S E L E C T ( T → F T ′ ) = F I R S T ( F T ′ ) = { i d , ( } SELECT(T\rightarrow FT')=FIRST(FT')=\{id,(\} SELECT(T→FT′)=FIRST(FT′)={ id,(}

5)因为$FIRST(\ast F{T}^{\prime })$中没有空，所以 S E L E C T ( T ′ → ∗ F T ′ ) = F I R S T ( ∗ F T ′ ) = { ∗ } SELECT(T'\rightarrow *FT')=FIRST(*FT') =\{ *\} SELECT(T′→∗FT′)=FIRST(∗FT′)={ ∗}

6 )因为$FIRST(\epsilon )$是空，所以 S E L E C T ( T ′ → ε ) = ( F I R S T ( ε ) − { ε } ) ⋃ F O L L O W ( T ′ ) = { + , ) , # } SELECT(T'\rightarrow \varepsilon)=(FIRST(\varepsilon) - \{\varepsilon\})\bigcup FOLLOW(T')=\{ +,),\# \} SELECT(T′→ε)=(FIRST(ε)−{ ε})⋃FOLLOW(T′)={ +,),#}

7)因为$FIRST(id)$中没有空，所以 S E L E C T ( F → i d ) = F I R S T ( i d ) = { i d } SELECT(F\rightarrow id)=FIRST(id)=\{ id \} SELECT(F→id)=FIRST(id)={ id}

8）因为$FIRST((E))$中没有空，所以 S E L E C T ( F → ( E ) ) = F I R S T ( ( E ) ) = { ( } SELECT(F\rightarrow (E) )=FIRST( (E) )=\{ (\} SELECT(F→(E))=FIRST((E))={ (}

   \;
   \;

LL(1)（常用）

一个上下文无关文法是$LL(1)$文法的充分必要条件是对每个非终结符$X$的两个不同产生式$X\to a，X\to \beta ,$满足$SELECT(X\to a)\bigcap SELECT(X\to \beta )=\varphi ,其中a,\beta 不同时{\Rightarrow }^{\ast }\epsilon$

• LL(1)文法既不是二义性的，也不含左递归，对LL(1)文法的所有句子均可进行确定的自顶向下语法分析

上下文无关文法 + 相同左部的产生式的SELECT集为空 = LL(1)文法
再看这个例子$LL(1)：<A>::=<b>|<c>|<d>$，同样的左部，可以有三个不同的右部，只要保证每个右部的第一个符号不是相同的，那么就能向前看一个就能选择出产生式！！！

递归子程序法

确定的自顶向下分析方法有两种：预测分析法和递归子程序法。

递归子程序法要求文法满足LL(1)，实现思想是对文法中每个非终结符编写一个递归过程，每个过程的功能是识别由该非终结符推出的串，当某个非终结符的产生式有多个候选式时，能够按LL(1)形式可唯一地确定选择某个候选进行推导。
由于递归子程序法对每个过程可能存在直接或间接的递归调用，在退出之前可能又被调用。所以，通常在入口处需要保存现场，出口出恢复现场！！！这通常使用栈来实现。

1.语法定义举例（递归子程序法）

<program>      				 ::=    <statement> { statement  } "#"
<statement>    				 ::=    <expression> "\n"
<expression>                 ::=    <multiplicative_expression> 
								{  "+"  <multiplicative_expression>  | "-"  <multiplicative_expression>  }
<multiplicative_expression>  ::=	<primary_expression> 
								{  "*"   <primary_expression> | "/" <primary_expression> }														
<primary_expression>		 ::=    <integer> | "(" <expression> ")"
<integer>   				 ::=    "0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9" 

2.语法描述图举例（递归子程序法）

3.构造语法分析程序举例（递归子程序法）

void main(){
    
    
	get_token();
	program();
}
void program(){
    
    
	while(token != '#')
		statement();
}
void statement(){
    
    
	if(token != '\n')expression();
	else get_token();
}
void expression(){
    
    
	multiplicative_expression();
	if(token == '+' || token =='-'){
    
    
		get_token();
		multiplicative_expression();
	}
}
void multiplicative_expression(){
    
    
	primary_expression();
	if(token =='*' || token =='/'){
    
    
		get_token();
		primary_expression();
	}
}
void primary_expression(){
    
    
	primary_expression();
	if(token == INTEGER)get_token();
	else if(token=='('){
    
    
		get_token();
		expression();
		get_token();
		if(token !=')')error("lack of right parenthesis");
	}
	else error("exception");
}

   \;
   \;
   \;

文法等价

根据前面的分析可知，LL(1)文法中，两个相同左部的产生式的几个候选式的第一个符号不可能是相同的，即候选式没有左公共因子！因为如果有的话，那么这个文法至少是$LL(k),k\ge 2$。
因为要求$FIRST$集，所以左因子肯定不能递归，不然就没完没了了！

1.提取左边的公共因子

如果文法中有$A\to a\beta |a\gamma$的产生式，这导致了相同产生式的右部的$FIRST$集相交，$SELECT(A\to a\beta )\bigcap SELECT(A\to a\gamma )\ne \varphi$！

$解：$
现在有$A\to a\beta |a\gamma$
$=>A\to a(\beta |\gamma )$
引入$A^{\prime }$
$=>A\to a{A}^{\prime },A^{\prime }\to \beta |\gamma$
写成更一般的形式
$=>A\to a{A}^{\prime },A^{\prime }\to {\beta }_1|{\beta }_2|...|{\beta }_n$
如果${\beta }_1|{\beta }_2|...|{\beta }_n$中仍然含有左公共因子，就要再次进行提取，反复知道所有的产生式都没用左公共因子为止！！！

2.消除左递归

一个文法含有下列形式的产生式之一时：

1. $A\to A\beta ,A\in V_N,\beta \in V^{\ast }$
2. $A\to B\beta ,B\to Aa,A、B\in V_N,a、\beta \in V^{\ast }$

则称该文法是左递归的！
一个文法是左递归时，不能采用自顶向下分析法。

消除左递归的方法：
1） 消除直接左递归，把直接左递归改写为右递归，比如对文法
$G:S\to Sa,S\to b$
改写成
$G:S\to b{S}^{\prime },S^{\prime }\to a{S}^{\prime }|\epsilon$

S最后只有一个b，说明S串第一个符号就是b
S能一直递归，并提出一个a，则说明S串为baaaaa…aaa
S -> bS’,后面的aaaa…aaa可以当做S’.然后因为要求是去除左递归，所以这里就用右递归S’->aS’
最后，S’也会迭代完，则S’->$\epsilon$

一般情况下（多个具有相同左部的左递归产生式），假定关于$A$的全部产生式为
$A\to A{a}_1|A{a}_2|......|A{a}_n|{\beta }_1|{\beta }_2|......|{\beta }_n$，其中$a_i(1\le i\le m)$不等于空，${\beta }_j(1\le j\le n)$不以$A$开头
消除左递归后改写成
$A\to {\beta }_1{A}^{\prime }|{\beta }_2{A}^{\prime }|......|{\beta }_n{A}^{\prime }$
$A^{\prime }\to a_1{A}^{\prime }|a_2{A}^{\prime }|......|a_n{A}^{\prime }|\epsilon$

和上面的例子同理，左递归的变成右递归
其实从第一条产生式就可以看出，$A$ = ${\beta }_1{a}_1{a}_1...|{\beta }_2{a}_2{a}_2...|......|{\beta }_n{a}_n{a}_n....$
就是以一种终结符开头,以若干个另一种终结符连接的字符串

2）消除间接左递归。先将间接左递归变成直接左递归，然后按(1)操作

比如有文法$G:$
$S\to Qc|c$
$Q\to Rb|b$
$R\to Sa|a$

改成直接左递归$:$
$R$代入$Q$
$Q\to Rb|b\to (Sa|a)b|b\to Sab|ab|b$
$Q$代入$S$
$S\to Qc|c\to (Sab|ab|b)c|c\to Sabc|abc|bc|c$
然后再消除左递归
$S\to abc{S}^{\prime }|bc{S}^{\prime }|c{S}^{\prime }$
$S^{\prime }\to abc{S}^{\prime }|\epsilon$
$R,Q$就可以不要了

所以，间接转直接的方法就是，先选好开始的S，然后找到最底层的产生式，再逐步代入上一层的产生式…
显然这存在个问题，如果最后剩下两个非终结符相互迭代，就没办法代入了！！！

参考：
《自己动手写编译器、链接器》
编译原理左递归消除?-百度知道