What is a Compiler?

A program that
translates a
program from a
source language into
a target language!
 What is a Compiler?

Target
Interpreter
Source
 What is a Compiler?
temp =v[k]; TEMP =V(K)
High-level Language v[k] =v[k+1];
v[k+1] =temp;
V(K) =V(K+1)
V(K+1) =TEMP
C/Java Compiler Fortran Compiler
lw $to, 0($2)
Assembly Language lw
sw
$t1,
$t1,
4($2)
0($2)
sw $to, 4($2)
MIPS Assembler
0000 1001 1100 0110 1010 1111 0101 1000
Machine Language 1010 1111 0101 1000 0000 1001 1100 0110
1100 0110 1010 1111 0101 1000 0000 1001
0101 1000 0000 1001 1100 0110 1010 1111
 How Compilers Work
Request Scanner Get a
a token token
Start Parser
Front End: Semantic Semantic
Action Checking Error
Analysis of
program syntax
and semantics Intermediate
Representation
157.669 produces FLOATCONST with a value of 157.669
 Name How Compilers Work
found in
symbol
table Show
Fails
semantic
error
Name
not
Lookup found Put in Do Passes Generate Get Done
variable symbol semantic next
name table checks code token
 Compiler Parts

Front End: Back End:

Analysis Synthesis
1. Lexical Analysis 4. Code Generation
2. Syntax Analysis 5. Optimization
3. Semantic Analysis
 The Big Picture
Scanning: Converting
Parsing: Translating input text into stream of
code to rules of grammar. known objects called
Building representation of tokens. Simplifies parsing
code.
process.
• Grammar dictates syntactic rules of language
• i.e., how legal sentence could be formed
• Lexical rules of language dictate how legal word
is formed by concatenating alphabet.
 Tokenization Quiz
If we use a space to denote the end of a
section, how many tokens are in the following
sentence?
Fill in the blank: 21
“The question of whether a computer can think is
no more interesting than the question of whether a
submarine can swim.”
- Edsger W. Dijkstra
 Scanning and Tokenization
Token
File buffer

Token buffer contains: token being identified

 Scanning and Tokenization
main()
{ Token
printf(“Hello World”);
}
buffer

Token buffer
niam

Keyword: main
 Parser Quiz
Check all the statements that
Grammar Rules: are grammatically correct
given the grammar rules.
• E -> E + E a + b
• E -> E * E
• E -> -E a + b * c
• E -> (E) a b + c
• E -> id
a + b + a c
 Parser

Translating code Demands scanner

to rules of a Control to produce a
grammar the overall token
operation

Failure: Success: Does nothing and

Syntax returns to get next token,
Error! or takes semantic action
 Parser: Grammar Rules
<C-PROG> ➝ MAIN OPENPAR <PARAMS> CLOSEPAR <MAIN-BODY>
<PARAMS> ➝ NULL
<PARAMS> ➝ VAR <VARLIST>
<VARLIST> ➝ , VAR <VARLIST>
<VARLIST> ➝ NULL
<MAIN-BODY> ➝ CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> ➝ <TYPE> VAR <VARLIST>;
<ASSIGN-STMT> ➝ VAR = <EXPR>;
<EXPR> ➝ VAR
<EXPR> ➝ VAR <OP> <EXPR>
<OP> ➝ +
<OP> ➝ -
<TYPE> ➝ INT
<TYPE> ➝ FLOAT
 Parser
Example:
main() { Scanner Token Buffer
int a,b;
a = b;
}
Parser
 Parser
Example:
main() { Scanner Token Buffer
int a,b;
’ Please, get me the
a = b; next token.’’
}
Parser
 Parser
