let cleanup_tmp = true;;
let trust_obj = function uri -> true;;
+(*let trust_obj = function uri -> false;;*)
type type_checked_obj =
CheckedObj of Cic.obj (* cooked obj *)
exception CircularDependency of string;;
exception CouldNotFreeze of string;;
exception CouldNotUnfreeze of string;;
+exception Term_not_found of UriManager.uri;;
(* Cache that uses == instead of = for testing equality *)
(* Invariant: an object is always in at most one of the *)
uri:UriManager.uri -> unit
val find_cooked : key:UriManager.uri -> Cic.obj
val add_cooked : key:UriManager.uri -> Cic.obj -> unit
+ val remove: UriManager.uri -> 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
+ val remove : UriManager.uri -> 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
;;
+ let remove uri =
+ if mem uri then
+ HT.remove hashtable uri
+ else
+ raise (Term_not_found uri);
+ ;;
+
+ (* 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 remove uri =
+ if (!unchecked_list <> []) || (!frozen_list <> []) then
+ failwith "CicEnvironment.remove while type checking"
+ else
+ CacheOfCookedObjects.remove uri
+ ;;
+ 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.Key_not_found _ ->
(* The body does not exist ==> we consider it an axiom *)
None
in
- let obj = CicParser.obj_of_xml filename bodyfilename in
+ let cleanup () =
if cleanup_tmp then
begin
- Unix.unlink filename ;
+ if Sys.file_exists filename then Unix.unlink filename ;
match bodyfilename with
- Some f -> Unix.unlink f
+ Some f -> if Sys.file_exists f then Unix.unlink f
| None -> ()
end ;
+ in
+ CicUniv.directly_to_env_begin ();
+ let obj =
+ try
+ CicParser.obj_of_xml filename bodyfilename
+ with exn ->
+ cleanup ();
+ raise exn
+ in
+ CicUniv.directly_to_env_end ();
+ cleanup ();
obj
)
;;
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
+;;
+
+let add_type_checked_term uri obj =
+ match obj with
+ Cic.Constant (s,(Some bo),ty,ul) ->
+ Cache.add_cooked ~key:uri obj
+ | _ -> assert false
+ Cache.add_cooked
+;;
+
+let remove_term = Cache.remove
+