Programming Languages and Compilers CS 421 Elsa L
- Slides: 39
Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http: //courses. engr. illinois. edu/cs 421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 3/11/2021 1
Background for Unification n n Terms made from constructors and variables (for the simple first order case) Constructors may be applied to arguments (other terms) to make new terms Variables and constructors with no arguments are base cases Constructors applied to different number of arguments (arity) considered different Substitution of terms for variables 3/11/2021 2
Simple Implementation Background type term = Variable of string | Const of (string * term list) let rec subst var_name residue term = match term with Variable name -> if var_name = name then residue else term | Const (c, tys) -> Const (c, List. map (subst var_name residue) tys); ; 3/11/2021 3
Unification Problem Given a set of pairs of terms (“equations”) {(s 1, t 1), (s 2, t 2), …, (sn, tn)} (the unification problem) does there exist a substitution (the unification solution) of terms for variables such that (si) = (ti), for all i = 1, …, n? 3/11/2021 4
Uses for Unification Type Inference and type checking n Pattern matching as in OCAML n n Can use a simplified version of algorithm Logic Programming - Prolog n Simple parsing n 3/11/2021 5
Unification Algorithm n n n Let S = {(s 1, t 1), (s 2, t 2), …, (sn, tn)} be a unification problem. Case S = { }: Unif(S) = Identity function (i. e. , no substitution) Case S = {(s, t)} S’: Four main steps 3/11/2021 6
Unification Algorithm n n n Delete: if s = t (they are the same term) then Unif(S) = Unif(S’) Decompose: if s = f(q 1, … , qm) and t =f(r 1, … , rm) (same f, same m!), then Unif(S) = Unif({(q 1, r 1), …, (qm, rm)} S’) Orient: if t = x is a variable, and s is not a variable, Unif(S) = Unif ({(x, s)} S’) 3/11/2021 7
Unification Algorithm n Eliminate: if s = x is a variable, and x does not occur in t (the occurs check), then Let = x | t n Let = Unif( (S’)) n Unif(S) = {x | (t)} o n n 3/11/2021 Note: {x | a} o {y | b} = {y | ({x | a}(b))} o {x | a} if y not in a 8
Tricks for Efficient Unification Don’t return substitution, rather do it incrementally n Make substitution be constant time n Requires implementation of terms to use mutable structures (or possibly lazy structures) n We won’t discuss these n 3/11/2021 9
Example n x, y, z variables, f, g constructors n S = {(f(x), f(g(y, z))), (g(y, f(y)), x)} 3/11/2021 10
Example n x, y, z variables, f, g constructors S is nonempty n S = {(f(x), f(g(y, z))), (g(y, f(y)), x)} n 3/11/2021 11
Example n x, y, z variables, f, g constructors Pick a pair: (g(y, f(y)), x) n S = {(f(x), f(g(y, z))), (g(y, f(y)), x)} n 3/11/2021 12
Example n n n x, y, z variables, f, g constructors Pick a pair: (g(y, f(y))), x) Orient: (x, g(y, f(y))) S = {(f(x), f(g(y, z))), (g(y, f(y)), x)} -> {(f(x), f(g(y, z))), (x, g(y, f(y)))} 3/11/2021 13
Example n x, y, z variables, f, g constructors n S -> {(f(x), f(g(y, z))), (x, g(y, f(y)))} 3/11/2021 14
Example n x, y, z variables, f, g constructors Pick a pair: (f(x), f(g(y, z))) n S -> {(f(x), f(g(y, z))), (x, g(y, f(y)))} n 3/11/2021 15
Example n n n x, y, z variables, f, g constructors Pick a pair: (f(x), f(g(y, z))) Decompose: (x, g(y, z)) S -> {(f(x), f(g(y, z))), (x, g(y, f(y)))} -> {(x, g(y, z)), (x, g(y, f(y)))} 3/11/2021 16
Example n x, y, z variables, f, g constructors Pick a pair: (x, g(y, f(y))) Substitute: {x |-> g(y, f(y))} S -> {(x, g(y, z)), (x, g(y, f(y)))} -> {(g(y, f(y)), g(y, z))} n With {x |-> g(y, f(y))} n n 3/11/2021 17
Example n x, y, z variables, f, g constructors Pick a pair: (g(y, f(y)), g(y, z)) n S -> {(g(y, f(y)), g(y, z))} n With {x | g(y, f(y))} 3/11/2021 18
Example n n n x, y, z variables, f, g constructors Pick a pair: (g(y, f(y)), g(y, z)) Decompose: (y, y) and (f(y), z) S -> {(g(y, f(y)), g(y, z))} -> {(y, y), (f(y), z)} With {x | g(y, f(y))} 3/11/2021 19
Example n x, y, z variables, f, g constructors Pick a pair: (y, y) n S -> {(y, y), (f(y), z)} n With {x | g(y, f(y))} 3/11/2021 20
Example n n n x, y, z variables, f, g constructors Pick a pair: (y, y) Delete S -> {(y, y), (f(y), z)} -> {(f(y), z)} With {x | g(y, f(y))} 3/11/2021 21
Example n x, y, z variables, f, g constructors Pick a pair: (f(y), z) n S -> {(f(y), z)} n With {x | g(y, f(y))} 3/11/2021 22
Example n n n x, y, z variables, f, g constructors Pick a pair: (f(y), z) Orient: (z, f(y)) S -> {(f(y), z)} -> {(z, f(y))} With {x | g(y, f(y))} 3/11/2021 23
Example n x, y, z variables, f, g constructors Pick a pair: (z, f(y)) n S -> {(z, f(y))} n With {x | g(y, f(y))} 3/11/2021 24
Example n n n x, y, z variables, f, g constructors Pick a pair: (z, f(y)) Eliminate: {z|-> f(y)} S -> {(z, f(y))} -> { } With {x | {z | f(y)} (g(y, f(y))) } o {z | f(y)} 3/11/2021 25
Example n n n x, y, z variables, f, g constructors Pick a pair: (z, f(y)) Eliminate: {z|-> f(y)} S -> {(z, f(y))} -> { } With {x | g(y, f(y))} o {(z | f(y))} 3/11/2021 26
Example S = {(f(x), f(g(y, z))), (g(y, f(y)), x)} Solved by {x | g(y, f(y))} o {(z | f(y))} f(g(y, f(y))) = f(g(y, f(y))) x z and g(y, f(y)) = g(y, f(y)) x 3/11/2021 27
Example of Failure: Decompose n n n n S = {(f(x, g(y)), f(h(y), x))} Decompose: (f(x, g(y)), f(h(y), x)) S -> {(x, h(y)), (g(y), x)} Orient: (g(y), x) S -> {(x, h(y)), (x, g(y))} Eliminate: (x, h(y)) S -> {(h(y), g(y))} with {x | h(y)} No rule to apply! Decompose fails! 3/11/2021 28
Example of Failure: Occurs Check n n n S = {(f(x, g(x)), f(h(x), x))} Decompose: (f(x, g(x)), f(h(x), x)) S -> {(x, h(x)), (g(x), x)} Orient: (g(y), x) S -> {(x, h(x)), (x, g(x))} No rules apply. 3/11/2021 29
Major Phases of a Compiler Optimized IR Source Program Relocatable Lex Instruction Object Code Selection Tokens Linker Parse Unoptimized Machine. Abstract Syntax Specific Assembly Language Machine Semantic Code Optimize Analysis Optimized Machine-Specific Symbol Table Assembly Language Translate Emit code Intermediate Assembly Language Representation Assembler Modified from “Modern Compiler Implementation in ML”, by Andrew Appel
Meta-discourse n n n Language Syntax and Semantics Syntax - Regular Expressions, DFSAs and NDFSAs - Grammars Semantics - Natural Semantics - Transition Semantics 3/11/2021 31
Language Syntax n n n Syntax is the description of which strings of symbols are meaningful expressions in a language It takes more than syntax to understand a language; need meaning (semantics) too Syntax is the entry point 3/11/2021 32
Syntax of English Language n Pattern 1 n Pattern 2 3/11/2021 33
Elements of Syntax n n n n Character set – previously always ASCII, now often 64 character sets Keywords – usually reserved Special constants – cannot be assigned to Identifiers – can be assigned to Operator symbols Delimiters (parenthesis, braces, brackets) Blanks (aka white space) 3/11/2021 34
Elements of Syntax n Expressions if. . . then begin. . . ; . . . end else begin. . . ; . . . end n Type expressions typexpr 1 -> typexpr 2 n Declarations (in functional languages) let pattern 1 = expr 1 in expr n Statements (in imperative languages) a = b + c n Subprograms let pattern 1 = let rec inner = … in expr 3/11/2021 35
Elements of Syntax Modules n Interfaces n Classes (for object-oriented languages) n 3/11/2021 36
Lexing and Parsing n Converting strings to abstract syntax trees done in two phases n Lexing: Converting string (or streams of characters) into lists (or streams) of tokens (the “words” of the language) n n Specification Technique: Regular Expressions Parsing: Convert a list of tokens into an abstract syntax tree n 3/11/2021 Specification Technique: BNF Grammars 37
Formal Language Descriptions n n n Regular expressions, regular grammars, finite state automata Context-free grammars, BNF grammars, syntax diagrams Whole family more of grammars and automata – covered in automata theory 3/11/2021 38
Grammars n n Grammars are formal descriptions of which strings over a given character set are in a particular language Language designers write grammar Language implementers use grammar to know what programs to accept Language users use grammar to know how to write legitimate programs 3/11/2021 39
- Cs 421 programming languages and compilers
- Cs 421 uiuc
- Pros and cons of compilers and interpreters
- Finding and understanding bugs in c compilers
- Compilers: principles, techniques, and tools
- Compilers and interpreters are themselves
- Real-time systems and programming languages
- Advantages and disadvantages of system software
- Real-time systems and programming languages
- Binarymove c++
- Cousins of compiler
- Crafting a compiler
- Function of compiler
- Front end in compiler design
- Real time example of multithreading in java
- Cxc it
- Introduction to programming languages
- Plc programming languages
- Joey paquet
- Imperative programming languages
- Alternative programming languages
- Strongly typed vs weakly typed
- Transmission programming languages
- Cse 340 principles of programming languages
- Integral data type is
- Xenia programming languages
- Mainstream programming languages
- Vineeth kashyap
- Programming languages
- Programming languages
- Programming languages
- Programming languages
- Language
- Brief history of programming languages
- Taxonomy of programming languages
- Xkcd functional programming
- If programming languages were cars
- Reasons for studying concepts of programming languages
- Cornell programming languages
- Low level programming language