自顶向下语法分析方法

自顶向下分析

• 自顶向下分析就是从文法的开始符号出发，按最左推导方式向下推导，试图推出要分析的输入串，为输入的符号串建立分析树
• 构造最左推导的关键问题：
  • 在构造最左推导的过程中，面对当前读入的单词符号 $a$ 和当前被替换的非终极符 $A$，应该选择 $A$ 的哪条候选式去替换它(推导)
  • 关键：找出选择一个非终极符号的候选式的方法

上下文无关文法的特性

• 自嵌入性：一个文法 $G$ 是自嵌入的，若存在一个非终极符 $A$，有 $A{\Rightarrow }^{\ast }\alpha A\beta ，\alpha 、\beta \in V^{+}$ 非空
  • 例如，$A\to aAb|ab$ 是自嵌入的，而 $A\to aA|ab$ 不具有自嵌入性，是三型文法（正则文法）
• 能够进行确定分析的语言称为确定语言
  • 对上下文无关语言的分析，并不总是能以确定的方式进行，需要回溯

带回溯的自顶向下语法分析

即 不确定的自顶向下分析

回溯的自顶向下语法分析实质

• 它是一个反复使用不同的产生式进行试探，以谋求匹配输入串的过程。
• 该方法分析效率低，在实际中并不适用，但给出了自顶向下语法分析的思想

例
$$\begin{array}{rl}G[S]：S& \to aAb\\ A& \to \ast \ast |\ast \end{array}$$

利用自顶向下语法分析，分析 $a\ast b$ 是否是合法的句子

引起回溯的原因

• 由于文法中同一非终极符的各候选式有公共的左因子或隐含有公共的左因子，使得推导无法选择唯一的候选式，导致盲目试探，大大影响速度
  • 如：$S\to aS|ab$，它们都有公共的左因子 $a$，当下一个想使用最左推导得出的终结符号为 $a$ 时，需要依次试探这两条规则
• 左递归问题：无论是直接左递归的， 还是间接左递归的，都会使分析过程无法终止
  • 如：$U\to U\alpha |b$ 若推导 $b\alpha \alpha$：$U\Rightarrow U\alpha \Rightarrow U\alpha \alpha \Rightarrow \dots$ (每次都使用第一条规则)

消除回溯与左递归

消除回溯

• 对文法加以一定的限制，使每次对候选式的选择是唯一的，从而进行确定的自上而下分析
  • 例如 $LL(1)$ 文法保证文法中的各条规则没有公共左因子

消除左递归

• 解决方法1：重排规则顺序
  例
  $S\to Sa|b$, 改为： $S\to b|Sa$ ，若推导 $’baa’$
  
• 解决方法2：将左递归→右递归（或迭代）
  例
  左递归文法 $S\to Sa|b$ 生成语言 $L=b{a}^{\ast }$；对应的右递归文法：$S\to bA,A\to aA|\epsilon$；或迭代 S → b { a } S →b\{a\} S→b{a}

迭代形式便于程序实现，但考试及作业中还是要写成规范的文法形式

例
表达式文法 $$\begin{array}{rl}E& \to E+T|T\\ T& \to T\ast F|F\\ F& \to (E)|a\end{array}$$

消除左递归，得
$$\begin{array}{rl}E& \to TE’\\ E’& \to +TE’|\epsilon \\ T& \to FT’\\ T’& \to \ast FT’|\epsilon \\ F& \to (E)|a\end{array}$$或
E → T { + T } （ 迭 代 ） T → F { ∗ F } F → ( E ) ∣ a \begin{aligned} E &→T\{+T\} （迭代）\\ T &→F\{*F\} \\ F &→(E) | a\end{aligned} ETF​→T{+T}（迭代）→F{∗F}→(E)∣a​

但要注意，不能直接将文法改成下列形式来消除左递归：
$$\begin{array}{rl}E& \to T+E|T\\ T& \to F\ast T|F\\ F& \to (E)|a\end{array}$$原因是：如果画出语法树会发现，这样更改之后，原本运算符号的左结合性变成了右结合性

---

若关于 $A$ 的全部规则为
$$A\to A{\alpha }_1|A{\alpha }_2|\dots |A{\alpha }_m|{\beta }_1|{\beta }_2|\dots |{\beta }_n$$

