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/branches/primop-branch-3/compiler/Elaborator/print/ppmod.sml
ViewVC logotype

Annotation of /sml/branches/primop-branch-3/compiler/Elaborator/print/ppmod.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2423 - (view) (download)

1 : blume 902 (* Copyright 1996 by AT&T Bell Laboratories *)
2 : macqueen 1344 (* Copyright 2003 by The SML/NJ Fellowship *)
3 : blume 902 (* ppmod.sml *)
4 :    
5 : macqueen 1344 (* modified to use SML/NJ Lib PP. [dbm, 7/30/03]) *)
6 :    
7 : blume 902 signature PPMOD =
8 :     sig
9 : blume 2222 val ppSignature: PrettyPrintNew.stream
10 : blume 902 -> Modules.Signature * StaticEnv.staticEnv * int -> unit
11 : blume 2222 val ppStructure: PrettyPrintNew.stream
12 : blume 902 -> Modules.Structure * StaticEnv.staticEnv * int -> unit
13 : blume 2222 val ppOpen: PrettyPrintNew.stream
14 : blume 902 -> SymPath.path * Modules.Structure * StaticEnv.staticEnv * int -> unit
15 : blume 2222 val ppStructureName : PrettyPrintNew.stream
16 : blume 902 -> Modules.Structure * StaticEnv.staticEnv -> unit
17 : blume 2222 val ppFunctor : PrettyPrintNew.stream
18 : blume 902 -> Modules.Functor * StaticEnv.staticEnv * int -> unit
19 : blume 2222 val ppFunsig : PrettyPrintNew.stream
20 : blume 902 -> Modules.fctSig * StaticEnv.staticEnv * int -> unit
21 : blume 2222 val ppBinding: PrettyPrintNew.stream
22 : blume 902 -> Symbol.symbol * Bindings.binding * StaticEnv.staticEnv * int
23 :     -> unit
24 : blume 2222 val ppEnv : PrettyPrintNew.stream
25 : blume 902 -> StaticEnv.staticEnv * StaticEnv.staticEnv * int *
26 :     Symbol.symbol list option
27 :     -> unit
28 :    
29 :     (* module internals *)
30 :    
31 :     val ppElements : (StaticEnv.staticEnv * int * Modules.entityEnv option)
32 : blume 2222 -> PrettyPrintNew.stream
33 : blume 902 -> Modules.elements -> unit
34 :    
35 : blume 2222 val ppEntity : PrettyPrintNew.stream
36 : blume 902 -> Modules.entity * StaticEnv.staticEnv * int
37 :     -> unit
38 :    
39 : blume 2222 val ppEntityEnv : PrettyPrintNew.stream
40 : blume 902 -> Modules.entityEnv * StaticEnv.staticEnv * int
41 :     -> unit
42 :    
43 :     end (* signature PPMOD *)
44 :    
45 :    
46 :     structure PPModules : PPMOD =
47 :     struct
48 :    
49 :     local structure S = Symbol
50 :     structure SP = SymPath
51 :     structure IP = InvPath
52 :     structure A = Access
53 :     (* structure II = InlInfo *)
54 :     structure T = Types
55 :     structure TU = TypesUtil
56 :     structure BT = BasicTypes
57 :     structure V = VarCon
58 :     structure M = Modules
59 :     structure MU = ModuleUtil
60 :     structure B = Bindings
61 :     structure SE = StaticEnv
62 :     structure EE = EntityEnv
63 :     structure LU = Lookup
64 :    
65 : blume 2222 structure PP = PrettyPrintNew
66 :     structure PU = PPUtilNew
67 :     open PrettyPrintNew PPUtilNew
68 : blume 902
69 :     in
70 :    
71 :     val internals = ElabControl.internals
72 :     fun bug msg = ErrorMsg.impossible("PPModules: "^msg)
73 :     fun C f x y = f y x;
74 :    
75 : macqueen 1344 val pps = PP.string
76 : blume 902 val ppType = PPType.ppType
77 :     val ppTycon = PPType.ppTycon
78 :     val ppTyfun = PPType.ppTyfun
79 :     val ppFormals = PPType.ppFormals
80 :    
81 :     val resultId = S.strSymbol "<resultStr>"
82 :    
83 :     fun strToEnv(M.SIG {elements,...},entities) =
84 :     let fun bindElem ((sym,spec), env) =
85 :     case spec
86 :     of M.TYCspec{entVar,...} =>
87 :     let val tyc = EE.lookTycEnt(entities,entVar)
88 :     in SE.bind(sym,B.TYCbind tyc,env)
89 :     end
90 :     | M.STRspec{entVar,sign,...} =>
91 :     let val strEnt = EE.lookStrEnt(entities,entVar)
92 :     in SE.bind(sym,B.STRbind(M.STR{sign=sign,rlzn=strEnt,
93 :     access=A.nullAcc,
94 : blume 2222 prim=[]}),
95 : blume 902 env)
96 :     end
97 :     | M.CONspec{spec=dcon, ...} => SE.bind(sym,B.CONbind dcon,env)
98 :     | _ => env
99 :     in foldl bindElem SE.empty elements
100 :     end
101 :     | strToEnv _ = SE.empty
102 :    
103 :     fun sigToEnv(M.SIG {elements,...}) =
104 :     let fun bindElem ((sym,spec), env) =
105 :     (case spec
106 :     of M.TYCspec{spec,...} => SE.bind(sym,B.TYCbind spec,env)
107 :     | M.STRspec{sign,slot,def,entVar=ev} =>
108 :     SE.bind(sym,B.STRbind(M.STRSIG{sign=sign,entPath=[ev]}),env)
109 :     | M.CONspec{spec=dcon, ...} => SE.bind(sym,B.CONbind dcon,env)
110 :     | _ => env)
111 :     in foldl bindElem SE.empty elements
112 :     end
113 :     | sigToEnv _ = bug "sigToEnv"
114 :    
115 :     (*
116 :     * Support for a hack to make sure that non-visible ConBindings don't
117 :     * cause spurious blank lines when pp-ing signatures.
118 :     *)
119 :     fun is_ppable_ConBinding (T.DATACON{rep=A.EXN _, ...}, _) = true
120 :     | is_ppable_ConBinding (con,env) =
121 :     let exception Hidden
122 :     val visibleDconTyc =
123 :     let val tyc = TU.dconTyc con
124 :     in (TU.equalTycon
125 :     (LU.lookTyc
126 :     (env,
127 :     SP.SPATH[IP.last(TU.tycPath tyc)],
128 :     fn _ => raise Hidden),
129 :     tyc)
130 :     handle Hidden => false)
131 :     end
132 :     in (!internals orelse not visibleDconTyc)
133 :     end
134 :    
135 :     fun all_ppable_bindings alist env =
136 :     List.filter (fn (name,B.CONbind con) => is_ppable_ConBinding(con,env)
137 :     | b => true)
138 :     alist
139 :    
140 :    
141 : macqueen 1344 fun ppLty ppstrm ( (* lambdaty,depth *) ) = pps ppstrm "<lambdaty>"
142 : blume 902
143 :     fun ppEntVar ppstrm entVar =
144 : macqueen 1344 pps ppstrm (EntPath.entVarToString entVar)
145 : blume 902
146 :     fun ppEntPath ppstrm entPath =
147 : macqueen 1344 pps ppstrm (EntPath.entPathToString entPath)
148 : blume 902 (* ppClosedSequence ppstream
149 : macqueen 1344 {front=(fn ppstrm => pps ppstrm "["),
150 :     sep=(fn ppstrm => (pps ppstrm ","; break ppstrm {nsp=0,offset=0})),
151 :     back=(fn ppstrm => pps ppstrm "]"),
152 : blume 902 style=INCONSISTENT,
153 :     pr=ppEntVar}
154 :     *)
155 :    
156 :     fun ppTycExp ppstrm (tycExp,depth) =
157 : macqueen 1344 if depth <= 0 then pps ppstrm "<tycExp>" else
158 : blume 902 case tycExp
159 :     of M.VARtyc ep =>
160 : macqueen 1344 (pps ppstrm "TE.V:"; break ppstrm {nsp=1,offset=1};
161 : blume 902 ppEntPath ppstrm ep)
162 :     | M.CONSTtyc tycon =>
163 : macqueen 1344 (pps ppstrm "TE.C:"; break ppstrm {nsp=1,offset=1};
164 : blume 902 ppTycon SE.empty ppstrm tycon)
165 :     | M.FORMtyc tycon =>
166 : macqueen 1344 (pps ppstrm "TE.FM:"; break ppstrm {nsp=1,offset=1};
167 : blume 902 ppTycon SE.empty ppstrm tycon)
168 :    
169 :     fun ppStructureName ppstrm (str,env) =
170 :     let val rpath =
171 :     case str
172 :     of M.STR { rlzn, ... } => #rpath rlzn
173 :     | _ => bug "ppStructureName"
174 :     fun look a = LU.lookStr(env,a,(fn _ => raise StaticEnv.Unbound))
175 :     fun check str' = MU.eqOrigin(str',str)
176 :     val (syms,found) = findPath(rpath,check,look)
177 :     in pps ppstrm (if found then SP.toString(SP.SPATH syms)
178 :     else "?"^(SP.toString(SP.SPATH syms)))
179 :     end
180 :    
181 :     fun ppVariable ppstrm =
182 : macqueen 1344 let val {openHVBox, openHOVBox,closeBox,pps,...} = en_pp ppstrm
183 : blume 2222 fun ppV(V.VALvar{path,access,typ,prim},env:StaticEnv.staticEnv) =
184 : macqueen 1344 (openHVBox 0;
185 :     pps (SP.toString path);
186 : blume 902 if !internals then PPVal.ppAccess ppstrm access else ();
187 :     pps " : "; ppType env ppstrm (!typ);
188 : macqueen 1344 closeBox())
189 : blume 902 | ppV (V.OVLDvar {name,options=ref optl,scheme=T.TYFUN{body,...}},env) =
190 : macqueen 1344 (openHVBox 0;
191 : blume 902 ppSym ppstrm (name); pps " : "; ppType env ppstrm body;
192 :     pps " as ";
193 :     ppSequence ppstrm
194 : blume 2222 {sep=C PrettyPrintNew.break{nsp=1,offset=0},
195 : blume 902 pr=(fn ppstrm => fn{variant,...} =>ppV(variant,env)),
196 :     style=CONSISTENT}
197 :     optl;
198 : macqueen 1344 closeBox())
199 : blume 902 | ppV(V.ERRORvar,_) = pps "<ERRORvar>"
200 :     in ppV
201 :     end
202 :    
203 :     fun ppConBinding ppstrm =
204 : macqueen 1344 let val {openHVBox, openHOVBox,closeBox,pps,...} = en_pp ppstrm
205 : blume 902 fun ppCon (T.DATACON{name, typ, rep=A.EXN _, ...}, env) =
206 : macqueen 1344 (openHOVBox 4;
207 : blume 902 pps "exception "; ppSym ppstrm name;
208 :     if BasicTypes.isArrowType typ then
209 :     (pps " of "; ppType env ppstrm (BasicTypes.domain typ))
210 :     else ();
211 : macqueen 1344 closeBox())
212 : blume 902 | ppCon (con as T.DATACON{name,typ,...},env) =
213 :     if !internals
214 : macqueen 1344 then (openHOVBox 4;
215 : blume 902 pps "datacon "; ppSym ppstrm name; pps " : ";
216 :     ppType env ppstrm typ;
217 : macqueen 1344 closeBox())
218 : blume 902 else ()
219 :     in ppCon
220 :     end
221 :    
222 :     fun ppStructure ppstrm (str,env,depth) =
223 : blume 2222 let val {openHVBox, openHOVBox,closeBox,pps,ppi,break,newline} = en_pp ppstrm
224 : blume 902 in case str
225 : blume 2222 of M.STR { sign, rlzn as { entities, ... }, prim, ... } =>
226 : blume 902 (if !internals
227 : macqueen 1344 then (openHVBox 2;
228 : blume 902 pps "STR";
229 :     nl_indent ppstrm 2;
230 : macqueen 1344 openHVBox 0;
231 : blume 902 pps "sign:";
232 : macqueen 1344 break {nsp=1,offset=2};
233 : blume 902 ppSignature0 ppstrm (sign,env,depth-1,SOME entities);
234 : macqueen 1344 newline();
235 : blume 902 pps "rlzn:";
236 : macqueen 1344 break {nsp=1,offset=2};
237 : blume 902 ppStrEntity ppstrm (rlzn,env,depth-1);
238 : blume 2222 newline();
239 :     pps "prim:";
240 :     break {nsp=1,offset=2};
241 :     (* GK: This should be cleaned up soon so as to use a
242 :     ppStrInfo that is an actual pretty printer conforming
243 :     to the pattern of the other pretty printers.
244 :     PrimOpId.ppStrInfo prim; *)
245 :     PPPrim.ppStrPrimInfo ppstrm prim;
246 : macqueen 1344 closeBox();
247 :     closeBox())
248 : blume 902 else case sign
249 :     of M.SIG { name = SOME sym, ... } =>
250 :     ((if MU.eqSign
251 :     (sign,
252 :     LU.lookSig
253 :     (env,sym,(fn _ => raise SE.Unbound)))
254 :     then ppSym ppstrm sym
255 :     else (ppSym ppstrm sym; pps "?"))
256 :     handle SE.Unbound =>
257 :     (ppSym ppstrm sym; pps "?"))
258 :     | M.SIG { name = NONE, ... } =>
259 :     if depth <= 1 then pps "<sig>"
260 :     else ppSignature0 ppstrm
261 :     (sign,env,depth-1,SOME entities)
262 :     | M.ERRORsig => pps "<error sig>")
263 :     | M.STRSIG _ => pps "<strsig>"
264 :     | M.ERRORstr => pps "<error str>"
265 :     end
266 :    
267 :     and ppElements (env,depth,entityEnvOp) ppstrm elements =
268 :     let fun pr first (sym,spec) =
269 :     case spec
270 :     of M.STRspec{sign,entVar,def,slot} =>
271 : macqueen 1344 (if first then () else newline ppstrm;
272 :     openHVBox ppstrm (PP.Rel 0);
273 :     pps ppstrm "structure ";
274 :     ppSym ppstrm sym; pps ppstrm " :";
275 :     break ppstrm {nsp=1,offset=2};
276 :     openHVBox ppstrm (PP.Rel 0);
277 : blume 902 case entityEnvOp
278 :     of NONE => ppSignature0 ppstrm (sign,env,depth-1,NONE)
279 :     | SOME eenv =>
280 :     let val {entities,...} =
281 :     case EE.look(eenv,entVar) of
282 :     M.STRent e => e
283 :     | _ => bug "ppElements:STRent"
284 :     in ppSignature0 ppstrm
285 :     (sign,env,depth-1,SOME entities)
286 :     end;
287 :     if !internals
288 : macqueen 1344 then (newline ppstrm;
289 :     pps ppstrm "entVar: ";
290 :     pps ppstrm (EntPath.entVarToString entVar))
291 : blume 902 else ();
292 : macqueen 1344 closeBox ppstrm;
293 :     closeBox ppstrm)
294 : blume 902
295 :     | M.FCTspec{sign,entVar,slot} =>
296 : macqueen 1344 (if first then () else newline ppstrm;
297 :     openHVBox ppstrm (PP.Rel 0);
298 :     pps ppstrm "functor ";
299 :     ppSym ppstrm sym; pps ppstrm " :";
300 :     break ppstrm {nsp=1,offset=2};
301 :     openHVBox ppstrm (PP.Rel 0);
302 : blume 902 ppFunsig ppstrm (sign,env,depth-1);
303 :     if !internals
304 : macqueen 1344 then (newline ppstrm;
305 :     pps ppstrm "entVar: ";
306 :     pps ppstrm (EntPath.entVarToString entVar))
307 : blume 902 else ();
308 : macqueen 1344 closeBox ppstrm;
309 :     closeBox ppstrm)
310 : blume 902
311 :     | M.TYCspec{spec,entVar,repl,scope} =>
312 : macqueen 1344 (if first then () else newline ppstrm;
313 :     openHVBox ppstrm (PP.Rel 0);
314 : blume 902 case entityEnvOp
315 : macqueen 1344 of NONE =>
316 :     if repl then
317 :     ppReplBind ppstrm (spec,env)
318 :     else ppTycBind ppstrm (spec,env)
319 : blume 902 | SOME eenv =>
320 :     (case EE.look(eenv,entVar)
321 : macqueen 1344 of M.TYCent tyc =>
322 :     if repl then
323 :     ppReplBind ppstrm (tyc,env)
324 :     else ppTycBind ppstrm (tyc,env)
325 :     | M.ERRORent => pps ppstrm "<ERRORent>"
326 : blume 902 | _ => bug "ppElements:TYCent");
327 :     if !internals
328 : macqueen 1344 then (newline ppstrm;
329 :     pps ppstrm "entVar: ";
330 :     pps ppstrm (EntPath.entVarToString entVar);
331 :     newline ppstrm;
332 :     pps ppstrm "scope: ";
333 :     pps ppstrm (Int.toString scope))
334 : blume 902 else ();
335 : macqueen 1344 closeBox ppstrm)
336 : blume 902
337 :     | M.VALspec{spec=typ,...} =>
338 : macqueen 1344 (if first then () else newline ppstrm;
339 :     openHOVBox ppstrm (PP.Rel 4);
340 :     pps ppstrm "val ";
341 :     ppSym ppstrm sym; pps ppstrm " : ";
342 : blume 902 ppType env ppstrm (typ);
343 : macqueen 1344 closeBox ppstrm)
344 : blume 902
345 :     | M.CONspec{spec=dcon as T.DATACON{rep=A.EXN _,...}, ...} =>
346 : macqueen 1344 (if first then () else newline ppstrm;
347 : blume 902 ppConBinding ppstrm (dcon,env))
348 :    
349 :     | M.CONspec{spec=dcon,...} =>
350 :     if !internals
351 : macqueen 1344 then (if first then () else newline ppstrm;
352 : blume 902 ppConBinding ppstrm (dcon,env))
353 :     else () (* ordinary data constructor, don't print *)
354 :    
355 : macqueen 1344 in openHVBox ppstrm (PP.Rel 0);
356 : blume 902 case elements
357 :     of nil => ()
358 :     | first :: rest => (pr true first; app (pr false) rest);
359 : macqueen 1344 closeBox ppstrm
360 : blume 902 end
361 :    
362 :     and ppSignature0 ppstrm (sign,env,depth,entityEnvOp) =
363 : blume 2222 let val {openHVBox, openHOVBox,closeBox,pps,ppi,break,newline} = en_pp ppstrm
364 : blume 902 val env = SE.atop(case entityEnvOp
365 :     of NONE => sigToEnv sign
366 :     | SOME entEnv => strToEnv(sign,entEnv),
367 :     env)
368 :     fun ppConstraints (variety,constraints : M.sharespec list) =
369 : macqueen 1344 (openHVBox 0;
370 : blume 902 ppvseq ppstrm 0 ""
371 :     (fn ppstrm => fn paths =>
372 : macqueen 1344 (openHOVBox 2;
373 : blume 902 pps "sharing "; pps variety;
374 :     ppSequence ppstrm
375 :     {sep=(fn ppstrm =>
376 : macqueen 1344 (pps " ="; break{nsp=1,offset=0})),
377 : blume 902 pr=ppSymPath,
378 :     style=INCONSISTENT}
379 :     paths;
380 : macqueen 1344 closeBox()))
381 : blume 902 constraints;
382 : macqueen 1344 closeBox ())
383 : gkuan 2407 val somePrint = ref false (* i.e., signature is not empty sig end *)
384 : blume 902 in if depth <= 0
385 :     then pps "<sig>"
386 :     else
387 :     case sign
388 :     of M.SIG {stamp,name,elements,typsharing,strsharing,...} =>
389 : gkuan 2408 let
390 :     (* Filter out ordinary dcon that do not print in ppElements
391 :     for element printing so that we do not print the spurious
392 :     newline. We still use the unfiltered elements
393 :     for determining whether the sig ... end should be
394 :     multiline even with just one datatype. *)
395 : gkuan 2423 val elems' =
396 :     List.filter
397 :     (fn (_,M.CONspec{spec=T.DATACON{rep=A.EXN _,...},...})
398 :     => true
399 :     | (_,M.CONspec{spec=dcon,...}) => false
400 :     | _ => true)
401 :     elements
402 : gkuan 2408 in
403 : blume 902 if !internals then
404 : macqueen 1344 (openHVBox 0;
405 : blume 902 pps "SIG:";
406 :     nl_indent ppstrm 2;
407 : macqueen 1344 openHVBox 0;
408 : blume 902 pps "stamp: "; pps (Stamps.toShortString stamp);
409 : macqueen 1344 newline();
410 : blume 902 pps "name: ";
411 :     case name
412 :     of NONE => pps "ANONYMOUS"
413 :     | SOME p => (pps "NAMED "; ppSym ppstrm p);
414 :     case elements
415 :     of nil => ()
416 : macqueen 1344 | _ => (newline(); pps "elements:";
417 : blume 902 nl_indent ppstrm 2;
418 :     ppElements (env,depth,entityEnvOp) ppstrm elements);
419 :     case strsharing
420 :     of nil => ()
421 : macqueen 1344 | _ => (newline(); pps "strsharing:";
422 : blume 902 nl_indent ppstrm 2;
423 :     ppConstraints("",strsharing));
424 :     case typsharing
425 :     of nil => ()
426 : macqueen 1344 | _ => (newline(); pps "tycsharing:";
427 : blume 902 nl_indent ppstrm 2;
428 :     ppConstraints("type ",typsharing));
429 : macqueen 1344 closeBox();
430 :     closeBox())
431 : blume 902 else (* not !internals *)
432 : macqueen 1344 (openHVBox 0;
433 : blume 902 pps "sig";
434 : gkuan 2407 (case elements
435 :     of nil => pps " "
436 :     | [_] => pps " "
437 :     | _ => nl_indent ppstrm 2);
438 : macqueen 1344 openHVBox 0;
439 : blume 902 case elements
440 :     of nil => ()
441 : gkuan 2408 | _ => (ppElements (env,depth,entityEnvOp) ppstrm elems';
442 : blume 902 somePrint := true);
443 :     case strsharing
444 :     of nil => ()
445 : macqueen 1344 | _ => (if !somePrint then newline() else ();
446 : blume 902 ppConstraints("",strsharing);
447 :     somePrint := true);
448 :     case typsharing
449 :     of nil => ()
450 : macqueen 1344 | _ => (if !somePrint then newline() else ();
451 : blume 902 ppConstraints("type ",typsharing);
452 :     somePrint := true);
453 : macqueen 1344 closeBox();
454 : gkuan 2407 (case elements
455 :     of nil => ()
456 :     | [_] => pps " "
457 :     | _ => newline());
458 : blume 902 pps "end";
459 : macqueen 1344 closeBox())
460 : gkuan 2408 end
461 : blume 902 | M.ERRORsig => pps "<error sig>"
462 :     end
463 :    
464 :     and ppFunsig ppstrm (sign,env,depth) =
465 : blume 2222 let val {openHVBox, openHOVBox,closeBox,pps,ppi,break,newline} = en_pp ppstrm
466 : blume 902 fun trueBodySig (orig as M.SIG { elements =
467 :     [(sym, M.STRspec { sign, ... })],
468 :     ... }) =
469 :     if Symbol.eq (sym, resultId) then sign else orig
470 :     | trueBodySig orig = orig
471 :     in if depth<=0 then pps "<fctsig>"
472 :     else case sign
473 :     of M.FSIG {paramsig,paramvar,paramsym,bodysig, ...} =>
474 :     if !internals
475 : macqueen 1344 then (openHVBox 0;
476 : blume 902 pps "FSIG:";
477 :     nl_indent ppstrm 2;
478 : macqueen 1344 openHVBox 0;
479 : blume 902 pps "psig: ";
480 :     ppSignature0 ppstrm (paramsig,env,depth-1,NONE);
481 : macqueen 1344 newline();
482 : blume 902 pps "pvar: ";
483 :     pps (EntPath.entVarToString paramvar);
484 : macqueen 1344 newline();
485 : blume 902 pps "psym: ";
486 :     (case paramsym
487 :     of NONE => pps "<anonymous>"
488 :     | SOME sym => ppSym ppstrm sym);
489 : macqueen 1344 newline();
490 : blume 902 pps "bsig: ";
491 :     ppSignature0 ppstrm (bodysig,env,depth-1,NONE);
492 : macqueen 1344 closeBox();
493 :     closeBox())
494 :     else (openHVBox 0;
495 : blume 902 pps "(";
496 :     case paramsym
497 :     of SOME x => pps (S.name x)
498 :     | _ => pps "<param>";
499 :     pps ": ";
500 :     ppSignature0 ppstrm (paramsig,env,depth-1,NONE);
501 :     pps ") :";
502 : macqueen 1344 break{nsp=1,offset=0};
503 : blume 902 ppSignature0 ppstrm
504 :     (trueBodySig bodysig,env,depth-1,NONE);
505 : macqueen 1344 closeBox())
506 : blume 902 | M.ERRORfsig => pps "<error fsig>"
507 :     end
508 :    
509 :     and ppStrEntity ppstrm (e,env,depth) =
510 :     let val {stamp,entities,properties,rpath,stub} = e
511 : blume 2222 val {openHVBox, openHOVBox,closeBox,pps,ppi,break,newline} = en_pp ppstrm
512 : blume 902 in if depth <= 1
513 :     then pps "<structure entity>"
514 : macqueen 1344 else (openHVBox 0;
515 : blume 902 pps "strEntity:";
516 :     nl_indent ppstrm 2;
517 : macqueen 1344 openHVBox 0;
518 : blume 902 pps "rpath: ";
519 :     pps (IP.toString rpath);
520 : macqueen 1344 newline();
521 : blume 902 pps "stamp: ";
522 :     pps (Stamps.toShortString stamp);
523 : macqueen 1344 newline();
524 : blume 902 pps "entities:";
525 :     nl_indent ppstrm 2;
526 :     ppEntityEnv ppstrm (entities,env,depth-1);
527 : macqueen 1344 newline();
528 : blume 902 pps "lambdaty:";
529 :     nl_indent ppstrm 2;
530 :     ppLty ppstrm ( (* ModulePropLists.strEntityLty e,depth-1 *));
531 : macqueen 1344 closeBox ();
532 :     closeBox ())
533 : blume 902 end
534 :    
535 :     and ppFctEntity ppstrm (e, env, depth) =
536 :     let val {stamp,closure,properties,tycpath,rpath,stub} = e
537 : blume 2222 val {openHVBox,openHOVBox,closeBox,pps,ppi,break,newline} = en_pp ppstrm
538 : blume 902 in if depth <= 1
539 :     then pps "<functor entity>"
540 : macqueen 1344 else (openHVBox 0;
541 : blume 902 pps "fctEntity:";
542 :     nl_indent ppstrm 2;
543 : macqueen 1344 openHVBox 0;
544 : blume 902 pps "rpath: ";
545 :     pps (IP.toString rpath);
546 : macqueen 1344 newline();
547 : blume 902 pps "stamp: ";
548 :     pps (Stamps.toShortString stamp);
549 : macqueen 1344 newline();
550 : blume 902 pps "closure:";
551 : macqueen 1344 break{nsp=1,offset=2};
552 : blume 902 ppClosure ppstrm (closure,depth-1);
553 : macqueen 1344 newline();
554 : blume 902 pps "lambdaty:";
555 : macqueen 1344 break{nsp=1,offset=2};
556 : blume 902 ppLty ppstrm ( (* ModulePropLists.fctEntityLty e,depth-1 *) );
557 :     pps "tycpath:";
558 : macqueen 1344 break{nsp=1,offset=2};
559 : blume 902 pps "--printing of tycpath not implemented yet--";
560 : macqueen 1344 closeBox ();
561 :     closeBox ())
562 : blume 902 end
563 :    
564 :     and ppFunctor ppstrm =
565 : blume 2222 let val {openHVBox, openHOVBox,closeBox,pps,ppi,break,newline} = en_pp ppstrm
566 : blume 902 fun ppF (M.FCT { sign, rlzn, ... }, env, depth) =
567 :     if depth <= 1
568 :     then pps "<functor>"
569 : macqueen 1344 else (openHVBox 0;
570 : blume 902 pps "sign:";
571 :     nl_indent ppstrm 2;
572 :     ppFunsig ppstrm (sign,env,depth-1);
573 : macqueen 1344 newline();
574 : blume 902 pps "rlzn:";
575 :     nl_indent ppstrm 2;
576 :     ppFctEntity ppstrm (rlzn,env,depth-1);
577 : macqueen 1344 closeBox ())
578 : blume 902 | ppF (M.ERRORfct,_,_) = pps "<error functor>"
579 :     in ppF
580 :     end
581 :    
582 :     and ppTycBind ppstrm (tyc,env) =
583 : blume 2222 let val {openHVBox, openHOVBox,closeBox,pps,ppi,break,newline} = en_pp ppstrm
584 : blume 902 fun visibleDcons(tyc,dcons) =
585 :     let fun checkCON(V.CON c) = c
586 :     | checkCON _ = raise SE.Unbound
587 :     fun find ((actual as {name,rep,domain}) :: rest) =
588 :     (let val found =
589 :     checkCON(LU.lookValSym
590 :     (env,name,
591 :     fn _ => raise SE.Unbound))
592 :     in (* test whether the datatypes of actual and
593 :     found constructor agree *)
594 :     case TU.dconTyc found
595 :     of tyc1 as T.GENtyc _ =>
596 :     (* the expected form in structures *)
597 :     if TU.eqTycon(tyc,tyc1)
598 :     then found :: find rest
599 :     else find rest
600 :     | T.PATHtyc _ =>
601 :     (* the expected form in signatures;
602 :     we won't check visibility [dbm] *)
603 :     found :: find rest
604 :     | d_found =>
605 :     (* something's weird *)
606 :     let val old_internals = !internals
607 :     in internals := true;
608 : macqueen 1344 openHVBox 0;
609 : blume 902 pps "ppTycBind failure: ";
610 : macqueen 1344 newline();
611 : blume 902 ppTycon env ppstrm tyc;
612 : macqueen 1344 newline();
613 : blume 902 ppTycon env ppstrm d_found;
614 : macqueen 1344 newline();
615 :     closeBox();
616 : blume 902 internals := old_internals;
617 :     find rest
618 :     end
619 :     end
620 :     handle SE.Unbound => find rest)
621 :     | find [] = []
622 :     in find dcons
623 :     end
624 :     fun stripPoly(T.POLYty{tyfun=T.TYFUN{body,...},...}) = body
625 :     | stripPoly ty = ty
626 :     fun ppDcon (T.DATACON{name,typ,...}) =
627 :     (ppSym ppstrm name;
628 :     let val typ = stripPoly typ
629 :     in if BT.isArrowType typ
630 :     then (pps " of "; ppType env ppstrm (BT.domain typ))
631 :     else ()
632 :     end)
633 :     in if !internals
634 : macqueen 1344 then (openHVBox 0;
635 : blume 902 pps "type "; ppTycon env ppstrm tyc;
636 : macqueen 1344 closeBox())
637 : blume 902 else
638 :     case tyc of
639 :     T.GENtyc { path, arity, eq, kind, ... } =>
640 :     (case (!eq, kind) of
641 :     (T.ABS, _) =>
642 :     (* abstype *)
643 : macqueen 1344 (openHVBox 0;
644 : blume 902 pps "type";
645 :     ppFormals ppstrm arity;
646 :     pps " ";
647 :     ppSym ppstrm (IP.last path);
648 : macqueen 1344 closeBox())
649 : blume 902 | (_, T.DATATYPE{index,family={members,...},...}) =>
650 :     (* ordinary datatype *)
651 :     let val {dcons,...} = Vector.sub(members,index)
652 :     val visdcons = visibleDcons(tyc,dcons)
653 :     val incomplete = length visdcons < length dcons
654 :     in
655 : macqueen 1344 openHVBox 0;
656 : blume 902 pps "datatype";
657 :     ppFormals ppstrm arity;
658 :     pps " ";
659 :     ppSym ppstrm (IP.last path);
660 :     case visdcons
661 :     of nil => pps " = ..."
662 :     | first :: rest =>
663 : macqueen 1344 (break{nsp=1,offset=2};
664 :     openHVBox 0;
665 : blume 902 pps "= "; ppDcon first;
666 : macqueen 1344 app (fn d => (break{nsp=1,offset=0}; pps "| "; ppDcon d))
667 : blume 902 rest;
668 :     if incomplete
669 : macqueen 1344 then (break{nsp=1,offset=0}; pps "... ")
670 : blume 902 else ();
671 : macqueen 1344 closeBox());
672 :     closeBox()
673 : blume 902 end
674 :     | _ =>
675 : macqueen 1344 (openHVBox 0;
676 : blume 902 if EqTypes.isEqTycon tyc
677 :     then pps "eqtype"
678 :     else pps "type";
679 :     ppFormals ppstrm arity;
680 :     pps " ";
681 :     ppSym ppstrm (IP.last path);
682 : macqueen 1344 closeBox()))
683 : blume 902 | T.DEFtyc{path,tyfun=T.TYFUN{arity,body},...} =>
684 : macqueen 1344 (openHOVBox 2;
685 : blume 902 pps "type";
686 :     ppFormals ppstrm arity;
687 : macqueen 1344 break{nsp=1,offset=0};
688 : blume 902 ppSym ppstrm (InvPath.last path);
689 :     pps " =";
690 : macqueen 1344 break{nsp=1,offset=0};
691 : blume 902 ppType env ppstrm body;
692 : macqueen 1344 closeBox ())
693 : blume 902 | tycon =>
694 :     (pps "strange tycon: ";
695 :     ppTycon env ppstrm tycon)
696 :     end (* ppTycBind *)
697 :    
698 : macqueen 1344 and ppReplBind ppstrm
699 :     (T.DEFtyc{tyfun=T.TYFUN{body=T.CONty(rightTyc,_),...},path,...},env) =
700 : blume 2222 let val {openHVBox, openHOVBox,closeBox,pps,ppi,break,newline} = en_pp ppstrm
701 : macqueen 1344 in openHOVBox 2;
702 :     pps "datatype"; break{nsp=1,offset=0};
703 :     ppSym ppstrm (IP.last path);
704 :     pps " ="; break{nsp=1,offset=0};
705 :     pps "datatype"; break{nsp=1,offset=0};
706 :     ppTycon env ppstrm rightTyc;
707 :     closeBox ()
708 :     end
709 :     | ppReplBind _ _ = ErrorMsg.impossible "ppReplBind"
710 :    
711 : blume 902 and ppEntity ppstrm (entity,env,depth) =
712 :     case entity
713 :     of M.TYCent tycon => ppTycon env ppstrm tycon
714 :     | M.STRent strEntity => ppStrEntity ppstrm (strEntity,env,depth-1)
715 :     | M.FCTent fctEntity => ppFctEntity ppstrm (fctEntity,env,depth-1)
716 : macqueen 1344 | M.ERRORent => pps ppstrm "ERRORent"
717 : blume 902
718 :     and ppEntityEnv ppstrm (entEnv,env,depth) =
719 :     if depth <= 1
720 : macqueen 1344 then pps ppstrm "<entityEnv>"
721 : blume 902 else (ppvseq ppstrm 2 ""
722 :     (fn ppstrm => fn (entVar,entity) =>
723 : blume 2222 let val {openHVBox,openHOVBox,closeBox,pps,ppi,break,newline} =
724 : blume 902 en_pp ppstrm
725 : macqueen 1344 in openHVBox 2;
726 : blume 902 pps (EntPath.entVarToString entVar);
727 :     pps ":";
728 :     nl_indent ppstrm 2;
729 :     ppEntity ppstrm (entity,env,depth-1);
730 : macqueen 1344 newline();
731 :     closeBox()
732 : blume 902 end)
733 :     (EE.toList entEnv))
734 :    
735 :     and ppEntDec ppstrm (entDec,depth) =
736 : macqueen 1344 if depth <= 0 then pps ppstrm "<entDec>"
737 : blume 902 else case entDec
738 :     of M.TYCdec(entVar,tycExp) =>
739 : macqueen 1344 (pps ppstrm "ED.T: ";
740 :     ppEntVar ppstrm entVar; break ppstrm {nsp=1,offset=1};
741 : blume 902 ppTycExp ppstrm (tycExp,depth-1))
742 :     | M.STRdec(entVar,strExp,sym) =>
743 : macqueen 1344 (pps ppstrm "ED.S: ";
744 :     ppEntVar ppstrm entVar; break ppstrm {nsp=1,offset=1};
745 :     ppStrExp ppstrm (strExp,depth-1); break ppstrm {nsp=1,offset=1};
746 : blume 902 ppSym ppstrm sym)
747 :     | M.FCTdec(entVar,fctExp) =>
748 : macqueen 1344 (pps ppstrm "ED.F: ";
749 :     ppEntVar ppstrm entVar; break ppstrm {nsp=1,offset=1};
750 : blume 902 ppFctExp ppstrm (fctExp,depth-1))
751 :     | M.SEQdec entityDecs =>
752 :     ppvseq ppstrm 0 ""
753 :     (fn ppstrm => fn entDec => ppEntDec ppstrm (entDec,depth))
754 :     entityDecs
755 : macqueen 1344 | M.LOCALdec(entityDecL,entityDecB) => pps ppstrm "ED.L:"
756 :     | M.ERRORdec => pps ppstrm "ED.ER:"
757 :     | M.EMPTYdec => pps ppstrm "ED.EM:"
758 : blume 902
759 :     and ppStrExp ppstrm (strExp,depth) =
760 : macqueen 1344 if depth <= 0 then pps ppstrm "<strExp>" else
761 : blume 902 case strExp
762 :     of M.VARstr ep =>
763 : macqueen 1344 (pps ppstrm "SE.V:"; break ppstrm {nsp=1,offset=1};
764 : blume 902 ppEntPath ppstrm ep)
765 :     | M.CONSTstr { stamp, rpath, ... } =>
766 : macqueen 1344 (pps ppstrm "SE.C:"; break ppstrm {nsp=1,offset=1};
767 : blume 902 ppInvPath ppstrm rpath)
768 :     | M.STRUCTURE{stamp,entDec} =>
769 : macqueen 1344 (pps ppstrm "SE.S:"; break ppstrm {nsp=1,offset=1};
770 : blume 902 ppEntDec ppstrm (entDec,depth-1))
771 :     | M.APPLY(fctExp,strExp) =>
772 : macqueen 1344 (openHVBox ppstrm (PP.Rel 0);
773 :     pps ppstrm "SE.AP:"; break ppstrm {nsp=1,offset=1};
774 :     openHVBox ppstrm (PP.Rel 0);
775 :     pps ppstrm "fct:"; ppFctExp ppstrm (fctExp, depth -1);
776 :     break ppstrm {nsp=1,offset=0};
777 :     pps ppstrm "arg:"; ppStrExp ppstrm (strExp, depth -1);
778 :     closeBox ppstrm;
779 :     closeBox ppstrm)
780 : blume 902 | M.LETstr(entDec,strExp) =>
781 : macqueen 1344 (openHVBox ppstrm (PP.Rel 0);
782 :     pps ppstrm "SE.L:"; break ppstrm {nsp=1,offset=1};
783 :     openHVBox ppstrm (PP.Rel 0);
784 :     pps ppstrm "let:"; ppEntDec ppstrm (entDec,depth-1);
785 :     break ppstrm {nsp=1,offset=0};
786 :     pps ppstrm "in:"; ppStrExp ppstrm (strExp, depth -1);
787 :     closeBox ppstrm;
788 :     closeBox ppstrm)
789 : blume 902 | M.ABSstr(sign,strExp) =>
790 : macqueen 1344 (openHVBox ppstrm (PP.Rel 0);
791 :     pps ppstrm "SE.AB:"; break ppstrm {nsp=1,offset=1};
792 :     openHVBox ppstrm (PP.Rel 0);
793 :     pps ppstrm "sign: <omitted>";
794 :     break ppstrm {nsp=1,offset=0};
795 :     pps ppstrm "sexp:"; ppStrExp ppstrm (strExp, depth -1);
796 :     closeBox ppstrm;
797 :     closeBox ppstrm)
798 : blume 902 | M.CONSTRAINstr{boundvar,raw,coercion} =>
799 : macqueen 1344 (openHVBox ppstrm (PP.Rel 0);
800 :     pps ppstrm "SE.CO:"; break ppstrm {nsp=1,offset=1};
801 :     openHVBox ppstrm (PP.Rel 0);
802 :     ppEntVar ppstrm boundvar; break ppstrm {nsp=1,offset=1};
803 :     pps ppstrm "src:"; ppStrExp ppstrm (raw, depth -1);
804 :     break ppstrm {nsp=1,offset=0};
805 :     pps ppstrm "tgt:"; ppStrExp ppstrm (coercion, depth -1);
806 :     closeBox ppstrm;
807 :     closeBox ppstrm)
808 :     | M.FORMstr(sign) => pps ppstrm "SE.FM:"
809 : blume 902
810 :     and ppFctExp ppstrm (fctExp,depth) =
811 : macqueen 1344 if depth <= 0 then pps ppstrm "<fctExp>" else
812 : blume 902 case fctExp
813 :     of M.VARfct ep =>
814 : macqueen 1344 (pps ppstrm "FE.V:"; ppEntPath ppstrm ep)
815 : blume 902 | M.CONSTfct { rpath, ... } =>
816 : macqueen 1344 (pps ppstrm "FE.C:"; ppInvPath ppstrm rpath)
817 : blume 902 | M.LAMBDA_TP {param, body, ...} =>
818 : macqueen 1344 (openHVBox ppstrm (PP.Rel 0);
819 :     pps ppstrm "FE.LP:"; break ppstrm {nsp=1,offset=1};
820 :     openHVBox ppstrm (PP.Rel 0);
821 :     pps ppstrm "par:"; ppEntVar ppstrm param;
822 :     break ppstrm {nsp=1,offset=0};
823 :     pps ppstrm "bod:"; ppStrExp ppstrm (body, depth-1);
824 :     closeBox ppstrm;
825 :     closeBox ppstrm)
826 : blume 902 | M.LAMBDA {param, body} =>
827 : macqueen 1344 (openHVBox ppstrm (PP.Rel 0);
828 :     pps ppstrm "FE.L:"; break ppstrm {nsp=1,offset=1};
829 :     openHVBox ppstrm (PP.Rel 0);
830 :     pps ppstrm "par:"; ppEntVar ppstrm param;
831 :     break ppstrm {nsp=1,offset=0};
832 :     pps ppstrm "bod:"; ppStrExp ppstrm (body, depth-1);
833 :     closeBox ppstrm;
834 :     closeBox ppstrm)
835 : blume 902 | M.LETfct (entDec,fctExp) =>
836 : macqueen 1344 (openHVBox ppstrm (PP.Rel 0);
837 :     pps ppstrm "FE.LT:"; break ppstrm {nsp=1,offset=1};
838 :     openHVBox ppstrm (PP.Rel 0);
839 :     pps ppstrm "let:"; ppEntDec ppstrm (entDec,depth-1);
840 :     break ppstrm {nsp=1,offset=0};
841 :     pps ppstrm "in:"; ppFctExp ppstrm (fctExp, depth -1);
842 :     closeBox ppstrm;
843 :     closeBox ppstrm)
844 : blume 902
845 :     (*
846 :     and ppBodyExp ppstrm (bodyExp,depth) =
847 : macqueen 1344 if depth <= 0 then pps ppstrm "<bodyExp>" else
848 : blume 902 case bodyExp
849 : macqueen 1344 of M.FLEX sign => pps ppstrm "BE.F:"
850 : blume 902 | M.OPAQ (sign,strExp) =>
851 : macqueen 1344 (openHVBox ppstrm (PP.Rel 0);
852 :     pps ppstrm "BE.O:"; break ppstrm {nsp=1,offset=1};
853 : blume 902 ppStrExp ppstrm (strExp,depth-1);
854 : macqueen 1344 closeBox ppstrm)
855 : blume 902 | M.TNSP (sign,strExp) =>
856 : macqueen 1344 (openHVBox ppstrm (PP.Rel 0);
857 :     pps ppstrm "BE.T:"; break ppstrm {nsp=1,offset=1};
858 : blume 902 ppStrExp ppstrm (strExp,depth-1);
859 : macqueen 1344 closeBox ppstrm)
860 : blume 902
861 :     *)
862 :    
863 :     and ppClosure ppstrm (M.CLOSURE{param,body,env},depth) =
864 : macqueen 1344 let val {openHVBox, openHOVBox,closeBox,pps,newline,break,...} = en_pp ppstrm
865 :     in openHVBox 0;
866 :     pps "CL:"; break{nsp=1,offset=1};
867 :     openHVBox 0;
868 :     pps "param: "; ppEntVar ppstrm param; newline();
869 :     pps "body: "; ppStrExp ppstrm (body,depth-1); newline();
870 : blume 902 pps "env: "; ppEntityEnv ppstrm (env,SE.empty,depth-1);
871 : macqueen 1344 closeBox();
872 :     closeBox()
873 : blume 902 end
874 :    
875 :     (* assumes no newline is needed before pping *)
876 :     and ppBinding ppstrm (name,binding:B.binding,env:SE.staticEnv,depth:int) =
877 :     case binding
878 :     of B.VALbind var => (pps ppstrm "val "; ppVariable ppstrm (var,env))
879 :     | B.CONbind con => ppConBinding ppstrm (con,env)
880 :     | B.TYCbind tycon => ppTycBind ppstrm (tycon,env)
881 :     | B.SIGbind sign =>
882 : blume 2222 let val {openHVBox,openHOVBox,closeBox,pps,ppi,break,...} = en_pp ppstrm
883 : macqueen 1344 in openHVBox 0;
884 : blume 902 pps "signature "; ppSym ppstrm name; pps " =";
885 : macqueen 1344 break{nsp=1,offset=2};
886 : blume 902 ppSignature0 ppstrm (sign,env,depth,NONE);
887 : macqueen 1344 closeBox()
888 : blume 902 end
889 :     | B.FSGbind fs =>
890 : macqueen 1344 let val {openHVBox,openHOVBox,closeBox,pps,...} = en_pp ppstrm
891 :     in openHVBox 2;
892 : blume 902 pps "funsig "; ppSym ppstrm name;
893 :     ppFunsig ppstrm (fs,env,depth);
894 : macqueen 1344 closeBox()
895 : blume 902 end
896 :     | B.STRbind str =>
897 : blume 2222 let val {openHVBox, openHOVBox,closeBox,pps,ppi,break,...} = en_pp ppstrm
898 : macqueen 1344 in openHVBox 0;
899 : blume 902 pps "structure "; ppSym ppstrm name; pps " :";
900 : macqueen 1344 break{nsp=1,offset=2};
901 : blume 902 ppStructure ppstrm (str,env,depth);
902 : macqueen 1344 closeBox()
903 : blume 902 end
904 :     | B.FCTbind fct =>
905 : macqueen 1344 let val {openHVBox,openHOVBox,closeBox,pps,...} = en_pp ppstrm
906 :     in openHVBox 0;
907 : blume 902 pps "functor ";
908 :     ppSym ppstrm name;
909 :     pps " : <sig>"; (* DBM -- should print the signature *)
910 : macqueen 1344 closeBox()
911 : blume 902 end
912 :     | B.FIXbind fixity =>
913 :     (pps ppstrm (Fixity.fixityToString fixity); ppSym ppstrm name)
914 :    
915 :     (* ppEnv: pp an environment in the context of the top environment.
916 :     The environment must either be for a signature or be absolute (i.e.
917 :     all types and structures have been interpreted) *)
918 :     (* Note: I make a preliminary pass over bindings to remove
919 :     invisible ConBindings -- Konrad.
920 :     and invisible structures too -- PC *)
921 :     and ppEnv ppstrm (env,topenv,depth,boundsyms) =
922 :     let val bindings =
923 :     case boundsyms
924 :     of NONE => SE.sort env
925 :     | SOME l => foldr (fn (x,bs) =>
926 :     ((x,SE.look(env,x))::bs
927 :     handle SE.Unbound => bs))
928 :     [] l
929 :     val pp_env = StaticEnv.atop(env,topenv)
930 :     in ppSequence ppstrm
931 : macqueen 1344 {sep=newline,
932 : blume 902 pr=(fn ppstrm => fn (name,binding) =>
933 :     ppBinding ppstrm (name,binding,pp_env,depth)),
934 :     style=CONSISTENT}
935 :     (all_ppable_bindings bindings pp_env)
936 :     end
937 :    
938 :     fun ppOpen ppstrm (path,str,env,depth) =
939 : blume 2222 let val {openHVBox,openHOVBox,closeBox,pps,ppi,break,newline} = en_pp ppstrm
940 : macqueen 1344 in openHVBox 0;
941 :     openHVBox 2;
942 :     pps "opening ";
943 : blume 902 ppSymPath ppstrm path;
944 :     if depth < 1 then ()
945 :     else (case str
946 :     of M.STR { sign, rlzn as {entities,...}, ... } =>
947 :     (case sign
948 :     of M.SIG {elements = [],...} => ()
949 :     | M.SIG {elements,...} =>
950 : macqueen 1344 (newline ();
951 :     openHVBox 0;
952 : blume 902 ppElements (SE.atop(sigToEnv sign, env),
953 :     depth,SOME entities)
954 :     ppstrm elements;
955 : macqueen 1344 closeBox ())
956 : blume 902 | M.ERRORsig => ())
957 :     | M.ERRORstr => ()
958 :     | M.STRSIG _ => bug "ppOpen");
959 : macqueen 1344 closeBox ();
960 :     newline();
961 :     closeBox ()
962 : blume 902 end
963 :    
964 :     fun ppSignature ppstrm (sign,env,depth) =
965 :     ppSignature0 ppstrm (sign,env,depth,NONE)
966 :    
967 :     end (* local *)
968 :     end (* structure PPModules *)

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