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 16 - (view) (download)

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 transTyconPhase = (Stats.makePhase "Compiler 033 4-transTycon")
157 :     val transTycon =
158 :     fn x => fn y => (Stats.doPhase transTyconPhase (transTycon x) y)
159 :    
160 :     val transTypePhase = (Stats.makePhase "Compiler 033 5-transType")
161 :     val transType =
162 :     fn x => fn y => (Stats.doPhase transTypePhase (transType x) y)
163 :    
164 :     fun strDefToStr(CONSTstrDef str, _) = str
165 :     | strDefToStr(VARstrDef(sign,entPath), entEnv) =
166 :     STR{sign=sign,rlzn=EE.lookStrEP(entEnv,entPath),
167 :     access=A.nullAcc, info=II.nullInfo}
168 :    
169 :     (*
170 :     * two pieces of essential structure information gathered during
171 :     * the environment lookup. SIGINFO is returned if the structure
172 :     * being searched is a STRSIG; otherwise it return STRINFO.
173 :     *)
174 :     datatype strInfo = SIGINFO of EP.entPath (* reverse order! *)
175 :     | STRINFO of strEntity * A.access * II.inl_info
176 :    
177 :     val bogusInfo = STRINFO (bogusStrEntity, A.nullAcc, II.nullInfo)
178 :    
179 :     fun getStrElem (sym, sign as SIG{elements,...}, sInfo) =
180 :     (case getSpec(elements,sym)
181 :     of STRspec{sign=subsig, slot, def, entVar} =>
182 :     (let val newInfo =
183 :     case sInfo
184 :     of SIGINFO ep => SIGINFO (entVar::ep)
185 :     | STRINFO (rlzn as {entities,...}, dacc, dinfo) =>
186 :     STRINFO(EE.lookStrEnt(entities,entVar),
187 :     A.selAcc(dacc,slot), II.selInfo(dinfo,slot))
188 :     in (subsig, newInfo)
189 :     end)
190 :     | _ => bug "getStrElem: wrong spec case")
191 :    
192 :     | getStrElem (sym, sign, _) = (sign, bogusInfo)
193 :    
194 :     fun getFctElem(sym, sign as SIG{elements,...},
195 :     sinfo as STRINFO(rlzn as {entities,...}, dacc, dinfo)) =
196 :     (case getSpec(elements, sym)
197 :     of FCTspec{sign=subfsig, entVar, slot} =>
198 :     FCT{sign=subfsig, rlzn=EE.lookFctEnt(entities,entVar),
199 :     access=A.selAcc(dacc, slot), info=II.selInfo(dinfo, slot)}
200 :     | _ => bug "mkFctVar - bad spec")
201 :    
202 :     | getFctElem _ = ERRORfct
203 :    
204 :     fun mkTyc(sym, sp, SIG{elements,...}, sInfo) =
205 :     (case getSpec (elements, sym)
206 :     of TYCspec{spec,entVar=ev,scope} =>
207 :     (case sInfo
208 :     of SIGINFO ep =>
209 :     T.PATHtyc{arity=TU.tyconArity spec, entPath=rev(ev::ep),
210 :     path=CVP.invertSPath sp}
211 :     | STRINFO (rlzn as {entities,...}, _, _) =>
212 :     EE.lookTycEnt(entities, ev))
213 :    
214 :     | _ => bug "mkTyc: wrong spec case")
215 :    
216 :     | mkTyc _ = T.ERRORtyc
217 :    
218 :     fun mkVal(sym, sp, sign as SIG{elements,...},
219 :     sInfo as STRINFO({entities,...}, dacc, dinfo)) : V.value =
220 :     (case getSpec(elements, sym)
221 :     of VALspec{spec,slot} =>
222 :     V.VAL(V.VALvar{access = A.selAcc(dacc,slot),
223 :     info = II.selInfo(dinfo,slot), path = sp,
224 :     typ = ref(transType entities spec)})
225 :    
226 :     | CONspec{spec=T.DATACON{name, const, typ, rep, sign}, slot} =>
227 :     let val newrep =
228 :     case (rep, slot)
229 :     of (A.EXN _, SOME i) => A.EXN (A.selAcc(dacc,i))
230 :     | _ => rep
231 :    
232 :     in V.CON(T.DATACON{rep=newrep, name=name,
233 :     typ=transType entities typ,
234 :     const=const, sign=sign})
235 :     end
236 :    
237 :     | _ => bug "mkVal: wrong spec")
238 :    
239 :     | mkVal _ = V.VAL(V.ERRORvar)
240 :    
241 :    
242 :     fun mkStrBase(sym, sign, sInfo) =
243 :     let val (newsig, newInfo) = getStrElem(sym, sign, sInfo)
244 :     in case newsig
245 :     of ERRORsig => ERRORstr
246 :     | _ =>
247 :     (case newInfo
248 :     of STRINFO(newrlzn, newacc, newinfo) =>
249 :     STR{sign=newsig, rlzn=newrlzn, access=newacc, info=newinfo}
250 :     | SIGINFO ep => STRSIG{sign=newsig, entPath=rev ep})
251 :     end
252 :    
253 :     fun mkStr(sym, _, sign, sInfo) = mkStrBase(sym, sign, sInfo)
254 :    
255 :     fun mkStrDef(sym, _, sign, sInfo) =
256 :     let val (newsig, newInfo) = getStrElem(sym, sign, sInfo)
257 :     in case newsig
258 :     of ERRORsig => CONSTstrDef ERRORstr
259 :     | _ =>
260 :     (case newInfo
261 :     of STRINFO (newrlzn, newacc, newinfo) =>
262 :     CONSTstrDef(STR{sign=newsig, rlzn=newrlzn,
263 :     access=newacc, info=newinfo})
264 :     | SIGINFO ep => VARstrDef(newsig, rev ep))
265 :     end
266 :    
267 :     fun mkFct(sym, sp, sign, sInfo) = getFctElem(sym, sign, sInfo)
268 :    
269 :     fun getPath makeIt (str, SP.SPATH spath, fullsp) =
270 :     let fun loop([sym], sign, sInfo) = makeIt(sym, fullsp, sign, sInfo)
271 :     | loop(sym::rest, sign, sInfo) =
272 :     let val (newsig, newsInfo) = getStrElem(sym, sign, sInfo)
273 :     in loop(rest, newsig, newsInfo)
274 :     end
275 :     | loop _ = bug "getPath.loop"
276 :    
277 :     in case str
278 :     of STR{sign, rlzn, access, info} =>
279 :     loop(spath, sign, STRINFO(rlzn, access, info))
280 :     | STRSIG{sign, entPath} =>
281 :     loop(spath, sign, SIGINFO (rev entPath))
282 :     | _ => loop(spath, ERRORsig, bogusInfo)
283 :     end
284 :    
285 :     val getTycPath : M.Structure * SP.path * SP.path -> T.tycon =
286 :     getPath mkTyc
287 :     val getValPath : M.Structure * SP.path * SP.path -> V.value =
288 :     getPath mkVal
289 :     val getStrPath : M.Structure * SP.path * SP.path -> M.Structure =
290 :     getPath mkStr
291 :     val getFctPath : M.Structure * SP.path * SP.path -> M.Functor =
292 :     getPath mkFct
293 :     val getStrDef : M.Structure * SP.path * SP.path -> M.strDef =
294 :     getPath mkStrDef
295 :    
296 :     fun checkPathSig(sign: M.Signature, spath: SP.path) : S.symbol option =
297 :     let val str = STRSIG{sign=sign,entPath=[]:EP.entPath}
298 :     fun checkLast(sym,_,SIG{elements,...},_) = (getSpec(elements,sym);())
299 :     | checkLast(sym,_,ERRORsig,_) = ()
300 :     in getPath checkLast (str,spath,SP.empty);
301 :     NONE
302 :     end
303 :     handle Unbound sym => SOME sym
304 :    
305 :     fun errBinding sym =
306 :     case S.nameSpace sym
307 :     of S.VALspace => B.VALbind V.ERRORvar
308 :     | S.TYCspace => B.TYCbind T.ERRORtyc
309 :     | S.STRspace => B.STRbind M.ERRORstr
310 :     | S.FCTspace => B.FCTbind M.ERRORfct
311 :     | _ => raise (Unbound sym)
312 :    
313 :     fun eqSign(SIG{stamp=s1,closed=true, ...},
314 :     SIG{stamp=s2,closed=true, ...}) = ST.eq(s1,s2)
315 :     | eqSign _ = false
316 :    
317 :     fun eqOrigin(STR{rlzn={stamp=s1,...},...},
318 :     STR{rlzn={stamp=s2,...},...}) = ST.eq(s1,s2)
319 :     | eqOrigin _ = false
320 :    
321 :    
322 :     (*
323 :     * The following functions are used in SCStaticEnv and module elaboration
324 :     * for building EntPathContexts. They extract module ids from modules.
325 :     *)
326 :     fun tycId(T.GENtyc{stamp,...}) = ModuleId.TYCid stamp
327 :     | tycId(T.DEFtyc{stamp,...}) = ModuleId.TYCid stamp
328 :     | tycId _ = bug "tycId"
329 :    
330 :     fun strId(STR{rlzn={stamp=rlznst,...},sign=SIG{stamp=sigst,...},...}) =
331 :     MI.STRid{rlzn=rlznst,sign=sigst}
332 :     | strId _ = bug "strId"
333 :    
334 :     fun strId2(SIG{stamp=sigst,...}, {stamp=rlznst,...} : strEntity) =
335 :     MI.STRid{rlzn=rlznst,sign=sigst}
336 :     | strId2 _ = bug "strId2"
337 :    
338 :     fun fsigId(FSIG{paramsig=SIG{stamp=sp,...},bodysig=SIG{stamp=sb,...},...}) =
339 :     MI.FSIGid{paramsig=sp,bodysig=sb}
340 :     | fsigId _ = bug "fsigId"
341 :    
342 :     fun fctId(FCT{rlzn={stamp,...},sign, ...}) =
343 :     MI.FCTid{rlzn=stamp,sign=fsigId sign}
344 :     | fctId _ = bug "fctId"
345 :    
346 :     fun fctId2(sign, {stamp,...} : fctEntity) =
347 :     MI.FCTid{rlzn=stamp,sign=fsigId sign}
348 :    
349 :     (*
350 :     * The reason that relativizeType does not need to get inside
351 :     * DEFtyc is because of our assumptions that the body in DEFtyc
352 :     * has already been relativized, when DEFtyc is elaborated;
353 :     * otherwise, this DEFtyc must be a rigid tycon.
354 :     *)
355 :     fun relativizeTyc epContext : T.tycon -> T.tycon * bool =
356 :     let fun mapTyc(tyc as (T.GENtyc{stamp,...} | T.DEFtyc{stamp,...})) =
357 :     let val tyc_id = ModuleId.TYCid stamp
358 :     in debugmsg ("mapTyc: "^ModuleId.idToString tyc_id);
359 :     case EPC.lookPath(epContext,tyc_id)
360 :     of NONE => (debugmsg "tyc not mapped 1"; (tyc,false))
361 :     | SOME entPath =>
362 :     let val tyc' = T.PATHtyc{arity=TU.tyconArity tyc,
363 :     entPath=entPath,
364 :     path=TU.tycPath tyc}
365 :     in debugmsg("tyc mapped: "^
366 :     Symbol.name(TypesUtil.tycName tyc'));
367 :     (tyc',true)
368 :     end
369 :     end
370 :     | mapTyc(tyc as T.PATHtyc _) =
371 :     (* assume this is a local tycon within the current signature *)
372 :     (debugmsg "tyc not mapped 2";
373 :     (tyc,true))
374 :     | mapTyc tyc = (debugmsg "tyc not mapped 3"; (tyc,false))
375 :    
376 :     fun mapTyc' tyc =
377 :     (debugmsg("mapTyc': "^(Symbol.name(TypesUtil.tycName tyc)));
378 :     mapTyc tyc)
379 :     in mapTyc'
380 :     end
381 :    
382 :     fun relativizeType epContext ty : T.ty * bool =
383 :     let val relative = ref false
384 :     fun vizTyc tyc =
385 :     let val (tyc',rel) = relativizeTyc epContext tyc
386 :     in relative := (!relative orelse rel);
387 :     tyc'
388 :     end
389 :     in (TU.mapTypeFull vizTyc ty, !relative)
390 :     end
391 :    
392 :    
393 :     (*
394 :     val relativizeTypePhase = (Stats.makePhase "Compiler 033 2-vizType")
395 :     val relativizeType =
396 :     fn x => fn y =>
397 :     (Stats.doPhase relativizeTypePhase (relativizeType x) y)
398 :    
399 :     *)
400 :    
401 :     (*
402 :     * getBinding(sym,str): return binding for element sym of structure str
403 :     * - used only inside the function openStructure
404 :     * - raises ModuleUtil.Unbound if sym not found in sig
405 :     *)
406 :     fun getBinding (sym, str as STR{sign as SIG{elements,...},
407 :     rlzn as {entities,...},
408 :     access=dacc, info=dinfo}) =
409 :     let val sinfo = STRINFO(rlzn, dacc, dinfo)
410 :     in case S.nameSpace sym
411 :     of S.VALspace =>
412 :     (case mkVal(sym, SP.SPATH[sym], sign, sinfo)
413 :     of V.VAL v => B.VALbind v
414 :     | V.CON d => B.CONbind d)
415 :    
416 :     | S.TYCspace => B.TYCbind(mkTyc(sym, SP.SPATH[sym], sign, sinfo))
417 :     | S.STRspace => B.STRbind(mkStrBase(sym, sign, sinfo))
418 :     | S.FCTspace => B.FCTbind(getFctElem(sym, sign, sinfo))
419 :     | sp => (debugmsg ("getBinding: "^S.symbolToString sym);
420 :     raise (Unbound sym))
421 :     end
422 :    
423 :     | getBinding (sym, STRSIG{sign as SIG{elements, ...},entPath=ep}) =
424 :     let val sinfo = SIGINFO(rev ep)
425 :     in case S.nameSpace sym
426 :     of S.TYCspace => B.TYCbind(mkTyc(sym, SP.SPATH[sym], sign, sinfo))
427 :     | S.STRspace => B.STRbind(mkStrBase(sym, sign, sinfo))
428 :     | _ => (debugmsg ("getBinding: "^S.symbolToString sym);
429 :     raise (Unbound sym))
430 :     end
431 :    
432 :     | getBinding (sym, STR{sign=ERRORsig,...}) = errBinding sym
433 :     | getBinding (sym, ERRORstr) = errBinding sym
434 :     | getBinding _ = bug "getBinding - bad arg"
435 :    
436 :     fun openStructure(env: SE.staticEnv, str) =
437 :     let fun look sym = getBinding(sym,str) handle Unbound _ => raise SE.Unbound
438 :     val symbols = getStrSymbols str
439 :     val genSyms = (fn () => symbols)
440 :     val nenv = SE.special(look, genSyms)
441 :     in SE.atop(nenv,env)
442 :     end
443 :    
444 :     (** extract inl_info from a list of bindings *)
445 :     fun extractInfo(B.STRbind(M.STR{info, ...})) = info
446 :     | extractInfo(B.FCTbind(M.FCT{info, ...})) = info
447 :     | extractInfo(B.VALbind(V.VALvar{info, ...})) = info
448 :     | extractInfo(B.CONbind _) = II.nullInfo
449 :     | extractInfo(B.STRbind _) = II.nullInfo
450 :     | extractInfo(B.FCTbind _) = II.nullInfo
451 :     | extractInfo _ = bug "unexpected binding in extractInfo"
452 :    
453 :     (* extract all signature names from a structure --
454 :     * doesn't look into functor components *)
455 :     fun getSignatureNames(STR{sign,...} | STRSIG{sign,...}) =
456 :     let fun sigNames(SIG{name,elements,...},names) =
457 :     foldl (fn ((_,STRspec{sign,...}),ns) =>
458 :     sigNames(sign, ns)
459 :     | (_,ns) => ns)
460 :     (case name of SOME n => n::names | NONE => names)
461 :     elements
462 :     | sigNames(ERRORsig,names) = names
463 :     fun removeDups (x::(rest as y::_),z) =
464 :     if S.eq(x,y) then removeDups(rest,z) else removeDups(rest,x::z)
465 :     | removeDups (x::nil,z) = x::z
466 :     | removeDups (nil,z) = z
467 :     in removeDups(Sort.sort S.symbolGt(sigNames(sign,nil)), nil)
468 :     end
469 :     | getSignatureNames(ERRORstr) = nil
470 :    
471 :     end (* local *)
472 :     end (* structure ModuleUtil *)
473 :    
474 :     (*
475 :     * $Log: moduleutil.sml,v $
476 :     * Revision 1.10 1997/10/01 18:14:17 dbm
477 :     * Added error recovery case to mkStrDef.
478 :     *
479 :     * Revision 1.9 1997/09/30 02:32:34 dbm
480 :     * Made treatment of SIGINFO consistent with argument being a _reverse_
481 :     * entity path.
482 :     *
483 :     * Revision 1.8 1997/09/24 04:07:25 dbm
484 :     * Modified mkStrBase to fix "Compiler bug: ModuleUtil.strId" in bug1150.sml
485 :     * that arose after Zhong's fixes for EntityEnv.Unbound problem.
486 :     *
487 :     * Revision 1.7 1997/07/17 20:40:45 dbm
488 :     * Clean up mapDtMembs.
489 :     *
490 :     * Revision 1.6 1997/07/15 16:14:41 dbm
491 :     * Change in representation associated with new treatment of extdefs in
492 :     * signatures and the rewrite of instantiate.sml.
493 :     * Added getSignature names for use in build/boot.sml.
494 :     *
495 :     * Revision 1.5 1997/05/20 12:24:18 dbm
496 :     * SML '97 sharing, where structure.
497 :     *
498 :     * Revision 1.4 1997/03/24 22:19:30 dbm
499 :     * Fix for bug 1166. Changed definition of descToTyc to interpret body
500 :     * of DEFtyc in EXTCONSTtyc case.
501 :     *
502 :     * Revision 1.3 1997/03/17 18:54:07 dbm
503 :     * Changes in datatype representation to support datatype replication.
504 :     *
505 :     * Revision 1.2 1997/01/21 13:25:32 george
506 :     * Modify the entityExp definition to correctly implement the
507 :     * datatype generativity in functor body. -- from zsh
508 :     *
509 :     *)

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