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

SCM Repository

[diderot] Diff of /trunk/src/compiler/c-util/tree-to-c.sml
ViewVC logotype

Diff of /trunk/src/compiler/c-util/tree-to-c.sml

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

revision 1372, Wed Jun 22 21:24:17 2011 UTC revision 1373, Wed Jun 22 21:36:18 2011 UTC
# Line 29  Line 29 
29    end = struct    end = struct
30    
31      structure CL = CLang      structure CL = CLang
32      structure RN = RuntimeNames      structure N = CNames
33      structure IL = TreeIL      structure IL = TreeIL
34      structure Op = IL.Op      structure Op = IL.Op
35      structure Ty = IL.Ty      structure Ty = IL.Ty
# Line 51  Line 51 
51      fun trType ty = (case ty      fun trType ty = (case ty
52             of Ty.BoolTy => CLang.T_Named "bool"             of Ty.BoolTy => CLang.T_Named "bool"
53              | Ty.StringTy => CL.charPtr              | Ty.StringTy => CL.charPtr
54              | Ty.IVecTy 1 => !RN.gIntTy              | Ty.IVecTy 1 => !N.gIntTy
55              | Ty.IVecTy n => CL.T_Named(RN.ivecTy n)              | Ty.IVecTy n => CL.T_Named(N.ivecTy n)
56              | Ty.TensorTy[] => !RN.gRealTy              | Ty.TensorTy[] => !N.gRealTy
57              | Ty.TensorTy[n] => CL.T_Named(RN.vecTy n)              | Ty.TensorTy[n] => CL.T_Named(N.vecTy n)
58              | Ty.TensorTy[n, m] => CL.T_Named(RN.matTy(n,m))              | Ty.TensorTy[n, m] => CL.T_Named(N.matTy(n,m))
59              | Ty.AddrTy(ImageInfo.ImgInfo{ty=(_, rTy), ...}) => CL.T_Ptr(CL.T_Num rTy)              | Ty.AddrTy(ImageInfo.ImgInfo{ty=(_, rTy), ...}) => CL.T_Ptr(CL.T_Num rTy)
60              | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) => CL.T_Ptr(CL.T_Named(RN.imageTy dim))              | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) => CL.T_Ptr(CL.T_Named(N.imageTy dim))
61              | _ => raise Fail(concat["TreeToC.trType(", Ty.toString ty, ")"])              | _ => raise Fail(concat["TreeToC.trType(", Ty.toString ty, ")"])
62            (* end case *))            (* end case *))
63    
# Line 88  Line 88 
88        val dLookup = mkLookup ""        val dLookup = mkLookup ""
89      in      in
90      fun trApply (f, args) = let      fun trApply (f, args) = let
91            val f' = if !RN.doublePrecision then dLookup f else fLookup f            val f' = if !N.doublePrecision then dLookup f else fLookup f
92            in            in
93              CL.mkApply(f', args)              CL.mkApply(f', args)
94            end            end
# Line 96  Line 96 
96    
97    (* vector indexing support.  Arguments are: vector, arity, index *)    (* vector indexing support.  Arguments are: vector, arity, index *)
98      fun ivecIndex (v, n, ix) = let      fun ivecIndex (v, n, ix) = let
99            val unionTy = CL.T_Named(concat["union", Int.toString n, !RN.gIntSuffix, "_t"])            val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gIntSuffix, "_t"])
100            val e1 = CL.mkCast(unionTy, v)            val e1 = CL.mkCast(unionTy, v)
101            val e2 = CL.mkSelect(e1, "i")            val e2 = CL.mkSelect(e1, "i")
102            in            in
# Line 104  Line 104 
104            end            end
105    
106      fun vecIndex (v, n, ix) = let      fun vecIndex (v, n, ix) = let
107            val unionTy = CL.T_Named(concat["union", Int.toString n, !RN.gRealSuffix, "_t"])            val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gRealSuffix, "_t"])
108            val e1 = CL.mkCast(unionTy, v)            val e1 = CL.mkCast(unionTy, v)
109            val e2 = CL.mkSelect(e1, "r")            val e2 = CL.mkSelect(e1, "r")
110            in            in
# Line 133  Line 133 
133              | (Op.Abs(Ty.IVecTy 1), args) =>              | (Op.Abs(Ty.IVecTy 1), args) =>
134                  CL.mkApply("abs", args)                  CL.mkApply("abs", args)
135              | (Op.Abs(Ty.TensorTy[]), args) =>              | (Op.Abs(Ty.TensorTy[]), args) =>
136                  CL.mkApply(RN.fabs(), args)                  CL.mkApply(N.fabs(), args)
137              | (Op.Abs ty, [a]) =>              | (Op.Abs ty, [a]) =>
138                  raise Fail(concat["Abs<", Ty.toString ty, ">"])                  raise Fail(concat["Abs<", Ty.toString ty, ">"])
139              | (Op.LT ty, [a, b]) =>              | (Op.LT ty, [a, b]) =>
# Line 151  Line 151 
151              | (Op.Not, [a]) =>              | (Op.Not, [a]) =>
152                  CL.mkUnOp(CL.%!, a)                  CL.mkUnOp(CL.%!, a)
153              | (Op.Max, args) =>              | (Op.Max, args) =>
154                  CL.mkApply(RN.max(), args)                  CL.mkApply(N.max(), args)
155              | (Op.Min, args) =>              | (Op.Min, args) =>
156                  CL.mkApply(RN.min(), args)                  CL.mkApply(N.min(), args)
157              | (Op.Clamp(Ty.TensorTy[]), args) => CL.mkApply(RN.clamp 1, args)              | (Op.Clamp(Ty.TensorTy[]), args) => CL.mkApply(N.clamp 1, args)
158              | (Op.Clamp(Ty.TensorTy[n]), args) => CL.mkApply(RN.clamp n, args)              | (Op.Clamp(Ty.TensorTy[n]), args) => CL.mkApply(N.clamp n, args)
159              | (Op.Lerp ty, args) => (case ty              | (Op.Lerp ty, args) => (case ty
160                   of Ty.TensorTy[] => CL.mkApply(RN.lerp 1, args)                   of Ty.TensorTy[] => CL.mkApply(N.lerp 1, args)
161                    | Ty.TensorTy[n] => CL.mkApply(RN.lerp n, args)                    | Ty.TensorTy[n] => CL.mkApply(N.lerp n, args)
162                    | _ => raise Fail(concat[                    | _ => raise Fail(concat[
163                          "lerp<", Ty.toString ty, "> not supported"                          "lerp<", Ty.toString ty, "> not supported"
164                        ])                        ])
165                  (* end case *))                  (* end case *))
166              | (Op.Dot d, args) =>              | (Op.Dot d, args) =>
167                  CL.E_Apply(RN.dot d, args)                  CL.E_Apply(N.dot d, args)
168              | (Op.MulVecMat(m, n), args) =>              | (Op.MulVecMat(m, n), args) =>
169                  if (1 < m) andalso (m < 4) andalso (m = n)                  if (1 < m) andalso (m < 4) andalso (m = n)
170                    then CL.E_Apply(RN.mulVecMat(m,n), args)                    then CL.E_Apply(N.mulVecMat(m,n), args)
171                    else raise Fail "unsupported vector-matrix multiply"                    else raise Fail "unsupported vector-matrix multiply"
172              | (Op.MulMatVec(m, n), args) =>              | (Op.MulMatVec(m, n), args) =>
173                  if (1 < m) andalso (m < 4) andalso (m = n)                  if (1 < m) andalso (m < 4) andalso (m = n)
174                    then CL.E_Apply(RN.mulMatVec(m,n), args)                    then CL.E_Apply(N.mulMatVec(m,n), args)
175                    else raise Fail "unsupported matrix-vector multiply"                    else raise Fail "unsupported matrix-vector multiply"
176              | (Op.MulMatMat(m, n, p), args) =>              | (Op.MulMatMat(m, n, p), args) =>
177                  if (1 < m) andalso (m < 4) andalso (m = n) andalso (n = p)                  if (1 < m) andalso (m < 4) andalso (m = n) andalso (n = p)
178                    then CL.E_Apply(RN.mulMatMat(m,n,p), args)                    then CL.E_Apply(N.mulMatMat(m,n,p), args)
179                    else raise Fail "unsupported matrix-matrix multiply"                    else raise Fail "unsupported matrix-matrix multiply"
180              | (Op.Cross, args) =>              | (Op.Cross, args) =>
181                  CL.E_Apply(RN.cross(), args)                  CL.E_Apply(N.cross(), args)
182              | (Op.Select(Ty.IVecTy n, i), [a]) =>              | (Op.Select(Ty.IVecTy n, i), [a]) =>
183                  ivecIndex (a, n, i)                  ivecIndex (a, n, i)
184              | (Op.Select(Ty.TensorTy[n], i), [a]) =>              | (Op.Select(Ty.TensorTy[n], i), [a]) =>
185                  vecIndex (a, n, i)                  vecIndex (a, n, i)
186              | (Op.Norm(Ty.TensorTy[n]), args) =>              | (Op.Norm(Ty.TensorTy[n]), args) =>
187                  CL.E_Apply(RN.length n, args)                  CL.E_Apply(N.length n, args)
188              | (Op.Norm(Ty.TensorTy[m,n]), args) =>              | (Op.Norm(Ty.TensorTy[m,n]), args) =>
189                  CL.E_Apply(RN.norm(m,n), args)                  CL.E_Apply(N.norm(m,n), args)
190              | (Op.Normalize d, args) =>              | (Op.Normalize d, args) =>
191                  CL.E_Apply(RN.normalize d, args)                  CL.E_Apply(N.normalize d, args)
192              | (Op.Trace n, args) =>              | (Op.Trace n, args) =>
193                  CL.E_Apply(RN.trace n, args)                  CL.E_Apply(N.trace n, args)
194              | (Op.Scale(Ty.TensorTy[n]), args) =>              | (Op.Scale(Ty.TensorTy[n]), args) =>
195                  CL.E_Apply(RN.scale n, args)                  CL.E_Apply(N.scale n, args)
196              | (Op.CL, _) =>              | (Op.CL, _) =>
197                  raise Fail "CL unimplemented"                  raise Fail "CL unimplemented"
198              | (Op.PrincipleEvec ty, _) =>              | (Op.PrincipleEvec ty, _) =>
199                  raise Fail "PrincipleEvec unimplemented"                  raise Fail "PrincipleEvec unimplemented"
200              | (Op.Subscript(Ty.IVecTy n), [v, ix]) => let              | (Op.Subscript(Ty.IVecTy n), [v, ix]) => let
201                  val unionTy = CL.T_Named(concat["union", Int.toString n, !RN.gIntSuffix, "_t"])                  val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gIntSuffix, "_t"])
202                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "i")                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "i")
203                  in                  in
204                    CL.mkSubscript(vecExp, ix)                    CL.mkSubscript(vecExp, ix)
205                  end                  end
206              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let
207                  val unionTy = CL.T_Named(concat["union", Int.toString n, !RN.gRealSuffix, "_t"])                  val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gRealSuffix, "_t"])
208                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")
209                  in                  in
210                    CL.mkSubscript(vecExp, ix)                    CL.mkSubscript(vecExp, ix)
# Line 214  Line 214 
214              | (Op.Subscript ty, t::(ixs as _::_)) =>              | (Op.Subscript ty, t::(ixs as _::_)) =>
215                  raise Fail(concat["Subscript<", Ty.toString ty, "> unsupported"])                  raise Fail(concat["Subscript<", Ty.toString ty, "> unsupported"])
216              | (Op.Ceiling d, args) =>              | (Op.Ceiling d, args) =>
217                  CL.mkApply(RN.addTySuffix("ceil", d), args)                  CL.mkApply(N.addTySuffix("ceil", d), args)
218              | (Op.Floor d, args) =>              | (Op.Floor d, args) =>
219                  CL.mkApply(RN.addTySuffix("floor", d), args)                  CL.mkApply(N.addTySuffix("floor", d), args)
220              | (Op.Round d, args) =>              | (Op.Round d, args) =>
221                  CL.mkApply(RN.addTySuffix("round", d), args)                  CL.mkApply(N.addTySuffix("round", d), args)
222              | (Op.Trunc d, args) =>              | (Op.Trunc d, args) =>
223                  CL.mkApply(RN.addTySuffix("trunc", d), args)                  CL.mkApply(N.addTySuffix("trunc", d), args)
224              | (Op.IntToReal, [a]) =>              | (Op.IntToReal, [a]) =>
225                  CL.mkCast(!RN.gRealTy, a)                  CL.mkCast(!N.gRealTy, a)
226              | (Op.RealToInt 1, [a]) =>              | (Op.RealToInt 1, [a]) =>
227                  CL.mkCast(!RN.gIntTy, a)                  CL.mkCast(!N.gIntTy, a)
228              | (Op.RealToInt d, args) =>              | (Op.RealToInt d, args) =>
229                  CL.mkApply(RN.vecftoi d, args)                  CL.mkApply(N.vecftoi d, args)
230  (* FIXME: need type info *)  (* FIXME: need type info *)
231              | (Op.ImageAddress(ImageInfo.ImgInfo{ty=(_,rTy), ...}), [a]) => let              | (Op.ImageAddress(ImageInfo.ImgInfo{ty=(_,rTy), ...}), [a]) => let
232                  val cTy = CL.T_Ptr(CL.T_Num rTy)                  val cTy = CL.T_Ptr(CL.T_Num rTy)
# Line 234  Line 234 
234                    CL.mkCast(cTy, CL.mkIndirect(a, "data"))                    CL.mkCast(cTy, CL.mkIndirect(a, "data"))
235                  end                  end
236              | (Op.LoadVoxels(info, 1), [a]) => let              | (Op.LoadVoxels(info, 1), [a]) => let
237                  val realTy as CL.T_Num rTy = !RN.gRealTy                  val realTy as CL.T_Num rTy = !N.gRealTy
238                  val a = CL.E_UnOp(CL.%*, a)                  val a = CL.E_UnOp(CL.%*, a)
239                  in                  in
240                    if (rTy = ImageInfo.sampleTy info)                    if (rTy = ImageInfo.sampleTy info)
# Line 244  Line 244 
244              | (Op.LoadVoxels _, [a]) =>              | (Op.LoadVoxels _, [a]) =>
245                  raise Fail("impossible " ^ Op.toString rator)                  raise Fail("impossible " ^ Op.toString rator)
246              | (Op.PosToImgSpace(ImageInfo.ImgInfo{dim, ...}), [img, pos]) =>              | (Op.PosToImgSpace(ImageInfo.ImgInfo{dim, ...}), [img, pos]) =>
247                  CL.mkApply(RN.toImageSpace dim, [img, pos])                  CL.mkApply(N.toImageSpace dim, [img, pos])
248              | (Op.TensorToWorldSpace(info, ty), [v, x]) =>              | (Op.TensorToWorldSpace(info, ty), [v, x]) =>
249                  CL.mkApply(RN.toWorldSpace ty, [v, x])                  CL.mkApply(N.toWorldSpace ty, [v, x])
250              | (Op.LoadImage info, [a]) =>              | (Op.LoadImage info, [a]) =>
251                  raise Fail("impossible " ^ Op.toString rator)                  raise Fail("impossible " ^ Op.toString rator)
252              | (Op.Inside(ImageInfo.ImgInfo{dim, ...}, s), [pos, img]) =>              | (Op.Inside(ImageInfo.ImgInfo{dim, ...}, s), [pos, img]) =>
253                  CL.mkApply(RN.inside dim, [pos, img, intExp s])                  CL.mkApply(N.inside dim, [pos, img, intExp s])
254              | (Op.Input(ty, desc, name), []) =>              | (Op.Input(ty, desc, name), []) =>
255                  raise Fail("impossible " ^ Op.toString rator)                  raise Fail("impossible " ^ Op.toString rator)
256              | (Op.InputWithDefault(ty, desc, name), [a]) =>              | (Op.InputWithDefault(ty, desc, name), [a]) =>
# Line 262  Line 262 
262    
263      fun trExp (env, e) = (case e      fun trExp (env, e) = (case e
264             of IL.E_Var x => trVar (env, x)             of IL.E_Var x => trVar (env, x)
265              | IL.E_Lit(Literal.Int n) => CL.mkIntTy(n, !RN.gIntTy)              | IL.E_Lit(Literal.Int n) => CL.mkIntTy(n, !N.gIntTy)
266              | IL.E_Lit(Literal.Bool b) => CL.mkBool b              | IL.E_Lit(Literal.Bool b) => CL.mkBool b
267              | IL.E_Lit(Literal.Float f) => CL.mkFlt(f, !RN.gRealTy)              | IL.E_Lit(Literal.Float f) => CL.mkFlt(f, !N.gRealTy)
268              | IL.E_Lit(Literal.String s) => CL.mkStr s              | IL.E_Lit(Literal.String s) => CL.mkStr s
269              | IL.E_Op(rator, args) => trOp (rator, trExps(env, args))              | IL.E_Op(rator, args) => trOp (rator, trExps(env, args))
270              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))
271              | IL.E_Cons(Ty.TensorTy[n], args) => CL.mkApply(RN.mkVec n, trExps(env, args))              | IL.E_Cons(Ty.TensorTy[n], args) => CL.mkApply(N.mkVec n, trExps(env, args))
272              | IL.E_Cons(ty, _) => raise Fail(concat["E_Cons(", Ty.toString ty, ", _) in expression"])              | IL.E_Cons(ty, _) => raise Fail(concat["E_Cons(", Ty.toString ty, ", _) in expression"])
273            (* end case *))            (* end case *))
274    
# Line 286  Line 286 
286             *)             *)
287              case rhs              case rhs
288               of IL.E_Op(Op.Add(Ty.TensorTy[m,n]), args) =>               of IL.E_Op(Op.Add(Ty.TensorTy[m,n]), args) =>
289                    [CL.mkCall(RN.addMat(m,n),  lhs :: trExps(env, args))]                    [CL.mkCall(N.addMat(m,n),  lhs :: trExps(env, args))]
290                | IL.E_Op(Op.Sub(Ty.TensorTy[m,n]), args) =>                | IL.E_Op(Op.Sub(Ty.TensorTy[m,n]), args) =>
291                    [CL.mkCall(RN.subMat(m,n),  lhs :: trExps(env, args))]                    [CL.mkCall(N.subMat(m,n),  lhs :: trExps(env, args))]
292                | IL.E_Op(Op.Neg(Ty.TensorTy[m,n]), args) =>                | IL.E_Op(Op.Neg(Ty.TensorTy[m,n]), args) =>
293                    [CL.mkCall(RN.scaleMat(m,n),  lhs :: intExp ~1 :: trExps(env, args))]                    [CL.mkCall(N.scaleMat(m,n),  lhs :: intExp ~1 :: trExps(env, args))]
294                | IL.E_Op(Op.Scale(Ty.TensorTy[m,n]), args) =>                | IL.E_Op(Op.Scale(Ty.TensorTy[m,n]), args) =>
295                    [CL.mkCall(RN.scaleMat(m,n),  lhs :: trExps(env, args))]                    [CL.mkCall(N.scaleMat(m,n),  lhs :: trExps(env, args))]
296                | IL.E_Op(Op.MulMatMat(m,n,p), args) =>                | IL.E_Op(Op.MulMatMat(m,n,p), args) =>
297                    [CL.mkCall(RN.mulMatMat(m,n,p), lhs :: trExps(env, args))]                    [CL.mkCall(N.mulMatMat(m,n,p), lhs :: trExps(env, args))]
298                | IL.E_Op(Op.Identity n, args) =>                | IL.E_Op(Op.Identity n, args) =>
299                    [CL.mkCall(RN.identityMat n, [lhs])]                    [CL.mkCall(N.identityMat n, [lhs])]
300                | IL.E_Op(Op.Zero(Ty.TensorTy[m,n]), args) =>                | IL.E_Op(Op.Zero(Ty.TensorTy[m,n]), args) =>
301                    [CL.mkCall(RN.zeroMat(m,n), [lhs])]                    [CL.mkCall(N.zeroMat(m,n), [lhs])]
302                | IL.E_Op(Op.TensorToWorldSpace(info, ty as Ty.TensorTy[_,_]), args) =>                | IL.E_Op(Op.TensorToWorldSpace(info, ty as Ty.TensorTy[_,_]), args) =>
303                    [CL.mkCall(RN.toWorldSpace ty, lhs :: trExps(env, args))]                    [CL.mkCall(N.toWorldSpace ty, lhs :: trExps(env, args))]
304                | IL.E_Op(Op.LoadVoxels(info, n), [a]) =>                | IL.E_Op(Op.LoadVoxels(info, n), [a]) =>
305                    if (n > 1)                    if (n > 1)
306                      then let                      then let
307                        val stride = ImageInfo.stride info                        val stride = ImageInfo.stride info
308                        val rTy = ImageInfo.sampleTy info                        val rTy = ImageInfo.sampleTy info
309                        val vp = freshVar "vp"                        val vp = freshVar "vp"
310                        val needsCast = (CL.T_Num rTy <> !RN.gRealTy)                        val needsCast = (CL.T_Num rTy <> !N.gRealTy)
311                        fun mkLoad i = let                        fun mkLoad i = let
312                              val e = CL.mkSubscript(CL.mkVar vp, intExp(i*stride))                              val e = CL.mkSubscript(CL.mkVar vp, intExp(i*stride))
313                              in                              in
314                                if needsCast then CL.mkCast(!RN.gRealTy, e) else e                                if needsCast then CL.mkCast(!N.gRealTy, e) else e
315                              end                              end
316                        in [                        in [
317                          CL.mkDecl(CL.T_Ptr(CL.T_Num rTy), vp, SOME(CL.I_Exp(trExp(env, a)))),                          CL.mkDecl(CL.T_Ptr(CL.T_Num rTy), vp, SOME(CL.I_Exp(trExp(env, a)))),
318                          CL.mkAssign(lhs,                          CL.mkAssign(lhs,
319                            CL.mkApply(RN.mkVec n, List.tabulate (n, mkLoad)))                            CL.mkApply(N.mkVec n, List.tabulate (n, mkLoad)))
320                        ] end                        ] end
321                    else [CL.mkAssign(lhs, trExp(env, rhs))]                    else [CL.mkAssign(lhs, trExp(env, rhs))]
322                | IL.E_Cons(Ty.TensorTy[n,m], args) => let                | IL.E_Cons(Ty.TensorTy[n,m], args) => let
# Line 329  Line 329 
329                      doRows (0, trExps(env, args))                      doRows (0, trExps(env, args))
330                    end                    end
331                | IL.E_Var x => (case IL.Var.ty x                | IL.E_Var x => (case IL.Var.ty x
332                     of Ty.TensorTy[n,m] => [CL.mkCall(RN.copyMat(n,m), [lhs, trVar(env, x)])]                     of Ty.TensorTy[n,m] => [CL.mkCall(N.copyMat(n,m), [lhs, trVar(env, x)])]
333                      | _ => [CL.mkAssign(lhs, trVar(env, x))]                      | _ => [CL.mkAssign(lhs, trVar(env, x))]
334                    (* end case *))                    (* end case *))
335                | _ => [CL.mkAssign(lhs, trExp(env, rhs))]                | _ => [CL.mkAssign(lhs, trExp(env, rhs))]
# Line 365  Line 365 
365                    | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let                    | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let
366                        val lhs = lookup(env, lhs)                        val lhs = lookup(env, lhs)
367                        val name = trExp(env, name)                        val name = trExp(env, name)
368                        val imgTy = CL.T_Named(RN.imageTy dim)                        val imgTy = CL.T_Named(N.imageTy dim)
369                        val loadFn = RN.loadImage dim                        val loadFn = N.loadImage dim
370                        in [                        in [
371                          CL.mkDecl(                          CL.mkDecl(
372                            CL.T_Named RN.statusTy, sts,                            CL.T_Named N.statusTy, sts,
373                            SOME(CL.I_Exp(CL.E_Apply(loadFn, [name, CL.mkUnOp(CL.%&, CL.E_Var lhs)]))))                            SOME(CL.I_Exp(CL.E_Apply(loadFn, [name, CL.mkUnOp(CL.%&, CL.E_Var lhs)]))))
374                        ] end)                        ] end)
375                    | IL.S_Input(lhs, name, desc, optDflt) => let                    | IL.S_Input(lhs, name, desc, optDflt) => let
376                        val inputFn = RN.input(V.ty lhs)                        val inputFn = N.input(V.ty lhs)
377                        val lhs = lookup(env, lhs)                        val lhs = lookup(env, lhs)
378                        val lhs = CL.E_Var lhs                        val lhs = CL.E_Var lhs
379                        val (initCode, hasDflt) = (case optDflt                        val (initCode, hasDflt) = (case optDflt
# Line 392  Line 392 
392                    | IL.S_Exit args =>                    | IL.S_Exit args =>
393                        saveState (env, args, CL.mkReturn NONE)                        saveState (env, args, CL.mkReturn NONE)
394                    | IL.S_Active args =>                    | IL.S_Active args =>
395                        saveState (env, args, CL.mkReturn(SOME(CL.mkVar RN.kActive)))                        saveState (env, args, CL.mkReturn(SOME(CL.mkVar N.kActive)))
396                    | IL.S_Stabilize args =>                    | IL.S_Stabilize args =>
397                        saveState (env, args, CL.mkReturn(SOME(CL.mkVar RN.kStabilize)))                        saveState (env, args, CL.mkReturn(SOME(CL.mkVar N.kStabilize)))
398                    | IL.S_Die => [CL.mkReturn(SOME(CL.mkVar RN.kDie))]                    | IL.S_Die => [CL.mkReturn(SOME(CL.mkVar N.kDie))]
399                  (* end case *))                  (* end case *))
400            in            in
401              List.foldr (fn (stm, stms) => trStmt(env, stm)@stms) [] stms              List.foldr (fn (stm, stms) => trStmt(env, stm)@stms) [] stms

Legend:
Removed from v.1372  
changed lines
  Added in v.1373

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