Announcements. Written Assignment 1 out, due Friday, July 6th at 5PM.
|
|
|
- Garey Curtis
- 6 years ago
- Views:
Transcription
1 Syntax Analysis
2 Announcements Written Assignment 1 out, due Friday, July 6th at 5PM. xplore the theoretical aspects of scanning. See the limits of maximal-munch scanning. Class mailing list: There is an issue with SCPD students and the course mailing list. mail the staff immediately if you haven't gotten any of our s.
3 Where We Are Source Code Lexical Analysis Syntax Analysis Semantic Analysis IR Generation IR Optimization Code Generation Optimization Machine Code
4 Where We Are Source Code Lexical Analysis Syntax Analysis Semantic Analysis IR Generation IR Optimization Code Generation Optimization Machine Code Flex-pert
5 Where We Are Source Code Lexical Analysis Syntax Analysis Semantic Analysis IR Generation IR Optimization Code Generation Optimization Machine Code
6 while (ip < z) ++ip;
7 w h i l e ( i p < z ) \n \t + + i p ; while (ip < z) ++ip;
8 T_While ( T_Ident < T_Ident ) ++ T_Ident ip z ip w h i l e ( i p < z ) \n \t + + i p ; while (ip < z) ++ip;
9 While < ++ Ident Ident Ident ip z ip T_While ( T_Ident < T_Ident ) ++ T_Ident ip z ip w h i l e ( i p < z ) \n \t + + i p ; while (ip < z) ++ip;
10 do[for] = new 0;
11 d o [ f o r ] = n e w 0 ; do[for] = new 0;
12 T_Do [ T_For ] = T_New T_IntConst 0 d o [ f o r ] = n e w 0 ; do[for] = new 0;
13 T_Do [ T_For ] = T_New T_IntConst 0 d o [ f o r ] = n e w 0 ; do[for] = new 0;
14 What is Syntax Analysis? After lexical analysis (scanning), we have a series of tokens. In syntax analysis (or parsing), we want to interpret what those tokens mean. Goal: Recover the structure described by that series of tokens. Goal: Report errors if those tokens do not properly encode a structure.
15 Outline Today: Formalisms for syntax analysis. Context-Free Grammars Derivations Concrete and Abstract Syntax Trees Ambiguity Next Week: Parsing algorithms. Top-Down Parsing Bottom-Up Parsing
16 Formal Languages An alphabet is a set Σ of symbols that act as letters. A language over Σ is a set of strings made from symbols in Σ. When scanning, our alphabet was ASCII or Unicode characters. We produced tokens. When parsing, our alphabet is the set of tokens produced by the scanner.
17 The Limits of Regular Languages When scanning, we used regular expressions to define each token. Unfortunately, regular expressions are (usually) too weak to define programming languages. Cannot define a regular expression matching all expressions with properly balanced parentheses. Cannot define a regular expression matching all functions with properly nested block structure. We need a more powerful formalism.
18 Context-Free Grammars A context-free grammar (or CFG) is a formalism for defining languages. Can define the context-free languages, a strict superset of the the regular languages. CFGs are best explained by example...
19 Arithmetic xpressions Suppose we want to describe all legal arithmetic expressions using addition, subtraction, multiplication, and division. Here is one possible CFG: int Op () Op + Op - Op * Op / Op Op () Op ( Op ) * ( Op ) int * ( Op ) int * (int Op ) int * (int Op int) int * (int + int)
20 Arithmetic xpressions Suppose we want to describe all legal arithmetic expressions using addition, subtraction, multiplication, and division. Here is one possible CFG: int Op () Op + Op - Op * Op / Op Op int int Op int int / int
21 Context-Free Grammars Formally, a context-free grammar is a collection of four objects: A set of nonterminal symbols (or variables), A set of terminal symbols, A set of production rules saying how each nonterminal can be converted by a string of terminals and nonterminals, and A start symbol that begins the derivation. int Op () Op + Op - Op * Op /
22 A Notational Shorthand int Op () Op + Op - Op * Op /
23 A Notational Shorthand int Op () Op + - * /
24 Not Notational Shorthand The syntax for regular expressions does not carry over to CFGs. Cannot use *,, or parentheses. S a*b
25 Not Notational Shorthand The syntax for regular expressions does not carry over to CFGs. Cannot use *,, or parentheses. S Ab
26 Not Notational Shorthand The syntax for regular expressions does not carry over to CFGs. Cannot use *,, or parentheses. S Ab A Aa ε
27 Not Notational Shorthand The syntax for regular expressions does not carry over to CFGs. Cannot use *,, or parentheses. S a(b c*)
28 Not Notational Shorthand The syntax for regular expressions does not carry over to CFGs. Cannot use *,, or parentheses. S ax X (b c*)
29 Not Notational Shorthand The syntax for regular expressions does not carry over to CFGs. Cannot use *,, or parentheses. S ax X b c*
30 Not Notational Shorthand The syntax for regular expressions does not carry over to CFGs. Cannot use *,, or parentheses. S ax X b C
31 Not Notational Shorthand The syntax for regular expressions does not carry over to CFGs. Cannot use *,, or parentheses. S ax X b C C Cc ε
32 More Context-Free Grammars Chemicals! C 19 H 14 O 5 S Cu 3 (CO 3 ) 2 (OH) 2 - MnO 4 S 2- Form Cmp Cmp Ion Cmp Term Term Num Cmp Cmp Term lem (Cmp) lem H He Li Be B C Ion + - IonNum + IonNum - IonNum Num 1 IonNum
33 CFGs for Chemistry Form Cmp Cmp Ion Cmp Term Term Num Cmp Cmp Term lem (Cmp) lem H He Li Be B C Ion + - IonNum + IonNum - IonNum Num 1 IonNum Form Cmp Ion Cmp Cmp Ion Cmp Term Num Ion Term Term Num Ion lem Term Num Ion Mn Term Num Ion Mn lem Num Ion MnO Num Ion MnO IonNum Ion MnO 4 Ion - MnO 4
34 CFGs for Programming Languages BLOCK STMT { STMTS } STMTS ε STMT STMTS STMT XPR; if (XPR) BLOCK while (XPR) BLOCK do BLOCK while (XPR); BLOCK XPR identifier constant XPR + XPR XPR XPR XPR * XPR...
35 Some CFG Notation We will be discussing generic transformations and operations on CFGs over the next two weeks. Let's standardize our notation.
36 Some CFG Notation Capital letters at the beginning of the alphabet will represent nonterminals. i.e. A, B, C, D Lowercase letters at the end of the alphabet will represent terminals. i.e. t, u, v, w Lowercase Greek letters will represent arbitrary strings of terminals and nonterminals. i.e. α, γ, ω
37 xamples We might write an arbitrary production as A ω We might write a string of a nonterminal followed by a terminal as At We might write an arbitrary production containing a nonterminal followed by a terminal as B αatω
38 Derivations Op Op () Op ( Op ) * ( Op ) int * ( Op ) int * (int Op ) int * (int Op int) int * (int + int) This sequence of steps is called a derivation. A string αaω yields string αγω iff A γ is a production. If α yields β, we write α β. We say that α derives β iff there is a sequence of strings where α α 1 α 2 β If α derives β, we write α * β.
39 Leftmost Derivations BLOCK STMT { STMTS } STMTS ε STMT STMTS STMT XPR; if (XPR) BLOCK while (XPR) BLOCK do BLOCK while (XPR); BLOCK XPR identifier constant XPR + XPR XPR XPR XPR * XPR XPR = XPR... STMTS STMT STMTS XPR; STMTS XPR = XPR; STMTS id = XPR; STMTS id = XPR + XPR; STMTS id = id + XPR; STMTS id = id + constant; STMTS id = id + constant;
40 Leftmost Derivations A leftmost derivation is a derivation in which each step expands the leftmost nonterminal. A rightmost derivation is a derivation in which each step expands the rightmost nonterminal. These will be of great importance when we talk about parsing next week.
41 Related Derivations Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op Op () Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) * (int + int) int * (int + int)
42 Derivations Revisited A derivation encodes two pieces of information: What productions were applied produce the resulting string from the start symbol? In what order were they applied? Multiple derivations might use the same productions, but apply them in a different order.
43 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int)
44 Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Parse Trees
45 Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Parse Trees
46 Parse Trees Op int Op Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int)
47 Parse Trees Op int Op Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int)
48 Parse Trees Op int Op Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) int
49 Parse Trees Op int Op Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) int
50 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op int *
51 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op int *
52 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op int * ( )
53 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op int * ( )
54 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op int * Op ( )
55 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op int * Op ( )
56 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op int * Op ( int )
57 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op int * Op ( int )
58 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op int * Op ( int + )
59 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op int * Op ( int + )
60 Parse Trees Op int Op int * int * () int * ( Op ) int * (int Op ) int * (int + ) int * (int + int) Op int * Op ( int + int )
61 Parse Trees Op Op () Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) * (int + int) int * (int + int)
62 Op Op () Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) * (int + int) int * (int + int) Parse Trees
63 Op Op () Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) * (int + int) int * (int + int) Parse Trees
64 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) * (int + int) int * (int + int)
65 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) * (int + int) int * (int + int)
66 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) * (int + int) int * (int + int) ( )
67 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) * (int + int) int * (int + int) ( )
68 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) Op * (int + int) int * (int + int) ( )
69 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) Op * (int + int) int * (int + int) ( )
70 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) Op * (int + int) int * (int + int) ( int )
71 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) Op * (int + int) int * (int + int) ( int )
72 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) Op * (int + int) int * (int + int) ( + int )
73 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) Op * (int + int) int * (int + int) ( + int )
74 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) Op * (int + int) int * (int + int) ( int + int )
75 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) Op * (int + int) int * (int + int) ( int + int )
76 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) Op * (int + int) int * (int + int) * ( int + int )
77 Parse Trees Op Op () Op Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) Op * (int + int) int * (int + int) * ( int + int )
78 Parse Trees Op Op () Op ( Op ) Op ( Op int) Op ( + int) Op (int + int) * (int + int) int * (int + int) Op int * Op ( int + int )
79 For Comparison Op Op Op Op int * ( int + int ) int * ( int + int )
80 Parse Trees A parse tree is a tree encoding the steps in a derivation. Internal nodes represent nonterminal symbols used in the production. Inorder walk of the leaves contains the generated string. ncodes what productions are used, not the order in which those productions are applied.
81 The Goal of Parsing Goal of syntax analysis: Recover the structure described by a series of tokens. If language is described as a CFG, goal is to recover a parse tree for the the input string. Usually we do some simplifications on the tree; more on that later. We'll discuss how to do this next week.
82 Challenges in Parsing
83 A Serious Problem Op Op Op Op int * int + int int * (int + int) int * int + int (int * int) + int
84 Ambiguity A CFG is said to be ambiguous if there is at least one string with two or more parse trees. Note that ambiguity is a property of grammars, not languages. There is no algorithm for converting an arbitrary ambiguous grammar into an unambiguous one. Some languages are inherently ambiguous, meaning that no unambiguous grammar exists for them. There is no algorithm for detecting whether an arbitrary grammar is ambiguous.
85 Is Ambiguity a Problem? Depends on semantics. int +
86 Is Ambiguity a Problem? Depends on semantics. R int + R R + R R + R 5 R + R
87 Is Ambiguity a Problem? Depends on semantics. int + -
88 Is Ambiguity a Problem? Depends on semantics. int + - R R R + - R R + R 5 R + R
89 Resolving Ambiguity If a grammar can be made unambiguous at all, it is usually made unambiguous through layering. Have exactly one way to build each piece of the string. Have exactly one way of combining those pieces back together.
90 xample: Balanced Parentheses Consider the language of all strings of balanced parentheses. xamples: ε () (()()) ((()))(())() Here is one possible grammar for balanced parentheses: P ε PP (P)
91 Balanced Parentheses Given the grammar P ε PP (P) How might we generate the string (()())?
92 Balanced Parentheses Given the grammar P ε PP (P) How might we generate the string (()())? P
93 Balanced Parentheses Given the grammar P ε PP (P) How might we generate the string (()())? P P ( )
94 Balanced Parentheses Given the grammar P ε PP (P) How might we generate the string (()())? P P P P ( )
95 Balanced Parentheses Given the grammar P ε PP (P) How might we generate the string (()())? P P P P P ( ( ) )
96 Balanced Parentheses Given the grammar P ε PP (P) How might we generate the string (()())? P P P P P ( ( ) ) ε
97 Balanced Parentheses Given the grammar P ε PP (P) How might we generate the string (()())? P P P P P P ( ( ) ( ) ) ε
98 Balanced Parentheses Given the grammar P ε PP (P) How might we generate the string (()())? P P P P P P ( ( ε ) ( ε ) )
99 Balanced Parentheses P P P P P P P P ( ( ε ) ( ε ) ) ε
100 How to resolve this ambiguity?
101 ( ( ) ( ) ) ( ) ( ( ) )
102 ( ( ) ( ) ) ( ) ( ( ) )
103 ( ( ) ( ) ) ( ) ( ( ) )
104 ( ( ) ( ) ) ( ) ( ( ) )
105 Rethinking Parentheses A string of balanced parentheses is a sequence of strings that are themselves balanced parentheses. To avoid ambiguity, we can build the string in two steps: Decide how many different substrings we will glue together. Build each substring independently.
106 Let's ask the Internet for help!
107
108 Um... what? The way the nyancat flies across the sky is similar to how we can build up strings of balanced parentheses.
109 Um... what? The way the nyancat flies across the sky is similar to how we can build up strings of balanced parentheses.
110 Um... what? The way the nyancat flies across the sky is similar to how we can build up strings of balanced parentheses.
111 Um... what? The way the nyancat flies across the sky is similar to how we can build up strings of balanced parentheses.
112 Um... what? The way the nyancat flies across the sky is similar to how we can build up strings of balanced parentheses.
113 Um... what? The way the nyancat flies across the sky is similar to how we can build up strings of balanced parentheses.
114 Um... what? The way the nyancat flies across the sky is similar to how we can build up strings of balanced parentheses.
115 Um... what? The way the nyancat flies across the sky is similar to how we can build up strings of balanced parentheses. ε
116 Building Parentheses Spread a string of parentheses across the string. There is exactly one way to do this for any number of parentheses. xpand out each substring by adding in parentheses and repeating. S P P S ε ( ) S
117 S PS PPS PP (S)P (S)(S) (PS)(S) (P)(S) ((S))(S) (())(S) (())() Building Parentheses S P S ε P ( ) S
118 Context-Free Grammars A regular expression can be Any letter ε The concatenation of regular expressions. The union of regular expressions. The Kleene closure of a regular expression. A parenthesized regular expression.
119 Context-Free Grammars This gives us the following CFG: R a b c R ε R RR R R R R R* R (R)
120 An Ambiguous Grammar R a b c R ε R RR R R R R R* R (R) R R R R R R R R a b * a (b*) a b * (a b)*
121 Resolving Ambiguity We can try to resolve the ambiguity via layering: R a b c R ε R RR R R R R R* R (R) a a b *
122 Resolving Ambiguity We can try to resolve the ambiguity via layering: R a b c R ε R RR R R R R R* R (R) a a b *
123 Resolving Ambiguity We can try to resolve the ambiguity via layering: R a b c R ε R RR R R R R R* R (R) a a b *
124 Resolving Ambiguity We can try to resolve the ambiguity via layering: R a b c R ε R RR R R R R R* R (R) a a b *
125 Resolving Ambiguity We can try to resolve the ambiguity via layering: R a b c R ε R RR R R R R R* R (R) a a b *
126 Resolving Ambiguity We can try to resolve the ambiguity via layering: R a b c R ε R RR R R R R R* R (R) a a b *
127 Resolving Ambiguity We can try to resolve the ambiguity via layering: R a b c R ε R RR R R R R R* R (R) a a b *
128 Resolving Ambiguity We can try to resolve the ambiguity via layering: R a b c R ε R RR R R R R R* R (R) R S R S S T ST T U T* U a b c U ε U (R)
129 Why is this unambiguous? R S R S S T ST T U T* U a b U ε U (R)
130 Why is this unambiguous? R S R S S T ST T U T* U a b U ε U (R) Only generates atomic expressions
131 Why is this unambiguous? R S R S S T ST T U T* U a b U ε U (R) Puts stars onto atomic expressions Only generates atomic expressions
132 Why is this unambiguous? R S R S S T ST T U T* U a b U ε U (R) Concatenates starred expressions Puts stars onto atomic expressions Only generates atomic expressions
133 Why is this unambiguous? R S R S S T ST T U T* U a b U ε U (R) Unions concatenated expressions Concatenates starred expressions Puts stars onto atomic expressions Only generates atomic expressions
134 R R S R S S T ST T U T* U a b c U ε U (R) a b c a *
135 R R R S R S S T ST T U T* U a b c U ε U (R) S a b c a *
136 R R R S R S S T ST T U T* U a b c U ε U (R) R S S a b c a *
137 R R R S R S S T ST T U T* U a b c U ε U (R) R S S S a b c a *
138 R R R S R S S T ST T U T* U a b c U ε U (R) S R S T S S a b c a *
139 R R R S R S S T ST T U T* U a b c U ε U (R) R S S T T S S a b c a *
140 R R R S R S S T ST T U T* U a b c U ε U (R) R S S T U T S S a b c a *
141 R R R S R S S T ST T U T* U a b c U ε U (R) R S S T U T S S a b c a *
142 R R R S R S S T ST T U T* U a b c U ε U (R) R S S T T U U S S a b c a *
143 R R R S R S S T ST T U T* U a b c U ε U (R) R S S T T U U S S a b c a *
144 R R R S R S S T ST R S S T U T* U a b c S S U ε T T T U (R) U U a b c a *
145 R R R S R S S T ST R S S T U T* U a b c S S U ε T T T U (R) U U U a b c a *
146 R R R S R S S T ST R S S T U T* U a b c S S U ε T T T U (R) U U U a b c a *
147 R R R S R S S T ST R S S T U T* U a b c S S T U ε T T T U (R) U U U a b c a *
148 R R R S R S S T ST R S S T U T* U a b c S S T U ε T T T T U (R) U U U a b c a *
149 R R R S R S S T ST T U T* U a b c U ε U (R) R S S S T T T T U U U U S T a b c a *
150 R R R S R S S T ST T U T* U a b c U ε U (R) R S S S T T T T U U U U S T a b c a *
151 Precedence Declarations If we leave the world of pure CFGs, we can often resolve ambiguities through precedence declarations. e.g. multiplication has higher precedence than addition, but lower precedence than exponentiation. Allows for unambiguous parsing of ambiguous grammars. We'll see how this is implemented later on.
152 The Structure of a Parse Tree R S R S S T ST T U T* U a b U ε U (R)
153 The Structure of a Parse Tree R S R S S T ST T U T* U a b U ε U (R) a a b *
154 The Structure of a Parse Tree R R S R S R S S T ST T U T* S T U a b U ε U (R) S T T U U U a a b *
155 The Structure of a Parse Tree R R S R S S T ST T U T* R S S T or U a b U ε U (R) S T T U U concat * a a b U a a b *
156 R S R S S T ST T U T* U a b U ε U (R) a ( b c )
157 R S R S R S S T ST T U T* U a b U ε U (R) T U R S R S S T T T U U U a ( b c )
158 R S R S R S S T ST T U T* U a b U ε U (R) S T R S T T U R S T a concat b or c U U U a ( b c )
159 Abstract Syntax Trees (ASTs) A parse tree is a concrete syntax tree; it shows exactly how the text was derived. A more useful structure is an abstract syntax tree, which retains only the essential structure of the input.
160 How to build an AST? Typically done through semantic actions. Associate a piece of code to execute with each production. As the input is parsed, execute this code to build the AST. xact order of code execution depends on the parsing method used. This is called a syntax-directed translation.
161 Simple Semantic Actions T + T T int T int * T T () 1.val = T.val + 2.val.val = T.val T.val = int.val T.val = int.val * T.val T.val =.val
162 Simple Semantic Actions T + T T int T int * T T () 1.val = T.val + 2.val.val = T.val T.val = int.val T.val = int.val * T.val T.val =.val int 26 * int 5 + int 7
163 Simple Semantic Actions T + T T int T int * T T () 1.val = T.val + 2.val.val = T.val T.val = int.val T.val = int.val * T.val T.val =.val T 5 int 26 * int 5 + int 7
164 Simple Semantic Actions T + T T int T int * T T () 1.val = T.val + 2.val.val = T.val T.val = int.val T.val = int.val * T.val T.val =.val T 130 T 5 int 26 * int 5 + int 7
165 Simple Semantic Actions T + T T int T int * T T () 1.val = T.val + 2.val.val = T.val T.val = int.val T.val = int.val * T.val T.val =.val T 130 T 5 T 7 int 26 * int 5 + int 7
166 Simple Semantic Actions T + 1.val = T.val + 2.val T.val = T.val T int T.val = int.val T int * T T.val = int.val * T.val T () T.val =.val T T 5 T 7 int 26 * int 5 + int 7
167 Simple Semantic Actions T + 1.val = T.val + 2.val T.val = T.val T int T.val = int.val 137 T int * T T.val = int.val * T.val T () T.val =.val T T 5 T 7 int 26 * int 5 + int 7
168 Semantic Actions to Build ASTs R S R.ast = S.ast; R R S R 1.ast = new Or(R 2.ast, S.ast); S T S.ast = T.ast; S ST S 1.ast = new Concat(S 2.ast, T.ast); T U T.ast = U.ast; T T* T 1.ast = new Star(T 2.ast); U a U.ast = new SingleChar('a'); U ε U.ast = new psilon(); U (R) U.ast = R.ast;
169 Summary Syntax analysis (parsing) extracts the structure from the tokens produced by the scanner. Languages are usually specified by context-free grammars (CFGs). A parse tree shows how a string can be derived from a grammar. A grammar is ambiguous if it can derive the same string multiple ways. There is no algorithm for eliminating ambiguity; it must be done by hand. Abstract syntax trees (ASTs) contain an abstract representation of a program's syntax. Semantic actions associated with productions can be used to build ASTs.
170 Next Time Top-Down Parsing Parsing as a Search Backtracking Parsers Predictive Parsers LL(1)
Context-Free Grammars
Context-Free Grammars Describing Languages We've seen two models for the regular languages: Automata accept precisely the strings in the language. Regular expressions describe precisely the strings in
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
Context-Free Grammars
Context-Free Grammars Describing Languages We've seen two models for the regular languages: Finite automata accept precisely the strings in the language. Regular expressions describe precisely the strings
Fall Compiler Principles Context-free Grammars Refresher. Roman Manevich Ben-Gurion University of the Negev
Fall 2016-2017 Compiler Principles Context-free Grammars Refresher Roman Manevich Ben-Gurion University of the Negev 1 xample grammar S S ; S S id := S print (L) id num + L L L, shorthand for Statement
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
THE COMPILATION PROCESS EXAMPLE OF TOKENS AND ATTRIBUTES
THE COMPILATION PROCESS Character stream CS 403: Scanning and Parsing Stefan D. Bruda Fall 207 Token stream Parse tree Abstract syntax tree Modified intermediate form Target language Modified target language
CS 403: Scanning and Parsing
CS 403: Scanning and Parsing Stefan D. Bruda Fall 2017 THE COMPILATION PROCESS Character stream Scanner (lexical analysis) Token stream Parser (syntax analysis) Parse tree Semantic analysis Abstract syntax
CSE 3302 Programming Languages Lecture 2: Syntax
CSE 3302 Programming Languages Lecture 2: Syntax (based on slides by Chengkai Li) Leonidas Fegaras University of Texas at Arlington CSE 3302 L2 Spring 2011 1 How do we define a PL? Specifying a PL: Syntax:
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
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
Parsing Part II. (Ambiguity, Top-down parsing, Left-recursion Removal)
Parsing Part II (Ambiguity, Top-down parsing, Left-recursion Removal) Ambiguous Grammars Definitions If a grammar has more than one leftmost derivation for a single sentential form, the grammar is ambiguous
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
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
Syntax Analysis Part I
Syntax Analysis Part I Chapter 4: Context-Free Grammars Slides adapted from : Robert van Engelen, Florida State University Position of a Parser in the Compiler Model Source Program Lexical Analyzer Token,
Part 5 Program Analysis Principles and Techniques
1 Part 5 Program Analysis Principles and Techniques Front end 2 source code scanner tokens parser il errors Responsibilities: Recognize legal programs Report errors Produce il Preliminary storage map Shape
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
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
Context-Free Grammars
Context-Free Grammars Lecture 7 http://webwitch.dreamhost.com/grammar.girl/ Outline Scanner vs. parser Why regular expressions are not enough Grammars (context-free grammars) grammar rules derivations
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
Introduction to Parsing. Lecture 8
Introduction to Parsing Lecture 8 Adapted from slides by G. Necula Outline Limitations of regular languages Parser overview Context-free grammars (CFG s) Derivations Languages and Automata Formal languages
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
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
Context-Free Languages and Parse Trees
Context-Free Languages and Parse Trees Mridul Aanjaneya Stanford University July 12, 2012 Mridul Aanjaneya Automata Theory 1/ 41 Context-Free Grammars A context-free grammar is a notation for describing
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
Syntax Analysis. Prof. James L. Frankel Harvard University. Version of 6:43 PM 6-Feb-2018 Copyright 2018, 2015 James L. Frankel. All rights reserved.
Syntax Analysis Prof. James L. Frankel Harvard University Version of 6:43 PM 6-Feb-2018 Copyright 2018, 2015 James L. Frankel. All rights reserved. Context-Free Grammar (CFG) terminals non-terminals start
VIVA QUESTIONS WITH ANSWERS
VIVA QUESTIONS WITH ANSWERS 1. What is a compiler? A compiler is a program that reads a program written in one language the source language and translates it into an equivalent program in another language-the
Outline. Limitations of regular languages. Introduction to Parsing. Parser overview. Context-free grammars (CFG s)
Outline Limitations of regular languages Introduction to Parsing Parser overview Lecture 8 Adapted from slides by G. Necula Context-free grammars (CFG s) Derivations Languages and Automata Formal languages
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
Introduction to Parsing. Lecture 5. Professor Alex Aiken Lecture #5 (Modified by Professor Vijay Ganesh)
Introduction to Parsing Lecture 5 (Modified by Professor Vijay Ganesh) 1 Outline Regular languages revisited Parser overview Context-free grammars (CFG s) Derivations Ambiguity 2 Languages and Automata
The analysis part breaks up the source program into constituent pieces and creates an intermediate representation of the source program.
COMPILER DESIGN 1. What is a compiler? A compiler is a program that reads a program written in one language the source language and translates it into an equivalent program in another language-the target
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
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/
Outline. Regular languages revisited. Introduction to Parsing. Parser overview. Context-free grammars (CFG s) Lecture 5. Derivations.
Outline Regular languages revisited Introduction to Parsing Lecture 5 Parser overview Context-free grammars (CFG s) Derivations Prof. Aiken CS 143 Lecture 5 1 Ambiguity Prof. Aiken CS 143 Lecture 5 2 Languages
Chapter 3: CONTEXT-FREE GRAMMARS AND PARSING Part 1
Chapter 3: CONTEXT-FREE GRAMMARS AND PARSING Part 1 1. Introduction Parsing is the task of Syntax Analysis Determining the syntax, or structure, of a program. The syntax is defined by the grammar rules
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
Derivations vs Parses. Example. Parse Tree. Ambiguity. Different Parse Trees. Context Free Grammars 9/18/2012
Derivations vs Parses Grammar is used to derive string or construct parser Context ree Grammars A derivation is a sequence of applications of rules Starting from the start symbol S......... (sentence)
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
Specifying Syntax. An English Grammar. Components of a Grammar. Language Specification. Types of Grammars. 1. Terminal symbols or terminals, Σ
Specifying Syntax Language Specification Components of a Grammar 1. Terminal symbols or terminals, Σ Syntax Form of phrases Physical arrangement of symbols 2. Nonterminal symbols or syntactic categories,
LANGUAGE PROCESSORS. Presented By: Prof. S.J. Soni, SPCE Visnagar.
LANGUAGE PROCESSORS Presented By: Prof. S.J. Soni, SPCE Visnagar. Introduction Language Processing activities arise due to the differences between the manner in which a software designer describes the
Ambiguous Grammars and Compactification
Ambiguous Grammars and Compactification Mridul Aanjaneya Stanford University July 17, 2012 Mridul Aanjaneya Automata Theory 1/ 44 Midterm Review Mathematical Induction and Pigeonhole Principle Finite Automata
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
2.2 Syntax Definition
42 CHAPTER 2. A SIMPLE SYNTAX-DIRECTED TRANSLATOR sequence of "three-address" instructions; a more complete example appears in Fig. 2.2. This form of intermediate code takes its name from instructions
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
( ) i 0. Outline. Regular languages revisited. Introduction to Parsing. Parser overview. Context-free grammars (CFG s) Lecture 5.
Outline Regular languages revisited Introduction to Parsing Lecture 5 Parser overview Context-free grammars (CFG s) Derivations Prof. Aiken CS 143 Lecture 5 1 Ambiguity Prof. Aiken CS 143 Lecture 5 2 Languages
Section A. A grammar that produces more than one parse tree for some sentences is said to be ambiguous.
Section A 1. What do you meant by parser and its types? A parser for grammar G is a program that takes as input a string w and produces as output either a parse tree for w, if w is a sentence of G, or
Compilers. Yannis Smaragdakis, U. Athens (original slides by Sam
Compilers Parsing Yannis Smaragdakis, U. Athens (original slides by Sam Guyer@Tufts) Next step text chars Lexical analyzer tokens Parser IR Errors Parsing: Organize tokens into sentences Do tokens conform
Defining syntax using CFGs
Defining syntax using CFGs Roadmap Last time Defined context-free grammar This time CFGs for specifying a language s syntax Language membership List grammars Resolving ambiguity CFG Review G = (N,Σ,P,S)
MA513: Formal Languages and Automata Theory Topic: Context-free Grammars (CFG) Lecture Number 18 Date: September 12, 2011
MA53: Formal Languages and Automata Theory Topic: Context-free Grammars (CFG) Lecture Number 8 Date: September 2, 20 xercise: Define a context-free grammar that represents (a simplification of) expressions
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
CSE P 501 Compilers. Parsing & Context-Free Grammars Hal Perkins Spring UW CSE P 501 Spring 2018 C-1
CSE P 501 Compilers Parsing & Context-Free Grammars Hal Perkins Spring 2018 UW CSE P 501 Spring 2018 C-1 Administrivia Project partner signup: please find a partner and fill out the signup form by noon
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?
Parsing. source code. while (k<=n) {sum = sum+k; k=k+1;}
Compiler Construction Grammars Parsing source code scanner tokens regular expressions lexical analysis Lennart Andersson parser context free grammar Revision 2012 01 23 2012 parse tree AST builder (implicit)
Part 3. Syntax analysis. Syntax analysis 96
Part 3 Syntax analysis Syntax analysis 96 Outline 1. Introduction 2. Context-free grammar 3. Top-down parsing 4. Bottom-up parsing 5. Conclusion and some practical considerations Syntax analysis 97 Structure
CS 406/534 Compiler Construction Parsing Part I
CS 406/534 Compiler Construction Parsing Part I Prof. Li Xu Dept. of Computer Science UMass Lowell Fall 2004 Part of the course lecture notes are based on Prof. Keith Cooper, Prof. Ken Kennedy and Dr.
CSE 311 Lecture 21: Context-Free Grammars. Emina Torlak and Kevin Zatloukal
CSE 311 Lecture 21: Context-Free Grammars Emina Torlak and Kevin Zatloukal 1 Topics Regular expressions A brief review of Lecture 20. Context-free grammars Syntax, semantics, and examples. 2 Regular expressions
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
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]
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,
Abstract Syntax Trees & Top-Down Parsing
Abstract Syntax Trees & Top-Down Parsing Review of Parsing Given a language L(G), a parser consumes a sequence of tokens s and produces a parse tree Issues: How do we recognize that s L(G)? A parse tree
Abstract Syntax Trees & Top-Down Parsing
Review of Parsing Abstract Syntax Trees & Top-Down Parsing Given a language L(G), a parser consumes a sequence of tokens s and produces a parse tree Issues: How do we recognize that s L(G)? A parse tree
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
B The SLLGEN Parsing System
B The SLLGEN Parsing System Programs are just strings of characters. In order to process a program, we need to group these characters into meaningful units. This grouping is usually divided into two stages:
Lexical Analysis. Introduction
Lexical Analysis Introduction Copyright 2015, Pedro C. Diniz, all rights reserved. Students enrolled in the Compilers class at the University of Southern California have explicit permission to make copies
EECS 6083 Intro to Parsing Context Free Grammars
EECS 6083 Intro to Parsing Context Free Grammars Based on slides from text web site: Copyright 2003, Keith D. Cooper, Ken Kennedy & Linda Torczon, all rights reserved. 1 Parsing sequence of tokens parser
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
CS 315 Programming Languages Syntax. Parser. (Alternatively hand-built) (Alternatively hand-built)
Programming languages must be precise Remember instructions This is unlike natural languages CS 315 Programming Languages Syntax Precision is required for syntax think of this as the format of the language
Parsing: Derivations, Ambiguity, Precedence, Associativity. Lecture 8. Professor Alex Aiken Lecture #5 (Modified by Professor Vijay Ganesh)
Parsing: Derivations, Ambiguity, Precedence, Associativity Lecture 8 (Modified by Professor Vijay Ganesh) 1 Topics covered so far Regular languages and Finite automaton Parser overview Context-free grammars
Front End. Hwansoo Han
Front nd Hwansoo Han Traditional Two-pass Compiler Source code Front nd IR Back nd Machine code rrors High level functions Recognize legal program, generate correct code (OS & linker can accept) Manage
Optimizing Finite Automata
Optimizing Finite Automata We can improve the DFA created by MakeDeterministic. Sometimes a DFA will have more states than necessary. For every DFA there is a unique smallest equivalent DFA (fewest states
Context-Free Grammars
Context-Free Grammars Describing Languages We've seen two models for the regular languages: Finite automata accept precisely the strings in the language. Regular expressions describe precisely the strings
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
Introduction to Lexical Analysis
Introduction to Lexical Analysis Outline Informal sketch of lexical analysis Identifies tokens in input string Issues in lexical analysis Lookahead Ambiguities Specifying lexers Regular expressions Examples
Lexical and Syntax Analysis
Lexical and Syntax Analysis (of Programming Languages) Top-Down Parsing Lexical and Syntax Analysis (of Programming Languages) Top-Down Parsing Easy for humans to write and understand String of characters
CS153: Compilers Lecture 4: Recursive Parsing
CS153: Compilers Lecture 4: Recursive Parsing Stephen Chong https://www.seas.harvard.edu/courses/cs153 Announcements Proj 1 out Due Thursday Sept 20 11:59 Start soon if you haven t! Proj 2 released today
A simple syntax-directed
Syntax-directed is a grammaroriented compiling technique Programming languages: Syntax: what its programs look like? Semantic: what its programs mean? 1 A simple syntax-directed Lexical Syntax Character
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
About the Tutorial. Audience. Prerequisites. Copyright & Disclaimer. Compiler Design
i About the Tutorial A compiler translates the codes written in one language to some other language without changing the meaning of the program. It is also expected that a compiler should make the target
ΕΠΛ323 - Θεωρία και Πρακτική Μεταγλωττιστών
ΕΠΛ323 - Θεωρία και Πρακτική Μεταγλωττιστών Lecture 5a Syntax Analysis lias Athanasopoulos eliasathan@cs.ucy.ac.cy Syntax Analysis Συντακτική Ανάλυση Context-free Grammars (CFGs) Derivations Parse trees
Principles of Programming Languages COMP251: Syntax and Grammars
Principles of Programming Languages COMP251: Syntax and Grammars Prof. Dekai Wu Department of Computer Science and Engineering The Hong Kong University of Science and Technology Hong Kong, China Fall 2007
Abstract Syntax Trees & Top-Down Parsing
Review of Parsing Abstract Syntax Trees & Top-Down Parsing Given a language L(G), a parser consumes a sequence of tokens s and produces a parse tree Issues: How do we recognize that s L(G)? A parse tree
Dr. D.M. Akbar Hussain
Syntax Analysis Parsing Syntax Or Structure Given By Determines Grammar Rules Context Free Grammar 1 Context Free Grammars (CFG) Provides the syntactic structure: A grammar is quadruple (V T, V N, S, R)
Abstract Syntax Trees Synthetic and Inherited Attributes
Abstract Syntax Trees Synthetic and Inherited Attributes Lecture 22 Sections 5.1-5.2 Robb T. Koether Hampden-Sydney College Mon, Mar 16, 2015 Robb T. Koether (Hampden-Sydney College)Abstract Syntax TreesSynthetic
Derivations of a CFG. MACM 300 Formal Languages and Automata. Context-free Grammars. Derivations and parse trees
Derivations of a CFG MACM 300 Formal Languages and Automata Anoop Sarkar http://www.cs.sfu.ca/~anoop strings grow on trees strings grow on Noun strings grow Object strings Verb Object Noun Verb Object
Lexical and Syntax Analysis. Top-Down Parsing
Lexical and Syntax Analysis Top-Down Parsing Easy for humans to write and understand String of characters Lexemes identified String of tokens Easy for programs to transform Data structure Syntax A syntax
Midterm Exam. CSCI 3136: Principles of Programming Languages. February 20, Group 2
Banner number: Name: Midterm Exam CSCI 336: Principles of Programming Languages February 2, 23 Group Group 2 Group 3 Question. Question 2. Question 3. Question.2 Question 2.2 Question 3.2 Question.3 Question
Context-Free Grammars
Context-Free Grammars 1 Informal Comments A context-free grammar is a notation for describing languages. It is more powerful than finite automata or RE s, but still cannot define all possible languages.
Languages and Compilers
Principles of Software Engineering and Operational Systems Languages and Compilers SDAGE: Level I 2012-13 3. Formal Languages, Grammars and Automata Dr Valery Adzhiev vadzhiev@bournemouth.ac.uk Office:
Introduction to Parsing
Introduction to Parsing The Front End Source code Scanner tokens Parser IR Errors Parser Checks the stream of words and their parts of speech (produced by the scanner) for grammatical correctness Determines
Context-Free Grammars
CFG2: Ambiguity Context-Free Grammars CMPT 379: Compilers Instructor: Anoop Sarkar anoopsarkar.github.io/compilers-class Ambiguity - / - / ( ) - / / - 16-06-22 2 Ambiguity Grammar is ambiguous if more
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
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
Formal Languages and Grammars. Chapter 2: Sections 2.1 and 2.2
Formal Languages and Grammars Chapter 2: Sections 2.1 and 2.2 Formal Languages Basis for the design and implementation of programming languages Alphabet: finite set Σ of symbols String: finite sequence
Syntax Analysis. COMP 524: Programming Language Concepts Björn B. Brandenburg. The University of North Carolina at Chapel Hill
Syntax Analysis Björn B. Brandenburg The University of North Carolina at Chapel Hill Based on slides and notes by S. Olivier, A. Block, N. Fisher, F. Hernandez-Campos, and D. Stotts. The Big Picture Character
Chapter 4. Lexical and Syntax Analysis. Topics. Compilation. Language Implementation. Issues in Lexical and Syntax Analysis.
Topics Chapter 4 Lexical and Syntax Analysis Introduction Lexical Analysis Syntax Analysis Recursive -Descent Parsing Bottom-Up parsing 2 Language Implementation Compilation There are three possible approaches
CS412/413. Introduction to Compilers Tim Teitelbaum. Lecture 2: Lexical Analysis 23 Jan 08
CS412/413 Introduction to Compilers Tim Teitelbaum Lecture 2: Lexical Analysis 23 Jan 08 Outline Review compiler structure What is lexical analysis? Writing a lexer Specifying tokens: regular expressions
Plan for Today. Regular Expressions: repetition and choice. Syntax and Semantics. Context Free Grammars
Plan for Today Context Free s models for specifying programming languages syntax semantics example grammars derivations Parse trees yntax-directed translation Used syntax-directed translation to interpret
Syntax Analysis. The Big Picture. The Big Picture. COMP 524: Programming Languages Srinivas Krishnan January 25, 2011
Syntax Analysis COMP 524: Programming Languages Srinivas Krishnan January 25, 2011 Based in part on slides and notes by Bjoern Brandenburg, S. Olivier and A. Block. 1 The Big Picture Character Stream Token
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
SYNTAX ANALYSIS 1. Define parser. Hierarchical analysis is one in which the tokens are grouped hierarchically into nested collections with collective meaning. Also termed as Parsing. 2. Mention the basic
CMSC 330: Organization of Programming Languages. Context-Free Grammars Ambiguity
CMSC 330: Organization of Programming Languages Context-Free Grammars Ambiguity Review Why should we study CFGs? What are the four parts of a CFG? How do we tell if a string is accepted by a CFG? What