Example:
main() { Scanner Token Buffer
int a,b; (niam
a = b;
}
Parser
 Parser
Example:
main() { Scanner Token Buffer
int a,b;
Token: main
a = b;
}
Parser
 Parser
Example:
main() { Scanner Token Buffer
int a,b;
a = b;
}
Parser I recognize this as
per grammar rules!
Every C program
should start with main.
This program starts
with main.
 Parser
Matching: Start matching using a rule
When match takes place at certain position,
move further (get next token & repeat)
If expansion needs to be done, choose appropriate
rule (How to decide which rule to choose?)
If no rule found, declare error
If several rules found, the grammar (set of
rules) is ambiguous - something wrong with it!
 Parser
Ambiguity can lead to understanding a given
sentence in two different ways which allows
assigning two meanings to the same sentence,
some thing highly undesirable, e.g. 1 * 2 + 3
can be interpreted as understanding 1 to be
multiplied by 2 and the result to be added
to 3... OR...
2 and 3 to be added together first and then
multiply 1 to the result.
 Ambiguous Parsing Quiz
Given:
if x==1 then if y==2 print 1 else print 2

Which grammar rule should be applied?

stmt -> if expr then stmt
stmt -> if expr then stmt else stmt
 Ambiguous Parsing Quiz
stmt ➝ matched_stmt | unmatched_stmt / other_stmt
matched_stmt ➝ if expr then matched_stmt else matched_stmt
| other_stmt
unmatched_stmt ➝ if expr then stmt
| if expr then matched_stmt else unmatched_stmt
 Scanning and Parsing
main() { Scanner
int a,b;
’ Please, get me
a = b; the next token.’’
}
Parser
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: MAIN
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
 Scanning and Parsing
main() { Scanner
int a,b;
’ Please, get me
a = b; the next token.’’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: OPENPAR
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: CLOSEPAR
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<PARAMETERS> → NULL
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: CLOSEPAR
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<PARAMETERS> → NULL
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: CLOSEPAR
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: CURLYOPEN
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: INT
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
<TYPE> → INT
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: INT
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
<TYPE> → INT
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: INT
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
<TYPE> → INT
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: VAR
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
<VARLIST> → , VAR <VARLIST>
<VARLIST> → NULL
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ ,’ [COMMA]
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
<VARLIST> → , VAR <VARLIST>
<VARLIST> → NULL
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: VAR
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
<VARLIST> → , VAR <VARLIST>
<VARLIST> → NULL
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ ; ’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
<VARLIST> → , VAR <VARLIST>
<VARLIST> → NULL
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ ; ’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
<VARLIST> → , VAR <VARLIST>
<VARLIST> → NULL
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ ; ’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
<VARLIST> → , VAR <VARLIST>
<VARLIST> → NULL
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ ; ’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
<VARLIST> → , VAR <VARLIST>
<VARLIST> → NULL
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ ; ’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ ; ’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<DECL-STMT> → <TYPE>VAR<VAR-LIST>;
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: VAR
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<ASSIGN-STMT> → VAR = <EXPR>;
<EXPR> → VAR
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ =’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<ASSIGN-STMT> → VAR = <EXPR>;
<EXPR> → VAR
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ VAR’’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<ASSIGN-STMT> → VAR = <EXPR>;
<EXPR> → VAR
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ VAR’’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<ASSIGN-STMT> → VAR = <EXPR>;
<EXPR> → VAR
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ VAR’’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<ASSIGN-STMT> → VAR = <EXPR>;
<EXPR> → VAR
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ ; ’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<ASSIGN-STMT> → VAR = <EXPR>;
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: ’ ; ’
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
<ASSIGN-STMT> → VAR = <EXPR>;
 Scanning and Parsing
main() { Scanner
int a,b;
a = b; Token: CURLYCLOSE
}
Parser
<C-PROG> ➝ MAIN OPENPAR <PARAMETERS> CLOSEPAR <MAIN-BODY>
<MAIN-BODY> → CURLYOPEN <DECL-STMT> <ASSIGN-STMT> CURLYCLOSE
 Syntax vs Semantics Quiz
Assuming we are using ’C’ programming language, determine
which statements are syntactically incorrect (A), which are
semantically incorrect (B), and which are both syntactically
and semantically incorrect (C).
int main() {
int a,b,c;
Statement 3 is botha +-syntactically
= b; /* and semantically
1 */ A incorrect,
missing operand after 2nd + (syntax error), and undeclared d
Statement
causing 1 syntactically
semantic c; /*: 2+-*/
a = b + incorrect
error - no such operator in C
Statement 42 is syntactically
semantically and
+ ;semantically
d = a + bincorrect /*due
3 */ C
to correct
undeclared variable d.
d = a + b; /* 4 */ B
}
 Syntax vs Semantics

During parsing?
(Syntax checking) Semantic actions
• What are semantic
• Tokens are matched and actions?
consumed by parser
• Symbol tables
• Variables have attributes Semantic
• Declaration attached checks
attributes to variables
 Symbol Table
int a,b; →
Declares a and b, Within current scope, Type integer
Use of a and b now legal
Basic Symbol Table
Name Type Scope
a int ”main”
b int ”main”
 Semantic Actions
Enter variable Look up Do binding of
declaration into variables in looked-up variables
symbol table symbol table (scoping rules, etc.)

Do type Keep the

checking for semantic context
compatibility of processing
a + b + c -> t1 = a + b
t2 = t1 + c
 Semantic Actions
Action symbols embedded in the grammar.
Each action symbol represents a semantic procedure.
These procedures do things and/or return values.

Semantic procedures are called by parser at

appropriate places during parsing

Semantic stack implements & stores semantic

records
 Semantic Actions
<decl-stmt> ➝ <type>#put-type<varlist>#do-decl
<type> ➝ int | float
<varlist> ➝ <var>#add-decl <varlist>
<varlist> ➝ <var>#add-decl
<var> ➝ ID#proc-decl
#put-type puts given type on semantic stack
#proc-decl builds decl record for var on stack
#add-decl builds decl-chain
#do-decl traverses chain on semantic stack using
backwards pointers entering each var into
symbol table
 Semantic Actions
id3
decl record Name Type Scope

id2 id1 1 3
#do-decl
⇒ id2 1 3
id1
id3 1 3
type
 Semantic Actions
Two types of semantic actions:

Translation:
Checking: generate
binding, type temporary values,
compatibility, propagate them to
scoping, etc keep semantic
context
 Scanner
Start Parser
Semantic Semantic
Analysis Error
Full Compiler
Structure Intermediate
Representation

Code Assembly
Generation Code