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

SCM Repository

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

Diff of /branches/vis12-cl/src/compiler/c-util/tree-to-c.sml

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

revision 1958, Tue Jul 10 13:01:03 2012 UTC revision 2033, Fri Oct 12 03:05:33 2012 UTC
# Line 174  Line 174 
174                    CL.mkSubscript(vecExp, ix)                    CL.mkSubscript(vecExp, ix)
175                  end                  end
176              | (Op.Subscript(Ty.SeqTy(ty, n)), [v, ix]) => CL.mkSubscript(v, ix)              | (Op.Subscript(Ty.SeqTy(ty, n)), [v, ix]) => CL.mkSubscript(v, ix)
177                | (Op.Subscript(Ty.DynSeqTy ty), [v, ix]) => let
178                    val elemTy = trType ty
179                    in
180                      CL.mkUnOp (CL.%*,
181                        CL.mkCast(CL.T_Ptr elemTy,
182                          CL.mkApply("Diderot_DynSeqAddr", [CL.mkSizeof elemTy, v, ix])))
183                    end
184              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let
185                  val unionTy = CL.T_Named(N.unionTy n)                  val unionTy = CL.T_Named(N.unionTy n)
186                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")
# Line 223  Line 230 
230                  CL.mkApply(N.toImageSpace(ImageInfo.dim info), [img, pos])                  CL.mkApply(N.toImageSpace(ImageInfo.dim info), [img, pos])
231              | (Op.TensorToWorldSpace(info, ty), [v, x]) =>              | (Op.TensorToWorldSpace(info, ty), [v, x]) =>
232                  CL.mkApply(N.toWorldSpace ty, [v, x])                  CL.mkApply(N.toWorldSpace ty, [v, x])
             | (Op.LoadImage info, [a]) =>  
                 raise Fail("impossible " ^ Op.toString rator)  
