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

SCM Repository

[smlnj] Diff of /sml/trunk/src/cm/bootstrap/btcompile.sml
ViewVC logotype

Diff of /sml/trunk/src/cm/bootstrap/btcompile.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 448, Thu Oct 21 09:20:16 1999 UTC revision 569, Tue Mar 7 04:01:07 2000 UTC
# Line 6  Line 6 
6   *   *
7   * Author: Matthias Blume (blume@kurims.kyoto-u.ac.jp)   * Author: Matthias Blume (blume@kurims.kyoto-u.ac.jp)
8   *)   *)
9  functor BootstrapCompileFn (structure MachDepVC: MACHDEP_VC  local
                             val os: SMLofNJ.SysInfo.os_kind) :> sig  
     val make' : string option -> bool  
     val make : unit -> bool  
     val deliver' : string option -> bool  
     val deliver : unit -> bool  
     val reset : unit -> unit  
     val symval : string -> { get: unit -> int option, set: int option -> unit }  
 end = struct  
   
10      structure EM = GenericVC.ErrorMsg      structure EM = GenericVC.ErrorMsg
11      structure E = GenericVC.Environment      structure E = GenericVC.Environment
12      structure SE = GenericVC.CMStaticEnv      structure SE = GenericVC.CMStaticEnv
13      structure BE = GenericVC.BareEnvironment      structure BE = GenericVC.BareEnvironment
14      structure PS = GenericVC.PersStamps      structure PS = GenericVC.PersStamps
15      structure CoerceEnv = GenericVC.CoerceEnv      structure CoerceEnv = GenericVC.CoerceEnv
16        structure GG = GroupGraph
17        structure DG = DependencyGraph
18    in
19    functor BootstrapCompileFn (structure MachDepVC : MACHDEP_VC
20                                val os : SMLofNJ.SysInfo.os_kind
21                                val load_plugin : string -> bool) :> sig
22        val make' : string option -> bool
23        val make : unit -> bool
24        val reset : unit -> unit
25        val symval : string -> { get: unit -> int option, set: int option -> unit }
26    end = struct
27      structure SSV = SpecificSymValFn (structure MachDepVC = MachDepVC      structure SSV = SpecificSymValFn (structure MachDepVC = MachDepVC
28                                        val os = os)                                        val os = os)
29      structure P = OS.Path      structure P = OS.Path
30      structure F = OS.FileSys      structure F = OS.FileSys
31      structure BF = MachDepVC.Binfile      structure BF = MachDepVC.Binfile
32    
33        val arch = MachDepVC.architecture
34        val osname = FilenamePolicy.kind2name os
35        val archos = concat [arch, "-", osname]
36    
37        fun init_servers (GG.GROUP { grouppath, ... }) =
38            Servers.cmb { archos = archos,
39                          root = SrcPath.descr grouppath }
40    
41      structure Compile = CompileFn (structure MachDepVC = MachDepVC      structure Compile = CompileFn (structure MachDepVC = MachDepVC
42                                     fun compile_there _ = false)                                     val compile_there =
43                                           Servers.compile o SrcPath.descr)
44    
45      structure BFC = BfcFn (structure MachDepVC = MachDepVC)      structure BFC = BfcFn (structure MachDepVC = MachDepVC)
46    
47      (* instantiate Stabilize... *)      (* instantiate Stabilize... *)
48      structure Stabilize =      structure Stabilize =
49          StabilizeFn (fun destroy_state _ i = Compile.evict i          StabilizeFn (structure MachDepVC = MachDepVC
                      structure MachDepVC = MachDepVC  
50                       fun recomp gp g = let                       fun recomp gp g = let
51                           val { store, get } = BFC.new ()                           val { store, get } = BFC.new ()
52                             val _ = init_servers g
53                           val { group, ... } =                           val { group, ... } =
54                               Compile.newTraversal (fn _ => fn _ => (),                               Compile.newTraversal (fn _ => fn _ => (),
55                                                     store, g)                                                     store, g)
56                       in                       in
57                           case group gp of                           case Servers.withServers (fn () => group gp) of
58                               NONE => NONE                               NONE => NONE
59                             | SOME _ => SOME get                             | SOME _ => SOME get
60                       end                       end
61                       val getII = Compile.getII)                       val getII = Compile.getII)
62    
63        structure VerifyStable = VerStabFn (structure Stabilize = Stabilize)
64    
65      (* ... and Parse *)      (* ... and Parse *)
66      structure Parse = ParseFn (structure Stabilize = Stabilize      structure Parse = ParseFn (structure Stabilize = Stabilize
67                                   val evictStale = Compile.evictStale
68                                 fun pending () = SymbolMap.empty)                                 fun pending () = SymbolMap.empty)
69    
70      (* copying an input file to an output file safely... *)      fun mkBootList g = let
71      fun copyFile (oi, ci, oo, co, inp, outp, eof) (inf, outf) = let          fun listName p =
72          fun workIn is = let              case P.fromString p of
73              fun workOut os = let                  { vol = "", isAbs = false, arcs = _ :: arc1 :: arcn } => let
74                  val N = 4096                      fun win32name () =
75                  fun loop () =                          concat (arc1 ::
76                      if eof is then () else (outp (os, inp (is, N)); loop ())                                  foldr (fn (a, r) => "\\" :: a :: r) [] arcn)
             in  
                 loop ()  
             end  
