Eelco Visser, profile picture
Uploaded byEelco Visser
PDF, PPTX947 views

Term Rewriting

This document discusses term rewriting and provides examples of how rewrite rules can be used to transform terms. Key points include: - Rewrite rules define pattern matching and substitution to transform terms from a left-hand side to a right-hand side. - Examples show desugaring language constructs like if-then statements, constant folding arithmetic expressions, and mapping/zipping lists with strategies as parameters to rules. - Terms can represent programming language syntax and semantics domains. Signatures define the structure of terms. - Rewriting systems provide a declarative way to define program transformations and semantic definitions through rewrite rules and strategies.

Embed presentation

Download as PDF, PPTX
1 / 142
2 / 142
3 / 142
4 / 142
5 / 142
6 / 142
7 / 142
8 / 142
9 / 142
10 / 142
11 / 142
12 / 142
13 / 142
14 / 142
15 / 142
16 / 142
17 / 142
18 / 142
19 / 142
20 / 142
21 / 142
22 / 142
23 / 142
24 / 142
25 / 142
26 / 142
27 / 142
28 / 142
29 / 142
30 / 142
31 / 142
32 / 142
33 / 142
34 / 142
35 / 142
36 / 142
37 / 142
38 / 142
39 / 142
40 / 142
41 / 142
42 / 142
43 / 142
44 / 142
45 / 142
46 / 142
47 / 142
48 / 142
49 / 142
50 / 142
51 / 142
52 / 142
53 / 142
54 / 142
55 / 142
56 / 142
57 / 142
58 / 142
59 / 142
60 / 142
61 / 142
62 / 142
63 / 142
64 / 142
65 / 142
66 / 142
67 / 142
68 / 142
69 / 142
70 / 142
71 / 142
72 / 142
73 / 142
74 / 142
75 / 142
76 / 142
77 / 142
78 / 142
79 / 142
80 / 142
81 / 142
82 / 142
83 / 142
84 / 142
85 / 142
86 / 142
87 / 142
88 / 142
89 / 142
90 / 142
91 / 142
92 / 142
93 / 142
94 / 142
95 / 142
96 / 142
97 / 142
98 / 142
99 / 142
100 / 142
101 / 142
102 / 142
103 / 142
104 / 142
105 / 142
106 / 142
107 / 142
108 / 142
109 / 142
110 / 142
111 / 142
112 / 142
113 / 142
114 / 142
115 / 142
116 / 142
117 / 142
118 / 142
119 / 142
120 / 142
121 / 142
122 / 142
123 / 142
124 / 142
125 / 142
126 / 142
127 / 142
128 / 142
129 / 142
130 / 142
131 / 142
132 / 142
133 / 142
134 / 142
135 / 142
136 / 142
137 / 142
138 / 142
139 / 142
140 / 142
141 / 142
142 / 142
IN4303 2015-2017 Compiler Construction Term Rewriting language specification Guido Wachsmuth, Eelco Visser
Software Languages 2 DynSem Stratego NaBL2 SDF3 ESV editor SPT tests syntax definition concrete syntax abstract syntax static semantics name binding type system dynamic semantics translation interpretation
Software Languages 3 DynSem Stratego NaBL2 SDF3 ESV editor SPT tests syntax definition concrete syntax abstract syntax static semantics name binding type system dynamic semantics translation interpretation
Software Languages 4 Language Software compiler construction
Software Languages 5 meta language facility
Software Languages 6 traditional compiler compilers manual implementation language implementation compile compiler
Software Languages 7 traditional compiler compilers compilation + compilation language implementation compile compiler language definition compile
Software Languages 8 traditional compiler compilers compilation + interpretation interpreter language definition compile language implementation
manual implementation Term Rewriting Spoofax Language Workbench Stratego • declarative DSL • domain: program transformation • means to manipulate ASTs • working on ATerms • compiles to Java (or C) Stratego in Spoofax • static analysis & error checking • code generation • semantic editor services 9
manual implementation Term Rewriting Spoofax Language Workbench Stratego • declarative DSL • domain: program transformation • means to manipulate ASTs • working on ATerms • compiles to Java (or C) Stratego in Spoofax • static analysis & error checking • code generation • semantic editor services 9 Note: static analysis is replaced by the higher-level NaBL2 language
concepts Term Rewriting Stratego signatures rewrite rules • transform term to term • left-hand side • pattern matching & variable binding • right-hand side • pattern instantiation & variable substitution rewrite strategies • algorithm for applying rewrite rules 10
example Term Rewriting Stratego module desugar imports include/Tiger operators strategies desugar-all = innermost(desugar) rules desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) 11
Software Languages 12 Terms
Term Rewriting Terms 13 Let( [ FunDec( "fact" , [FArg("n", Tp(Tid("int")))] , Tp(Tid("int")) , If( Lt(Var("n"), Int("1")) , Int("1") , Seq( [ Times( Var("n") , Call( Var("fact") , [Minus(Var("n"), Int("1"))] ) ) ] ) ) ) ] , [Call(Var("fact"), [Int("10")])] ) let function fact(n : int) : int = if n < 1 then 1 else (n * fact(n - 1)) in fact(10) end
Term Rewriting Syntax of Terms module Terms sorts Cons Term lexical syntax Cons = [a-zA-Z][a-zA-Z0-9]* context-free syntax Term.App = <<Cons>(<{Term ","}*>)> 14 Zero() Succ(Zero()) Cons(A(), Cons(B(), Nil()))
Term Rewriting Syntax of Terms module Terms sorts Cons Term lexical syntax Cons = [a-zA-Z][a-zA-Z0-9]* context-free syntax Term.App = <<Cons>(<{Term ","}*>)> Term.List = <[<{Term ","}*>]> Term.Tuple = <(<{Term ","}*>)> 15 Zero() Succ(Zero()) [A(), B()]
Term Rewriting Syntax of Terms module ATerms sorts Cons Term lexical syntax Cons = [a-zA-Z][a-zA-Z0-9]* Cons = String Int = [0-9]+ String = """ StringChar* """ StringChar = ~["n] StringChar = "" ["] context-free syntax Term.Str = <<String>> Term.Int = <<Int>> Term.App = <<Cons>(<{Term ","}*>)> Term.List = <[<{Term ","}*>]> Term.Tuple = <(<{Term ","}*>)> 16 0 1 [A(), B()] Var(“x”) Let( [ Decl(“x”, IntT()), Decl(“y”, BoolT()) ] , Eq(Var(“x”), Int(0)) )
Term Rewriting Syntax of A(nnotated)Terms module ATerms sorts Cons Term lexical syntax Cons = [a-zA-Z][a-zA-Z0-9]* // more lexical syntax omitted context-free syntax Term.Anno = <<PreTerm>{<{Term “,"}*>}> Term = <<PreTerm>> PreTerm.Str = <<String>> PreTerm.Int = <<Int>> PreTerm.App = <<Cons>(<{Term ","}*>)> PreTerm.List = <[<{Term ","}*>]> PreTerm.Tuple = <(<{Term ","}*>)> 17 Var(“x”){Type(IntT())}
Software Languages 18 Signatures
context-free syntax Exp.Uminus = [- [Exp]] Exp.Power = [[Exp] ** [Exp]] Exp.Times = [[Exp] * [Exp]] Exp.Divide = [[Exp] / [Exp]] Exp.Plus = [[Exp] + [Exp]] Exp.Minus = [[Exp] - [Exp]] Exp.CPlus = [[Exp] +i [Exp]] Exp.CMinus = [[Exp] -i [Exp]] Exp.Eq = [[Exp] = [Exp]] Exp.Neq = [[Exp] <> [Exp]] Exp.Gt = [[Exp] > [Exp]] Exp.Lt = [[Exp] < [Exp]] Exp.Geq = [[Exp] >= [Exp]] Exp.Leq = [[Exp] <= [Exp]] Exp.True = <true> Exp.False = <false> Exp.And = [[Exp] & [Exp]] Exp.Or = [[Exp] | [Exp]] Term Rewriting Signatures signature constructors Uminus : Exp -> Exp Power : Exp * Exp -> Exp Times : Exp * Exp -> Exp Divide : Exp * Exp -> Exp Plus : Exp * Exp -> Exp Minus : Exp * Exp -> Exp CPlus : Exp * Exp -> Exp CMinus : Exp * Exp -> Exp Eq : Exp * Exp -> Exp Neq : Exp * Exp -> Exp Gt : Exp * Exp -> Exp Lt : Exp * Exp -> Exp Geq : Exp * Exp -> Exp Leq : Exp * Exp -> Exp True : Exp False : Exp And : Exp * Exp -> Exp Or : Exp * Exp -> Exp 19
Software Languages 20 Rewrite Rules
Term Rewriting Desugaring if x then printint(x) 21 if x then printint(x) else ()
Term Rewriting Desugaring if x then printint(x) 21 if x then printint(x) else () IfThen( Var("x") , Call( "printint" , [Var("x")] ) ) IfThenElse( Var("x") , Call( "printint" , [Var("x")] ) , NoVal() )
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) Term Rewriting Desugaring if x then printint(x) 21 if x then printint(x) else () IfThen( Var("x") , Call( "printint" , [Var("x")] ) ) IfThenElse( Var("x") , Call( "printint" , [Var("x")] ) , NoVal() )
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) Term Rewriting Desugaring if x then printint(x) 21 if x then printint(x) else () IfThen( Var("x") , Call( "printint" , [Var("x")] ) ) IfThenElse( Var("x") , Call( "printint" , [Var("x")] ) , NoVal() ) pattern matching
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) Term Rewriting Desugaring if x then printint(x) 21 if x then printint(x) else () IfThen( Var("x") , Call( "printint" , [Var("x")] ) ) IfThenElse( Var("x") , Call( "printint" , [Var("x")] ) , NoVal() ) pattern matching e1 e2
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) Term Rewriting Desugaring if x then printint(x) 21 if x then printint(x) else () IfThen( Var("x") , Call( "printint" , [Var("x")] ) ) IfThenElse( Var("x") , Call( "printint" , [Var("x")] ) , NoVal() ) pattern matching pattern instantiation e1 e2
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) Term Rewriting Desugaring if x then printint(x) 21 if x then printint(x) else () IfThen( Var("x") , Call( "printint" , [Var("x")] ) ) IfThenElse( Var("x") , Call( "printint" , [Var("x")] ) , NoVal() ) pattern matching pattern instantiation e1 e2
desugar: Uminus(e) -> Bop(MINUS(), Int("0"), e) desugar: Plus(e1, e2) -> Bop(PLUS(), e1, e2) desugar: Minus(e1, e2) -> Bop(MINUS(), e1, e2) desugar: Times(e1, e2) -> Bop(MUL(), e1, e2) desugar: Divide(e1, e2) -> Bop(DIV(), e1, e2) desugar: Eq(e1, e2) -> Rop(EQ(), e1, e2) desugar: Neq(e1, e2) -> Rop(NE(), e1, e2) desugar: Leq(e1, e2) -> Rop(LE(), e1, e2) desugar: Lt(e1, e2) -> Rop(LT(), e1, e2) desugar: Geq(e1, e2) -> Rop(LE(), e2, e1) desugar: Gt(e1, e2) -> Rop(LT(), e2, e1) desugar: And(e1, e2) -> IfThenElse(e1, e2, Int("0")) desugar: Or(e1, e2) -> IfThenElse(e1, Int("1"), e2) Term Rewriting More Desugaring signature constructors PLUS: BinOp MINUS: BinOp MUL: BinOp DIV: BinOp EQ: RelOp NE: RelOp LE: RelOp LT: RelOp Bop: BinOp * Expr * Expr -> Expr Rop: RelOp * Expr * Expr -> Expr 22
Term Rewriting Constant Folding x := 21 + 21 + x 23 x := 42 + x
Term Rewriting Constant Folding x := 21 + 21 + x 23 x := 42 + x Assign( Var("x") , Plus( Plus( Int("21") , Int("21") ) , Var("x") ) ) Assign( Var("x") , Plus( Int("42") , Var("x") ) )
eval: Bop(PLUS(), Int(i1), Int(i2)) -> Int(i3) where <addS> (i1, i2) => i3 Term Rewriting Constant Folding x := 21 + 21 + x 23 x := 42 + x Assign( Var("x") , Plus( Plus( Int("21") , Int("21") ) , Var("x") ) ) Assign( Var("x") , Plus( Int("42") , Var("x") ) )
eval: Bop(PLUS(), Int(i1), Int(i2)) -> Int(<addS> (i1, i2)) eval: Bop(MINUS(), Int(i1), Int(i2)) -> Int(<subtS> (i1, i2)) eval: Bop(MUL(), Int(i1), Int(i2)) -> Int(<mulS> (i1, i2)) eval: Bop(DIV(), Int(i1), Int(i2)) -> Int(<divS> (i1, i2)) eval: Rop(EQ(), Int(i), Int(i)) -> Int("1") eval: Rop(EQ(), Int(i1), Int(i2)) -> Int("0") where not( <eq> (i1, i2) ) eval: Rop(NE(), Int(i), Int(i)) -> Int("0") eval: Rop(NE(), Int(i1), Int(i2)) -> Int("1") where not( <eq> (i1, i2) ) eval: Rop(LT(), Int(i1), Int(i2)) -> Int("1") where <ltS> (i1, i2) eval: Rop(LT(), Int(i1), Int(i2)) -> Int("0") where not( <ltS> (i1, i2) ) eval: Rop(LE(), Int(i1), Int(i2)) -> Int("1") where <leqS> (i1, i2) eval: Rop(LE(), Int(i1), Int(i2)) -> Int("0") where not( <leqS> (i1, i2)) Term Rewriting More Constant Folding 24
parameters Term Rewriting Rewrite Rules f(x,y|a,b): lhs -> rhs • strategy or rule parameters x,y • term parameters a,b • no matching f(|a,b): lhs -> rhs • optional strategy parameters f(x,y): lhs -> rhs • optional term parameters f: lhs -> rhs 25
example: map Term Rewriting Rules with Parameters 26 [ 1 , 2 , 3 ] [ 2 , 3 , 4 ] map(inc)
example: map Term Rewriting Rules with Parameters 26 [ 1 , 2 , 3 ] [ 2 , 3 , 4 ] map(inc) inc 1 2 3 2 3 4inc inc
example: map Term Rewriting Rules with Parameters map(s): [] -> [] map(s): [x|xs] -> [<s> x | <map(s)> xs] 26 [ 1 , 2 , 3 ] [ 2 , 3 , 4 ] map(inc) inc 1 2 3 2 3 4inc inc
example: zip Term Rewriting Rules with Parameters 27 [ 1 , 2 , 3 ] [ (1,4) , (2,5) , (3,6) ] [ 4 , 5 , 6 ] zip
example: zip Term Rewriting Rules with Parameters 27 [ 1 , 2 , 3 ] [ (1,4) , (2,5) , (3,6) ] [ 4 , 5 , 6 ] zip [ 1 , 2 , 3 ] [ 5 , 7 , 9 ] [ 4 , 5 , 6 ] zip(add)
example: zip Term Rewriting Rules with Parameters 27 [ 1 , 2 , 3 ] [ (1,4) , (2,5) , (3,6) ] [ 4 , 5 , 6 ] zip [ 1 , 2 , 3 ] [ 5 , 7 , 9 ] [ 4 , 5 , 6 ] zip(add) map(add)
example: zip Term Rewriting Rules with Parameters zip(s): ([],[]) -> [] zip(s): ([x|xs],[y|ys]) -> [<s> (x,y) | <zip(s)> (xs,ys)] zip = zip(id) 27 [ 1 , 2 , 3 ] [ (1,4) , (2,5) , (3,6) ] [ 4 , 5 , 6 ] zip [ 1 , 2 , 3 ] [ 5 , 7 , 9 ] [ 4 , 5 , 6 ] zip(add) map(add)
example: fold Term Rewriting Rules with Parameters 28 [1,2,3] foldr(!0,add) 6
example: fold Term Rewriting Rules with Parameters 28 [1,2,3] foldr(!0,add) 6 [] 0 [3] 3 [2,3] 56 [1,2,3]
example: fold Term Rewriting Rules with Parameters foldr(s1,s2): [] -> <s1> foldr(s1,s2): [x|xs] -> <s2> (x,<foldr(s1,s2)> xs) 28 [1,2,3] foldr(!0,add) 6 [] 0 [3] 3 [2,3] 56 [1,2,3]
example: inverse Term Rewriting Rules with Parameters 29 [1,2,3] inverse(|[]) [3,2,1]
example: inverse Term Rewriting Rules with Parameters 29 [1,2,3] inverse(|[]) [3,2,1] [2,3] [1][] [1,2,3] [3] [2,1] [3,2,1] []
example: inverse Term Rewriting Rules with Parameters inverse(|is): [] -> is inverse(|is): [x|xs] -> <inverse(|[x|is])> xs 29 [1,2,3] inverse(|[]) [3,2,1] [2,3] [1][] [1,2,3] [3] [2,1] [3,2,1] []
Software Languages 30 Rewrite Strategies
rules and strategies Term Rewriting Transformation Definitions rewrite rules • term to term • left-hand side matching • right-hand side instantiation • conditional • partial transformation rewrite strategies • rule selection • algorithm • composition of transformations 31
example Term Rewriting Stratego module desugar imports include/Tiger operators strategies desugar-all = innermost(desugar) rules desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) 32
example Term Rewriting Stratego module eval imports include/Tiger operators desugar strategies eval-all = innermost(desugar + eval) rules eval: Bop(PLUS(),Int(i1),Int(i2)) -> Int(i3) where <addS> (i1, i2) => i3 33
Term Rewriting Strategy Combinators identity id 34
Term Rewriting Strategy Combinators identity id failure fail 34
Term Rewriting Strategy Combinators identity id failure fail sequential composition s1 ; s2 34
Term Rewriting Strategy Combinators identity id failure fail sequential composition s1 ; s2 deterministic choice s1 <+ s2 34
Term Rewriting Strategy Combinators identity id failure fail sequential composition s1 ; s2 deterministic choice s1 <+ s2 non-deterministic choice s1 + s2 34
Term Rewriting Strategy Combinators identity id failure fail sequential composition s1 ; s2 deterministic choice s1 <+ s2 non-deterministic choice s1 + s2 guarded choice s1 < s2 + s3 34
variables Term Rewriting Strategy Combinators pattern matching ?t 35
variables Term Rewriting Strategy Combinators pattern matching ?t pattern instantiation !t 35
variables Term Rewriting Strategy Combinators pattern matching ?t pattern instantiation !t strategy application <s> t ≣ !t ; s 35
variables Term Rewriting Strategy Combinators pattern matching ?t pattern instantiation !t strategy application <s> t ≣ !t ; s result matching s => t ≣ s ; ?t <s> t1 => t2 t2 := <s> t1 35
variables Term Rewriting Strategy Combinators pattern matching ?t pattern instantiation !t strategy application <s> t ≣ !t ; s result matching s => t ≣ s ; ?t <s> t1 => t2 t2 := <s> t1 variable scope {x,y: s} 35
rules and strategies Term Rewriting Strategy Combinators named rewrite rule l: t1 -> t2 where s ≣ l = ?t1 ; s ; !t2 36
rules and strategies Term Rewriting Strategy Combinators named rewrite rule l: t1 -> t2 where s ≣ l = ?t1 ; s ; !t2 unscoped rewrite rule (t1 -> t2 where s) ≣ ?t1 ; s ; !t2 36
rules and strategies Term Rewriting Strategy Combinators named rewrite rule l: t1 -> t2 where s ≣ l = ?t1 ; s ; !t2 unscoped rewrite rule (t1 -> t2 where s) ≣ ?t1 ; s ; !t2 strategy definition f(x,y|a,b) = s 36
examples Term Rewriting Strategy Combinators try(s) = s <+ id 37
examples Term Rewriting Strategy Combinators try(s) = s <+ id repeat(s) = try(s ; repeat(s)) 37
examples Term Rewriting Strategy Combinators try(s) = s <+ id repeat(s) = try(s ; repeat(s)) topdown(s) = s ; all(topdown(s)) 37
examples Term Rewriting Strategy Combinators try(s) = s <+ id repeat(s) = try(s ; repeat(s)) topdown(s) = s ; all(topdown(s)) alltd(s) = s <+ all(alltd(s)) 37
examples Term Rewriting Strategy Combinators try(s) = s <+ id repeat(s) = try(s ; repeat(s)) topdown(s) = s ; all(topdown(s)) alltd(s) = s <+ all(alltd(s)) bottomup(s) = all(bottomup(s)) ; s 37
examples Term Rewriting Strategy Combinators try(s) = s <+ id repeat(s) = try(s ; repeat(s)) topdown(s) = s ; all(topdown(s)) alltd(s) = s <+ all(alltd(s)) bottomup(s) = all(bottomup(s)) ; s innermost(s) = bottomup(try(s ; innermost(s))) 37
examples Term Rewriting Strategy Combinators try(s) = s <+ id repeat(s) = try(s ; repeat(s)) topdown(s) = s ; all(topdown(s)) alltd(s) = s <+ all(alltd(s)) bottomup(s) = all(bottomup(s)) ; s innermost(s) = bottomup(try(s ; innermost(s))) oncetd(s) = s <+ one(oncetd(s)) 37
examples Term Rewriting Strategy Combinators try(s) = s <+ id repeat(s) = try(s ; repeat(s)) topdown(s) = s ; all(topdown(s)) alltd(s) = s <+ all(alltd(s)) bottomup(s) = all(bottomup(s)) ; s innermost(s) = bottomup(try(s ; innermost(s))) oncetd(s) = s <+ one(oncetd(s)) contains(|t) = oncetd(?t) 37
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(switch) 38 Const Mul Const 3 4 5 Const Add
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(switch) 38 Const Mul Const 3 4 5 Const Add1
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(switch) 39 Mul Const 3 Const 4 5 Const Add1
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(switch) 39 Mul Const 3 Const 4 5 Const Add1 2
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(switch) 40 Mul Const 3 Const 5 4 Const Add1 2
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(switch) 40 Mul Const 3 Const 5 4 Const Add1 2 3
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(try(switch)) 41 Const Mul Const 3 4 5 Const Add
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(try(switch)) 41 Const Mul Const 3 4 5 Const Add1
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(try(switch)) 42 Mul Const 3 Const 4 5 Const Add1
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(try(switch)) 42 Mul Const 3 Const 4 5 Const Add1 2
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(try(switch)) 43 Mul Const 3 Const 5 4 Const Add1 2
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(try(switch)) 43 Mul Const 3 Const 5 4 Const Add1 2 3
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(try(switch)) 43 Mul Const 3 Const 5 4 Const Add1 2 3 4
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(try(switch)) 43 Mul Const 3 Const 5 4 Const Add1 2 3 4 5
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(try(switch)) 43 Mul Const 3 Const 5 4 Const Add1 2 3 4 5 6
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(try(switch)) 43 Mul Const 3 Const 5 4 Const Add1 2 3 4 5 6 7
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) topdown(s) = s ; all(topdown(s)) topdown(try(switch)) 43 Mul Const 3 Const 5 4 Const Add1 2 3 4 5 6 7 8
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 44 Const Mul Const 3 4 5 Const Add
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 44 Const Mul Const 3 4 5 Const Add1
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 45 Mul Const 3 Const 4 5 Const Add1
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 46 Const Mul Const 3 4 5 Const Add
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 46 Const Mul Const 3 4 5 Const Add1
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 46 Const Mul Const 3 4 5 Const Add1 2
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 46 Const Mul Const 3 4 5 Const Add1 2 3
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 46 Const Mul Const 3 4 5 Const Add1 2 3 4
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 47 Const Mul Const 3 5 4 Const Add1 2 3 4
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(switch) 48 Const Mul Const 3 4 5 Const Add
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(switch) 48 Const Mul Const 3 4 5 Const Add1
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(switch) 48 Const Mul Const 3 4 5 Const Add1 2
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(switch) 48 Const Mul Const 3 4 5 Const Add1 2 3
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 49 Const Mul Const 3 4 5 Const Add
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 49 Const Mul Const 3 4 5 Const Add1
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 49 Const Mul Const 3 4 5 Const Add1 2
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 49 Const Mul Const 3 4 5 Const Add1 2 3
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 49 Const Mul Const 3 4 5 Const Add1 2 3 4
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 49 Const Mul Const 3 4 5 Const Add1 2 3 4 5
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 49 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 49 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6 7
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 49 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6 7 8
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 50 Const Mul Const 3 4 5 Const Add1 2 3 4
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 51 Const Mul Const 3 5 4 Const Add1 2 3 4
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 52 Const Mul Const 3 5 4 Const Add1
Mul Const 3 Const 5 4 Const Add example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) bottomup(s) = all(bottomup(s)) ; s bottomup(try(switch)) 53 1
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 54 Const Mul Const 3 4 5 Const Add
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 54 Const Mul Const 3 4 5 Const Add1
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 54 Const Mul Const 3 4 5 Const Add1 2
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 54 Const Mul Const 3 4 5 Const Add1 2 3
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 54 Const Mul Const 3 4 5 Const Add1 2 3 4
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 54 Const Mul Const 3 4 5 Const Add1 2 3 4 5
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 54 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 54 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6 7
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 54 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6 7 8
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 55 Const Mul Const 3 4 5 Const Add1 2 3 4
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 56 Const Mul Const 3 5 4 Const Add1 2 3 4
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 56 Const Mul Const 3 5 4 Const Add1 2 3 4 9
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 56 Const Mul Const 3 5 4 Const Add1 2 3 4 9 10
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 56 Const Mul Const 3 5 4 Const Add1 2 3 4 9 10 11
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 56 Const Mul Const 3 5 4 Const Add1 2 3 4 9 10 11 12
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 57 Const Mul Const 3 5 4 Const Add1 2 3 4
example Term Rewriting Stratego switch: Add(e1, e2) -> Add(e2, e1) switch: Mul(e1, e2) -> Mul(e2, e1) innermost(s) = bottomup(try(s ; innermost(s))) innermost(switch) 58 Const Mul Const 3 4 5 Const Add1 2 3 4
lessons learned Term Rewriting Summary 59
lessons learned Term Rewriting Summary How do you define AST transformations in Stratego? • signatures • rewrite rules • rewrite strategies • strategy combinators 59
lessons learned Term Rewriting Summary How do you define AST transformations in Stratego? • signatures • rewrite rules • rewrite strategies • strategy combinators What kind of strategies can you find in the Stratego library? • arithmetics • map, zip, foldr • generic traversals 59
learn more Term Rewriting Literature 60
learn more Term Rewriting Literature Spoofax Lennart C. L. Kats, Eelco Visser: The Spoofax Language Workbench. Rules for Declarative Specification of Languages and IDEs. OOPSLA 2010 http://www.spoofax.org 60
learn more Term Rewriting Literature Spoofax Lennart C. L. Kats, Eelco Visser: The Spoofax Language Workbench. Rules for Declarative Specification of Languages and IDEs. OOPSLA 2010 http://www.spoofax.org Stratego Martin Bravenboer, Karl Trygve Kalleberg, Rob Vermaas, Eelco Visser: Stratego/XT 0.17. A language and toolset for program transformation. Science of Computer Programming, 72(1-2), 2008. http://www.strategoxt.org 60
Software Languages 61 Except where otherwise noted, this work is licensed under
Software Languages 62 attribution slide title author license 1, 35 Programming language textbooks K.lee public domain 2 The Bigger Picture F. Delventhal CC BY 2.0 5 Rose 2 des Kleinen Prinzen Antoine Saint-Exupéry public domain 11 Dog and owner on Ballykinler Beach Jonny Green CC BY 2.0 12 Fashionable melange of English words (1) trialsanderrors public domain 13 Gift asenat29 CC BY 2.0 13 Toxic John Morgan CC BY 2.0 14 Latin Grammar Anthony Nelzin 15 Ginkgo Biloba Johann Wolfgang von Goethe public domain 16 Sub-deb slang genibee CC BY-NC 2.0 17 Wednesday Michael Fawcett CC BY-NC-SA 2.0 19, 25, 67 Thesaurus Enoch Lau CC BY-SA 3.0 22 The captured Swiftsure, Seven Oaks, Loyal George and Convertine brought through Goeree Gat Willem van de Velde the Younger public domain
Software Languages 63 Stra slide title author license 23 Tower of Babel Pieter Bruegel the Elder public domain 26 The Ashtadhyayi translated by Srisa Chandra Vasu public domain 27 Buchdruckerduden public domain 28 Boeing 737-300 -400 -500 Manitenance Manual Alaska Airlines Bill Abbott CC BY-SA 2.0 30 Esperanto public domain 31 Quenya Juanma Pérez Rabasco CC BY 2.0 32 Klingon Dictionary Josh Bancroft CC BY-NC 2.0 33 Overweight Na'vi HARRY NGUYEN CC BY 2.0 36, 45, 46 IBM Electronic Data Processing Machine NASA public domain 41 Tiger Bernard Landgraf CC BY-SA 3.0 42 The C Programming Language Bill Bradford CC BY 2.0 43 Italian Java book cover 49-73 PICOL icons Melih Bilgil CC BY 3.0

