Home My Page Projects Code Snippets Project Openings diderot

# SCM Repository

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

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

revision 2838, Tue Nov 25 03:40:24 2014 UTC revision 3167, Sun Mar 29 20:01:07 2015 UTC
# Line 4  Line 4
5   *)   *)
6
7     (*
8      During the transition from high-IL to mid-IL, complicated EIN expressions are split into simpler ones in order to better identify methods for code generation and common subexpressions. Combining EIN operators in the optimization phase can lead to large and complicated EIN operators. A general code generator would need to expand every operation to work on scalars, which could miss the opportunity for vectorization and lead to poor code generation. Instead, every EIN operator is split into a set of simple EIN operators.  Each EIN expression then only has one operation working on  constants, tensors, deltas, epsilons, images and kernels.
9
10     (1) When the outer EIN operator is $\in {--, +, -, *, /, \sum}$ then for each subexpression analyze to see if they need to be rewritten.
11
12     (1a.) When a subexpression is a field expression $\circledast,\nabla$ then it becomes 0. When it is another operation ${@ --, +, -, *, /, \sum}$ then we lift that subexpression and create a new EIN operator. We replace the subexpression with a tensor expression that represent it's size.
13
14     (1b) Call cleanIndex.sml to clean the indices in the subexpression, and get the shape for the tensor replacement.
15
16     (1c) Call cleanParams.sml to clean the params in the subexpression.\\
17     *)
18
19  structure Split = struct  structure Split = struct
20
21      local      local
22
23      structure E = Ein      structure E = Ein
structure mk= mkOperators
structure SrcIL = HighIL
structure SrcTy = HighILTypes
structure SrcOp = HighOps
structure SrcSV = SrcIL.StateVar
structure VTbl = SrcIL.Var.Tbl
24      structure DstIL = MidIL      structure DstIL = MidIL
25      structure DstTy = MidILTypes      structure DstTy = MidILTypes
structure DstOp = MidOps
26      structure DstV = DstIL.Var      structure DstV = DstIL.Var
structure SrcV = SrcIL.Var
27      structure P=Printer      structure P=Printer
structure F=Filter
structure T=TransformEin
structure Var = MidIL.Var
28      structure cleanP=cleanParams      structure cleanP=cleanParams
29      structure cleanI=cleanIndex      structure cleanI=cleanIndex
30
val testing=1
in
31
32        in
33
34        val numFlag=0   (*remove common subexpression*)
35        val testing=0
36      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}
37      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))
38      fun setEinZero(y,params,index,args)=  (y,DstIL.EINAPP(setEin(params,index,E.Const 0),args))      val einappzero=DstIL.EINAPP(setEin([],[],E.Const 0),[])
39        fun setEinZero y=  (y,einappzero)
40      fun cleanParams e =cleanP.cleanParams e      fun cleanParams e =cleanP.cleanParams e
41      fun cleanIndex e =cleanI.cleanIndex e      fun cleanIndex e =cleanI.cleanIndex e
42        fun printEINAPP e=MidToString.printEINAPP e
43      fun itos i =Int.toString i      fun itos i =Int.toString i
44        fun filterSca e=Filter.filterSca e
45      fun err str=raise Fail str      fun err str=raise Fail str
46      val cnt = ref 0      val cnt = ref 0
47        fun incUse (DstIL.V{useCnt, ...}) = (useCnt := !useCnt + 1)
48      fun genName prefix = let      fun genName prefix = let
49          val n = !cnt          val n = !cnt
50      in      in
# Line 53  Line 56
56          | _ =>(print(String.concat n);1)          | _ =>(print(String.concat n);1)
57          (*end case*))          (*end case*))
58
fun printEINAPP(id, DstIL.EINAPP(rator, args))=let
val a=String.concatWith " , " (List.map Var.toString args)
in
String.concat([(DstTy.toString (Var.ty id)),"<",Var.toString id,"> ==",P.printerE rator, a,"\n"])
end
| printEINAPP(id, DstIL.OP(rator, args))=let
val a=String.concatWith " , " (List.map Var.toString args)
in
String.concat([(DstTy.toString (Var.ty id)),"<",Var.toString id,"> =",DstOp.toString rator,a,"\n"])
end

