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

SCM Repository

[diderot] Diff of /branches/vis12/src/compiler/c-target/gen-output.sml
ViewVC logotype

Diff of /branches/vis12/src/compiler/c-target/gen-output.sml

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

revision 2718, Tue Sep 23 17:51:35 2014 UTC revision 2719, Tue Sep 23 17:51:53 2014 UTC
# Line 52  Line 52 
52      structure CL = CLang      structure CL = CLang
53      structure N = CNames      structure N = CNames
54      structure Nrrd = NrrdEnums      structure Nrrd = NrrdEnums
55        structure U = OutputUtil
56    
57      fun mapi f l = let      fun mapi f l = let
58            fun mapf (i, [], l) = List.rev l            fun mapf (i, [], l) = List.rev l
# Line 65  Line 66 
66      fun wrldPtr tgt = CL.T_Ptr(CL.T_Named(N.worldTy tgt))      fun wrldPtr tgt = CL.T_Ptr(CL.T_Named(N.worldTy tgt))
67      fun mkInt i = CL.mkInt(IntInf.fromInt i)      fun mkInt i = CL.mkInt(IntInf.fromInt i)
68    
   (* return information about the output type.  This is a tuple  
    *  
    *    (c-type, nrrd-type, nrrd-axis-kind, # elements)  
    *)  
     fun infoOf (tgt : Properties.props, ty) = (case ty  
            of Ty.IntTy => if #longint tgt  
                 then (CL.int64, Nrrd.TypeLLong, Nrrd.KindScalar, 1)  
                 else (CL.int32, Nrrd.TypeInt, Nrrd.KindScalar, 1)  
             | Ty.TensorTy [] => if #double tgt  
                 then (CL.double, Nrrd.TypeDouble, Nrrd.KindScalar, 1)  
                 else (CL.float, Nrrd.TypeFloat, Nrrd.KindScalar, 1)  
             | Ty.TensorTy dims => let  
                 val (axisKind, nElems) = (case dims  
                        of [2] => (Nrrd.Kind2Vector, 2)  
                         | [3] => (Nrrd.Kind3Vector, 3)  
                         | [4] => (Nrrd.Kind4Vector, 4)  
                         | [2,2] => (Nrrd.Kind2DMatrix, 4)  
                         | [3,3] => (Nrrd.Kind3DMatrix, 9)  
                         | _ => (Nrrd.KindList, List.foldl Int.* 1 dims)  
                       (* end case *))  
                 in  
                   if #double tgt  
                     then (CL.double, Nrrd.TypeDouble, axisKind, nElems)  
                     else (CL.float, Nrrd.TypeFloat, axisKind, nElems)  
                 end  
             | Ty.SeqTy(ty, n) => raise Fail "FIXME" (*let  
                 val (elemTy, nrrdTy, dims) = infoOf (tgt, ty)  
                 in  
                   (elemTy, nrrdTy, n::dims)  
                 end*)  
             | _ => raise Fail(concat["GetOutput.infoOf(", Ty.toString ty, ")"])  
           (* end case *))  
   
69    (* variables in the generated code *)    (* variables in the generated code *)
70      val wrldV = CL.mkVar "wrld"      val wrldV = CL.mkVar "wrld"
71      val sizesV = CL.mkVar "sizes"      val sizesV = CL.mkVar "sizes"
# Line 158  Line 126 
126            CL.mkBinOp(CL.mkSubscript(CL.mkIndirect(wrldV, "status"), iV), CL.#!=, DIDEROT_DIE),            CL.mkBinOp(CL.mkSubscript(CL.mkIndirect(wrldV, "status"), iV), CL.#!=, DIDEROT_DIE),
127            stm)            stm)
128    
   (* code fragment to allocate nrrd data and check for errors  
         if (nrrdMaybeAlloc_nva(<nrrdVar>, <nrrdType>, <nDims>, sizes) != 0) {  
             char *msg = biffGetDone(NRRD);  
             biffMsgAdd (wrld->errors, msg);  
             FREE (msg);  
             return true;  
         }  
    *)  
     fun maybeAlloc (nrrdVar, nrrdType, nDims) =  
           CL.mkIfThen(  
             CL.mkBinOp(  
               CL.mkApply("nrrdMaybeAlloc_nva", [  
                   nrrdVar, CL.mkVar nrrdType, mkInt nDims, sizesV  
                 ]),  
               CL.#!=,  
               CL.mkInt 0),  
           (* then *)  
             CL.mkBlock[  
                 CL.mkDeclInit(CL.charPtr, "msg", CL.mkApply("biffGetDone", [NRRD])),  
                 World.errorMsgAdd msgV,  
                 CL.mkCall("FREE", [msgV]),  
                 CL.mkReturn(SOME(CL.mkVar "true"))  
               ]  
           (* endif*))  
   
