Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /trunk/src/compiler/translate/translate.sml
ViewVC logotype

Diff of /trunk/src/compiler/translate/translate.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 194, Mon Aug 2 16:40:29 2010 UTC revision 226, Tue Aug 3 21:34:18 2010 UTC
# Line 17  Line 17 
17      structure VSet = Var.Set      structure VSet = Var.Set
18      structure IL = HighIL      structure IL = HighIL
19    
20      fun lookup env x = (case VMap.find x      fun lookup env x = (case VMap.find (env, x)
21             of SOME x' => x'             of SOME x' => x'
22              | NONE => raise Fail(concat[              | NONE => raise Fail(concat[
23                    "no binding for ", Var.toString x, " in environment"                    "no binding for ", Var.uniqueNameOf x, " in environment"
24                  ])                  ])
25            (* end case *))            (* end case *))
26    
27    (* create a new instance of a variable *)    (* create a new instance of a variable *)
28      fun newVar x = IL.newVar (Var.nameOf x)      fun newVar x = IL.Var.new (Var.nameOf x)
29    
30    (* expression translation *)    (* expression translation *)
31      fun cvtExpr (env, lhs, exp) = (case exp      fun cvtExp (env, lhs, exp) = (case exp
32             of S.E_Var x => [(lhs, IL.VAR(lookup env x))]             of S.E_Var x => [(lhs, IL.VAR(lookup env x))]
33              | S.E_Lit lit => [(lhs, IL.LIT lit)]              | S.E_Lit lit => [(lhs, IL.LIT lit)]
34              | S.E_Tuple xs => raise Fail "E_Tuple not implemeted"              | S.E_Tuple xs => raise Fail "E_Tuple not implemeted"
# Line 38  Line 38 
38                    TranslateBasis.translate (lhs, f, tyArgs, args')                    TranslateBasis.translate (lhs, f, tyArgs, args')
39                  end                  end
40              | S.E_Cons args => [(lhs, IL.CONS(List.map (lookup env) args))]              | S.E_Cons args => [(lhs, IL.CONS(List.map (lookup env) args))]
41                | S.E_Input(name, NONE) => [(lhs, IL.OP(HighOps.Input name, []))]
42                | S.E_Input(name, SOME dflt) =>
43                    [(lhs, IL.OP(HighOps.InputWithDefault name, [lookup env dflt]))]
44                | S.E_Field fld => [(lhs, IL.OP(HighOps.Field fld, []))]
45                | S.E_LoadImage info => [(lhs, IL.OP(HighOps.LoadImage info, []))]
46            (* end case *))            (* end case *))
47    
48    (* convert a Simple AST block to an IL statement.  We return the statement that represents the    (* convert a Simple AST block to an IL statement.  We return the statement that represents the
# Line 53  Line 58 
58                  val assigned = VSet.add(assigned, x)                  val assigned = VSet.add(assigned, x)
59                  val env = VMap.insert(env, x, x')                  val env = VMap.insert(env, x, x')
60                  in                  in
61                    cvt (env, assigned, rest, stms@assignments)                    toBlock (env, assigned, rest, stms@assignments)
62                  end                  end
63              | toBlock (env, assigned, stms, assignments) = let              | toBlock (env, assigned, stms, assignments) = let
64                  val (succ, env, assigned) = toStmt (env, assigned, stms)                  val (succ, env, assigned) = toStmt (env, assigned, stms)
# Line 64  Line 69 
69                  end                  end
70            and toStmt (env, assigned, []) =            and toStmt (env, assigned, []) =
71                  (IL.mkBLOCK{succ=IL.dummy, body=[]}, env, assigned)                  (IL.mkBLOCK{succ=IL.dummy, body=[]}, env, assigned)
72              | toStmt (env, assigned, stms as stmt::rest) = (case stm              | toStmt (env, assigned, stms as stm::rest) = (case stm
73                   of S.S_Assign => toBlock (env, assigned, stms)                   of S.S_Assign _ => toBlock (env, assigned, stms, [])
74                    | S.S_IfThenElse(x, b1, b2) => let                    | S.S_IfThenElse(x, b1, b2) => let
75                        val x' = lookup env x                        val x' = lookup env x
76                        val (s1, env1, assigned1) = block(env, b1)                        val (s1, env1, assigned1) = cvtBlock(env, b1)
77                        val (s2, env2, assigned2) = block(env, b2)                        val (s2, env2, assigned2) = cvtBlock(env, b2)
78                        val assigned = VSet.union(assigned1, assigned2)                        val assigned = VSet.union(assigned1, assigned2)
79                        val (env, phis) = let                        val (env, phis) = let
80                              fun mkPhi (x, (env, phis)) = let                              fun mkPhi (x, (env, phis)) = let
81                                    val x1 = lookup(env1, x)                                    val x1 = lookup env1 x
82                                    val x2 = lookup(env2, x)                                    val x2 = lookup env2 x
83                                    val x' = newVar x                                    val x' = newVar x
84                                    in                                    in
85                                      (VMap.insert(env, x, x'), (x', [x1, x2])::phis)                                      (VMap.insert(env, x, x'), (x', [x1, x2])::phis)
# Line 108  Line 113 
113                                  (stm, env, assigned)                                  (stm, env, assigned)
114                                end                                end
115                        end                        end
116                    | S.S_Die => (IL.mkDIE(), assigned, stms)                    | S.S_Die => (IL.mkDIE(), env, assigned)
117                    | S.S_Stabilize => (IL.mkSTABILIZE(), assigned, stms)                    | S.S_Stabilize => (IL.mkSTABILIZE(), env, assigned)
118                  (* end case *))                  (* end case *))
119            in            in
120              toStmt (env, VSet.empty, stms)              toStmt (env, VSet.empty, stms)
121            end            end
122    
123      fun translate (S.Program{globals, globaInit, actors}) = ??      fun translate (S.Program{globals, globalInit, actors}) = let
124              val (globalInit, env, _) = cvtBlock (VMap.empty, globalInit)
125            (* get the SSA names for the globals and a reduced environment *)
126              val (env, globs) = let
127                    val lookup = lookup env
128                    fun cvtVar (x, (env, globs)) = let
129                          val x' = lookup x
130                          in
131                            (VMap.insert(env, x, x'), x'::globs)
132                          end
133                    val (env, globs) = List.foldl cvtVar (VMap.empty, []) globals
134                    in
135                      (env, List.rev globs)
136                    end
137              fun cvtActor (S.Actor{name, params, state, stateInit, methods}) = let
138                    val (env, params) = let
139                          fun cvtParam (x, (env, xs)) = let
140                                val x' = newVar x
141                                in
142                                  (VMap.insert(env, x, x'), x'::xs)
143                                end
144                          val (env, params) = List.foldl cvtParam (env, []) params
145                          in
146                            (env, List.rev params)
147                          end
148                    val (stateInit, env, _) = cvtBlock (env, stateInit)
149                    val state = List.map (lookup env) state
150                    fun cvtMethod (S.Method(name, blk)) = let
151                          val (body, _, _) = cvtBlock (env, blk)
152                          in
153                            IL.Method(name, body)
154                          end
155                    in
156                      IL.Actor{
157                          name = name,
158                          params = params,
159                          state = state,
160                          stateInit = stateInit,
161                          methods = List.map cvtMethod methods
162                        }
163                    end
164              in
165                IL.Program{
166                    globals = globs,
167                    globalInit = globalInit,
168                    actors = List.map cvtActor actors
169                  }
170              end
171    
172    end    end

Legend:
Removed from v.194  
changed lines
  Added in v.226

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