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

SCM Repository

[diderot] Annotation of /branches/vis15/src/compiler/high-to-mid/probe-ein.sml
ViewVC logotype

Annotation of /branches/vis15/src/compiler/high-to-mid/probe-ein.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3550 - (view) (download)

1 : jhr 3550 (* probe-ein.sml
2 :     *
3 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     *
5 :     * COPYRIGHT (c) 2016 The University of Chicago
6 :     * All rights reserved.
7 :     *)
8 :    
9 :     structure ProbeEin : sig
10 :    
11 :     end = struct
12 :    
13 :     structure E = Ein
14 :     structure DstIL = MidIL
15 :     structure DstOp = MidOps
16 :     structure T = TransformEin
17 :     structure MidToS = MidToString
18 :     structure DstV = DstIL.Var
19 :     structure DstTy = MidILTypes
20 :    
21 :     (* This file expands probed fields
22 :     * Take a look at ProbeEin tex file for examples
23 :     * Note that the original field is an EIN operator in the form <V_alpha * H^(deltas)>(midIL.var list )
24 :     * Param_ids are used to note the placement of the argument in the midIL.var list
25 :     * Index_ids keep track of the shape of an Image or differentiation.
26 :     * Mu bind Index_id
27 :     * Generally, we will refer to the following
28 :     * dim:dimension of field V
29 :     * s: support of kernel H
30 :     * alpha: The alpha in <V_alpha * H^(deltas)>
31 :     * deltas: The deltas in <V_alpha * H^(deltas)>
32 :     * Vid:param_id for V
33 :     * hid:param_id for H
34 :     * nid: integer position param_id
35 :     * fid :fractional position param_id
36 :     * img-imginfo about V
37 :     *)
38 :    
39 :     (* FIXME: what are these for? should they be settable from the command-line? *)
40 :     val valnumflag = true
41 :     val tsplitvar = true
42 :     val fieldliftflag = true
43 :     val constflag = false
44 :     val detflag = true
45 :    
46 :     fun transformToIndexSpace e=T.transformToIndexSpace e
47 :     fun transformToImgSpace e=T.transformToImgSpace e
48 :     fun toStringBind e=(MidToString.toStringBind e)
49 :     fun mkEin e=Ein.mkEin e
50 :     fun mkEinApp(rator,args)=DstIL.EINAPP(rator,args)
51 :     fun setConst e = E.setConst e
52 :     fun setNeg e = E.setNeg e
53 :     fun setExp e = E.setExp e
54 :     fun setDiv e= E.setDiv e
55 :     fun setSub e= E.setSub e
56 :     fun setProd e= E.setProd e
57 :     fun setAdd e= E.setAdd e
58 :    
59 :     fun getRHSDst x = (case DstIL.Var.binding x
60 :     of DstIL.VB_RHS(DstIL.OP(rator, args)) => (rator, args)
61 :     | DstIL.VB_RHS(DstIL.VAR x') => getRHSDst x'
62 :     | vb => raise Fail(concat[
63 :     "expected rhs operator for ", DstIL.Var.toString x,
64 :     " but found ", DstIL.vbToString vb
65 :     ])
66 :     (* end case *))
67 :    
68 :    
69 :     (* getArgsDst:MidIL.Var* MidIL.Var->int, ImageInfo, int
70 :     uses the Param_ids for the image, kernel,
71 :     and position tensor to get the Mid-IL arguments
72 :     returns the support of ther kernel, and image
73 :     *)
74 :     fun getArgsDst (hArg, imgArg, args) = (case (getRHSDst hArg, getRHSDst imgArg)
75 :     of ((DstOp.Kernel(h, i), _ ), (DstOp.LoadImage(_, _, img), _ )) =>
76 :     (Kernel.support h, img, ImageInfo.dim img)
77 :     | ((k,_), (i,_)) => raise Fail (String.concat[
78 :     "Expected kernel: ", DstOp.toString k, ", Expected Image: ", DstOp.toString i
79 :     ])
80 :     (* end case *))
81 :    
82 :    
83 :     (*handleArgs():int*int*int*Mid IL.Var list
84 :     ->int*Mid.ILVars list* code*int* low-il-var
85 :     * uses the Param_ids for the image, kernel, and tensor
86 :     * and gets the mid-IL vars for each.
87 :     *Transforms the position to index space
88 :     *P is the mid-il var for the (transformation matrix)transpose
89 :     *)
90 :     fun handleArgs(Vid,hid,tid,args)=let
91 :     val imgArg=List.nth(args,Vid)
92 :     val hArg=List.nth(args,hid)
93 :     val newposArg=List.nth(args,tid)
94 :     val (s,img,dim) =getArgsDst(hArg,imgArg,args)
95 :     val (argsT,P,code)=transformToImgSpace(dim,img,newposArg,imgArg)
96 :     in
97 :     (dim,args@argsT,code, s,P)
98 :     end
99 :    
100 :     (*createBody:int*int*int,mu list, param_id, param_id, param_id, param_id
101 :     * expands the body for the probed field
102 :     *)
103 :     fun createBody(dim, s,sx,alpha,deltas,Vid, hid, nid, fid)=let
104 :     (*1-d fields*)
105 :     fun createKRND1 ()=let
106 :     val sum=sx
107 :     val dels=List.map (fn e=>(E.C 0,e)) deltas
108 :     val pos=[setAdd[E.Tensor(fid,[]),E.Value(sum)]]
109 :     val rest= E.Krn(hid,dels,setSub(E.Tensor(nid,[]),E.Value(sum)))
110 :     in
111 :     setProd[E.Img(Vid,alpha,pos),rest]
112 :     end
113 :     (*createKRN Image field and kernels *)
114 :     fun createKRN(0,imgpos,rest)=setProd ([E.Img(Vid,alpha,imgpos)] @rest)
115 :     | createKRN(dim,imgpos,rest)=let
116 :     val dim'=dim-1
117 :     val sum=sx+dim'
118 :     val dels=List.map (fn e=>(E.C dim',e)) deltas
119 :     val pos=[setAdd[E.Tensor(fid,[E.C dim']),E.Value(sum)]]
120 :     val rest'= E.Krn(hid,dels,setSub(E.Tensor(nid,[E.C dim']),E.Value(sum)))
121 :     in
122 :     createKRN(dim',pos@imgpos,[rest']@rest)
123 :     end
124 :     val exp=(case dim
125 :     of 1 => createKRND1()
126 :     | _=> createKRN(dim, [],[])
127 :     (* end case *))
128 :     (*sumIndex creating summaiton Index for body*)
129 :     val slb=1-s
130 :     val _=List.tabulate(dim, (fn dim=> (String.concat[" sx:",Int.toString(sx)," dim:",Int.toString(dim),"esum",Int.toString(sx+dim) ]) ))
131 :     val esum=List.tabulate(dim, (fn dim=>(E.V (dim+sx),slb,s)))
132 :     in
133 :     E.Sum(esum, exp)
134 :     end
135 :    
136 :     (*getsumshift:sum_indexid list* int list-> int
137 :     *get fresh/unused index_id, returns int
138 :     *)
139 :     fun getsumshift(sx,n) =let
140 :     val nsumshift= (case sx
141 :     of []=> n
142 :     | _=>let
143 :     val (E.V v,_,_)=List.hd(List.rev sx)
144 :     in v+1
145 :     end
146 :     (* end case *))
147 :    
148 :     val aa=List.map (fn (E.V v,_,_)=>Int.toString v) sx
149 :     val _ =(String.concat["\n", "SumIndex:" ,(String.concatWith"," aa),
150 :     "\n\t Index length:",Int.toString n,
151 :     "\n\t Freshindex: ", Int.toString nsumshift])
152 :     in
153 :     nsumshift
154 :     end
155 :    
156 :     (*formBody:ein_exp->ein_exp
157 :     *just does a quick rewrite
158 :     *)
159 :     fun formBody(E.Sum([],e))=formBody e
160 :     | formBody(E.Sum(sx,e))= E.Sum(sx,formBody e)
161 :     | formBody(E.Opn(E.Prod, [e]))=e
162 :     | formBody e=e
163 :    
164 :     (* silly change in order of the product to match vis branch WorldtoSpace functions*)
165 :     fun multiPs([P0,P1,P2],sx,body)= formBody(E.Sum(sx, setProd[P0,P1,P2,body]))
166 :     (*
167 :     | multiPs([P0,P1],sx,body)=formBody(E.Sum(sx, setProd([P0,body,P1])))
168 :     *)
169 :     | multiPs([P0,P1,P2,P3],sx,body)= formBody(E.Sum(sx, setProd[P0,P1,P2,P3,body]))
170 :     | multiPs(Ps,sx,body)=formBody(E.Sum(sx,setProd([body]@Ps)))
171 :    
172 :    
173 :     fun multiMergePs([P0,P1],[sx0,sx1],body)=E.Sum([sx0],setProd[P0,E.Sum([sx1],setProd[P1,body])])
174 :     | multiMergePs e=multiPs e
175 :    
176 :    
177 :     (* replaceProbe:ein_exp* params *midIL.var list * int list* sum_id list
178 :     -> ein_exp* *code
179 :     * Transforms position to world space
180 :     * transforms result back to index_space
181 :     * rewrites body
182 :     * replace probe with expanded version
183 :     *)
184 :     (* fun replaceProbe(testN,y,originalb,b,params,args,index, sx)*)
185 :    
186 :     fun replaceProbe(testN,(y, DstIL.EINAPP(e,args)),p ,sx)
187 :     =let
188 :     val originalb=Ein.body e
189 :     val params=Ein.params e
190 :     val index=Ein.index e
191 :     val _ = testp["\n***************** \n Replace ************ \n"]
192 :     val _= toStringBind (y, DstIL.EINAPP(e,args))
193 :    
194 :     val E.Probe(E.Conv(Vid,alpha,hid,dx),E.Tensor(tid,_))=p
195 :     val fid=length(params)
196 :     val nid=fid+1
197 :     val Pid=nid+1
198 :     val nshift=length(dx)
199 :     val (dim,argsA,code,s,PArg) = handleArgs(Vid,hid,tid,args)
200 :     val freshIndex=getsumshift(sx,length(index))
201 :     val (dx,newsx1,Ps)=transformToIndexSpace(freshIndex,dim,dx,Pid)
202 :     val params'=params@[E.TEN(3,[dim]),E.TEN(1,[dim]),E.TEN(1,[dim,dim])]
203 :     val body' = createBody(dim, s,freshIndex+nshift,alpha,dx,Vid, hid, nid, fid)
204 :     val body' = multiPs(Ps,newsx1,body')
205 :    
206 :     val body'=(case originalb
207 :     of E.Sum(sx, E.Probe _) => E.Sum(sx,body')
208 :     | E.Sum(sx,E.Opn(E.Prod,[eps0,E.Probe _ ])) => E.Sum(sx,setProd[eps0,body'])
209 :     | _ => body'
210 :     (* end case *))
211 :    
212 :    
213 :     val args'=argsA@[PArg]
214 :     val einapp=(y,mkEinApp(mkEin(params',index,body'),args'))
215 :     in
216 :     code@[einapp]
217 :     end
218 :    
219 :    
220 :     fun createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)= let
221 :     val Pid=0
222 :     val tid=1
223 :    
224 :     (*Assumes body is already clean*)
225 :     val (newdx,newsx,Ps)=transformToIndexSpace(freshIndex,dim,dx,Pid)
226 :    
227 :     (*need to rewrite dx*)
228 :     val (_,sizes,e as E.Conv(_,alpha',_,dx))=(case sx@newsx
229 :     of []=> ([],index,E.Conv(9,alpha,7,newdx))
230 :     | _ => cleanIndex.cleanIndex(E.Conv(9,alpha,7,newdx),index,sx@newsx)
231 :     (* end case *))
232 :    
233 :     val params=[E.TEN(1,[dim,dim]),E.TEN(1,sizes)]
234 :     fun filterAlpha []=[]
235 :     | filterAlpha(E.C _::es)= filterAlpha es
236 :     | filterAlpha(e1::es)=[e1]@(filterAlpha es)
237 :    
238 :     val tshape=filterAlpha(alpha')@newdx
239 :     val t=E.Tensor(tid,tshape)
240 :    
241 :     val (splitvar,body)=(case originalb
242 :     of E.Sum(sx, E.Probe _) => (true,multiPs(Ps,sx@newsx,t))
243 :     | E.Sum(sx,E.Opn(E.Prod,[eps0,E.Probe _ ])) => (false,E.Sum(sx,setProd[eps0,multiPs(Ps,newsx,t)]))
244 :     | _ => (case tsplitvar
245 :     of(* true => (true,multiMergePs(Ps,newsx,t)) (*pushes summations in place*)
246 :     | false*) _ => (true,multiPs(Ps,newsx,t))
247 :     (* end case *))
248 :     (* end case *))
249 :    
250 :     val _ =(case splitvar
251 :     of true=> (String.concat["splitvar is true", P.printbody body])
252 :     | _ => (String.concat["splitvar is false",P.printbody body])
253 :     (* end case *))
254 :    
255 :    
256 :     val ein0=mkEin(params,index,body)
257 :     in
258 :     (splitvar,ein0,sizes,dx,alpha')
259 :     end
260 :    
261 :     fun liftProbe(printStrings,(y, DstIL.EINAPP(e,args)),p ,sx)=let
262 :     val _=testp["\n******* Lift Geneirc Probe ***\n"]
263 :     val originalb=Ein.body e
264 :     val params=Ein.params e
265 :     val index=Ein.index e
266 :     val _ = (toStringBind (y, DstIL.EINAPP(e,args)))
267 :    
268 :     val E.Probe(E.Conv(Vid,alpha,hid,dx),E.Tensor(tid,_))=p
269 :     val fid=length(params)
270 :     val nid=fid+1
271 :     val nshift=length(dx)
272 :     val (dim,args',code,s,PArg) = handleArgs(Vid,hid,tid,args)
273 :     val freshIndex=getsumshift(sx,length(index))
274 :    
275 :     (*transform T*P*P..Ps*)
276 :     val (splitvar,ein0,sizes,dx,alpha')= createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)
277 :    
278 :     val FArg = DstV.new ("F", DstTy.TensorTy(sizes))
279 :     val einApp0=mkEinApp(ein0,[PArg,FArg])
280 :     val rtn0=(case splitvar
281 :     of false => [(y,mkEinApp(ein0,[PArg,FArg]))]
282 :     | _ => let
283 :     val bind3 = (y,DstIL.EINAPP(SummationEin.main ein0,[PArg,FArg]))
284 :     in Split.splitEinApp bind3
285 :     end
286 :     (* end case *))
287 :    
288 :     (*lifted probe*)
289 :     val params'=params@[E.TEN(3,[dim]),E.TEN(1,[dim])]
290 :     val freshIndex'= length(sizes)
291 :    
292 :     val body' = createBody(dim, s,freshIndex',alpha',dx,Vid, hid, nid, fid)
293 :     val ein1=mkEin(params',sizes,body')
294 :     val einApp1=mkEinApp(ein1,args')
295 :     val rtn1=(FArg,einApp1)
296 :     val rtn=code@[rtn1]@rtn0
297 :     val _= List.map toStringBind ([rtn1]@rtn0)
298 :     val _=(String.concat["\n* end Lift Geneirc Probe ******** \n"])
299 :     in
300 :     rtn
301 :     end
302 :    
303 :     fun searchFullField (fieldset,code1,body1,dx)=let
304 :     val (lhs,_)=code1
305 :     fun continueReconstruction ()=let
306 :     val _=print"Tash:don't replaced"
307 :     in (case dx
308 :     of []=> (lhs,replaceProbe(1,code1,body1,[]))
309 :     | _ =>(lhs,liftProbe(1,code1,body1,[]))
310 :     (* end case *))
311 :     end
312 :     in (case valnumflag
313 :     of false => (fieldset,continueReconstruction())
314 :     | true => (case (einSet.rtnVarN(fieldset,code1))
315 :     of (fieldset,NONE) => (fieldset,continueReconstruction())
316 :     | (fieldset,SOME m) =>(print"TASH:replaced"; (fieldset,(m,[])))
317 :     (* end case *))
318 :     (* end case *))
319 :     end
320 :    
321 :     fun liftFieldMat(newvx,e)=
322 :     let
323 :     val _=testp[ "\n ***************************** start FieldMat\n"]
324 :     val (y, DstIL.EINAPP(ein,args))=e
325 :     val E.Probe(E.Conv(V,[c1,v0],h,dx),pos)=Ein.body ein
326 :     val index0=Ein.index ein
327 :     val index1 = index0@[3]
328 :     val body1_unshifted = E.Probe(E.Conv(V,[E.V newvx, v0],h,dx),pos)
329 :     (* clean to get body indices in order *)
330 :     val ( _ , _, body1)= cleanIndex.cleanIndex(body1_unshifted,index1,[])
331 :     val _ = testp ["\n Shifted ",P.printbody body1_unshifted,"=>",P.printbody body1]
332 :    
333 :     val lhs1=DstV.new ("L", DstTy.TensorTy(index1))
334 :     val ein1 = mkEin(Ein.params ein,index1,body1)
335 :     val code1= (lhs1,mkEinApp(ein1,args))
336 :     val codeAll= (case dx
337 :     of []=> replaceProbe(1,code1,body1,[])
338 :     | _ =>liftProbe(1,code1,body1,[])
339 :     (* end case *))
340 :    
341 :     (*Probe that tensor at a constant position c1*)
342 :     val param0 = [E.TEN(1,index1)]
343 :     val nx=List.tabulate(length(dx)+1,fn n=>E.V n)
344 :     val body0 = E.Tensor(0,[c1]@nx)
345 :     val ein0 = mkEin(param0,index0,body0)
346 :     val einApp0 = mkEinApp(ein0,[lhs1])
347 :     val code0 = (y,einApp0)
348 :     val _= toStringBind code0
349 :     val _=testp["\n end FieldMat *****************************\n "]
350 :     in
351 :     codeAll@[code0]
352 :     end
353 :    
354 :     fun liftFieldVec(newvx,e,fieldset)=
355 :     let
356 :     val _=testp[ "\n ***************************** start FieldVec\n"]
357 :     val (y, DstIL.EINAPP(ein,args))=e
358 :     val E.Probe(E.Conv(V,[c1],h,dx),pos)=Ein.body ein
359 :     val index0=Ein.index ein
360 :     val index1 = index0@[3]
361 :     val body1_unshifted = E.Probe(E.Conv(V,[E.V newvx],h,dx),pos)
362 :     (* clean to get body indices in order *)
363 :     val ( _ , _, body1)= cleanIndex.cleanIndex(body1_unshifted,index1,[])
364 :    
365 :    
366 :     val lhs1=DstV.new ("L", DstTy.TensorTy(index1))
367 :     val ein1 = mkEin(Ein.params ein,index1,body1)
368 :     val code1= (lhs1,mkEinApp(ein1,args))
369 :     val (fieldset,(lhs0,codeAll))=searchFullField (fieldset,code1,body1,dx)
370 :    
371 :     (*Probe that tensor at a constant position c1*)
372 :     val param0 = [E.TEN(1,index1)]
373 :     val nx=List.tabulate(length(dx),fn n=>E.V n)
374 :     val body0 = E.Tensor(0,[c1]@nx)
375 :     val ein0 = mkEin(param0,index0,body0)
376 :     val einApp0 = mkEinApp(ein0,[lhs0])
377 :     val code0 = (y,einApp0)
378 :    
379 :     val _ = testp ["\n Shifted ",P.printbody body1_unshifted,"=>",P.printbody body1]
380 :     val _ = (toStringBind code0)
381 :     val _ = testp[ "\n end FieldVec *****************************\n "]
382 :     in
383 :     codeAll@[code0]
384 :     end
385 :    
386 :    
387 :    
388 :     fun liftFieldSum e =
389 :     let
390 :     val _=testp[ "\n************************************* Start Lift Field Sum\n"]
391 :     val (y, DstIL.EINAPP(ein,args))=e
392 :     val E.Sum([(vsum,0,n)],E.Probe(E.Conv(V,[c1,v0],h,dx),pos))=Ein.body ein
393 :     val index0=Ein.index ein
394 :     val index1 = index0@[3]@[3]
395 :     val shiftdx=List.tabulate(length(dx),fn n=>E.V (n+2))
396 :     val body1 = E.Probe(E.Conv(V,[E.V 0,E.V 1],h,shiftdx),pos)
397 :    
398 :    
399 :     val lhs1=DstV.new ("L", DstTy.TensorTy(index1))
400 :     val ein1 = mkEin(Ein.params ein,index1,body1)
401 :     val code1= (lhs1,mkEinApp(ein1,args))
402 :     val codeAll= (case dx
403 :     of [] => replaceProbe(1,code1,body1,[])
404 :     | _ =>liftProbe(1,code1,body1,[])
405 :     (* end case *))
406 :    
407 :     (*Probe that tensor at a constant position c1*)
408 :     val param0 = [E.TEN(1,index1)]
409 :     val nx=List.tabulate(length(dx),fn n=>E.V n)
410 :     val body0 = E.Sum([(vsum,0,n)],E.Tensor(0,[vsum,vsum]@nx))
411 :     val ein0 = mkEin(param0,index0,body0)
412 :     val einApp0 = mkEinApp(ein0,[lhs1])
413 :     val code0 = (y,einApp0)
414 :     val _ = toStringBind e
415 :     val _ = toStringBind code0
416 :     val _ = (String.concat ["\norig",P.printbody(Ein.body ein),"\n replace i ",P.printbody body1,"\nfreshtensor",P.printbody body0])
417 :     val _ =((List.map toStringBind (codeAll@[code0])))
418 :     val _ = testp["\n*** end Field Sum*************************************\n"]
419 :     in
420 :     codeAll@[code0]
421 :     end
422 :    
423 :    
424 :     (* expandEinOp: code-> code list
425 :     * A this point we only have simple ein ops
426 :     * Looks to see if the expression has a probe. If so, replaces it.
427 :     * Note how we keeps eps expressions so only generate pieces that are used
428 :     *)
429 :     fun expandEinOp( e as (y, DstIL.EINAPP(ein,args)),fieldset)=let
430 :    
431 :     fun checkConst(es,a)=(case constflag
432 :     of true => liftProbe a
433 :     | _ => let
434 :     fun fConst ([],a) =
435 :     (case fieldliftflag
436 :     of true => liftProbe a
437 :     | _ => replaceProbe a
438 :     (* end case *))
439 :     | fConst ((E.C _::_),a) = replaceProbe a
440 :     | fConst ((_ ::es),a)= checkConst(es,a)
441 :     in fConst(es,a) end
442 :     (* end case*))
443 :     fun rewriteBodyB b=(case b
444 :     of (E.Probe(E.Conv(_,_,_,[]),_))
445 :     => replaceProbe(0,e,b,[])
446 :     | (E.Probe(E.Conv (_,alpha,_,dx),_))
447 :     => checkConst(dx,(0,e,b,[])) (*scans dx for contant*)
448 :     | (E.Sum(sx,p as E.Probe(E.Conv(_,_,_,[]),_)))
449 :     => replaceProbe(0,e,p, sx) (*no dx*)
450 :     | (E.Sum(sx,p as E.Probe(E.Conv(_,[],_,dx),_)))
451 :     => checkConst(dx,(0,e,p,sx)) (*scalar field*)
452 :     | (E.Sum(sx,E.Probe p))
453 :     => replaceProbe(0,e,E.Probe p, sx)
454 :     | (E.Sum(sx,E.Opn(E.Prod,[eps,E.Probe p])))
455 :     => replaceProbe(0,e,E.Probe p,sx)
456 :     | _ => [e]
457 :     (* end case *))
458 :     fun rewriteBody b=(case detflag
459 :     of true => (case b
460 :     of (E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[]),pos))
461 :     => liftFieldMat (1,e)
462 :     | (E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[E.V 1]),pos))
463 :     => liftFieldMat (2,e)
464 :     | (E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[E.V 1,E.V 2]),pos))
465 :     => liftFieldMat (3,e)
466 :     | _ => rewriteBodyB b
467 :     (* end case *))
468 :     | _ => rewriteBodyB b
469 :     (* end case *))
470 :     val (fieldset,var) = (case valnumflag
471 :     of true => einSet.rtnVar(fieldset,y,DstIL.EINAPP(ein,args))
472 :     | _ => (fieldset,NONE)
473 :     (* end case *))
474 :    
475 :     fun matchField b=(case b
476 :     of E.Probe _ => 1
477 :     | E.Sum (_, E.Probe _)=>1
478 :     | E.Sum(_, E.Opn(E.Prod,[ _ ,E.Probe _]))=>1
479 :     | _ =>0
480 :     (* end case *))
481 :     val b=Ein.body ein
482 :    
483 :     in (case var
484 :     of NONE=> ((rewriteBody(Ein.body ein),fieldset,matchField(Ein.body ein),0))
485 :     | SOME v=> (("\n mapp_replacing"^(P.printerE ein)^":");( [(y,DstIL.VAR v)],fieldset, matchField(Ein.body ein),1))
486 :     (* end case *))
487 :     end
488 :    
489 :     end (* ProbeEin *)

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