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
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
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 [];;
;;
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:
(function () ->
- let filename = Getter.getxml uri in
+ let filename = Http_getter.getxml' uri in
let bodyfilename =
match UriManager.bodyuri_of_uri uri with
None -> None
| Some bodyuri ->
try
- ignore (Getter.resolve bodyuri) ;
+ ignore (Http_getter.resolve' bodyuri) ;
(* The body exists ==> it is not an axiom *)
- Some (Getter.getxml bodyuri)
+ Some (Http_getter.getxml' bodyuri)
with
- Getter.Unresolved ->
+ Http_getter_types.Unresolvable_URI _ ->
(* The body does not exist ==> we consider it an axiom *)
None
in
Cache.unchecked_to_frozen uri ;
if trust && trust_obj uri then
begin
- Logger.log (`Trusting uri) ;
+ CicLogger.log (`Trusting uri) ;
set_type_checking_info uri ;
CheckedObj (Cache.find_cooked uri)
end
Cic.InductiveDefinition _ -> Cache.add_cooked uri obj
| _ -> raise OnlyPutOfInductiveDefinitionsIsAllowed
;;
+
+let in_cache uri =
+ try
+ ignore (Cache.find_cooked uri);true
+ with Not_found -> false
+;;
projects / helm.git / blobdiff