编译原理 第五章 Bottom-Up Parsing

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

Chapter Five. Bottom-Up Parsing

LR grammars (from Left to Right,rightmost derivation)
shift-reduce parsers
action:

1. Shift : Shift a terminal from the front of the input to the top of the stack.
2. Reduce: Reduce a string $\alpha$ at the top of the stack to a nonterminal A, given the BNF choice $A\to \alpha$.
   A bottom-up parser : a shift-reduce parser.

One further feature of bottom-up parsers： grammars are always augmented with a new start symbol.
if S is the start symbol, a new start symbol S’ is added to the grammar : $S^{\prime }\to S$

LR(0) item
NFA of LR(0):

1. If X is a token or a nonterminal
   the item can be written as $A\to \alpha \cdot X\eta$
2. If X is a token, then this transition corresponds to a shift of X from the input to the top of the stack during a parse.
3. if X is a nonterminal
   X will never appear as an input symbol. (such a transition will still correspond to the pushing of X onto the stack during a parse, but this can only occur during a reduction by a production $X\to \cdot \beta$ )

DFA of LR(0)
LR(0) Parsing Algorithm:
Let s be the current state (at the top of the parsing stack).Then actions are defined as follows:

1. If state s contains any item of the form $A\to \alpha \cdot X\beta$(X is a terminal). Then the action is to shift the current input token X on to the stack.
   if the token is not X, an error is declared.

2. If state s contains any complete item (an item of the form $A\to \gamma \cdot$), then the action is to reduce by the rule $A\to \gamma \cdot$

   1. back up to the state from which the construction γ began. This state must contain a item of the form $B\to \alpha \cdot A\beta$;Push $A$ onto the stack.
   2. A reduction by the rule $S^{\prime }\to S$, where S’ is the start state,

   Acceptance if the input is empty
   Error if the input is not empty.

A grammar is LR(0) if and only if

1. each state is a shift state( a state containing only “shift” items)
2. a reduce state containing a single complete item.

LR(0) Parsing Table
The table rows labeled with the states of the DFA.

SLR(1) Parsing
algorithm:

1. If state s contains any item of form $A\to \alpha \cdot X\beta$, then the action is to shift the current input token X onto the stack, and the new state to be pushed on the stack is the state containing the item $A\to \alpha X\cdot \beta$
2. If state s contains the complete item $A\to \gamma \cdot$ ,and the next token in the input string is in $Follow(A)$, then the action is to reduce by the rule $A\to \gamma \cdot$.
   1. A reduction by the rule $S^{\prime }\to S$, where $S^{\prime }$ is the start state, this will happen only if the next input token is $.
   2. Remove the string $\gamma$ and all of its corresponding states from the parsing stack, back up in the DFA to the state from which the construction of $\gamma$ began.
   3. This state must contain an item of the form $B\to \alpha \cdot A\beta$ ;Push $A$ onto the stack, and push the state containing the item $B\to \alpha A\cdot \beta$ .
3. If the next input token is such that neither of the above two cases applies, an error is declared.

a grammar is SLR(1) if and only if, for any state $s$, the following two conditions are satisfied:

1. For any item $A\to \alpha \cdot X\beta$ in $s$ with $X$ a terminal, there is no complete item $B\to \gamma \cdot$ in s with $X\in Follow(B)$.
2. For any two complete items $A\to \alpha \cdot$ and $B\to \beta \cdot$ in $s$, $Follow(A)\cap Follow(B)$ is empty.

SLR(1) is likely to cause stack overflow when it has lots of right recursion
remove right recursion(like remove left recursion)

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

2. $A\to {\alpha }_{1}A|{\alpha }_{2}A|...|{\alpha }_{n}A|{\beta }_1|{\beta }_2|...|{\beta }_m$
   transform to
   $$\begin{gathered} A\to A^{\prime }({\beta }_1|{\beta }_2|...|{\beta }_m) \\ {A}^{\prime }\to A^{\prime }({\alpha }_1|{\alpha }_2|...|{\alpha }_n)|ϵ \end{gathered}$$

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

   1. picking an arbitrary order for all non-terminals, ay,$A_1,...,A_m$
   2. eliminates all rules of the form $A_i\to \gamma A_j$ 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

two kinds of parsing conflicts:
shift-reduce conflicts
reduce-reduce conflicts
always prefer the shift over the reduce.

LR(1) Parsing
an LR(1) item is a pair consisting of an LR(0) item and a lookahead token,like $[A\to \alpha \cdot \beta ,a]$,$a$ means follow $A$
parsing algorithm:

1. Given an LR(1) item $[A\to \alpha \cdot X\gamma ,a]$, where $X$ is any symbol (terminal or nontermilnal), there is a transition on X to the item $[A\to \alpha X\cdot \gamma ,a]$
2. Given an LR(1) item $[A\to \alpha \cdot B\gamma ,a]$, where $B$ is a nonterminal, there are $ϵ$-transitions to items $[B\to \cdot \beta ,b]$ for every production $B\to \beta$ and for every token b in $First(\gamma a)$.