其中，每个 ${\alpha }_i$ 都不等于 $\epsilon$ ，每个 ${\beta }_i$ 都不以 $A$ 开头则消除左递归，得
$$\begin{gathered} A\to ({\beta }_1|{\beta }_2|\dots |{\beta }_n)A’ \\ A’\to ({\alpha }_1|{\alpha }_2|\dots |{\alpha }_m)A’|\epsilon \end{gathered}$$或使用迭代形式：
A → ( β 1 ∣ β 2 ∣ … ∣ β n ) { α 1 ∣ α 2 ∣ … ∣ α m } A →(β_1 | β_2 | … | β_n )\{α_1 | α_2 | …| α_m \} A→(β1​∣β2​∣…∣βn​){α1​∣α2​∣…∣αm​}

---

消除间接左递归

例
$$\begin{array}{rl}G[S]：S& \to Qc|c\\ Q& \to Rb|b\\ R& \to Sa|a\end{array}$$

因 $S\Rightarrow Qc\Rightarrow Rbc\Rightarrow Sabc$, 是左递归文法
代入法：
$$\begin{array}{rl}S& \to (Rb|b)c|c\\ S& \to Rbc|bc|c\\ S& \to (Sa|a)bc|bc|c\\ S& \to Sabc|abc|bc|c\end{array}$$消除左递归，得
$$\begin{array}{rl}S& \to abcS’|bcS’|cS’\\ S’& \to abcS’|\epsilon \end{array}$$

确定的自顶向下分析

• 确定的自顶向下分析方法对文法要求比较严格，必须无二义性、且消除左递归和回溯
  • 递归下降分析： 利用程序设计语言的递归函数实现，每个函数对应文法的一个非终极符。便于手工构造语法分析器
  • LL(K)分析：由一张预测分析表和一个总控程序组成。预测分析表给出了当面临输入符号时，运用到非终极符的推导所选用的产生式。便于用语法分析器的自动构造工具，自动构造语法分析器

例
构造最左推导（$aabbaa$) (自顶向下)
$$\begin{gathered} S\to aAS|a \\ A\to SbA|SS|ba \end{gathered}$$

LL 分析法（预测分析法）

$LL(K)$ 含义

• $LL(K)$ 含义：
  • 从左（$L$）到右（$R$）扫描输入串，并建立它的最左推导
  • $K$：在选择同一非终极符的不同规则时，通过向前看 $K$ 个符号决定
• $LL(K)$ 文法：是非歧义文法中能构造出确定的自顶向下分析器的最大文法类
• $LL$ 分析器又称预测分析器，是 $PDA$ 特例

预测分析方法

• 在自顶向下分析中，如果在每步推导中，面对被替换的非终结符号 $A$ 和当前从左至右读入输入串读到的单词符号 $a$，如果 $A$ 的定义（无 $\epsilon$-产生式）
  $$A\to {\alpha }_1|{\alpha }_2|\dots |{\alpha }_n$$中，只有 ${\alpha }_i$（$1\le i\le n$) 推导出的第一个终极符号是 $a$，那么就可以用产生式$A\to {\alpha }_i$ 构造最左推导，即用 ${\alpha }_i$ 替换 $A$

---

• 一类简单文法的分析器工作过程：
  $G$ 为 $S-$ 文法，当且仅当它满足：
  • 每条规则的右部都以 $V_T$ 开头
  • 如果一个 $V_N$ 有多条规则，那么它们都以不同的 $V_T$ 开头

例
$$S\to aS|bA,A\to d|ccA$$

• 列出预测分析矩阵（表）/ LL分析表：
  

$\#$ 代表句子结束

---

• 对于上例，在推导过程中，完全可以根据当前的向前看符号决定选择哪个产生式进行推导，因此，分析过程是完全确定的。这种分析称为自顶向下的预测分析
• 原因在于，文法中，$\forall A\in V_N$,
  $$A\to {\alpha }_1|{\alpha }_2|...|{\alpha }_n\forall i,j(1\le i,j\le n\&i<>j)$$从 ${\alpha }_i$ 推导出来的第一个终结符号集合（称为 $FIRST({\alpha }_i)$ ）和从 ${\alpha }_j$ 推导出来的第一个终结符号集合（称为 $FIRST({\alpha }_j)$ ）是不相交的，即：
  $$FIRST({\alpha }_i)\cap FIRST({\alpha }_j)=\varphi$$