77          in          in
78              SafeIO.perform { openIt = fn () => oo outf,                      case os of
79                               closeIt = co,                          SMLofNJ.SysInfo.WIN32 => win32name ()
80                               work = workOut,                        | _ => P.toString { isAbs = false, vol = "",
81                               cleanup = fn () =>                                            arcs = arc1 :: arcn }
                                  (F.remove outf handle _ => ()) }  
82          end          end
83                  | _ => raise Fail ("BootstrapCompile:listName: bad name: " ^ p)
84      in      in
85          SafeIO.perform { openIt = fn () => oi inf,          MkBootList.group listName g
                          closeIt = ci,  
                          work = workIn,  
                          cleanup = fn () => () }  
86      end      end
87    
88      val copyTextFile =      fun mk_compile { deliver, root, dirbase = dbopt, paranoid } = let
         copyFile (TextIO.openIn, TextIO.closeIn,  
                   AutoDir.openTextOut, TextIO.closeOut,  
                   TextIO.inputN, TextIO.output, TextIO.endOfStream)  
   
     val copyBinFile =  
         copyFile (BinIO.openIn, BinIO.closeIn,  
                   AutoDir.openBinOut, BinIO.closeOut,  
                   BinIO.inputN, BinIO.output, BinIO.endOfStream)  
   
     fun compile deliver dbopt = let  
89    
90          val dirbase = getOpt (dbopt, BtNames.dirbaseDefault)          val dirbase = getOpt (dbopt, BtNames.dirbaseDefault)
91          val pcmodespec = BtNames.pcmodespec          val pcmodespec = BtNames.pcmodespec
92          val initgspec = BtNames.initgspec          val initgspec = BtNames.initgspec
93          val maingspec = BtNames.maingspec          val maingspec = BtNames.maingspec
94    
95          val arch = MachDepVC.architecture          val bindir = concat [dirbase, BtNames.bin_infix, archos]
96          val osname = FilenamePolicy.kind2name os          val bootdir = concat [dirbase, BtNames.boot_infix, archos]
         val bindir = concat [dirbase, ".bin.", arch, "-", osname]  
         val bootdir = concat [dirbase, ".boot.", arch, "-", osname]  
   
         fun listName (p, copy) =  
             case P.fromString p of  
                 { vol = "", isAbs = false, arcs = arc0 :: arc1 :: arcn } => let  
                     fun win32name () =  
                         concat (arc1 ::  
                                 foldr (fn (a, r) => "\\" :: a :: r) [] arcn)  
                     fun doCopy () = let  
                         val bootpath =  
                             P.toString { isAbs = false, vol = "",  
                                          arcs = bootdir :: arc1 :: arcn }  
                     in  
                         copyBinFile (p, bootpath)  
                     end  
                 in  
                     if copy andalso arc0 = bindir then doCopy () else ();  
                     case os of  
                         SMLofNJ.SysInfo.WIN32 => win32name ()  
                       | _ => P.toString { isAbs = false, vol = "",  
                                           arcs = arc1 :: arcn }  
                 end  
               | _ => raise Fail "BootstrapCompile:listName: bad name"  
