Home My Page Projects Code Snippets Project Openings 3D graphics for Standard ML
Summary Activity SCM

SCM Repository

[sml3d] Diff of /trunk/sml3d/src/particles/compiler/translate.sml
ViewVC logotype

Diff of /trunk/sml3d/src/particles/compiler/translate.sml

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

revision 1108, Thu Apr 7 03:46:38 2011 UTC revision 1109, Thu Apr 7 21:28:20 2011 UTC
# Line 38  Line 38 
38    (* constants *)    (* constants *)
39      val pi = 3.14159265358979      val pi = 3.14159265358979
40    
41      fun constructUserDefs([]) = []      fun retState s = IR.mkRETURN s
       | constructUserDefs(IR.V{id, ...} :: users) =  
           (IR.USER_DEF id) :: constructUserDefs(users)  
   
     fun userVarsFromState(PS{user, ...}) = user  
     fun userVarsFromEmit(P.EMIT{...}) = []  
   
     fun retState s = let  
       val PS{pos, vel, size, ttl, color, user} = s  
      in  
       IR.mkRETURN (  
         [pos, vel, size, ttl, color] @ user,  
         [IR.POS, IR.VEL, IR.SZ, IR.TTL, IR.COLOR] @ constructUserDefs(user)  
       )  
      end  
42    
43    (* translation environment *)    (* translation environment *)
44      datatype env = TE of (IR.block list ref * IR.var PSV.Map.map * IR.var PSV.SVMap.map)      datatype env = TE of (IR.block list ref * IR.var PSV.Map.map)
45        fun insert (TE(blks, env), x, x') = TE(blks, PSV.Map.insert (env, x, x'))
46    
47      fun psvToIRVar (TE(_, env, _), x as PSV.V{name, id, ...}) = (case PSV.Map.find(env, x)    (* Interaction with environment and state variables *)
48        fun psvToIRVar (TE(_, env), x as PSV.V{name, id, ...}) = (case PSV.Map.find(env, x)
49             of SOME x' => x'             of SOME x' => x'
50              | NONE => raise Fail (String.concat["unknown variable ", name, " with ID ", Int.toString id])              | NONE => raise Fail (String.concat["unknown variable ", name, " with ID ", Int.toString id])
51              (* end case *))              (* end case *))
52    
53      fun pssvToIRVar (TE(_, _, env), x as PSV.SV{name, id, ...}) = (case PSV.SVMap.find(env, x)          fun findIRVarByName (state, name) = let
54             of SOME x' => x'            fun eq (var as IR.V{name=st_name, ...}) = st_name = ("ps_" ^ name)
55              | NONE => raise Fail (String.concat["unknown variable ", name, " with ID ", Int.toString id])           in
56              (case (List.find eq state)
57                of SOME sv => sv
58                 | NONE => raise Fail ("Could not find var mapping.")
59              (* end case *))              (* end case *))
60             end
61    
62      fun insertVar (TE(blks, varEnv, svarEnv), x, x') = TE(blks, PSV.Map.insert (varenv, x, x'), svarEnv)          fun getIRVarForSV (v as PSV.SV{name, ...}, state) = findIRVarByName(state, name)
     fun insertSVar (TE(blks, varEnv, svarEnv), x, x') = TE(blks, varenv, PSV.Map.insert (svarEnv, x, x'))  
63    
64    (* create a block that implements the given continuation *)    (* create a block that implements the given continuation *)
65        fun newBlockWithArgs (TE(blks, _), state , args, k : particle_state -> IR.stmt) = let
66      fun createUserVarCopies( [ ], _ ) = [ ]         fun copyVar(v as IR.V{name, varType, ...}) = IR.newParam(name, varType)
67        | createUserVarCopies( IR.V{varType, ...} :: vars, i) =         val newState = List.map copyVar state
68        IR.newParam ("ps_user" ^ (Int.toString i), varType) :: (createUserVarCopies(vars, i+1))             val blk = IR.newBlock (newState @ args, k newState)
   
     fun newBlockWithArgs (TE(blks, _, _), state , args, k : particle_state -> IR.stmt) = let  
            val blk = IR.newBlock (state @ args, k state)  
