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

branches/vis15/src/compiler/c-util/tree-to-c.sml revision 3869, Tue May 17 12:41:49 2016 UTC branches/vis15/src/compiler/c-util/tree-to-cxx.sml revision 3870, Tue May 17 13:53:58 2016 UTC
# Line 95  Line 95 
95    
96    (* Translate a TreeIR operator application to a CLang expression *)    (* Translate a TreeIR operator application to a CLang expression *)
97      fun trOp (rator, args) = (case (rator, args)      fun trOp (rator, args) = (case (rator, args)
98              | (Op.IAdd, [a, b]) => CL.mkBinOp(a, CL.#+, b)             of (Op.IAdd, [a, b]) => CL.mkBinOp(a, CL.#+, b)
99              | (Op.ISub, [a, b]) => CL.mkBinOp(a, CL.#-, b)              | (Op.ISub, [a, b]) => CL.mkBinOp(a, CL.#-, b)
100              | (Op.IMul, [a, b]) => CL.mkBinOp(a, CL.#*, b)              | (Op.IMul, [a, b]) => CL.mkBinOp(a, CL.#*, b)
101              | (Op.IDiv, [a, b]) => CL.mkBinOp(a, CL.#/, b)              | (Op.IDiv, [a, b]) => CL.mkBinOp(a, CL.#/, b)
# Line 106  Line 106 
106              | (Op.RMul, [a, b]) => CL.mkBinOp(a, CL.#*, b)              | (Op.RMul, [a, b]) => CL.mkBinOp(a, CL.#*, b)
107              | (Op.RDiv, [a, b]) => CL.mkBinOp(a, CL.#/, b)              | (Op.RDiv, [a, b]) => CL.mkBinOp(a, CL.#/, b)
108              | (Op.RNeg, [a]) => CL.mkUnOp(CL.%-, a)              | (Op.RNeg, [a]) => CL.mkUnOp(CL.%-, a)
109              | (Op.RClamp, [a, b, c]) =>              | (Op.RClamp, [a, b, c]) => CL.mkApply("clamp", [a, b, c])
110              | (Op.RLerp, [a, b, c]) =>              | (Op.RLerp, [a, b, c]) => CL.mkApply("lerp", [a, b, c])
111              | (Op.LT ty, [a, b]) => CL.mkBinOp(a, CL.#<, b)              | (Op.LT ty, [a, b]) => CL.mkBinOp(a, CL.#<, b)
112              | (Op.LTE ty, [a, b]) => CL.mkBinOp(a, CL.#<=, b)              | (Op.LTE ty, [a, b]) => CL.mkBinOp(a, CL.#<=, b)
113              | (Op.EQ ty, [a, b]) => CL.mkBinOp(a, CL.#==, b)              | (Op.EQ ty, [a, b]) => CL.mkBinOp(a, CL.#==, b)
# Line 120  Line 120 
120              | (Op.Min ty, args) => mkStdApply("max", args)              | (Op.Min ty, args) => mkStdApply("max", args)
121              | (Op.VAdd d, [a, b]) => CL.mkBinOp(a, CL.#+, b)              | (Op.VAdd d, [a, b]) => CL.mkBinOp(a, CL.#+, b)
122              | (Op.VSub d, [a, b]) => CL.mkBinOp(a, CL.#-, b)              | (Op.VSub d, [a, b]) => CL.mkBinOp(a, CL.#-, b)
123              | (Op.VScale d, [a, b]) =>              | (Op.VScale d, [a, b]) => CL.mkApply("vscale", [a, b])
124              | (Op.VMul d, [a, b]) => CL.mkBinOp(a, CL.#*, b)              | (Op.VMul d, [a, b]) => CL.mkBinOp(a, CL.#*, b)
125              | (Op.VNeg d, [a]) => CL.mkUnOp(CL.%-, a)              | (Op.VNeg d, [a]) => CL.mkUnOp(CL.%-, a)
126              | (Op.VSum d, [a, b]) =>              | (Op.VSum d, [a]) => CL.mkApply("vsum", [a, b])
127              | (Op.VIndex(d, i), [a]) =>              | (Op.VIndex(d, i), [a]) => CL.mkSubscript(a, intExp i)
128              | (Op.VClamp d, [a, b, c]) =>              | (Op.VClamp d, [a, b, c]) => CL.mkApply("clamp", [a, b, c])
129              | (Op.VMapClamp d, [a, b, c]) =>              | (Op.VMapClamp d, [a, b, c]) => CL.mkApply("clamp", [a, b, c])
130              | (Op.VLerp d, [a, b, c]) =>              | (Op.VLerp d, [a, b, c]) => CL.mkApply("lerp", [a, b, c])
131              | (Op.TensorIndex(ty, idxs), [a]) =>              | (Op.TensorIndex(ty, idxs), [a]) => ??
132              | (Op.ProjectLast(ty, idxs), [a]) =>              | (Op.ProjectLast(ty, idxs), [a]) => ??
133              | (Op.EigenVecs2x2, []) =>              | (Op.EigenVals2x2, [a]) => ??
134              | (Op.EigenVecs3x3, []) =>              | (Op.EigenVals3x3, [a]) => ??
135              | (Op.EigenVals2x2, []) =>              | (Op.Zero ty, []) => ??
136              | (Op.EigenVals3x3, []) =>              | (Op.Select(ty, i), [a]) => ??
137              | (Op.Zero ty, []) =>              | (Op.Subscript ty, [a, b]) => ??
138              | (Op.Select(ty * int), []) =>              | (Op.MkDynamic(ty, i), [a]) => ??
139              | (Op.Subscript ty, []) =>              | (Op.Append ty, [a, b]) => ??
140              | (Op.MkDynamic(ty * int), []) =>              | (Op.Prepend ty, [a, b]) => ??
141              | (Op.Append ty, []) =>              | (Op.Concat ty, [a, b]) => ??
142              | (Op.Prepend ty, []) =>              | (Op.Range, [a, b]) => ??
143              | (Op.Concat ty, []) =>              | (Op.Length ty, [a]) => ??
144              | (Op.Range, []) =>              | (Op.SphereQuery(ty1, ty2), []) => ??
145              | (Op.Length ty, []) =>              | (Op.Sqrt, [a]) => mkStdApply("sqrt", [a])
146              | (Op.SphereQuery(ty * ty), []) =>              | (Op.Cos, [a]) => mkStdApply("cos", [a])
147              | (Op.Sqrt, []) =>              | (Op.ArcCos, [a]) => mkStdApply("acos", [a])
148              | (Op.Cos, []) =>              | (Op.Sin, [a]) => mkStdApply("sin", [a])
149              | (Op.ArcCos, []) =>              | (Op.ArcSin, [a]) => mkStdApply("asin", [a])
150              | (Op.Sin, []) =>              | (Op.Tan, [a]) => mkStdApply("tan", [a])
151              | (Op.ArcSin, []) =>              | (Op.ArcTan, [a]) => mkStdApply("atan", [a])
152              | (Op.Tan, []) =>              | (Op.Exp, [a]) => mkStdApply("exp", [a])
153              | (Op.ArcTan, []) =>              | (Op.Ceiling 1, [a]) => mkStdApply("ceil", [a])
154              | (Op.Exp, []) =>              | (Op.Ceiling d, [a]) => ??
155              | (Op.Ceiling d, []) =>              | (Op.Floor 1, [a]) => mkStdApply("floor", [a])
156              | (Op.Floor d, []) =>              | (Op.Floor d, [a]) => ??
157              | (Op.Round d, []) =>              | (Op.Round 1, [a]) => mkStdApply("round", [a])
158              | (Op.Trunc d, []) =>              | (Op.Round d, [a]) => ??
159              | (Op.IntToReal, []) =>              | (Op.Trunc 1, [a]) => mkStdApply("trun", [a])
160              | (Op.RealToInt d, []) =>              | (Op.Trunc d, [a]) => ??
161                | (Op.IntToReal, [a]) => ??
162                | (Op.RealToInt 1, [a]) => ??
163                | (Op.RealToInt d, [a]) => ??
164  (*  (*
165              | R_All of ty              | R_All of ty
166              | R_Exists of ty              | R_Exists of ty
# Line 168  Line 171 
171              | R_Mean of ty              | R_Mean of ty
172              | R_Variance of ty              | R_Variance of ty
173  *)  *)
174              | (Op.Transform(ImageInfo.info * int), []) =>              | (Op.Transform info, [img]) => ??
175              | (Op.Translate(ImageInfo.info), []) =>              | (Op.Translate info, [img]) => ??
176              | (Op.BaseAddress(ImageInfo.info), []) =>              | (Op.BaseAddress info, [img]) => ??
177              | (Op.ControlIndex(ImageInfo.info * idxctl * int), []) =>              | (Op.ControlIndex(info, ctl, i), [a]) => ??
178              | (Op.Inside(ImageInfo.info * int), []) =>              | (Op.Inside(info, i), [pos, img]) => ??
179              | (Op.ImageDim(ImageInfo.info * int), []) =>              | (Op.ImageDim(info, i), [img]) => ??
180              | (Op.LoadSeq(ty * string), []) =>              | (Op.LoadSeq(ty, file), []) => ??
181              | (Op.LoadImage(ty * string), []) =>              | (Op.LoadImage(ty, file), []) => ??
182              | (Op.MathFn f, args) => CL.mkApply(??, args)              | (Op.MathFn f, args) => mkStdApply(MathFns.toString f, args)
183              | _ => raise Fail(concat[              | _ => raise Fail(concat[
184                     "unknown or incorrect operator ", Op.toString rator                     "unknown or incorrect operator ", Op.toString rator
185                   ])                   ])
# Line 188  Line 191 
191              | IR.E_Var x => rvalueVar (env, x)              | IR.E_Var x => rvalueVar (env, x)
192              | IR.E_Lit(Literal.Int n) => CL.mkIntTy(n, !CTyN.gIntTy)              | IR.E_Lit(Literal.Int n) => CL.mkIntTy(n, !CTyN.gIntTy)
193              | IR.E_Lit(Literal.Bool b) => CL.mkBool b              | IR.E_Lit(Literal.Bool b) => CL.mkBool b
194              | IR.E_Lit(Literal.Float f) => CL.mkFlt(f, !CTyN.gRealTy)              | IR.E_Lit(Literal.Real f) => CL.mkFlt(f, !CTyN.gRealTy)
195              | IR.E_Lit(Literal.String s) => CL.mkStr s              | IR.E_Lit(Literal.String s) => CL.mkStr s
196              | IR.E_Op(rator, args) => trOp (rator, trExps(env, args))              | IR.E_Op(rator, args) => trOp (rator, trExps(env, args))
197              | IR.E_Apply(f, args) => trApply(f, trExps(env, args))              | IR.E_Vec(d, args) => ??
198              | IR.E_Cons(Ty.TensorTy[n], args) => CL.mkApply(MathN.mkVec n, trExps(env, args))              | IR.E_Cons(args, Ty.TensorTy shape) => ??
199              | IR.E_Cons(ty, _) => raise Fail(concat["E_Cons(", Ty.toString ty, ", _) in expression"])              | IR.E_Seq(args, ty) => ??
200                | IR.E_Pack(layout, args) => ??
201                | IR.E_VLoad(layout, e, i) => ??
202            (* end case *))            (* end case *))
203    
204      and trExps (env, exps) = List.map (fn exp => trExp(env, exp)) exps      and trExps (env, exps) = List.map (fn exp => trExp(env, exp)) exps
205    
206    (* translate a print expression *)      fun trMultiAssign (env, lhs, IR.E_Op(rator, args)) = (case (lhs, rator, args)
207      fun trPrint (env, tys, args) = let             of ([vals, vecs], Op.EigenVecs2x2, [m]) => let
208            val args = List.map (fn e => trExp(env, e)) args                  val (m, stms) = expToVar (env, CTyN.matTy(2,2), "m", m)
209                    in
210                      stms @ [CL.mkCall(MathN.evecs2x2, [
211                          vals, vecs,
212                          matIndex (m, CL.mkInt 0, CL.mkInt 0),
213                          matIndex (m, CL.mkInt 0, CL.mkInt 1),
214                          matIndex (m, CL.mkInt 1, CL.mkInt 1)
215                        ])]
216                    end
217                | ([vals, vecs], Op.EigenVecs3x3, [m]) => let
218                    val (m, stms) = expToVar (env, CTyN.matTy(3,3), "m", m)
219            in            in
220              GenPrint.genPrintStm (CL.mkIndirect(CL.mkVar "wrld", "_output"), tys, args)                    stms @ [CL.mkCall(MathN.evecs3x3, [
221                          vals, vecs,
222                          matIndex (m, CL.mkInt 0, CL.mkInt 0),
223                          matIndex (m, CL.mkInt 0, CL.mkInt 1),
224                          matIndex (m, CL.mkInt 0, CL.mkInt 2),
225                          matIndex (m, CL.mkInt 1, CL.mkInt 1),
226                          matIndex (m, CL.mkInt 1, CL.mkInt 2),
227                          matIndex (m, CL.mkInt 2, CL.mkInt 2)
228                        ])]
229            end            end
230                | _ => raise Fail "bogus multi-assignment"
231              (* end case *))
232          | trMultiAssign (env, lhs, rhs) = raise Fail "bogus multi-assignment"
233    
234      fun trLocals (env : env, locals) =      fun trLocals (env : env, locals) =
235            List.foldl            List.foldl
236              (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)))
237                env locals                env locals
238    
239      fun trStms (env, stms) = let      fun trStms (env, stms : CL.stm list) = let
240            fun trStm (stm, (env, stms)) = (case stm            fun trStm (stm, (env, stms : CL.stm list)) = (case stm
241                   of IR.S_Comment text => CL.mkComment text :: stms                   of IR.S_Comment text => (env, CL.mkComment text :: stms)
242                    | IR.S_Assign(isDecl, x, exp) => let                    | IR.S_Assign(isDecl, x, exp) => let
243                        val (env, stm) = trAssign (env, lvalueVar (env, x), exp)                        val (env, stm) = trAssign (env, lvalueVar (env, x), exp)
244                        in                        in
245                          (env, stm::stms)                          (env, stm::stms)
246                        end                        end
247                    | IR.S_MAssign(xs, exp) =>                    | IR.S_MAssign(xs, exp) =>
248                        (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)
249                    | IR.S_GAssign(x, exp) =>                    | IR.S_GAssign(x, exp) =>
250                        (env, trAssign (env, lvalueGlobalVar (env, x), exp) :: stms)                        (env, trAssign (env, lvalueGlobalVar (env, x), exp) :: stms)
251                    | IR.S_IfThen(cond, thenBlk) =>                    | IR.S_IfThen(cond, thenBlk) =>
252                        (env, CL.mkIfThen(trExp(env, cond), trBlk(env, thenBlk)) :: stms)                        (env, CL.mkIfThen(trExp(env, cond), trBlock(env, thenBlk)) :: stms)
253                    | IR.S_IfThenElse(cond, thenBlk, elseBlk) => let                    | IR.S_IfThenElse(cond, thenBlk, elseBlk) => let
254                        val stm = CL.mkIfThenElse(trExp(env, cond),                        val stm = CL.mkIfThenElse(trExp(env, cond),
255                              trBlk(env, thenBlk),                              trBlock(env, thenBlk),
256                              trBlk(env, elseBlk))                              trBlock(env, elseBlk))
257                        in                        in
258                          (env, stm :: stms)                          (env, stm :: stms)
259                        end                        end
# Line 235  Line 261 
261                    | IR.S_Foreach(x, e, blk) => ??                    | IR.S_Foreach(x, e, blk) => ??
262                    | IR.S_New(strand, args) => ??                    | IR.S_New(strand, args) => ??
263                    | IR.S_Save(x, exp) => trAssign (env, lvalueStateVar(env, x), exp)                    | IR.S_Save(x, exp) => trAssign (env, lvalueStateVar(env, x), exp)
264                    | IR.S_LoadNrrd(lhs, Ty.DynSeqTy ty, nrrd) =>                    | IR.S_LoadNrrd(lhs, Ty.SeqTy(ty, NONE), nrrd) =>
265                        [GenLoadNrrd.loadSeqFromFile (lvalueVar (env, lhs), ty, CL.mkStr nrrd)]                        (env, GenLoadNrrd.loadSeqFromFile (lvalueVar (env, lhs), ty, CL.mkStr nrrd) :: stms)
266                    | IR.S_LoadNrrd(lhs, Ty.ImageTy info, nrrd) =>                    | IR.S_LoadNrrd(lhs, Ty.ImageTy info, nrrd) =>
267                        [GenLoadNrrd.loadImage (lvalueVar (env, lhs), info, CL.mkStr nrrd)]                        (env, GenLoadNrrd.loadImage (lvalueVar (env, lhs), info, CL.mkStr nrrd) :: stms)
268                    | IR.S_Input(_, _, _, NONE) => []                    | IR.S_Input(_, _, _, NONE) => (env, stms)
269                    | IR.S_Input(gv, name, _, SOME dflt) => [                    | IR.S_Input(gv, name, _, SOME dflt) =>
270                          CL.mkAssign(lvalueGlobalVar (env, gv), trExp(env, dflt))                        (env, CL.mkAssign(lvalueGlobalVar (env, gv), trExp(env, dflt)) :: stms)
                       ]  
271                    | IR.S_InputNrrd _ => (env, stms)                    | IR.S_InputNrrd _ => (env, stms)
272                    | IR.S_Exit args => (env, stms)                    | IR.S_Exit => (env, stms)
273                    | IR.S_Print(tys, args) => ??                    | IR.S_Print(tys, args) => let
274                          val args = List.map (fn e => trExp(env, e)) args
275                          val stm = GenPrint.genPrintStm (
276                                CL.mkIndirect(CL.mkVar "wrld", "_output"),
277                                tys, args)
278                          in
279                            (env, stm::stms)
280                          end
281                    | IR.S_Active => (env, CL.mkReturn(SOME(CL.mkVar RN.kActive)) :: stms)                    | IR.S_Active => (env, CL.mkReturn(SOME(CL.mkVar RN.kActive)) :: stms)
282                    | IR.S_Stabilize => (env, CL.mkReturn(SOME(CL.mkVar RN.kStabilize)) :: stms)                    | IR.S_Stabilize => (env, CL.mkReturn(SOME(CL.mkVar RN.kStabilize)) :: stms)
283                    | IR.S_Die => (env, CL.mkReturn(SOME(CL.mkVar RN.kDie)) :: stms)                    | IR.S_Die => (env, CL.mkReturn(SOME(CL.mkVar RN.kDie)) :: stms)

Legend:
Removed from v.3869  
changed lines
  Added in v.3870

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