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

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/simplify/simplify.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/simplify/simplify.sml

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

revision 3445, Fri Nov 20 15:47:57 2015 UTC revision 3452, Sat Nov 21 23:59:35 2015 UTC
# Line 19  Line 19 
19      structure STy = SimpleTypes      structure STy = SimpleTypes
20      structure Ty = Types      structure Ty = Types
21      structure VMap = Var.Map      structure VMap = Var.Map
     structure InP = Inputs  
22    
23    (* convert a Types.ty to a SimpleTypes.ty *)    (* convert a Types.ty to a SimpleTypes.ty *)
24      fun cvtTy ty = (case ty      fun cvtTy ty = (case ty
# Line 31  Line 30 
30              | Ty.T_Int => STy.T_Int              | Ty.T_Int => STy.T_Int
31              | Ty.T_String => STy.T_String              | Ty.T_String => STy.T_String
32              | Ty.T_Sequence(ty, NONE) => STy.T_Sequence(cvtTy ty, NONE)              | Ty.T_Sequence(ty, NONE) => STy.T_Sequence(cvtTy ty, NONE)
33              | Ty.T_Sequence(ty, dim) => STy.T_Sequence(cvtTy ty, SOME(TU.monoDim dim))              | Ty.T_Sequence(ty, SOME dim) => STy.T_Sequence(cvtTy ty, SOME(TU.monoDim dim))
34              | Ty.T_Named id => STy.T_Named id              | Ty.T_Named id => STy.T_Named id
35              | Ty.T_Kernel n => STy.T_Kernel(TU.monoDiff n)              | Ty.T_Kernel n => STy.T_Kernel(TU.monoDiff n)
36              | Ty.T_Tensor shape => STy.T_Tensor(TU.monoShape shape)              | Ty.T_Tensor shape => STy.T_Tensor(TU.monoShape shape)
# Line 44  Line 43 
43                    dim = TU.monoDim dim,                    dim = TU.monoDim dim,
44                    shape = TU.monoShape shape                    shape = TU.monoShape shape
45                  }                  }
46              | Ty.T_Fun(tys1, ty2) => STy.T_Fun(List.map cvtTy tys1, simplify ty2)              | Ty.T_Fun(tys1, ty2) => STy.T_Fun(List.map cvtTy tys1, cvtTy ty2)
47            (* end case *))            (* end case *))
48    
49      fun newTemp ty = SimpleVar.new ("_t", SimpleVar.LocalVar, ty)      fun newTemp ty = SimpleVar.new ("_t", SimpleVar.LocalVar, ty)
50    
51        datatype env = E of {
52            errStrm : Error.err_stream,
53            vMap : SimpleVar.t VMap.map
54          }
55    
56        fun newEnv errStrm = E{errStrm=errStrm, vMap=VMap.empty}
57    
58        fun errStream (E{errStrm, ...}) = errStrm
59    
60    (* convert an AST variable to a Simple variable *)    (* convert an AST variable to a Simple variable *)
61      fun cvtVar (env, x as Var.V{name, kind, ty=([], ty), ...}) = let      fun cvtVar (E{errStrm, vMap}, x) = let
62            val x' = SimpleVar.new (name, kind, cvtTy ty)            val x' = SimpleVar.new (Var.nameOf x, Var.kindOf x, cvtTy(Var.monoTypeOf x))
63            in            in
64              (x', VMap.insert(env, x, x'))              (x', E{errStrm=errStrm, vMap=VMap.insert(vMap, x, x')})
65            end            end
66    
67      fun cvtVars (env, xs) = List.foldr      fun cvtVars (env, xs) = List.foldr
# Line 63  Line 71 
71                (x'::xs, env)                (x'::xs, env)
72              end) ([], env) xs              end) ([], env) xs
73    
74      fun lookupVar (env, x) = (case VMap.find (env, x)      fun lookupVar (E{vMap, ...}, x) = (case VMap.find (vMap, x)
75             of SOME x' => x'             of SOME x' => x'
76              | NONE => raise Fail(concat["lookupVar(", Var.uniqueNameOf x, ")"])              | NONE => raise Fail(concat["lookupVar(", Var.uniqueNameOf x, ")"])
77            (* end case *))            (* end case *))
# Line 71  Line 79 
79    (* make a block out of a list of statements that are in reverse order *)    (* make a block out of a list of statements that are in reverse order *)
80      fun mkBlock stms = S.Block(List.rev stms)      fun mkBlock stms = S.Block(List.rev stms)
81    
82      fun inputImage (nrrd, dim, shape) = (      fun inputImage (env, nrrd, dim, shape) = (
83            case ImageInfo.fromNrrd(NrrdInfo.getInfo nrrd, dim, shape)            case ImageInfo.fromNrrd(NrrdInfo.getInfo(errStream env, nrrd), dim, shape)
84             of NONE => raise Fail(concat["nrrd file \"", nrrd, "\" does not have expected type"])             of NONE => raise Fail(concat["nrrd file \"", nrrd, "\" does not have expected type"])
85              | SOME info => InP.Proxy(nrrd, info)              | SOME info => S.Proxy(nrrd, info)
86            (* end case *))            (* end case *))
87    
88      datatype 'a ctl_flow_info      datatype 'a ctl_flow_info
# Line 153  Line 161 
161              (* end case *)              (* end case *)
162            end            end
163    
     fun simplifyProgram (AST.Program{props, decls}) = let  
           val inputs = ref []  
           val inputInit = ref []  
           val globals = ref []  
           val globalInit = ref []  
           val funcs = ref []  
           val initially = ref NONE  
           val strands = ref []  
           fun setInitially init = (case !initially  
                  of NONE => initially := SOME init  
 (* FIXME: the check for multiple initially decls should happen in type checking *)  
                   | SOME _ => raise Fail "multiple initially declarations"  
                 (* end case *))  
           fun simplifyDecl (dcl, env) = (case dcl  
                  of AST.D_Input(x, desc, NONE) => let  
                       val (x', env) = cvtVar(env, x)  
                       val (ty, init) = (case SimpleVar.typeOf x'  
                              of ty as SimpleTypes.T_Image{dim, shape} => let  
                                   val info = ImageInfo.mkInfo(dim, shape)  
                                   in  
                                     (ty, SOME(InP.Image info))  
                                   end  
                               | ty => (ty, NONE)  
                             (* end case *))  
                       val inp = InP.INP{  
                               ty = ty,  
                               name = SimpleVar.nameOf x',  
                               desc = desc,  
                               init = init  
                             }  
                       in  
                         inputs := (x', inp) :: !inputs;  
                         env  
                       end  
                   | AST.D_Input(x, desc, SOME(AST.E_LoadNrrd(tvs, nrrd, ty))) => let  
                       val (x', env) = cvtVar(env, x)  
                     (* load the nrrd proxy here *)  
                       val info = NrrdInfo.getInfo nrrd  
                       val (ty, init) = (case SimpleVar.typeOf x'  
                              of ty as SimpleTypes.T_DynSequence _ => (ty, InP.DynSeq nrrd)  
                               | ty as SimpleTypes.T_Image{dim, shape} => (ty, inputImage(nrrd, dim, shape))  
                               | _ => raise Fail "impossible"  
                             (* end case *))  
                       val inp = InP.INP{  
                               ty = ty,  
                               name = SimpleVar.nameOf x',  
                               desc = desc,  
                               init = SOME init  
                             }  
                       in  
                         inputs := (x', inp) :: !inputs;  
                         env  
                       end  
                   | AST.D_Input(x, desc, SOME e) => let  
                       val (x', env) = cvtVar(env, x)  
                       val (stms, e') = simplifyExp (env, e, [])  
                       val inp = InP.INP{  
                               ty = SimpleVar.typeOf x',  
                               name = SimpleVar.nameOf x',  
                               desc = desc,  
                               init = NONE  
                             }  
                       in  
                         inputs := (x', inp) :: !inputs;  
                         inputInit := S.S_Assign(x', e') :: (stms @ !inputInit);  
                         env  
                       end  
                   | AST.D_Var(AST.VD_Decl(x, e)) => let  
                       val (x', env) = cvtVar(env, x)  
                       val (stms, e') = simplifyExp (env, e, [])  
                       in  
                         globals := x' :: !globals;  
                         globalInit := S.S_Assign(x', e') :: (stms @ !globalInit);  
                         env  
                       end  
                   | AST.D_Func(f, params, body) => let  
                       val (f', env) = cvtVar(env, f)  
                       val (params', env) = cvtVars (env, params)  
                       val body' = pruneUnreachableCode (simplifyBlock(env, body))  
                       in  
                         funcs := S.Func{f=f', params=params', body=body'} :: !funcs;  
                         env  
                       end  
                   | AST.D_Strand info => (  
                       strands := simplifyStrand(env, info) :: !strands;  
                       env)  
                   | AST.D_InitialArray(creat, iters) => (  
                       setInitially (simplifyInit(env, true, creat, iters));  
                       env)  
                   | AST.D_InitialCollection(creat, iters) => (  
                       setInitially (simplifyInit(env, false, creat, iters));  
                       env)  
                 (* end case *))  
           val env = List.foldl simplifyDecl VMap.empty decls  
           in  
             S.Program{  
                 props = props,  
                 inputDefaults = mkBlock (!inputInit),  
                 inputs = List.rev(!inputs),  
                 globals = List.rev(!globals),  
                 globalInit = mkBlock (!globalInit),  
                 funcs = List.rev(!funcs),  
                 init = (case !initially  
 (* FIXME: the check for the initially block should really happen in typechecking *)  
                    of NONE => raise Fail "missing initially declaration"  
                     | SOME blk => blk  
                   (* end case *)),  
                 strands = List.rev(!strands)  
               }  
           end  
   
     and simplifyInit (env, isArray, AST.C_Create(strand, exps), iters) = let  
           fun simplifyIter (AST.I_Range(x, e1, e2), (env, iters, stms)) = let  
                 val (stms, lo) = simplifyExpToVar (env, e1, stms)  
                 val (stms, hi) = simplifyExpToVar (env, e2, stms)  
                 val (x', env) = cvtVar (env, x)  
                 in  
                   (env, {param=x', lo=lo, hi=hi}::iters, stms)  
                 end  
           val (env, iters, iterStms) = List.foldl simplifyIter (env, [], []) iters  
           val (stms, xs) = simplifyExpsToVars (env, exps, [])  
           val creat = S.C_Create{  
                   argInit = mkBlock stms,  
                   name = strand,  
                   args = xs  
                 }  
           in  
             S.Initially{  
                 isArray = isArray,  
                 rangeInit = mkBlock iterStms,  
                 iters = List.rev iters,  
                 create = creat  
               }  
           end  
   
     and simplifyStrand (env, AST.Strand{name, params, state, methods}) = let  
           val (params', env) = cvtVars (env, params)  
           fun simplifyState (env, [], xs, stms) = (List.rev xs, mkBlock stms, env)  
             | simplifyState (env, AST.VD_Decl(x, e) :: r, xs, stms) = let  
                 val (stms, e') = simplifyExp (env, e, stms)  
                 val (x', env) = cvtVar(env, x)  
                 in  
                   simplifyState (env, r, x'::xs, S.S_Assign(x', e') :: stms)  
                 end  
           val (xs, stm, env) = simplifyState (env, state, [], [])  
           in  
             S.Strand{  
                 name = name,  
                 params = params',  
                 state = xs, stateInit = stm,  
                 methods = List.map (simplifyMethod env) methods  
               }  
           end  
   
     and simplifyMethod env (AST.M_Method(name, body)) =  
           S.Method(name, pruneUnreachableCode (simplifyBlock(env, body)))  
   
164    (* simplify a statement into a single statement (i.e., a block if it expands    (* simplify a statement into a single statement (i.e., a block if it expands
165     * into more than one new statement).     * into more than one new statement).
166     *)     *)
167      and simplifyBlock (env, stm) = mkBlock (#1 (simplifyStmt (env, stm, [])))      fun simplifyBlock env stm = mkBlock (#1 (simplifyStmt (env, stm, [])))
168    
169    (* simplify the statement stm where stms is a reverse-order list of preceeding simplified    (* simplify the statement stm where stms is a reverse-order list of preceeding simplified
170     * statements.  This function returns a reverse-order list of simplified statements.     * statements.  This function returns a reverse-order list of simplified statements.
# Line 331  Line 182 
182                  in                  in
183                    (simplify (env, body, stms), env)                    (simplify (env, body, stms), env)
184                  end                  end
185              | AST.S_Decl(AST.VD_Decl(x, e)) => let              | AST.S_Decl(x, NONE) => let
186                    val (x', env) = cvtVar(env, x)
187                    in
188    (* QUESTION: where do we declare x? *)
189                      (stms, env)
190                    end
191                | AST.S_Decl(x, SOME e) => let
192                  val (stms, e') = simplifyExp (env, e, stms)                  val (stms, e') = simplifyExp (env, e, stms)
193                  val (x', env) = cvtVar(env, x)                  val (x', env) = cvtVar(env, x)
194                  in                  in
# Line 339  Line 196 
196                  end                  end
197              | AST.S_IfThenElse(e, s1, s2) => let              | AST.S_IfThenElse(e, s1, s2) => let
198                  val (stms, x) = simplifyExpToVar (env, e, stms)                  val (stms, x) = simplifyExpToVar (env, e, stms)
199                  val s1 = simplifyBlock (env, s1)                  val s1 = simplifyBlock env s1
200                  val s2 = simplifyBlock (env, s2)                  val s2 = simplifyBlock env s2
201                  in                  in
202                    (S.S_IfThenElse(x, s1, s2) :: stms, env)                    (S.S_IfThenElse(x, s1, s2) :: stms, env)
203                  end                  end
204              | AST.S_Assign(x, e) => let              | AST.S_Assign((x, _), e) => let
205                  val (stms, e') = simplifyExp (env, e, stms)                  val (stms, e') = simplifyExp (env, e, stms)
206                  in                  in
207                    (S.S_Assign(lookupVar(env, x), e') :: stms, env)                    (S.S_Assign(lookupVar(env, x), e') :: stms, env)
# Line 370  Line 227 
227            (* end case *))            (* end case *))
228    
229      and simplifyExp (env, exp, stms) = let      and simplifyExp (env, exp, stms) = let
230            fun doApply (f, tyArgs, args, ty) = let            fun doPrimApply (f, tyArgs, args, ty) = let
231                  val (stms, xs) = simplifyExpsToVars (env, args, stms)                  val (stms, xs) = simplifyExpsToVars (env, args, stms)
232                  in                  in
233                    case Var.kindOf f                    case Var.kindOf f
234                     of S.FunVar => (stms, S.E_Apply(lookupVar(env, f), xs, cvtTy ty))                     of Var.BasisVar => let
                     | S.BasisVar => let  
235                          fun cvtTyArg (Types.TYPE tv) = S.TY(cvtTy(TU.resolve tv))                          fun cvtTyArg (Types.TYPE tv) = S.TY(cvtTy(TU.resolve tv))
236                            | cvtTyArg (Types.DIFF dv) = S.DIFF(TU.monoDiff(TU.resolveDiff dv))                            | cvtTyArg (Types.DIFF dv) = S.DIFF(TU.monoDiff(TU.resolveDiff dv))
237                            | cvtTyArg (Types.SHAPE sv) = S.SHAPE(TU.monoShape(TU.resolveShape sv))                            | cvtTyArg (Types.SHAPE sv) = S.SHAPE(TU.monoShape(TU.resolveShape sv))
# Line 384  Line 240 
240                          in                          in
241                            (stms, S.E_Prim(f, tyArgs, xs, cvtTy ty))                            (stms, S.E_Prim(f, tyArgs, xs, cvtTy ty))
242                          end                          end
243                      | _ => raise Fail "bogus application"                      | _ => raise Fail "bogus prim application"
244                    (* end case *)                    (* end case *)
245                  end                  end
246            in            in
247              case exp              case exp
248               of AST.E_Var x => (case Var.kindOf x               of AST.E_Var(x, _) => (case Var.kindOf x
249                     of Var.BasisVar => let                     of Var.BasisVar => let
250                          val ty = cvtTy(Var.monoTypeOf x)                          val ty = cvtTy(Var.monoTypeOf x)
251                          val x' = newTemp ty                          val x' = newTemp ty
# Line 400  Line 256 
256                      | _ => (stms, S.E_Var(lookupVar(env, x)))                      | _ => (stms, S.E_Var(lookupVar(env, x)))
257                    (* end case *))                    (* end case *))
258                | AST.E_Lit lit => (stms, S.E_Lit lit)                | AST.E_Lit lit => (stms, S.E_Lit lit)
259                | AST.E_Tuple es => raise Fail "E_Tuple not yet implemented"                | AST.E_Prim(rator, tyArgs, args as [AST.E_Lit(Literal.Int n)], ty) =>
               | AST.E_Apply(rator, tyArgs, args as [AST.E_Lit(Literal.Int n)], ty) =>  
260                  (* constant-fold negation of integer literals *)                  (* constant-fold negation of integer literals *)
261                    if Var.same(BasisVars.neg_i, rator)                    if Var.same(BasisVars.neg_i, rator)
262                      then (stms, S.E_Lit(Literal.Int(~n)))                      then (stms, S.E_Lit(Literal.Int(~n)))
263                      else doApply (rator, tyArgs, args, ty)                      else doPrimApply (rator, tyArgs, args, ty)
264                | AST.E_Apply(rator, tyArgs, args as [AST.E_Lit(Literal.Float f)], ty as Types.T_Tensor sh) =>                | AST.E_Prim(rator, tyArgs, args as [AST.E_Lit(Literal.Real f)], ty as Types.T_Tensor sh) =>
265                  (* constant-fold negation of real literals *)                  (* constant-fold negation of real literals *)
266                    if Var.same(BasisVars.neg_i, rator) andalso List.null(TU.monoShape sh)                    if Var.same(BasisVars.neg_i, rator) andalso List.null(TU.monoShape sh)
267                      then (stms, S.E_Lit(Literal.Float(FloatLit.negate f)))                      then (stms, S.E_Lit(Literal.Real(RealLit.negate f)))
268                      else doApply (rator, tyArgs, args, ty)                      else doPrimApply (rator, tyArgs, args, ty)
269                | AST.E_Apply(f, tyArgs, args, ty) => doApply (f, tyArgs, args, ty)                | AST.E_Prim(f, tyArgs, args, ty) => doPrimApply (f, tyArgs, args, ty)
270                | AST.E_Cons es => let                | AST.E_Apply((f, _), args, ty) => let
271                      val (stms, xs) = simplifyExpsToVars (env, args, stms)
272                      in
273                        case Var.kindOf f
274                         of Var.FunVar => (stms, S.E_Apply(lookupVar(env, f), xs, cvtTy ty))
275                          | _ => raise Fail "bogus application"
276                        (* end case *)
277                      end
278                  | AST.E_Tensor(es, ty) => let
279                    val (stms, xs) = simplifyExpsToVars (env, es, stms)                    val (stms, xs) = simplifyExpsToVars (env, es, stms)
280                    in                    in
281                      (stms, S.E_Cons xs)                      (stms, S.E_Tensor(xs, cvtTy ty))
282                    end                    end
283                | AST.E_Seq(es, ty) => let                | AST.E_Seq(es, ty) => let
284                    val (stms, xs) = simplifyExpsToVars (env, es, stms)                    val (stms, xs) = simplifyExpsToVars (env, es, stms)
# Line 450  Line 313 
313                      (S.S_IfThenElse(x, s1, s2) :: stms, S.E_Var result)                      (S.S_IfThenElse(x, s1, s2) :: stms, S.E_Var result)
314                    end                    end
315                | AST.E_LoadNrrd(_, nrrd, ty) => (case cvtTy ty                | AST.E_LoadNrrd(_, nrrd, ty) => (case cvtTy ty
316                     of ty as SimpleTypes.T_DynSequence _ => (stms, S.E_LoadSeq(ty, nrrd))                     of ty as SimpleTypes.T_Sequence(_, NONE) => (stms, S.E_LoadSeq(ty, nrrd))
317                      | ty as SimpleTypes.T_Image{dim, shape} => (                      | ty as SimpleTypes.T_Image{dim, shape} => (
318                          case ImageInfo.fromNrrd(NrrdInfo.getInfo nrrd, dim, shape)                          case ImageInfo.fromNrrd(NrrdInfo.getInfo(errStream env, nrrd), dim, shape)
319                           of NONE => raise Fail(concat[                           of NONE => raise Fail(concat[
320                                  "nrrd file \"", nrrd, "\" does not have expected type"                                  "nrrd file \"", nrrd, "\" does not have expected type"
321                                ])                                ])
# Line 495  Line 358 
358              f (exps, [], stms)              f (exps, [], stms)
359            end            end
360    
361      fun transform (errStrm, ast) = let      fun simplifyStrand (env, AST.Strand{name, params, state, initM, updateM, stabilizeM}) = let
362            val simple = simplifyProgram ast            val (params', env) = cvtVars (env, params)
363            val _ = SimplePP.output (Log.logFile(), "simplify", simple)   (* DEBUG *)            fun simplifyState (env, [], xs, stms) = (List.rev xs, mkBlock stms, env)
364            val simple = Inliner.transform simple              | simplifyState (env, (x, optE) :: r, xs, stms) = let
365            val _ = SimplePP.output (Log.logFile(), "inlining", simple)   (* DEBUG *)                  val (x', env') = cvtVar(env, x)
366                    in
367                      case optE
368                       of NONE => simplifyState (env', r, x'::xs, stms)
369                        | SOME e => let
370                            val (stms, e') = simplifyExp (env, e, stms)
371                            in
372                              simplifyState (env', r, x'::xs, S.S_Assign(x', e') :: stms)
373                            end
374                      (* end case *)
375                    end
376              val (xs, stm, env) = simplifyState (env, state, [], [])
377              in
378                S.Strand{
379                    name = name,
380                    params = params',
381                    state = xs, stateInit = stm,
382                    initM = Option.map (simplifyBlock env) initM,
383                    updateM = simplifyBlock env updateM,
384                    stabilizeM = Option.map (simplifyBlock env) stabilizeM
385                  }
386              end
387    
388        fun transform (errStrm, prog) = let
389              val AST.Program{
390                      props, const_dcls, input_dcls, globals, init, strand, create, update
391                    } = prog
392              val inputs' = ref[]
393              val globals' = ref[]
394              val globalInit = ref[]
395              val funcs = ref[]
396              fun simplifyConstDcl ((x, SOME e), env) = ??
397              fun simplifyInputDcl (((x, optE), desc), env) = ??
398              fun simplifyGlobalDcl (AST.D_Var(x, optE), env) = let
399                    val (x', env) = cvtVar(env, x)
400                    in
401                      case optE
402                        of NONE => (globals' := x' :: !globals'; env)
403                         | SOME e => let
404                             val (stms, e') = simplifyExp (env, e, [])
405                             in
406                               globals' := x' :: !globals';
407                               globalInit := S.S_Assign(x', e') :: (stms @ !globalInit);
408                               env
409                             end
410                      (* end case *)
411                    end
412                | simplifyGlobalDcl (AST.D_Func(f, params, body), env) = let
413                    val (f', env) = cvtVar(env, f)
414                    val (params', env) = cvtVars (env, params)
415                    val body' = pruneUnreachableCode (simplifyBlock env body)
416                    in
417                      funcs := S.Func{f=f', params=params', body=body'} :: !funcs;
418                      env
419                    end
420    
421    (*
422                     of AST.D_Input(x, desc, NONE) => let
423                          val (x', env) = cvtVar(env, x)
424                          val (ty, init) = (case SimpleVar.typeOf x'
425                                 of ty as SimpleTypes.T_Image{dim, shape} => let
426                                      val info = ImageInfo.mkInfo(dim, shape)
427            in            in
428              simple                                      (ty, SOME(S.Image info))
429                                      end
430                                  | ty => (ty, NONE)
431                                (* end case *))
432                          val inp = S.INP{
433                                  ty = ty,
434                                  name = SimpleVar.nameOf x',
435                                  desc = desc,
436                                  init = init
437                                }
438                          in
439                            inputs := (x', inp) :: !inputs;
440                            env
441                          end
442                      | AST.D_Input(x, desc, SOME(AST.E_LoadNrrd(tvs, nrrd, ty))) => let
443                          val (x', env) = cvtVar(env, x)
444                        (* load the nrrd proxy here *)
445                          val info = NrrdInfo.getInfo nrrd
446                          val (ty, init) = (case SimpleVar.typeOf x'
447                                 of ty as SimpleTypes.T_Seq(_, NONE) => (ty, S.DynSeq nrrd)
448                                  | ty as SimpleTypes.T_Image{dim, shape} =>
449                                      (ty, inputImage(env, nrrd, dim, shape))
450                                  | _ => raise Fail "impossible"
451                                (* end case *))
452                          val inp = S.INP{
453                                  ty = ty,
454                                  name = SimpleVar.nameOf x',
455                                  desc = desc,
456                                  init = SOME init
457                                }
458                          in
459                            inputs := (x', inp) :: !inputs;
460                            env
461                          end
462                      | AST.D_Input(x, desc, SOME e) => let
463                          val (x', env) = cvtVar(env, x)
464                          val (stms, e') = simplifyExp (env, e, [])
465                          val inp = S.INP{
466                                  ty = SimpleVar.typeOf x',
467                                  name = SimpleVar.nameOf x',
468                                  desc = desc,
469                                  init = NONE
470                                }
471                          in
472                            inputs := (x', inp) :: !inputs;
473                            inputInit := S.S_Assign(x', e') :: (stms @ !inputInit);
474                            env
475                          end
476    *)
477              val env = newEnv errStrm
478              val env = List.foldl simplifyConstDcl env const_dcls
479              val env = List.foldl simplifyInputDcl env input_dcls
480              val env = List.foldl simplifyGlobalDcl env globals
481              in
482                S.Program{
483                    props = props,
484                    inputs = List.rev(!inputs'),
485                    globals = List.rev(!globals'),
486                    init = mkBlock (!globalInit),
487                    funcs = List.rev(!funcs),
488                    strand = simplifyStrand (env, strand),
489                    create = ??,
490                    update =  ??
491                  }
492            end            end
493    
494    end    end

Legend:
Removed from v.3445  
changed lines
  Added in v.3452

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