编译原理 第四章 Top-Down Parsing

本书以 编译原理及实践 为textbook

Chapter Four. Top-Down Parsing

Recursive-descent parsing(requires EBNF)
LL(k) parsing
when LL(1) parsing,the process is in the stack,so the parsing is inverted
action:generate(replace a non-terminal A at the top of stack by grammer $A\to \alpha$) or match
LL(1) parsing table-construction rule

1. if $A\to \alpha$ and $\alpha {\Rightarrow }^{\ast }a\beta$($a$ is a token),add $A\to \alpha$ to the table entry $M[A,a]$;
2. if $A\to \alpha$ and $\alpha {\Rightarrow }^{\ast }ϵ$ and $S$$${\Rightarrow }^{\ast }\beta Aa\gamma$(S is the start symbol,a is a token(or $)),add $A\to \alpha$ to the table entry $M[A,a]$

LL(1) grammer if parsing table has at most one production in table entry
algorithm:

1. if the top of the parsing stack is terminal $a$ and the next input token is $a$,then match(pop the parsing stack,advance the input),else error
2. if the top of the parsing stack is non-terminal $A$ and the next input token is $a$,and exist $M[A,a]=A\to X_1{X}_2...X_n$),then generate(pop the parsing stack and push $X_i$ onto the parsing stack by reverse order),else error
   if the top of the parsing stack is $ and the next input token is $,accept

left recursion removal
immediate left recursion
indirect left recursion

1. immediate left recursion
   $A\to A\alpha |\beta$
   transform to
   $$\begin{gathered} A\to \beta A^{\prime } \\ {A}^{\prime }\to \alpha A^{\prime }|ϵ \end{gathered}$$

2. general immediate left recursion
   $A\to A{\alpha }_1|A{\alpha }_2|...|A{\alpha }_n|{\beta }_1|{\beta }_2|...|{\beta }_m$
   transform to
   $$\begin{gathered} A\to {\beta }_{1}A|{\beta }_{2}A|...|{\beta }_m{A}^{\prime } \\ {A}^{\prime }\to {\alpha }_1{A}^{\prime }|{\alpha }_2{A}^{\prime }|...{\alpha }_n{A}^{\prime }|ϵ \end{gathered}$$

3. general left recursion
   gammers with no $ϵ$-productions and no cycles
   algorithm:

   1. picking an arbitrary order for all non-terminals,say,$A_1,...,A_m$
   2. eliminates all rules of the form $A_i\to A_j\gamma$ with $j⩽i$
   3. every step in suach a loop would only increase the index,and thus the original index cannot be reached again

   pseudo code：

i=1 to m
	j=1 to i-1
		repalce Ai->Ajβ by the rule Ai->α1β|α2β|...|αkβ 
		where Aj->α1|α2|...|αk is the current rule for Aj
	remove,if necessary,immediate left recursion involving Ai

right recursion grammer can be executed in left recursion way by return value for non-terminal token

left factoring
solution:
$A\to \alpha \beta |\alpha \gamma$
transforms to
$$\begin{gathered} A\to \alpha A^{\prime } \\ {A}^{\prime }\to \beta |\gamma \end{gathered}$$
algorithm:
…
It is more difficult for LL(1) to adapt to syntax tree construction.

1. The structure of the syntax tree can be obscured by left factoring and left recursion removal;
2. The parsing stack represents only predicated structure, not structure that have been actually seen.
   The solution:
3. An extra stack is used to keep track of syntax tree nodes;
4. “action” markers are placed in the parsing stack to indicate when and what actions on the tree stack should occur.

First Set,means the first nonterminal can be derivated by the token
Follow Set,means the first nonterminal(except $ϵ$) following the token

First Set algorithm:
$\alpha \to X_1{X}_2...X_n$

1. First($\alpha$) contains F i r s t ( X 1 ) − { ϵ } First(X_{1})-\{\epsilon\} First(X1​)−{ϵ}
2. For each $i=2,...,n$,if forr all $k=1,...,i-1$,$First(X_k)$ contains $ϵ$,then $First(\alpha )$ contains F i r s t ( X k ) − { ϵ } First(X_{k})-\{\epsilon\} First(Xk​)−{ϵ}
3. if all the set $First(X_1)$,…,$First(X_n)$ contain $ϵ$,then $First(\alpha )$ contains $ϵ$

Follow Set algorithm:

1. If A is the start symbol,the $ is in the $Follow(A)$.
2. If there is a production $B\to \alpha A\gamma$,then F i r s t ( γ ) − { ϵ } First(\gamma)-\{\epsilon\} First(γ)−{ϵ} is in $Follow(A)$
3. If there is a production $B\to \alpha A\gamma$,and $ϵ$ in $First(\gamma )$,then $Follow(A)$ contains $Follow(B)$

simplify LL(1) parsing table-construction rules:

1. For each token $a$ in $First(\alpha )$,add $A\to \alpha$ to the entry $M[A,a]$.
2. If $ϵ$ is in $First(\alpha )$,for each element $a$ of $Follow(A)$(a token or $),add $A\to \alpha$ to $M[A,a]$.

A garmmer in BNF is $LL(1)$ if the following conditions are satified:

1. For every production $A\to {\alpha }_1|{\alpha }_2|...|{\alpha }_n$,$First({\alpha }_i)\bigcap First({\alpha }_j)$ is empty for all $i$ and $j$,$1⩽i,j⩽n$,$i\ne j$
2. For every non terminal $A$ such that $First(A)$ contains $ϵ$,$First(A)\bigcap Follow(A)$ is empty.

error recovery
different levels of response to errors:

1. Give a meaningful error message;
   determine as closely as possible the location where that error has occurred.
2. Some form of error correction; (error repair)
   the parser attempts to infer a correct program from the incorrect one given.

Some important considerations that apply are the following:

1. To determine that an error has occurred as soon as possible.
2. After an error has occurred
   pick a likely place to resume the parse
   try to parse as much of the code as possible
3. To avoid the error cascade problem.
4. To avoid infinite loops on error.

Panic mode:

1. A standard form of error recovery in recursive-decent parsers
2. The error handler will consume a possibly large number of tokens in an attempt to find a place to resume parsing;

mechanism:

1. A set of synchronizing tokens are provided to each recursive procedure;
2. If an error is encountered, the parser scans ahead, throwing away tokens until one of the synchronized tokens is seen in the input, whence parsing is resumed.

one way is parsing table,another way is use synchset stack
LL(1) parsing table addition:

1. $M[A,\alpha ]=sync$,if $\alpha \in Follow(A)$
2. $M[A,\alpha ]{=}^{\prime }ski{p}^{\prime }$,if $\alpha \notin First(A)\cup Follow(A)$

Given a non-ternimal A at the top of the stack and an input token that is not in First(A) (or Follow(A), if εis in First(A)), there are three possible alternative:

1. Pop A from the stack.
2. Successively pop tokens from the input until a token is seen (restart).
3. Push a new non-terminal onto the stack

algorithm:

1. alternative 1 (Pop)
   if the current input token is $ or is in Follow(A);
2. alternative 2 (scan)
   if the current input token is not $ and is not in First(A)∪Follow(A)
3. Option 3 (Push a new non-terminal )
   occasionally useful in special situation.