Writing a Grammar

• Intro
  • Grammars can not describe all programming language syntax
    • The book mentions checking to see that identifiers are declared before they are used.
    • But in some sense, we don't need to have that in the language, we can do that as we build the parse tree.
  • The parser will accept a superset of the language
  • And further steps must ensure that the other requirements are met.
• Lexical Vs Syntatic Analysis
  • They once again ask why break things were we do (lexer, parser ...)
    1. It is a good place to break things apart.
    2. Lexical rules fit nicely in regular expressions
    3. Lexical analizers can be built automatically.
  • Grammars are good at nested structures.
• Eliminating Ambiguity
  • The following is ambiguious

  • 
    stmt  → if expr then stmt
          | if expr then stmt  else stmt
          | other
    	

  • Parse if E₁ then S₁ else if E₂ then S₂ else S₃
  • Parse if E₁ then if E₂ then S₁ else S₂
    • Favor the rules in order of statements given
    • Favor the largest rule that applies.
  • Most languages use "Match else with the closest then
    • C has this problem even though it does not have an then
    • They state that this can be done in the grammar but is rarely done.
    • How do we fix this at Edinboro?
  • They present an unabiguous grammar

  • stmt	→	matched_stmt
    	|	open_stmt
    matched_stmt	→	if expr then matched_stmt else matched_stmt
    	|	other
    open_stmt	→	if expr then stmt
    	→	if expr then matched_stmt else open_stmt

  • Parse if E₁ then if E₂ then S₁ else S₂
• Elimination of Left Recursion
  • This grammar is left recursive

    E	→	E + T
    	|	T
    T	→	T * F
    	|	F
    F	→	( E )
    	|	id

  • In general A =>⁺ Aα
  • Left recursion is unacceptable for a top down parser.
  • So we need to eliminate left recursion.
  • For immediate left recurison we do the following transformation

    A  → Aα | Β
    becomes
    
    A  → ΒA'
    A' → αA' | ε
    	 

  • Eliminate the left recursion in the above grammar.
  • more generally

    A  → Aα1 | Aα2 |  ... | Aαm | Β1 | Β2 |  ... | Βn
    
    becomes
    
    A  → Β1A' | Β2A' | ... | ΒnA'
    A' → α1A' | α2A' | ... | αmA' | ε
    	 

  • Non-immediate left recursion

    • S → Aa | b
      A → AC | Sd | ε
      	  

    • We can derive S => Aa => Sda (S =>⁺ Sα)
    • They give an algorithm.

      
       arrange nonterminals in some order A1 A2 ... An
       for (each i from 1 to n) {
         for ( each j from 1 to i -1) {
           replace each production of the form Ai→ Ajγ 
                with productions Ai → δ1γ | δ2γ| ... | δkγ
      	  where Aj→ δ1 | δ2 | ... | δk aer all current Aj productions.
           }
           eliminate the immedate left recursion among the Ai productions.
         }
       }