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

SCM Repository

[diderot] View of /branches/vis15/src/compiler/cxx-util/gen-load-nrrd.sml
ViewVC logotype

View of /branches/vis15/src/compiler/cxx-util/gen-load-nrrd.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3906 - (download) (annotate)
Mon May 23 22:09:41 2016 UTC (3 years, 1 month ago) by jhr
File size: 2801 byte(s)
working on merge: code generation
(* gen-load-nrrd.sml
 *
 * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
 *
 * COPYRIGHT (c) 2015 The University of Chicago
 * All rights reserved.
 *)

structure GenLoadNrrd : sig

  (* loadImage (img, arg)
   *    returns code to load an image from either a Nrrd file or an in-memory Nrrd, where
   *    "lhs" is the image object and arg specifies either the file or nrrd.
   *    The generated code check the status of the load attempt and will return "true"
   *    (i.e., error) if the load fails.
   *)
    val loadImage : CLang.exp * CLang.exp -> CLang.stm

    val loadSeqFromFile : CLang.exp * APITypes.t * CLang.exp -> CLang.stm
    val loadSeq : CLang.exp * APITypes.t * CLang.exp -> CLang.stm

  end = struct

    structure CL = CLang
    structure RN = CxxNames
    structure Ty = APITypes

    val wrldPrefixTy = CL.T_Ptr(CL.T_Named "WorldBase")

    fun loadImage (img, arg) = let
	  val loadExp = CL.mkApplyExp(CL.mkSelect(img, "load"), [CL.mkVar "wrld", arg])
          in
(* FIXME: we should also generate code to check that the loaded image has the right type, etc. *)
            CL.mkIfThen(loadExp, CL.mkReturn(SOME(CL.mkVar "true")))
          end

    fun doSeq loadFn (lhs, elemTy, arg) = let
          val (nDims, dimInit, dimExp, elemTy) = (case elemTy
                 of Ty.TensorTy(dims as _::_) => let
                      val nDims = List.length dims
                      fun lp (_, [], init) = CL.I_Array(List.rev init)
                        | lp (i, d::dd, init) =
                            lp(i+1, dd, (i, CL.I_Exp(CL.mkInt(IntInf.fromInt d)))::init)
                      val dimInit = CL.mkDecl(
                            CL.T_Array(CL.T_Named "unsigned int", SOME nDims), "_dims",
                            SOME(lp(0, dims, [])))
                      in
                        (nDims, [dimInit], CL.mkVar "_dims", Ty.realTy)
                      end
                  | Ty.SeqTy(ty', _) => raise Fail(concat[
			"loading sequences of type ", Ty.toString ty', " not supported yet"
		      ])
                  | _ => (0, [], CL.mkInt 0, elemTy)
                (* end case *))
          in CL.mkBlock (
            dimInit @ [
                CL.mkAssign(
                  lhs,
                  CL.mkApply(loadFn elemTy, [
                      CL.mkCast(CL.T_Ptr(CL.T_Named "WorldBase"), CL.mkVar "wrld"),
                      arg,
                      CL.mkInt(IntInf.fromInt nDims),
                      dimExp
                    ])),
                CL.mkIfThen(
                  CL.mkBinOp(lhs, CL.#==, CL.mkInt 0),
                  CL.mkReturn(SOME(CL.mkVar "true")))
              ]
          ) end

    val loadSeqFromFile = doSeq RN.loadDynSeqFromFile
    val loadSeq = doSeq RN.loadDynSeq

  end

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