added support for dump/restore/clear proof checker cache

diff --git a/helm/ocaml/cic_proof_checking/cicEnvironment.ml b/helm/ocaml/cic_proof_checking/cicEnvironment.ml
index 823aa3a40880b8500f6723fad1a8bfc76361ecff..f63b1618c5e6f4db654571a08ea7ddf8829cd1a8 100644 (file)
--- a/helm/ocaml/cic_proof_checking/cicEnvironment.ml
+++ b/helm/ocaml/cic_proof_checking/cicEnvironment.ml
@@ -62,6 +62,10 @@ module Cache :
     uri:UriManager.uri -> unit
    val find_cooked : key:UriManager.uri -> Cic.obj
    val add_cooked : key:UriManager.uri -> Cic.obj -> unit
+
+   val dump_to_channel : ?callback:(string -> unit) -> out_channel -> unit
+   val restore_from_channel : ?callback:(string -> unit) -> in_channel -> unit
+   val empty : unit -> unit
   end 
 =
   struct
@@ -70,6 +74,11 @@ module Cache :
      val mem  : UriManager.uri -> bool
      val find : UriManager.uri -> Cic.obj
      val add  : UriManager.uri -> Cic.obj -> unit
+
+      (** (de)serialization of type checker cache *)
+     val dump_to_channel : ?callback:(string -> unit) -> out_channel -> unit
+     val restore_from_channel : ?callback:(string -> unit) -> in_channel -> unit
+     val empty : unit -> unit
     end
    =
     struct
@@ -93,6 +102,153 @@ module Cache :
      let add uri obj =
       HT.add hashtable uri obj
      ;;