$<>$ 表示不等于

预测分析器

• 分析器的动作总是由 栈顶元素$X$ 以及 当前输入符号$a$ 决定的
  

分析器的动作有3种：

• 若栈顶符号 $X$ 是一个非终极符，则去查分析表 $M[X,a]$
  • $M[X,a]$ 是一文法规则 $X\to \alpha$，则用 $\alpha$ 去替换栈顶的 $X$ （ $\alpha$ 逆序推入栈中），并输出文法规则编号。（相当于进行了一次最左推导）
  • $M[X,a]$ 无定义，则报错并转错误处理程序
  • 上述两种情况均不读下一符号
• 若栈顶符号 $X$ 是一个终极符且 $X=a$，则将栈顶符号弹出，并读下一个符号，若$X\in V_T$ , 且 $X\ne a$，则报错
• 若 $X=“\#”=a$，则分析器停机，输入串被接受

$LL(1)$ 文法

• 对于 $LL(k)$ 文法，$k=1$ 最常见，只需根据栈顶符号 $X$ 和当前输入符号 $a$，即可确定用哪条规则进行推导

---

FIRST 集 (开头符号集)

• 串 $\alpha \in (V_N\cup V_T{)}^{\ast }$ 的 FIRST 集：
  F I R S T ( α ) = { a ∣ α ⇒ ∗ a β , a ∈ V T , α , β ∈ V ∗ } FIRST(α)=\{a| α\Rightarrow^*aβ, a ∈V_T, α, β ∈V^*\} FIRST(α)={a∣α⇒∗aβ,a∈VT​,α,β∈V∗}若 $\alpha {\Rightarrow }^{\ast }\epsilon$, 则 $\epsilon \in FIRST(\alpha )$

---

定义1

• 设 $G$ 是不带 $\epsilon$ 规则的文法，若对所有 $A\to {\alpha }_1|{\alpha }_2|\dots |{\alpha }_n$ 的规则，有 $FIRST({\alpha }_i)\cap FIRST({\alpha }_j)=\Phi ,i\ne j$，则 $G$ 为 $LL(1)$ 文法

---

下面讨论有 $\epsilon$ 规则的文法

例

• $S\to aA,S\to d,A\to bAS,A\to \epsilon$
  若对 $abd$ 串，$S{\Rightarrow }^{①}aA{\Rightarrow }^{③}abAS{\Rightarrow }^{④}abS{\Rightarrow }^{②}abd$

• 何时选用 $A\to \epsilon$ 的空规则？
  • 在分析时，只有见到它的后继符号才能决定使用这条规则（使用这条规则之后可以匹配跟在它后面的终结符号）—引进 跟随集 (Follow 集)

---

Follow 集定义：

• 若 $G=(V_N,V_T,P,S)$ 是 CFG，$A\in V_N$， F o l l o w ( A ) = { a ∣ S ⇒ ∗ α A β , a ∈ F i r s t ( β ) , β ∈ V + } Follow(A)=\{a | S\Rightarrow^* αAβ, a∈First(β), β ∈V^+\} Follow(A)={a∣S⇒∗αAβ,a∈First(β),β∈V+}即:句型中紧跟在 $A$ 后面的那些终极符
• 规定 $\#$ 属于开始符号 $S$ 的 Follow 集，$\#$ 是句子结束符
• 若 $\beta {\Rightarrow }^{\ast }\epsilon$,则 $\#\in Follow(A)$；换句话说：若 $S{\Rightarrow }^{\ast }\dots A$，则规定 $\#\in Follow(A)$

---

定义2

• 一个文法 $G$ 是 $LL(1)$ 文法，当且仅当对文法中形如$A\to {\alpha }_1|{\alpha }_2|\dots |{\alpha }_n$ 都满足 LL(1)条件，即：
  • $First({\alpha }_i)\cap First({\alpha }_j)=\Phi ,i\ne j$
  • 如果 ${\alpha }_i{\Rightarrow }^{\ast }\epsilon$,则 $First({\alpha }_j)\cap Follow(A)=\Phi ,i\ne j$

---

• 为简化 LL(1) 条件，引进选择集 $Select(A\to \alpha )$
  

定义3