129    (* code fragment to initialize the axes kinds; the data axis (axis[0]) is given, but we skip it    (* code fragment to initialize the axes kinds; the data axis (axis[0]) is given, but we skip it
130     * (by convention) if it is scalar. The other axes are the specified domAxisKind.     * (by convention) if it is scalar. The other axes are the specified domAxisKind.
131     *)     *)
# Line 209  Line 152 
152     *    copy data from strands to nrrd     *    copy data from strands to nrrd
153     *)     *)
154      fun genDynOutput (tgt, snapshot, nAxes, ty, name) = let      fun genDynOutput (tgt, snapshot, nAxes, ty, name) = let
155            val (elemCTy, nrrdType, axisKind, nElems) = infoOf (tgt, ty)            val (elemCTy, nrrdType, axisKind, nElems) = U.infoOf (tgt, ty)
156            val stateVar = stateVar tgt            val stateVar = stateVar tgt
157            val (isArray, nAxes, domAxisKind) = (case nAxes            val (isArray, nAxes, domAxisKind) = (case nAxes
158                   of NONE => (false, 1, Nrrd.KindList)                   of NONE => (false, 1, Nrrd.KindList)
# Line 248  Line 191 
191                      then dimSizes ::                      then dimSizes ::
192                        List.tabulate (nAxes, fn i =>                        List.tabulate (nAxes, fn i =>
193                          setSizes(i+1, CL.mkSubscript(CL.mkIndirect(wrldV, "size"), mkInt(nAxes-i-1)))) @                          setSizes(i+1, CL.mkSubscript(CL.mkIndirect(wrldV, "size"), mkInt(nAxes-i-1)))) @
194                        [maybeAlloc (nLengthsV, Nrrd.tyToEnum Nrrd.TypeInt, nAxes+1)]                        [U.maybeAlloc (nLengthsV, Nrrd.tyToEnum Nrrd.TypeInt, nAxes+1)]
195                      else [                      else [
196                          dimSizes, setSizes(1, numStableV),                          dimSizes, setSizes(1, numStableV),
197                          maybeAlloc (nLengthsV, Nrrd.tyToEnum Nrrd.TypeInt, 2)                          U.maybeAlloc (nLengthsV, Nrrd.tyToEnum Nrrd.TypeInt, 2)
198                        ])                        ])
199                  end                  end
200          (* generate code to allocate the data nrrd *)          (* generate code to allocate the data nrrd *)
# Line 259  Line 202 
202                  then [ (* drop data axis for scalar data by convention *)                  then [ (* drop data axis for scalar data by convention *)
203                      CL.mkComment["allocate nData nrrd"],                      CL.mkComment["allocate nData nrrd"],
204                      setSizes(0, numElemsV),                      setSizes(0, numElemsV),
205                      maybeAlloc (nDataV, Nrrd.tyToEnum nrrdType, 1)                      U.maybeAlloc (nDataV, Nrrd.tyToEnum nrrdType, 1)
206                    ]                    ]
207                  else [                  else [
208                      CL.mkComment["allocate nData nrrd"],                      CL.mkComment["allocate nData nrrd"],
209                      setSizes(0, mkInt nElems),                      setSizes(0, mkInt nElems),
210                      setSizes(1, numElemsV),                      setSizes(1, numElemsV),
211                      maybeAlloc (nDataV, Nrrd.tyToEnum nrrdType, 2)                      U.maybeAlloc (nDataV, Nrrd.tyToEnum nrrdType, 2)
212                    ]                    ]
213          (* generate the nLengths copy code *)          (* generate the nLengths copy code *)
214            val copyLengths = let            val copyLengths = let
# Line 328  Line 271 
271     *    copy data from strands to nrrd     *    copy data from strands to nrrd
272     *)     *)
273      fun genFixedOutput (tgt, snapshot, nAxes, ty, name) = let      fun genFixedOutput (tgt, snapshot, nAxes, ty, name) = let
274            val (elemCTy, nrrdType, axisKind, nElems) = infoOf (tgt, ty)            val (elemCTy, nrrdType, axisKind, nElems) = U.infoOf (tgt, ty)
275            val stateVar = stateVar tgt            val stateVar = stateVar tgt
276            val (isArray, nAxes, domAxisKind) = (case nAxes            val (isArray, nAxes, domAxisKind) = (case nAxes
277                   of NONE => (false, 1, Nrrd.KindList)                   of NONE => (false, 1, Nrrd.KindList)
# Line 386  Line 329 
329                  CL.mkComment["Compute sizes of nrrd file"] ::                  CL.mkComment["Compute sizes of nrrd file"] ::
330                  initSizes @                  initSizes @
331                  CL.mkComment["Allocate nData nrrd"] ::                  CL.mkComment["Allocate nData nrrd"] ::
332                  maybeAlloc (nDataV, Nrrd.tyToEnum  nrrdType, nAxes+nDataAxes) ::                  U.maybeAlloc (nDataV, Nrrd.tyToEnum  nrrdType, nAxes+nDataAxes) ::
333                  CL.mkComment["copy data to output nrrd"] ::                  CL.mkComment["copy data to output nrrd"] ::
334                  copyCode @                  copyCode @
335                  [CL.mkReturn(SOME(CL.mkVar "false"))]                  [CL.mkReturn(SOME(CL.mkVar "false"))]
# Line 411  Line 354 
354                  val getFns = List.map (getFn false) outputs                  val getFns = List.map (getFn false) outputs
355                  in                  in
356                    if (#exec tgt)                    if (#exec tgt)
357                      then getFns @ OutputUtil.genOutput(tgt, outputs)                      then getFns @ U.genOutput(tgt, outputs)
358                    else if (#snapshot tgt)                    else if (#snapshot tgt)
359                      then List.map (getFn true) outputs @ getFns                      then List.map (getFn true) outputs @ getFns
360                      else getFns                      else getFns

Legend:
Removed from v.2718  
changed lines
  Added in v.2719

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