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

SCM Repository

[diderot] Diff of /branches/charisee_dev/src/compiler/high-to-mid/split.sml
ViewVC logotype

Diff of /branches/charisee_dev/src/compiler/high-to-mid/split.sml

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

revision 2845, Fri Dec 12 06:46:23 2014 UTC revision 3229, Thu Jul 30 16:10:54 2015 UTC
# Line 24  Line 24 
24      structure DstIL = MidIL      structure DstIL = MidIL
25      structure DstTy = MidILTypes      structure DstTy = MidILTypes
26      structure DstV = DstIL.Var      structure DstV = DstIL.Var
27    
28      structure P=Printer      structure P=Printer
29      structure cleanP=cleanParams      structure cleanP=cleanParams
30      structure cleanI=cleanIndex      structure cleanI=cleanIndex
31      structure handleE=handleEin  
32    
33      in      in
34    
35      val testing=1      val numFlag=1   (*remove common subexpression*)
36        val testing=0
37      fun setEin(params,index,body)=Ein.EIN{params=params, index=index, body=body}      fun setEin(params,index,body)=Ein.EIN{params=params, index=index, body=body}
38      fun assignEinApp(y,params,index,body,args)= (y,DstIL.EINAPP(setEin(params,index,body),args))      fun assignEinApp(y,params,index,body,args)= (y,DstIL.EINAPP(setEin(params,index,body),args))
39      val einappzero=DstIL.EINAPP(setEin([],[],E.Const 0),[])      val einappzero=DstIL.EINAPP(setEin([],[],E.Const 0),[])
# Line 39  Line 41 
41      fun cleanParams e =cleanP.cleanParams e      fun cleanParams e =cleanP.cleanParams e
42      fun cleanIndex e =cleanI.cleanIndex e      fun cleanIndex e =cleanI.cleanIndex e
43      fun printEINAPP e=MidToString.printEINAPP e      fun printEINAPP e=MidToString.printEINAPP e
     fun isZero e=handleE.isZero e  
44      fun itos i =Int.toString i      fun itos i =Int.toString i
45        fun filterSca e=Filter.filterSca e
46      fun err str=raise Fail str      fun err str=raise Fail str
47      val cnt = ref 0      val cnt = ref 0
48        fun incUse (DstIL.V{useCnt, ...}) = (useCnt := !useCnt + 1)
49      fun genName prefix = let      fun genName prefix = let
50          val n = !cnt          val n = !cnt
51      in      in
# Line 54  Line 57 
57          | _ =>(print(String.concat n);1)          | _ =>(print(String.concat n);1)
58          (*end case*))          (*end case*))
59    
   