+
+      (* used to hash cons uris on restore to grant URI structure unicity *)
+     let restore_uris =
+       let module C = Cic in
+       let recons uri =
+         UriManager.uri_of_string (UriManager.string_of_uri uri)
+       in
+       let rec restore_in_term =
+         function
+            (C.Rel _) as t -> t
+          | C.Var (uri,exp_named_subst) ->
+             let uri' = recons uri in
+             let exp_named_subst' =
+              List.map
+               (function (uri,t) ->(recons uri,restore_in_term t)) exp_named_subst
+             in
+              C.Var (uri',exp_named_subst')
+          | C.Meta (i,l) ->
+             let l' =
+              List.map
+               (function
+                   None -> None
+                 | Some t -> Some (restore_in_term t)
+               ) l
+             in
+              C.Meta(i,l')
+          | C.Sort _ as t -> t
+          | C.Implicit as t -> t
+          | C.Cast (te,ty) -> C.Cast (restore_in_term te, restore_in_term ty)
+          | C.Prod (n,s,t) -> C.Prod (n, restore_in_term s, restore_in_term t)
+          | C.Lambda (n,s,t) -> C.Lambda (n, restore_in_term s, restore_in_term t)
+          | C.LetIn (n,s,t) -> C.LetIn (n, restore_in_term s, restore_in_term t)
+          | C.Appl l -> C.Appl (List.map restore_in_term l)
+          | C.Const (uri,exp_named_subst) ->
+             let uri' = recons uri in
+             let exp_named_subst' = 
+              List.map
+               (function (uri,t) -> (recons uri,restore_in_term t)) exp_named_subst
+             in
+              C.Const (uri',exp_named_subst')
+          | C.MutInd (uri,tyno,exp_named_subst) ->
+             let uri' = recons uri in
+             let exp_named_subst' = 
+              List.map
+               (function (uri,t) -> (recons uri,restore_in_term t)) exp_named_subst
+             in
+              C.MutInd (uri',tyno,exp_named_subst')
+          | C.MutConstruct (uri,tyno,consno,exp_named_subst) ->
+             let uri' = recons uri in
+             let exp_named_subst' = 
+              List.map
+               (function (uri,t) -> (recons uri,restore_in_term t)) exp_named_subst
+             in
+              C.MutConstruct (uri',tyno,consno,exp_named_subst')
+          | C.MutCase (uri,i,outty,t,pl) ->
+             C.MutCase (recons uri, i, restore_in_term outty, restore_in_term t,
+              List.map restore_in_term pl)
+          | C.Fix (i, fl) ->
+             let len = List.length fl in
+             let liftedfl =
+              List.map
+               (fun (name, i, ty, bo) ->
+                 (name, i, restore_in_term ty, restore_in_term bo))
+                fl
+             in
+              C.Fix (i, liftedfl)
+          | C.CoFix (i, fl) ->
+             let len = List.length fl in
+             let liftedfl =
+              List.map
+               (fun (name, ty, bo) -> (name, restore_in_term ty, restore_in_term bo))
+                fl
+             in
+              C.CoFix (i, liftedfl)
+       in
+       function
+          C.Constant (name,bo,ty,params) ->
+            let bo' =
+              match bo with
+                None -> None
+              | Some bo -> Some (restore_in_term bo)
+            in
+            let ty' = restore_in_term ty in
+            let params' = List.map recons params in
+            C.Constant (name, bo', ty', params')
+        | C.CurrentProof (name,conjs,bo,ty,params) ->
+            let conjs' =
+              List.map
+                (function (i,hyps,ty) ->
+                  (i,
+                  List.map (function
+                      None -> None
+                    | Some (name,C.Decl t) ->
+                        Some (name,C.Decl (restore_in_term t))
+                    | Some (name,C.Def (bo,ty)) ->
+                        let ty' =
+                          match ty with
+                            None -> None
+                          | Some ty'' -> Some (restore_in_term ty'')
+                        in
+                        Some (name,C.Def (restore_in_term bo, ty'))) hyps,
+                  restore_in_term ty))
+                conjs
+            in
+            let bo' = restore_in_term bo in
+            let ty' = restore_in_term ty in
+            let params' = List.map recons params in
+            C.CurrentProof (name, conjs', bo', ty', params')
+        | C.Variable (name,bo,ty,params) ->
+            let bo' =
+              match bo with
+                None -> None
+              | Some bo -> Some (restore_in_term bo)
+            in
+            let ty' = restore_in_term ty in
+            let params' = List.map recons params in
+            C.Variable (name, bo', ty', params')
+        | C.InductiveDefinition (tl,params,paramsno) ->
+            let params' = List.map recons params in
+            let tl' =
+              List.map (function (name, inductive, ty, constructors) ->
+                name,
+                inductive,
+                restore_in_term ty,
+                (List.map
+                  (function (name, ty) -> name, restore_in_term ty)
+                  constructors))
+                tl
+            in
+            C.InductiveDefinition (tl', params', paramsno)
+
+     let dump_to_channel ?(callback = ignore) oc =
+       HT.iter (fun uri _ -> callback (UriManager.string_of_uri uri)) hashtable;
+       Marshal.to_channel oc hashtable [] ;;
+     let empty () = HT.clear hashtable ;;
+     let restore_from_channel ?(callback = ignore) ic =
+       let restored = Marshal.from_channel ic in
+       empty ();
+       HT.iter
+        (fun k v ->
+          callback (UriManager.string_of_uri k);
+          HT.add hashtable
+            (UriManager.uri_of_string (UriManager.string_of_uri k))
+            (restore_uris v))
+        restored
+     ;;
+
     end
    ;;
    let frozen_list = ref [];;
@@ -132,9 +288,17 @@ module Cache :
    ;;
    let find_cooked ~key:uri = CacheOfCookedObjects.find uri;;
    let add_cooked ~key:uri obj = CacheOfCookedObjects.add uri obj;;
+
+   let dump_to_channel = CacheOfCookedObjects.dump_to_channel;;
+   let restore_from_channel = CacheOfCookedObjects.restore_from_channel;;
+   let empty = CacheOfCookedObjects.empty;;
   end
 ;;
 
+let dump_to_channel = Cache.dump_to_channel;;
+let restore_from_channel = Cache.restore_from_channel;;
+let empty = Cache.empty;;
+
 let find_or_add_unchecked_to_cache uri =
  Cache.find_or_add_unchecked uri
   ~get_object_to_add:

diff --git a/helm/ocaml/cic_proof_checking/cicEnvironment.mli b/helm/ocaml/cic_proof_checking/cicEnvironment.mli
index e93db958210ef5fa820d502f4317d2567f868a6c..99244f47f7c25e2bef0efe258507c9e5b49b81c0 100644 (file)
--- a/helm/ocaml/cic_proof_checking/cicEnvironment.mli
+++ b/helm/ocaml/cic_proof_checking/cicEnvironment.mli
@@ -77,3 +77,9 @@ exception OnlyPutOfInductiveDefinitionsIsAllowed
 (* WARNING: VERY UNSAFE.                                                 *)
 (* This function should be called only on a well-typed definition.       *)
 val put_inductive_definition : UriManager.uri -> Cic.obj -> unit
+
+(* (de)serialization *)
+val dump_to_channel : ?callback:(string -> unit) -> out_channel -> unit
+val restore_from_channel : ?callback:(string -> unit) -> in_channel -> unit
+val empty : unit -> unit
+