Annotation of /trunk/src/compiler/simplify/simplify.sml

Parent Directory | Revision Log

---

Revision 171 - (view) (download)

1 :	jhr	171	(* simplify.sml
2 :			*
3 :			* COPYRIGHT (c) 2010 The Diderot Project (http://diderot.cs.uchicago.edu)
4 :			* All rights reserved.
5 :			*
6 :			* Simplify the AST representation.
7 :			*)
8 :
9 :			structure Simplify : sig
10 :
11 :			val transform : AST.program -> Simple.program
12 :
13 :			end = struct
14 :
15 :			structure Ty = Types
16 :			structure S = Simple
17 :
18 :			local
19 :			val tempName = Atom.atom "_t"
20 :			in
21 :			fun newTemp ty = Var.new (tempName, AST.LocalVar, ty)
22 :			end
23 :
24 :			(* make a block out of a list of statements that are in reverse order *)
25 :			fun mkBlock stms = let
26 :			fun flatten [] = []
27 :			| flatten (S.S_Block stms :: r) = stms @ flatten r
28 :			| flatten (stm :: r) = stm :: flatten r
29 :			in
30 :			S.S_Block(flatten (List.rev stms))
31 :			end
32 :
33 :			fun transform (AST.Program dcls) = let
34 :			val globals = ref []
35 :			val globalInit = ref []
36 :			val actors = ref []
37 :			fun simplifyDecl dcl = (case dcl
38 :			of AST.D_Input(x, NONE) => globals := x :: !globals
39 :			| AST.D_Input(x, SOME e) => let
40 :			val (stms, e') = simplifyExp (e, [])
41 :			in
42 :			(* FIXME: note that we should add code to check for the input value overriding the default value *)
43 :			globals := x :: !globals;
44 :			globalInit := S.S_Assign(x, e') :: (stms @ !globalInit)
45 :			end
46 :			| AST.D_Var(AST.VD_Decl(x, e)) => let
47 :			val (stms, e') = simplifyExp (e, [])
48 :			in
49 :			globals := x :: !globals;
50 :			globalInit := S.S_Assign(x, e') :: (stms @ !globalInit)
51 :			end
52 :			| AST.D_Actor info => actors := simplifyActor info :: !actors
53 :			| AST.D_InitialArray(e, iters) => () (* FIXME *)
54 :			| AST.D_InitialCollection(e, iters) => () (* FIXME *)
55 :			(* end case *))
56 :			in
57 :			List.app simplifyDecl dcls;
58 :			S.Prog{
59 :			globals = List.rev(!globals),
60 :			globalInit = mkBlock (!globalInit),
61 :			actors = List.rev(!actors)
62 :			}
63 :			end
64 :
65 :			and simplifyActor {name, params, state, methods} = let
66 :			fun simplifyState ([], xs, stms) = (List.rev xs, mkBlock stms)
67 :			| simplifyState (AST.VD_Decl(x, e) :: r, xs, stms) = let
68 :			val (stms, e') = simplifyExp (e, stms)
69 :			in
70 :			simplifyState (r, x::xs, S.S_Assign(x, e') :: stms)
71 :			end
72 :			val (xs, stm) = simplifyState (state, [], [])
73 :			in
74 :			S.Actor{
75 :			params = params,
76 :			state = xs, stateInit = stm,
77 :			methods = List.map simplifyMethod methods
78 :			}
79 :			end
80 :
81 :			and simplifyMethod (AST.M_Method(name, body)) =
82 :			S.M_Method(name, simplifyBlock body)
83 :
84 :			(* simplify a statement into a single statement (i.e., a block if it expands into more
85 :			* than one new statement.
86 :			*)
87 :			and simplifyBlock stm = mkBlock (simplifyStmt (stm, []))
88 :
89 :			and simplifyStmt (stm, stms) = (case stm
90 :			of AST.S_Block body => let
91 :			fun simplify ([], stms) = stms
92 :			| simplify (stm::r, stms) = simplify (r, simplifyStmt (stm, stms))
93 :			in
94 :			simplify (body, stms)
95 :			end
96 :			| AST.S_Decl(AST.VD_Decl(x, e)) => let
97 :			val (stms, e') = simplifyExp (e, stms)
98 :			in
99 :			S.S_Assign(x, e') :: stms
100 :			end
101 :			| AST.S_IfThenElse(e, s1, s2) => let
102 :			val (stms, x) = simplifyExpToVar (e, stms)
103 :			val s1 = simplifyBlock s1
104 :			val s2 = simplifyBlock s2
105 :			in
106 :			S.S_IfThenElse(x, s1, s2) :: stms
107 :			end
108 :			| AST.S_Assign(x, e) => let
109 :			val (stms, e') = simplifyExp (e, stms)
110 :			in
111 :			S.S_Assign(x, e') :: stms
112 :			end
113 :			| AST.S_New(name, args) => let
114 :			val (stms, xs) = simplifyExpsToVars (args, stms)
115 :			in
116 :			S.S_New(name, xs) :: stms
117 :			end
118 :			| AST.S_Die => S.S_Die :: stms
119 :			| AST.S_Stabilize => S.S_Stabilize :: stms
120 :			(* end case *))
121 :
122 :			and simplifyExp (exp, stms) = (
123 :			case exp
124 :			of AST.E_Var x => (stms, S.E_Var x)
125 :			| AST.E_Lit lit => (stms, S.E_Lit lit)
126 :			| AST.E_Tuple es => raise Fail "E_Tuple not yet implemented"
127 :			| AST.E_Apply(f, tyArgs, args, ty) => let
128 :			val (stms, xs) = simplifyExpsToVars (args, stms)
129 :			in
130 :			(stms, S.E_Apply(f, tyArgs, xs, ty))
131 :			end
132 :			| AST.E_Cons es => let
133 :			val (stms, xs) = simplifyExpsToVars (es, stms)
134 :			in
135 :			(stms, S.E_Cons xs)
136 :			end
137 :			| AST.E_Cond(e1, e2, e3) => let
138 :			(* a conditional expression gets turned into an if-then-else statememt *)
139 :			val result = newTemp Ty.T_Bool
140 :			val (stms, x) = simplifyExpToVar (e1, stms)
141 :			fun simplifyBranch e = let
142 :			val (stms, e) = simplifyExp (e, [])
143 :			in
144 :			mkBlock (S.S_Assign(result, e)::stms)
145 :			end
146 :			val s1 = simplifyBranch e1
147 :			val s2 = simplifyBranch e2
148 :			in
149 :			(S.S_IfThenElse(x, s1, s2) :: stms, S.E_Var result)
150 :			end
151 :			(* end case *))
152 :
153 :			and simplifyExpToVar (exp, stms) = let
154 :			val (stms, e) = simplifyExp (exp, stms)
155 :			in
156 :			case e
157 :			of S.E_Var x => (stms, x)
158 :			| _ => let
159 :			val x = newTemp (S.typeOf e)
160 :			in
161 :			(S.S_Assign(x, e)::stms, x)
162 :			end
163 :			(* end case *)
164 :			end
165 :
166 :			and simplifyExpsToVars (exps, stms) = let
167 :			fun f ([], xs, stms) = (stms, List.rev xs)
168 :			| f (e::es, xs, stms) = let
169 :			val (stms, x) = simplifyExpToVar (e, stms)
170 :			in
171 :			f (es, x::xs, stms)
172 :			end
173 :			in
174 :			f (exps, [], stms)
175 :			end
176 :
177 :			end

---

root@smlnj-gforge.cs.uchicago.edu	ViewVC Help
Powered by ViewVC 1.0.0