1. The TINY sample language and it’s compiler
Notes by Liu Xinxin, Peng Shaowu

2. 1 The TINY Sample Language and Compiler
2 Implementation of a TINY Scanner
3 Syntax of the TINY Language
4 A Recursive-Descent Parser for TINY
5 A Semantic Analyzer for the TINY Language
6 A runtime environment for the TINY Language

3. 1 The TINY Sample Language and Compiler

4. TINY Compiler
The construction of TINY compiler uses the techniques studied in each chapter and show how all the parts of a compiler fit together.
Using experiment language TINY as source language
Using TM(the assembly language for a simple hypothetical processor) as the target language
Compiler is written in C

5. The construction of compiler for a concrete language
Familiar with the source language (lexical, syntax, semantic)
Familiar with the target language (addressing mode, the number of register, data representation )
Determine the structure of compiler

6. 1.1 The TINY Language Syntax description
A program is a sequence of statements separated by semicolons
Declarations
No procedures and no declarations
Data Type
All variables are integer variables, and variables are declared by assigning values to them

7. Statement
Two control statements: if-statement and repeat-statement, read and write statements
Expression
Boolean and integer arithmetic expressions
Comment
Comments are allowed within curly bracket

8. Example
{sample program in TINY language- computes factorial}
read x; { input an integer }
if 0<x then { don’t compute if x<=0 }
fact:=1;
repeat
fact := fact*x;
x := x-1
until x=0;
write fact{output factorial of x}
end

9. Components of the TINY Compiler
It has the following components: Scanner, parser, semantic analyzer, and code generator phases together with a symbol table
Following components are absent
No optimization phases and separate error handler or literal table

10. Structure of TINY Compiler
Four-pass compiler
The first pass consists of the scanner and parser, which construct the syntax tree;
The second and third passes undertake semantic analysis
The second pass constructs the symbol table
The third pass performs type checking
The forth pass is the code generator

11. The code that drives these passes: syntaxTree=parse(); buildSymtab(syntaxTree); typeCheck(syntaxTree); codeGen(syntaxTree,codefile);

12. 2. Implementation of a TINY Scanner

13. 2.1 Implementing a Scanner for the Sample Language TINY
The lexical structure of TINY
Reserved Words
Special Symbols
Other
if then else end
repeat until
read write
* /
= <
( ) ; :=
number
identifier

14. Construct a DFA for the scanner directly

15. Explanation:
All accepting states are collected into one state “DONE”, the different token recognized is saved in a variable
Construct a table of reserved words, reserved words are considered only after an identifier has been recognized, and then to look up the identifier in the table
The implementation of the DFA uses the doubly nested case analysis

16. 3 Syntax of the TINY Language

17. 3.1 A Context-Free Grammar for TINY
program -> stmt-seq
stmt->seq -> stmt-seq;stmt | stmt
stmt -> if-stmt|repeat-stmt|assign stmt|read-stmt | write-stmt
if-stmt ->if exp then stmt-seq end
| if exp then stmt-seq else stmt-seq end
repeat-stmt->repeat stmt-seq until exp
assign-stmt-> id:= exp
read-stmt -> read id
write-stmt -> write exp

18. exp -> simp-exp cop simp-exp |simp-exp
simp-exp -> simp-exp addop term |term
term -> term mulop factor | factor
factor -> (exp) |num |id

19. 3.2 Syntax Tree Structure for the TINY Compiler
Basic syntax tree structures 1 A sequence of statements 2 An if-statement ; s
syntax tree of s;s;s
seq

20. 3 A repeat-statement
4 An assign-statement
5 A write-statement
6 An operator-expression

21. {sample program in TINY language- computes factorial}
read x;{input an integer}
if 0<x then {don’t compute if x<=0}
fact:=1;
repeat
fact:=fact*x;
x:=x-1
until x=0;
write fact{output factorial of x}
end

23. 4 A Recursive-Descent Parser for TINY

24. TINY Grammar in EBNF …
stmt->seq -> stmt {;stmt}
exp -> simp-exp [cop simp-exp]
simp-exp -> term {addop term}
term -> factor {mulop factor} ……

25. 5 A Semantic Analyzer for the TINY Language

26. We separate the discussion of the TINY semantic analyzer into two parts
The structure of the symbol table and its associated operations
The operations of the semantic analyzer itself, including the construction of the symbol table and type checking

27. What information needs to be held in the table
5.1 A Symbol Table for TINY
What information needs to be held in the table
It does not need to contain scope information, and data type
It contains locations for variables for code generation
It also contains a cross-reference listing of line numbers where variables are accessed

28. Variable Name Location Line numbers x 5,6,9,10,10,11 fact 1 7,9,9,12
For example
5: read x;
6: if x>0 then
7: fact:=1;
8: repeat
9: fact:=fact*x;
10: x:=x-1
11: until x=0;
12: write fact
13:end
The symbol table for this program
Variable Name
Location
Line numbers x
5,6,9,10,10,11
fact 1
7,9,9,12

29. 5.2 A Semantic Analyzer for TINY
The symbol table is an inherited attribute, while the data type of an expression is a synthesized attribute
Thus, the symbol table can be built by a preorder traversal of the syntax tree, and type checking can be performed by a post-order traversal
Each is processed in a separate pass over the syntax tree

30. 6 A Runtime Environment for the TINY Language

31. The structure of a runtime environment for the TINY language
Place the variables in absolute addresses at the bottom end of program memory
Allocate the temporary (dynamic storage during expression evaluation) stack at the top end

32. top of memory
temp1
temp2
temp3
free memory w z y x
top of temp stack 3 2 1
bottom of memory
Runtime environment of TINY