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 3871, Tue May 17 15:09:13 2016 UTC revision 3872, Wed May 18 13:08:16 2016 UTC
# Line 35  Line 35 
35      structure Op = TreeOps      structure Op = TreeOps
36      structure Ty = TreeTypes      structure Ty = TreeTypes
37      structure V = TreeVar      structure V = TreeVar
38      structure VMap = VMap      structure VMap = V.Map
39    
40      datatype var = datatype CL.typed_var      datatype var = datatype CL.typed_var
41      type env = CLang.typed_var VMap.map      type env = CLang.typed_var VMap.map
# Line 92  Line 92 
92    
93    (* make an application of a function from the "diderot" namespace *)    (* make an application of a function from the "diderot" namespace *)
94      fun mkDiderotApply (f, args) = CL.mkApply("diderot::" ^ f, args)      fun mkDiderotApply (f, args) = CL.mkApply("diderot::" ^ f, args)
95        fun mkDiderotCall (f, args) = CL.mkCall("diderot::" ^ f, args)
96    
97    (* Translate a TreeIR operator application to a CLang expression *)    (* Translate a TreeIR operator application to a CLang expression *)
98      fun trOp (rator, args) = (case (rator, args)      fun trOp (rator, args) = (case (rator, args)
# Line 123  Line 124 
124              | (Op.VScale d, [a, b]) => CL.mkApply("vscale", [a, b])              | (Op.VScale d, [a, b]) => CL.mkApply("vscale", [a, b])
125              | (Op.VMul d, [a, b]) => CL.mkBinOp(a, CL.#*, b)              | (Op.VMul d, [a, b]) => CL.mkBinOp(a, CL.#*, b)
126              | (Op.VNeg d, [a]) => CL.mkUnOp(CL.%-, a)              | (Op.VNeg d, [a]) => CL.mkUnOp(CL.%-, a)
127              | (Op.VSum d, [a]) => CL.mkApply("vsum", [a, b])              | (Op.VSum d, [a]) => CL.mkApply("vsum", [a])
128              | (Op.VIndex(d, i), [a]) => CL.mkSubscript(a, intExp i)              | (Op.VIndex(d, i), [a]) => CL.mkSubscript(a, intExp i)
129              | (Op.VClamp d, [a, b, c]) => CL.mkApply("clamp", [a, b, c])              | (Op.VClamp d, [a, b, c]) => CL.mkApply("clamp", [a, b, c])
130              | (Op.VMapClamp d, [a, b, c]) => CL.mkApply("clamp", [a, b, c])              | (Op.VMapClamp d, [a, b, c]) => CL.mkApply("clamp", [a, b, c])
# Line 156  Line 157 
157              | (Op.Floor d, [a]) => ??              | (Op.Floor d, [a]) => ??
158              | (Op.Round 1, [a]) => mkStdApply("round", [a])              | (Op.Round 1, [a]) => mkStdApply("round", [a])
159              | (Op.Round d, [a]) => ??              | (Op.Round d, [a]) => ??
160              | (Op.Trunc 1, [a]) => mkStdApply("trun", [a])              | (Op.Trunc 1, [a]) => mkStdApply("trunc", [a])
161              | (Op.Trunc d, [a]) => ??              | (Op.Trunc d, [a]) => ??
162              | (Op.IntToReal, [a]) => ??              | (Op.IntToReal, [a]) => ??
163              | (Op.RealToInt 1, [a]) => ??              | (Op.RealToInt 1, [a]) => ??
# Line 187  Line 188 
188    
189      fun trExp (env, e) = (case e      fun trExp (env, e) = (case e
190             of IR.E_Global x => rvalueGlobalVar (env, x)             of IR.E_Global x => rvalueGlobalVar (env, x)
191              | IR.E_State x => rvalueStateVar (env, x)              | IR.E_State(NONE, x) => rvalueStateVar (env, x)
192                | IR.E_State(SOME e, x) => CL.mkIndirect(trExp(env, e), TreeStateVar.name x)
193              | IR.E_Var x => rvalueVar (env, x)              | IR.E_Var x => rvalueVar (env, x)
194              | IR.E_Lit(Literal.Int n) => CL.mkIntTy(n, !CTyN.gIntTy)              | IR.E_Lit(Literal.Int n) => CL.mkIntTy(n, !CTyN.gIntTy)
195              | IR.E_Lit(Literal.Bool b) => CL.mkBool b              | IR.E_Lit(Literal.Bool b) => CL.mkBool b
# Line 203  Line 205 
205    
206      and trExps (env, exps) = List.map (fn exp => trExp(env, exp)) exps      and trExps (env, exps) = List.map (fn exp => trExp(env, exp)) exps
207    
208      fun trMultiAssign (env, lhs, IR.E_Op(rator, args)) = (case (lhs, rator, args)      fun trExpToVar (env, ty, name, exp) = (case trExp (env, exp)
209             of ([vals, vecs], Op.EigenVecs2x2, [m]) => let             of e as CL.E_Var _ => (e, [])
210                  val (m, stms) = expToVar (env, CTyN.matTy(2,2), "m", m)              | e => let
211                    val x = freshName name
212                  in                  in
213                    stms @ [CL.mkCall(MathN.evecs2x2, [                    (CL.mkVar x, pCL.mkDeclInit(ty, x, e))
                       vals, vecs,  
                       matIndex (m, CL.mkInt 0, CL.mkInt 0),  
                       matIndex (m, CL.mkInt 0, CL.mkInt 1),  
                       matIndex (m, CL.mkInt 1, CL.mkInt 1)  
                     ])]  
214                  end                  end
215    
216        fun trRHS mkStm (env, rhs) = (case rhs
217               of IR.E_Op(??, args) => ???
218                | IR.E_Cons(args, Ty.TensorTy shape) => ??
219                | IR.E_Seq(args, ty) => ??
220                | _ => mkStm (trExp (env, rhs)) (* generic case *)
221              (* end case *))
222    
223        fun trAssign (env, lhs, rhs) =
224              trRHS (fn rhs => CL.mkAssign(lhs, rhs)) (env, rhs)
225    
226        fun trDecl (env, ty, lhs, rhs) =
227              trRHS (fn rhs => CL.mkDeclInit(ty, lhs, rhs)) (env, rhs)
228    
229        fun trMultiAssign (env, lhs, IR.E_Op(rator, args)) = (case (lhs, rator, args)
230               of ([vals, vecs], Op.EigenVecs2x2, [m]) =>
231                    mkDiderotCall("eigenvecs", [trExp (env, exp), vals, vecs])
232              | ([vals, vecs], Op.EigenVecs3x3, [m]) => let              | ([vals, vecs], Op.EigenVecs3x3, [m]) => let
233                  val (m, stms) = expToVar (env, CTyN.matTy(3,3), "m", m)                  mkDiderotCall("eigenvecs", [trExp (env, exp), vals, vecs])
                 in  
                   stms @ [CL.mkCall(MathN.evecs3x3, [  
                       vals, vecs,  
                       matIndex (m, CL.mkInt 0, CL.mkInt 0),  
                       matIndex (m, CL.mkInt 0, CL.mkInt 1),  
                       matIndex (m, CL.mkInt 0, CL.mkInt 2),  
                       matIndex (m, CL.mkInt 1, CL.mkInt 1),  
                       matIndex (m, CL.mkInt 1, CL.mkInt 2),  
                       matIndex (m, CL.mkInt 2, CL.mkInt 2)  
                     ])]  
                 end  
234              | _ => raise Fail "bogus multi-assignment"              | _ => raise Fail "bogus multi-assignment"
235            (* end case *))            (* end case *))
236        | trMultiAssign (env, lhs, rhs) = raise Fail "bogus multi-assignment"        | trMultiAssign (env, lhs, rhs) = raise Fail "bogus multi-assignment"
# Line 236  Line 240 
240              (fn (x, env) => VMap.insert(env, x, V(trType(V.ty x), V.name x)))              (fn (x, env) => VMap.insert(env, x, V(trType(V.ty x), V.name x)))
241                env locals                env locals
242    
243      fun trStms (env, stms : CL.stm list) = let      fun trStms (env, stms : TreeIR.stm list) = let
244            fun trStm (stm, (env, stms : CL.stm list)) = (case stm            fun trStm (stm, (env, stms : CL.stm list)) = (case stm
245                   of IR.S_Comment text => (env, CL.mkComment text :: stms)                   of IR.S_Comment text => (env, CL.mkComment text :: stms)
246                    | IR.S_Assign(isDecl, x, exp) => let                    | IR.S_Assign(true, x, exp) => let
247                          val (env, stm) = trDecl (env, ??, lookup (env, x), exp)
248                          in
249                            (env, stm::stms)
250                          end
251                      | IR.S_Assign(false, x, exp) => let
252                        val (env, stm) = trAssign (env, lvalueVar (env, x), exp)                        val (env, stm) = trAssign (env, lvalueVar (env, x), exp)
253                        in                        in
254                          (env, stm::stms)                          (env, stm::stms)
# Line 287  Line 296 
296            end            end
297    
298      and trBlock (env, IR.Block{locals, body}) = let      and trBlock (env, IR.Block{locals, body}) = let
299            val env = trLocals (env, locals)            val env = trLocals (env, !locals)
300            val stms = trStms (env, body)            val stms = trStms (env, body)
301            fun mkDecl (x, stms) = (case VMap.find (env, x)            fun mkDecl (x, stms) = (case VMap.find (env, x)
302                   of SOME(V(ty, x')) => CL.mkDecl(ty, x', NONE) :: stms                   of SOME(V(ty, x')) => CL.mkDecl(ty, x', NONE) :: stms
303                    | NONE => raise Fail(concat["mkDecl(", V.name x, ", _)"])                    | NONE => raise Fail(concat["mkDecl(", V.name x, ", _)"])
304                  (* end case *))                  (* end case *))
305            val stms = List.foldr mkDecl stms locals            val stms = List.foldr mkDecl stms (!locals)
306            in            in
307              CL.mkBlock stms              CL.mkBlock stms
308            end            end

Legend:
Removed from v.3871  
changed lines
  Added in v.3872

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