Lecture9 syntax analysis_5
0 likes144 views
Bottom-up parsing builds parse trees starting from the leaves (terminals) and working towards the root (start symbol). It can handle a more general class of grammars than top-down parsing. Shift-reduce parsing splits the input string into two parts separated by a special character, with terminals on the right. It uses two actions: shift moves a terminal from right to left, and reduce applies a production to remove symbols from the left. Conflicts can occur when it is possible to shift or reduce, or to reduce in different ways. Handles mark points where reduction also allows deriving the start symbol.
Lecture9 syntax analysis_5
- 1. Syntax Analysis IV Lecture 9 Syntax Analysis IV Bottom-Up Parsing
- 2. Bottom-Up Parsing • Given a grammar G, a parse tree for a given string is constructed by starting at the leaves (terminals of the string) and working to the root (the start symbol S). • They are able to accept a more general class of grammars compared to top-down predictive parsers. • It builds on the concepts developed in top-down parsing. • Preferred method for most of the parser generators including bison • They don’t need left-factored grammars – So, its valid to use the following grammar E T + E | T T int * T | int | (E)
- 3. • A parse for a string generates a sequence of derivations of the form: S δ0 δ1 δ2 … … δn-1 sentence • Bottom-up parsing reduces a string to the start symbol by inverting productions Bottom-Up Parsing • Let A b be a production and δi-1 and δi be two consecutive derivations with sentential forms: αAβ and αbβ – δi-1 is derived from δi by match the RHS b in δi, and then replacing b with its corresponding LHS, A. This is called a reduction • The parse tree is the result of the tokens and the reductions.
- 4. • Consider the parse for the input string: int * int + int E T + E | T T int * T | int | (E) • When we reduce, we only have terminals to the right. Sentential Form Productions int * int + int int * T + int T int T + int T int * T T + T T int Bottom-Up Parsing terminals to the right. – In the reduction: αAβ αbβ – If b to A is a step of a bottom-up parsing (i.e. A b is a reduction) – Then β is a string of terminals • In other words, a bottom-up parser traces a rightmost derivation in reverse T + E E T E E T+E
- 5. Shift-Reduce Parsing • Idea: Split string being parsed into two parts: – Two parts are separated by a special character ‘|’ – Left part is a string of terminals and non terminals – Right part is a string of terminals • Still to be examined • Bottom up parsing has two actions• Bottom up parsing has two actions – Shift: Move terminal symbol from right string to left string • ABC | xyz ABCx | yz – Reduce: Apply an inverse production at the right end of the left string – If A xy is a production, then • Cbxy | ijk CbA | ijk
- 6. Sentential Form Productions |int * int + int Shift int | * int + int Shift int * | int + int Shift int * int | + int Reduce T int int * T | + int Reduce T int * T Shift-Reduce Example int * T | + int Reduce T int * T T | + int Shift T + | int Shift T + int | Reduce T int T + T | Reduce E T T + E | Reduce E T+E E | Accept
- 7. To Shift or Reduce • Symbols on the left of “|” are kept on a stack – Top of the stack is at “|” – Shift pushes a terminal on the stack – Reduce pops symbols (RHS of production) and pushes a non terminal (LHS of production) onto the stack • The most important issues are: – When to shift and when to reduce! – Which production to use for reduction? – Sometimes parser can reduce but it should not! – X Є can always be reduced! – Sometimes parser can reduce in different ways!
- 8. • In a given state, more than one action (shift or reduce) may lead to a valid parse – If it is legal to shift or reduce: • Shift-reduce conflict – If it is legal to reduce by two different productions: To Shift or Reduce ? - Conflicts – If it is legal to reduce by two different productions: • Reduce-reduce conflict • Reduce action should be taken only if the result can be reduced to the start symbol
- 9. Shift-Reduce Parsing - Handles • A substring that matches the right-side of a production that occurs as one step in the rightmost derivation. This substring is called a handle. • Because d is a right-sentential form, the substring to the right of a handle contains only terminal symbols. Therefore, the parser doesn’t need to scan past theTherefore, the parser doesn’t need to scan past the handle. • If a grammar is unambiguous, then every right sentential form has a unique handle • If we can find those handles, we can build a derivation
- 10. Recognizing Handles • Given the grammar: E T + E | T T int * T | int | (E) • Consider step : int | * int + int • We could reduce by T int giving T | * int + int – But this is incorrect because: • No way to reduce to the start symbol E • So, a handle is a reduction that also allows further reductions back to the start symbol • In shift-reduce parsing, handles appear only at the top of the stack, never inside
- 11. • Handles always appear only at stack top: – Immediately after reducing a handle – Right-most non-terminal on top of the stack – Next handle must be to right of right-most non- terminal, because this is a right-most derivation – Sequence of shift moves reaches next handle Recognizing Handles – Sequence of shift moves reaches next handle • It is not obvious how to detect handles • At each step the parser sees only the stack, not the entire input; start with that . . . • α is a viable prefix if there is a β such that α|β is a state of a shift-reduce parser
- 12. Viable Prefixes • A viable prefix does not extend past the right end of the handle • It’s a viable prefix because it is a prefix of the handle • As long as a parser has viable prefixes on the stack no parsing error has been detectedstack no parsing error has been detected • For any grammar, the set of viable prefixes is a regular language • So, we can generate an automata to recognize viable prefixes!
- 13. Hierarchy of Grammar Class