CS4200 2019 Lecture 1: Introduction
1 like1,066 views
This document provides an overview of the CS4200 Compiler Construction course at TU Delft. It discusses the course organization, structure, and assessment. The course is split into two parts - CS4200-A which covers concepts and techniques through lectures, papers, and homework assignments, and CS4200-B which involves building a compiler for a subset of Java as a semester-long project. Students will use the Spoofax language workbench to implement their compiler and will submit assignments through a private GitLab repository.
![Etymology
!29
Latin
Etymology
From con- (âwith, togetherâ) + pÄ«lĆ (âram downâ).
Pronunciation
âą (Classical) IPA(key): /komËpiË.loË/, [kÉmËpiË.É«oË]
Verb
compÄ«lĆ (present inïŹnitive compÄ«lÄre, perfect active compÄ«lÄvÄ«, supine
compÄ«lÄtum); ïŹrst conjugation
1. I snatch together and carry oïŹ; plunder, pillage, rob, steal.
https://en.wiktionary.org/wiki/compilo#Latin](https://image.slidesharecdn.com/cs4200-2019-1-introduction-190905113639/85/CS4200-2019-Lecture-1-Introduction-29-320.jpg)
![Etymology
!31
The ïŹrst compiler was written by Grace Hopper, in 1952, for the A-0
System language. The term compiler was coined by Hopper.[1][2] The A-0
functioned more as a loader or linker than the modern notion of a compiler.
https://en.wikipedia.org/wiki/History_of_compiler_construction](https://image.slidesharecdn.com/cs4200-2019-1-introduction-190905113639/85/CS4200-2019-Lecture-1-Introduction-31-320.jpg)
![From Calling Conventions to Procedures
!54
f(e1)
calc:
push eBP ; save old frame pointer
mov eBP,eSP ; get new frame pointer
sub eSP,localsize ; reserve place for locals
.
. ; perform calculations, leave result in AX
.
mov eSP,eBP ; free space for locals
pop eBP ; restore old frame pointer
ret paramsize ; free parameter space and return
push eAX ; pass some register result
push byte[eBP+20] ; pass some memory variable (FASM/TASM syntax)
push 3 ; pass some constant
call calc ; the returned result is now in eAX
def f(x)={ ... }
http://en.wikipedia.org/wiki/Calling_convention
function deïŹnition and call in Scala](https://image.slidesharecdn.com/cs4200-2019-1-introduction-190905113639/85/CS4200-2019-Lecture-1-Introduction-54-320.jpg)
![From Malloc to Garbage Collection
!55
/* Allocate space for an array with ten elements of type int. */
int *ptr = (int*)malloc(10 * sizeof (int));
if (ptr == NULL) {
/* Memory could not be allocated, the program
should handle the error here as appropriate. */
} else {
/* Allocation succeeded. Do something. */
free(ptr); /* We are done with the int objects,
and free the associated pointer. */
ptr = NULL; /* The pointer must not be used again,
unless re-assigned to using malloc again. */
}
http://en.wikipedia.org/wiki/Malloc
int [] = new int[10];
/* use it; gc will clean up (hopefully) */](https://image.slidesharecdn.com/cs4200-2019-1-introduction-190905113639/85/CS4200-2019-Lecture-1-Introduction-55-320.jpg)
![Calc: Syntax DeïŹnition
!78
context-free syntax // numbers
Exp = <(<Exp>)> {bracket}
Exp.Num = NUM
Exp.Min = <-<Exp>>
Exp.Pow = <<Exp> ^ <Exp>> {right}
Exp.Mul = <<Exp> * <Exp>> {left}
Exp.Div = <<Exp> / <Exp>> {left}
Exp.Sub = <<Exp> - <Exp>> {left, prefer}
Exp.Add = <<Exp> + <Exp>> {left}
Exp.Eq = <<Exp> == <Exp>> {non-assoc}
Exp.Neq = <<Exp> != <Exp>> {non-assoc}
Exp.Gt = [[Exp] > [Exp]] {non-assoc}
Exp.Lt = [[Exp] < [Exp]] {non-assoc}
context-free syntax // variables and functions
Exp.Var = ID
Exp.Let = <
let <ID> = <Exp> in
<Exp>
>
Exp.Fun = < <ID+> . <Exp>>
Exp.App = <<Exp> <Exp>> {left}](https://image.slidesharecdn.com/cs4200-2019-1-introduction-190905113639/85/CS4200-2019-Lecture-1-Introduction-78-320.jpg)
![Calc: Type System
!79
rules // numbers
[[ Num(x) ^ (s) : NumT() ]].
[[ Pow(e1, e2) ^ (s) : NumT() ]] :=
[[ e1 ^ (s) : NumT() ]],
[[ e2 ^ (s) : NumT() ]].
[[ Mul(e1, e2) ^ (s) : NumT() ]] :=
[[ e1 ^ (s) : NumT() ]],
[[ e2 ^ (s) : NumT() ]].
[[ Add(e1, e2) ^ (s) : NumT() ]] :=
[[ e1 ^ (s) : NumT() ]],
[[ e2 ^ (s) : NumT() ]].
rules // variables and functions
[[ Var(x) ^ (s) : ty ]] :=
{x} -> s, {x} |-> d, d : ty.
[[ Let(x, e1, e2) ^ (s) : ty2 ]] :=
new s_let, {x} <- s_let, {x} : ty, s_let -P-> s,
[[ e1 ^ (s) : ty ]],
[[ e2 ^ (s_let) : ty2 ]].
[[ Fun([x], e) ^ (s) : FunT(ty1, ty2) ]] :=
new s_fun, {x} <- s_fun, {x} : ty1, s_fun -P-> s,
[[ e ^ (s_fun) : ty2 ]].
[[ App(e1, e2) ^ (s) : ty_res ]] :=
[[ e1 ^ (s) : ty_fun ]],
[[ e2 ^ (s) : ty_arg ]],
FunT(ty_arg, ty_res) instOf ty_fun.](https://image.slidesharecdn.com/cs4200-2019-1-introduction-190905113639/85/CS4200-2019-Lecture-1-Introduction-79-320.jpg)
![Calc: Dynamic Semantics
!80
rules // numbers
Num(n) --> NumV(parseB(n))
Pow(NumV(i), NumV(j)) --> NumV(powB(i, j))
Mul(NumV(i), NumV(j)) --> NumV(mulB(i, j))
Div(NumV(i), NumV(j)) --> NumV(divB(i, j))
Sub(NumV(i), NumV(j)) --> NumV(subB(i, j))
Add(NumV(i), NumV(j)) --> NumV(addB(i, j))
Lt(NumV(i), NumV(j)) --> BoolV(ltB(i, j))
Eq(NumV(i), NumV(j)) --> BoolV(eqB(i, j))
rules // variables and functions
E |- Var(x) --> E[x]
E |- Fun([x], e) --> ClosV(x, e, E)
E |- Let(x, v1, e2) --> v
where E {x |--> v1, E} |- e2 --> v
App(ClosV(x, e, E), v_arg) --> v
where E {x |--> v_arg, E} |- e --> v](https://image.slidesharecdn.com/cs4200-2019-1-introduction-190905113639/85/CS4200-2019-Lecture-1-Introduction-80-320.jpg)
![Calc: Code Generation
!81
rules // numbers
exp-to-java : Num(v) -> $[BigDecimal.valueOf([v])]
exp-to-java :
Add(e1, e2) -> $[[je1].add([je2])]
with
<exp-to-java> e1 => je1
; <exp-to-java> e2 => je2
exp-to-java :
Sub(e1, e2) -> $[[je1].subtract([je2])]
with
<exp-to-java> e1 => je1
; <exp-to-java> e2 => je2
rules // variables and functions
exp-to-java : Var(x) -> $[[x]]
exp-to-java :
Let(x, e1, e2) -> $[(([jty]) [x] -> [je2]).apply([je1])]
with
<nabl2-get-ast-type> e1 => ty1
; <nabl2-get-ast-type> e2 => ty2
; <type-to-java> FunT(ty1, ty2) => jty
; <exp-to-java> e1 => je1
; <exp-to-java> e2 => je2
exp-to-java :
f@Fun([x], e) -> $[(([jty]) [x] -> [je])]
with
<nabl2-get-ast-type> f => ty
; <type-to-java> ty => jty
; <exp-to-java> e => je
exp-to-java:
App(e1, e2) -> $[[e1].apply([e2])]
with
<exp-to-java> e1 => je1
; <exp-to-java> e2 => je2](https://image.slidesharecdn.com/cs4200-2019-1-introduction-190905113639/85/CS4200-2019-Lecture-1-Introduction-81-320.jpg)
CS4200 2019 Lecture 1: Introduction
- 1. CS4200 Compiler Construction Eelco Visser TU Delft September 2019 Lecture 1: What is a Compiler? !1
- 2. Course organization - Course team - Study material - Project Introduction - What is a compiler? - Why do we need compilers? - What do we study in this course? This Lecture !2
- 5. !5 No use of electronic devices during lectures
- 6. !6 Slack #spoofax-users channel for questions about Spoofax => send me email
- 9. CS4200-A: Compiler Construction (5 ECTS) - Study concepts and techniques - Lectures - Papers - Homework assignments: apply to small problems - Assessment: exams in November and January CS4200-B: Compiler Construction Project (5 ECTS) - Build a compiler and programming environment for a subset of Java - Assessment: code submitted for lab assignments CS4200: Two Courses !9
- 10. CS4200-A: Compiler Construction Concepts and Techniques 10
- 11. !11
- 13. WebLab for Homework, Exams, Grade Registration !13 https://weblab.tudelft.nl/cs4200/2019-2020/
- 14. Sign in to WebLab using âSingle Sign On for TU Delftâ !14
- 15. Enroll for Course CS4200 in WebLab !15 https://weblab.tudelft.nl/cs4200/2019-2020/
- 17. CS4200-B: Compiler Construction Project Building a compiler and IDE for MiniJava 17
- 19. Download Special Spoofax Version for the Course! !19 https://tudelft-cs4200-2019.github.io/documentation/spoofax.html
- 20. !20
- 21. !21
- 23. Private GitLab repository per student - https://gitlab.ewi.tudelft.nl/CS4200-B/2019-2020/ Submit by Merge Request Multiple submissions possible Limited early feedback provided Details online: - https://tudelft-cs4200-2019.github.io/project/#submission Assignment Submission !23
- 25. To pass you need to meet all of these criteria: - Each assignment grade >= 4 - Each milestone average >= 5 - Overall average >= 6 Project grades !25
- 26. Project Grades and Registration !26 https://weblab.tudelft.nl/cs4200/2019-2020/assignment/20207/info
- 27. Lab on Fridays. 13:45-17:45 DW-PC 2 Walk-in hours on Wednesdays. 9:30-11:00 E4.420 (Building 28) Contact hours !27 https://tudelft-cs4200-2018.github.io/team/
- 28. What is a Compiler? 28
- 29. Etymology !29 Latin Etymology From con- (âwith, togetherâ) + pÄ«lĆ (âram downâ). Pronunciation âą (Classical) IPA(key): /komËpiË.loË/, [kÉmËpiË.É«oË] Verb compÄ«lĆ (present inïŹnitive compÄ«lÄre, perfect active compÄ«lÄvÄ«, supine compÄ«lÄtum); ïŹrst conjugation 1. I snatch together and carry oïŹ; plunder, pillage, rob, steal. https://en.wiktionary.org/wiki/compilo#Latin
- 30. Dictionary !30 English Verb compile (third-person singular simple present compiles, present participle compiling, simple past and past participle compiled) 1. (transitive) To put together; to assemble; to make by gathering things from various sources. Samuel Johnson compiled one of the most inïŹuential dictionaries of the English language. 2. (obsolete) To construct, build. quotations 3. (transitive, programming) To use a compiler to process source code and produce executable code. After I compile this program I'll run it and see if it works. 4. (intransitive, programming) To be successfully processed by a compiler into executable code. There must be an error in my source code because it won't compile. 5. (obsolete, transitive) To contain or comprise. quotations 6. (obsolete) To write; to compose. https://en.wiktionary.org/wiki/compile
- 31. Etymology !31 The ïŹrst compiler was written by Grace Hopper, in 1952, for the A-0 System language. The term compiler was coined by Hopper.[1][2] The A-0 functioned more as a loader or linker than the modern notion of a compiler. https://en.wikipedia.org/wiki/History_of_compiler_construction
- 32. Compiling = Translating !32 High-Level Language compiler Low-Level Language A compiler translates high-level programs to low-level programs
- 33. Compiling = Translating !33 C gcc X86 GCC translates C programs to object code for X86 (and other architectures)
- 34. Compiling = Translating !34 Java javac JVM bytecode A Java compiler translates Java programs to bytecode instructions for Java Virtual Machine
- 35. Architecture: Multi-Pass Compiler !35 Java Type Check JVM bytecode A modern compiler typically consists of sequence of stages or passes Parse CodeGenOptimize
- 36. Intermediate Representations !36 Java Type Check JVM bytecode A compiler is a composition of a series of translations between intermediate languages Parse CodeGenOptimize Abstract Syntax Tree Annotated AST Transformed AST
- 37. Compiler Components !37 Java Type Check JVM bytecode Parse CodeGenOptimize Abstract Syntax Tree Annotated AST Transformed AST Parser âąReads in program text âąChecks that it complies with the syntactic rules of the language âąProduces an abstract syntax tree âąRepresents the underlying (syntactic) structure of the program.
- 38. Compiler Components !38 Java Type Check JVM bytecode Parse CodeGenOptimize Abstract Syntax Tree Annotated AST Transformed AST Type checker âąConsumes an abstract syntax tree âąChecks that the program complies with the static semantic rules of the language âąPerforms name analysis, relating uses of names to declarations of names âąChecks that the types of arguments of operations are consistent with their speciïŹcation
- 39. Compiler Components !39 Java Type Check JVM bytecode Parse CodeGenOptimize Abstract Syntax Tree Annotated AST Transformed AST Optimizer âąConsumes a (typed) abstract syntax tree âąApplies transformations that improve the program in various dimensions ⣠execution time ⣠memory consumption ⣠energy consumption.
- 40. Compiler Components !40 Java Type Check JVM bytecode Parse CodeGenOptimize Abstract Syntax Tree Annotated AST Transformed AST Code generator âąTransforms abstract syntax tree to instructions for a particular computer architecture âąaka instruction selection Register allocator âąAssigns physical registers to symbolic registers in the generated instructions
- 41. Back-EndFront-End Compiler = Front-end + Back-End !41 Java Type Check JVM bytecode A compiler can typically be divided in a front-end (analysis) and a back-end (synthesis) Parse CodeGenOptimize Annotated AST
- 42. Back-EndFront-End Compiler = Front-end + Back-End !42 C Type Check X86Parse CodeGenOptimizeLLVM A compiler can typically be divided in a front-end (analysis) and a back-end (synthesis)
- 43. Back-End Front-End Repurposing Back-End !43 C Type Check X86 Repurposing: reuse a back-end for a diïŹerent source language Parse CodeGenOptimizeLLVM Front-End C++ Type CheckParse
- 44. Back-EndFront-End Retargeting Compiler !44 C Type Check X86 Retargeting: compile to diïŹerent hardware architecture Parse CodeGenOptimize LLVM Back-End ArmCodeGenOptimize Front-End C++ Type CheckParse
- 45. Compiler - translates high-level programs to machine code for a computer Bytecode compiler - generates code for a virtual machine Just-in-time compiler - defers (some aspects of) compilation to run time Source-to-source compiler (transpiler) - translate between high-level languages Cross-compiler - runs on diïŹerent architecture than target architecture Types of Compilers (1) !45
- 46. Interpreter - directly executes a program (although prior to execution program is typically transformed) Hardware compiler - generate conïŹguration for FPGA or integrated circuit De-compiler - translates from low-level language to high-level language Types of Compilers (2) !46
- 47. What is a Compiler? !47 Java Type Check JVM bytecode Parse CodeGenOptimize Compiler Construction = Building Variants of Java? A bunch of components for translating programs
- 49. - fetch data from memory - store data in register - perform basic operation on data in register - fetch instruction from memory - update the program counter - etc. Programming = Instructing Computer !49
- 50. !50 "Computational thinking is the thought processes involved in formulating a problem and expressing its solution(s) in such a way that a computerâhuman or machineâcan eïŹectively carry out." Jeanette M. Wing. Computational Thinking BeneïŹts Society. In Social Issues in Computing. January 10, 2014. http://socialissues.cs.toronto.edu/index.html
- 52. !52 Intermediate Language linguistic abstraction | liNGËgwistik abËstrakSHÉn | noun 1. a programming language construct that captures a programming design pattern the linguistic abstraction saved a lot of programming eïŹort he introduced a linguistic abstraction for page navigation in web programming 2. the process of introducing linguistic abstractions linguistic abstraction for name binding removed the algorithmic encoding of name resolution Problem Domain Solution Domain
- 53. From Instructions to Expressions !53 mov &a, &c add &b, &c mov &a, &t1 sub &b, &t1 and &t1,&c Source: http://sites.google.com/site/arch1utep/home/course_outline/translating-complex-expressions-into-assembly-language-using-expression-trees c = a c += b t1 = a t1 -= b c &= t1 c = (a + b) & (a - b)
- 54. From Calling Conventions to Procedures !54 f(e1) calc: push eBP ; save old frame pointer mov eBP,eSP ; get new frame pointer sub eSP,localsize ; reserve place for locals . . ; perform calculations, leave result in AX . mov eSP,eBP ; free space for locals pop eBP ; restore old frame pointer ret paramsize ; free parameter space and return push eAX ; pass some register result push byte[eBP+20] ; pass some memory variable (FASM/TASM syntax) push 3 ; pass some constant call calc ; the returned result is now in eAX def f(x)={ ... } http://en.wikipedia.org/wiki/Calling_convention function deïŹnition and call in Scala
- 55. From Malloc to Garbage Collection !55 /* Allocate space for an array with ten elements of type int. */ int *ptr = (int*)malloc(10 * sizeof (int)); if (ptr == NULL) { /* Memory could not be allocated, the program should handle the error here as appropriate. */ } else { /* Allocation succeeded. Do something. */ free(ptr); /* We are done with the int objects, and free the associated pointer. */ ptr = NULL; /* The pointer must not be used again, unless re-assigned to using malloc again. */ } http://en.wikipedia.org/wiki/Malloc int [] = new int[10]; /* use it; gc will clean up (hopefully) */
- 56. Linguistic Abstraction !56 identify pattern use new abstraction language A language B design abstraction
- 57. Compiler Automates Work of Programmer !57 Problem Domain Solution Domain General- Purpose Language CompilerProgrammer Compilers for modern high-level languages - Reduce the gap between problem domain and program - Support programming in terms of computational concepts instead of machine concepts - Abstract from hardware architecture (portability) - Protect against a range of common programming errors
- 59. - Systems programming - Embedded software - Web programming - Enterprise software - Database programming - Distributed programming - Data analytics - ... Domains of Computation !59 Problem Domain Solution Domain General- Purpose Language
- 60. !60 Problem Domain Solution Domain General- Purpose Language âA programming language is low level when its programs require attention to the irrelevantâ Alan J. Perlis. Epigrams on Programming. SIGPLAN Notices, 17(9):7-13, 1982.
- 61. !61 Solution Domain Problem Domain Domain-speciïŹc language (DSL) noun 1. a programming language that provides notation, analysis, veriïŹcation, and optimization specialized to an application domain 2. result of linguistic abstraction beyond general-purpose computation General- Purpose Language Domain- Specific Language
- 62. Domain Analysis - What are the features of the domain? Language Design - What are adequate linguistic abstractions? - Coverage: can language express everything in the domain? ⣠often the domain is unbounded; language design is making choice what to cover - Minimality: but not more ⣠allowing too much interferes with multi-purpose goal Semantics - What is the semantics of such deïŹnitions? - How can we verify the correctness / consistency of language deïŹnitions? Implementation - How do we derive eïŹcient language implementations from such deïŹnitions? Evaluation - Apply to new and existing languages to determine adequacy Language Design Methodology !62
- 64. !64 Solution Domain Problem Domain General- Purpose Language Domain- Specific Language Making programming languages is probably very expensive?
- 65. !65 General- Purpose Language Making programming languages is probably very expensive? Solution Domain Problem Domain General- Purpose Language Domain- Specific Language Language Design Compiler + Editor (IDE)
- 66. !66 Compiler + Editor (IDE) Meta-Linguistic Abstraction Language Design General- Purpose Language Declarative Meta Languages Solution Domain Problem Domain General- Purpose Language Domain- Specific Language Language Design Applying compiler construction to the domain of compiler construction
- 67. !67 Compiler + Editor (IDE) Language Design General- Purpose Language Declarative Meta Languages Solution Domain Problem Domain General- Purpose Language Language Design That also applies to the deïŹnition of (compilers for) general purpose languages
- 69. !69 Language Workbench Language Design Syntax DeïŹnition Static Semantics Dynamic Semantics Transforms Meta-DSLs Compiler + Editor (IDE)
- 70. !70 A Language Designerâs Workbench Language Design SDF3 Stratego Consistency Proof NaBL2 DynSem Responsive Editor (IDE) Tests Incremental Compiler Syntax DeïŹnition Static Semantics Dynamic Semantics Transforms
- 71. Objective - A workbench supporting design and implementation of programming languages Approach - Declarative multi-purpose domain-speciïŹc meta-languages Meta-Languages - Languages for deïŹning languages Domain-SpeciïŹc - Linguistic abstractions for domain of language deïŹnition (syntax, names, types, âŠ) Multi-Purpose - Derivation of interpreters, compilers, rich editors, documentation, and veriïŹcation from single source Declarative - Focus on what not how; avoid bias to particular purpose in language deïŹnition Declarative Language DeïŹnition !71
- 72. Representation - Standardized representation for <aspect> of programs - Independent of speciïŹc object language SpeciïŹcation Formalism - Language-speciïŹc declarative rules - Abstract from implementation concerns Language-Independent Interpretation - Formalism interpreted by language-independent algorithm - Multiple interpretations for diïŹerent purposes - Reuse between implementations of diïŹerent languages Separation of Concerns !72
- 73. SDF3: Syntax deïŹnition - context-free grammars + disambiguation + constructors + templates - derivation of parser, formatter, syntax highlighting, ⊠NaBL2 or Statix: Names & Types - name resolution with scope graphs - type checking/inference with constraints - derivation of name & type resolution algorithm Stratego: Program Transformation - term rewrite rules with programmable rewriting strategies - derivation of program transformation system FlowSpec: Data-Flow Analysis - extraction of control-ïŹow graph and speciïŹcation of data-ïŹow rules - derivation of data-ïŹow analysis engine DynSem: Dynamic Semantics - speciïŹcation of operational (natural) semantics - derivation of interpreter Meta-Languages in Spoofax Language Workbench !73
- 74. The Spoofax Language Workbench - Lennart C. L. Kats, Eelco Visser - OOPSLA 2010 A Language Designer's Workbench - A one-stop-shop for implementation and veriïŹcation of language designs - Eelco Visser, Guido Wachsmuth, Andrew P. Tolmach, Pierre Neron, Vlad A. Vergu, Augusto Passalaqua, GabriĂ«l D. P. Konat - Onward 2014 Literature !74
- 75. A Taste of Compiler Construction 75
- 76. Language DeïŹnition in Spoofax Language Workbench !76 SDF3: Syntax DeïŹnition NaBL2: Static Semantics DynSem: Dynamic Semantics Programming Environment+ + Stratego: Program Transformation+
- 77. Calc: A Little Calculator Language !77 rY = 0.017; // yearly interest rate Y = 30; // number of years P = 379,000; // principal N = Y * 12; // number of months c = if(rY == 0) // no interest P / N else let r = rY / 12 in let f = (1 + r) ^ N in (r * P * f) / (f - 1); c; // payment per month https://github.com/MetaBorgCube/metaborg-calc http://www.metaborg.org/en/latest/source/langdev/meta/lang/tour/index.html
- 78. Calc: Syntax DeïŹnition !78 context-free syntax // numbers Exp = <(<Exp>)> {bracket} Exp.Num = NUM Exp.Min = <-<Exp>> Exp.Pow = <<Exp> ^ <Exp>> {right} Exp.Mul = <<Exp> * <Exp>> {left} Exp.Div = <<Exp> / <Exp>> {left} Exp.Sub = <<Exp> - <Exp>> {left, prefer} Exp.Add = <<Exp> + <Exp>> {left} Exp.Eq = <<Exp> == <Exp>> {non-assoc} Exp.Neq = <<Exp> != <Exp>> {non-assoc} Exp.Gt = [[Exp] > [Exp]] {non-assoc} Exp.Lt = [[Exp] < [Exp]] {non-assoc} context-free syntax // variables and functions Exp.Var = ID Exp.Let = < let <ID> = <Exp> in <Exp> > Exp.Fun = < <ID+> . <Exp>> Exp.App = <<Exp> <Exp>> {left}
- 79. Calc: Type System !79 rules // numbers [[ Num(x) ^ (s) : NumT() ]]. [[ Pow(e1, e2) ^ (s) : NumT() ]] := [[ e1 ^ (s) : NumT() ]], [[ e2 ^ (s) : NumT() ]]. [[ Mul(e1, e2) ^ (s) : NumT() ]] := [[ e1 ^ (s) : NumT() ]], [[ e2 ^ (s) : NumT() ]]. [[ Add(e1, e2) ^ (s) : NumT() ]] := [[ e1 ^ (s) : NumT() ]], [[ e2 ^ (s) : NumT() ]]. rules // variables and functions [[ Var(x) ^ (s) : ty ]] := {x} -> s, {x} |-> d, d : ty. [[ Let(x, e1, e2) ^ (s) : ty2 ]] := new s_let, {x} <- s_let, {x} : ty, s_let -P-> s, [[ e1 ^ (s) : ty ]], [[ e2 ^ (s_let) : ty2 ]]. [[ Fun([x], e) ^ (s) : FunT(ty1, ty2) ]] := new s_fun, {x} <- s_fun, {x} : ty1, s_fun -P-> s, [[ e ^ (s_fun) : ty2 ]]. [[ App(e1, e2) ^ (s) : ty_res ]] := [[ e1 ^ (s) : ty_fun ]], [[ e2 ^ (s) : ty_arg ]], FunT(ty_arg, ty_res) instOf ty_fun.
- 80. Calc: Dynamic Semantics !80 rules // numbers Num(n) --> NumV(parseB(n)) Pow(NumV(i), NumV(j)) --> NumV(powB(i, j)) Mul(NumV(i), NumV(j)) --> NumV(mulB(i, j)) Div(NumV(i), NumV(j)) --> NumV(divB(i, j)) Sub(NumV(i), NumV(j)) --> NumV(subB(i, j)) Add(NumV(i), NumV(j)) --> NumV(addB(i, j)) Lt(NumV(i), NumV(j)) --> BoolV(ltB(i, j)) Eq(NumV(i), NumV(j)) --> BoolV(eqB(i, j)) rules // variables and functions E |- Var(x) --> E[x] E |- Fun([x], e) --> ClosV(x, e, E) E |- Let(x, v1, e2) --> v where E {x |--> v1, E} |- e2 --> v App(ClosV(x, e, E), v_arg) --> v where E {x |--> v_arg, E} |- e --> v
- 81. Calc: Code Generation !81 rules // numbers exp-to-java : Num(v) -> $[BigDecimal.valueOf([v])] exp-to-java : Add(e1, e2) -> $[[je1].add([je2])] with <exp-to-java> e1 => je1 ; <exp-to-java> e2 => je2 exp-to-java : Sub(e1, e2) -> $[[je1].subtract([je2])] with <exp-to-java> e1 => je1 ; <exp-to-java> e2 => je2 rules // variables and functions exp-to-java : Var(x) -> $[[x]] exp-to-java : Let(x, e1, e2) -> $[(([jty]) [x] -> [je2]).apply([je1])] with <nabl2-get-ast-type> e1 => ty1 ; <nabl2-get-ast-type> e2 => ty2 ; <type-to-java> FunT(ty1, ty2) => jty ; <exp-to-java> e1 => je1 ; <exp-to-java> e2 => je2 exp-to-java : f@Fun([x], e) -> $[(([jty]) [x] -> [je])] with <nabl2-get-ast-type> f => ty ; <type-to-java> ty => jty ; <exp-to-java> e => je exp-to-java: App(e1, e2) -> $[[e1].apply([e2])] with <exp-to-java> e1 => je1 ; <exp-to-java> e2 => je2
- 84. The Basis !84 Java Type Check JVM bytecode Parse CodeGenOptimize
- 85. !85 Compiler construction techniques are applicable in a wide range of software (development) applications
- 86. SpeciïŹc âą Understanding a speciïŹc compiler âą Understanding a programming language (MiniJava) âą Understanding a target machine (Java Virtual Machine) âą Understanding a compilation scheme (MiniJava to Byte Code) Architecture âą Understanding architecture of compilers âą Understanding (concepts of) programming languages âą Understanding compilation techniques Domains âą Understanding (principles of) syntax deïŹnition and parsing âą Understanding (principles of) static semantics and type checking âą Understanding (principles of) dynamic semantics and interpretation/code generation Meta âą Understanding meta-languages and their compilation Levels of Understanding Compilers !86
- 87. Syntax âą concrete syntax, abstract syntax âą context-free grammars âą derivations, ambiguity, disambiguation, associativity, priority âą parsing, parse trees, abstract syntax trees, terms âą pretty-printing âą parser generation âą syntactic editor services Transformation âą rewrite rules, rewrite strategies âą simpliïŹcation, desugaring Course Topics !87 Statics âą static semantics and type checking ⣠name binding, name resolution, scope graphs ⣠types, type checking, type inference, subtyping ⣠uniïŹcation, constraints âą semantic editor services âą data-ïŹow analysis ⣠control-ïŹow, data-ïŹow ⣠monotone frameworks, worklist algorithm Dynamics âą dynamic semantics and interpreters âą operational semantics, program execution âą virtual machines, assembly code, byte code âą code generation âą memory management, garbage collection
- 88. Q1 âą What is a compiler? (Introduction) âą Syntax DeïŹnition âą Parsing âą Syntactic Editor Services âą Transformation âą Static Semantics & Name Resolution âą Type Checking âą SpeciïŹcation with Statix (or NaBL2) âą Constraint Resolution Lectures (Tentative) !88 Lectures: Thursday, 10:45 in Lecture Hall Boole at EWI Lectures: Wednesday, 15:45 in Lecture Hall Boole at EWI Q2 âą Data-Flow Analysis âą Monotone Frameworks âą Virtual Machines âą Code Generation âą Interpreters âą Memory Management âą Applications âą Reserve âą Overview
- 90. This award winning paper describes the design of the Spoofax Language Workbench. It provides an alternative architecture for programming languages tooling from the compiler pipeline discussed in this lecture. Read the paper and make the homework assignments on WebLab. Note that the details of some of the technologies in Spoofax have changed since the publication. The https://doi.org/10.1145/1932682.1869497
- 91. Assignment Read this paper in preparation for Lecture 2 http://swerl.tudelft.nl/twiki/pub/Main/TechnicalReports/TUD-SERG-2010-019.pdf https://doi.org/10.1145/1932682.1869535
- 92. Next Lecture 92
- 93. Next: Syntax DeïŹnition !93 Lecture: Friday, 13:45 in Lecture Hall Pi at EWI Java Type Check JVM bytecode Parse CodeGenOptimize Specification of syntax definition from which we can derive parsers