More Related Content

PDF
Declarative Semantics Definition - Term Rewriting
byGuido Wachsmuth
 
PDF
Static Analysis
byEelco Visser
 
PDF
Static name resolution
byEelco Visser
 
PDF
Lexical Analysis
byEelco Visser
 
PDF
Dynamic Semantics
byEelco Visser
 
PDF
LL Parsing
byEelco Visser
 
PDF
Declarative Semantics Definition - Static Analysis and Error Checking
byGuido Wachsmuth
 
PDF
Formal Grammars
byEelco Visser
 
Declarative Semantics Definition - Term Rewriting
byGuido Wachsmuth
 
Static Analysis
byEelco Visser
 
Static name resolution
byEelco Visser
 
Lexical Analysis
byEelco Visser
 
Dynamic Semantics
byEelco Visser
 
LL Parsing
byEelco Visser
 
Declarative Semantics Definition - Static Analysis and Error Checking
byGuido Wachsmuth
 
Formal Grammars
byEelco Visser
 

What's hot

PDF
Declarative Syntax Definition - Grammars and Trees
byGuido Wachsmuth
 
PDF
Introduction - Imperative and Object-Oriented Languages
byGuido Wachsmuth
 
PDF
Pure and Declarative Syntax Definition: Paradise Lost and Regained
byGuido Wachsmuth
 
