(* $Id$ *)
-open Printf
+module PEH = ProofEngineHelpers
exception Drop
(* mo file name, ma file name *)
clean_baseuri: bool
}
-(** create a ProofEngineTypes.mk_fresh_name_type function which uses given
- * names as long as they are available, then it fallbacks to name generation
- * using FreshNamesGenerator module *)
-let namer_of names =
- let len = List.length names in
- let count = ref 0 in
- fun metasenv context name ~typ ->
- if !count < len then begin
- let name = Cic.Name (List.nth names !count) in
- incr count;
- name
- end else
- FreshNamesGenerator.mk_fresh_name ~subst:[] metasenv context name ~typ
-
let rec tactic_of_ast status ast =
let module PET = ProofEngineTypes in
match ast with
Tactics.applyS ~term ~params ~dbd:(LibraryDb.instance ())
~universe:status.GrafiteTypes.universe
| GrafiteAst.Assumption _ -> Tactics.assumption
- | GrafiteAst.Auto (_,params) ->
- AutoTactic.auto_tac ~params ~dbd:(LibraryDb.instance ())
+ | GrafiteAst.AutoBatch (_,params) ->
+ Tactics.auto ~params ~dbd:(LibraryDb.instance ())
~universe:status.GrafiteTypes.universe
- | GrafiteAst.Cases (_, what, names) ->
- Tactics.cases_intros ~mk_fresh_name_callback:(namer_of names)
+ | GrafiteAst.Cases (_, what, (howmany, names)) ->
+ Tactics.cases_intros ?howmany ~mk_fresh_name_callback:(PEH.namer_of names)
what
| GrafiteAst.Change (_, pattern, with_what) ->
Tactics.change ~pattern with_what
| GrafiteAst.Clear (_,id) -> Tactics.clear id
| GrafiteAst.ClearBody (_,id) -> Tactics.clearbody id
+ | GrafiteAst.Compose (_,t1,t2,times,(howmany, names)) ->
+ Tactics.compose times t1 t2 ?howmany
+ ~mk_fresh_name_callback:(PEH.namer_of names)
| GrafiteAst.Contradiction _ -> Tactics.contradiction
| GrafiteAst.Constructor (_, n) -> Tactics.constructor n
| GrafiteAst.Cut (_, ident, term) ->
- let names = match ident with None -> [] | Some id -> [id] in
- Tactics.cut ~mk_fresh_name_callback:(namer_of names) term
+ let names = match ident with None -> [] | Some id -> [Some id] in
+ Tactics.cut ~mk_fresh_name_callback:(PEH.namer_of names) term
| GrafiteAst.Decompose (_, names) ->
- let mk_fresh_name_callback = namer_of names in
+ let mk_fresh_name_callback = PEH.namer_of names in
Tactics.decompose ~mk_fresh_name_callback ()
| GrafiteAst.Demodulate _ ->
Tactics.demodulate
~dbd:(LibraryDb.instance ()) ~universe:status.GrafiteTypes.universe
- | GrafiteAst.Destruct (_,term) -> Tactics.destruct term
- | GrafiteAst.Elim (_, what, using, pattern, depth, names) ->
- Tactics.elim_intros ?using ?depth ~mk_fresh_name_callback:(namer_of names)
+ | GrafiteAst.Destruct (_,xterm) -> Tactics.destruct xterm
+ | GrafiteAst.Elim (_, what, using, pattern, (depth, names)) ->
+ Tactics.elim_intros ?using ?depth ~mk_fresh_name_callback:(PEH.namer_of names)
~pattern what
- | GrafiteAst.ElimType (_, what, using, depth, names) ->
- Tactics.elim_type ?using ?depth ~mk_fresh_name_callback:(namer_of names)
+ | GrafiteAst.ElimType (_, what, using, (depth, names)) ->
+ Tactics.elim_type ?using ?depth ~mk_fresh_name_callback:(PEH.namer_of names)
what
| GrafiteAst.Exact (_, term) -> Tactics.exact term
| GrafiteAst.Exists _ -> Tactics.exists
Tactics.fold ~reduction ~term ~pattern
| GrafiteAst.Fourier _ -> Tactics.fourier
| GrafiteAst.FwdSimpl (_, hyp, names) ->
- Tactics.fwd_simpl ~mk_fresh_name_callback:(namer_of names)
+ Tactics.fwd_simpl ~mk_fresh_name_callback:(PEH.namer_of names)
~dbd:(LibraryDb.instance ()) hyp
| GrafiteAst.Generalize (_,pattern,ident) ->
- let names = match ident with None -> [] | Some id -> [id] in
- Tactics.generalize ~mk_fresh_name_callback:(namer_of names) pattern
+ let names = match ident with None -> [] | Some id -> [Some id] in
+ Tactics.generalize ~mk_fresh_name_callback:(PEH.namer_of names) pattern
| GrafiteAst.IdTac _ -> Tactics.id
- | GrafiteAst.Intros (_, None, names) ->
- PrimitiveTactics.intros_tac ~mk_fresh_name_callback:(namer_of names) ()
- | GrafiteAst.Intros (_, Some num, names) ->
- PrimitiveTactics.intros_tac ~howmany:num
- ~mk_fresh_name_callback:(namer_of names) ()
+ | GrafiteAst.Intros (_, (howmany, names)) ->
+ PrimitiveTactics.intros_tac ?howmany
+ ~mk_fresh_name_callback:(PEH.namer_of names) ()
| GrafiteAst.Inversion (_, term) ->
Tactics.inversion term
| GrafiteAst.LApply (_, linear, how_many, to_what, what, ident) ->
- let names = match ident with None -> [] | Some id -> [id] in
- Tactics.lapply ~mk_fresh_name_callback:(namer_of names)
+ let names = match ident with None -> [] | Some id -> [Some id] in
+ Tactics.lapply ~mk_fresh_name_callback:(PEH.namer_of names)
~linear ?how_many ~to_what what
| GrafiteAst.Left _ -> Tactics.left
| GrafiteAst.LetIn (loc,term,name) ->
- Tactics.letin term ~mk_fresh_name_callback:(namer_of [name])
+ Tactics.letin term ~mk_fresh_name_callback:(PEH.namer_of [Some name])
| GrafiteAst.Reduce (_, reduction_kind, pattern) ->
(match reduction_kind with
| `Normalize -> Tactics.normalize ~pattern
| GrafiteAst.Replace (_, pattern, with_what) ->
Tactics.replace ~pattern ~with_what
| GrafiteAst.Rewrite (_, direction, t, pattern, names) ->
- EqualityTactics.rewrite_tac ~direction ~pattern t names
+ EqualityTactics.rewrite_tac ~direction ~pattern t
+(* to be replaced with ~mk_fresh_name_callback:(PEH.namer_of names) *)
+ (List.map (function Some s -> s | None -> assert false) names)
| GrafiteAst.Right _ -> Tactics.right
| GrafiteAst.Ring _ -> Tactics.ring
| GrafiteAst.Split _ -> Tactics.split
- | GrafiteAst.Subst _ -> Tactics.subst
| GrafiteAst.Symmetry _ -> Tactics.symmetry
| GrafiteAst.Transitivity (_, term) -> Tactics.transitivity term
(* Implementazioni Aggiunte *)
let after = ProofEngineTypes.goals_of_proof proof in
let opened_goals, closed_goals = Tacticals.goals_diff ~before ~after ~opened in
let proof, opened_goals =
- let uri, metasenv_after_tactic, t, ty, attrs = proof in
+ let uri, metasenv_after_tactic, _subst, t, ty, attrs = proof in
let reordered_metasenv, opened_goals =
reorder_metasenv
starting_metasenv
metasenv_after_refinement metasenv_after_tactic
opened goal always_opens_a_goal
in
- let proof' = uri, reordered_metasenv, t, ty, attrs in
+ let proof' = uri, reordered_metasenv, _subst, t, ty, attrs in
proof', opened_goals
in
let incomplete_proof =
let after = ProofEngineTypes.goals_of_proof proof in
let opened_goals, closed_goals = Tacticals.goals_diff ~before ~after ~opened in
let proof, opened_goals =
- let uri, metasenv_after_tactic, t, ty, attrs = proof in
+ let uri, metasenv_after_tactic, _subst, t, ty, attrs = proof in
let reordered_metasenv, opened_goals =
reorder_metasenv
starting_metasenv
metasenv_after_refinement metasenv_after_tactic
opened goal always_opens_a_goal
in
- let proof' = uri, reordered_metasenv, t, ty, attrs in
+ let proof' = uri, reordered_metasenv, _subst, t, ty, attrs in
proof', opened_goals
in
let incomplete_proof =
type 'a eval_from_moo =
{ efm_go: GrafiteTypes.status -> string -> GrafiteTypes.status }
-let coercion_moo_statement_of (uri,arity) =
- GrafiteAst.Coercion (HExtlib.dummy_floc, uri, false, arity)
+let coercion_moo_statement_of (uri,arity, saturations) =
+ GrafiteAst.Coercion (HExtlib.dummy_floc, uri, false, arity, saturations)
let refinement_toolkit = {
RefinementTool.type_of_aux' =
RefinementTool.pack_coercion_obj = CicRefine.pack_coercion_obj;
}
-let eval_coercion status ~add_composites uri arity baseuri =
+let eval_coercion status ~add_composites uri arity saturations baseuri =
let status,compounds =
- GrafiteSync.add_coercion ~add_composites refinement_toolkit status uri arity
- baseuri
+ GrafiteSync.add_coercion ~add_composites refinement_toolkit status uri arity
+ saturations baseuri
in
let moo_content =
- List.map coercion_moo_statement_of ((uri,arity)::compounds)
+ List.map coercion_moo_statement_of ((uri,arity,saturations)::compounds)
in
let status = GrafiteTypes.add_moo_content moo_content status in
{status with GrafiteTypes.proof_status = GrafiteTypes.No_proof},
- List.map fst compounds
+ List.map (fun u,_,_ -> u) compounds
module MatitaStatus =
struct
in
let is_a_coercion, arity_coercion = is_a_coercion uri in
if is_a_coercion then
- Some (uri, coercion_moo_statement_of (uri,arity_coercion))
+ Some (uri, coercion_moo_statement_of (uri,arity_coercion,0))
else if is_a_wanted_coercion then
- Some (uri, coercion_moo_statement_of (uri,arity_wanted))
+ Some (uri, coercion_moo_statement_of (uri,arity_wanted,0))
else
None)
lemmas)
*)
let status = GrafiteTypes.add_moo_content [cmd] status in
status,[]
- | GrafiteAst.Coercion (loc, uri, add_composites, arity) ->
- eval_coercion status ~add_composites uri arity
+ | GrafiteAst.Coercion (loc, uri, add_composites, arity, saturations) ->
+ eval_coercion status ~add_composites uri arity saturations
(GrafiteTypes.get_string_option status "baseuri")
| GrafiteAst.Default (loc, what, uris) as cmd ->
LibraryObjects.set_default what uris;
*)
status,[]
| GrafiteAst.Print (_,"proofterm") ->
- let _,_,p,_, _ = GrafiteTypes.get_current_proof status in
- print_endline (AutoTactic.pp_proofterm p);
+ let _,_,_,p,_, _ = GrafiteTypes.get_current_proof status in
+ print_endline (Auto.pp_proofterm p);
status,[]
| GrafiteAst.Print (_,_) -> status,[]
| GrafiteAst.Qed loc ->
- let uri, metasenv, bo, ty, attrs =
+ let uri, metasenv, _subst, bo, ty, attrs =
match status.GrafiteTypes.proof_status with
- | GrafiteTypes.Proof (Some uri, metasenv, body, ty, attrs) ->
- uri, metasenv, body, ty, attrs
- | GrafiteTypes.Proof (None, metasenv, body, ty, attrs) ->
+ | GrafiteTypes.Proof (Some uri, metasenv, subst, body, ty, attrs) ->
+ uri, metasenv, subst, body, ty, attrs
+ | GrafiteTypes.Proof (None, metasenv, subst, body, ty, attrs) ->
raise (GrafiteTypes.Command_error
("Someone allows to start a theorem without giving the "^
"name/uri. This should be fixed!"))
with Not_found -> v
in
if Http_getter_storage.is_read_only value then begin
- HLog.error (sprintf "uri %s belongs to a read-only repository" value);
+ HLog.error (Printf.sprintf "uri %s belongs to a read-only repository" value);
raise (ReadOnlyUri value)
end;
- if not (Http_getter_storage.is_empty value) &&
- opts.clean_baseuri
+ if (not (Http_getter_storage.is_empty ~local:true value) ||
+ LibraryClean.db_uris_of_baseuri value <> [])
+ && opts.clean_baseuri
then begin
HLog.message ("baseuri " ^ value ^ " is not empty");
HLog.message ("cleaning baseuri " ^ value);
LibraryClean.clean_baseuris [value];
- assert (Http_getter_storage.is_empty value);
+ assert (Http_getter_storage.is_empty ~local:true value);
end;
if not (Helm_registry.get_opt_default Helm_registry.bool "matita.nodisk"
~default:false)
then
HExtlib.mkdir
- (Filename.dirname (Http_getter.filename ~writable:true (value ^
+ (Filename.dirname
+ (Http_getter.filename ~local:true ~writable:true (value ^
"/foo.con")));
end;
GrafiteTypes.set_option status name value,[]
| Cic.CurrentProof (_,metasenv',bo,ty,_, attrs) ->
let name = UriManager.name_of_uri uri in
if not(CicPp.check name ty) then
- HLog.error ("Bad name: " ^ name);
+ HLog.warn ("Bad name: " ^ name);
if opts.do_heavy_checks then
begin
let dbd = LibraryDb.instance () in
("Theorem already proved: " ^ UriManager.string_of_uri x ^
"\nPlease use a variant."));
end;
- let initial_proof = (Some uri, metasenv', bo, ty, attrs) in
+ let _subst = [] in
+ let initial_proof = (Some uri, metasenv', _subst, bo, ty, attrs) in
let initial_stack = Continuationals.Stack.of_metasenv metasenv' in
{ status with GrafiteTypes.proof_status =
GrafiteTypes.Incomplete_proof
projects / helm.git / blobdiff