Chapter 1. Introduction

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 Target Program input output

5. An interpreter • Much slower program execution • Better error diagnostics Interpreter 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 library filesrelocatable object files Linker/Loader 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 SymbolTable 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 * t1t3 = id2 + t2id1 = 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.0id1 = 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, id3MULF R2, R2, #60.0LDF R1, id2ADDF R1, R1, R2STF 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. Impacts on Compilers • To translate and support new language features • To take advantage of new hardware capabilities • To promote the use of high-level languages by minimizing the execution overhead • To make high-performance computer architectures effective on users’ applications • To evaluate architectural concepts

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

25. 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

26. 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…

27. End of Chapter 1