97    
98          val keep_going = #get StdConfig.keep_going ()          val keep_going = #get StdConfig.keep_going ()
99    
100          val ctxt = SrcPath.cwdContext ()          val ctxt = SrcPath.cwdContext ()
101    
102          val pidfile = P.joinDirFile { dir = bootdir, file = "RTPID" }          val listfile = P.joinDirFile { dir = bootdir, file = BtNames.bootlist }
103          val listfile = P.joinDirFile { dir = bootdir, file = "BOOTLIST" }          val pidmapfile = P.joinDirFile { dir = bootdir, file = BtNames.pidmap }
104    
105          val pcmode = PathConfig.new ()          val pcmode = PathConfig.new ()
106          val _ = PathConfig.processSpecFile (pcmode, pcmodespec)          val _ = PathConfig.processSpecFile (pcmode, pcmodespec)
# Line 134  Line 108 
108          fun stdpath s = SrcPath.standard pcmode { context = ctxt, spec = s }          fun stdpath s = SrcPath.standard pcmode { context = ctxt, spec = s }
109    
110          val initgspec = stdpath initgspec          val initgspec = stdpath initgspec
111          val maingspec = stdpath maingspec          val maingspec =
112                case root of
113          val cmifile = valOf (SrcPath.reAnchoredName (initgspec, bootdir))                  NONE => stdpath maingspec
114              handle Option => raise Fail "BootstrapCompile: cmifile"                | SOME r => SrcPath.fromDescr pcmode r
115    
116          val fnpolicy =          val fnpolicy =
117              FilenamePolicy.separate { bindir = bindir, bootdir = bootdir }              FilenamePolicy.separate { bindir = bindir, bootdir = bootdir }
118                  { arch = arch, os = os }                  { arch = arch, os = os }
119    
120          fun mkParam { primconf, pervasive, pervcorepids }          fun mkParam corenv =
121                      { corenv } =              { fnpolicy = fnpolicy,
             { primconf = primconf,  
               fnpolicy = fnpolicy,  
122                pcmode = pcmode,                pcmode = pcmode,
123                symval = SSV.symval,                symval = SSV.symval,
124                keep_going = keep_going,                keep_going = keep_going,
125                pervasive = pervasive,                corenv = corenv }
               corenv = corenv,  
               pervcorepids = pervcorepids }  
126    
127          val emptydyn = E.dynamicPart E.emptyEnv          val emptydyn = E.dynamicPart E.emptyEnv
128    
129          (* first, build an initial GeneralParam.info, so we can          (* first, build an initial GeneralParam.info, so we can
130           * deal with the pervasive env and friends... *)           * deal with the pervasive env and friends... *)
131    
132          val primconf = Primitive.primEnvConf          val param_nocore = mkParam BE.emptyEnv
         val mkInitParam = mkParam { primconf = primconf,  
                                     pervasive = E.emptyEnv,  
                                     pervcorepids = PidSet.empty }  
   
         val param_nocore = mkInitParam { corenv = BE.staticPart BE.emptyEnv }  
133    
134          val groupreg = GroupReg.new ()          val groupreg = GroupReg.new ()
135          val errcons = EM.defaultConsumer ()          val errcons = EM.defaultConsumer ()
136          val ginfo_nocore = { param = param_nocore, groupreg = groupreg,          val ginfo_nocore = { param = param_nocore, groupreg = groupreg,
137                               errcons = errcons }                               errcons = errcons }
138    
139          fun main_compile arg = let          fun mk_main_compile arg = let
             val { rts, core, pervasive, primitives, binpaths } = arg  