PDF
Syntax Definition
byEelco Visser
 
PDF
Syntax Definition
byGuido Wachsmuth
 
KEY
Compiler Components and their Generators - Lexical Analysis
byGuido Wachsmuth
 
PDF
Compiler Components and their Generators - Traditional Parsing Algorithms
byGuido Wachsmuth
 
PDF
Declare Your Language: Syntactic (Editor) Services
byEelco Visser
 
PDF
Declare Your Language: Transformation by Strategic Term Rewriting
byEelco Visser
 
PDF
Declare Your Language: Type Checking
byEelco Visser
 
PDF
Type analysis
byEelco Visser
 
PDF
Declare Your Language: Name Resolution
byEelco Visser
 
PDF
Compiler Construction | Lecture 5 | Transformation by Term Rewriting
byEelco Visser
 
PDF
Dynamic Semantics Specification and Interpreter Generation
byEelco Visser
 
PDF
Compiler Construction | Lecture 8 | Type Constraints
byEelco Visser
 
PDF
CS4200 2019 | Lecture 5 | Transformation by Term Rewriting
byEelco Visser
 
PDF
Declare Your Language (at DLS)
byEelco Visser
 
PDF
CS4200 2019 | Lecture 3 | Parsing
byEelco Visser
 
PDF
Declarative Type System Specification with Statix
byEelco Visser
 
