| TacticAst.Symmetry _ -> Tactics.symmetry
| TacticAst.Transitivity (_, term) -> Tactics.transitivity term
-let eval_tactical status tac =
- let apply_tactic tactic =
- let (proof, goals) =
- ProofEngineTypes.apply_tactic tactic (MatitaMisc.get_proof_status status)
- in
- let new_status =
- match goals with
- | [] ->
- let (_,metasenv,_,_) = proof in
- (match metasenv with
- | [] -> Proof proof
- | (ng,_,_)::_ -> Incomplete_proof (proof,ng))
- | ng::_ -> Incomplete_proof (proof, ng)
- in
- { status with proof_status = new_status }
+let disambiguate_term status term =
+ let (aliases, metasenv, cic, _) =
+ match
+ MatitaDisambiguator.disambiguate_term ~dbd:(MatitaDb.instance ())
+ ~aliases:(status.aliases) ~context:(MatitaMisc.get_proof_context status)
+ ~metasenv:(MatitaMisc.get_proof_metasenv status) term
+ with
+ | [x] -> x
+ | _ -> assert false
+ in
+ let proof_status =
+ match status.proof_status with
+ | No_proof -> Intermediate metasenv
+ | Incomplete_proof ((uri, _, proof, ty), goal) ->
+ Incomplete_proof ((uri, metasenv, proof, ty), goal)
+ | Intermediate _ -> Intermediate metasenv
+ | Proof _ -> assert false
+ in
+ let status = { status with proof_status = proof_status } in
+ let status = MatitaSync.set_proof_aliases status aliases 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
- let rec tactical_of_ast = function
- | TacticAst.Tactic (loc, tactic) -> tactic_of_ast tactic
+ status, (wanted, hyp_paths ,goal_path)
+
+let disambiguate_tactic status = function
+ | 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.Elim (loc, what, Some using, depth, idents) ->
+ let status, what = disambiguate_term status what in
+ let status, using = disambiguate_term status using in
+ status, TacticAst.Elim (loc, what, Some using, depth, idents)
+ | TacticAst.Elim (loc, what, None, depth, idents) ->
+ let status, what = disambiguate_term status what in
+ status, TacticAst.Elim (loc, what, None, depth, idents)
+ | TacticAst.ElimType (loc, what, Some using, depth, idents) ->
+ let status, what = disambiguate_term status what in
+ let status, using = disambiguate_term status using in
+ status, TacticAst.ElimType (loc, what, Some using, depth, idents)
+ | TacticAst.ElimType (loc, what, None, depth, idents) ->
+ let status, what = disambiguate_term status what in
+ status, TacticAst.ElimType (loc, what, None, depth, idents)
+ | 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.Injection (loc,term)
+ | TacticAst.Intros (loc, num, names) ->
+ status, TacticAst.Intros (loc, num, names)
+ | 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.Transitivity (loc, term) ->
+ let status, cic = disambiguate_term status term in
+ status, TacticAst.Transitivity (loc, cic)
+
+let apply_tactic tactic status =
+ let status,tactic = disambiguate_tactic status tactic in
+ let tactic = tactic_of_ast tactic in
+ let (proof, goals) =
+ ProofEngineTypes.apply_tactic tactic (MatitaMisc.get_proof_status status) in
+ let dummy = -1 in
+ { status with
+ proof_status = MatitaTypes.Incomplete_proof (proof,dummy) }, goals
+
+module MatitaStatus =
+ struct
+ type input_status = MatitaTypes.status
+ type output_status = MatitaTypes.status * ProofEngineTypes.goal list
+ type tactic = input_status -> output_status
+
+ let focus (status,_) goal =
+ let proof,_ = MatitaMisc.get_proof_status status in
+ {status with proof_status = MatitaTypes.Incomplete_proof (proof,goal)}
+
+ let goals (_,goals) = goals
+
+ let set_goals (status,_) goals = status,goals
+
+ let id_tac status = apply_tactic (TacticAst.IdTac CicAst.dummy_floc) status
+
+ let mk_tactic tac = tac
+
+ let apply_tactic tac = tac
+
+ end
+
+module MatitaTacticals = Tacticals.Make(MatitaStatus)
+
+let eval_tactical status tac =
+ let rec tactical_of_ast tac =
+ match tac with
+ | TacticAst.Tactic (loc, tactic) -> apply_tactic tactic
+ | TacticAst.Seq (loc, tacticals) -> (* tac1; tac2; ... *)
+ MatitaTacticals.seq ~tactics:(List.map tactical_of_ast tacticals)
| TacticAst.Do (loc, num, tactical) ->
- Tacticals.do_tactic num (tactical_of_ast tactical)
+ MatitaTacticals.do_tactic ~n:num ~tactic:(tactical_of_ast tactical)
| TacticAst.Repeat (loc, tactical) ->
- Tacticals.repeat_tactic (tactical_of_ast tactical)
- | TacticAst.Seq (loc, tacticals) -> (* tac1; tac2; ... *)
- Tacticals.seq (List.map tactical_of_ast tacticals)
+ MatitaTacticals.repeat_tactic ~tactic:(tactical_of_ast tactical)
| TacticAst.Then (loc, tactical, tacticals) -> (* tac; [ tac1 | ... ] *)
- Tacticals.thens (tactical_of_ast tactical)
- (List.map tactical_of_ast tacticals)
- | TacticAst.Tries (loc, tacticals) ->
- Tacticals.try_tactics
- (List.map (fun t -> "", tactical_of_ast t) tacticals)
+ MatitaTacticals.thens ~start:(tactical_of_ast tactical)
+ ~continuations:(List.map tactical_of_ast tacticals)
+ | TacticAst.First (loc, tacticals) ->
+ MatitaTacticals.first
+ ~tactics:(List.map (fun t -> "", tactical_of_ast t) tacticals)
| TacticAst.Try (loc, tactical) ->
- Tacticals.try_tactic (tactical_of_ast tactical)
+ MatitaTacticals.try_tactic ~tactic:(tactical_of_ast tactical)
+ | TacticAst.Solve (loc, tacticals) ->
+ MatitaTacticals.solve_tactics
+ ~tactics:(List.map (fun t -> "",tactical_of_ast t) tacticals)
+ in
+ let status,goals = tactical_of_ast tac status in
+ let proof,_ = MatitaMisc.get_proof_status status in
+ let new_status =
+ match goals with
+ | [] ->
+ let (_,metasenv,_,_) = proof in
+ (match metasenv with
+ | [] -> Proof proof
+ | (ng,_,_)::_ -> Incomplete_proof (proof,ng))
+ | ng::_ -> Incomplete_proof (proof, ng)
in
- apply_tactic (tactical_of_ast tac)
+ { status with proof_status = new_status }
let eval_coercion status coercion =
let coer_uri,coer_ty =
(* to avoid a long list of recursive functions *)
let eval_from_stream_ref = ref (fun _ _ _ -> assert false);;
+let disambiguate_obj status obj =
+ let uri =
+ match obj with
+ TacticAst.Inductive (_,(name,_,_,_)::_)
+ | TacticAst.Record (_,name,_,_) ->
+ Some (UriManager.uri_of_string (MatitaMisc.qualify status name ^ ".ind"))
+ | TacticAst.Inductive _ -> assert false
+ | _ -> None in
+ let (aliases, metasenv, cic, _) =
+ match
+ MatitaDisambiguator.disambiguate_obj ~dbd:(MatitaDb.instance ())
+ ~aliases:(status.aliases) ~uri obj
+ with
+ | [x] -> x
+ | _ -> assert false
+ in
+ let proof_status =
+ match status.proof_status with
+ | No_proof -> Intermediate metasenv
+ | Incomplete_proof _
+ | Intermediate _
+ | Proof _ -> assert false
+ in
+ let status = { status with proof_status = proof_status } in
+ let status = MatitaSync.set_proof_aliases status aliases in
+ status, cic
+
+let disambiguate_command status = function
+ | TacticAst.Default _
+ | TacticAst.Alias _
+ | TacticAst.Include _ as cmd -> status,cmd
+ | TacticAst.Coercion (loc, term) ->
+ let status, term = disambiguate_term status term in
+ status, TacticAst.Coercion (loc,term)
+ | (TacticAst.Set _ | TacticAst.Qed _ | TacticAst.Drop _ ) as cmd ->
+ status, cmd
+ | TacticAst.Obj (loc,obj) ->
+ let status,obj = disambiguate_obj status obj in
+ status, TacticAst.Obj (loc,obj)
+
let eval_command status cmd =
+ let status,cmd = disambiguate_command status cmd in
match cmd with
| TacticAst.Default (loc, what, uris) as cmd ->
LibraryObjects.set_default what uris;
| TacticAst.Command (_, cmd) -> eval_command status cmd
| TacticAst.Macro (_, mac) ->
command_error (sprintf "The macro %s can't be in a script"
- (TacticAstPp.pp_macro_cic mac))
+ (TacticAstPp.pp_macro_ast mac))
let eval_comment status c = status
-let eval status st =
+let eval_ast status st =
match st with
| TacticAst.Executable (_,ex) -> eval_executable status ex
| TacticAst.Comment (_,c) -> eval_comment status c
-let disambiguate_term status term =
- let (aliases, metasenv, cic, _) =
- match
- MatitaDisambiguator.disambiguate_term ~dbd:(MatitaDb.instance ())
- ~aliases:(status.aliases) ~context:(MatitaMisc.get_proof_context status)
- ~metasenv:(MatitaMisc.get_proof_metasenv status) term
- with
- | [x] -> x
- | _ -> assert false
- in
- let proof_status =
- match status.proof_status with
- | No_proof -> Intermediate metasenv
- | Incomplete_proof ((uri, _, proof, ty), goal) ->
- Incomplete_proof ((uri, metasenv, proof, ty), goal)
- | Intermediate _ -> Intermediate metasenv
- | Proof _ -> assert false
- in
- let status = { status with proof_status = proof_status } in
- let status = MatitaSync.set_proof_aliases status aliases in
- status, cic
-
-let disambiguate_obj status obj =
- let uri =
- match obj with
- TacticAst.Inductive (_,(name,_,_,_)::_)
- | TacticAst.Record (_,name,_,_) ->
- Some (UriManager.uri_of_string (MatitaMisc.qualify status name ^ ".ind"))
- | TacticAst.Inductive _ -> assert false
- | _ -> None in
- let (aliases, metasenv, cic, _) =
- match
- MatitaDisambiguator.disambiguate_obj ~dbd:(MatitaDb.instance ())
- ~aliases:(status.aliases) ~uri obj
- with
- | [x] -> x
- | _ -> assert false
- in
- let proof_status =
- match status.proof_status with
- | No_proof -> Intermediate metasenv
- | Incomplete_proof _
- | Intermediate _
- | Proof _ -> assert false
- in
- let status = { status with proof_status = proof_status } in
- let status = MatitaSync.set_proof_aliases status aliases 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.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.Elim (loc, what, Some using, depth, idents) ->
- let status, what = disambiguate_term status what in
- let status, using = disambiguate_term status using in
- status, TacticAst.Elim (loc, what, Some using, depth, idents)
- | TacticAst.Elim (loc, what, None, depth, idents) ->
- let status, what = disambiguate_term status what in
- status, TacticAst.Elim (loc, what, None, depth, idents)
- | TacticAst.ElimType (loc, what, Some using, depth, idents) ->
- let status, what = disambiguate_term status what in
- let status, using = disambiguate_term status using in
- status, TacticAst.ElimType (loc, what, Some using, depth, idents)
- | TacticAst.ElimType (loc, what, None, depth, idents) ->
- let status, what = disambiguate_term status what in
- status, TacticAst.ElimType (loc, what, None, depth, idents)
- | 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.Injection (loc,term)
- | TacticAst.Intros (loc, num, names) ->
- status, TacticAst.Intros (loc, num, names)
- | 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.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) ->
- let status, tac = disambiguate_tactic status tactic in
- status, TacticAst.Tactic (loc, tac)
- | TacticAst.Do (loc, num, tactical) ->
- let status, tac = disambiguate_tactical status tactical in
- status, TacticAst.Do (loc, num, tac)
- | TacticAst.Repeat (loc, tactical) ->
- let status, tac = disambiguate_tactical status tactical in
- status, TacticAst.Repeat (loc, tac)
- | TacticAst.Seq (loc, tacticals) -> (* tac1; tac2; ... *)
- let status, tacticals = disambiguate_tacticals status tacticals in
- let tacticals = List.rev tacticals in
- status, TacticAst.Seq (loc, tacticals)
- | TacticAst.Then (loc, tactical, tacticals) -> (* tac; [ tac1 | ... ] *)
- let status, tactical = disambiguate_tactical status tactical in
- let status, tacticals = disambiguate_tacticals status tacticals in
- status, TacticAst.Then (loc, tactical, tacticals)
- | TacticAst.Tries (loc, tacticals) ->
- let status, tacticals = disambiguate_tacticals status tacticals in
- status, TacticAst.Tries (loc, tacticals)
- | TacticAst.Try (loc, tactical) ->
- let status, tactical = disambiguate_tactical status tactical in
- status, TacticAst.Try (loc, tactical)
-
-and disambiguate_tacticals status tacticals =
- let status, tacticals =
- List.fold_left
- (fun (status, tacticals) tactical ->
- let status, tac = disambiguate_tactical status tactical in
- status, tac :: tacticals)
- (status, [])
- tacticals
- in
- let tacticals = List.rev tacticals in
- status, tacticals
-
-let disambiguate_command status = function
- | TacticAst.Default _
- | TacticAst.Alias _
- | TacticAst.Include _ as cmd -> status,cmd
- | TacticAst.Coercion (loc, term) ->
- let status, term = disambiguate_term status term in
- status, TacticAst.Coercion (loc,term)
- | (TacticAst.Set _ | TacticAst.Qed _ | TacticAst.Drop _ ) as cmd ->
- status, cmd
- | TacticAst.Obj (loc,obj) ->
- let status,obj = disambiguate_obj status obj in
- status, TacticAst.Obj (loc,obj)
-
-let disambiguate_executable status ex =
- match ex with
- | TacticAst.Tactical (loc, tac) ->
- let status, tac = disambiguate_tactical status tac in
- status, (TacticAst.Tactical (loc, tac))
- | TacticAst.Command (loc, cmd) ->
- let status, cmd = disambiguate_command status cmd in
- status, (TacticAst.Command (loc, cmd))
- | TacticAst.Macro (_, mac) ->
- command_error (sprintf "The macro %s can't be in a script"
- (TacticAstPp.pp_macro_ast mac))
-
-let disambiguate_comment status c =
- match c with
- | TacticAst.Note (loc,n) -> status, TacticAst.Note (loc,n)
- | TacticAst.Code (loc,ex) ->
- let status, ex = disambiguate_executable status ex in
- status, TacticAst.Code (loc,ex)
-
-let disambiguate_statement status statement =
- match statement with
- | TacticAst.Comment (loc,c) ->
- let status, c = disambiguate_comment status c in
- status, TacticAst.Comment (loc,c)
- | TacticAst.Executable (loc,ex) ->
- let status, ex = disambiguate_executable status ex in
- status, TacticAst.Executable (loc,ex)
-
-let eval_ast status ast =
- let status,st = disambiguate_statement status ast in
- (* this disambiguation step should be deferred to support tacticals *)
- eval status st
-
let eval_from_stream status str cb =
let stl = CicTextualParser2.parse_statements str in
List.iter
if debug then
debug_print ("TACTICALS WARNING: " ^ s)
-
-(** TACTIC{,AL}S *)
-
- (* not a tactical, but it's used only here (?) *)
-
let id_tac =
let id_tac (proof,goal) =
let _, metasenv, _, _ = proof in
in
mk_tactic id_tac
+let fail_tac =
+ let fail_tac (proof,goal) =
+ let _, metasenv, _, _ = proof in
+ let _, _, _ = CicUtil.lookup_meta goal metasenv in
+ raise (Fail "fail tactical")
+ in
+ mk_tactic fail_tac
+
+module type Status =
+ sig
+ type input_status
+ type output_status
+ type tactic
+ val id_tac : tactic
+ val mk_tactic : (input_status -> output_status) -> tactic
+ val apply_tactic : tactic -> input_status -> output_status
+ val goals : output_status -> ProofEngineTypes.goal list
+ val set_goals: output_status -> ProofEngineTypes.goal list -> output_status
+ val focus : output_status -> ProofEngineTypes.goal -> input_status
+ end
+
+module type T =
+ sig
+ type tactic
+
+ val first: tactics: (string * tactic) list -> tactic
+
+ val thens: start: tactic -> continuations: tactic list -> tactic
+
+ val then_: start: tactic -> continuation: tactic -> tactic
+
+ (** "folding" of then_ *)
+ val seq: tactics: tactic list -> tactic
+
+ val repeat_tactic: tactic: tactic -> tactic
+
+ val do_tactic: n: int -> tactic: tactic -> tactic
+
+ val try_tactic: tactic: tactic -> tactic
+
+ val solve_tactics: tactics: (string * tactic) list -> tactic
+ end
+
+module Make (S:Status) : T with type tactic = S.tactic =
+struct
+type tactic = S.tactic
+
(**
naive implementation of ORELSE tactical, try a sequence of tactics in turn:
if one fails pass to the next one and so on, eventually raises (failure "no
tactics left")
- TODO warning: not tail recursive due to "try .. with" boxing
-
- Galla: is this exactly Coq's "First"?
-
*)
-let try_tactics ~tactics =
- let rec try_tactics ~(tactics: (string * tactic) list) status =
- warn "in Tacticals.try_tactics";
+let first ~tactics =
+ let rec first ~(tactics: (string * tactic) list) status =
+ warn "in Tacticals.first";
match tactics with
| (descr, tac)::tactics ->
- warn ("Tacticals.try_tactics IS TRYING " ^ descr);
+ warn ("Tacticals.first IS TRYING " ^ descr);
(try
- let res = apply_tactic tac status in
- warn ("Tacticals.try_tactics: " ^ descr ^ " succedeed!!!");
+ let res = S.apply_tactic tac status in
+ warn ("Tacticals.first: " ^ descr ^ " succedeed!!!");
res
with
e ->
| (CicTypeChecker.TypeCheckerFailure _)
| (CicUnification.UnificationFailure _) ->
warn (
- "Tacticals.try_tactics failed with exn: " ^
+ "Tacticals.first failed with exn: " ^
Printexc.to_string e);
- try_tactics ~tactics status
+ first ~tactics status
| _ -> raise e (* [e] must not be caught ; let's re-raise it *)
)
- | [] -> raise (Fail "try_tactics: no tactics left")
+ | [] -> raise (Fail "first: no tactics left")
in
- mk_tactic (try_tactics ~tactics)
+ S.mk_tactic (first ~tactics)
let thens ~start ~continuations =
let thens ~start ~continuations status =
- let (proof,new_goals) = apply_tactic start status in
+ let output_status = S.apply_tactic start status in
+ let new_goals = S.goals output_status in
try
- List.fold_left2
- (fun (proof,goals) goal tactic ->
- let (proof',new_goals') = apply_tactic tactic (proof,goal) in
- (proof',goals@new_goals')
- ) (proof,[]) new_goals continuations
+ let output_status,goals =
+ List.fold_left2
+ (fun (output_status,goals) goal tactic ->
+ let status = S.focus output_status goal in
+ let output_status' = S.apply_tactic tactic status in
+ let new_goals' = S.goals output_status' in
+ (output_status',goals@new_goals')
+ ) (output_status,[]) new_goals continuations
+ in
+ S.set_goals output_status goals
with
Invalid_argument _ ->
-(* FG: more debugging information *)
let debug = Printf.sprintf "thens: expected %i new goals, found %i"
(List.length continuations) (List.length new_goals)
in
raise (Fail debug)
in
- mk_tactic (thens ~start ~continuations )
+ S.mk_tactic (thens ~start ~continuations )
let then_ ~start ~continuation =
let then_ ~start ~continuation status =
- let (proof,new_goals) = apply_tactic start status in
- List.fold_left
- (fun (proof,goals) goal ->
- let (proof',new_goals') = apply_tactic continuation (proof,goal) in
- (proof',goals@new_goals')
- ) (proof,[]) new_goals
+ let output_status = S.apply_tactic start status in
+ let new_goals = S.goals output_status in
+ let output_status,goals =
+ List.fold_left
+ (fun (output_status,goals) goal ->
+ let status = S.focus output_status goal in
+ let output_status' = S.apply_tactic continuation status in
+ let new_goals' = S.goals output_status' in
+ (output_status',goals@new_goals')
+ ) (output_status,[]) new_goals
+ in
+ S.set_goals output_status goals
in
- mk_tactic (then_ ~start ~continuation)
+ S.mk_tactic (then_ ~start ~continuation)
let rec seq ~tactics =
match tactics with
let repeat_tactic ~tactic =
let rec repeat_tactic ~tactic status =
warn "in repeat_tactic";
- try let (proof, goallist) = apply_tactic tactic status in
- let rec step proof goallist =
+ try
+ let output_status = S.apply_tactic tactic status in
+ let goallist = S.goals output_status in
+ let rec step output_status goallist =
match goallist with
- [] -> (proof, [])
+ [] -> output_status,[]
| head::tail ->
- let (proof', goallist') = repeat_tactic ~tactic (proof, head) in
- let (proof'', goallist'') = step proof' tail in
- proof'', goallist'@goallist''
+ let status = S.focus output_status head in
+ let output_status' = repeat_tactic ~tactic status in
+ let goallist' = S.goals output_status' in
+ let output_status'',goallist'' = step output_status' tail in
+ output_status'',goallist'@goallist''
in
- step proof goallist
+ let output_status,goallist = step output_status goallist in
+ S.set_goals output_status goallist
with
(Fail _) as e ->
warn ("Tacticals.repeat_tactic failed after nth time with exception: " ^ Printexc.to_string e) ;
- apply_tactic id_tac status
+ S.apply_tactic S.id_tac status
in
- mk_tactic (repeat_tactic ~tactic)
-;;
-
+ S.mk_tactic (repeat_tactic ~tactic)
(* This tries to apply tactic n times *)
let rec do_tactic ~n ~tactic status =
warn "in do_tactic";
try
- let (proof, goallist) =
- if (n>0) then apply_tactic tactic status
- else apply_tactic id_tac status in
+ let output_status =
+ if (n>0) then S.apply_tactic tactic status
+ else S.apply_tactic S.id_tac status in
+ let goallist = S.goals output_status in
(* else (proof, []) in *)
(* perche' non va bene questo? stessa questione di ##### ? *)
- let rec step proof goallist =
+ let rec step output_status goallist =
match goallist with
- [] -> (proof, [])
+ [] -> output_status, []
| head::tail ->
- let (proof', goallist') =
- do_tactic ~n:(n-1) ~tactic (proof, head) in
- let (proof'', goallist'') = step proof' tail in
- proof'', goallist'@goallist''
+ let status = S.focus output_status head in
+ let output_status' = do_tactic ~n:(n-1) ~tactic status in
+ let goallist' = S.goals output_status' in
+ let (output_status'', goallist'') = step output_status' tail in
+ output_status'', goallist'@goallist''
in
- step proof goallist
+ let output_status,goals = step output_status goallist in
+ S.set_goals output_status goals
with
(Fail _) as e ->
warn ("Tacticals.do_tactic failed after nth time with exception: " ^ Printexc.to_string e) ;
- apply_tactic id_tac status
+ S.apply_tactic S.id_tac status
in
- mk_tactic (do_tactic ~n ~tactic)
-;;
+ S.mk_tactic (do_tactic ~n ~tactic)
let rec try_tactic ~tactic status =
warn "in Tacticals.try_tactic";
try
- apply_tactic tactic status
+ S.apply_tactic tactic status
with
(Fail _) as e ->
warn ( "Tacticals.try_tactic failed with exn: " ^ Printexc.to_string e);
- apply_tactic id_tac status
+ S.apply_tactic S.id_tac status
in
- mk_tactic (try_tactic ~tactic)
-;;
-
-let fail_tac = mk_tactic (fun _ -> raise (Fail "fail tactical"))
+ S.mk_tactic (try_tactic ~tactic)
(* This tries tactics until one of them doesn't _solve_ the goal *)
(* TODO: si puo' unificare le 2(due) chiamate ricorsive? *)
| (descr, currenttactic)::moretactics ->
warn ("Tacticals.solve_tactics is trying " ^ descr);
(try
- let (proof, goallist) = apply_tactic currenttactic status in
+ let output_status = S.apply_tactic currenttactic status in
+ let goallist = S.goals output_status in
match goallist with
[] -> warn ("Tacticals.solve_tactics: " ^ descr ^
" solved the goal!!!");
(* questo significa che non ci sono piu' goal, o che current_tactic non ne
ha aperti di nuovi? (la 2a!) #####
nel secondo caso basta per dire che solve_tactics has solved the goal? (si!) *)
- (proof, goallist)
+ output_status
| _ -> warn ("Tacticals.solve_tactics: try the next tactic");
solve_tactics ~tactics:(moretactics) status
with
solve_tactics ~tactics status
)
| [] -> raise (Fail "solve_tactics cannot solve the goal");
- apply_tactic id_tac status
+ S.apply_tactic S.id_tac status
in
- mk_tactic (solve_tactics ~tactics)
-;;
+ S.mk_tactic (solve_tactics ~tactics)
+end
+
+module ProofEngineStatus =
+ struct
+ type input_status = ProofEngineTypes.status
+ type output_status = ProofEngineTypes.proof * ProofEngineTypes.goal list
+ type tactic = ProofEngineTypes.tactic
+ let id_tac = id_tac
+ let mk_tactic = ProofEngineTypes.mk_tactic
+ let apply_tactic = ProofEngineTypes.apply_tactic
+ let goals (_,goals) = goals
+ let set_goals (proof,_) goals = proof,goals
+ let focus (proof,_) goal = proof,goal
+ end
+
+module ProofEngineTacticals = Make(ProofEngineStatus)
+
+include ProofEngineTacticals