• 一个文法 $G$ 是 LL(1) 文法，当且仅当对文法中的所有形如 $A\to {\alpha }_1|{\alpha }_2|\dots |{\alpha }_n$ 的产生式, 其各候选式都满足如下的 LL(1) 条件：
  $$select(A\to {\alpha }_i)\cap select(A\to {\alpha }_j)=\phi (i\ne j)$$
• 只要一个 CFG 满足 $LL(1)$ 条件，就是 $LL(1)$ 文法，能采用预测分析法进行确定的自顶向下分析

---

• 利用 $select$ 集构造 $LL(1)$ 分析表, 每个元素 $M[A,a]$ 按下述规则确定： (其中, A ∈ V N , a ∈ V T ∪ { # } A∈V_N, a∈V_T ∪\{\#\} A∈VN​,a∈VT​∪{#} )
  • 对于每个形如 $A\to \alpha$ 的产生式:
    若 $a\in select(A\to \alpha )$ , 则置 $M[A,a]=“A\to \alpha ”$，否则置错，用空白表示
• 判断 $LL(1)$ 文法可从分析表判断，若 $LL(1)$ 分析表中每一项没有多重定义（即无二义性），就是 $LL(1)$ 文法
• 对不同的 $LL(1)$ 文法，其预测分析器的总控程序完全一样。不同仅在于分析表不同

---

$Follow$ 集的计算 (求 $select$ 集的关键)

• 设 $S$ 为 $G$ 中开始符号，则 $\#\in FOLLOW(S)$
• 若 $A\to \alpha B\beta$ 是一产生式，则把 $FIRST(\beta )$ 的非空元素加入到 $FOLLOW(B)$ 中
  • 如果 $\beta {\Rightarrow }^{\ast }\epsilon$，即有： $A\to \alpha B$，则把 $FOLLOW(A)$ 也加入到 $FOLLOW(B)$ 中
• 反复使用上一步，直到每个 $V_N$ 的 FOLLOW 集不再增大为止

例
给定文法 $S\to 0S|1S|\epsilon$ 是否为 $LL(1)$ 文法？
解

• 构造 LL(1) 分析表:
  
• 因为表中无多重定义， 所以该文法是 LL(1) 文法

例
给定文法 $S\to 0S0|1S1|\epsilon$ 是否为 LL(1) 文法？
解

• 构造 LL(1) 分析表:
  
• 因为表中出现多重定义， 所以该文法不是 LL(1) 文法

例
左递归文法是 LL(1) 文法吗？
解

• 因为左递归文法意味着有隐含的左公共因子，所以左递归文法不是 LL(1) 文法
  • 例如：$A\to Aa|b$
    因为： F i r s t ( A a ) = { b } ， F i r s t ( b ) = { b } First(Aa)= \{ b\}， First(b)=\{b\} First(Aa)={b}，First(b)={b}所以： F i r s t ( A a ) ∩ F i r s t ( b ) = { b } First(Aa) \cap First(b)= \{b\} First(Aa)∩First(b)={b}

很明显，歧义文法也不是 LL(1) 文法

例
判断 $G[S]$ 是否是 $LL(1)$ 文法，如果是，构造 $LL(1)$ 分析表
$$\begin{array}{rl}1.S& \to AB|bC\\ 2.A& \to \epsilon |b\\ 3.B& \to \epsilon |aD\\ 4.C& \to AD|b\\ 5.D& \to aS|c\end{array}$$
解

• 求 $V_N$ 的 $First$ 集、 $Follow$ 集
  • $First$ 集
    
  • $Follow$ 集
    • 由规则1：$FOLLOW(B)=FOLLOW(S),FOLLOW(C)=FOLLOW(S)$
    • 由规则3、4：$FOLLOW(D)=FOLLOW(B)\cup FOLLOW(C)=FOLLOW(S)$
    • 由规则1、4：$FOLLOW(A)=FIRST(B)\cup FOLLOW(S)\cup FIRST(D)$
      ($B{\Rightarrow }^{\ast }\epsilon$)
    • 由规则5： F O L L O W ( S ) = F O L L O W ( D ) = F O L L O W ( S ) = { # } FOLLOW(S)=FOLLOW(D)=FOLLOW(S)=\{\#\} FOLLOW(S)=FOLLOW(D)=FOLLOW(S)={#}
    • 因此， F O L L O W ( S ) = { # } F O L L O W ( B ) = F O L L O W ( C ) = F O L L O W ( D ) = { # } F O L L O W ( A ) = { a , c , # } FOLLOW(S)=\{\#\} \\ FOLLOW(B)=FOLLOW(C)=FOLLOW(D)=\{\#\}\\ FOLLOW(A)=\{a,c,\#\} FOLLOW(S)={#}FOLLOW(B)=FOLLOW(C)=FOLLOW(D)={#}FOLLOW(A)={a,c,#}
      
• 求 $select$ 集
  
• $LL(1)$ 分析表
  

文法的变换

• 某些非 $LL(1)$ 文法，经过变换 (消除左递归及公共左因子) 后，有可能改造成 $LL(1)$ 文法

改写之后的文法不一定就是 $LL(1)$ 文法，还需要进一步用 $LL(1)$ 条件判断

左递归文法的变换

例
给定文法
$$\begin{array}{rl}G[S]：S& \to i|(E)\\ E& \to E+S|E-S|S\end{array}$$

(1) 求每一非终极符的 $First$ 集和 $Follow$ 集
(2) 判断该文法是否为 $LL(1)$ 文法，为什么？能否进行文法变换成为 $LL(1)$ 文法？若能，给出 $LL(1)$ 分析表
解
(1)

(2) 因为该文法是左递归文法，所以不是 $LL(1)$ 文法。下面变换左递归文法：
$$E\to E(+S|-S)|S$$

消除左递归：
$$\begin{array}{rl}E& \to S{E}^{\prime }\\ E^{\prime }& \to (+S|-S)E^{\prime }|\epsilon \end{array}$$因此，消除左递归之后的文法为：
$$\begin{array}{rl}{G}^{\prime }[S]：S& \to i|(E)\\ E& \to S{E}^{\prime }\\ E^{\prime }& \to +S{E}^{\prime }|-S{E}^{\prime }|\epsilon \end{array}$$进一步构建 $G^{\prime }[S]$ 的 $LL(1)$ 分析表：

因为 $LL(1)$ 分析表无多重定义，所以变换后的文法 $G^{\prime }[S]$ 是 $LL(1)$ 文法

提取左公共因子变换

例
变换下列文法 $G[S]：S\to aSb|aSc|\epsilon$，并判断是否为 $LL(1)$ 文法
解:
提取左公共因子变换:
$$S\to aS（b|c）|\epsilon$$令: $B\to b|c$
变换后的文法:
$$\begin{array}{rl}G’[S]：S& \to aSB|\epsilon \\ B& \to b|c\end{array}$$

G ′ [ S ] : S e l e c t ( S → a S B ) = { a } S e l e c t ( S → ε ) = { b , c , # } S e l e c t ( B → b ) = { b } S e l e c t ( B → c ) = { c } \begin{aligned} G'[S] :Select(S→ aSB)&=\{a\} \\ Select(S→ \varepsilon)&=\{b,c,\#\} \\ Select(B →b)&=\{b\}\\ Select(B →c)&=\{c\}\end{aligned} G′[S]:Select(S→aSB)Select(S→ε)Select(B→b)Select(B→c)​={a}={b,c,#}={b}={c}​

具有相同左部的产生式的 $Select$ 集两两不相交，故 $G^{\prime }[S]$ 为 $LL(1)$ 文法

例
能否通过文法变换，将下面文法转换为 $LL(1)$ 文法
$$\begin{array}{rl}S& \to iBtSeS|iBtS|a\\ B& \to b\end{array}$$解
$$\begin{array}{rl}S& \to ibtSS’|a\\ S’& \to eS|\epsilon \end{array}$$

因为 s e l e c t ( S ’ → ε ) = F o l l o w （ S ’ ） = { # , e } select(S’ →ε)=Follow（ S’ ）=\{\#, e\} select(S’→ε)=Follow（S’）={#,e} ，与 { e } \{e\} {e} 是相交的，不满足 $LL(1)$ 条件，所以不是 $LL(1)$ 文法

角替换

• 规则的角：一规则右部的最左出现
  • 如： $S\to cS|Ac$ 中 $c,A$ 即为规则的角
• 角替换：对一规则的非终极符的角，用其规则右部去替换它
  • 非终极符角的出现意味着左公共因子可能是隐式的。消除隐式左公共因子可采用角替换
• 注意，角替换可能会使某些产生式变成无用产生式，即伴随着对文法的化简

角替换与提取左公共因子往往同时进行，角替换本身不改变文法的 $LL(1)$ 性质

例
下列文法是否为 $LL(1)$ 文法？
$$\begin{array}{rl}G[S]：S& \to cS|Ac\\ A& \to aS|b\end{array}$$

解

• 产生式 $S\to Ac$ 中含有角 $A$，角替换为：$S\to aSc|bc$
• 由于 $G^{\prime }[S]$ 中非终极符 $A$ 变成不可达符号，$A\to aS|b$ 应予以删除。改造后的文法
  G ′ [ S ] : S → c S ∣ a S c ∣ b c S e l e c t ( S → c S ) = { c } S e l e c t ( S → a S c ) = { a } S e l e c t ( S → b c ) = { b } \begin{aligned}G'[S] : S→cS|a&Sc|bc\\ Select(S→cS )&=\{c\}\\ Select(S→aSc)&=\{a\}\\ Select(S→bc )&=\{b\}\end{aligned} G′[S]:S→cS∣aSelect(S→cS)Select(S→aSc)Select(S→bc)​Sc∣bc={c}={a}={b}​
• 显然, 具有相同左部的产生式的 $Select$ 集两两相交为空，故为 $LL(1)$ 文法

例
下列文法是否为 $LL(1)$ 文法？如果不是，是否能改写为 $LL(1)$ 文法？
$$\begin{array}{rl}G[S]：S& \to AB(1)\\ A& \to Ba|\epsilon (2)\\ B& \to Db|D(3)\\ D& \to d|\epsilon (4)\end{array}$$

解

• 对于 $S\to AB$ 和 $A\to Ba|\epsilon$ 来说，有隐含的左公共因子， $B\to Db|D$ 也有左公共因子，所以不是$LL(1)$ 文法。下面进行角替换：
  • $(2)$ 代入 $(1)$，得：$S\to BaB|B$
    提取左公共因子：$S\to BS’,S’\to aB|\epsilon$
  • $(3)$ 提取左公共因子 ： $B\to DB’,B’\to b|\epsilon$
  • 删除 $(2)$，得
    $$\begin{array}{rl}G’[S]:S& \to BS’\\ S’& \to aB|\epsilon \\ B& \to DB’\\ B’& \to b|\epsilon \\ D& \to d|\epsilon \end{array}$$

发现代入后无公共左因子时，就不用继续角替换了

• 因为预测分析表无多重定义，所以改写后的文法是 $LL(1)$ 文法

例
下列文法是否为 $LL(1)$ 文法？如果不是，是否能改写为 $LL(1)$ 文法？
$$S\to Ap|Bq,A\to aAp|d,B\to aBq|e$$解
角替换：
$$S\to (aAp|d)p|(aBq|e)q$$

即： $S\to aApp|aBqq|dp|eq,A\to aAp|d,B\to aBq|e$
对 $S$ 变换，$S\to aS’|dp|eq,S’\to App|Bqq$
对 $S‘$ 角替换， $S’\to (aAp|d)pp|(aBq|e)qq$ 再提取左因式，$S’\to aS’’|dpp|eqq,S’’\to Appp|Bqqq$
继续重复，仍然有左因式。因此，无法改写为 $LL(1)$ 文法

例:
判断下列文法是否是 $LL(1)$ 文法，并给出 $LL(1)$ 分析表
$$\begin{array}{rl}G[E]: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 i|(E)\end{array}$$

因为 $LL(1)$ 分析表无多重定义，所以该文法是 $LL(1)$ 文法

$LL(1)$ 分析器

• $LL(1)$ 分析器是由一张 $LL(1)$ 分析表，一个控制程序和一个分析栈组成。分析栈中存放文法符号
  
• 分析器初态：分析栈中压入“#”和文法开始符号 $S$，栈顶元素是 $S$。待匹配指针指向输入串的第一个待匹配符

• 伪代码： 设 w是待匹配符号串，ip指向w#的第一个符号

do
{
	让 X 等于栈顶符号，并且让 a 是 ip 指向的符号
	if( X 是终极符或 '#')
	{ 
		if (X == a)  
		{
			把 X 从栈顶弹出，并推进 ip;
		}else 
		{
			Error;  
		}
	}else if (M[X, a] == "X→y1y2…yk”)
	{
		从栈中弹出X;
		把yk,  yk-1, …, y1压入栈;	/*  y1 在栈顶 */
	else{
		Error; 
	}
} while( X != '#')

例
以输入串 $i+i\ast i$ 为例,给出用 $LL(1)$ 分析器识别符号串的过程
$$\begin{array}{rl}G[E]: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 i|(E)\end{array}$$

先求 $LL(1)$ 分析表：

下面给出部分过程：

递归子程序

• 递归下降分析法是一种确定的自顶向下的语法分析方法，其分析过程是从文法开始符号出发，执行一组递归过程，不断向下推导，直到推出句子
• 针对文法的每一非终极符，根据相应产生式各候选式的结构，为其编写一个递归函数，用来识别该非终极符所表示的语法范畴

---

在编写递归子程序时，需要注意：

• 文法必须是 $LL(1)$ 文法 (确定的语法分析)
• 待匹配符号串是要被分析的源程序，是用助记符或整数码表示的单词类别串 (因为上一步已经经过了词法分析)
  • 例如待匹配符号串 ID:=ID+NUM#, 按从左向右扫描输入串的顺序，开始的时候，当前匹配指针指向的输入符号是 ID
• 如果遇到终极符，判断是否与输入的符号匹配。若匹配，则读取下一个待匹配符号；如果匹配失败，则意味着有语法错误
• 如果遇到非终极符，则直接调用该非终极符对应的子程序
  • 如果非终极符 $A$ 的右部只有一个候选式，则按从左向右的顺序依次构造 $A$ 的识别过程
  • 如果非终极符 $A$ 的右部有多个候选式，则根据每个候选式的第一个符号确定识别非终极符 $A$ 的流程控制转向

---

在给出示例伪代码之前，先做出如下约定：

• 定义辅助函数getsym()的作用是读取当前指针指向的待匹配符，并使待匹配指针向前移，指向下一个待匹配符。变量sym用来存储当前匹配指针指向的输入符号
• 默认进入子程序时已经取到了当前的输入符号；从子程序返回时，也已经取到了下一次准备匹配的输入符号

---

例
文法 $Z\to (U)|aUb，U\to dZ|e$，为其构造递归下降分析子程序。并对输入串 $aeb$ 进行语法分析
解
文法中有两个非终结符号 $Z$ 和 $U$，需要分别编两个函数来完成 $Z$ 和 $U$ 规则的识别

• 对于规则 $Z\to (U)|aUb$，右部有两个候选式，因此，$Z$ 的识别过程有两个分支，分别根据符号 $($ 和 $a$ 来判别
• 同理，对规则 $U\to dZ|e$ 设计的过程也分为两个分支

对于输入串 $aeb$,

• 从 $Z$ 函数开始识别(开始符号)，由于 $sym$ 不等于 $($，等于 $a$，所以选择 $Z$ 函数的右边分支，表示选择了 $Z\to aUb$ 规则。读下一个符号，使$sym=e$;
• 调 $U$ 函数，因 $sym=e$，表示使用 $U\to e$ 规则, 读下一个符号，使 $sym=b$，并返回调用程序 $Z$ 函数右边分支 $U$ 的下方，接着判断 $sym=b$，读下一个符号，并退出 $Z$.
• 在主函数中判断:若 $sym=\#$, 则分析过程结束，从而判定输入串 $aeb$ 语法分析成功
• 这个过程相当于构造了如下推导过程：$Z\Rightarrow aUb\Rightarrow aeb$

例
为下列文法的每个非终极符构造相应的递归函数
$$\begin{array}{rl}G[Z]：Z& \to (U)|aUb\\ U& \to dZ|e\end{array}$$

解

main()
{ 
	sym = getsym(); // 读取当前输入串的第一个符号
	Z();			// 从文法开始符号对应的子程序开始识别
	if (sym == '#') 
		OK; //”#”是程序结束的标志
	else 
		error("error in main");
}

Z() 	// Z→(U) | aUb 
{
	if(sym == '(')
	{ 
		sym = getsym();
		U();
		if(sym != ')') 
		{
			error( "缺 )" ) ; 
			exit(0);
		} else 
			sym = getsym();
	}
	else if(sym == 'a')
	{ 
		sym = getsym();
		U();
		if(sym != 'b') 
		{
			error ("缺b"); 
			exit(0);
		} else 
			sym = getsym();
	}
	else {
		error ("缺 ( 或 a"); 
		exit(0);
	} 
}

U() 	// U→dZ | e 
{
	if(sym == 'd')
	{ 
		sym = getsym();
		Z();
	}else if(sym == 'e')
		sym = getsym();
	else {
		error( "缺 d 或 e" ); 
		exit(0);
	}
}

例
为下列文法的每个非终极符构造相应的递归函数.
$$\begin{array}{rl}G[E]：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 i|(E)\end{array}$$
解

main()
{ 
	sym = getsym(); // 读取当前输入串的第一个符号
	E();			// 从文法开始符号对应的子程序开始识别
	if (sym == '#') // 这里的 == 可能需要调用词法分析器来识别单词
		OK; //”#”是程序结束的标志
	else 
		error (“error in main”);
}

E() 	// E→TE'
{
	if(sym == 'i' || sym == '(') /* if (sym is in first(T)) */
	{ 
		T();
		E'();
	}else {
		error("非法符号", sym); 
		exit(0);
	} 
}


E'() 	// E'→+TE'|epsilon
{
	if (sym == '+')
	{ 
		sym = getsym();
		T(); 
		E'();
	}else if (sym != '#' && sym != ')') /* if (sym is not in follow(E')) */
	{
		error("非法符号", sym); 
		exit(0);
	}
} //意味着用 E'→epsilon 推导

T() // T→FT'
{
	if (sym == 'i' || sym == '(' ) /* if (sym is in first(F)) */
	{ 
		F();
		T'();
	}else {
		error("非法符号", sym); 
		exit(0);
	} 
}


T'() 	// T'→*FT'|epsilon
{
	if (sym == '*')
	{ 
		sym = getsym();
		F(); 
		T'();
	}else if (sym != '#' && sym != '+' && sym != ')')	// if (sym is not in follow(T'))
	{
		error("非法符号", sym); 
		exit(0);
	}
} //意味着用 T'→epsilon 推导


F() 	// F → i | (E)
{
	if(sym == 'i')
		sym = getsym(); 
	else if(sym == '(')
	{ 
		sym = getsym();
		E();
		if(sym == ')') 
			sym = getsym();
		else {
			error("缺)"); 
			exit(0);
		}
	}else {
		error("缺（或i "); 
		exit(0);
	} 
}

---

• 一般在用递归子程序时，表达式都是用迭代形式实现，更加简洁

可以比较一下下面的例子与上面的例子

例
$$\begin{array}{rl}G[E]：E& \to E+T|+T|-T\\ T& \to T\ast F|F\\ F& \to i|(E)\end{array}$$

设计递归子程序
解
对文法 $G$ 消除左递归为 $G^{\prime }(E)$:(使用迭代形式)
G ′ [ E ] ： E → [ + ∣ − ] T { + T } T → F { ∗ F } F → i ∣ ( E ) \begin{aligned}G'[E]：E&→[+|-]T\{+T\} \\ T&→F\{*F\}\\ F&→i|(E)\end{aligned} G′[E]：ETF​→[+∣−]T{+T}→F{∗F}→i∣(E)​

E() 	// E→ [+|-] T{+T}
{ 
	if (sym == '+' || sym == '-')
	{ 
		sym = getsym();
		if(sym == 'i' || sym == '(')
			T();
		else { 
			error; 
			exit(0);
		}
	} else if (sym == 'i' || sym == '(' )
		T();
	else { 
		error; 
		exit(0);
	}
	while (sym == '+')
	{ 
		sym = getsym();
		if (sym == 'i' || sym == '(' )
			T();
		else { 
			error; 
			exit(0);
		}
	}
}

T() 	// T→ F{*F}
{
	if(sym == 'i' || sym == '(' )
		F();
	else { 
		error; 
		exit(0);
	} 
	while (sym == '*')
	{ 
		sym = getsym();
		if (sym == 'i' || sym == '(') 
			F();
		else { 
			error; 
			exit(0);
		}
	}
}


F() 	// F → i | (E)
{
	if(sym == 'i')
		sym = getsym(); 
	else if(sym == '(')
	{ 
		sym = getsym();
		E();
		if(sym == ')') 
			sym = getsym();
		else {
			error("缺)"); 
			exit(0);
		}
	}else {
		error("缺 ( 或 i "); 
		exit(0);
	} 
}