1. Chapter 1. Introduction

2. Outline Language Processors The Structure of a Compiler
The Evolution of Programming Languages
Why study principle of programming languages

3. Language Processors
A compiler
source program
Compiler
target program

4. Running the target program
input
output

5. An interpreter Much slower program execution Better error diagnostics
source program
output
input

6. A hybrid compiler, e.g. Java
source program
Translator
intermediate program
Virtual Machine
output
input

7. Outline Language Processors The Structure of a Compiler
The Evolution of Programming Languages
Why study principle of programming languages

8. A Language Processing System
source program
Preprocessor
modified source program
Compiler
target assembly program
Assembler
relocatable machine code
Linker/Loader
library files relocatable object files
target machine code

9. The Structure of a Compiler
Analysis
Front end
Using a grammatical structure to create an intermediate representation
Collecting information about the source program in a symbol table
Synthesis
Back end
Constructing the target program from the intermediate representation and the symbol table

10. Phases of a Compiler character stream Lexical Analyzer token stream
Symbol Table
Syntax Analyzer
syntax tree
(optional)
Semantic Analyzer
syntax tree
Machine-Independent Code Optimization
Intermediate Code Generator
intermediate representation
Code Generator
Machine-Dependent Code Optimization
(optional)
target machine code

11. Lexical Analysis (Scanning)
Grouping characters into lexemes
E.g.
position = initial + rate * 60
<id,1> <=> <id,2> <+> <id,3> <*> <60>

12. Syntax Analysis (Parsing)
Creating a tree-like (e.g. syntax tree) intermediate representation that depicts the grammatical structure of the token streams
E.g.
<id,1> <=> <id,2> <+> <id,3> <*> <60> = +
<id, 1> *
<id, 2> 60
<id, 3>

13. Semantic Analysis Type checking Type conversions or coercions E.g. = +
<id, 1> *
<id, 2>
<id, 3>
int2float 60

14. Intermediate Code Generation
Generating a low-level intermediate representation
It should be easy to produce
It should be easy to translate into the target machine
E.g. three-address code
t1 = int2float(60) t2 = id3 * t1 t3 = id2 + t2 id1 = t3

15. Code Optimization Attempts to improve the intermediate code
Better: faster, shorter code, or code that consumes less power (Chap. 8 -)
E.g.
t1 = id3 * 60.0 id1 = id2 + t1

16. Code Generation
Mapping intermediate representation of the source program into the target language (Chap. 8)
Machine code: register/memory location assignments
E.g.
LDF R2, id3 MULF R2, R2, #60.0 LDF R1, id2 ADDF R1, R1, R2 STF id1, R1

17. Symbol Table Management
To record the variable names and collect information about various attributes of each name
Storage, type, scope
Number and types of arguments, method of argument passing, and the type returned

18. Grouping of Phases into Passes
Front-end pass
Lexical analysis, syntax analysis, semantic analysis, intermediate code generation
(Optional) Code optimization pass
Back-end pass
Code generation

19. Outline Language Processors The Structure of a Compiler
The Evolution of Programming Languages
Why study principle of programming languages

20. The Evolution of Programming Languages
Machine language: 1940’s
Assembly language: early 1950’s
Higher-level languages: late 1950’s
Fortran: scientific computation
Cobol: business data processing
Lisp: symbolic computation
Today: thousands of programming languages

21. Classification of Programming Languages – by Generation
First generation: machine languages
Second generation: assembly languages
Third generation: high-level languages
Fortran, Cobol, Lisp, C, C++, C#, Java
Fourth generation: specific application
NOMAD, SQL, Postscript
Fifth generation: logic- and constraint-based
Prolog, OPS5

22. Classification of Programming Languages - by Functions
Imperative: how
C, C++, C#, Java
Declarative: what
ML, Haskell, Prolog
von Neumann language
Fortran, C
Object-oriented language
Simula 67, Smalltalk, C++, C#, Java, Ruby
Scripting languages
Awk, JavaScript, Perl, PHP, Python, Ruby, Tcl

23. Outline Language Processors The Structure of a Compiler
The Evolution of Programming Languages
Why study principle of programming languages

24. Why study principle of programming languages?
Become a better software engineer
Understand how to use language features
Appreciate implementation issues
Better background for language selection
Familiar with range of languages
Understand issues / advantages / disadvantages
Better able to learn languages
You might need to know a lot

25. Why study programming languages?
Better understanding of implementation issues
How is “this feature” implemented?
Why does “this part” run so slowly?
Better able to design languages
Those who ignore history are bound to repeat it…

26. End of Chapter 1