PDF
"That scripting language called Prolog"
bySergei Winitzki
 
Declarative Syntax Definition - Grammars and Trees
byGuido Wachsmuth
 
Introduction - Imperative and Object-Oriented Languages
byGuido Wachsmuth
 
Pure and Declarative Syntax Definition: Paradise Lost and Regained
byGuido Wachsmuth
 
Syntax Definition
byEelco Visser
 
Syntax Definition
byGuido Wachsmuth
 
Compiler Components and their Generators - Lexical Analysis
byGuido Wachsmuth
 
Compiler Components and their Generators - Traditional Parsing Algorithms
byGuido Wachsmuth
 
Declare Your Language: Syntactic (Editor) Services
byEelco Visser
 
Declare Your Language: Transformation by Strategic Term Rewriting
byEelco Visser
 
Declare Your Language: Type Checking
byEelco Visser
 
Type analysis
byEelco Visser
 
Declare Your Language: Name Resolution
byEelco Visser
 
Compiler Construction | Lecture 5 | Transformation by Term Rewriting
byEelco Visser
 
Dynamic Semantics Specification and Interpreter Generation
byEelco Visser
 
Compiler Construction | Lecture 8 | Type Constraints
byEelco Visser
 
CS4200 2019 | Lecture 5 | Transformation by Term Rewriting
byEelco Visser
 
