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

SCM Repository

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

Diff of /branches/charisee/src/compiler/c-util/tree-to-c-fn.sml

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

revision 2668, Thu Jun 12 03:29:04 2014 UTC revision 2669, Fri Jun 13 02:08:31 2014 UTC
# Line 70  Line 70 
70    
71      fun addrOf e = CL.mkUnOp(CL.%&, e)      fun addrOf e = CL.mkUnOp(CL.%&, e)
72    
73      val cat=CL.T_Named ("cat")  
74    (* translate TreeIL types to CLang types *)    (* translate TreeIL types to CLang types *)
75      fun trType ty = (case ty      fun trType ty = (case ty
76             of Ty.BoolTy => CLang.T_Named "bool"             of Ty.BoolTy => CLang.T_Named "bool"
# Line 157  Line 157 
157    
158    (* matrix indexing *)    (* matrix indexing *)
159      fun matIndex (m, ix, jx) =      fun matIndex (m, ix, jx) =
160            CL.mkSubscript(CL.mkSelect(CL.mkSubscript(m, ix), "r"), jx)          (*  CL.mkSubscript(CL.mkSelect(CL.mkSubscript(m, ix), "r"), jx)*)
161    
162            CL.mkSubscript(CL.mkSubscript(m, ix), jx)
163    
164    
165      fun matProj(m, ix) =      fun matProj(m, ix) =
166       CL.mkSelect(CL.mkSubscript(m, ix), "r")       CL.mkSelect(CL.mkSubscript(m, ix), "r")
# Line 182  Line 185 
185               (*Vector functions*)               (*Vector functions*)
186              | (Op.prodScaV d,args)   => CL.E_Apply(N.NameScaV d, args)              | (Op.prodScaV d,args)   => CL.E_Apply(N.NameScaV d, args)
187              | (Op.sumVec d,args)     => CL.E_Apply(N.NameSumV d, args)              | (Op.sumVec d,args)     => CL.E_Apply(N.NameSumV d, args)
188              | (Op.IndexTensor(_,Ty.TensorTy [], Ty.indexTy [i],  Ty.TensorTy [argTy]),[a])=>              | (Op.IndexTensor(_,Ty.TensorTy [], Ty.indexTy [i],  Ty.TensorTy [argTy]),[a])=>prntArr(a,argTy,i)
189                      (*vecIndex (a, argTy, i)*)                      (*vecIndex (a, argTy, i)*)
190                      CL.E_Str "cow8"  
191    
192              | (Op.IndexTensor (_,Ty.TensorTy [_], Ty.indexTy [i],              | (Op.IndexTensor (_,Ty.TensorTy [_], Ty.indexTy [i],
193                  Ty.TensorTy[_,_]),[m])=>matProj(m,intExp i)                  Ty.TensorTy[_,_]),[m])=>matProj(m,intExp i)
# Line 224  Line 227 
227              | (Op.PrincipleEvec ty, _) => raise Fail "PrincipleEvec unimplemented"              | (Op.PrincipleEvec ty, _) => raise Fail "PrincipleEvec unimplemented"
228              | (Op.Select(Ty.TupleTy tys, i), [a]) => raise Fail "Select unimplemented"              | (Op.Select(Ty.TupleTy tys, i), [a]) => raise Fail "Select unimplemented"
229              | (Op.Index(Ty.SeqTy(Ty.IntTy, n), i), [a]) => ivecIndex (a, n, i)              | (Op.Index(Ty.SeqTy(Ty.IntTy, n), i), [a]) => ivecIndex (a, n, i)
230              | (Op.Index(Ty.TensorTy[n], i), [a]) => (*vecIndex (a, n, i)*) CL.E_Str "cow64"              | (Op.Index(Ty.TensorTy[n], i), [a]) => vecIndex (a, n, i)
231              | (Op.Subscript(Ty.SeqTy(Ty.IntTy, n)), [v, ix]) => let              | (Op.Subscript(Ty.SeqTy(Ty.IntTy, n)), [v, ix]) => let
232                  val unionTy = CL.T_Named(concat["Squishunion", Int.toString n, !N.gIntSuffix, "_t"])                  val unionTy = CL.T_Named(concat["Squishunion", Int.toString n, !N.gIntSuffix, "_t"])
233                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "i")                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "i")
# Line 293  Line 296 
296                (* N.mkVec n,N.NameConsVec n*)                (* N.mkVec n,N.NameConsVec n*)
297    
298              | IL.E_Cons(Ty.TensorTy e, args) => CL.mkApply(N.tenTy e,trExps(env, args))              | IL.E_Cons(Ty.TensorTy e, args) => CL.mkApply(N.tenTy e,trExps(env, args))
299    
300              | IL.E_Cons(ty, _) => raise Fail(concat["E_Cons(", Ty.toString ty, ", _) in expression"])              | IL.E_Cons(ty, _) => raise Fail(concat["E_Cons(", Ty.toString ty, ", _) in expression"])
301              | IL.E_mkVec( aligned,rst, orig,indexAt,_,args) =>              | IL.E_mkVec( aligned,rst, orig,indexAt,_,args) =>
302                            CL.mkApply(N.NameMkVec(aligned,rst,orig), trExps(env, [args]))                            CL.mkApply(N.NameMkVec(aligned,rst,orig), trExps(env, [args]))
# Line 350  Line 354 
354                      | Ty.TensorTy[n, m] =>                      | Ty.TensorTy[n, m] =>
355  *)  *)
356                      | Ty.SeqTy(elemTy, n) =>  let                      | Ty.SeqTy(elemTy, n) =>  let
357                          val (x, stm) = expToVar (env, (*trType ty*) cat , "vec", exp)                          val (x, stm) = expToVar (env, trType ty , "vec", exp)
358                          val elems = List.tabulate (n, fn i => ivecIndex (x, n, i))                          val elems = List.tabulate (n, fn i => ivecIndex (x, n, i))
359                          val (fmt, args) = mkSeqFmt (elemTy, elems, fmt, args)                          val (fmt, args) = mkSeqFmt (elemTy, elems, fmt, args)
360                          in                          in
# Line 368  Line 372 
372    
373                    | Ty.TensorTy[] => ("%f"::fmt, elem::args)                    | Ty.TensorTy[] => ("%f"::fmt, elem::args)
374                    | Ty.TensorTy[n] => let                    | Ty.TensorTy[n] => let
375                        val elems = List.tabulate (n, fn i => (*vecIndex (elem, n, i)*) CL.E_Str "cowd1111")                        val elems = List.tabulate (n, fn i => prntArr (elem, n, i) (*vecIndex (elem, n, i)*))
376                        in                        in
377                          mkSeqFmt (Ty.TensorTy[], elems, fmt, args)                          mkSeqFmt (Ty.TensorTy[], elems, fmt, args)
378                        end                        end
# Line 447  Line 451 
451                          CL.mkApply(N.mkVec n, List.tabulate (n, mkLoad)))                          CL.mkApply(N.mkVec n, List.tabulate (n, mkLoad)))
452                      ] end                      ] end
453                  else [CL.mkAssign(lhs, trExp(env, rhs))]                  else [CL.mkAssign(lhs, trExp(env, rhs))]
454              | IL.E_Cons(Ty.TensorTy[n,m], args) => let              | IL.E_Cons _ => raise Fail "Cons-caught it here"
455                (*| IL.E_Cons(Ty.TensorTy[n,m], args) => let
456                (* matrices are represented as arrays of union<d><ty>_t vectors *)                (* matrices are represented as arrays of union<d><ty>_t vectors *)
457                  fun doRows (_, []) = []                  fun doRows (_, []) = []
458                    | doRows (i, e::es) =                    | doRows (i, e::es) =
# Line 455  Line 460 
460                          :: doRows (i+1, es)                          :: doRows (i+1, es)
461                  in                  in
462                    doRows (0, trExps(env, args))                    doRows (0, trExps(env, args))
463                  end                  end*)
464              | IL.E_Var x => (case IL.Var.ty x              | IL.E_Var x => (case IL.Var.ty x
465                   of Ty.TensorTy[n,m] => [CL.mkCall(N.copyMat(n,m), [lhs, VarToC.rvalueVar(env, x)])]                   of Ty.TensorTy[n,m] => [CL.mkCall(N.copyMat(n,m), [lhs, VarToC.rvalueVar(env, x)])]
466                    | _ => [CL.mkAssign(lhs, VarToC.rvalueVar(env, x))]                    | _ => [CL.mkAssign(lhs, VarToC.rvalueVar(env, x))]
# Line 510  Line 515 
515    
516      fun trStms (env, stms) = let      fun trStms (env, stms) = let
517            val _= pntTest "\n tree Stmt"            val _= pntTest "\n tree Stmt"
518              val bug=CL.E_Var"sunflower"
519    
520            fun trStmt (env, stm) = (case stm            fun trStmt (env, stm) = (case stm
521                   of IL.S_Comment text => [CL.mkComment text]                   of IL.S_Comment text => [CL.mkComment text]
# Line 521  Line 526 
526                           (*val (CL.E_Var f)=x                           (*val (CL.E_Var f)=x
527                            val g=CL.E_Var x*)                            val g=CL.E_Var x*)
528    
529                          val exp=CL.mkApply(N.NameMkVec(A,rty,orig), [(*CL.E_Var"selfOut->PP"*) x' ]@trExps(env, [indexAt,args]))                          val exp=CL.mkApply(N.NameMkVec(A,rty,orig), [x' ]@trExps(env, [indexAt,args]))
530                          in                          in
531                              [CL.S_Exp exp]                              [CL.S_Exp exp]
532                          end                          end
533    
534                      (*Should find all vectors here *)
535                    | IL.S_Assign([x],IL.E_Cons(Ty.TensorTy[n], args)) =>let                    | IL.S_Assign([x],IL.E_Cons(Ty.TensorTy[n], args)) =>let
536                          val  x' =VarToC.lvalueVar (env, x)                          val  x' =VarToC.lvalueVar (env, x)
537                          val exp=  CL.mkApply(N.NameConsArray n, [x']@trExps(env, args))                          val exp=  CL.mkApply(N.NameConsArray [n], [x']@trExps(env, args))
538                            in
539                                [CL.S_Exp exp]
540                        end
541                      | IL.S_Assign([x],IL.E_Cons(Ty.TensorTy[i,j], args)) =>let
542                      val  x' =VarToC.lvalueVar (env, x)
543                      val exp=  CL.mkApply(N.NameConsArray [i,j], [x']@trExps(env, args))
544                          in                          in
545                              [CL.S_Exp exp]                              [CL.S_Exp exp]
546                      end                      end
547    
548                    | IL.S_Assign([x], exp) =>  
549                          trAssign (env, VarToC.lvalueVar (env, x), exp)                    | IL.S_Assign([x], IL.E_Cons _ ) =>raise Fail "Cons not written yet "
550    
551    
552                      | IL.S_Assign([x], exp) =>(
553                            trAssign (env, VarToC.lvalueVar (env, x) , exp))
554    
555    
556                    | IL.S_Assign(xs, exp) =>                    | IL.S_Assign(xs, exp) =>
# Line 546  Line 562 
562                          trBlk(env, thenBlk),                          trBlk(env, thenBlk),
563                          trBlk(env, elseBlk))]                          trBlk(env, elseBlk))]
564                    | IL.S_New _ => raise Fail "new not supported yet" (* FIXME *)                    | IL.S_New _ => raise Fail "new not supported yet" (* FIXME *)
565                    | IL.S_Save([x], exp) => trAssign (env, VarToC.lvalueStateVar x, exp)                    | IL.S_Save([x],IL.E_Cons _) =>
566                    raise Fail "roses"
567    
568                      | IL.S_Save([x],exp) =>
569    
570                    trAssign (env, VarToC.lvalueStateVar x, exp)
571    
572                    | IL.S_Save(xs, exp) =>                    | IL.S_Save(xs, exp) =>
573                        trMultiAssign (env, List.map VarToC.lvalueStateVar xs, exp)                        trMultiAssign (env, List.map VarToC.lvalueStateVar xs, exp)
574                    | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let                    | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let

Legend:
Removed from v.2668  
changed lines
  Added in v.2669

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