| printEINAPP(id,_)= String.concat([Var.toString id,"<",(DstTy.toString (Var.ty id)),"> non-einapp\n"])

(* mkreplacement:params*index*index_list*int list* ein_exp-> ein_exp* params*args*code*
*creates new param and replacement tensor for the original ein_exp
*Then cleans params for suebxpression
*)
fun mkreplacement(params,args,tshape,sizes,body)=let
val id=length(params)
val params'=params@[E.TEN(1,sizes)]
val e'=E.Tensor(id,tshape)
val M  = DstV.new (genName ("TLifted_"^itos id), DstTy.TensorTy sizes)
val args'=args@[M]
val einapp=cleanParams(M,body,params',sizes,args')
in
(e',params',args',[einapp])
end

59      (* 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)
60      *lifts expression and returns replacement tensor      *lifts expression and returns replacement tensor
61      * cleans the index and params of subexpression      * cleans the index and params of subexpression
62        *creates new param and replacement tensor for the original ein_exp
63      *)      *)
64      fun lift(e,params,index,sx,args)=let      fun lift(name,e,params,index,sx,args,fieldset,flag)=let
65          val (tshape,sizes,body)=cleanIndex(e,index,sx)          val (tshape,sizes,body)=cleanIndex(e,index,sx)
66          val (Re,Rparams,Rargs,code)=mkreplacement(params,args,tshape,sizes,body)          val id=length(params)
67      in          val Rparams=params@[E.TEN(1,sizes)]
68          (Re,Rparams,Rargs,code)          val Re=E.Tensor(id,tshape)
69            val M  = DstV.new (genName (name^"_l_"^itos id), DstTy.TensorTy sizes)
70            val Rargs=args@[M]
71            val einapp=cleanParams(M,body,Rparams,sizes,Rargs)
72            val (_,einapp0)=einapp
73            val (Rargs,newbies,fieldset) =(case flag
74                of 1=> let
75                    val (fieldset,var) = einSet.rtnVar(fieldset,M,einapp0)
76                    in (case var
77                        of NONE=> (args@[M],[einapp],fieldset)
78                        | SOME v=> (incUse v ;(args@[v],[],fieldset))
79                        (*end case*))
80      end      end
81                | _=>(args@[M],[einapp],fieldset)
82      (* simplelift:ein_app*params*index*sum_id*args-> (ein_exp* params*args*code)                (*end case*))
*lifts expression and returns replacement tensor
* cleans params of subexpression
*)
fun simplelift(e,params,index,args)=(*let
val tshape=List.map (fn x => E.V x) index
val(Re,Rparams,Rargs,code)=mkreplacement(params,args,tshape,index,e)
83          in          in
84          (Re,Rparams,Rargs,code)              (Re,Rparams,Rargs,newbies,fieldset)
85          end          end
*)lift(e,params,index,[],args)