140    
141                val { core = core_n, pervasive = perv_n, others, src } = arg
142    
143                fun recompInitGroup () = let
144              val ovldR = GenericVC.Control.overloadKW              val ovldR = GenericVC.Control.overloadKW
145              val savedOvld = !ovldR              val savedOvld = !ovldR
146              val _ = ovldR := true              val _ = ovldR := true
# Line 181  Line 148 
148    
149              (* here we build a new gp -- the one that uses the freshly              (* here we build a new gp -- the one that uses the freshly
150               * brewed pervasive env, core env, and primitives *)               * brewed pervasive env, core env, and primitives *)
151              val core = valOf (sbnode ginfo_nocore core)                  val core = valOf (sbnode ginfo_nocore core_n)
152              val corenv =  CoerceEnv.es2bs (#statenv (#ii core) ())                  val corenv =
153              val core_sym = #symenv (#ii core) ()                      BE.mkenv { static = CoerceEnv.es2bs
154                                              (#env (#statenv core ())),
155              (* The following is a bit of a hack (but corenv is a hack anyway):                                 symbolic = #symenv core (),
              * As soon as we have core available, we have to patch the  
              * ginfo to include the correct corenv (because virtually  
              * everybody else needs access to corenv). *)  
             val param_justcore = mkInitParam { corenv = corenv }  
             val ginfo_justcore = { param = param_justcore, groupreg = groupreg,  
                                    errcons = errcons }  
   
             fun rt n = valOf (sbnode ginfo_justcore n)  
             val rts = rt rts  
             val pervasive = rt pervasive  
   
             fun sn2pspec (name, n) = let  
                 val { ii = { statenv, symenv, statpid, sympid }, ctxt } = rt n  
                 val env =  
                     E.mkenv { static = statenv (),  
                               symbolic = symenv (),  
156                                dynamic = emptydyn }                                dynamic = emptydyn }
157                  val pidInfo =  
158                      { statpid = statpid, sympid = sympid, ctxt = ctxt }                  (* The following is a bit of a hack (but corenv is a hack
159                     * anyway): As soon as we have core available, we have to
160                     * patch the ginfo to include the correct corenv (because
161                     * virtually everybody else needs access to corenv). *)
162                    val param = mkParam corenv
163                    val ginfo =
164                        { param = param, groupreg = groupreg, errcons = errcons }
165    
166                    val perv_fsbnode = (NONE, perv_n)
167    
168                    fun rt n = valOf (sbnode ginfo n)
169                    val pervasive = rt perv_n
170    
171                    fun rt2ie (n, ii: IInfo.info) = let
172                        val bs = CoerceEnv.es2bs (#env (#statenv ii ()))
173                        val (dae, mkDomain) = Statenv2DAEnv.cvt bs
174                    in
175                        { ie = ((NONE, n), dae), mkDomain = mkDomain }
176                    end
177    
178                    fun add_exports (n, exports) = let
179                        val { ie, mkDomain } = rt2ie (n, rt n)
180                        fun ins_ie (sy, m) = SymbolMap.insert (m, sy, ie)
181              in              in
182                  { name = name, env = env, pidInfo = pidInfo }                      SymbolSet.foldl ins_ie exports (mkDomain ())
183              end              end
184    
185              val pspecs = map sn2pspec primitives                  val special_exports = let
186                        fun mkie (n, rtn) = #ie (rt2ie (n, rtn))
187                    in
188                        foldl SymbolMap.insert' SymbolMap.empty
189                           [(PervCoreAccess.pervStrSym, mkie (perv_n, pervasive)),
190                            (PervCoreAccess.coreStrSym, mkie (core_n, core))]
191                    end
192                in
193                    (GG.GROUP { exports = foldl add_exports special_exports others,
194                                kind = GroupGraph.LIB (StringSet.empty, []),
195                                required = StringSet.singleton "primitive",
196                                grouppath = initgspec,
197                                sublibs = [] },
198                     corenv)
199                    before (ovldR := savedOvld)
200                end
201    
202              val _ = ovldR := savedOvld              (* just go and load the stable init group or signal failure *)
203                fun loadInitGroup () = let
204              (* The following is a hack but must be done for both the symbolic                  val coresym = PervCoreAccess.coreStrSym
205               * and later the dynamic part of the core environment:                  val lsarg =
206               * we must include these parts in the pervasive env. *)                      { getGroup = fn _ => raise Fail "CMB: initial getGroup",
207              val perv_sym = E.layerSymbolic (#symenv (#ii pervasive) (),                        anyerrors = ref false }
                                             core_sym)  
   
             val param =  
                 mkParam { primconf = Primitive.configuration pspecs,  
                           pervasive = E.mkenv { static =  
                                                  #statenv (#ii pervasive) (),  
                                                 symbolic = perv_sym,  
                                                 dynamic = emptydyn },  
                           pervcorepids =  
                             PidSet.addList (PidSet.empty,  
                                             [#statpid (#ii pervasive),  
                                              #sympid (#ii pervasive),  
                                              #statpid (#ii core)]) }  
                         { corenv = corenv }  
             val stab =  
                 if deliver then SOME true else NONE  
208          in          in
209              case Parse.parse NONE param stab maingspec of                  case Stabilize.loadStable ginfo_nocore lsarg initgspec of
210                  NONE => false                      NONE => NONE
211                      | SOME (g as GG.GROUP { exports, ... }) =>
212                            (case SymbolMap.find (exports, coresym) of
213                                 SOME ((_, DG.SB_BNODE (_, ii)), _) => let
214                                     val stat = #env (#statenv ii ())
215                                     val sym = #symenv ii ()
216                                     val corenv =
217                                         BE.mkenv { static = CoerceEnv.es2bs stat,
218                                                    symbolic = sym,
219                                                    dynamic = emptydyn }
220                                 in
221                                     SOME (g, corenv)
222                                 end
223                               | _ => NONE)
224                end
225    
226                (* Don't try to load the stable init group. Instead, recompile
227                 * directly. *)
228                fun dontLoadInitGroup () = let
229                    val (g0, corenv) = recompInitGroup ()
230                    val stabarg = { group = g0, anyerrors = ref false }
231                in
232                    if deliver then
233                        case Stabilize.stabilize ginfo_nocore stabarg of
234                            SOME g => (g, corenv)
235                          | NONE => raise Fail "CMB: cannot stabilize init group"
236                    else (g0, corenv)
237                end
238    
239                (* Try loading the init group from the stable file if possible;
240                 * recompile if loading fails *)
241                fun tryLoadInitGroup () =
242                    case loadInitGroup () of
243                        SOME g => g
244                      | NONE => dontLoadInitGroup ()
245    
246                (* Ok, now, based on "paranoid" and stable verification,
247                 * call the appropriate function(s) to get the init group. *)
248                val (init_group, corenv) =
249                    if paranoid then let
250                        val export_nodes = core_n :: perv_n :: others
251                        val ver_arg = (initgspec, export_nodes, [],
252                                       SrcPathSet.empty)
253                        val em = StableMap.empty
254                    in
255                        if VerifyStable.verify' ginfo_nocore em ver_arg then
256                            tryLoadInitGroup ()
257                        else dontLoadInitGroup ()
258                    end
259                    else tryLoadInitGroup ()
260    
261                (* now we finally build the real param and ginfo that we can
262                 * use throughout the rest... *)
263                val param = mkParam corenv
264                val ginfo =
265                    { param = param, errcons = errcons, groupreg = groupreg }
266    
267                val stab = if deliver then SOME true else NONE
268    
269                val gr = GroupReg.new ()
270                val _ = GroupReg.register gr (initgspec, src)
271    
272                val parse_arg =
273                    { load_plugin = load_plugin,
274                      gr = gr,
275                      param = param,
276                      stabflag = stab,
277                      group = maingspec,
278                      init_group = init_group,
279                      paranoid = paranoid }
280            in
281                Servers.dirbase dirbase;
282                case Parse.parse parse_arg of
283                    NONE => NONE
284                | SOME (g, gp) => let                | SOME (g, gp) => let
285                        fun thunk () = let
286                            val _ = init_servers g
287                      fun store _ = ()                      fun store _ = ()
288                      val { group = recomp, ... } =                      val { group = recomp, ... } =
289                          Compile.newTraversal (fn _ => fn _ => (), store, g)                          Compile.newTraversal (fn _ => fn _ => (), store, g)
290                            val res =
291                                Servers.withServers (fn () => recomp gp)
292                  in                  in
293                      if isSome (recomp gp) then let                          if isSome res then let
294                          val rtspid = PS.toHex (#statpid (#ii rts))                              val { l = bootitems, ss } = mkBootList g
295                          fun writeList s = let                              val stablelibs = Reachable.stableLibsOf g
296                              fun add ((p, flag), l) = let                              fun inSet bi = StableSet.member (ss, bi)
297                                  val n = listName (p, true)                              val frontiers =
298                              in                                  SrcPathMap.map (Reachable.frontier inSet)
299                                  if flag then n :: l else l                                                 stablelibs
300                              end                              fun writeBootList s = let
301                              fun transcribe (p, NONE) = listName (p, true)                                  fun wr str = TextIO.output (s, str ^ "\n")
302                                | transcribe (p, SOME (off, desc)) =                                  val numitems = length bootitems
303                                  concat [listName (p, false),                                  fun biggerlen (s, n) = Int.max (size s, n)
304                                          "@", Int.toString off, ":", desc]                                  val maxlen = foldl biggerlen 0 bootitems
305                              val bootstrings =                              in
306                                  foldr add (map transcribe (MkBootList.group g))                                  wr (concat ["%", Int.toString numitems,
307                                        binpaths                                              " ", Int.toString maxlen]);
308                              fun show str =                                  app wr bootitems
309                                  (TextIO.output (s, str);                              end
310                                fun writePid s i = let
311                                    val sn = BinInfo.stablename i
312                                    val os = BinInfo.offset i
313                                    val descr = BinInfo.describe i
314                                    val bfc = BFC.getStable
315                                        { stable = sn, offset = os, descr = descr }
316                                in
317                                    case BF.exportPidOf bfc of
318                                        NONE => ()
319                                      | SOME pid =>
320                                            (TextIO.output (s, " ");
321                                             TextIO.output (s, PS.toHex pid))
322                                end
323                                fun writePidLine s (p, set) =
324                                    if StableSet.isEmpty set then ()
325                                    else (TextIO.output (s, SrcPath.descr p);
326                                          StableSet.app (writePid s) set;
327                                   TextIO.output (s, "\n"))                                   TextIO.output (s, "\n"))
328                          in                              fun writePidMap s =
329                              app show bootstrings                                  SrcPathMap.appi (writePidLine s) frontiers
                         end  
330                      in                      in
331                        if deliver then                        if deliver then
332                         (SafeIO.perform { openIt = fn () =>                                  (SafeIO.perform
333                                             AutoDir.openTextOut pidfile,                                   { openIt = fn () =>
                                          closeIt = TextIO.closeOut,  
                                          work = fn s =>  
                                            TextIO.output (s, rtspid ^ "\n"),  
                                          cleanup = fn () =>  
                                            OS.FileSys.remove pidfile  
                                            handle _ => () };  
                         SafeIO.perform { openIt = fn () =>  
334                                             AutoDir.openTextOut listfile,                                             AutoDir.openTextOut listfile,
335                                           closeIt = TextIO.closeOut,                                           closeIt = TextIO.closeOut,
336                                           work = writeList,                                     work = writeBootList,
337                                           cleanup = fn () =>                                     cleanup = fn _ =>
338                                             OS.FileSys.remove listfile                                             OS.FileSys.remove listfile
339                                             handle _ => () };                                             handle _ => () };
340                          copyTextFile (SrcPath.osstring initgspec, cmifile);                                   SafeIO.perform
341                          Say.say ["Runtime System PID is: ", rtspid, "\n"])                                   { openIt = fn () =>
342                                           AutoDir.openTextOut pidmapfile,
343                                       closeIt = TextIO.closeOut,
344                                       work = writePidMap,
345                                       cleanup = fn _ =>
346                                           OS.FileSys.remove pidmapfile
347                                           handle _ => () };
348                                     Say.say
349                                          ["New boot directory has been built.\n"])
350                        else ();                        else ();
351                        true                        true
352                      end                      end
353                      else false                      else false
354                  end                  end
355          end handle Option => (Compile.reset (); false)                  in
356                        SOME ((g, gp, pcmode), thunk)
357                    end
358            end handle Option => (Compile.reset (); NONE)
359                     (* to catch valOf failures in "rt" *)                     (* to catch valOf failures in "rt" *)
360      in      in
361          case BuildInitDG.build ginfo_nocore initgspec of          case BuildInitDG.build ginfo_nocore initgspec of
362              SOME x => main_compile x              SOME x => mk_main_compile x
363            | NONE => false            | NONE => NONE
364        end
365    
366        fun compile dbopt =
367            case mk_compile { deliver = true, root = NONE,
368                              dirbase = dbopt, paranoid = true } of
369                NONE => false
370              | SOME (_, thunk) => thunk ()
371    
372        local
373            fun slave (dirbase, root) =
374                case mk_compile { deliver = false, root = SOME root,
375                                  dirbase = SOME dirbase, paranoid = false } of
376                    NONE => NONE
377                  | SOME ((g, gp, pcmode), _) => let
378                        val trav = Compile.newSbnodeTraversal () gp
379                        fun trav' sbn = isSome (trav sbn)
380                    in
381                        SOME (g, trav', pcmode)
382                    end
383        in
384            val _ = CMBSlaveHook.init archos slave
385      end      end
386    
387      fun reset () =      fun reset () =
388          (Compile.reset ();          (Compile.reset ();
389           Parse.reset ())           Parse.reset ())
390    
391      val make' = compile false      val make' = compile
392      fun make () = make' NONE      fun make () = make' NONE
     fun deliver' arg =  
         SafeIO.perform { openIt = fn () => (),  
                          closeIt = reset,  
                          work = fn () => compile true arg,  
                          cleanup = fn () => () }  
     fun deliver () = deliver' NONE  
393      val symval = SSV.symval      val symval = SSV.symval
394  end  end
395    end (* local *)

Legend:
Removed from v.448  
changed lines
  Added in v.569

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