Bottom Up Parsing

• Top down parsing starts at the root and works towards the leaves.
• Bottom up starts at the leaves and works towards the root.
• We will start with shift-reduce parsing
  • In this method we either shift input tokens to a holding area
  • Or apply a rule to reduce the tokens to a nonterminal.
• When we reduce, we would be building the nodes of a parse tree if so desired.
• The decision to shift or reduce, and what to reduce to are really the only considerations here.
• He states that it would be too intense to build a shift-reduce parser by hand.
• This is a method parser generation tools use.
• By the way, this is LR parsing.
• A handle
  • S =>^*_rm αAω =>_rm αβω
  • Then A → β
  • And the position following α is the handle of αβω
  • "Informally a handle is a substring that matches the body of a production, and is a step along the reverse of a rightmost derivation"
• Consider the grammar:

  E → E + T 
    | T
  T → T * F 
    | F
  F → (E)
    | id
  
  Parse id1 * id2
  
  
  Right Sentential Form
   Handle
   Input
   Production
   Action
   $ 
    
   id1 * id2 $ 
    
   Shift
   $id1 
  id1 
    * id2 $ 
   F → id
   Reduce
   $F 
  F 
    * id2 $ 
   T → F
   Reduce
   $T 
    
    * id2$
    
   Shift
   $T * 
    
    id2$
    
   Shift
   $T * id2 
  id2  
   $ 
   F → id
   Reduce
   $T * F  
   T * F 
   $ 
   T → T * F 
   Reduce
   $T  
   T  
   $ 
   E → T 
   Reduce
   $E  
      
   $ 
     
   Accept
  
      

• He provides an alternative definition for a handle
  • The handle of a right sentential form γ is the production A → β
  • and a position in γ where the string β may be found,
  • such that replacing β at that position by A produces the previous right-sentential form of the rightmost derivation of γ
• Handle pruning
  • Starting with a string of terminals ω
  • If ω is a sentence of the grammar
  • Let ω = γ_n, where γ_n is the n^th right sentential form of some rightmost derivation.
  • To reconstruct the derivation
    • locate the handle β_n in γ_n
    • And replace β_n with A_n where A_{n → βn}
    • This provides γ_n-1
    • Repeat until the start simple is reached.
• Shift-Reduce Parsing
  • An input buffer and a stack.
  • Start with $ on the stack and ω$ in the input buffer
  • Shift 0 or more input symbols onto the stack.
  • If possible reduce the top symbols on the stack
  • End with $S on the stack and $ in the input buffer.
• Actions: Shift, Reduce, Accept, Error
• He notes that the handle will always be on the top of the stack
  • Two cases
  • See the picture on page 238
  • In both cases production A → δ was applied first in the derivation and B → ρ was applied later.
    • In case 1, A → &alpah;Bβ
    • In case 2, A and B are not related.
  • So in the reverse derivation, the B*rarr; ρ be reduced before A → δ
    1. S =>^*_rm αAz =>_rmαβByz =>_rmαβγyz
       • B → γ
       • A → βBy
       • At some point

             STACK      INPUT
             $αβγ        yz$      Reduce    B → γ
             $αβB        yz$      Shift
             $αβBy       z$       Reduce    A → βBy
             $αA         z$      
         
         		 

    2. S =>^*_rm αBxAz =>_rm α Bxyz =>_rm αγxyz
       • B → γ
       • A → y
       • At some point

             STACK      INPUT
             $αγ         xyz$      Reduce    B → γ
             $αB         xyz$      Shift
             $αBx        yz$       Shift
             $αBxy       z$        Reduce    A → y
             $αBxA       z$       
         	    

  • Notice that in both cases, there was no reason to search past the top of the stack for the next handle.
• Conflicts during Shift-Reduce Parsing.
  • With these parsers there are several types of problems we can encounter
  • Our friend the dangling else presents a shift/reduce conflict

    
    stmt → if expr then stmt
         | if expr then stmt else stmt
         | other
    
    
              STACK                    INPUT
        $α if expr then stmt         else...$
    	

  • In this case we don't know if we should reduce by the first prodcution or shift to prepare for the second.
  • We should select the shift, as the rule in c++ is associate the else with the closest if.
  • This grammar is not in LR(k), which will be defined later.
  • But the above workaround will do. Simply prefer shift in this case.
  • A second example:

    stmt           → id ( parameter_list)
                   | expr := expr
    parameter_list → parameter_list, parameter
                   | parameter
    parameter      → id
    expr           → id (expr_list)
                   | id
    expr_list      → expr_list, expr
                   | expr
    	

  • Parameter lists and arrays are both marked with id₁(
  • We will have a reduce/reduce error here
  • We could solve this problem by determining what id₁ represents.
  • We could have a new nonterminal procid to identify procedure definitions.
  • So this could be handled in the lexer