86
87
88      (* isOp: ein->int      (* isOp: ein->int
# Line 117  Line 95
95          | E.Apply _   => 0          | E.Apply _   => 0
96          | E.Lift _    => 0          | E.Lift _    => 0
97          | E.Neg _     => 1          | E.Neg _     => 1
98            | E.Sqrt _    => 1
99            | E.Cosine _      => 1
100            | E.ArcCosine _   => 1
101            | E.Sine _        => 1
102            | E.ArcSine _     => 1
103            | E.PowInt _      => 1
104            | E.PowReal _     => 1
106          | E.Sub _     => 1          | E.Sub _     => 1
107          | E.Prod _    => 1          | E.Prod _    => 1
# Line 131  Line 116
116      (*end case*))      (*end case*))
117
118
(* simpleOp:ein_exp*params*index*args-> ein_exp*params*args*code
* If e1 an op then call simplelift() to replace it
* Otherwise rewrite to 0 or it remains the same
*)
fun simpleOp(e1,params,index,args)=(case (isOp e1)
of  0   => (E.Const 0,params,args,[])
| 2     => (e1,params,args,[])
| _     => simplelift(e1,params,index,args)
(*end*))
119
120        fun rewriteOp3(name,sx,e1,x)=let
121            val ((y, DstIL.EINAPP(ein,args)),fieldset,flag)=x
122            val params=Ein.params ein
123            val index=Ein.index ein
124            in (case (isOp e1)
125                of  0   => (E.Const 0,params,args,[],fieldset)
126                | 1     => lift(name,e1,params,index,sx,args,fieldset,flag)
127                | 2     => (e1,params,args,[],fieldset)
128                (*end*))
129            end
130
131      (* simpleOps:ein_exp list*params*index*args-> ein_exp list*params*args*code      (* rewriteOp:ein_exp*params*index*args-> ein_exp*params*args*code
132       * calls simpleOp on ein_exp list      * If e1 an op then call lift() to replace it
133       *)       *)
134      fun simpleOps(list1,params,index,args)=let      fun rewriteOp(name,e1,params,index,sx,args,fieldset,flag)=(case (isOp e1)
135          fun m([],rest,params,args,code)=(rest,params,args,code)          of  0   => (E.Const 0,params,args,[],fieldset)
136          | m(e1::es,rest,params,args,code)=let          | 1     => lift(name,e1,params,index,sx,args,fieldset,flag)
137              val (e1',params',args',code')= simpleOp(e1,params,index,args)          | 2     => (e1,params,args,[],fieldset)             (*not lifted*)
138            (*end*))
139
140
141
142
143        fun rewriteOps(name,list1,params,index,sx,args,fieldset0,flag)=let
144            fun m([],rest,params,args,code,fieldset)=(rest,params,args,code,fieldset)
145            | m(e1::es,rest,params,args,code,fieldset)=let
146
147                val (e1',params',args',code',fieldset)= rewriteOp(name,e1,params,index,sx,args,fieldset,flag)
148              in              in
149                  m(es,rest@[e1'],params',args',code@code')                  m(es,rest@[e1'],params',args',code@code',fieldset)
150              end              end
151          in          in
152              m(list1,[],params,args,[])                  m(list1,[],params,args,[],fieldset0)
153          end          end
154
155      (* prodOps:ein_exp list*params*index*sum_id list*args-> ein_exp list*params*args*code
156       * calls lift  on ein_exp list      (*rewriteOrig: var* ein_exp* params*index list*mid-il vars
157               When the operation is zero then we return a real.
158            -Moved is Zero to before split.
159       *)       *)
160      fun prodOps(list1,params,index,sx,args)=let      fun rewriteOrig(y,body,params,index,sx,args) =cleanParams(y,body,params,index,args)
161          fun m([],rest,params,args,code)=(rest,params,args,code)
162          | m(e1::es,rest,params,args,code)=(case (isOp e1)      fun rewriteOrig3(sx,body,params,args,x) =let
163              of  0   => m(es,rest@[E.Const 0],params,args,code)          val ((y,DstIL.EINAPP(ein,_)),_,_)=x
164              | 2     => m(es,rest@[e1],params,args,code)          val index=Ein.index ein
165              | 1     => let          in  cleanParams(y,body,params,index,args)
166                  val (e1',params',args',code')= lift(e1,params,index,sx,args)          end
167
168        (* handleNeg:var*ein_exp *params*index*args-> (var*einap)*code
169        * calls rewriteOp() lift  on ein_exp
170        *)
171        fun handleNeg(e1,x)=let
172            val (e1',params',args',code,fieldset)=  rewriteOp3("neg",[],e1,x)
173            val body' =E.Neg e1'
174            val einapp= rewriteOrig3([],body',params',args',x)
175                  in                  in
176                      m(es,rest@[e1'],params',args',code@code')              (einapp,code,fieldset)
177                  end                  end
178              (*end case*))
179        (* handleSqrt:var*ein_exp *params*index*args-> (var*einap)*code
180        * calls rewriteOp() lift  on ein_exp
181        *)
182        fun handleSqrt(y,e1,params,index,args,fieldset,flag)=let
183            val (e1',params',args',code,fieldset)=  rewriteOp("sqrt", e1,params,index,[],args,fieldset,flag)
184            val body =E.Sqrt e1'
185            val einapp= rewriteOrig(y,body,params',index,[],args')
186          in          in
187              m(list1,[],params,args,[])          (einapp,code,fieldset)
188          end          end
189
190
191      fun isZero(y,body,params,index,args) =(case (cleanI.isZero body)      (* handleCosine:var*ein_exp *params*index*args-> (var*einap)*code
192          of 1=>  setEinZero(y,params,[],args)      * calls rewriteOp() lift  on ein_exp
193          | _ =>  cleanParams(y,body,params,index,args)      *)
194      (*end case*))      fun handleCosine(y,e1,params,index,args,fieldset,flag)=let
195            val (e1',params',args',code,fieldset)=  rewriteOp("cosine", e1,params,index,[],args,fieldset,flag)
196            val body =E.Cosine e1'
197            val einapp= rewriteOrig(y,body,params',index,[],args')
198            in
199                (einapp,code,fieldset)
200        end
201
202      (* handleNeg:var*ein_exp *params*index*args-> (var*einap)*code      (* handleArcCosine:var*ein_exp *params*index*args-> (var*einap)*code
203      * calls simpleOp() lift  on ein_exp      * calls rewriteOp() lift  on ein_exp
204      *)      *)
205      fun handleNeg(y,e1,params,index,args)=let      fun handleArcCosine(y,e1,params,index,args,fieldset,flag)=let
206          val (e1',params',args',code)=  simpleOp(e1,params,index,args)          val (e1',params',args',code,fieldset)=  rewriteOp("ArcCosine", e1,params,index,[],args,fieldset,flag)
207          val body =E.Neg e1'          val body =E.ArcCosine e1'
208          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
209      in      in
210          (einapp,code)              (einapp,code,fieldset)
211      end      end
212
213        (* handleSine:var*ein_exp *params*index*args-> (var*einap)*code
214        * calls rewriteOp() lift  on ein_exp
215        *)
216        fun handleSine(y,e1,params,index,args,fieldset,flag)=let
217            val (e1',params',args',code,fieldset)=  rewriteOp("sine", e1,params,index,[],args,fieldset,flag)
218            val body =E.Sine e1'
219            val einapp= rewriteOrig(y,body,params',index,[],args')
220            in
221                (einapp,code,fieldset)
222        end
223
224        (* handleSine:var*ein_exp *params*index*args-> (var*einap)*code
225        * calls rewriteOp() lift  on ein_exp
226        *)
227        fun handleArcSine(y,e1,params,index,args,fieldset,flag)=let
228            val (e1',params',args',code,fieldset)=  rewriteOp("ArcSine", e1,params,index,[],args,fieldset,flag)
229            val body =E.ArcSine e1'
230            val einapp= rewriteOrig(y,body,params',index,[],args')
231            in
232                (einapp,code,fieldset)
233            end
234
235
236     (* handleSub:var*ein_exp*ein_exp *params*index*args-> (var*einap)*code     (* handleSub:var*ein_exp*ein_exp *params*index*args-> (var*einap)*code
237      * calls simpleOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
238      *)      *)
239      fun handleSub(y,e1,e2,params,index,args)=let      fun handleSub(y,e1,e2,params,index,args,fieldset,flag)=let
240          val ([e1',e2'],params',args',code)=  simpleOps([e1,e2],params,index,args)          val ([e1',e2'],params',args',code,fieldset)=  rewriteOps("subt",[e1,e2],params,index,[],args,fieldset,flag)
241          val body =E.Sub(e1',e2')          val body =E.Sub(e1',e2')
242          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
243      in      in
244          (einapp,code)              (einapp,code,fieldset)
245      end      end
246
247      (* handleDiv:var*ein_exp *ein_exp*params*index*args-> (var*einap)*code      (* handleDiv:var*ein_exp *ein_exp*params*index*args-> (var*einap)*code
248      * calls simpleOp() lift  on ein_exp      * calls rewriteOp() lift  on ein_exp
249      *)      *)
250      fun handleDiv(y,e1,e2,params,index,args)=let      fun handleDiv(y,e1,e2,params,index,args,fieldset,flag)=let
251          val (e1',params1',args1',code1')=simpleOp(e1,params,index,args)          val (e1',params1',args1',code1',fieldset)=rewriteOp("div-num",e1,params,index,[],args,fieldset,flag)
252          val (e2',params2',args2',code2')=simpleOp(e2,params1',[],args1')          val (e2',params2',args2',code2',fieldset)=rewriteOp("div-denom",e2,params1',index,[],args1',fieldset,flag)
253          val body =E.Div(e1',e2')          val body =E.Div(e1',e2')
254          val einapp= isZero(y,body,params2',index,args2')          val einapp= rewriteOrig(y,body,params2',index,[],args2')
255      in      in
256              (einapp,code1'@code2')                  (einapp,code1'@code2',fieldset)
257      end      end
258

260      * calls simpleOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
261      *)      *)
263          val (e1',params',args',code)=  simpleOps(e1,params,index,args)
266          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
267      in      in
268          (einapp,code)              (einapp,code,fieldset)
269      end      end
270
271      (* handleProd:var*ein_exp list*params*index*args-> (var*einap)*code      (* handleProd:var*ein_exp list*params*index*args-> (var*einap)*code
272       * calls prodOps() lift  on ein_exp       * calls rewriteOps() lift  on ein_exp
273       *)       *)
274      fun handleProd(y,e1,params,index,args)=let      fun handleProd(y,e1,params,index,args,fieldset,flag)=let
275          val (e1',params',args',code)=  prodOps(e1,params,index,[],args)          val (e1',params',args',code,fieldset)=  rewriteOps("prod",e1,params,index,[],args,fieldset,flag)
276          val body =E.Prod e1'          val body =E.Prod e1'
277          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
278      in      in
279          (einapp,code)              (einapp,code,fieldset)
280      end      end
281
282     (* handleSumProd:var*ein_exp *params*index*args-> (var*einap)*code     (* handleSumProd:var*ein_exp *params*index*args-> (var*einap)*code
283      * calls prodOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
284      *)      *)
285      fun handleSumProd(y,e1,params,index,sx,args)=let      fun handleSumProd(y,e1,params,index,sx,args,fieldset,flag)=let
286          val _ =List.map (fn (_,_,ub)=> Int.toString ub) sx          val (e1',params',args',code,fieldset)=  rewriteOps("sumprod",e1,params,index,sx,args,fieldset,flag)
val (e1',params',args',code)=  prodOps(e1,params,index,sx,args)
287          val body= E.Sum(sx,E.Prod e1')          val body= E.Sum(sx,E.Prod e1')
288          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,sx,args')
289      in      in
290          (einapp,code)              (einapp,code,fieldset)
291      end      end
292
293      (* split:var*ein_app-> (var*einap)*code      (* split:var*ein_app-> (var*einap)*code
294      * split ein expression into smaller pieces      * split ein expression into smaller pieces
295          note we leave summation around probe exp
296      *)      *)
297      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
298          val zero=   (setEinZero(y,params,[],args),[])          val x= ((y,einapp),fieldset,flag)
299          val default=((y,einapp),[])          val zero=   (setEinZero y,[],fieldset)
300            val default=((y,einapp),[],fieldset)
301          val sumIndex=ref []          val sumIndex=ref []
302            val str="Poorly formed EIN operator. Argument needs to be applied in High-IL"^(P.printbody body)
303            val _=testp["\n\nStarting split",P.printbody body]
304          fun rewrite b=(case b          fun rewrite b=(case b
305              of E.Probe _              => default              of E.Probe (E.Conv _,_)   => default
306                | E.Probe(E.Field _,_)    => raise Fail str
307                | E.Probe _               => raise Fail str
308              | E.Conv _                => zero              | E.Conv _                => zero
309              | E.Field _               => zero              | E.Field _               => zero
310              | E.Apply _               => zero              | E.Apply _               => zero
311              | E.Lift e                => zero              | E.Lift e                => zero
312              | E.Delta _               => default              | E.Delta _               => default
313              | E.Epsilon _             => default              | E.Epsilon _             => default
314                | E.Eps2 _                => default
315              | E.Tensor _              => default              | E.Tensor _              => default
316              | E.Const _               => default              | E.Const _               => default
317              | E.Neg e1                => handleNeg(y,e1,params,index,args)              | E.ConstR _              => default
318              | E.Sub (e1,e2)           => handleSub(y,e1,e2,params,index,args)              | E.Neg e1                => handleNeg(e1,x)
319              | E.Div (e1,e2)           => handleDiv(y,e1,e2,params,index,args)              | E.Sqrt e1               => handleSqrt(y,e1,params,index,args,fieldset,flag)
320              | E.Sum(_,E.Probe _)      => default              | E.Cosine e1             => handleCosine(y,e1,params,index,args,fieldset,flag)
321              | E.Sum(_,E.Conv _)       => zero              | E.ArcCosine e1          => handleArcCosine(y,e1,params,index,args,fieldset,flag)
322              | E.Sum(sx,E.Prod e1)     => handleSumProd(y,e1,params,index,sx,args)              | E.Sine e1               => handleSine(y,e1,params,index,args,fieldset,flag)
323              | E.Sum(sx,E.Neg n)       => rewrite (E.Neg(E.Sum(sx,n)))              | E.ArcSine e1            => handleArcSine(y,e1,params,index,args,fieldset,flag)
324              | E.Sum(sx,E.Add a)       => rewrite (E.Add(List.map (fn e=> E.Sum(sx,e)) a))              | E.PowInt e1             => err(" PowInt unsupported")
325              | E.Sum(sx,E.Sub (e1,e2)) => rewrite (E.Sub(E.Sum(sx,e1),E.Sum(sx,e2)))              | E.PowReal e1            => err(" PowReal unsupported")
326              | E.Sum(sx,E.Div(e1,e2))  => rewrite(E.Div(E.Sum(sx,e1),E.Sum(sx,e2)))              | E.Sub (e1,e2)           => handleSub(y,e1,e2,params,index,args,fieldset,flag)
327              | E.Sum(c1, E.Sum (c2,e)) => rewrite (E.Sum (c1@c2,e))              | E.Div (e1,e2)           => handleDiv(y,e1,e2,params,index,args,fieldset,flag)
328              | E.Sum(sx,_)             => default              | E.Sum(_,E.Prod[E.Eps2 _, E.Probe(E.Conv _,_)  ])      => default
329              | E.Add e1                => handleAdd(y,e1,params,index,args)              | E.Sum(_,E.Prod[E.Epsilon _, E.Probe(E.Conv _,_)  ])      => default
330              | E.Prod e1               => handleProd(y,e1,params,index,args)              | E.Sum(_,E.Probe(E.Conv _,_))    => default
331                | E.Sum(sx,E.Prod e1)     => handleSumProd(y,e1,params,index,sx,args,fieldset,flag)
332                | E.Sum(sx,E.Delta d)     => handleSumProd(y,[E.Delta d],params,index,sx,args,fieldset,flag)
333                | E.Sum(sx,_)             => err(" summation not distributed:"^str)
335                | E.Prod e1               => handleProd(y,e1,params,index,args,fieldset,flag)
336              | E.Partial _             => err(" Partial used after normalize")              | E.Partial _             => err(" Partial used after normalize")
337              | E.Krn _                 => err("Krn used before expand")              | E.Krn _                 => err("Krn used before expand")
338              | E.Value _               => err("Value used before expand")              | E.Value _               => err("Value used before expand")
339              | E.Img _                 => err("Probe used before expand")              | E.Img _                 => err("Probe used before expand")
340              (*end case *))              (*end case *))
341            val (einapp2,newbies,fieldset) =rewrite body
val (einapp2,newbies) =rewrite body
342          in          in
343              (einapp2,newbies)              ((einapp2,newbies),fieldset)
344          end          end
345          |split(y,app) =((y,app),[])          |split((y,app),fieldset,_) =(((y,app),[]),fieldset)
346
347
348      (* iterMultiple:code*code=> (code*code)      fun iterMultiple(einapp2,newbies2,fieldset)=let
349       * recursively split ein expression into smaller pieces          fun itercode([],rest,code,_)=(rest,code)
350      *)            | itercode(e1::newbies,rest,code,cnt)=let
351      fun iterMultiple(einapp2,newbies2)=let                  val ((einapp3,code3),_) = split(e1,fieldset,numFlag)
352          fun itercode([],rest,code)=(rest,code)                      val (rest4,code4)=itercode(code3,[],[],cnt+1)
353          | itercode(e1::newbies,rest,code)=let          in
354              val (einapp3,code3) =split(e1)              itercode(newbies,rest@[einapp3],code4@( rest4)@code,cnt+2)
val (rest4,code4)=itercode(code3,[],[])
in itercode(newbies,rest@[einapp3],code4@rest4@code)
355              end              end
356          val(rest,code)= itercode(newbies2,[],[])              val(rest,code)= itercode(newbies2,[],[],1)
357          in          in
358              (einapp2,code@rest)              ((code)@rest@[einapp2])
359          end          end
360
361
362      fun iterSplit(y,einapp)=let      fun iterAll(einapp2,fieldset)=let
363          val (einapp2,newbies2)=split(y,einapp)          fun itercode([],rest,code,_)=(rest,code)
364            | itercode(e1::newbies,rest,code,cnt)=let
365                val ((einapp3,code3),_) = split(e1,fieldset,numFlag)
366                val (rest4,code4)=itercode(code3,[],[],cnt+1)
367      in      in
368          iterMultiple(einapp2,newbies2)                  itercode(newbies,rest@[einapp3],code4@( rest4)@code,cnt+2)
369                end
370            val(rest,code)= itercode(einapp2,[],[],0)
371            in
372                (code@rest)
373      end      end
374
375        fun splitEinApp einapp3= let
376            val fieldset= einSet.EinSet.empty
377
378            (* **** split in parts **** *)
379      (* gettest:code*code=> (code*code)          (*
380      * print results for splitting einapp          val ((einapp4,newbies4),fieldset)=split(einapp3,fieldset,0)
381            val _ =testp["\n\t===>\n",printEINAPP(einapp4),"\nand\n",(String.concatWith",\n\t"(List.map printEINAPP newbies4))]
382            val (newbies5)= iterMultiple(einapp4,newbies4,fieldset)
383      *)      *)
384      fun gettest(einapp)=(case testing
385          of 0=>iterSplit(einapp)          (* **** split all at once **** *)
386          | _=>let          val (newbies5)= iterAll([einapp3],fieldset)
387              val star="\n*************\n"
val _ =print(String.concat[star])
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])
388              in              in
389                  (einapp2,newbies)              newbies5
390              end              end
(*end case*))
391
392
393    end; (* local *)    end; (* local *)

Legend:
 Removed from v.2838 changed lines Added in v.3167