open Printf
open MatitaTypes
+exception Drop;;
+
let debug = false ;;
let debug_print = if debug then prerr_endline else ignore ;;
FreshNamesGenerator.mk_fresh_name ~subst:[] metasenv context name ~typ
let tactic_of_ast = function
- | TacticAst.Intros (_, None, names) ->
- (* TODO Zack implement intros length *)
- PrimitiveTactics.intros_tac ~mk_fresh_name_callback:(namer_of names) ()
- | TacticAst.Intros (_, Some num, names) ->
- (* TODO Zack implement intros length *)
- PrimitiveTactics.intros_tac ~howmany:num
- ~mk_fresh_name_callback:(namer_of names) ()
- | TacticAst.Reflexivity _ -> Tactics.reflexivity
+ | TacticAst.Absurd (_, term) -> Tactics.absurd term
+ | TacticAst.Apply (_, term) -> Tactics.apply term
| TacticAst.Assumption _ -> Tactics.assumption
+ | TacticAst.Auto (_,depth,width) ->
+ AutoTactic.auto_tac ?depth ?width ~dbd:(MatitaDb.instance ()) ()
+ | TacticAst.Change (_, pattern, with_what) ->
+ Tactics.change ~pattern with_what
+ | TacticAst.Clear (_,id) -> Tactics.clear id
+ | TacticAst.ClearBody (_,id) -> Tactics.clearbody id
| TacticAst.Contradiction _ -> Tactics.contradiction
+ | TacticAst.Compare (_, term) -> Tactics.compare term
+ | TacticAst.Constructor (_, n) -> Tactics.constructor n
+ | TacticAst.Cut (_, ident, term) ->
+ let names = match ident with None -> [] | Some id -> [id] in
+ Tactics.cut ~mk_fresh_name_callback:(namer_of names) term
+ | TacticAst.DecideEquality _ -> Tactics.decide_equality
+ | TacticAst.Decompose (_,term) -> Tactics.decompose term
+ | TacticAst.Discriminate (_,term) -> Tactics.discriminate term
+ | TacticAst.Elim (_, term, _) ->
+ Tactics.elim_intros term
+ | TacticAst.ElimType (_, term) -> Tactics.elim_type term
+ | TacticAst.Exact (_, term) -> Tactics.exact term
| TacticAst.Exists _ -> Tactics.exists
+ | TacticAst.Fail _ -> Tactics.fail
+ | TacticAst.Fold (_, reduction_kind, term, pattern) ->
+ let reduction =
+ match reduction_kind with
+ | `Normalize -> CicReduction.normalize ~delta:false ~subst:[]
+ | `Reduce -> ProofEngineReduction.reduce
+ | `Simpl -> ProofEngineReduction.simpl
+ | `Whd -> CicReduction.whd ~delta:false ~subst:[]
+ in
+ Tactics.fold ~reduction ~term ~pattern
| TacticAst.Fourier _ -> Tactics.fourier
+ | TacticAst.FwdSimpl (_, hyp, names) ->
+ Tactics.fwd_simpl ~mk_fresh_name_callback:(namer_of names) ~hyp ~dbd:(MatitaDb.instance ())
+ | TacticAst.Generalize (_,pattern,ident) ->
+ let names = match ident with None -> [] | Some id -> [id] in
+ Tactics.generalize ~mk_fresh_name_callback:(namer_of names) pattern
| TacticAst.Goal (_, n) -> Tactics.set_goal n
+ | TacticAst.IdTac _ -> Tactics.id
+ | TacticAst.Injection (_,term) -> Tactics.injection term
+ | TacticAst.Intros (_, None, names) ->
+ PrimitiveTactics.intros_tac ~mk_fresh_name_callback:(namer_of names) ()
+ | TacticAst.Intros (_, Some num, names) ->
+ PrimitiveTactics.intros_tac ~howmany:num
+ ~mk_fresh_name_callback:(namer_of names) ()
+ | TacticAst.LApply (_, 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) ?how_many ~to_what what
| TacticAst.Left _ -> Tactics.left
+ | TacticAst.LetIn (loc,term,name) ->
+ Tactics.letin term ~mk_fresh_name_callback:(namer_of [name])
+ | TacticAst.Reduce (_, reduction_kind, pattern) ->
+ (match reduction_kind with
+ | `Normalize -> Tactics.normalize ~pattern
+ | `Reduce -> Tactics.reduce ~pattern
+ | `Simpl -> Tactics.simpl ~pattern
+ | `Whd -> Tactics.whd ~pattern)
+ | TacticAst.Reflexivity _ -> Tactics.reflexivity
+ | TacticAst.Replace (_, pattern, with_what) ->
+ Tactics.replace ~pattern ~with_what
+ | TacticAst.Rewrite (_, direction, t, pattern) ->
+ EqualityTactics.rewrite_tac ~direction ~pattern t
| TacticAst.Right _ -> Tactics.right
| TacticAst.Ring _ -> Tactics.ring
| TacticAst.Split _ -> Tactics.split
| TacticAst.Symmetry _ -> Tactics.symmetry
| TacticAst.Transitivity (_, term) -> Tactics.transitivity term
- | TacticAst.Apply (_, term) -> Tactics.apply term
- | TacticAst.Absurd (_, term) -> Tactics.absurd term
- | TacticAst.Exact (_, term) -> Tactics.exact term
- | TacticAst.Cut (_, term) -> Tactics.cut term
- | TacticAst.Elim (_, term, _) ->
- (* TODO Zack implement "using" argument *)
- (* old: Tactics.elim_intros_simpl term *)
- Tactics.elim_intros term
- | TacticAst.ElimType (_, term) -> Tactics.elim_type term
- | TacticAst.Replace (_, what, with_what) -> Tactics.replace ~what ~with_what
- | TacticAst.Auto (_,depth) ->
-(* AutoTactic.auto_tac ~num (MatitaDb.instance ()) *)
- AutoTactic.auto_tac_new ?depth ~dbd:(MatitaDb.instance ()) ()
- | TacticAst.Change (_, what, with_what, _) -> Tactics.change ~what ~with_what
-(*
- (* TODO Zack a lot more of tactics to be implemented here ... *)
- | TacticAst.Change_pattern of 'term pattern * 'term * 'ident option
- | TacticAst.Change of 'term * 'term * 'ident option
- | TacticAst.Decompose of 'ident * 'ident list
- | TacticAst.Discriminate of 'ident
- | TacticAst.Fold of reduction_kind * 'term
- | TacticAst.Injection of 'ident
- | TacticAst.Replace_pattern of 'term pattern * 'term
-*)
- | TacticAst.LetIn (loc,term,name) ->
- Tactics.letin term ~mk_fresh_name_callback:(namer_of [name])
- | TacticAst.ReduceAt (_,reduction_kind,ident,path) ->
- ProofEngineTypes.mk_tactic
- (fun (((_,metasenv,_,_),goal) as status) ->
- let metano,context,ty = CicUtil.lookup_meta goal metasenv in
- let where, also_in_hypotheses =
- if ident = "goal" then
- ty, false
- else
- let hyp =
- try
- List.find (function
- | Some (Cic.Name name,entry) when name = ident -> true
- | _ -> false)
- context
- with
- Not_found ->
- raise (ProofEngineTypes.Fail
- (ident ^ " is not an hypothesis"))
- in
- (match hyp with
- | Some (_, Cic.Decl term) -> term
- | Some (_, Cic.Def (term,ty)) -> term
- | None -> assert false),true
- in
- let pointers = CicUtil.select ~term:where ~context:path in
- (match reduction_kind with
- | `Normalize ->
- ProofEngineTypes.apply_tactic
- (Tactics.normalize ~also_in_hypotheses ~terms:(Some pointers))
- status
- | `Reduce ->
- ProofEngineTypes.apply_tactic
- (Tactics.reduce ~also_in_hypotheses ~terms:(Some pointers))
- status
- | `Simpl ->
- ProofEngineTypes.apply_tactic
- (Tactics.simpl ~also_in_hypotheses ~terms:(Some pointers))
- status
- | `Whd ->
- ProofEngineTypes.apply_tactic
- (Tactics.whd ~also_in_hypotheses ~terms:(Some pointers))
- status))
- | TacticAst.Reduce (_,reduction_kind,opts) ->
- let terms, also_in_hypotheses =
- match opts with
- | Some (l,`Goal) -> Some l, false
- | Some (l,`Everywhere) -> Some l, true
- | None -> None, false
- in
- (match reduction_kind with
- | `Normalize -> Tactics.normalize ~also_in_hypotheses ~terms
- | `Reduce -> Tactics.reduce ~also_in_hypotheses ~terms
- | `Simpl -> Tactics.simpl ~also_in_hypotheses ~terms
- | `Whd -> Tactics.whd ~also_in_hypotheses ~terms)
- | TacticAst.Rewrite (_,dir,t,ident) ->
- if dir = `Left then
- EqualityTactics.rewrite_tac ~term:t
- else
- EqualityTactics.rewrite_back_tac ~term:t
- | TacticAst.FwdSimpl (_, name) ->
- Tactics.fwd_simpl ~hyp:(Cic.Name name) ~dbd:(MatitaDb.instance ())
- | TacticAst.LApply (_, term, substs) ->
- let f (name, term) = Cic.Name name, term in
- Tactics.lapply ~substs:(List.map f substs) term
- | _ -> assert false
let eval_tactical status tac =
let apply_tactic tactic =
in
let rec tactical_of_ast = function
| TacticAst.Tactic (loc, tactic) -> tactic_of_ast tactic
- | TacticAst.Fail loc -> Tacticals.fail
| TacticAst.Do (loc, num, tactical) ->
Tacticals.do_tactic num (tactical_of_ast tactical)
- | TacticAst.IdTac loc -> Tacticals.id_tac
| TacticAst.Repeat (loc, tactical) ->
Tacticals.repeat_tactic (tactical_of_ast tactical)
| TacticAst.Seq (loc, tacticals) -> (* tac1; tac2; ... *)
let eval_command status cmd =
match cmd with
- | TacticAst.Set (loc, name, value) -> set_option status name value
+ | TacticAst.Set (loc, name, value) ->
+ let value =
+ if name = "baseuri" then
+ MatitaMisc.strip_trailing_slash value
+ else
+ value
+ in
+ set_option status name value
+ | TacticAst.Drop loc -> raise Drop
| TacticAst.Qed loc ->
let uri, metasenv, bo, ty =
match status.proof_status with
in
status, cic
+let disambiguate_pattern status (wanted, hyp_paths, goal_path) =
+ let interp path = Disambiguate.interpretate_path [] status.aliases path in
+ let goal_path = interp goal_path in
+ let hyp_paths = List.map (fun (name, path) -> name, interp path) hyp_paths in
+ let status,wanted =
+ match wanted with
+ None -> status,None
+ | Some wanted ->
+ let status,wanted = disambiguate_term status wanted in
+ status, Some wanted
+ in
+ status, (wanted, hyp_paths ,goal_path)
+
let disambiguate_tactic status = function
- | TacticAst.Transitivity (loc, term) ->
- let status, cic = disambiguate_term status term in
- status, TacticAst.Transitivity (loc, cic)
| TacticAst.Apply (loc, term) ->
let status, cic = disambiguate_term status term in
status, TacticAst.Apply (loc, cic)
| TacticAst.Absurd (loc, term) ->
let status, cic = disambiguate_term status term in
status, TacticAst.Absurd (loc, cic)
+ | TacticAst.Assumption loc -> status, TacticAst.Assumption loc
+ | TacticAst.Auto (loc,depth,width) -> status, TacticAst.Auto (loc,depth,width)
+ | TacticAst.Change (loc, pattern, with_what) ->
+ let status, with_what = disambiguate_term status with_what in
+ let status, pattern = disambiguate_pattern status pattern in
+ status, TacticAst.Change (loc, pattern, with_what)
+ | TacticAst.Clear (loc,id) -> status,TacticAst.Clear (loc,id)
+ | TacticAst.ClearBody (loc,id) -> status,TacticAst.ClearBody (loc,id)
+ | TacticAst.Compare (loc,term) ->
+ let status, term = disambiguate_term status term in
+ status, TacticAst.Compare (loc,term)
+ | TacticAst.Constructor (loc,n) ->
+ status, TacticAst.Constructor (loc,n)
+ | TacticAst.Contradiction loc ->
+ status, TacticAst.Contradiction loc
+ | TacticAst.Cut (loc, ident, term) ->
+ let status, cic = disambiguate_term status term in
+ status, TacticAst.Cut (loc, ident, cic)
+ | TacticAst.DecideEquality loc ->
+ status, TacticAst.DecideEquality loc
+ | TacticAst.Decompose (loc,term) ->
+ let status,term = disambiguate_term status term in
+ status, TacticAst.Decompose(loc,term)
+ | TacticAst.Discriminate (loc,term) ->
+ let status,term = disambiguate_term status term in
+ status, TacticAst.Discriminate(loc,term)
| TacticAst.Exact (loc, term) ->
let status, cic = disambiguate_term status term in
status, TacticAst.Exact (loc, cic)
- | TacticAst.Cut (loc, term) ->
- let status, cic = disambiguate_term status term in
- status, TacticAst.Cut (loc, cic)
| TacticAst.Elim (loc, term, Some term') ->
let status, cic1 = disambiguate_term status term in
let status, cic2 = disambiguate_term status term' in
| TacticAst.ElimType (loc, term) ->
let status, cic = disambiguate_term status term in
status, TacticAst.ElimType (loc, cic)
- | TacticAst.Replace (loc, what, with_what) ->
- let status, cic1 = disambiguate_term status what in
- let status, cic2 = disambiguate_term status with_what in
- status, TacticAst.Replace (loc, cic1, cic2)
- | TacticAst.Change (loc, what, with_what, ident) ->
- let status, cic1 = disambiguate_term status what in
- let status, cic2 = disambiguate_term status with_what in
- status, TacticAst.Change (loc, cic1, cic2, ident)
-(*
- (* TODO Zack a lot more of tactics to be implemented here ... *)
- | TacticAst.Change_pattern of 'term pattern * 'term * 'ident option
- | TacticAst.Change of 'term * 'term * 'ident option
- | TacticAst.Decompose of 'ident * 'ident list
- | TacticAst.Discriminate of 'ident
- | TacticAst.Fold of reduction_kind * 'term
- | TacticAst.Injection of 'ident
- | TacticAst.Replace_pattern of 'term pattern * 'term
-*)
- | TacticAst.LetIn (loc,term,name) ->
+ | TacticAst.Exists loc -> status, TacticAst.Exists loc
+ | TacticAst.Fail loc -> status,TacticAst.Fail loc
+ | TacticAst.Fold (loc,reduction_kind, term, pattern) ->
+ let status, pattern = disambiguate_pattern status pattern in
+ let status, term = disambiguate_term status term in
+ status, TacticAst.Fold (loc,reduction_kind, term, pattern)
+ | TacticAst.FwdSimpl (loc, hyp, names) ->
+ status, TacticAst.FwdSimpl (loc, hyp, names)
+ | TacticAst.Fourier loc -> status, TacticAst.Fourier loc
+ | TacticAst.Generalize (loc,pattern,ident) ->
+ let status, pattern = disambiguate_pattern status pattern in
+ status, TacticAst.Generalize(loc,pattern,ident)
+ | TacticAst.Goal (loc, g) -> status, TacticAst.Goal (loc, g)
+ | TacticAst.IdTac loc -> status,TacticAst.IdTac loc
+ | TacticAst.Injection (loc,term) ->
let status, term = disambiguate_term status term in
- status, TacticAst.LetIn (loc,term,name)
- | TacticAst.ReduceAt (loc, reduction_kind, ident, path) ->
- let path = Disambiguate.interpretate_path [] status.aliases path in
- status, TacticAst.ReduceAt(loc, reduction_kind, ident, path)
- | TacticAst.Reduce (loc, reduction_kind, opts) ->
- let status, opts =
- match opts with
- | None -> status, None
- | Some (l,pat) ->
- let status, l =
- List.fold_right (fun t (status,acc) ->
- let status',t' = disambiguate_term status t in
- status', t'::acc)
- l (status,[])
- in
- status, Some (l, pat)
- in
- status, TacticAst.Reduce (loc, reduction_kind, opts)
- | TacticAst.Rewrite (loc,dir,t,ident) ->
- let status, term = disambiguate_term status t in
- status, TacticAst.Rewrite (loc,dir,term,ident)
+ status, TacticAst.Injection (loc,term)
| TacticAst.Intros (loc, num, names) ->
status, TacticAst.Intros (loc, num, names)
- | TacticAst.Auto (loc,num) -> status, TacticAst.Auto (loc,num)
- | TacticAst.Reflexivity loc -> status, TacticAst.Reflexivity loc
- | TacticAst.Assumption loc -> status, TacticAst.Assumption loc
- | TacticAst.Contradiction loc -> status, TacticAst.Contradiction loc
- | TacticAst.Exists loc -> status, TacticAst.Exists loc
- | TacticAst.Fourier loc -> status, TacticAst.Fourier loc
+ | TacticAst.LApply (loc, depth, to_what, what, ident) ->
+ let f term (status, to_what) =
+ let status, term = disambiguate_term status term in
+ status, term :: to_what
+ in
+ let status, to_what = List.fold_right f to_what (status, []) in
+ let status, what = disambiguate_term status what in
+ status, TacticAst.LApply (loc, depth, to_what, what, ident)
| TacticAst.Left loc -> status, TacticAst.Left loc
+ | TacticAst.LetIn (loc, term, name) ->
+ let status, term = disambiguate_term status term in
+ status, TacticAst.LetIn (loc,term,name)
+ | TacticAst.Reduce (loc, reduction_kind, pattern) ->
+ let status, pattern = disambiguate_pattern status pattern in
+ status, TacticAst.Reduce(loc, reduction_kind, pattern)
+ | TacticAst.Reflexivity loc -> status, TacticAst.Reflexivity loc
+ | TacticAst.Replace (loc, pattern, with_what) ->
+ let status, pattern = disambiguate_pattern status pattern in
+ let status, with_what = disambiguate_term status with_what in
+ status, TacticAst.Replace (loc, pattern, with_what)
+ | TacticAst.Rewrite (loc, dir, t, pattern) ->
+ let status, term = disambiguate_term status t in
+ let status, pattern = disambiguate_pattern status pattern in
+ status, TacticAst.Rewrite (loc, dir, term, pattern)
| TacticAst.Right loc -> status, TacticAst.Right loc
| TacticAst.Ring loc -> status, TacticAst.Ring loc
| TacticAst.Split loc -> status, TacticAst.Split loc
| TacticAst.Symmetry loc -> status, TacticAst.Symmetry loc
- | TacticAst.Goal (loc, g) -> status, TacticAst.Goal (loc, g)
- | TacticAst.FwdSimpl (loc, name) -> status, TacticAst.FwdSimpl (loc, name)
- | TacticAst.LApply (loc, term, substs) ->
- let f (status, substs) (name, term) =
- let status, term = disambiguate_term status term in
- status, (name, term) :: substs
- in
- let status, term = disambiguate_term status term in
- let status, substs = List.fold_left f (status, []) substs in
- status, TacticAst.LApply (loc, term, substs)
-
- | x ->
- print_endline ("Not yet implemented:" ^ TacticAstPp.pp_tactic x);
- assert false
+ | TacticAst.Transitivity (loc, term) ->
+ let status, cic = disambiguate_term status term in
+ status, TacticAst.Transitivity (loc, cic)
let rec disambiguate_tactical status = function
| TacticAst.Tactic (loc, tactic) ->
| TacticAst.Try (loc, tactical) ->
let status, tactical = disambiguate_tactical status tactical in
status, TacticAst.Try (loc, tactical)
- | (TacticAst.IdTac _ | TacticAst.Fail _) as tac ->
- status, tac
and disambiguate_tacticals status tacticals =
let status, tacticals =
| TacticAst.Coercion (loc, term) ->
let status, term = disambiguate_term status term in
status, TacticAst.Coercion (loc,term)
- | (TacticAst.Set _ | TacticAst.Qed _) as cmd ->
+ | (TacticAst.Set _ | TacticAst.Qed _ | TacticAst.Drop _ ) as cmd ->
status, cmd
| TacticAst.Alias _ as x -> status, x
| TacticAst.Obj (loc,obj) ->
let eval_from_stream status str cb =
let stl = CicTextualParser2.parse_statements str in
- List.fold_left
- (fun status ast -> cb status ast;eval_ast status ast) status
- stl
+ List.iter (fun ast -> cb !status ast;status := eval_ast !status ast) stl
+
+let eval_from_stream_greedy status str cb =
+ while true do
+ print_string "matita> ";
+ flush stdout;
+ let ast = CicTextualParser2.parse_statement str in
+ cb !status ast;
+ status := eval_ast !status ast
+ done
let eval_string status str =
eval_from_stream status (Stream.of_string str) (fun _ _ -> ())
let default_options () =
+(*
let options =
StringMap.add "baseuri"
(String
(Helm_registry.get "matita.baseuri" ^ Helm_registry.get "matita.owner"))
no_options
in
+*)
let options =
StringMap.add "basedir"
(String (Helm_registry.get "matita.basedir" ))
- options
+ no_options
in
options