Declare Your Language (at DLS)
byEelco Visser
 
CS4200 2019 | Lecture 3 | Parsing
byEelco Visser
 
Declarative Type System Specification with Statix
byEelco Visser
 
"That scripting language called Prolog"
bySergei Winitzki
 

Similar to Term Rewriting

PDF
Declare Your Language: Dynamic Semantics
byEelco Visser
 
PDF
Compiler Construction | Lecture 14 | Interpreters
byEelco Visser
 
PDF
Decaf language specification
bySami Said
 
PDF
Model-Driven Software Development - Pretty-Printing, Editor Services, Term Re...
byEelco Visser
 
KEY
Verification with LoLA: 2 The LoLA Input Language
byUniversität Rostock
 
PPT
Syntax analysis
byBinsent Ribera
 
PPT
Syntax analysis
byBinsent Ribera
 
PPT
Syntax
byABDERRAHMAN ID -SAID
 
PDF
C compiler(final)
byFarzan Dehbashi
 
PDF
A Language Designer’s Workbench. A one-stop shop for implementation and verif...
byEelco Visser
 
PDF
The Logical Burrito - pattern matching, term rewriting and unification
byNorman Richards
 
PDF
Towards a General Approach for Symbolic Model-Checker Prototyping
byEdmundo López Bóbeda
 