60      (* lift:ein_app*params*index*sum_id*args-> (ein_exp* params*args*code)      (* lift:ein_app*params*index*sum_id*args-> (ein_exp* params*args*code)
61      *lifts expression and returns replacement tensor      *lifts expression and returns replacement tensor
62      * cleans the index and params of subexpression      * cleans the index and params of subexpression
63      *creates new param and replacement tensor for the original ein_exp      *creates new param and replacement tensor for the original ein_exp
64      *)      *)
65      fun lift(name,e,params,index,sx,args)=let      fun lift(name,e,params,index,sx,args,fieldset,flag)=let
66          val (tshape,sizes,body)=cleanIndex(e,index,sx)          val (tshape,sizes,body)=cleanIndex(e,index,sx)
67          val id=length(params)          val id=length(params)
68          val Rparams=params@[E.TEN(1,sizes)]          val Rparams=params@[E.TEN(1,sizes)]
# Line 68  Line 70 
70          val M  = DstV.new (genName (name^"_l_"^itos id), DstTy.TensorTy sizes)          val M  = DstV.new (genName (name^"_l_"^itos id), DstTy.TensorTy sizes)
71          val Rargs=args@[M]          val Rargs=args@[M]
72          val einapp=cleanParams(M,body,Rparams,sizes,Rargs)          val einapp=cleanParams(M,body,Rparams,sizes,Rargs)
73            val (_,einapp0)=einapp
74            val (Rargs,newbies,fieldset) =(case flag
75                of 1=> let
76                    val (fieldset,var) = einSet.rtnVar(fieldset,M,einapp0)
77                    in (case var
78                        of NONE=> (args@[M],[einapp],fieldset)
79                        | SOME v=> (incUse v ;(args@[v],[],fieldset))
80                        (*end case*))
81                    end
82                | _=>(args@[M],[einapp],fieldset)
83                  (*end case*))
84      in      in
85          (Re,Rparams,Rargs,[einapp])              (Re,Rparams,Rargs,newbies,fieldset)
86      end      end
87    
88    
89      (* isOp: ein->int      (* isOp: ein->int
90       * checks to see if this sub-expression is pulled out or split form original       * checks to see if this sub-expression is pulled out or split form original
91       * 0-becomes zero,1-remains the same, 2-operator       * 0-becomes zero,1-remains the same, 2-operator
# Line 83  Line 96 
96          | E.Apply _   => 0          | E.Apply _   => 0
97          | E.Lift _    => 0          | E.Lift _    => 0
98          | E.Neg _     => 1          | E.Neg _     => 1
99            | E.Sqrt _    => 1
100            | E.Cosine _      => 1
101            | E.ArcCosine _   => 1
102            | E.Sine _        => 1
103            | E.ArcSine _     => 1
104            | E.PowInt _      => 1
105            | E.PowReal _     => 1
106          | E.Add _     => 1          | E.Add _     => 1
107          | E.Sub _     => 1          | E.Sub _     => 1
108          | E.Prod _    => 1          | E.Prod _    => 1
# Line 96  Line 116 
116          | _           => 2          | _           => 2
117      (*end case*))      (*end case*))
118    
119    
120    
121        fun rewriteOp3(name,sx,e1,x)=let
122            val ((y, DstIL.EINAPP(ein,args)),fieldset,flag)=x
123            val params=Ein.params ein
124            val index=Ein.index ein
125            in (case (isOp e1)
126                of  0   => (E.Const 0,params,args,[],fieldset)
127                | 1     => lift(name,e1,params,index,sx,args,fieldset,flag)
128                | 2     => (e1,params,args,[],fieldset)
129                (*end*))
130            end
131    
132      (* rewriteOp:ein_exp*params*index*args-> ein_exp*params*args*code      (* rewriteOp:ein_exp*params*index*args-> ein_exp*params*args*code
133       * If e1 an op then call lift() to replace it       * If e1 an op then call lift() to replace it
      * Otherwise rewrite to 0 or it remains the same  
134       *)       *)
135      fun rewriteOp(name,e1,params,index,sx,args)=(case (isOp e1)      fun rewriteOp(name,e1,params,index,sx,args,fieldset,flag)=(case (isOp e1)
136          of  0   => (E.Const 0,params,args,[])          of  0   => (E.Const 0,params,args,[],fieldset)
137          | 2     => (e1,params,args,[])          | 1     => lift(name,e1,params,index,sx,args,fieldset,flag)
138          | _     => lift(name,e1,params,index,sx,args)          | 2     => (e1,params,args,[],fieldset)             (*not lifted*)
139          (*end*))          (*end*))
140    
141      (* rewriteOps:ein_exp list*params*index*sum_id list*mid-il vars  
142             -> ein_exp list*params*args*code  
143       * calls rewriteOp on ein_exp list  
144       *)      fun rewriteOps(name,list1,params,index,sx,args,fieldset0,flag)=let
145      fun rewriteOps(name,list1,params,index,sx,args)=let          fun m([],rest,params,args,code,fieldset)=(rest,params,args,code,fieldset)
146          fun m([],rest,params,args,code)=(rest,params,args,code)          | m(e1::es,rest,params,args,code,fieldset)=let
147          | m(e1::es,rest,params,args,code)=let  
148              val (e1',params',args',code')= rewriteOp(name,e1,params,index,sx,args)              val (e1',params',args',code',fieldset)= rewriteOp(name,e1,params,index,sx,args,fieldset,flag)
149              in              in
150                  m(es,rest@[e1'],params',args',code@code')                  m(es,rest@[e1'],params',args',code@code',fieldset)
151              end              end
152          in          in
153              m(list1,[],params,args,[])                  m(list1,[],params,args,[],fieldset0)
154          end          end
155    
156    
157      (*rewriteOrig: var* ein_exp* params*index list*mid-il vars      (*rewriteOrig: var* ein_exp* params*index list*mid-il vars
158             When the operation is zero then we return a real.             When the operation is zero then we return a real.
159          -Moved is Zero to before split.          -Moved is Zero to before split.
160      *)      *)
161      fun rewriteOrig(y,body,params,index,sx,args) =(case (isZero body)      fun rewriteOrig(y,body,params,index,sx,args) =cleanParams(y,body,params,index,args)
162          of 1=>  setEinZero y  
163          | _ => cleanParams(y,body,params,index,args)      fun rewriteOrig3(sx,body,params,args,x) =let
164          (*end case*))          val ((y,DstIL.EINAPP(ein,_)),_,_)=x
165            val index=Ein.index ein
166            in  cleanParams(y,body,params,index,args)
167            end
168    
169      (* handleNeg:var*ein_exp *params*index*args-> (var*einap)*code      (* handleNeg:var*ein_exp *params*index*args-> (var*einap)*code
170      * calls rewriteOp() lift  on ein_exp      * calls rewriteOp() lift  on ein_exp
171      *)      *)
172      fun handleNeg(y,e1,params,index,args)=let      fun handleNeg(e1,x)=let
173          val (e1',params',args',code)=  rewriteOp(DstV.name y, e1,params,index,[],args)          val (e1',params',args',code,fieldset)=  rewriteOp3("neg",[],e1,x)
174          val body =E.Neg e1'          val body' =E.Neg e1'
175            val einapp= rewriteOrig3([],body',params',args',x)
176            in
177                (einapp,code,fieldset)
178            end
179    
180        (* handleSqrt:var*ein_exp *params*index*args-> (var*einap)*code
181        * calls rewriteOp() lift  on ein_exp
182        *)
183        fun handleSqrt(y,e1,params,index,args,fieldset,flag)=let
184            val (e1',params',args',code,fieldset)=  rewriteOp("sqrt", e1,params,index,[],args,fieldset,flag)
185            val body =E.Sqrt e1'
186            val einapp= rewriteOrig(y,body,params',index,[],args')
187        in
188            (einapp,code,fieldset)
189        end
190    
191    
192        (* handleCosine:var*ein_exp *params*index*args-> (var*einap)*code
193        * calls rewriteOp() lift  on ein_exp
194        *)
195        fun handleCosine(y,e1,params,index,args,fieldset,flag)=let
196            val (e1',params',args',code,fieldset)=  rewriteOp("cosine", e1,params,index,[],args,fieldset,flag)
197            val body =E.Cosine e1'
198            val einapp= rewriteOrig(y,body,params',index,[],args')
199            in
200                (einapp,code,fieldset)
201        end
202    
203        (* handleArcCosine:var*ein_exp *params*index*args-> (var*einap)*code
204        * calls rewriteOp() lift  on ein_exp
205        *)
206        fun handleArcCosine(y,e1,params,index,args,fieldset,flag)=let
207            val (e1',params',args',code,fieldset)=  rewriteOp("ArcCosine", e1,params,index,[],args,fieldset,flag)
208            val body =E.ArcCosine e1'
209            val einapp= rewriteOrig(y,body,params',index,[],args')
210            in
211                (einapp,code,fieldset)
212        end
213    
214        (* handleSine:var*ein_exp *params*index*args-> (var*einap)*code
215        * calls rewriteOp() lift  on ein_exp
216        *)
217        fun handleSine(y,e1,params,index,args,fieldset,flag)=let
218            val (e1',params',args',code,fieldset)=  rewriteOp("sine", e1,params,index,[],args,fieldset,flag)
219            val body =E.Sine e1'
220          val einapp= rewriteOrig(y,body,params',index,[],args')          val einapp= rewriteOrig(y,body,params',index,[],args')
221          in          in
222              (einapp,code)              (einapp,code,fieldset)
223          end          end
224    
225        (* handleSine:var*ein_exp *params*index*args-> (var*einap)*code
226        * calls rewriteOp() lift  on ein_exp
227        *)
228        fun handleArcSine(y,e1,params,index,args,fieldset,flag)=let
229            val (e1',params',args',code,fieldset)=  rewriteOp("ArcSine", e1,params,index,[],args,fieldset,flag)
230            val body =E.ArcSine e1'
231            val einapp= rewriteOrig(y,body,params',index,[],args')
232            in
233                (einapp,code,fieldset)
234            end
235    
236    
237     (* handleSub:var*ein_exp*ein_exp *params*index*args-> (var*einap)*code     (* handleSub:var*ein_exp*ein_exp *params*index*args-> (var*einap)*code
238      * calls rewriteOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
239      *)      *)
240      fun handleSub(y,e1,e2,params,index,args)=let      fun handleSub(y,e1,e2,params,index,args,fieldset,flag)=let
241          val ([e1',e2'],params',args',code)=  rewriteOps(DstV.name y,[e1,e2],params,index,[],args)          val ([e1',e2'],params',args',code,fieldset)=  rewriteOps("subt",[e1,e2],params,index,[],args,fieldset,flag)
242          val body =E.Sub(e1',e2')          val body =E.Sub(e1',e2')
243          val einapp= rewriteOrig(y,body,params',index,[],args')          val einapp= rewriteOrig(y,body,params',index,[],args')
244          in          in
245              (einapp,code)              (einapp,code,fieldset)
246          end          end
247    
248      (* handleDiv:var*ein_exp *ein_exp*params*index*args-> (var*einap)*code      (* handleDiv:var*ein_exp *ein_exp*params*index*args-> (var*einap)*code
249      * calls rewriteOp() lift  on ein_exp      * calls rewriteOp() lift  on ein_exp
250      *)      *)
251      fun handleDiv(y,e1,e2,params,index,args)=let      fun handleDiv(y,e1,e2,params,index,args,fieldset,flag)=let
252          val (e1',params1',args1',code1')=rewriteOp(DstV.name y,e1,params,index,[],args)          val (e1',params1',args1',code1',fieldset)=rewriteOp("div-num",e1,params,index,[],args,fieldset,flag)
253          val (e2',params2',args2',code2')=rewriteOp(DstV.name y,e2,params1',[],[],args1')          val (e2',params2',args2',code2',fieldset)=rewriteOp("div-denom",e2,params1',index,[],args1',fieldset,flag)
254          val body =E.Div(e1',e2')          val body =E.Div(e1',e2')
255          val einapp= rewriteOrig(y,body,params2',index,[],args2')          val einapp= rewriteOrig(y,body,params2',index,[],args2')
256          in          in
257                  (einapp,code1'@code2')                  (einapp,code1'@code2',fieldset)
258          end          end
259    
260      (* handleAdd:var*ein_exp list *params*index*args-> (var*einap)*code      (* handleAdd:var*ein_exp list *params*index*args-> (var*einap)*code
261      * calls rewriteOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
262      *)      *)
263      fun handleAdd(y,e1,params,index,args)=let  fun   handleAdd(y,e1 as [_,_,_,_],params,index,args,fieldset,flag)=let
264          val (e1',params',args',code)=  rewriteOps(DstV.name y,e1,params,index,[],args)  
265    val (e1',params',args',code,fieldset)=  rewriteOps("add",e1,params,index,[],args,fieldset,flag)
266    fun pb es=String.concatWith "\n\n\t-*-" (List.map P.printbody es)
267    (*)val _ =print("\n****Inside Add:"^Int.toString(length index)^"\n -"^ pb e1 ^"----- newbies\n-"^ pb e1')*)
268    
269          val body =E.Add e1'          val body =E.Add e1'
270          val einapp= rewriteOrig(y,body,params',index,[],args')          val einapp= rewriteOrig(y,body,params',index,[],args')
271          in          in
272              (einapp,code)  (einapp,code,fieldset)
273    end
274        | handleAdd(y,e1,params,index,args,fieldset,flag)=let
275    
276            val (e1',params',args',code,fieldset)=  rewriteOps("add",e1,params,index,[],args,fieldset,flag)
277            fun pb es=String.concatWith "\n-" (List.map P.printbody es)
278    
279    
280            val body =E.Add e1'
281            val einapp= rewriteOrig(y,body,params',index,[],args')
282            in
283                (einapp,code,fieldset)
284          end          end
285    
286      (* handleProd:var*ein_exp list*params*index*args-> (var*einap)*code      (* handleProd:var*ein_exp list*params*index*args-> (var*einap)*code
287       * calls rewriteOps() lift  on ein_exp       * calls rewriteOps() lift  on ein_exp
288       *)       *)
289      fun handleProd(y,e1,params,index,args)=let      fun handleProd(y,e1,params,index,args,fieldset,flag)=let
290          val (e1',params',args',code)=  rewriteOps(DstV.name y,e1,params,index,[],args)          val (e1',params',args',code,fieldset)=  rewriteOps("prod",e1,params,index,[],args,fieldset,flag)
291          val body =E.Prod e1'          val body =E.Prod e1'
292          val einapp= rewriteOrig(y,body,params',index,[],args')          val einapp= rewriteOrig(y,body,params',index,[],args')
293          in          in
294              (einapp,code)              (einapp,code,fieldset)
295          end          end
296    
297     (* handleSumProd:var*ein_exp *params*index*args-> (var*einap)*code     (* handleSumProd:var*ein_exp *params*index*args-> (var*einap)*code
298      * calls rewriteOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
299      *)      *)
300      fun handleSumProd(y,e1,params,index,sx,args)=let      fun handleSumProd(y,e1,params,index,sx,args,fieldset,flag)=let
301          val (e1',params',args',code)=  rewriteOps(DstV.name y,e1,params,index,sx,args)          val (e1',params',args',code,fieldset)=  rewriteOps("sumprod",e1,params,index,sx,args,fieldset,flag)
302          val body= E.Sum(sx,E.Prod e1')          val body= E.Sum(sx,E.Prod e1')
303          val einapp= rewriteOrig(y,body,params',index,sx,args')          val einapp= rewriteOrig(y,body,params',index,sx,args')
304          in          in
305              (einapp,code)              (einapp,code,fieldset)
306          end          end
307    
308      (* split:var*ein_app-> (var*einap)*code      (* split:var*ein_app-> (var*einap)*code
309      * split ein expression into smaller pieces      * split ein expression into smaller pieces
310        note we leave summation around probe exp        note we leave summation around probe exp
311      *)      *)
312      fun split(y,einapp as DstIL.EINAPP(Ein.EIN{params, index, body},args))=let      fun split((y,einapp as DstIL.EINAPP(Ein.EIN{params, index, body},args)),fieldset,flag) =let
313          val zero=   (setEinZero y,[])          val x= ((y,einapp),fieldset,flag)
314          val default=((y,einapp),[])          val zero=   (setEinZero y,[],fieldset)
315            val default=((y,einapp),[],fieldset)
316          val sumIndex=ref []          val sumIndex=ref []
317            val str="Poorly formed EIN operator. Argument needs to be applied in High-IL"^(P.printbody body)
318            val _=testp["\n\nStarting split",P.printbody body]
319          fun rewrite b=(case b          fun rewrite b=(case b
320              of E.Probe _              => default              of E.Probe(E.Conv _,_)   => default
321              | E.Conv _                => zero              | E.Probe(E.Field _,_)    => raise Fail str
322              | E.Field _               => zero              | E.Probe _               => raise Fail str
323              | E.Apply _               => zero              | E.Conv _                => raise Fail "should have been swept"
324              | E.Lift e                => zero              | E.Field _               => raise Fail "should have been swept"
325                | E.Apply _               => raise Fail "should have been swept"
326                | E.Lift e                => raise Fail "should have been swept"
327              | E.Delta _               => default              | E.Delta _               => default
328              | E.Epsilon _             => default              | E.Epsilon _             => default
329              | E.Eps2 _                => default              | E.Eps2 _                => default
330              | E.Tensor _              => default              | E.Tensor _              => default
331              | E.Const _               => default              | E.Const _               => default
332              | E.Neg e1                => handleNeg(y,e1,params,index,args)              | E.ConstR _              => default
333              | E.Sub (e1,e2)           => handleSub(y,e1,e2,params,index,args)              | E.Neg e1                => handleNeg(e1,x)
334              | E.Div (e1,e2)           => handleDiv(y,e1,e2,params,index,args)              | E.Sqrt e1               => handleSqrt(y,e1,params,index,args,fieldset,flag)
335              | E.Sum(_,E.Prod[E.Eps2 _, E.Probe _ ])      => default              | E.Cosine e1             => handleCosine(y,e1,params,index,args,fieldset,flag)
336              | E.Sum(_,E.Prod[E.Epsilon _, E.Probe _ ])      => default              | E.ArcCosine e1          => handleArcCosine(y,e1,params,index,args,fieldset,flag)
337              | E.Sum(_,E.Probe _)      => default              | E.Sine e1               => handleSine(y,e1,params,index,args,fieldset,flag)
338              | E.Sum(_,E.Conv _)       => zero              | E.ArcSine e1            => handleArcSine(y,e1,params,index,args,fieldset,flag)
339              | E.Sum(sx,E.Prod e1)     => handleSumProd(y,e1,params,index,sx,args)              | E.PowInt e1             => err(" PowInt unsupported")
340              | E.Sum(sx,E.Neg n)       => rewrite (E.Neg(E.Sum(sx,n)))              | E.PowReal e1            => err(" PowReal unsupported")
341              | E.Sum(sx,E.Add a)       => rewrite (E.Add(List.map (fn e=> E.Sum(sx,e)) a))              | E.Sub (e1,e2)           => handleSub(y,e1,e2,params,index,args,fieldset,flag)
342              | E.Sum(sx,E.Sub (e1,e2)) => rewrite (E.Sub(E.Sum(sx,e1),E.Sum(sx,e2)))              | E.Div (e1,e2)           => handleDiv(y,e1,e2,params,index,args,fieldset,flag)
343              | E.Sum(sx,E.Div(e1,e2))  => rewrite(E.Div(E.Sum(sx,e1),E.Sum(sx,e2)))  (*
344              | E.Sum(c1, E.Sum (c2,e)) => rewrite (E.Sum (c1@c2,e))              | E.Sum(_,E.Prod[E.Eps2 _, E.Probe(E.Conv _,_)  ])      => default
345              | E.Sum(sx,_)             => default              | E.Sum(_,E.Prod[E.Epsilon _, E.Probe(E.Conv _,_)  ])      => default
346              | E.Add e1                => handleAdd(y,e1,params,index,args)  *)
347              | E.Prod e1               => handleProd(y,e1,params,index,args)              | E.Sum(_,E.Probe(E.Conv _,_))    => default
348                | E.Sum(sx,E.Prod e1)     => handleSumProd(y,e1,params,index,sx,args,fieldset,flag)
349                | E.Sum(sx,E.Delta d)     => handleSumProd(y,[E.Delta d],params,index,sx,args,fieldset,flag)
350                | E.Sum(sx,E.Tensor _)    => default
351                | E.Sum(sx,_)             => err(" summation not distributed:"^str)
352                | E.Add e1                => handleAdd(y,e1,params,index,args,fieldset,flag)
353                | E.Prod e1               => handleProd(y,e1,params,index,args,fieldset,flag)
354              | E.Partial _             => err(" Partial used after normalize")              | E.Partial _             => err(" Partial used after normalize")
355              | E.Krn _                 => err("Krn used before expand")              | E.Krn _                 => err("Krn used before expand")
356              | E.Value _               => err("Value used before expand")              | E.Value _               => err("Value used before expand")
357              | E.Img _                 => err("Probe used before expand")              | E.Img _                 => err("Probe used before expand")
358              (*end case *))              (*end case *))
359          val (einapp2,newbies) =rewrite body          val (einapp2,newbies,fieldset) =rewrite body
360          in          in
361              (einapp2,newbies)              ((einapp2,newbies),fieldset)
362          end          end
363          |split(y,app) =((y,app),[])          |split((y,app),fieldset,_) =(((y,app),[]),fieldset)
364    
365      (* iterMultiple:code*code=> (code*code)  
366       * recursively split ein expression into smaller pieces      fun iterMultiple(einapp2,newbies2,fieldset)=let
367      *)          fun itercode([],rest,code,_)=(rest,code)
368      fun iterMultiple(einapp2,newbies2)=let            | itercode(e1::newbies,rest,code,cnt)=let
369          fun itercode([],rest,code)=(rest,code)                  val ((einapp3,code3),_) = split(e1,fieldset,numFlag)
370          | itercode(e1::newbies,rest,code)=let                      val (rest4,code4)=itercode(code3,[],[],cnt+1)
371              val (einapp3,code3) =split(e1)          in
372              val (rest4,code4)=itercode(code3,[],[])              itercode(newbies,rest@[einapp3],code4@( rest4)@code,cnt+2)
             in itercode(newbies,rest@[einapp3],code4@rest4@code)  
373              end              end
374          val(rest,code)= itercode(newbies2,[],[])              val(rest,code)= itercode(newbies2,[],[],1)
375          in          in
376              (einapp2,code@rest)              ((code)@rest@[einapp2])
377          end          end
378    
379      fun iterSplit(y,einapp as DstIL.EINAPP(Ein.EIN{params, index, body},args))=let  
380          (*val (_,_,body')=cleanIndex(body,index,[])      fun iterAll(einapp2,fieldset)=let
381          val einapp1= assignEinApp(y,params,index,body',args)          fun itercode([],rest,code,_)=(rest,code)
382          *)          | itercode(e1::newbies,rest,code,cnt)=let
383          val (_,sizes,body')=cleanIndex(body,index,[])              val ((einapp3,code3),_) = split(e1,fieldset,numFlag)
384          val einapp1= assignEinApp(y,params,index,body',args)              val (rest4,code4)=itercode(code3,[],[],cnt+1)
385          val a=testp["\n rewriten einapp\n \t",printEINAPP einapp1]                  val _ =testp [printEINAPP(e1),"\n\t===>\n",printEINAPP(einapp3),"\nand\n",(String.concatWith",\n\t"(List.map printEINAPP (code4@rest4)))]
         val (einapp2,newbies2)=split einapp1  
386      in      in
387          iterMultiple(einapp2,newbies2)                  itercode(newbies,rest@[einapp3],code4@( rest4)@code,cnt+2)
388      end      end
389            val(rest,code)= itercode(einapp2,[],[],0)
390            in
391                (code@rest)
392            end
393    
394        fun splitEinApp einapp3= let
395            val fieldset= einSet.EinSet.empty
396    
397      (* gettest:code*code=> (code*code)          (* **** split in parts **** *)
398      * print results for splitting einapp          (*
399            val ((einapp4,newbies4),fieldset)=split(einapp3,fieldset,0)
400            val _ =testp["\n\t===>\n",printEINAPP(einapp4),"\nand\n",(String.concatWith",\n\t"(List.map printEINAPP newbies4))]
401            val (newbies5)= iterMultiple(einapp4,newbies4,fieldset)
402      *)      *)
403      fun gettest einapp=(case testing  
404          of 0=>iterSplit(einapp)          (* **** split all at once **** *)
405          | _=>let          val (newbies5)= iterAll([einapp3],fieldset)
406              val star="\n************* SPLIT********\n"  
             val _ =print(String.concat[star,"\n","start get test",printEINAPP einapp])  
             val (einapp2,newbies)=iterSplit(einapp)  
             val a=printEINAPP einapp2  
             val b=String.concatWith",\n\t"(List.map printEINAPP newbies)  
             val _ =print(String.concat[printEINAPP einapp,"=>",a," newbies\n\t",b, "\n",a,star])  
407              in              in
408                  (einapp2,newbies)              newbies5
409              end              end
410          (*end case*))  
411    
412    end; (* local *)    end; (* local *)
413    

Legend:
Removed from v.2845  
changed lines
  Added in v.3229

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