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

SCM Repository

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

Annotation of /branches/charisee_dev/src/compiler/high-to-mid/ProbeEin.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3327 - (view) (download)

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

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