PDF
The Ring programming language version 1.5.3 book - Part 86 of 184
byMahmoud Samir Fayed
 
PDF
Grammarware Memes
byEelco Visser
 
PDF
Scope Graphs: A fresh look at name binding in programming languages
byEelco Visser
 
PDF
iRODS Rule Language Cheat Sheet
bySamuel Lampa
 
PPT
Ch2
bykinnarshah8888
 
PPT
Lexical analysis, syntax analysis, semantic analysis. Ppt
byovidlivi91
 
PDF
The Ring programming language version 1.10 book - Part 88 of 212
byMahmoud Samir Fayed
 
PPTX
Compiler
byalekhya57
 
Declare Your Language: Dynamic Semantics
byEelco Visser
 
Compiler Construction | Lecture 14 | Interpreters
byEelco Visser
 
Decaf language specification
bySami Said
 
Model-Driven Software Development - Pretty-Printing, Editor Services, Term Re...
byEelco Visser
 
Verification with LoLA: 2 The LoLA Input Language
byUniversität Rostock
 
Syntax analysis
byBinsent Ribera
 
Syntax analysis
byBinsent Ribera
 
Syntax
byABDERRAHMAN ID -SAID
 
C compiler(final)
byFarzan Dehbashi
 
A Language Designer’s Workbench. A one-stop shop for implementation and verif...
byEelco Visser
 