The start symbol of the NFA of LR(1) items becomes the item [S’ —>.S, $].

General LR(1) parsing algorithm:
Let $s$ be the current state (at the top of the parsing stack). Then actions are defined as follows:

1. If state $s$: any LR(1) item of the form $[A\to \alpha \cdot X\beta ,a]$, $X$ is a terminal, and $X$ is the next token in the input string
2. If state $s$ : the complete LR(1) item $[A\to \alpha \cdot ,a]$ , the next token: in the input string is $a$
3. If the next input token is such that neither of the above two cases applies, an error is declared.

a grammar is LR(1) if and only if, for any state $s$. the following two conditions are satisfied.

1. For any item $[A\to \alpha \cdot X\beta ,a]$ in s with $X$ a terminal, there is no item in s of the form $[B\to \gamma \cdot ,X]$ (otherwise there is a shift-reduce conflict).
2. There are no two items in s of the form $[A\to \alpha \cdot ,a]$ and $[B\to \beta \cdot ,a]$ (otherwise, there is a reduce-reduce conflict).

LALR(1) Parsing
principle:

1. The core of a state of the DFA of LR(1) items is a state of the DFA of LR(0) items.
2. Given two states $s1$ and $s2$ of the DFA of LR(1) items that have the same core, suppose there is a transition on the symbol $X$ from $s1$ to a state $t1$. Then there is also a transition on $X$ from state $s2$ to a state $t2$, and the states $t1$ and $t2$ have the same core.

propagating lookaheads parsing:unknown

error recovery
An LR(1) parser can, for example, detect errors earlier than an LALR(1) or SLR(1) parser, and these latter can detect errors earlier than an LR(0) parser. (earlier is on time)

A good error recovery in bottom-up parsers: removing symbol from either the parsing stack or the input or both.
There are three possible alternative actions:

1. Pop a state from the stack.
2. Successively pop tokens from the input until a token is seen for which we can restart the parse.
3. push a new state onto the stack.

more concrete,

1. Pop states from the parsing stack until a state is found with nonempty Goto entries.
2. If there is a legal action on the current input token from one of the Goto states, push that state onto the stack and restart the parse. If there are several such states,prefer a shift to a reduce.Among the reduce actions,prefer one whose associated nonterminal is lesat general.
3. If there is no legal action on the current input token from one of the Goto states, advance the input.

There are several possible solutions (infinite loop):

1. insist on a shift action from a Goto state in step 2. （ too restrictive ）
2. if the next legal move is a reduction, to set a flag that causes the parser to keep track of the sequence of states during the following reductions
3. if the same state recurs, to pop stack states until the original state is removed.

yacc:
{definitions}
%%
{rules}
%%
{auxiliary routines}

%{
#include <stdio.h>
#include <ctype.h>
%}
%token NUMBER
%%
command:   exp { printf (“%d\n”,$1);}
                  ;            /*allows printing of the result */
exp: exp '+' term   {$$ = $1 + $3;}
      | exp '-' term     {$$ = $1 - $3;}
      | term                  {$$ = $1;}
      ;
term:  term '*' factor   {$$ = $1* $3;}
       | factor  {$$ = $1;}
       ;
factor :NUMBER   {$$ = $1;}
          | '('  exp ')'  {$$=$2;}
          ;
%% 
main ( )
{ return yyparse( ); 
}
int yylex(void)
{   int c;
    while( ( c = getchar ( ) )== ‘ ’ );
   /*eliminates blanks */
   if ( isdigit(c) ) {
      unget (c,stidin) ;
      scanf (“%d”,&yylval ) ;
      return (NUMBER ) ;
    }
   if (c== ‘\n’) return 0;
       /* makes the parse stop */
   return ( c ) ;
 }
int yyerror (char * s)
{ fprintf (stderr, “%s\n”,s ) ;
return 0;
}/* allows for printing of an error message */

yacc优先级:

1. Yacc disambiguates by preferring the reduction by the grammar rule listed first in the specification file.
2. %left ‘+’ ‘-’
   %left ‘*’ (specified in the definitions )
   the operators ‘+’ and ‘-’ have the same precedence and are left associative
   the operator ‘*’ is left associative and has higher precedence than ‘+’ and ‘-’
3. the priority of a rule is given by the last token occurring on the right-hand side of that rule.
   1. If the rule has higher priority, the conflict is resolved in favor of reducing.
   2. If the rule and token have equal priority, then a left precedence favors reducing, right favors shifting, and nonassoc yields an error action.
   3. assign a specific precedence to a rule using the %prec directive

Local error recovery mechanisms:
adjusting the parse stack and the input at the point where the error was detected in a way that will allow parsing to resume.
Yacc parser generator :uses a special error symbol to control the recovery process.
error is considered a terminal symbol.
When the LR parser reaches an error state, it takes the following actions:

1. Pop the stack (if necessary) until a state is reached in which the action for the error token is shift.
2. Shift the error token.
3. Discard input symbols (if necessary) until a lookahead is reached that has a nonerror action in the current state.
4. Resume normal parsing.