Programming Languages and Compilers (CS 421)
|
|
|
- Margery Adams
- 5 years ago
- Views:
Transcription
1 Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 10/31/17 1
2 BNF Grammars n Start with a set of characters, a,b,c, n We call these terminals n Add a set of different characters, X,Y,Z, n We call these nonterminals n One special nonterminal S called start symbol 10/31/17 2
3 BNF Grammars n BNF rules (aka productions) have form X ::= y where X is any nonterminal and y is a string of terminals and nonterminals n BNF grammar is a set of BNF rules such that every nonterminal appears on the left of some rule 10/31/17 3
4 Sample Grammar n Terminals: ( ) n Nonterminals: <Sum> n Start symbol = <Sum> n <Sum> ::= 0 n <Sum >::= 1 n <Sum> ::= <Sum> + <Sum> n <Sum> ::= (<Sum>) n Can be abbreviated as <Sum> ::= 0 1 <Sum> + <Sum> ( ) 10/31/17 4
5 BNF Deriviations n Given rules X::= yzw and Z::=v we may replace Z by v to say X => yzw => yvw n Sequence of such replacements called derivation n Derivation called right-most if always replace the right-most non-terminal 10/31/17 5
6 BNF Semantics n The meaning of a BNF grammar is the set of all strings consisting only of terminals that can be derived from the Start symbol 10/31/17 6
7 BNF Derivations n Start with the start symbol: <Sum> => 10/31/17 7
8 BNF Derivations n Pick a non-terminal <Sum> => 10/31/17 8
9 BNF Derivations n Pick a rule and substitute: n <Sum> ::= <Sum> + <Sum> <Sum> => <Sum> + <Sum > 10/31/17 9
10 BNF Derivations n Pick a non-terminal: <Sum> => <Sum> + <Sum > 10/31/17 10
11 BNF Derivations n Pick a rule and substitute: n <Sum> ::= ( <Sum> ) <Sum> => <Sum> + <Sum > => ( <Sum> ) + <Sum> 10/31/17 11
12 BNF Derivations n Pick a non-terminal: <Sum> => <Sum> + <Sum > => ( <Sum> ) + <Sum> 10/31/17 12
13 BNF Derivations n Pick a rule and substitute: n <Sum> ::= <Sum> + <Sum> <Sum> => <Sum> + <Sum > => ( <Sum> ) + <Sum> => ( <Sum> + <Sum> ) + <Sum> 10/31/17 13
14 BNF Derivations n Pick a non-terminal: <Sum> => <Sum> + <Sum > => ( <Sum> ) + <Sum> => ( <Sum> + <Sum> ) + <Sum> 10/31/17 14
15 BNF Derivations n Pick a rule and substitute: n <Sum >::= 1 <Sum> => <Sum> + <Sum > => ( <Sum> ) + <Sum> => ( <Sum> + <Sum> ) + <Sum> => ( <Sum> + 1 ) + <Sum> 10/31/17 15
16 BNF Derivations n Pick a non-terminal: <Sum> => <Sum> + <Sum > => ( <Sum> ) + <Sum> => ( <Sum> + <Sum> ) + <Sum> => ( <Sum> + 1 ) + <Sum> 10/31/17 16
17 BNF Derivations n Pick a rule and substitute: n <Sum >::= 0 <Sum> => <Sum> + <Sum > => ( <Sum> ) + <Sum> => ( <Sum> + <Sum> ) + <Sum> => ( <Sum> + 1 ) + <Sum> => ( <Sum> + 1 ) /31/17 17
18 BNF Derivations n Pick a non-terminal: <Sum> => <Sum> + <Sum > => ( <Sum> ) + <Sum> => ( <Sum> + <Sum> ) + <Sum> => ( <Sum> + 1 ) + <Sum> => ( <Sum> + 1 ) /31/17 18
19 BNF Derivations n Pick a rule and substitute n <Sum> ::= 0 <Sum> => <Sum> + <Sum > => ( <Sum> ) + <Sum> => ( <Sum> + <Sum> ) + <Sum> => ( <Sum> + 1 ) + <Sum> => ( <Sum> + 1 ) 0 => ( ) /31/17 19
20 BNF Derivations n ( ) + 0 is generated by grammar <Sum> => <Sum> + <Sum > => ( <Sum> ) + <Sum> => ( <Sum> + <Sum> ) + <Sum> => ( <Sum> + 1 ) + <Sum> => ( <Sum> + 1 ) + 0 => ( ) /31/17 20
21 <Sum> ::= 0 1 <Sum> + <Sum> (<Sum>) <Sum> => 10/31/17 21
22 Regular Grammars n Subclass of BNF n Only rules of form <nonterminal>::=<terminal><nonterminal> or <nonterminal>::=<terminal> or <nonterminal>::=ε n Defines same class of languages as regular expressions n Important for writing lexers (programs that convert strings of characters into strings of tokens) 10/31/17 22
23 Example n Regular grammar: <Balanced> ::= ε <Balanced> ::= 0<OneAndMore> <Balanced> ::= 1<ZeroAndMore> <OneAndMore> ::= 1<Balanced> <ZeroAndMore> ::= 0<Balanced> n Generates even length strings where every initial substring of even length has same number of 0 s as 1 s 10/31/17 23
24 Extended BNF Grammars n Alternatives: allow rules of from X::=y z n Abbreviates X::= y, X::= z n Options: X::=y[v]z n Abbreviates X::=yvz, X::=yz n Repetition: X::=y{v}*z n Can be eliminated by adding new nonterminal V and rules X::=yz, X::=yVz, V::=v, V::=vV 10/31/17 24
25 Parse Trees n Graphical representation of derivation n Each node labeled with either non-terminal or terminal n If node is labeled with a terminal, then it is a leaf (no sub-trees) n If node is labeled with a non-terminal, then it has one branch for each character in the right-hand side of rule used to substitute for it 10/31/17 25
26 Example n Consider grammar: <exp> ::= <factor> <factor> + <factor> <factor> ::= <bin> <bin> * <exp> <bin> ::= 0 1 n Problem: Build parse tree for 1 * as an <exp> 10/31/17 26
27 Example cont. n 1 * 1 + 0: <exp> <exp> is the start symbol for this parse tree 10/31/17 27
28 Example cont. n 1 * 1 + 0: <exp> <factor> Use rule: <exp> ::= <factor> 10/31/17 28
29 Example cont. n 1 * 1 + 0: <exp> <factor> <bin> * <exp> Use rule: <factor> ::= <bin> * <exp> 10/31/17 29
30 Example cont. n 1 * 1 + 0: <exp> <factor> <bin> * <exp> 1 <factor> + <factor> Use rules: <bin> ::= 1 and <exp> ::= <factor> + <factor> 10/31/17 30
31 Example cont. n 1 * 1 + 0: <exp> <factor> <bin> * <exp> 1 <factor> + <factor> <bin> <bin> Use rule: <factor> ::= <bin> 10/31/17 31
32 Example cont. n 1 * 1 + 0: <exp> <factor> <bin> * <exp> 1 <factor> + <factor> <bin> <bin> Use rules: <bin> ::= /31/17 32
33 Example cont. n 1 * 1 + 0: <exp> <factor> <bin> * <exp> 1 <factor> + <factor> <bin> <bin> 1 0 Fringe of tree is string generated by grammar 10/31/17 33
34 Your Turn: 1 * * 1 10/31/17 34
35 Parse Tree Data Structures n Parse trees may be represented by OCaml datatypes n One datatype for each nonterminal n One constructor for each rule n Defined as mutually recursive collection of datatype declarations 10/31/17 35
36 Example n Recall grammar: <exp> ::= <factor> <factor> + <factor> <factor> ::= <bin> <bin> * <exp> <bin> ::= 0 1 n type exp = Factor2Exp of factor Plus of factor * factor and factor = Bin2Factor of bin Mult of bin * exp and bin = Zero One 10/31/17 36
37 Example cont. n 1 * 1 + 0: <exp> <factor> <bin> * <exp> 1 <factor> + <factor> <bin> <bin> /31/17 37
38 Example cont. n Can be represented as Factor2Exp (Mult(One, Plus(Bin2Factor One, Bin2Factor Zero))) 10/31/17 38
39 Ambiguous Grammars and Languages n A BNF grammar is ambiguous if its language contains strings for which there is more than one parse tree n If all BNF s for a language are ambiguous then the language is inherently ambiguous 10/31/17 39
40 Example: Ambiguous Grammar n <Sum> <Sum> <Sum> + <Sum> <Sum> + <Sum> <Sum> + <Sum> 0 0 <Sum> + <Sum> /31/17 40
41 Example n What is the result for: * /31/17 41
42 Example n What is the result for: * n Possible answers: n 41 = ((3 + 4) * 5) + 6 n 47 = 3 + (4 * (5 + 6)) n 29 = (3 + (4 * 5)) + 6 = 3 + ((4 * 5) + 6) n 77 = (3 + 4) * (5 + 6) 10/31/17 42
43 Example n What is the value of: /31/17 43
44 Example n What is the value of: n n n Possible answers: In Pascal, C++, SML assoc. left = (7 5) 2 = 0 In APL, associate to right = 7 (5 2) = 4 10/31/17 44
45 Two Major Sources of Ambiguity n Lack of determination of operator precedence n Lack of determination of operator assoicativity n Not the only sources of ambiguity 10/31/17 45
46 Disambiguating a Grammar n Given ambiguous grammar G, with start symbol S, find a grammar G with same start symbol, such that language of G = language of G n Not always possible n No algorithm in general 10/31/17 46
47 Disambiguating a Grammar n Idea: Each non-terminal represents all strings having some property n Identify these properties (often in terms of things that can t happen) n Use these properties to inductively guarantee every string in language has a unique parse 10/31/17 47
48 Steps to Grammar Disambiguation n n n n n n Identify the rules and a smallest use that display ambiguity Decide which parse to keep; why should others be thrown out? What syntactic restrictions on subexpressions are needed to throw out the bad (while keeping the good)? Add a new non-terminal and rules to describe this set of restricted subexpressions (called stratifying, or refactoring) Replace old rules to use new non-terminals Rinse and repeat 10/31/17 48
49 Example n Ambiguous grammar: <exp> ::= 0 1 <exp> + <exp> <exp> * <exp> n String with more then one parse: * n Sourceof ambiuity: associativity and precedence 10/31/17 49
50 Two Major Sources of Ambiguity n Lack of determination of operator precedence n Lack of determination of operator assoicativity n Not the only sources of ambiguity 10/4/07 50
51 How to Enforce Associativity n Have at most one recursive call per production n When two or more recursive calls would be natural leave right-most one for right assoicativity, left-most one for left assoiciativity 10/4/07 51
52 Example n <Sum> ::= 0 1 <Sum> + <Sum> (<Sum>) n Becomes n <Sum> ::= <Num> <Num> + <Sum> n <Num> ::= 0 1 (<Sum>) 10/4/07 52
53 Operator Precedence n Operators of highest precedence evaluated first (bind more tightly). n Precedence for infix binary operators given in following table n Needs to be reflected in grammar 10/4/07 53
54 Precedence Table - Sample Fortan Pascal C/C++ Ada SML highest ** *, /, div, mod *, / +, - *, /, % ++, -- ** div, mod, /, * *, /, mod +, -, ^ +, - +, - +, - :: 10/4/07 54
55 First Example Again n In any above language, * = 29 n In APL, all infix operators have same precedence n Thus we still don t know what the value is (handled by associativity) n How do we handle precedence in grammar? 10/4/07 55
56 Predence in Grammar n Higher precedence translates to longer derivation chain n Example: <exp> ::= 0 1 <exp> + <exp> <exp> * <exp> n Becomes <exp> ::= <mult_exp> <exp> + <mult_exp> <mult_exp> ::= <id> <mult_exp> * <id> <id> ::= /4/07 56
57 Parser Code n <grammar>.ml defines one parsing function per entry point n Parsing function takes a lexing function (lexer buffer to token) and a lexer buffer as arguments n Returns semantic attribute of corresponding entry point 10/31/17 57
58 Ocamlyacc Input n File format: %{ <header> %} <declarations> %% <rules> %% <trailer> 10/31/17 58
59 Ocamlyacc <header> n Contains arbitrary Ocaml code n Typically used to give types and functions needed for the semantic actions of rules and to give specialized error recovery n May be omitted n <footer> similar. Possibly used to call parser 10/31/17 59
60 Ocamlyacc <declarations> n %token symbol symbol n Declare given symbols as tokens n %token <type> symbol symbol n Declare given symbols as token constructors, taking an argument of type <type> n %start symbol symbol n Declare given symbols as entry points; functions of same names in <grammar>.ml 10/31/17 60
61 Ocamlyacc <declarations> n %type <type> symbol symbol Specify type of attributes for given symbols. Mandatory for start symbols n %left symbol symbol n %right symbol symbol n %nonassoc symbol symbol Associate precedence and associativity to given symbols. Same line,same precedence; earlier line, lower precedence (broadest scope) 10/31/17 61
62 Ocamlyacc <rules> n nonterminal : symbol... symbol { semantic_action }... symbol... symbol { semantic_action } ; n Semantic actions are arbitrary Ocaml expressions n Must be of same type as declared (or inferred) for nonterminal n Access semantic attributes (values) of symbols by position: $1 for first symbol, $2 to second 10/31/17 62
63 Example - Base types (* File: expr.ml *) type expr = Term_as_Expr of term Plus_Expr of (term * expr) Minus_Expr of (term * expr) and term = Factor_as_Term of factor Mult_Term of (factor * term) Div_Term of (factor * term) and factor = Id_as_Factor of string Parenthesized_Expr_as_Factor of expr 10/31/17 63
64 Example - Lexer (exprlex.mll) { (*open Exprparse*) } let numeric = ['0' - '9'] let letter =['a' - 'z' 'A' - 'Z'] rule token = parse "+" {Plus_token} "-" {Minus_token} "*" {Times_token} "/" {Divide_token} "(" {Left_parenthesis} ")" {Right_parenthesis} letter (letter numeric "_")* as id {Id_token id} [' ' '\t' '\n'] {token lexbuf} eof {EOL} 10/31/17 64
65 Example - Parser (exprparse.mly) %{ open Expr %} %token <string> Id_token %token Left_parenthesis Right_parenthesis %token Times_token Divide_token %token Plus_token Minus_token %token EOL %start main %type <expr> main %% 10/31/17 65
66 Example - Parser (exprparse.mly) expr: term { Term_as_Expr $1 } term Plus_token expr { Plus_Expr ($1, $3) } term Minus_token expr { Minus_Expr ($1, $3) } 10/31/17 66
67 Example - Parser (exprparse.mly) term: factor { Factor_as_Term $1 } factor Times_token term { Mult_Term ($1, $3) } factor Divide_token term { Div_Term ($1, $3) } 10/31/17 67
68 Example - Parser (exprparse.mly) factor: Id_token { Id_as_Factor $1 } Left_parenthesis expr Right_parenthesis {Parenthesized_Expr_as_Factor $2 } main: expr EOL { $1 } 10/31/17 68
69 Example - Using Parser # #use "expr.ml";; # #use "exprparse.ml";; # #use "exprlex.ml";; # let test s = let lexbuf = Lexing.from_string (s^"\n") in main token lexbuf;; 10/31/17 69
70 Example - Using Parser # test "a + b";; - : expr = Plus_Expr (Factor_as_Term (Id_as_Factor "a"), Term_as_Expr (Factor_as_Term (Id_as_Factor "b"))) 10/31/17 70
71 LR Parsing n Read tokens left to right (L) n Create a rightmost derivation (R) n How is this possible? n Start at the bottom (left) and work your way up n Last step has only one non-terminal to be replaced so is right-most n Working backwards, replace mixed strings by non-terminals n Always proceed so that there are no nonterminals to the right of the string to be replaced 10/31/17 71
72 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => = ( ) + 0 shift 10/31/17 72
73 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => = ( ) + 0 shift = ( ) + 0 shift 10/31/17 73
74 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 74
75 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => = ( <Sum> + 1 ) + 0 shift => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 75
76 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => = ( <Sum> + 1 ) + 0 shift = ( <Sum> + 1 ) + 0 shift => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 76
77 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => => ( <Sum> + 1 ) + 0 reduce = ( <Sum> + 1 ) + 0 shift = ( <Sum> + 1 ) + 0 shift => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 77
78 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => => ( <Sum> + <Sum> ) + 0 reduce => ( <Sum> + 1 ) + 0 reduce = ( <Sum> + 1 ) + 0 shift = ( <Sum> + 1 ) + 0 shift => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 78
79 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => = ( <Sum> ) + 0 shift => ( <Sum> + <Sum> ) + 0 reduce => ( <Sum> + 1 ) + 0 reduce = ( <Sum> + 1 ) + 0 shift = ( <Sum> + 1 ) + 0 shift => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 79
80 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => => ( <Sum> ) + 0 reduce = ( <Sum> ) + 0 shift => ( <Sum> + <Sum> ) + 0 reduce => ( <Sum> + 1 ) + 0 reduce = ( <Sum> + 1 ) + 0 shift = ( <Sum> + 1 ) + 0 shift => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 80
81 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => = <Sum> + 0 shift => ( <Sum> ) + 0 reduce = ( <Sum> ) + 0 shift => ( <Sum> + <Sum> ) + 0 reduce => ( <Sum> + 1 ) + 0 reduce = ( <Sum> + 1 ) + 0 shift = ( <Sum> + 1 ) + 0 shift => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 81
82 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => = <Sum> + 0 shift = <Sum> + 0 shift => ( <Sum> ) + 0 reduce = ( <Sum> ) + 0 shift => ( <Sum> + <Sum> ) + 0 reduce => ( <Sum> + 1 ) + 0 reduce = ( <Sum> + 1 ) + 0 shift = ( <Sum> + 1 ) + 0 shift => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 82
83 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => => <Sum> + 0 reduce = <Sum> + 0 shift = <Sum> + 0 shift => ( <Sum> ) + 0 reduce = ( <Sum> ) + 0 shift => ( <Sum> + <Sum> ) + 0 reduce => ( <Sum> + 1 ) + 0 reduce = ( <Sum> + 1 ) + 0 shift = ( <Sum> + 1 ) + 0 shift => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 83
84 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => <Sum> + <Sum > reduce => <Sum> + 0 reduce = <Sum> + 0 shift = <Sum> + 0 shift => ( <Sum> ) + 0 reduce = ( <Sum> ) + 0 shift => ( <Sum> + <Sum> ) + 0 reduce => ( <Sum> + 1 ) + 0 reduce = ( <Sum> + 1 ) + 0 shift = ( <Sum> + 1 ) + 0 shift => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 84
85 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> <Sum> => <Sum> + <Sum > reduce => <Sum> + 0 reduce = <Sum> + 0 shift = <Sum> + 0 shift => ( <Sum> ) + 0 reduce = ( <Sum> ) + 0 shift => ( <Sum> + <Sum> ) + 0 reduce => ( <Sum> + 1 ) + 0 reduce = ( <Sum> + 1 ) + 0 shift = ( <Sum> + 1 ) + 0 shift => ( ) + 0 reduce = ( ) + 0 shift = ( ) + 0 shift 10/31/17 85
86 Example ( ) /31/17 86
87 Example ( ) /31/17 87
88 Example ( ) /31/17 88
89 Example <Sum> ( ) /31/17 89
90 Example <Sum> ( ) /31/17 90
91 Example <Sum> ( ) /31/17 91
92 Example <Sum> <Sum> ( ) /31/17 92
93 Example <Sum> <Sum> <Sum> ( ) /31/17 93
94 Example <Sum> <Sum> <Sum> ( ) /31/17 94
95 Example <Sum> <Sum> <Sum> <Sum> ( ) /31/17 95
96 Example <Sum> <Sum> <Sum> <Sum> ( ) /31/17 96
97 Example <Sum> <Sum> <Sum> <Sum> ( ) /31/17 97
98 Example <Sum> <Sum> <Sum> <Sum> <Sum> ( ) /31/17 98
99 Example <Sum> <Sum> <Sum> <Sum> <Sum> <Sum> ( ) /31/17 99
100 Example <Sum> <Sum> <Sum> <Sum> <Sum> <Sum> ( ) /31/17 100
101 LR Parsing Tables n Build a pair of tables, Action and Goto, from the grammar n This is the hardest part, we omit here n Rows labeled by states n For Action, columns labeled by terminals and end-of-tokens marker n (more generally strings of terminals of fixed length) n For Goto, columns labeled by nonterminals 10/31/17 101
102 Action and Goto Tables n Given a state and the next input, Action table says either n shift and go to state n, or n reduce by production k (explained in a bit) n accept or error n Given a state and a non-terminal, Goto table says n go to state m 10/31/17 102
103 LR(i) Parsing Algorithm n Based on push-down automata n Uses states and transitions (as recorded in Action and Goto tables) n Uses a stack containing states, terminals and non-terminals 10/31/17 103
104 LR(i) Parsing Algorithm 0. Insure token stream ends in special endof-tokens symbol 1. Start in state 1 with an empty stack 2. Push state(1) onto stack 3. Look at next i tokens from token stream (toks) (don t remove yet) 4. If top symbol on stack is state(n), look up action in Action table at (n, toks) 10/31/17 104
105 LR(i) Parsing Algorithm 5. If action = shift m, a) Remove the top token from token stream and push it onto the stack b) Push state(m) onto stack c) Go to step 3 10/31/17 105
106 LR(i) Parsing Algorithm 6. If action = reduce k where production k is E ::= u a) Remove 2 * length(u) symbols from stack (u and all the interleaved states) b) If new top symbol on stack is state(m), look up new state p in Goto(m,E) c) Push E onto the stack, then push state(p) onto the stack d) Go to step 3 10/31/17 106
107 LR(i) Parsing Algorithm 7. If action = accept n Stop parsing, return success 8. If action = error, n Stop parsing, return failure 10/31/17 107
108 Adding Synthesized Attributes n Add to each reduce a rule for calculating the new synthesized attribute from the component attributes n Add to each non-terminal pushed onto the stack, the attribute calculated for it n When performing a reduce, n gather the recorded attributes from each nonterminal popped from stack n Compute new attribute for non-terminal pushed onto stack 10/31/17 108
109 Shift-Reduce Conflicts n Problem: can t decide whether the action for a state and input character should be shift or reduce n Caused by ambiguity in grammar n Usually caused by lack of associativity or precedence information in grammar 10/31/17 109
110 Example: <Sum> = 0 1 (<Sum>) <Sum> + <Sum> shift -> reduce -> <Sum> shift -> <Sum> shift -> <Sum> reduce -> <Sum> + <Sum> /31/17 110
111 Example - cont n Problem: shift or reduce? n You can shift-shift-reduce-reduce or reduce-shift-shift-reduce n Shift first - right associative n Reduce first- left associative 10/31/17 111
112 Reduce - Reduce Conflicts n Problem: can t decide between two different rules to reduce by n Again caused by ambiguity in grammar n Symptom: RHS of one production suffix of another n Requires examining grammar and rewriting it n Harder to solve than shift-reduce errors 10/31/17 112
113 Example n S ::= A ab A ::= abc B ::= bc abc a bc ab c abc shift shift shift n Problem: reduce by B ::= bc then by S ::= ab, or by A::= abc then S::A? 10/31/17 113
Programming Languages and Compilers (CS 421)
Programming Languages and Compilers (CS 421) Sasa Misailovic 4110 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421a Based in part on slides by Mattox Beckman, as updated by Vikram Adve, Gul
n Parsing function takes a lexing function n Returns semantic attribute of 10/27/16 2 n Contains arbitrary Ocaml code n May be omitted 10/27/16 4
Parser Code Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul
Example. Programming Languages and Compilers (CS 421) Disambiguating a Grammar. Disambiguating a Grammar. Steps to Grammar Disambiguation
Programming Languages and Compilers (CS 421) Sasa Misailovic 4110 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421a Based in part on slides by Mattox Beckman, as updated by Vikram Adve, Gul
n <exp>::= 0 1 b<exp> <exp>a n <exp>m<exp> 11/7/ /7/17 4 n Read tokens left to right (L) n Create a rightmost derivation (R)
Disambiguating a Grammar Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram
Programming Languages and Compilers (CS 421)
Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 11/9/17
Programming Languages and Compilers (CS 421)
Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 10/20/16
n (0 1)*1 n a*b(a*) n ((01) (10))* n You tell me n Regular expressions (equivalently, regular 10/20/ /20/16 4
Regular Expressions Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve
Programming Languages and Compilers (CS 421)
Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 10/30/17
Programming Languages & Compilers. Programming Languages and Compilers (CS 421) I. Major Phases of a Compiler. Programming Languages & Compilers
Programming Languages & Compilers Programming Languages and Compilers (CS 421) I Three Main Topics of the Course II III Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 New Programming
Programming Languages & Compilers. Programming Languages and Compilers (CS 421) Programming Languages & Compilers. Major Phases of a Compiler
Programming Languages & Compilers Programming Languages and Compilers (CS 421) Three Main Topics of the Course I II III Sasa Misailovic 4110 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421a
MP 5 A Parser for PicoML
MP 5 A Parser for PicoML CS 421 Fall 2017 Revision 1.0 Assigned Friday, November 3, 2017 Due Wednesday, November 8, 2017 Friday, November 10, 2017 Extension None past the allowed lab sign-up time 1 Change
Context-Free Grammar. Concepts Introduced in Chapter 2. Parse Trees. Example Grammar and Derivation
Concepts Introduced in Chapter 2 A more detailed overview of the compilation process. Parsing Scanning Semantic Analysis Syntax-Directed Translation Intermediate Code Generation Context-Free Grammar A
Two Problems. Programming Languages and Compilers (CS 421) Type Inference - Example. Type Inference - Outline. Type Inference - Example
Two Problems Programming Languages and Compilers (CS 421) Sasa Misailovic 4110 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421a Based in part on slides by Mattox Beckman, as updated by Vikram
JavaCC Parser. The Compilation Task. Automated? JavaCC Parser
JavaCC Parser The Compilation Task Input character stream Lexer stream Parser Abstract Syntax Tree Analyser Annotated AST Code Generator Code CC&P 2003 1 CC&P 2003 2 Automated? JavaCC Parser The initial
CS 11 Ocaml track: lecture 6
CS 11 Ocaml track: lecture 6 n Today: n Writing a computer language n Parser generators n lexers (ocamllex) n parsers (ocamlyacc) n Abstract syntax trees Problem (1) n We want to implement a computer language
Bottom-Up Parsing. Lecture 11-12
Bottom-Up Parsing Lecture 11-12 (From slides by G. Necula & R. Bodik) 9/22/06 Prof. Hilfinger CS164 Lecture 11 1 Bottom-Up Parsing Bottom-up parsing is more general than topdown parsing And just as efficient
A Simple Syntax-Directed Translator
Chapter 2 A Simple Syntax-Directed Translator 1-1 Introduction The analysis phase of a compiler breaks up a source program into constituent pieces and produces an internal representation for it, called
CS 4120 Introduction to Compilers
CS 4120 Introduction to Compilers Andrew Myers Cornell University Lecture 6: Bottom-Up Parsing 9/9/09 Bottom-up parsing A more powerful parsing technology LR grammars -- more expressive than LL can handle
CS453 : JavaCUP and error recovery. CS453 Shift-reduce Parsing 1
CS453 : JavaCUP and error recovery CS453 Shift-reduce Parsing 1 Shift-reduce parsing in an LR parser LR(k) parser Left-to-right parse Right-most derivation K-token look ahead LR parsing algorithm using
Chapter 3: Describing Syntax and Semantics. Introduction Formal methods of describing syntax (BNF)
Chapter 3: Describing Syntax and Semantics Introduction Formal methods of describing syntax (BNF) We can analyze syntax of a computer program on two levels: 1. Lexical level 2. Syntactic level Lexical
CSCI312 Principles of Programming Languages
Copyright 2006 The McGraw-Hill Companies, Inc. CSCI312 Principles of Programming Languages! LL Parsing!! Xu Liu Derived from Keith Cooper s COMP 412 at Rice University Recap Copyright 2006 The McGraw-Hill
Bottom-Up Parsing. Lecture 11-12
Bottom-Up Parsing Lecture 11-12 (From slides by G. Necula & R. Bodik) 2/20/08 Prof. Hilfinger CS164 Lecture 11 1 Administrivia Test I during class on 10 March. 2/20/08 Prof. Hilfinger CS164 Lecture 11
Where We Are. CMSC 330: Organization of Programming Languages. This Lecture. Programming Languages. Motivation for Grammars
CMSC 330: Organization of Programming Languages Context Free Grammars Where We Are Programming languages Ruby OCaml Implementing programming languages Scanner Uses regular expressions Finite automata Parser
ECE251 Midterm practice questions, Fall 2010
ECE251 Midterm practice questions, Fall 2010 Patrick Lam October 20, 2010 Bootstrapping In particular, say you have a compiler from C to Pascal which runs on x86, and you want to write a self-hosting Java
LR Parsing LALR Parser Generators
LR Parsing LALR Parser Generators Outline Review of bottom-up parsing Computing the parsing DFA Using parser generators 2 Bottom-up Parsing (Review) A bottom-up parser rewrites the input string to the
Compilation 2013 Parser Generators, Conflict Management, and ML-Yacc
Compilation 2013 Parser Generators, Conflict Management, and ML-Yacc Erik Ernst Aarhus University Parser generators, ML-Yacc LR parsers are tedious to write, but can be generated, e.g., by ML-Yacc Input:
Topic 3: Syntax Analysis I
Topic 3: Syntax Analysis I Compiler Design Prof. Hanjun Kim CoreLab (Compiler Research Lab) POSTECH 1 Back-End Front-End The Front End Source Program Lexical Analysis Syntax Analysis Semantic Analysis
Review main idea syntax-directed evaluation and translation. Recall syntax-directed interpretation in recursive descent parsers
Plan for Today Review main idea syntax-directed evaluation and translation Recall syntax-directed interpretation in recursive descent parsers Syntax-directed evaluation and translation in shift-reduce
Context-free grammars
Context-free grammars Section 4.2 Formal way of specifying rules about the structure/syntax of a program terminals - tokens non-terminals - represent higher-level structures of a program start symbol,
LR Parsing LALR Parser Generators
Outline LR Parsing LALR Parser Generators Review of bottom-up parsing Computing the parsing DFA Using parser generators 2 Bottom-up Parsing (Review) A bottom-up parser rewrites the input string to the
In One Slide. Outline. LR Parsing. Table Construction
LR Parsing Table Construction #1 In One Slide An LR(1) parsing table can be constructed automatically from a CFG. An LR(1) item is a pair made up of a production and a lookahead token; it represents a
Introduction to Bottom-Up Parsing
Introduction to Bottom-Up Parsing Lecture 11 CS 536 Spring 2001 1 Outline he strategy: shift-reduce parsing Ambiguity and precedence declarations Next lecture: bottom-up parsing algorithms CS 536 Spring
Compiler Construction: Parsing
Compiler Construction: Parsing Mandar Mitra Indian Statistical Institute M. Mitra (ISI) Parsing 1 / 33 Context-free grammars. Reference: Section 4.2 Formal way of specifying rules about the structure/syntax
COMP-421 Compiler Design. Presented by Dr Ioanna Dionysiou
COMP-421 Compiler Design Presented by Dr Ioanna Dionysiou Administrative! Any questions about the syllabus?! Course Material available at www.cs.unic.ac.cy/ioanna! Next time reading assignment [ALSU07]
Lecture Notes on Bottom-Up LR Parsing
Lecture Notes on Bottom-Up LR Parsing 15-411: Compiler Design Frank Pfenning Lecture 9 1 Introduction In this lecture we discuss a second parsing algorithm that traverses the input string from left to
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Context Free Grammars 1 Architecture of Compilers, Interpreters Source Analyzer Optimizer Code Generator Abstract Syntax Tree Front End Back End Compiler
COP 3402 Systems Software Syntax Analysis (Parser)
COP 3402 Systems Software Syntax Analysis (Parser) Syntax Analysis 1 Outline 1. Definition of Parsing 2. Context Free Grammars 3. Ambiguous/Unambiguous Grammars Syntax Analysis 2 Lexical and Syntax Analysis
Programming Language Syntax and Analysis
Programming Language Syntax and Analysis 2017 Kwangman Ko (http://compiler.sangji.ac.kr, kkman@sangji.ac.kr) Dept. of Computer Engineering, Sangji University Introduction Syntax the form or structure of
Outline CS412/413. Administrivia. Review. Grammars. Left vs. Right Recursion. More tips forll(1) grammars Bottom-up parsing LR(0) parser construction
C12/1 Introduction to Compilers and Translators pring 00 Outline More tips forll1) grammars Bottom-up parsing LR0) parser construction Lecture 5: Bottom-up parsing Lecture 5 C 12/1 pring '00 Andrew Myers
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Context Free Grammars and Parsing 1 Recall: Architecture of Compilers, Interpreters Source Parser Static Analyzer Intermediate Representation Front End Back
LECTURE 3. Compiler Phases
LECTURE 3 Compiler Phases COMPILER PHASES Compilation of a program proceeds through a fixed series of phases. Each phase uses an (intermediate) form of the program produced by an earlier phase. Subsequent
EDAN65: Compilers, Lecture 06 A LR parsing. Görel Hedin Revised:
EDAN65: Compilers, Lecture 06 A LR parsing Görel Hedin Revised: 2017-09-11 This lecture Regular expressions Context-free grammar Attribute grammar Lexical analyzer (scanner) Syntactic analyzer (parser)
Syntax Analysis Check syntax and construct abstract syntax tree
Syntax Analysis Check syntax and construct abstract syntax tree if == = ; b 0 a b Error reporting and recovery Model using context free grammars Recognize using Push down automata/table Driven Parsers
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Context Free Grammars 1 Architecture of Compilers, Interpreters Source Analyzer Optimizer Code Generator Abstract Syntax Tree Front End Back End Compiler
CMSC 330: Organization of Programming Languages. Architecture of Compilers, Interpreters
: Organization of Programming Languages Context Free Grammars 1 Architecture of Compilers, Interpreters Source Scanner Parser Static Analyzer Intermediate Representation Front End Back End Compiler / Interpreter
CMSC 330: Organization of Programming Languages. Context Free Grammars
CMSC 330: Organization of Programming Languages Context Free Grammars 1 Architecture of Compilers, Interpreters Source Analyzer Optimizer Code Generator Abstract Syntax Tree Front End Back End Compiler
Outline. The strategy: shift-reduce parsing. Introduction to Bottom-Up Parsing. A key concept: handles
Outline Introduction to Bottom-Up Parsing Lecture Notes by Profs. Alex Aiken and George Necula (UCB) he strategy: -reduce parsing A key concept: handles Ambiguity and precedence declarations CS780(Prasad)
COP4020 Programming Languages. Syntax Prof. Robert van Engelen
COP4020 Programming Languages Syntax Prof. Robert van Engelen Overview n Tokens and regular expressions n Syntax and context-free grammars n Grammar derivations n More about parse trees n Top-down and
Parsing II Top-down parsing. Comp 412
COMP 412 FALL 2018 Parsing II Top-down parsing Comp 412 source code IR Front End Optimizer Back End IR target code Copyright 2018, Keith D. Cooper & Linda Torczon, all rights reserved. Students enrolled
CMSC 330: Organization of Programming Languages. Context Free Grammars
CMSC 330: Organization of Programming Languages Context Free Grammars 1 Architecture of Compilers, Interpreters Source Analyzer Optimizer Code Generator Abstract Syntax Tree Front End Back End Compiler
COP4020 Programming Languages. Syntax Prof. Robert van Engelen
COP4020 Programming Languages Syntax Prof. Robert van Engelen Overview Tokens and regular expressions Syntax and context-free grammars Grammar derivations More about parse trees Top-down and bottom-up
2068 (I) Attempt all questions.
2068 (I) 1. What do you mean by compiler? How source program analyzed? Explain in brief. 2. Discuss the role of symbol table in compiler design. 3. Convert the regular expression 0 + (1 + 0)* 00 first
Lecture Notes on Bottom-Up LR Parsing
Lecture Notes on Bottom-Up LR Parsing 15-411: Compiler Design Frank Pfenning Lecture 9 September 23, 2009 1 Introduction In this lecture we discuss a second parsing algorithm that traverses the input string
CS 314 Principles of Programming Languages
CS 314 Principles of Programming Languages Lecture 5: Syntax Analysis (Parsing) Zheng (Eddy) Zhang Rutgers University January 31, 2018 Class Information Homework 1 is being graded now. The sample solution
PART 3 - SYNTAX ANALYSIS. F. Wotawa TU Graz) Compiler Construction Summer term / 309
PART 3 - SYNTAX ANALYSIS F. Wotawa (IST @ TU Graz) Compiler Construction Summer term 2016 64 / 309 Goals Definition of the syntax of a programming language using context free grammars Methods for parsing
Architecture of Compilers, Interpreters. CMSC 330: Organization of Programming Languages. Front End Scanner and Parser. Implementing the Front End
Architecture of Compilers, Interpreters : Organization of Programming Languages ource Analyzer Optimizer Code Generator Context Free Grammars Intermediate Representation Front End Back End Compiler / Interpreter
Compilers. Bottom-up Parsing. (original slides by Sam
Compilers Bottom-up Parsing Yannis Smaragdakis U Athens Yannis Smaragdakis, U. Athens (original slides by Sam Guyer@Tufts) Bottom-Up Parsing More general than top-down parsing And just as efficient Builds
CSE P 501 Exam 11/17/05 Sample Solution
1. (8 points) Write a regular expression or set of regular expressions that generate the following sets of strings. You can use abbreviations (i.e., name = regular expression) if it helps to make your
Introduction to Lexing and Parsing
Introduction to Lexing and Parsing ECE 351: Compilers Jon Eyolfson University of Waterloo June 18, 2012 1 Riddle Me This, Riddle Me That What is a compiler? 1 Riddle Me This, Riddle Me That What is a compiler?
CS415 Compilers. Syntax Analysis. These slides are based on slides copyrighted by Keith Cooper, Ken Kennedy & Linda Torczon at Rice University
CS415 Compilers Syntax Analysis These slides are based on slides copyrighted by Keith Cooper, Ken Kennedy & Linda Torczon at Rice University Limits of Regular Languages Advantages of Regular Expressions
Introduction to Parsing. Lecture 5
Introduction to Parsing Lecture 5 1 Outline Regular languages revisited Parser overview Context-free grammars (CFG s) Derivations Ambiguity 2 Languages and Automata Formal languages are very important
Compiler Design Concepts. Syntax Analysis
Compiler Design Concepts Syntax Analysis Introduction First task is to break up the text into meaningful words called tokens. newval=oldval+12 id = id + num Token Stream Lexical Analysis Source Code (High
CSE 401 Midterm Exam Sample Solution 2/11/15
Question 1. (10 points) Regular expression warmup. For regular expression questions, you must restrict yourself to the basic regular expression operations covered in class and on homework assignments:
Lexical and Syntax Analysis (2)
Lexical and Syntax Analysis (2) In Text: Chapter 4 N. Meng, F. Poursardar Motivating Example Consider the grammar S -> cad A -> ab a Input string: w = cad How to build a parse tree top-down? 2 Recursive-Descent
MIT Specifying Languages with Regular Expressions and Context-Free Grammars
MIT 6.035 Specifying Languages with Regular essions and Context-Free Grammars Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology Language Definition Problem How to precisely
CSCE 314 Programming Languages
CSCE 314 Programming Languages Syntactic Analysis Dr. Hyunyoung Lee 1 What Is a Programming Language? Language = syntax + semantics The syntax of a language is concerned with the form of a program: how
S Y N T A X A N A L Y S I S LR
LR parsing There are three commonly used algorithms to build tables for an LR parser: 1. SLR(1) = LR(0) plus use of FOLLOW set to select between actions smallest class of grammars smallest tables (number
Lecture 7: Deterministic Bottom-Up Parsing
Lecture 7: Deterministic Bottom-Up Parsing (From slides by G. Necula & R. Bodik) Last modified: Tue Sep 20 12:50:42 2011 CS164: Lecture #7 1 Avoiding nondeterministic choice: LR We ve been looking at general
Parsing. Note by Baris Aktemur: Our slides are adapted from Cooper and Torczon s slides that they prepared for COMP 412 at Rice.
Parsing Note by Baris Aktemur: Our slides are adapted from Cooper and Torczon s slides that they prepared for COMP 412 at Rice. Copyright 2010, Keith D. Cooper & Linda Torczon, all rights reserved. Students
Building Compilers with Phoenix
Building Compilers with Phoenix Syntax-Directed Translation Structure of a Compiler Character Stream Intermediate Representation Lexical Analyzer Machine-Independent Optimizer token stream Intermediate
Context-Free Languages & Grammars (CFLs & CFGs) Reading: Chapter 5
Context-Free Languages & Grammars (CFLs & CFGs) Reading: Chapter 5 1 Not all languages are regular So what happens to the languages which are not regular? Can we still come up with a language recognizer?
G53CMP: Lecture 4. Syntactic Analysis: Parser Generators. Henrik Nilsson. University of Nottingham, UK. G53CMP: Lecture 4 p.1/32
G53CMP: Lecture 4 Syntactic Analysis: Parser Generators Henrik Nilsson University of Nottingham, UK G53CMP: Lecture 4 p.1/32 This Lecture Parser generators ( compiler compilers ) The parser generator Happy
Parsing. Roadmap. > Context-free grammars > Derivations and precedence > Top-down parsing > Left-recursion > Look-ahead > Table-driven parsing
Roadmap > Context-free grammars > Derivations and precedence > Top-down parsing > Left-recursion > Look-ahead > Table-driven parsing The role of the parser > performs context-free syntax analysis > guides
Compiler Construction 2016/2017 Syntax Analysis
Compiler Construction 2016/2017 Syntax Analysis Peter Thiemann November 2, 2016 Outline 1 Syntax Analysis Recursive top-down parsing Nonrecursive top-down parsing Bottom-up parsing Syntax Analysis tokens
Review of CFGs and Parsing II Bottom-up Parsers. Lecture 5. Review slides 1
Review of CFGs and Parsing II Bottom-up Parsers Lecture 5 1 Outline Parser Overview op-down Parsers (Covered largely through labs) Bottom-up Parsers 2 he Functionality of the Parser Input: sequence of
LL(k) Parsing. Predictive Parsers. LL(k) Parser Structure. Sample Parse Table. LL(1) Parsing Algorithm. Push RHS in Reverse Order 10/17/2012
Predictive Parsers LL(k) Parsing Can we avoid backtracking? es, if for a given input symbol and given nonterminal, we can choose the alternative appropriately. his is possible if the first terminal of
Syntactic Analysis. Top-Down Parsing
Syntactic Analysis Top-Down Parsing Copyright 2017, Pedro C. Diniz, all rights reserved. Students enrolled in Compilers class at University of Southern California (USC) have explicit permission to make
A programming language requires two major definitions A simple one pass compiler
A programming language requires two major definitions A simple one pass compiler [Syntax: what the language looks like A context-free grammar written in BNF (Backus-Naur Form) usually suffices. [Semantics:
Parsing III. CS434 Lecture 8 Spring 2005 Department of Computer Science University of Alabama Joel Jones
Parsing III (Top-down parsing: recursive descent & LL(1) ) (Bottom-up parsing) CS434 Lecture 8 Spring 2005 Department of Computer Science University of Alabama Joel Jones Copyright 2003, Keith D. Cooper,
CPS 506 Comparative Programming Languages. Syntax Specification
CPS 506 Comparative Programming Languages Syntax Specification Compiling Process Steps Program Lexical Analysis Convert characters into a stream of tokens Lexical Analysis Syntactic Analysis Send tokens
Compilation 2012 Context-Free Languages Parsers and Scanners. Jan Midtgaard Michael I. Schwartzbach Aarhus University
Compilation 2012 Parsers and Scanners Jan Midtgaard Michael I. Schwartzbach Aarhus University Context-Free Grammars Example: sentence subject verb object subject person person John Joe Zacharias verb asked
Chapter 4. Lexical and Syntax Analysis
Chapter 4 Lexical and Syntax Analysis Chapter 4 Topics Introduction Lexical Analysis The Parsing Problem Recursive-Descent Parsing Bottom-Up Parsing Copyright 2012 Addison-Wesley. All rights reserved.
MIT Specifying Languages with Regular Expressions and Context-Free Grammars. Martin Rinard Massachusetts Institute of Technology
MIT 6.035 Specifying Languages with Regular essions and Context-Free Grammars Martin Rinard Massachusetts Institute of Technology Language Definition Problem How to precisely define language Layered structure
n Takes abstract syntax trees as input n In simple cases could be just strings n One procedure for each syntactic category
Interpreter Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul
Top-Down Parsing and Intro to Bottom-Up Parsing. Lecture 7
Top-Down Parsing and Intro to Bottom-Up Parsing Lecture 7 1 Predictive Parsers Like recursive-descent but parser can predict which production to use Predictive parsers are never wrong Always able to guess
3. Parsing. Oscar Nierstrasz
3. Parsing Oscar Nierstrasz Thanks to Jens Palsberg and Tony Hosking for their kind permission to reuse and adapt the CS132 and CS502 lecture notes. http://www.cs.ucla.edu/~palsberg/ http://www.cs.purdue.edu/homes/hosking/
Programming Languages and Compilers (CS 421)
Programming Languages and Compilers (CS 421) Sasa Misailovic 4110 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421a Based in part on slides by Mattox Beckman, as updated by Vikram Adve, Gul
CSE 401 Midterm Exam 11/5/10
Name There are 5 questions worth a total of 100 points. Please budget your time so you get to all of the questions. Keep your answers brief and to the point. The exam is closed books, closed notes, closed
Syntax-Directed Translation. Lecture 14
Syntax-Directed Translation Lecture 14 (adapted from slides by R. Bodik) 9/27/2006 Prof. Hilfinger, Lecture 14 1 Motivation: parser as a translator syntax-directed translation stream of tokens parser ASTs,
Introduction to Parsing. Lecture 5
Introduction to Parsing Lecture 5 1 Outline Regular languages revisited Parser overview Context-free grammars (CFG s) Derivations Ambiguity 2 Languages and Automata Formal languages are very important
Downloaded from Page 1. LR Parsing
Downloaded from http://himadri.cmsdu.org Page 1 LR Parsing We first understand Context Free Grammars. Consider the input string: x+2*y When scanned by a scanner, it produces the following stream of tokens:
UNIT III & IV. Bottom up parsing
UNIT III & IV Bottom up parsing 5.0 Introduction Given a grammar and a sentence belonging to that grammar, if we have to show that the given sentence belongs to the given grammar, there are two methods.
LR Parsing. Table Construction
#1 LR Parsing Table Construction #2 Outline Review of bottom-up parsing Computing the parsing DFA Closures, LR(1) Items, States Transitions Using parser generators Handling Conflicts #3 In One Slide An
flex is not a bad tool to use for doing modest text transformations and for programs that collect statistics on input.
flex is not a bad tool to use for doing modest text transformations and for programs that collect statistics on input. More often than not, though, you ll want to use flex to generate a scanner that divides
Question Points Score
CS 453 Introduction to Compilers Midterm Examination Spring 2009 March 12, 2009 75 minutes (maximum) Closed Book You may use one side of one sheet (8.5x11) of paper with any notes you like. This exam has
CS 4240: Compilers and Interpreters Project Phase 1: Scanner and Parser Due Date: October 4 th 2015 (11:59 pm) (via T-square)
CS 4240: Compilers and Interpreters Project Phase 1: Scanner and Parser Due Date: October 4 th 2015 (11:59 pm) (via T-square) Introduction This semester, through a project split into 3 phases, we are going
Compilers and computer architecture From strings to ASTs (2): context free grammars
1 / 1 Compilers and computer architecture From strings to ASTs (2): context free grammars Martin Berger October 2018 Recall the function of compilers 2 / 1 3 / 1 Recall we are discussing parsing Source
University of Technology Department of Computer Sciences. Final Examination st Term. Subject:Compilers Design
Subject:Compilers Design Division: All Branches Examiner:Dr. Abeer Tariq University of Technology Department of Computer Sciences 2102 Final Examination 2011-2012 1 st Term Year:Third Time: 3 Hours Date:
Programming Project II
Programming Project II CS 322 Compiler Construction Winter Quarter 2006 Due: Saturday, January 28, at 11:59pm START EARLY! Description In this phase, you will produce a parser for our version of Pascal.
Top-Down Parsing and Intro to Bottom-Up Parsing. Lecture 7
Top-Down Parsing and Intro to Bottom-Up Parsing Lecture 7 1 Predictive Parsers Like recursive-descent but parser can predict which production to use Predictive parsers are never wrong Always able to guess