The Logical Burrito - pattern matching, term rewriting and unification
byNorman Richards
 
Towards a General Approach for Symbolic Model-Checker Prototyping
byEdmundo López Bóbeda
 
The Ring programming language version 1.5.3 book - Part 86 of 184
byMahmoud Samir Fayed
 
Grammarware Memes
byEelco Visser
 
Scope Graphs: A fresh look at name binding in programming languages
byEelco Visser
 
iRODS Rule Language Cheat Sheet
bySamuel Lampa
 
Ch2
bykinnarshah8888
 
Lexical analysis, syntax analysis, semantic analysis. Ppt
byovidlivi91
 
The Ring programming language version 1.10 book - Part 88 of 212
byMahmoud Samir Fayed
 
Compiler
byalekhya57
 

More from Eelco Visser

PDF
CS4200 2019 | Lecture 4 | Syntactic Services
byEelco Visser
 
PDF
CS4200 2019 | Lecture 2 | syntax-definition
byEelco Visser
 
PDF
CS4200 2019 Lecture 1: Introduction
byEelco Visser
 
PDF
A Direct Semantics of Declarative Disambiguation Rules
byEelco Visser
 
PDF
Compiler Construction | Lecture 17 | Beyond Compiler Construction
byEelco Visser
 
PDF
Domain Specific Languages for Parallel Graph AnalytiX (PGX)
byEelco Visser
 
PDF
Compiler Construction | Lecture 15 | Memory Management
byEelco Visser
 
PDF
Compiler Construction | Lecture 13 | Code Generation
byEelco Visser
 
PDF
Compiler Construction | Lecture 12 | Virtual Machines
byEelco Visser
 
PDF
Compiler Construction | Lecture 11 | Monotone Frameworks
byEelco Visser
 
PDF
Compiler Construction | Lecture 10 | Data-Flow Analysis
byEelco Visser
 
PDF
Compiler Construction | Lecture 9 | Constraint Resolution
byEelco Visser
 
PDF
Compiler Construction | Lecture 7 | Type Checking
byEelco Visser
 
PDF
Compiler Construction | Lecture 6 | Introduction to Static Analysis
byEelco Visser
 
PDF
Compiler Construction | Lecture 4 | Parsing
byEelco Visser
 
PDF
Compiler Construction | Lecture 3 | Syntactic Editor Services
byEelco Visser
 
PDF
Compiler Construction | Lecture 2 | Declarative Syntax Definition
byEelco Visser
 
PDF
Compiler Construction | Lecture 1 | What is a compiler?
byEelco Visser
 
PDF
Declare Your Language: Virtual Machines & Code Generation
byEelco Visser
 
PDF
Declare Your Language: Constraint Resolution 2
byEelco Visser
 
