Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/src/compiler/Semant/modules/moduleutil.sml
ViewVC logotype

Annotation of /sml/trunk/src/compiler/Semant/modules/moduleutil.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 24 - (view) (download)
Original Path: sml/branches/SMLNJ/src/compiler/Semant/modules/moduleutil.sml

1 : monnier 16 (* COPYRIGHT (c) 1996 Bell Laboratories. *)
2 :     (* moduleutil.sml *)
3 :    
4 :     structure ModuleUtil : MODULEUTIL =
5 :     struct
6 :    
7 :     local structure S = Symbol
8 :     structure SP = SymPath
9 :     structure IP = InvPath
10 :     structure CVP = ConvertPaths
11 :     structure EP = EntPath
12 :     structure EPC = EntPathContext
13 :     structure A = Access
14 :     structure II = InlInfo
15 :     structure T = Types
16 :     structure TU = TypesUtil
17 :     structure V = VarCon
18 :     structure B = Bindings
19 :     structure EE = EntityEnv
20 :     structure ST = Stamps
21 :     structure M = Modules
22 :     structure MI = ModuleId
23 :     structure SE = StaticEnv
24 :     open Modules
25 :     in
26 :    
27 :     (* debugging hooks *)
28 :     val say = Control.Print.say
29 :     val debugging = Control.CG.mudebugging (* ref false *)
30 :     fun debugmsg (msg: string) =
31 :     if !debugging then (say msg; say "\n") else ()
32 :    
33 :     fun bug s = ErrorMsg.impossible ("ModuleUtil: " ^ s)
34 :    
35 :     (*
36 :     * Look up the entity corresponding to a given symbol in the `elements'
37 :     * of a signature and the corresponding `entities' from a structure
38 :     * realization. The (dynamic) access fields of structures and
39 :     * functors are adjusted before they are returned. The static accesses
40 :     * of types, structures, and functors are just returned.
41 :     *
42 :     * Used by the (structure and functor) matching functions.
43 :     *)
44 :    
45 :     exception Unbound of S.symbol
46 :    
47 :     fun getSpec (elements, sym) =
48 :     let fun h [] = (debugmsg("$getSpec "^S.name sym); raise (Unbound sym))
49 :     | h ((s, sp) :: elemr) = if S.eq(s, sym) then sp else h elemr
50 :     in h elements
51 :     end
52 :    
53 :     (*
54 :     * the following might be used to speedup the signature lookup process
55 :     *
56 :     * fun getSpec (elements, sym) =
57 :     * Env.look(elements,sym)
58 :     * handle Env.Unbound => raise (Unbound sym)
59 :     *
60 :     * we'll use more efficient represntations for elements in the future.
61 :     *)
62 :    
63 :     (*** return the entity variable of a particular spec ***)
64 :     fun getSpecVar (STRspec{entVar,...}) = SOME entVar
65 :     | getSpecVar (TYCspec{entVar,...}) = SOME entVar
66 :     | getSpecVar (FCTspec{entVar,...}) = SOME entVar
67 :     | getSpecVar _ = NONE
68 :    
69 :     (*** The function getTyc is used in modules/sigmatch.sml only ***)
70 :     fun getTyc (elements, entEnv, sym) =
71 :     case getSpec (elements, sym)
72 :     of TYCspec{entVar,...} => (EE.lookTycEnt(entEnv,entVar), entVar)
73 :     | _ => bug "getTyc: wrong spec"
74 :    
75 :     (*** The function getStr is used in modules/sigmatch.sml only ***)
76 :     fun getStr (elements, entEnv, sym, dacc, dinfo) =
77 :     case getSpec(elements, sym)
78 :     of STRspec{sign, slot, def, entVar} =>
79 :     (case EE.look(entEnv,entVar)
80 :     of STRent entity =>
81 :     (STR{sign = sign, rlzn = entity, access = A.selAcc(dacc,slot),
82 :     info = II.selInfo(dinfo, slot)}, entVar)
83 :     | _ => bug "getStr: bad entity")
84 :     | _ => bug "getStr: wrong spec"
85 :    
86 :     (*** The function getFct is used in modules/sigmatch.sml only ***)
87 :     fun getFct (elements, entEnv, sym, dacc, dinfo) =
88 :     case getSpec(elements, sym)
89 :     of FCTspec{sign, slot, entVar} =>
90 :     (case EE.look(entEnv,entVar)
91 :     of FCTent entity =>
92 :     (FCT{sign = sign, rlzn = entity, access = A.selAcc(dacc,slot),
93 :     info = II.selInfo(dinfo, slot)}, entVar)
94 :     | _ => bug "getFct: bad entity")
95 :     | _ => bug "getFct: wrong spec"
96 :    
97 :     val errorStrStamp = ST.special "ERRORstr"
98 :     val errorStrName = InvPath.IPATH[S.strSymbol "ERRORstr"]
99 :    
100 :     fun getStrStamp(STR{rlzn={stamp,...},...}) = stamp
101 :     | getStrStamp ERRORstr = errorStrStamp
102 :     | getStrStamp _ = bug "getStrStamp"
103 :    
104 :     fun getStrName(STR{rlzn={rpath,...},...}) = rpath
105 :     | getStrName ERRORstr = errorStrName
106 :     | getStrName _ = bug "getStrName"
107 :    
108 :     fun getStrs(STR{sign=SIG{elements,...},rlzn={entities,...}, access, info}) =
109 :     List.mapPartial
110 :     (fn (sym,STRspec{sign,slot,def,entVar}) =>
111 :     SOME(STR{sign = sign,
112 :     rlzn = EE.lookStrEnt(entities,entVar),
113 :     access = A.selAcc(access, slot),
114 :     info = II.selInfo(info, slot)})
115 :     | _ => NONE) elements
116 :     | getStrs ERRORstr = nil
117 :     | getStrs _ = bug "getStrs"
118 :    
119 :     fun getTycs(STR{sign=SIG{elements,...},rlzn={entities,...},...}) =
120 :     let val tycvars = List.mapPartial
121 :     (fn (sym,TYCspec{entVar,...}) => SOME entVar
122 :     | _ => NONE) elements
123 :     in List.map (fn tycVar => EE.lookTycEnt(entities,tycVar)) tycvars
124 :     end
125 :     | getTycs ERRORstr = nil
126 :     | getTycs _ = bug "getTycs"
127 :    
128 :     fun getSigSymbols(SIG{symbols,...}) = symbols
129 :     | getSigSymbols _ = nil
130 :    
131 :     fun getStrSymbols(STR{sign,...}) = getSigSymbols sign
132 :     | getStrSymbols _ = nil
133 :    
134 :     (*** Translate a tycon in a given entityEnv ***)
135 :     fun transTycon entEnv (T.PATHtyc{entPath,path,...}) =
136 :     (EE.lookTycEP(entEnv,entPath)
137 :     handle EE.Unbound =>
138 :     (debugmsg (String.concat["$transTycon ",
139 :     IP.toString path," ",
140 :     EP.entPathToString entPath]);
141 :     raise EE.Unbound))
142 :     | transTycon _ tycon = tycon
143 :    
144 :    
145 :     (*
146 :     * Translate a type in a given entityEnv
147 :     *
148 :     * We should never need to recurse inside each DEFtyc's body because
149 :     * a DEFtycs is either rigid or has been relativized as a whole into
150 :     * a PATHtyc with an entPath somewhere before.
151 :     *)
152 :     fun transType entEnv ty =
153 :     TU.mapTypeFull (transTycon entEnv) ty
154 :     handle EE.Unbound => (debugmsg "$transType"; raise EE.Unbound)
155 :    
156 :     val transTycon =
157 : monnier 24 fn x => fn y =>
158 :     (Stats.doPhase (Stats.makePhase "Compiler 033 4-transTycon")
159 :     (transTycon x) y)
160 : monnier 16
161 : monnier 24
162 : monnier 16 val transType =
163 : monnier 24 fn x => fn y =>
164 :     (Stats.doPhase (Stats.makePhase "Compiler 033 5-transType")
165 :     (transType x) y)
166 : monnier 16
167 :     fun strDefToStr(CONSTstrDef str, _) = str
168 :     | strDefToStr(VARstrDef(sign,entPath), entEnv) =
169 :     STR{sign=sign,rlzn=EE.lookStrEP(entEnv,entPath),
170 :     access=A.nullAcc, info=II.nullInfo}
171 :    
172 :     (*
173 :     * two pieces of essential structure information gathered during
174 :     * the environment lookup. SIGINFO is returned if the structure
175 :     * being searched is a STRSIG; otherwise it return STRINFO.
176 :     *)
177 :     datatype strInfo = SIGINFO of EP.entPath (* reverse order! *)
178 :     | STRINFO of strEntity * A.access * II.inl_info
179 :    
180 :     val bogusInfo = STRINFO (bogusStrEntity, A.nullAcc, II.nullInfo)
181 :    
182 :     fun getStrElem (sym, sign as SIG{elements,...}, sInfo) =
183 :     (case getSpec(elements,sym)
184 :     of STRspec{sign=subsig, slot, def, entVar} =>
185 :     (let val newInfo =
186 :     case sInfo
187 :     of SIGINFO ep => SIGINFO (entVar::ep)
188 :     | STRINFO (rlzn as {entities,...}, dacc, dinfo) =>
189 :     STRINFO(EE.lookStrEnt(entities,entVar),
190 :     A.selAcc(dacc,slot), II.selInfo(dinfo,slot))
191 :     in (subsig, newInfo)
192 :     end)
193 :     | _ => bug "getStrElem: wrong spec case")
194 :    
195 :     | getStrElem (sym, sign, _) = (sign, bogusInfo)
196 :    
197 :     fun getFctElem(sym, sign as SIG{elements,...},
198 :     sinfo as STRINFO(rlzn as {entities,...}, dacc, dinfo)) =
199 :     (case getSpec(elements, sym)
200 :     of FCTspec{sign=subfsig, entVar, slot} =>
201 :     FCT{sign=subfsig, rlzn=EE.lookFctEnt(entities,entVar),
202 :     access=A.selAcc(dacc, slot), info=II.selInfo(dinfo, slot)}
203 :     | _ => bug "mkFctVar - bad spec")
204 :    
205 :     | getFctElem _ = ERRORfct
206 :    
207 :     fun mkTyc(sym, sp, SIG{elements,...}, sInfo) =
208 :     (case getSpec (elements, sym)
209 :     of TYCspec{spec,entVar=ev,scope} =>
210 :     (case sInfo
211 :     of SIGINFO ep =>
212 :     T.PATHtyc{arity=TU.tyconArity spec, entPath=rev(ev::ep),
213 :     path=CVP.invertSPath sp}
214 :     | STRINFO (rlzn as {entities,...}, _, _) =>
215 :     EE.lookTycEnt(entities, ev))
216 :    
217 :     | _ => bug "mkTyc: wrong spec case")
218 :    
219 :     | mkTyc _ = T.ERRORtyc
220 :    
221 :     fun mkVal(sym, sp, sign as SIG{elements,...},
222 :     sInfo as STRINFO({entities,...}, dacc, dinfo)) : V.value =
223 :     (case getSpec(elements, sym)
224 :     of VALspec{spec,slot} =>
225 :     V.VAL(V.VALvar{access = A.selAcc(dacc,slot),
226 :     info = II.selInfo(dinfo,slot), path = sp,
227 :     typ = ref(transType entities spec)})
228 :    
229 :     | CONspec{spec=T.DATACON{name, const, typ, rep, sign}, slot} =>
230 :     let val newrep =
231 :     case (rep, slot)
232 :     of (A.EXN _, SOME i) => A.EXN (A.selAcc(dacc,i))
233 :     | _ => rep
234 :    
235 :     in V.CON(T.DATACON{rep=newrep, name=name,
236 :     typ=transType entities typ,
237 :     const=const, sign=sign})
238 :     end
239 :    
240 :     | _ => bug "mkVal: wrong spec")
241 :    
242 :     | mkVal _ = V.VAL(V.ERRORvar)
243 :    
244 :    
245 :     fun mkStrBase(sym, sign, sInfo) =
246 :     let val (newsig, newInfo) = getStrElem(sym, sign, sInfo)
247 :     in case newsig
248 :     of ERRORsig => ERRORstr
249 :     | _ =>
250 :     (case newInfo
251 :     of STRINFO(newrlzn, newacc, newinfo) =>
252 :     STR{sign=newsig, rlzn=newrlzn, access=newacc, info=newinfo}
253 :     | SIGINFO ep => STRSIG{sign=newsig, entPath=rev ep})
254 :     end
255 :    
256 :     fun mkStr(sym, _, sign, sInfo) = mkStrBase(sym, sign, sInfo)
257 :    
258 :     fun mkStrDef(sym, _, sign, sInfo) =
259 :     let val (newsig, newInfo) = getStrElem(sym, sign, sInfo)
260 :     in case newsig
261 :     of ERRORsig => CONSTstrDef ERRORstr
262 :     | _ =>
263 :     (case newInfo
264 :     of STRINFO (newrlzn, newacc, newinfo) =>
265 :     CONSTstrDef(STR{sign=newsig, rlzn=newrlzn,
266 :     access=newacc, info=newinfo})
267 :     | SIGINFO ep => VARstrDef(newsig, rev ep))
268 :     end
269 :    
270 :     fun mkFct(sym, sp, sign, sInfo) = getFctElem(sym, sign, sInfo)
271 :    
272 :     fun getPath makeIt (str, SP.SPATH spath, fullsp) =
273 :     let fun loop([sym], sign, sInfo) = makeIt(sym, fullsp, sign, sInfo)
274 :     | loop(sym::rest, sign, sInfo) =
275 :     let val (newsig, newsInfo) = getStrElem(sym, sign, sInfo)
276 :     in loop(rest, newsig, newsInfo)
277 :     end
278 :     | loop _ = bug "getPath.loop"
279 :    
280 :     in case str
281 :     of STR{sign, rlzn, access, info} =>
282 :     loop(spath, sign, STRINFO(rlzn, access, info))
283 :     | STRSIG{sign, entPath} =>
284 :     loop(spath, sign, SIGINFO (rev entPath))
285 :     | _ => loop(spath, ERRORsig, bogusInfo)
286 :     end
287 :    
288 :     val getTycPath : M.Structure * SP.path * SP.path -> T.tycon =
289 :     getPath mkTyc
290 :     val getValPath : M.Structure * SP.path * SP.path -> V.value =
291 :     getPath mkVal
292 :     val getStrPath : M.Structure * SP.path * SP.path -> M.Structure =
293 :     getPath mkStr
294 :     val getFctPath : M.Structure * SP.path * SP.path -> M.Functor =
295 :     getPath mkFct
296 :     val getStrDef : M.Structure * SP.path * SP.path -> M.strDef =
297 :     getPath mkStrDef
298 :    
299 :     fun checkPathSig(sign: M.Signature, spath: SP.path) : S.symbol option =
300 :     let val str = STRSIG{sign=sign,entPath=[]:EP.entPath}
301 :     fun checkLast(sym,_,SIG{elements,...},_) = (getSpec(elements,sym);())
302 :     | checkLast(sym,_,ERRORsig,_) = ()
303 :     in getPath checkLast (str,spath,SP.empty);
304 :     NONE
305 :     end
306 :     handle Unbound sym => SOME sym
307 :    
308 :     fun errBinding sym =
309 :     case S.nameSpace sym
310 :     of S.VALspace => B.VALbind V.ERRORvar
311 :     | S.TYCspace => B.TYCbind T.ERRORtyc
312 :     | S.STRspace => B.STRbind M.ERRORstr
313 :     | S.FCTspace => B.FCTbind M.ERRORfct
314 :     | _ => raise (Unbound sym)
315 :    
316 :     fun eqSign(SIG{stamp=s1,closed=true, ...},
317 :     SIG{stamp=s2,closed=true, ...}) = ST.eq(s1,s2)
318 :     | eqSign _ = false
319 :    
320 :     fun eqOrigin(STR{rlzn={stamp=s1,...},...},
321 :     STR{rlzn={stamp=s2,...},...}) = ST.eq(s1,s2)
322 :     | eqOrigin _ = false
323 :    
324 :    
325 :     (*
326 :     * The following functions are used in SCStaticEnv and module elaboration
327 :     * for building EntPathContexts. They extract module ids from modules.
328 :     *)
329 :     fun tycId(T.GENtyc{stamp,...}) = ModuleId.TYCid stamp
330 :     | tycId(T.DEFtyc{stamp,...}) = ModuleId.TYCid stamp
331 :     | tycId _ = bug "tycId"
332 :    
333 :     fun strId(STR{rlzn={stamp=rlznst,...},sign=SIG{stamp=sigst,...},...}) =
334 :     MI.STRid{rlzn=rlznst,sign=sigst}
335 :     | strId _ = bug "strId"
336 :    
337 :     fun strId2(SIG{stamp=sigst,...}, {stamp=rlznst,...} : strEntity) =
338 :     MI.STRid{rlzn=rlznst,sign=sigst}
339 :     | strId2 _ = bug "strId2"
340 :    
341 :     fun fsigId(FSIG{paramsig=SIG{stamp=sp,...},bodysig=SIG{stamp=sb,...},...}) =
342 :     MI.FSIGid{paramsig=sp,bodysig=sb}
343 :     | fsigId _ = bug "fsigId"
344 :    
345 :     fun fctId(FCT{rlzn={stamp,...},sign, ...}) =
346 :     MI.FCTid{rlzn=stamp,sign=fsigId sign}
347 :     | fctId _ = bug "fctId"
348 :    
349 :     fun fctId2(sign, {stamp,...} : fctEntity) =
350 :     MI.FCTid{rlzn=stamp,sign=fsigId sign}
351 :    
352 :     (*
353 :     * The reason that relativizeType does not need to get inside
354 :     * DEFtyc is because of our assumptions that the body in DEFtyc
355 :     * has already been relativized, when DEFtyc is elaborated;
356 :     * otherwise, this DEFtyc must be a rigid tycon.
357 :     *)
358 :     fun relativizeTyc epContext : T.tycon -> T.tycon * bool =
359 :     let fun mapTyc(tyc as (T.GENtyc{stamp,...} | T.DEFtyc{stamp,...})) =
360 :     let val tyc_id = ModuleId.TYCid stamp
361 :     in debugmsg ("mapTyc: "^ModuleId.idToString tyc_id);
362 :     case EPC.lookPath(epContext,tyc_id)
363 :     of NONE => (debugmsg "tyc not mapped 1"; (tyc,false))
364 :     | SOME entPath =>
365 :     let val tyc' = T.PATHtyc{arity=TU.tyconArity tyc,
366 :     entPath=entPath,
367 :     path=TU.tycPath tyc}
368 :     in debugmsg("tyc mapped: "^
369 :     Symbol.name(TypesUtil.tycName tyc'));
370 :     (tyc',true)
371 :     end
372 :     end
373 :     | mapTyc(tyc as T.PATHtyc _) =
374 :     (* assume this is a local tycon within the current signature *)
375 :     (debugmsg "tyc not mapped 2";
376 :     (tyc,true))
377 :     | mapTyc tyc = (debugmsg "tyc not mapped 3"; (tyc,false))
378 :    
379 :     fun mapTyc' tyc =
380 :     (debugmsg("mapTyc': "^(Symbol.name(TypesUtil.tycName tyc)));
381 :     mapTyc tyc)
382 :     in mapTyc'
383 :     end
384 :    
385 :     fun relativizeType epContext ty : T.ty * bool =
386 :     let val relative = ref false
387 :     fun vizTyc tyc =
388 :     let val (tyc',rel) = relativizeTyc epContext tyc
389 :     in relative := (!relative orelse rel);
390 :     tyc'
391 :     end
392 :     in (TU.mapTypeFull vizTyc ty, !relative)
393 :     end
394 :    
395 :    
396 :     (*
397 :     val relativizeType =
398 :     fn x => fn y =>
399 : monnier 24 (Stats.doPhase (Stats.makePhase "Compiler 033 2-vizType")
400 :     (relativizeType x) y)
401 : monnier 16
402 :     *)
403 :    
404 :     (*
405 :     * getBinding(sym,str): return binding for element sym of structure str
406 :     * - used only inside the function openStructure
407 :     * - raises ModuleUtil.Unbound if sym not found in sig
408 :     *)
409 :     fun getBinding (sym, str as STR{sign as SIG{elements,...},
410 :     rlzn as {entities,...},
411 :     access=dacc, info=dinfo}) =
412 :     let val sinfo = STRINFO(rlzn, dacc, dinfo)
413 :     in case S.nameSpace sym
414 :     of S.VALspace =>
415 :     (case mkVal(sym, SP.SPATH[sym], sign, sinfo)
416 :     of V.VAL v => B.VALbind v
417 :     | V.CON d => B.CONbind d)
418 :    
419 :     | S.TYCspace => B.TYCbind(mkTyc(sym, SP.SPATH[sym], sign, sinfo))
420 :     | S.STRspace => B.STRbind(mkStrBase(sym, sign, sinfo))
421 :     | S.FCTspace => B.FCTbind(getFctElem(sym, sign, sinfo))
422 :     | sp => (debugmsg ("getBinding: "^S.symbolToString sym);
423 :     raise (Unbound sym))
424 :     end
425 :    
426 :     | getBinding (sym, STRSIG{sign as SIG{elements, ...},entPath=ep}) =
427 :     let val sinfo = SIGINFO(rev ep)
428 :     in case S.nameSpace sym
429 :     of S.TYCspace => B.TYCbind(mkTyc(sym, SP.SPATH[sym], sign, sinfo))
430 :     | S.STRspace => B.STRbind(mkStrBase(sym, sign, sinfo))
431 :     | _ => (debugmsg ("getBinding: "^S.symbolToString sym);
432 :     raise (Unbound sym))
433 :     end
434 :    
435 :     | getBinding (sym, STR{sign=ERRORsig,...}) = errBinding sym
436 :     | getBinding (sym, ERRORstr) = errBinding sym
437 :     | getBinding _ = bug "getBinding - bad arg"
438 :    
439 :     fun openStructure(env: SE.staticEnv, str) =
440 :     let fun look sym = getBinding(sym,str) handle Unbound _ => raise SE.Unbound
441 :     val symbols = getStrSymbols str
442 :     val genSyms = (fn () => symbols)
443 :     val nenv = SE.special(look, genSyms)
444 :     in SE.atop(nenv,env)
445 :     end
446 :    
447 :     (** extract inl_info from a list of bindings *)
448 :     fun extractInfo(B.STRbind(M.STR{info, ...})) = info
449 :     | extractInfo(B.FCTbind(M.FCT{info, ...})) = info
450 :     | extractInfo(B.VALbind(V.VALvar{info, ...})) = info
451 :     | extractInfo(B.CONbind _) = II.nullInfo
452 :     | extractInfo(B.STRbind _) = II.nullInfo
453 :     | extractInfo(B.FCTbind _) = II.nullInfo
454 :     | extractInfo _ = bug "unexpected binding in extractInfo"
455 :    
456 :     (* extract all signature names from a structure --
457 :     * doesn't look into functor components *)
458 :     fun getSignatureNames(STR{sign,...} | STRSIG{sign,...}) =
459 :     let fun sigNames(SIG{name,elements,...},names) =
460 :     foldl (fn ((_,STRspec{sign,...}),ns) =>
461 :     sigNames(sign, ns)
462 :     | (_,ns) => ns)
463 :     (case name of SOME n => n::names | NONE => names)
464 :     elements
465 :     | sigNames(ERRORsig,names) = names
466 :     fun removeDups (x::(rest as y::_),z) =
467 :     if S.eq(x,y) then removeDups(rest,z) else removeDups(rest,x::z)
468 :     | removeDups (x::nil,z) = x::z
469 :     | removeDups (nil,z) = z
470 :     in removeDups(Sort.sort S.symbolGt(sigNames(sign,nil)), nil)
471 :     end
472 :     | getSignatureNames(ERRORstr) = nil
473 :    
474 :     end (* local *)
475 :     end (* structure ModuleUtil *)
476 :    
477 :     (*
478 :     * $Log: moduleutil.sml,v $
479 :     * Revision 1.10 1997/10/01 18:14:17 dbm
480 :     * Added error recovery case to mkStrDef.
481 :     *
482 :     * Revision 1.9 1997/09/30 02:32:34 dbm
483 :     * Made treatment of SIGINFO consistent with argument being a _reverse_
484 :     * entity path.
485 :     *
486 :     * Revision 1.8 1997/09/24 04:07:25 dbm
487 :     * Modified mkStrBase to fix "Compiler bug: ModuleUtil.strId" in bug1150.sml
488 :     * that arose after Zhong's fixes for EntityEnv.Unbound problem.
489 :     *
490 :     * Revision 1.7 1997/07/17 20:40:45 dbm
491 :     * Clean up mapDtMembs.
492 :     *
493 :     * Revision 1.6 1997/07/15 16:14:41 dbm
494 :     * Change in representation associated with new treatment of extdefs in
495 :     * signatures and the rewrite of instantiate.sml.
496 :     * Added getSignature names for use in build/boot.sml.
497 :     *
498 :     * Revision 1.5 1997/05/20 12:24:18 dbm
499 :     * SML '97 sharing, where structure.
500 :     *
501 :     * Revision 1.4 1997/03/24 22:19:30 dbm
502 :     * Fix for bug 1166. Changed definition of descToTyc to interpret body
503 :     * of DEFtyc in EXTCONSTtyc case.
504 :     *
505 :     * Revision 1.3 1997/03/17 18:54:07 dbm
506 :     * Changes in datatype representation to support datatype replication.
507 :     *
508 :     * Revision 1.2 1997/01/21 13:25:32 george
509 :     * Modify the entityExp definition to correctly implement the
510 :     * datatype generativity in functor body. -- from zsh
511 :     *
512 :     *)

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