Context-Free Grammar (CFG)

Transcription

1 Context-Free Grammar (CFG) context-free grammar looks like this bunch of rules: ain idea: + 1 (),, are non-terminal symbols aka variables. When you see them, you apply rules to expand. One of them is designated as the start symbol. You always start from it. I will designate as the start symbol. +,,, 1, (, ) are terminal symbols. They are the characters you want in your language. 1 / 12

2 Derivation (aka Generation) Derivation is a finite sequence of applying the rules until all non-terminal symbols are gone. Often aim for a specific final string () 1 ( + ) 1 ( + ) 1 ( + ) 1 ( + ) 1 ( + ) 1 ( + ) 1 ( + ) 1 ( + 1 ) 1 ( + 1 1) Context-free grammars can support: matching parentheses, unlimited nesting. 2 / 12

3 Backus-Naur Form (BNF) Backus-Naur Form is a computerized, practical notation for CFGs. Surround non-terminal symbols by <>; allow multi-letter names. erge rules with the same LHS. (Some versions.) Surround terminal strings by single or double quotes. Use ::= for. Our example grammar in BNF: <expr > ::= <expr > "+" <expr > <mul > <mul > ::= <mul > "*" <mul > <atom > <atom > ::= "" "1" "(" <expr > ")" 3 / 12

4 xtended Backus-Naur Form (BNF) {...} for or more occurrences. [...] for or 1 occurrences. Some versions: No <> needed around non-terminal symbols. xample: Lisp/Scheme S-expression 1 grammar (basic): In BNF: <s- expr > ::= <identifier > "(" <s- exprs > ")" <s- exprs > ::= s- expr s- expr s- exprs In BNF: <s- expr > ::= <identifier > "(" <s-expr > { <s-expr > } ")" So you need fewer artificial non-terminals and rules that merely mean at least of this, at least 1 of that, etc. 1 symbolic expression 4 / 12

5 Parse Tree aka Derivation Tree parse tree aka derivation tree presents a derivation with more structure (tree), less repetition. + + This example generates / 12

6 mbiguous Grammar Two different trees generate the same + + : If this happens, the grammar is ambiguous. We try to design unambiguous grammars. (Bad news: CFG ambiguity is undecidable.) 6 / 12

7 Unambiguous Grammar xample n unambiguous grammar that generates the same language as our ambiguous grammar example: <expr > ::= <expr > "+" <mul > <mul > <mul > ::= <mul > "*" <atom > <atom > <atom > ::= "" "1" "(" <expr > ")" xercise: Find the parse trees for + + and. Observe that this grammar makes + and associate to the left. (Bad news: quivalence of two CFGs is also undecidable.) 7 / 12

8 Left Recursive vs Right Recursive <expr> ::= <expr> "+" <mul> That is a left recursive rule. The recursion is at the beginning (left). <expr> ::= <mul> "+" <expr> That is a right recursive rule. The recursion is at the end (right). They affect whether infix operators associate to the left or right. They also affect some parsing algorithms. 8 / 12

9 Recursive Descent Parsing Recursive descent parsing is a simple strategy for writing a parser. Write a procedure for each rule. Non-terminals on RHS become procedure calls, possibly recursive calls. (Thus recursive descent. lso top-down.) (Left recursion needs special treatment to avoid infinite loops.) Terminal symbols: Consume input and check. lternatives require lookahead and/or backtracking. Some options for handling left recursion: Re-design grammar to not have left recursion. any left recursions just express -or-more of something. So have a repeater function instead. 9 / 12

10 Recursive Descent Parser xample xample grammar suitable for recursive descent parsing: <sub > ::= <atom > "-" <sub > <atom > <atom > ::= "" "1" "(" <sub > ")" Pseudo-code of recursive descent parser: sub: try (atom; read; if not "-" then fail; sub;) if that failed: atom; atom: read; if "" or "1": return; if "(": sub; read; if not ")" then fail; else: fail; 1 / 12

11 bstract Syntax Tree (ST) Recall parse trees: Internal nodes are non-terminal symbols. Both operators and operands are terminal symbols at leaves. bstract syntax trees: Non-terminal symbols gone. Operators at internal nodes, operands at leaves. Operators and operands are no longer strings. Instead tree data structures (functional and imperative languages) or objects (the Composite design pattern in OO languages). 11 / 12

12 Parse Tree vs bstract Syntax Tree xample Parse tree: bstract syntax tree: ost parsers output abstract syntax trees directly. Parse trees are usually for our understanding. 12 / 12