CS4200 2019 | Lecture 4 | Syntactic Services
byEelco Visser
 
CS4200 2019 | Lecture 2 | syntax-definition
byEelco Visser
 
CS4200 2019 Lecture 1: Introduction
byEelco Visser
 
A Direct Semantics of Declarative Disambiguation Rules
byEelco Visser
 
Compiler Construction | Lecture 17 | Beyond Compiler Construction
byEelco Visser
 
Domain Specific Languages for Parallel Graph AnalytiX (PGX)
byEelco Visser
 
Compiler Construction | Lecture 15 | Memory Management
byEelco Visser
 
Compiler Construction | Lecture 13 | Code Generation
byEelco Visser
 
Compiler Construction | Lecture 12 | Virtual Machines
byEelco Visser
 
Compiler Construction | Lecture 11 | Monotone Frameworks
byEelco Visser
 
Compiler Construction | Lecture 10 | Data-Flow Analysis
byEelco Visser
 
Compiler Construction | Lecture 9 | Constraint Resolution
byEelco Visser
 
Compiler Construction | Lecture 7 | Type Checking
byEelco Visser
 
Compiler Construction | Lecture 6 | Introduction to Static Analysis
byEelco Visser
 
Compiler Construction | Lecture 4 | Parsing
byEelco Visser
 
Compiler Construction | Lecture 3 | Syntactic Editor Services
byEelco Visser
 
Compiler Construction | Lecture 2 | Declarative Syntax Definition
byEelco Visser
 
Compiler Construction | Lecture 1 | What is a compiler?
byEelco Visser
 
Declare Your Language: Virtual Machines & Code Generation
byEelco Visser
 
Declare Your Language: Constraint Resolution 2
byEelco Visser
 

Recently uploaded

PPTX
Choosing Your Web3 Architecture: L1 vs L2 vs Appchain
bystorygamemarketing
 
PDF
Best SaaS Growth Strategy for 2026: Referral Programs That Retain Better
byReferral Factory
 
PPTX
Computing Adnans presentation OTHM level 3
bymashikhossain23
 
PDF
Oracle AI Database 26ai _ AI-Native Database for Enterprises.pdf
byAstuteBusiness
 
PDF
apidays Paris 2025 | AI and APIs - Ensuring Platform Migration Reliability wi...
byapidays
 
PPT
C++ how to program 10 edition Harvey Deitel
byatisyemen
 
PDF
DSD-INT 2025 MODFLOW 6 Developments - Langevin
byDeltares
 
PDF
What Web Teams Need to Know About Building API-Powered Websites
byAlex Halsey
 
PDF
Wormhole Token – Smart Contract Security Audit Report by EtherAuthority
byEtherAuthority
 
PPTX
Managing Multiple Projects from One ERP Dashboard - by biCanvas ERP
bybiCanvasERP
 
PDF
The Hidden Cost of “Quick” Web App Development
byiProgrammer Solutions Private Limited
 
PPTX
Why Airline Platforms Fail at Change and How Etihad Fixed It
byIT IDOL Technologies
 
PDF
Software Development Company in India.pdf
byitswssoftware
 
PDF
Common CRM Implementation Mistakes & How to Avoid Them.pdf
byCRMLeaf
 
PDF
Achieving App Stability through mobile performance testing
byAvekshaa Technologies
 
PPT
C++ how to program 10 edition Harvey Deitel
byatisyemen
 
PDF
ment.tech-What Infrastructure as Code Means for Businesses.pdf
bysj2643598
 
PPTX
The Best Open Source Analytics Platform Like ThoughtSpot.pptx
byVarsha Nayak
 
PDF
Mastering ROS 2 for Robotics Programming.pdf
byssuser4e6c051
 
PDF
AI Concepts - MCP Neurons
byPhilip Schwarz
 
Choosing Your Web3 Architecture: L1 vs L2 vs Appchain
bystorygamemarketing
 
Best SaaS Growth Strategy for 2026: Referral Programs That Retain Better
byReferral Factory
 
Computing Adnans presentation OTHM level 3
bymashikhossain23
 
Oracle AI Database 26ai _ AI-Native Database for Enterprises.pdf
byAstuteBusiness
 
apidays Paris 2025 | AI and APIs - Ensuring Platform Migration Reliability wi...
byapidays
 
C++ how to program 10 edition Harvey Deitel
byatisyemen
 
DSD-INT 2025 MODFLOW 6 Developments - Langevin
byDeltares
 
What Web Teams Need to Know About Building API-Powered Websites
byAlex Halsey
 
Wormhole Token – Smart Contract Security Audit Report by EtherAuthority
byEtherAuthority
 
Managing Multiple Projects from One ERP Dashboard - by biCanvas ERP
bybiCanvasERP
 
The Hidden Cost of “Quick” Web App Development
byiProgrammer Solutions Private Limited
 
Why Airline Platforms Fail at Change and How Etihad Fixed It
byIT IDOL Technologies
 
Software Development Company in India.pdf
byitswssoftware
 
Common CRM Implementation Mistakes & How to Avoid Them.pdf
byCRMLeaf
 
Achieving App Stability through mobile performance testing
byAvekshaa Technologies
 
C++ how to program 10 edition Harvey Deitel
byatisyemen
 
ment.tech-What Infrastructure as Code Means for Businesses.pdf
bysj2643598
 
The Best Open Source Analytics Platform Like ThoughtSpot.pptx
byVarsha Nayak
 
Mastering ROS 2 for Robotics Programming.pdf
byssuser4e6c051
 
AI Concepts - MCP Neurons
byPhilip Schwarz
 

Term Rewriting