Repository navigation
Expand file tree
/
Copy pathMiniC.hs
More file actions
81 lines (67 loc) · 1.82 KB
/
Copy pathMiniC.hs
File metadata and controls
81 lines (67 loc) · 1.82 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74<
7DD1
/div>
75
76
77
78
79
80
81
{-# LANGUAGE DuplicateRecordFields #-}
-- Object Language
module MiniC where
import qualified Data.Set as Set
type Name = String
data Expr
= Lit {v :: Int}
| Add {lhs :: Expr, rhs :: Expr}
| Sub {lhs :: Expr, rhs :: Expr}
| Select {index :: Expr}
| Var {n :: Name}
| QuantVar {n::Name}
deriving Show
l .+ r = Add l r
l .- r = Sub l r
sel i = Select i
var n = Var n
qv n = QuantVar n
lit v = Lit v
data LogExpr
= Eq {lhs :: Expr, rhs :: Expr}
| Lt {lhs :: Expr, rhs :: Expr}
| Gt {lhs :: Expr, rhs :: Expr}
| Not {le :: LogExpr}
| Or {lhsl :: LogExpr, rhsl :: LogExpr}
| And {lhsl :: LogExpr, rhsl :: LogExpr}
| Impl {lhsl :: LogExpr, rhsl :: LogExpr}
| True
| False
deriving Show
l .== r = Eq l r
l .< r = Lt l r
l .> r = Gt l r
l .>= r = (l .> r) .|| (l .== r)
l .<= r = (l .< r) .|| (l .== r)
l .|| r = Or l r
l .&& r = And l r
l .=> r = Impl l r
data Forall = Forall {vars :: [Name], body :: LogExpr} deriving Show
forAll v b = Forall v b
data Stmt
= Store {index :: Expr, e :: Expr}
| Assign {v :: Name, e :: Expr}
| While {cond :: LogExpr, inv :: Forall, body :: [Stmt]}
| If {cond :: LogExpr, thn :: [Stmt], els :: [Stmt]}
| Assert {fa :: Forall}
| Assume {fa :: Forall}
deriving Show
store i e = Store i e
v .:= e = Assign v e
while c i b = While c i b
if' c t e = If c t e
assert f = Assert f
assume f = Assume f
mutatable :: Stmt -> Set.Set Name
mutatable (Store index e) = Set.empty
mutatable (Assign v e) = Set.singleton v
mutatable (While cond inv body) = Set.unions $ map mutatable body
mutatable (If cond thn els) = Set.unions $ map mutatable (thn <> els)
mutatable (Assert fa) = Set.empty
mutatable (Assume fa) = Set.empty
data Prog = Prog
{ formals :: [Name]
, vars :: [Name]
, body :: [Stmt]
}
prog f v b = Prog f v b