233              | (Op.Inside(info, s), [pos, img]) =>              | (Op.Inside(info, s), [pos, img]) =>
234                  CL.mkApply(N.inside(ImageInfo.dim info), [pos, img, intExp s])                  CL.mkApply(N.inside(ImageInfo.dim info), [pos, img, intExp s])
235              | (Op.Input(ty, desc, name), []) =>              | (Op.LoadSeq(ty, nrrd), []) =>
236                  raise Fail("impossible " ^ Op.toString rator)                  raise Fail("impossible " ^ Op.toString rator)
237              | (Op.InputWithDefault(ty, desc, name), [a]) =>              | (Op.LoadImage(ty, nrrd, info), []) =>
238                  raise Fail("impossible " ^ Op.toString rator)                  raise Fail("impossible " ^ Op.toString rator)
239                | (Op.Input _, []) => raise Fail("impossible " ^ Op.toString rator)
240              | _ => raise Fail(concat[              | _ => raise Fail(concat[
241                    "unknown or incorrect operator ", Op.toString rator                    "unknown or incorrect operator ", Op.toString rator
242                  ])                  ])
# Line 507  Line 513 
513            val env = trLocals (env, locals)            val env = trLocals (env, locals)
514            fun trStmt (env, stm) = (case stm            fun trStmt (env, stm) = (case stm
515                   of IL.S_Comment text => [CL.mkComment text]                   of IL.S_Comment text => [CL.mkComment text]
516    (* DEPRECATED
517                    | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let                    | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let
518                        val lhs = VarToC.lvalueVar (env, lhs)                        val lhs = VarToC.lvalueVar (env, lhs)
519                        val imgTy = CL.T_Named(N.imageTy dim)                        val imgTy = CL.T_Named(N.imageTy dim)
# Line 519  Line 526 
526                                addrOf lhs                                addrOf lhs
527                              ]))))                              ]))))
528                        ] end)                        ] end)
529    *)
530                      | IL.S_LoadNrrd _ => [] (* FIXME *)
531                      | IL.S_InputNrrd _ => [] (* FIXME *)
532                    | _ => []                    | _ => []
533                  (* end case *))                  (* end case *))
534            val stms = List.foldr (fn (stm, stms) => trStmt(env, stm)@stms) [] body            val stms = List.foldr (fn (stm, stms) => trStmt(env, stm)@stms) [] body
# Line 547  Line 557 
557                    | IL.S_Save([x], exp) => trAssign (env, VarToC.lvalueStateVar x, exp)                    | IL.S_Save([x], exp) => trAssign (env, VarToC.lvalueStateVar x, exp)
558                    | IL.S_Save(xs, exp) =>                    | IL.S_Save(xs, exp) =>
559                        trMultiAssign (env, List.map VarToC.lvalueStateVar xs, exp)                        trMultiAssign (env, List.map VarToC.lvalueStateVar xs, exp)
560    (* DEPRECATED
561                    | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let                    | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let
562                        val lhs = VarToC.lvalueVar (env, lhs)                        val lhs = VarToC.lvalueVar (env, lhs)
563                        val name = trExp(env, name)                        val name = trExp(env, name)
# Line 560  Line 571 
571                                name, addrOf lhs                                name, addrOf lhs
572                              ]))))                              ]))))
573                        ] end)                        ] end)
574    *)
575                      | IL.S_LoadNrrd(lhs, Ty.DynSeqTy ty, nrrd) => let
576                          val lhs = VarToC.lvalueVar (env, lhs)
577                          val (nDims, dimInit, dimExp, elemTy) = (case ty
578                                 of Ty.TensorTy(dims as _::_) => let
579                                      val nDims = List.length dims
580                                      fun lp (_, [], init) = CL.I_Array(List.rev init)
581                                        | lp (i, d::dd, init) =
582                                            lp(i+1, dd, (i, CL.I_Exp(CL.mkInt(IntInf.fromInt d)))::init)
583                                      val dimInit = CL.mkDecl(
584                                            CL.T_Ptr(CL.T_Named "unsigned int"), "_dims",
585                                            SOME(lp(0, dims, [])))
586                                      in
587                                        (nDims, [dimInit], CL.mkVar "_dims", Ty.TensorTy[])
588                                      end
589                                  | Ty.SeqTy ty' => raise Fail "type not supported yet"
590                                  | _ => (0, [], CL.mkInt 0, ty)
591                                (* end case *))
592                          val loadFn = N.loadDynSeqFromFile elemTy
593                          in [CL.mkBlock (
594                            dimInit @
595                            [CL.mkAssign(
596                              lhs,
597                              CL.E_Apply(loadFn, [
598                                  CL.mkCast(CL.T_Ptr(CL.T_Named "WorldPrefix_t"), CL.mkVar "wrld"),
599                                  CL.mkStr nrrd,
600                                  CL.mkInt(IntInf.fromInt nDims),
601                                  dimExp
602                                ]))]
603                          )] end
604                      | IL.S_LoadNrrd(lhs, Ty.ImageTy info, nrrd) => checkSts (fn sts => let
605                          val lhs = VarToC.lvalueVar (env, lhs)
606                          val name = CL.E_Str nrrd
607                          val dim = ImageInfo.dim info
608                          val imgTy = CL.T_Named(N.imageTy dim)
609                          val loadFn = N.loadImage dim
610                          in [
611                            CL.mkDecl(
612                              CL.T_Named N.statusTy, sts,
613                              SOME(CL.I_Exp(CL.E_Apply(loadFn, [
614                                  CL.mkCast(CL.T_Ptr(CL.T_Named "WorldPrefix_t"), CL.mkVar "wrld"),
615                                  name, addrOf lhs
616                                ]))))
617                          ] end)
618                    | IL.S_Input(_, _, _, NONE) => []                    | IL.S_Input(_, _, _, NONE) => []
619                    | IL.S_Input(lhs, name, _, SOME dflt) => [                    | IL.S_Input(lhs, name, _, SOME dflt) => [
620                          CL.mkAssign(VarToC.lvalueVar(env, lhs), trExp(env, dflt))                          CL.mkAssign(VarToC.lvalueVar(env, lhs), trExp(env, dflt))
621                        ]                        ]
622                      | IL.S_InputNrrd _ => []
623                    | IL.S_Exit args => []                    | IL.S_Exit args => []
624                    | IL.S_Active => [CL.mkReturn(SOME(CL.mkVar N.kActive))]                    | IL.S_Active => [CL.mkReturn(SOME(CL.mkVar N.kActive))]
625                    | IL.S_Stabilize => [CL.mkReturn(SOME(CL.mkVar N.kStabilize))]                    | IL.S_Stabilize => [CL.mkReturn(SOME(CL.mkVar N.kStabilize))]

Legend:
Removed from v.1958  
changed lines
  Added in v.2033

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