Introduction to LR Parsing: Simple LR

• We begin with a look at a simple? LR scheme
• And more complex schemes are introduced in later sections.
• We will generate an automaton, with a set of states.
• These states will be used for diagnostic messages from parser generators.
• The parser we build will be table driven.
• Why LR prsers
  • An LR grammar is a grammar where a left-to-right shift-reduce parser can recognize handles of right-sentenail forms when they appear on the top of the stack.
  • Why use them?
    • "Virtually all" languages constructs can be written in LR grammars
    • It is the most general non-backtracking algorithm known, but it is as efficient as other moethods
    • It detects syntax errors as soon as possible in left-to-right scan of input.
    • L(LL) &issub; L(LR)
  • Again he states that constucting LR parsers is hard to do by hand, but as we will see, it is not too bad to program.
  • YACC
• Itemsn and the LR(0) Automaton
  • LR parsers maintain a set of states to keep track of where they are in a parse.
  • States represent items
    • An item is a production of the grammar, with a dot at some position.
    • A → .XYZ, A→ X.YZ ...
    • A → ε is represented by A→ .
    • An item represents what we have seen so far in the parsing process.
  • A subset of the items called the canonical LR(0) collection are used to build an automaton to make parsing decisions.
    • In some sense, we enumerate every state the parser could be in with every rule.
    • Generate an item for each
    • Build an automaton from these.
  • This makes this type of parser take up quite a bit of memory
  • But there are ways to fix this.
  • Consider

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

  • Add the state E' → E to form G'
    • G' is an augmented grammar
    • This new state gives us the ability to tell when we are done.
      • If we are in E' and the input is empty, accept
  • We will consider two functions CLOSURE and GOTO
  • For a set of items I, CLOSURE(I) is a new set constructed by
    1. Add every item in I to CLOSURE(I)
    2. If A → α.Bβ, and B→γ add B→.γ to CLOSURE(I)
    3. Repeat until no other items can be added to CLOSURE(I)
  • GOTO(I,X)
    • I is a set of items.
    • X is a symbol
    • Construct a new set
    • If A → α.Xβ then add A→ αX.β to GOTO(I,X)
  • Construct the table on 244
  • He illustrates how this will be used to parse id + id
    • There is a stack which holds the states we have been in, initially it contains a 0

      Stack	Symbols	Input	Action
      0	$	id + id	shift to 5
      0 5	$ id	*id	Reduce F→ id
      0	$ F	+ id	go to state 3
      0 3	$ F	+ id	Reduce T → F
      0	$ T	+ id	go to state 2
      0 2	$ T	+ id	Reduce E → T
      0	$ E	+ id	go to state 1
      0 1	$ E	+ id	Shift, goto sate 6
      0 1 6	$ E +	id	Shift, goto sate 5
      0 1 6 5	$ E + id	$	Reduce F → id
      0 1 6	$ E + F	$	go to state 3
      0 1 6 3	$ E + F	$	Reduce T → F
      0 1 6	$ E + T	$	go to state 9
      0 1 6 9	$ E + T	$	Reduce E → E + T
      0 1 6	$ E	$	Reduce E → E + T