69            in            in
70             blks := blk :: !blks;             blks := blk :: !blks;
71             blk             blk
# Line 227  Line 215 
215                    letPRIM("htInv", IR.T_FLOAT, IR.DIV, [IR.newConst("one", IR.C_FLOAT 1.0), height], fn htInv =>                    letPRIM("htInv", IR.T_FLOAT, IR.DIV, [IR.newConst("one", IR.C_FLOAT 1.0), height], fn htInv =>
216                    letPRIM("n", IR.T_VEC, IR.SCALE, [htInv, normVec], fn norm =>                    letPRIM("n", IR.T_VEC, IR.SCALE, [htInv, normVec], fn norm =>
217                    (* Generate a point in the lower disc. *)                    (* Generate a point in the lower disc. *)
218                      genVecVar("ptInDisc", insert(env, normVar, norm), P.D_DISC{pt = pt1, normal = normVar, irad = irad, orad = orad}, fn ptInDisc =>                      genVecVar("ptInDisc",
219                          insert(env, normVar, norm),
220                          P.D_DISC{pt = pt1, normal = normVar, irad = irad, orad = orad},
221                          dist,
222                          fn ptInDisc =>
223                    (* Now add this point to a random scaling of the normVec. *)                    (* Now add this point to a random scaling of the normVec. *)
224                      letPRIM("s", IR.T_FLOAT, IR.MULT, [height, ourRand], fn scale =>                      letPRIM("s", IR.T_FLOAT, IR.MULT, [height, ourRand], fn scale =>
225                      letPRIM("sn", IR.T_VEC, IR.SCALE, [scale, normVec], fn scaledNormVec =>                      letPRIM("sn", IR.T_VEC, IR.SCALE, [scale, normVec], fn scaledNormVec =>
# Line 268  Line 260 
260                    letPRIM("eh",  IR.T_FLOAT, IR.RAND, [], fn ourRand =>                    letPRIM("eh",  IR.T_FLOAT, IR.RAND, [], fn ourRand =>
261                    letPRIM("nv", IR.T_VEC, IR.SUB_VEC, [psvToIRVar(env, pt2), psvToIRVar(env, pt1)], fn normVec =>                    letPRIM("nv", IR.T_VEC, IR.SUB_VEC, [psvToIRVar(env, pt2), psvToIRVar(env, pt1)], fn normVec =>
262                    letPRIM("n", IR.T_VEC, IR.NORM, [normVec], fn norm =>                    letPRIM("n", IR.T_VEC, IR.NORM, [normVec], fn norm =>
263                      genVecVar("ptInDisc", insert(env, normVar, norm), P.D_DISC{pt = pt1, normal = normVar, irad = irad, orad = orad}, fn ptInDisc =>                      genVecVar("ptInDisc",
264                          insert(env, normVar, norm),
265                          P.D_DISC{pt = pt1, normal = normVar, irad = irad, orad = orad},
266                          dist,
267                          fn ptInDisc =>
268                      letPRIM("gptt", IR.T_VEC, IR.SUB_VEC, [psvToIRVar(env, pt2), ptInDisc], fn genPtToTip =>                      letPRIM("gptt", IR.T_VEC, IR.SUB_VEC, [psvToIRVar(env, pt2), ptInDisc], fn genPtToTip =>
269                      letPRIM("gpttlen", IR.T_FLOAT, IR.LEN, [genPtToTip], fn genPtToTipLen =>                      letPRIM("gpttlen", IR.T_FLOAT, IR.LEN, [genPtToTip], fn genPtToTipLen =>
270                      letPRIM("s", IR.T_FLOAT, IR.MULT, [genPtToTipLen, ourRand], fn scale =>                      letPRIM("s", IR.T_FLOAT, IR.MULT, [genPtToTipLen, ourRand], fn scale =>
# Line 471  Line 467 
467              (* end case *)              (* end case *)
468            end (*end let *)            end (*end let *)
469    
470            fun mkIntBool(env, p1var, p2var, d : Vec3f.vec3 P.domain, k : IR.var -> IR.stmt) = let
   (* generate code to produce a random particle state from a domain *)  
     fun newParticle (posDomain, (szDom : Float.float P.domain, szDist), velDomain, colDomain, env, k : particle_state -> IR.stmt) =  
             (* genVecVar (vecVar, env, domain, stmt) *)  
             genVecVar("ps_pos", env, posDomain, fn newPos =>  
             genVecVar("ps_vel", env, velDomain, fn newVel =>  
             genVecVar("ps_col", env, colDomain, fn newCol =>  
             genFloatVar("ps_size", env, szDom, szDist, fn newSize =>  
             letPRIM ("ps_ttl", IR.T_FLOAT, IR.COPY, [IR.newConst("fbool", IR.C_FLOAT 10000.0)], fn newIsDead =>  
               k(PS{pos = newPos,  
                    vel = newVel,  
                    size = newSize,  
                    ttl = newIsDead,  
                    color = newCol,  
                    user = []})  
             )))))  
   
         fun mkIntBool(env, p1var, p2var, d : Vec3f.vec3f P.domain, k : IR.var -> IR.stmt) = let  
471            val _ = ()            val _ = ()
472           in           in
473            (case d            (case d
# Line 521  Line 500 
500    
501           end (* mkIntBool *)           end (* mkIntBool *)
502    
503          fun mkIntPt(env, p1var, p2var, d : Vec3f.vec3f P.domain, k : IR.var -> IR.stmt) = let          fun mkIntPt(env, p1var, p2var, d : Vec3f.vec3 P.domain, k : IR.var -> IR.stmt) = let
504            val _ = ()            val _ = ()
505           in           in
506            (case d            (case d
507              of P.D_POINT(pt) => k (psvToIRVar pt)              of P.D_POINT(pt) => k (psvToIRVar (env, pt))
508               | _ => raise Fail ("Cannot calculate intersection for specified domain")               | _ => raise Fail ("Cannot calculate intersection for specified domain")
509            (* end case *))            (* end case *))
510           end (* mkIntPt *)           end (* mkIntPt *)
# Line 534  Line 513 
513       * domain. Note, that the particle doesn't necessarily need to be on the       * domain. Note, that the particle doesn't necessarily need to be on the
514       * domain, but if it's not then the behavior is undefined.       * domain, but if it's not then the behavior is undefined.
515       *)       *)
516      fun normAtPoint(retNorm, d, env, state, k : IR.var -> particle_state -> IR.stmt) = let      fun normAtPoint(retNorm, d, env, pos, state, k : IR.var -> particle_state -> IR.stmt) = let
517        val newNorm = IR.newParam("n", IR.T_VEC)        val newNorm = IR.newParam("n", IR.T_VEC)
518        val nextBlk = newBlockWithArgs(env, userVarsFromState(state), [newNorm], k(newNorm))        val nextBlk = newBlockWithArgs(env, state, [newNorm], k(newNorm))
       val PS{pos, ...} = state  
519       in       in
520        (case d        (case d
521            of P.D_PLANE{pt, normal} => letPRIM(retNorm, IR.T_VEC, IR.COPY, [psvToIRVar(env, normal)],            of P.D_PLANE{pt, normal} => letPRIM(retNorm, IR.T_VEC, IR.COPY, [psvToIRVar(env, normal)],
# Line 557  Line 535 
535                     )                     )
536                   )                   )
537    
538             | P.D_SPHERE{center, irad, orad} => let             | P.D_SPHERE{center, irad, orad} =>
               val PS{pos, ...} = state  
               in  
539                      letPRIM("sv", IR.T_VEC, IR.SUB_VEC, [pos, psvToIRVar(env, center)], fn subVec =>                      letPRIM("sv", IR.T_VEC, IR.SUB_VEC, [pos, psvToIRVar(env, center)], fn subVec =>
540                  letPRIM(retNorm, IR.T_VEC, IR.NORM, [subVec], fn newNormVar => k newNormVar state                  letPRIM(retNorm, IR.T_VEC, IR.NORM, [subVec], fn newNormVar => k newNormVar state
541                      ))                      ))
               end  
542    
543             | _ => raise Fail("Cannot find normal to point of specified domain.")             | _ => raise Fail("Cannot find normal to point of specified domain.")
544           (* end case *))           (* end case *))
545          end          end
546    
547          fun trExpr(expr, env, state, k : IR.var -> IR.stmt) = (case expr          fun trExpr(expr, env, state, k : IR.var -> IR.stmt) = (case expr
548            of CONSTF f => k IR.newConst ("c", IR.C_FLOAT f)            of P.CONSTF f => k (IR.newConst ("c", IR.C_FLOAT f))
549    
550         | CONST3F v => k IR.newConst ("c", IR.C_VEC v)         | P.CONST3F v => k (IR.newConst ("c", IR.C_VEC v))
551    
552         | VAR v => k (psvToIRVar v)         | P.VAR v => k (psvToIRVar (env, v))
553    
554         | STATE_VAR sv => k (pssvToIRVar sv)         | P.STATE_VAR sv => k (getIRVarForSV (sv, state))
555    
556         | GENERATE3F (dom, dist) => genVecVar("genVec", env, dom, dist, k)         | P.GENERATE3F (dom, dist) => genVecVar("genVec", env, dom, dist, k)
557    
558         | GENERATEF (dom, dist) => genFloatVar("genFlt", env, dom, dist, k)         | P.GENERATEF (dom, dist) => genFloatVar("genFlt", env, dom, dist, k)
559    
560         | ADD(e1, e2) =>         | P.ADD(e1, e2) =>
561           trExpr(e1, env, state, fn e1var =>           trExpr(e1, env, state, fn e1var =>
562           trExpr(e2, env, state, fn e2var =>           trExpr(e2, env, state, fn e2var =>
563           let           let
564            val V{varType=vt1, ...} = e1var            val IR.V{varType=vt1, ...} = e1var
565            val V{varType=vt2, ...} = e2var            val IR.V{varType=vt2, ...} = e2var
566           in           in
567            (case (vt1, vt2)            (case (vt1, vt2)
568              of (IR.T_FLOAT, IR.T_FLOAT) => letPRIM("addVar", IR.T_FLOAT, IR.ADD, [e1var, e2var], k)              of (IR.T_FLOAT, IR.T_FLOAT) => letPRIM("addVar", IR.T_FLOAT, IR.ADD, [e1var, e2var], k)
# Line 596  Line 571 
571            (* end case *))            (* end case *))
572           end))           end))
573    
574         | SCALE (e1, e2) =>         | P.SCALE (e1, e2) =>
575           trExpr(e1, env, state, fn e1var =>           trExpr(e1, env, state, fn e1var =>
576           trExpr(e2, env, state, fn e2var =>           trExpr(e2, env, state, fn e2var =>
577           let           let
578            val V{varType=vt1, ...} = e1var            val IR.V{varType=vt1, ...} = e1var
579            val V{varType=vt2, ...} = e2var            val IR.V{varType=vt2, ...} = e2var
580           in           in
581            (case (vt1, vt2)            (case (vt1, vt2)
582              of (IR.T_FLOAT, IR.T_VEC) => letPRIM("scaleVar", IR.T_VEC, IR.SCALE, [e1var, e2var], k)              of (IR.T_FLOAT, IR.T_VEC) => letPRIM("scaleVar", IR.T_VEC, IR.SCALE, [e1var, e2var], k)
# Line 610  Line 585 
585            (* end case *))            (* end case *))
586           end))           end))
587    
588         | DIV (e1, e2) =>         | P.DIV (e1, e2) =>
589           trExpr(e1, env, state, fn e1var =>           trExpr(e1, env, state, fn e1var =>
590           trExpr(e2, env, state, fn e2var =>           trExpr(e2, env, state, fn e2var =>
591           let           let
592            val V{varType=vt1, ...} = e1var            val IR.V{varType=vt1, ...} = e1var
593            val V{varType=vt2, ...} = e2var            val IR.V{varType=vt2, ...} = e2var
594           in           in
595            (case (vt1, vt2)            (case (vt1, vt2)
596              of (IR.T_FLOAT, IR.T_FLOAT) => letPRIM("divVar", IR.T_FLOAT, IR.DIV, [e1var, e2var], k)              of (IR.T_FLOAT, IR.T_FLOAT) => letPRIM("divVar", IR.T_FLOAT, IR.DIV, [e1var, e2var], k)
# Line 623  Line 598 
598            (* end case *))            (* end case *))
599           end))           end))
600    
601         | NEG e =>         | P.NEG e =>
602           trExpr(e, env, state, fn evar =>           trExpr(e, env, state, fn evar =>
603           let           let
604            val V{varType, ...} = evar            val IR.V{varType, ...} = evar
605           in           in
606            (case varType            (case varType
607              of IR.T_FLOAT => letPRIM("negVar", IR.T_FLOAT, IR.T_MULT, [evar, IR.newConst("negOne", IR.C_FLOAT ~1.0)], k)              of IR.T_FLOAT => letPRIM("negVar", IR.T_FLOAT, IR.MULT, [evar, IR.newConst("negOne", IR.C_FLOAT ~1.0)], k)
608               | IR.T_VEC => letPRIM("negVar", IR.T_VEC, IR.NEG_VEC, [evar], k)               | IR.T_VEC => letPRIM("negVar", IR.T_VEC, IR.NEG_VEC, [evar], k)
609               | _ => raise Fail ("Type mismatch to NEG expression")               | _ => raise Fail ("Type mismatch to NEG expression")
610            (* end case *))            (* end case *))
611           end)           end)
612    
613         | DOT (e1, e2) =>         | P.DOT (e1, e2) =>
614           trExpr(e1, env, state, fn e1var =>           trExpr(e1, env, state, fn e1var =>
615           trExpr(e2, env, state, fn e2var =>           trExpr(e2, env, state, fn e2var =>
616           let           let
617            val V{varType=vt1, ...} = e1var            val IR.V{varType=vt1, ...} = e1var
618            val V{varType=vt2, ...} = e2var            val IR.V{varType=vt2, ...} = e2var
619           in           in
620            (case (vt1, vt2)            (case (vt1, vt2)
621              of (IR.T_VEC, IR.T_VEC) => letPRIM("dotVar", IR.T_FLOAT, IR.DOT, [e1var, e2var], k)              of (IR.T_VEC, IR.T_VEC) => letPRIM("dotVar", IR.T_FLOAT, IR.DOT, [e1var, e2var], k)
# Line 648  Line 623 
623            (* end case *))            (* end case *))
624           end))           end))
625    
626         | CROSS (e1, e2) =>         | P.CROSS (e1, e2) =>
627           trExpr(e1, env, state, fn e1var =>           trExpr(e1, env, state, fn e1var =>
628           trExpr(e2, env, state, fn e2var =>           trExpr(e2, env, state, fn e2var =>
629           let           let
630            val V{varType=vt1, ...} = e1var            val IR.V{varType=vt1, ...} = e1var
631            val V{varType=vt2, ...} = e2var            val IR.V{varType=vt2, ...} = e2var
632           in           in
633            (case (vt1, vt2)            (case (vt1, vt2)
634              of (IR.T_VEC, IR.T_VEC) => letPRIM("crossVar", IR.T_VEC, IR.CROSS, [e1var, e2var], k)              of (IR.T_VEC, IR.T_VEC) => letPRIM("crossVar", IR.T_VEC, IR.CROSS, [e1var, e2var], k)
# Line 661  Line 636 
636            (* end case *))            (* end case *))
637           end))           end))
638    
639         | NORMALIZE e =>         | P.NORMALIZE e =>
640           trExpr(e, env, state, fn evar =>           trExpr(e, env, state, fn evar =>
641           let           let
642            val V{varType, ...} = evar            val IR.V{varType, ...} = evar
643           in           in
644            (case varType            (case varType
645              of IR.T_VEC => letPRIM("normVar", IR.T_VEC, IR.NORM, [evar], k)              of IR.T_VEC => letPRIM("normVar", IR.T_VEC, IR.NORM, [evar], k)
# Line 672  Line 647 
647            (* end case *))            (* end case *))
648           end)           end)
649    
650         | LENGTH e =>         | P.LENGTH e =>
651           trExpr(e, env, state, fn evar =>           trExpr(e, env, state, fn evar =>
652           let           let
653            val V{varType, ...} = evar            val IR.V{varType, ...} = evar
654           in           in
655            (case varType            (case varType
656              of IR.T_VEC => letPRIM("lenVar", IR.T_VEC, IR.LEN, [evar], k)              of IR.T_VEC => letPRIM("lenVar", IR.T_VEC, IR.LEN, [evar], k)
# Line 684  Line 659 
659           end)           end)
660    
661         (* !SPEED! We're assuming that there is an intersection here... *)         (* !SPEED! We're assuming that there is an intersection here... *)
662         | INTERSECT {p1, p2, d} =>         | P.INTERSECT {p1, p2, d} =>
663           trExpr(p1, env, state, fn p1var =>           trExpr(p1, env, state, fn p1var =>
664           trExpr(p2, env, state, fn p2var =>           trExpr(p2, env, state, fn p2var =>
665           let           let
666            val V{varType=vt1, ...} = p1var            val IR.V{varType=vt1, ...} = p1var
667            val V{varType=vt2, ...} = p2var            val IR.V{varType=vt2, ...} = p2var
668           in           in
669            (case (vt1, vt2)            (case (vt1, vt2)
670              of (IR.T_VEC, IR.T_VEC) => mkIntPt(env, p1var, p2var, d, k)              of (IR.T_VEC, IR.T_VEC) => mkIntPt(env, p1var, p2var, d, k)
# Line 697  Line 672 
672            (* end case *))            (* end case *))
673           end))           end))
674    
675         | NORMALTO (e, d) =>         | P.NORMALTO (e, d) =>
676           trExpr(e, env, state, fn evar =>           trExpr(e, env, state, fn evar =>
677           let           let
678            val V{varType, ...} = evar            val IR.V{varType, ...} = evar
679            fun cont s = k s            fun cont s = k s
680           in           in
681            (case varType            (case varType
682              of IR.T_VEC => normAtPoint("normVar", d, env, state, fn var => fn state' => k var)              of IR.T_VEC => normAtPoint("normVar", d, env, evar, state, fn var => fn state' => k var)
683               | _ => raise Fail("Type mismatch to NORMALTO expression")               | _ => raise Fail("Type mismatch to NORMALTO expression")
684            (* end case *))            (* end case *))
685           end)           end)
686    
687            (* end case expr *))            (* end case expr *))
688    
689              (* generate code to produce a random particle state from a domain *)
690        fun newParticle (sv_gens, env, state, k : particle_state -> IR.stmt) = let
691    
692          fun createVar(P.GEN{var, ...}) = let
693            val P.PSV.SV{name, ty, ...} = var
694           in
695            IR.newLocal("ps_" ^ name, IR.psvTyToIRTy ty, (IR.RAND, []))
696           end
697    
698          val newState = List.map createVar sv_gens
699    
700          fun genVar((sv_gen, var), cont) = let
701            val P.GEN{exp, ...} = sv_gen
702            val IR.V{varType, ...} = var
703           in
704            trExpr(exp, env, state, fn newVal => IR.mkPRIM(var, IR.COPY, [newVal], cont))
705           end (* genVar *)
706    
707         in
708          List.foldr (fn (x, y) => genVar(x, y)) (k newState) (ListPair.zipEq (sv_gens, newState))
709         end (* new particle *)
710    
711      fun trEmitter(emit, env, state, k : particle_state -> IR.stmt) = let      fun trEmitter(emit, env, state, k : particle_state -> IR.stmt) = let
712        val P.EMIT{freq, sv_gens} = emit        val P.EMIT{freq, sv_gens} = emit
713        val blk = newBlock (env, user, k)        val blk = newBlock (env, state, k)
714          val ttl = findIRVarByName(state, "ttl")
715       in       in
716        letPRIM("isDead", IR.T_BOOL, IR.GT, [IR.newConst("small", IR.C_FLOAT 0.1), ttl], fn isDead =>        letPRIM("isDead", IR.T_BOOL, IR.GT, [IR.newConst("small", IR.C_FLOAT 0.1), ttl], fn isDead =>
717        IR.mkIF(isDead,        IR.mkIF(isDead,
718         (* then *)         (* then *)
719         genFloatVar("t1", env, rDom, rDist, fn t1 =>         trExpr(freq, env, state, fn t1 =>
720         letPRIM("t2", IR.T_FLOAT, IR.ITOF, [psvToIRVar (env, PSV.numDead)], fn t2 =>         letPRIM("t2", IR.T_FLOAT, IR.ITOF, [psvToIRVar (env, PSV.numDead)], fn t2 =>
721         letPRIM("prob", IR.T_FLOAT, IR.DIV, [t1, t2], fn prob =>         letPRIM("prob", IR.T_FLOAT, IR.DIV, [t1, t2], fn prob =>
722         letPRIM("r", IR.T_FLOAT, IR.RAND, [], fn r =>         letPRIM("r", IR.T_FLOAT, IR.RAND, [], fn r =>
723         letPRIM("t3", IR.T_BOOL, IR.GT, [prob, r], fn t3 =>         letPRIM("t3", IR.T_BOOL, IR.GT, [prob, r], fn t3 =>
724         IR.mkIF(t3,         IR.mkIF(t3,
725          (* then *)          (* then *)
726          newParticle (posDomain, szDomain, velDomain, colDomain, env,          newParticle (sv_gens, env, state, fn state' => retState state'),
          fn state' => retState state'),  
727          (* else *)          (* else *)
728          IR.DISCARD)))))),          IR.DISCARD)))))),
729         (* else *)         (* else *)
# Line 885  Line 882 
882                          PSV.Map.insert (map, x, x')                          PSV.Map.insert (map, x, x')
883                     end (* ins *)                     end (* ins *)
884    
885                   fun convertToIR PSV.SV{name, ty, id, ...} = IR.newParam(name, IR.psvTyToIRTy ty)                   fun convertToIR PSV.SV{name, ty, id, ...} = IR.newParam("ps_" ^ name, IR.psvTyToIRTy ty)
                  fun inssv (x, map) = PSV.SVMap.insert(map, x, convertToIR x)  
886                  in                  in
887                    TE(                    TE(
888                     blks,                     blks,
889                     PSV.Set.foldl insv PSV.Map.empty pgm_vars,                     PSV.Set.foldl insv PSV.Map.empty pgm_vars
                    PSV.SVSet.foldl inssv PSV.SVMap.empty state_vars  
890                    )                    )
891                  end (* env *)                  end (* env *)
892    

Legend:
Removed from v.1108  
changed lines
  Added in v.1109

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