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

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/cxx-util/tree-to-cxx.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/cxx-util/tree-to-cxx.sml

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

revision 3892, Sat May 21 17:08:42 2016 UTC revision 3893, Sat May 21 21:33:08 2016 UTC
# Line 81  Line 81 
81    (* integer literal expression *)    (* integer literal expression *)
82      fun intExp (i : int) = CL.mkInt(IntInf.fromInt i)      fun intExp (i : int) = CL.mkInt(IntInf.fromInt i)
83    
84        val zero = CL.mkInt 0
85    
86      fun addrOf e = CL.mkUnOp(CL.%&, e)      fun addrOf e = CL.mkUnOp(CL.%&, e)
87    
88    (* make an application of a function from the "std" namespace *)    (* make an application of a function from the "std" namespace *)
# Line 202  Line 204 
204              | IR.E_Lit(Literal.Real f) => CL.mkFlt(f, Env.realTy env)              | IR.E_Lit(Literal.Real f) => CL.mkFlt(f, Env.realTy env)
205              | IR.E_Lit(Literal.String s) => CL.mkStr s              | IR.E_Lit(Literal.String s) => CL.mkStr s
206              | IR.E_Op(rator, args) => trOp (env, rator, trExps(env, args))              | IR.E_Op(rator, args) => trOp (env, rator, trExps(env, args))
207              | IR.E_Vec(d, args) => ??              | IR.E_Vec(w, pw, args) => let
208              | IR.E_Cons(args, Ty.TensorTy shape) => ??                  val args = trExps (env, args)
209              | IR.E_Seq(args, ty) => ??                  val args = if (w < pw) then args @ List.tabulate(pw-w, fn _ => zero) else args
210                    in
211                      CL.mkVec(CL.T_Named("vec" ^ Int.toString pw), args)
212                    end
213                | IR.E_Cons(args, Ty.TensorTy shape) => raise Fail "unexpected E_Cons"
214                | IR.E_Seq(args, ty) => raise Fail "unexpected E_Seq"
215              | IR.E_Pack(layout, args) => ??              | IR.E_Pack(layout, args) => ??
216              | IR.E_VLoad(layout, e, i) => ??              | IR.E_VLoad(layout, e, i) => ??
217            (* end case *))            (* end case *))
# Line 215  Line 222 
222      fun trExpToVar (env, ty, name, exp) = (case trExp (env, exp)      fun trExpToVar (env, ty, name, exp) = (case trExp (env, exp)
223             of e as CL.E_Var _ => (e, [])             of e as CL.E_Var _ => (e, [])
224              | e => let              | e => let
225                  val x = freshName name                  val x = freshVar name
226                  in                  in
227                    (CL.mkVar x, [CL.mkDeclInit(ty, x, e)])                    (CL.mkVar x, [CL.mkDeclInit(ty, x, e)])
228                  end                  end
229            (* end case *))            (* end case *))
230    
231      fun trRHS mkStm (env, rhs) = (case rhs      fun trAssign (env, lhs, rhs) = let
232             of IR.E_Op(??, args) => ???            fun trArg (i, arg) = CL.mkAssign(CL.mkSubscript(lhs, intExp i), trExp (env, arg))
233              | IR.E_Cons(args, Ty.TensorTy shape) => ??            in
234              | IR.E_Seq(args, ty) => ??              case rhs
235              | _ => mkStm (trExp (env, rhs)) (* generic case *)               of IR.E_Cons(args, _) => List.mapi trArg args
236            (* end case *))                | IR.E_Seq(args, _) => List.mapi trArg args
237                  | _ => [CL.mkAssign(lhs, trExp (env, rhs))]
238      fun trAssign (env, lhs, rhs) =              (* end case *)
239            trRHS (fn rhs => CL.mkAssign(lhs, rhs)) (env, rhs)            end
240    
241      fun trDecl (env, ty, lhs, rhs) =      fun trDecl (env, ty, lhs, rhs) = let
242            trRHS (fn rhs => CL.mkDeclInit(ty, lhs, rhs)) (env, rhs)            fun trArgs args = CL.mkDecl(
243                    ty, lhs, SOME(CL.I_Exps(List.map (fn arg => CL.I_Exp(trExp (env, arg))) args)))
244              in
245                case rhs
246                 of IR.E_Cons(args, _) => trArgs args
247                  | IR.E_Seq(args, _) => trArgs args
248                  | _ => CL.mkDeclInit(ty, lhs, trExp (env, rhs))
249                (* end case *)
250              end
251    
252      fun trMultiAssign (env, lhs, IR.E_Op(rator, args)) = (case (lhs, rator, args)      fun trMultiAssign (env, lhs, IR.E_Op(rator, args)) = (case (lhs, rator, args)
253             of ([vals, vecs], Op.EigenVecs2x2, [exp]) =>             of ([vals, vecs], Op.EigenVecs2x2, [exp]) =>
# Line 247  Line 262 
262            fun trStm (stm, (env, stms : CL.stm list)) = (case stm            fun trStm (stm, (env, stms : CL.stm list)) = (case stm
263                   of IR.S_Comment text => (env, CL.mkComment text :: stms)                   of IR.S_Comment text => (env, CL.mkComment text :: stms)
264                    | IR.S_Assign(true, x, exp) => let                    | IR.S_Assign(true, x, exp) => let
265                        val (env, stm) = trDecl (env, ??, Env.lookup (env, x), exp)                        val ty = trType (env, V.ty x)
266                          val x' = ??
267                          val env = Env.insert (env, x, x')
268                        in                        in
269                          (env, stm::stms)                          (env, trDecl (env, ty, x', exp) :: stms)
270                        end                        end
271                    | IR.S_Assign(false, x, exp) => let                    | IR.S_Assign(false, x, exp) => let
272                        val (env, stm) = trAssign (env, lvalueVar (env, x), exp)                        val stms' = trAssign (env, lvalueVar (env, x), exp)
273                        in                        in
274                          (env, stm::stms)                          (env, stms' @ stms)
275                        end                        end
276                    | IR.S_MAssign(xs, exp) =>                    | IR.S_MAssign(xs, exp) =>
277                        (env, trMultiAssign (env, List.map (fn x => lvalueVar (env, x)) xs, exp) :: stms)                        (env, trMultiAssign (env, List.map (fn x => lvalueVar (env, x)) xs, exp) :: stms)
278                    | IR.S_GAssign(x, exp) =>                    | IR.S_GAssign(x, exp) =>
279                        (env, trAssign (env, lvalueGlobalVar (env, x), exp) :: stms)                        (env, trAssign (env, lvalueGlobalVar (env, x), exp) @ stms)
280                    | IR.S_IfThen(cond, thenBlk) =>                    | IR.S_IfThen(cond, thenBlk) =>
281                        (env, CL.mkIfThen(trExp(env, cond), trBlock(env, thenBlk)) :: stms)                        (env, CL.mkIfThen(trExp(env, cond), trBlock(env, thenBlk)) :: stms)
282                    | IR.S_IfThenElse(cond, thenBlk, elseBlk) => let                    | IR.S_IfThenElse(cond, thenBlk, elseBlk) => let
# Line 282  Line 299 
299                        end                        end
300                    | IR.S_Foreach(x, e, blk) => ??                    | IR.S_Foreach(x, e, blk) => ??
301                    | IR.S_New(strand, args) => ??                    | IR.S_New(strand, args) => ??
302                    | IR.S_Save(x, exp) => trAssign (env, lvalueStateVar(env, x), exp)                    | IR.S_Save(x, exp) => (env, trAssign (env, lvalueStateVar(env, x), exp))
303                    | IR.S_LoadNrrd(lhs, nrrd) => let                    | IR.S_LoadNrrd(lhs, nrrd) => let
304                        val stm = (case V.ty lhs                        val stm = (case V.ty lhs
305                               of Ty.SeqTy(ty, NONE) =>                               of Ty.SeqTy(ty, NONE) =>

Legend:
Removed from v.3892  
changed lines
  Added in v.3893

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