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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/tree-il/tree-il-pp.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/tree-il/tree-il-pp.sml

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

trunk/src/compiler/tree-il/tree-il-pp.sml revision 1115, Thu May 5 04:42:18 2011 UTC branches/charisee/src/compiler/tree-il/tree-il-pp.sml revision 2690, Fri Aug 29 15:41:22 2014 UTC
# Line 28  Line 28 
28      fun prl (out, l) = pr(out, concat l)      fun prl (out, l) = pr(out, concat l)
29      fun prln (out, l) = (indent out; prl(out, l))      fun prln (out, l) = (indent out; prl(out, l))
30    
31        fun itos m = Int.toString m
32    
33      fun expToString e = let      fun expToString e = let
34            fun argsToS (lp, args, rp, l) = let            fun argsToS (shift, lp, args, rp, l) = let
35                  fun argToS ([], l) = l                  fun argToS ([], l) = l
36                    | argToS ([e], l) = toS (e, l)                    | argToS ([e], l) = toS (e, l)
37                    | argToS (e::es, l) = toS(e, "," :: argToS(es, l))                    | argToS (e::es, l) = toS(e, shift:: argToS(es, l))
38                  in                  in
39                    lp :: argToS(args, rp :: l)                    lp :: argToS(args, rp :: l)
40                  end                  end
41            and toS (IL.E_Var x, l) = Var.name x :: l  
42              and toS (IL.E_State x, l) = IL.stateVarToString x :: l
43                | toS (IL.E_Var x, l) = (case (Var.kind x)
44                     of IL.VK_Local => Var.name x :: l
45                      | _ => "::" :: Var.name x :: l
46                    (* end case *))
47              | toS (IL.E_Lit lit, l) = Literal.toString lit :: l              | toS (IL.E_Lit lit, l) = Literal.toString lit :: l
48              | toS (IL.E_Op(rator, args), l) = Op.toString rator :: argsToS ("(", args, ")", l)              | toS (IL.E_Op(rator, args), l) = Op.toString rator :: argsToS (",","(", args, ")", l)
49              | toS (IL.E_Apply(f, args), l) = ILBasis.toString f :: argsToS ("(", args, ")", l)              | toS (IL.E_Apply(f, args), l) = MathFuns.toString f :: argsToS (",","(", args, ")", l)
50              | toS (IL.E_Cons(ty, args), l) =              | toS (IL.E_Cons(ty, args), l) =
51                  "<" :: Ty.toString ty :: ">" :: argsToS ("{", args, "}", l)                  "<" :: Ty.toString ty :: ">" :: argsToS (",","{", args, "}", l)
52                | toS (IL.E_Mux(A,nSize,oSize, pieces, args),l) =
53                        "Mux<" ::itos nSize :: ":" :: itos oSize ::"[>\t ]"::argsToS (",","(", args, ")", l)
54    
55    
56                | toS (IL.E_LoadArr(A,tyNew, tyOrig, arg, offset), l) =
57                            "LdArr<" :: itos tyNew :: ":" :: itos tyOrig :: ">("
58                                :: argsToS (",", "(", [arg, offset], ")", l)
59            in            in
60              String.concat (toS (e, []))              String.concat (toS (e, []))
61            end            end
62    
63    
64      fun argsToString (prefix, es) = String.concat[      fun argsToString (prefix, es) = String.concat[
65              prefix, "(", String.concatWith "," (List.map expToString es), ")"              prefix, "(", String.concatWith "," (List.map expToString es), ")"
66            ]            ]
# Line 59  Line 74 
74              | ppParams (x::r) = (              | ppParams (x::r) = (
75                  prl(out, [Ty.toString (Var.ty x), " ", Var.name x, ","]);                  prl(out, [Ty.toString (Var.ty x), " ", Var.name x, ","]);
76                  ppParams r)                  ppParams r)
77            fun ppSVarDecl (IL.SV{varying, output, var}) = let            fun ppSVarDecl (IL.SV{varying, output, name, ty, ...}) = let
78                  val v = if varying then "varying " else ""                  val v = if varying then "varying " else ""
79                  val out = if output then "output " else ""                  val out = if output then "output " else ""
80                  in                  in
81                    prln (out', [v, out, Ty.toString(Var.ty var), " ", Var.name var, ";\n"])                    prln (out', [v, out, Ty.toString ty, " ", name, ";\n"])
82                  end                  end
83            in            in
84              prln (out, ["strand ", Atom.toString name, " ("]);              prln (out, ["strand ", Atom.toString name, " ("]);
# Line 75  Line 90 
90            end            end
91    
92      and ppMethod out (IL.Method{name, body}) = (      and ppMethod out (IL.Method{name, body}) = (
93            prln (out, [Atom.toString name, " () "]);            prln (out, [StrandUtil.nameToString name, " () "]);
94            ppBlock (out, body);            ppBlock (out, body);
95            pr (out, "\n"))            pr (out, "\n"))
96    
# Line 94  Line 109 
109                  in                  in
110                    List.app (fn s => prln(out, ["// ", s, "\n"])) text                    List.app (fn s => prln(out, ["// ", s, "\n"])) text
111                  end                  end
112              | IL.S_Assign(x, e) => prln(out, [Var.name x, " = ", expToString e, ";\n"])              | IL.S_Assign([], e) => prln(out, [expToString e, ";\n"])
113                | IL.S_Assign([x], e) => prln(out, [Var.name x, "=Assign= ", expToString e, ";\n"])
114                | IL.S_Assign(x::xs, e) => (
115                    prln(out, ["(", Var.name x]);
116                    List.app (fn x => prl(out, [",", Var.name x])) xs;
117                    prl (out, [") = ", expToString e, ";\n"]))
118              | IL.S_IfThen(cond, blk) => (              | IL.S_IfThen(cond, blk) => (
119                  prln (out, ["if (", expToString cond, ") "]);                  prln (out, ["if (", expToString cond, ") "]);
120                  ppBlock (out, blk);                  ppBlock (out, blk);
# Line 113  Line 133 
133                    ]);                    ]);
134                  ppBlock (out, blk);                  ppBlock (out, blk);
135                  pr (out, "\n"))                  pr (out, "\n"))
             | IL.S_Cons(x, args) => let  
                 fun mkStrings [] = []  
                   | mkStrings [e] = [expToString e]  
                   | mkStrings (e::es) = (expToString e ^ ",") :: mkStrings es  
                 val args = mkStrings args  
                 in  
                   if (List.foldl (fn (s, n) => n+size s) 0 args > 60)  
                     then let  
                       val out' = incIndent out  
                       val out'' = incIndent out'  
                       fun prArgs (_, []) = (  
                             pr (out', "\n");  
                             prln (out', ["};\n"]))  
                         | prArgs (n, arg::args) =  
                             if (n = 0)  
                               then (  
                                 prln (out'', [arg]);  
                                 prArgs (n + size arg, args))  
                             else if (n + size arg > 60)  
                               then (  
                                 pr(out'', "\n");  
                                 prArgs (0, arg::args))  
                               else (  
                                 pr(out'', " ");  
                                 pr(out'', arg);  
                                 prArgs (n + size arg + 1, args))  
                       in  
                         prln (out, [Var.name x, " = {\n"]);  
                         prArgs (0, args)  
                       end  
                     else (  
                       prln (out, Var.name x :: " = {" :: args);  
                       pr (out, "};\n"))  
                 end  
             | IL.S_LoadVoxels(x, dim, exp) =>  
                 prln (out, [  
                     Var.name x, " = loadVoxels<",  
                     Int.toString dim, "> (", expToString exp, ");\n"  
                   ])  
136  *)  *)
137                | IL.S_New(strand, args) =>
138                    prln (out, [argsToString("new "^Atom.toString strand, args), ";\n"])
139                | IL.S_Save([x], rhs) =>
140                    prln (out, [IL.stateVarToString x, " =Save= ", expToString rhs, ";\n"])
141                | IL.S_Save(x::xs, e) => (
142                    prln(out, ["(", IL.stateVarToString x]);
143                    List.app (fn x => prl(out, [",", IL.stateVarToString x])) xs;
144                    prl (out, [") = ", expToString e, ";\n"]))
145              | IL.S_LoadImage(x, dim, exp) =>              | IL.S_LoadImage(x, dim, exp) =>
146                  prln (out, [                  prln (out, [
147                      Var.name x, " = load<", Int.toString dim, "> (", expToString exp, ");\n"                      Var.name x, " = load<", Int.toString dim, "> (", expToString exp, ");\n"
148                    ])                    ])
149              | IL.S_Input(x, name, NONE) =>              | IL.S_Input(x, name, desc, NONE) =>
150                  prln (out, [                  prln (out, [
151                      Var.name x, " = input<", Ty.toString(Var.ty x), "> (\"",                      Var.name x, " = input<", Ty.toString(Var.ty x), "> (\"",
152                      String.toString name, "\");\n"                      String.toString name, "\",\"", String.toString desc, "\");\n"
153                    ])                    ])
154              | IL.S_Input(x, name, SOME dflt) =>              | IL.S_Input(x, name, desc, SOME dflt) =>
155                  prln (out, [                  prln (out, [
156                      Var.name x, " = input<", Ty.toString(Var.ty x), "> (\"",                      Var.name x, " = input<", Ty.toString(Var.ty x), "> (\"",
157                      String.toString name, "\",", expToString dflt, ");\n"                      String.toString name, "\",\"", String.toString desc, "\",",
158                        expToString dflt, ");\n"
159                    ])                    ])
160              | IL.S_Exit es => prln (out, [argsToString("exit", es), ";\n"])              | IL.S_Exit es => prln (out, [argsToString("exit", es), ";\n"])
161            (* return functions for methods *)            (* return functions for methods *)
162              | IL.S_Active es => prln (out, [argsToString("active", es), ";\n"])              | IL.S_Active => prln (out, ["active;\n"])
163              | IL.S_Stabilize es => prln (out, [argsToString("stabilize", es), ";\n"])              | IL.S_Stabilize => prln (out, ["stabilize;\n"])
164              | IL.S_Die => prln (out, ["die;\n"])              | IL.S_Die => prln (out, ["die;\n"])
165                | IL.S_StoreVec(x,A,nSize, oSize, pieces, args) =>
166                       prln(out, "StoreVectoArr1<" ::expToString x:: " = "::itos nSize :: ":" :: itos oSize ::[">\n\t" ])
167            (* end case *))            (* end case *))
168    
169      fun statement (outS, stm) = ppStm((outS, 0), stm)      fun statement (outS, stm) = ppStm((outS, 0), stm)
170    
171      fun block (outS, blk) = (ppBlock ((outS, 0), blk); pr ((outS, 0), "\n"))      fun block (outS, blk) = (ppBlock ((outS, 0), blk); pr ((outS, 0), "\n"))
172    
173      fun program (outS, IL.Program{globals, globalInit, strands, initially}) = let      fun ppInitially (out, {isArray, iterPrefix, iters, createPrefix, strand, args}) = let
174              fun ppBlock (out, IL.Block{locals, body}, inside) = let
175                    val out' = incIndent out
176                    in
177                      pr (out, "{\n");
178                      List.app (ppVarDecl out') locals;
179                      List.app (fn stm => ppStm(out', stm)) body;
180                      inside out';
181                      indent out; pr (out, "}")
182                    end
183              fun ppCreate out = let
184                    fun ppNew out = prln(out, [argsToString("new "^Atom.toString strand, args), ";\n"])
185                    in
186                      indent out; ppBlock (out, createPrefix, ppNew);  pr(out, "\n")
187                    end
188              fun ppIters out = let
189                    fun ppIter (out, []) = ppCreate out
190                      | ppIter (out, (i, lo, hi)::iters) = (
191                          prln(out, ["for ", Var.name i, " = ", expToString lo, " .. ", expToString hi, "\n"]);
192                          ppIter (incIndent out, iters))
193                    in
194                      ppIter (out, iters)
195                    end
196              in
197                indent out; pr(out, if isArray then "ARRAY " else "COLLECTION ");
198                ppBlock (out, iterPrefix, ppIters);
199                pr (out, "\n")
200              end
201    
202        fun program (outS, IL.Program{props,types,oprations, globals, inputInit, globalInit, strands, initially}) = let
203            val out = (outS, 0)            val out = (outS, 0)
204            val out' = incIndent out            val out' = incIndent out
205            in            in
206                pr(out, "//***** PROPERTIES *****\n");
207                case props
208                 of [] => prln(out', ["none\n"])
209                  | _ => prln(out', [String.concatWith " " (List.map StrandUtil.propToString props), "\n"])
210                (* end case *);
211              prln(out, ["//***** GLOBALS *****\n"]);              prln(out, ["//***** GLOBALS *****\n"]);
212              List.app (ppVarDecl out') globals;              List.app (ppVarDecl out') globals;
213                prln(out, ["//***** INPUT INIT *****\n"]);
214                indent out'; ppBlock (out', inputInit); pr (out, "\n");
215              prln(out, ["//***** GLOBAL INIT *****\n"]);              prln(out, ["//***** GLOBAL INIT *****\n"]);
216              indent out'; ppBlock (out', globalInit); pr (out, "\n");              indent out'; ppBlock (out', globalInit); pr (out, "\n");
217              prln(out, ["//***** STRANDS *****\n"]);              prln(out, ["//***** STRANDS *****\n"]);
218              List.app (ppStrand out) strands;              List.app (ppStrand out) strands;
219              prln(out, ["//***** INITIALLY *****\n"])              prln(out, ["//***** INITIALLY *****\n"]);
220              (* FIXME: print initially stuff *)              ppInitially (out', initially)
221            end            end
222    
223    end    end

Legend:
Removed from v.1115  
changed lines
  Added in v.2690

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