end else
FreshNamesGenerator.mk_fresh_name ~subst:[] metasenv context name ~typ
-let tactic_of_ast status ast =
+let rec tactic_of_ast status ast =
let module PET = ProofEngineTypes in
match ast with
+ (* Higher order tactics *)
+ | GrafiteAst.Do (loc, n, tactic) ->
+ Tacticals.do_tactic n (tactic_of_ast status tactic)
+ | GrafiteAst.Seq (loc, tactics) -> (* tac1; tac2; ... *)
+ Tacticals.seq (List.map (tactic_of_ast status) tactics)
+ | GrafiteAst.Repeat (loc, tactic) ->
+ Tacticals.repeat_tactic (tactic_of_ast status tactic)
+ | GrafiteAst.Then (loc, tactic, tactics) -> (* tac; [ tac1 | ... ] *)
+ Tacticals.thens
+ (tactic_of_ast status tactic)
+ (List.map (tactic_of_ast status) tactics)
+ | GrafiteAst.First (loc, tactics) ->
+ Tacticals.first (List.map (tactic_of_ast status) tactics)
+ | GrafiteAst.Try (loc, tactic) ->
+ Tacticals.try_tactic (tactic_of_ast status tactic)
+ | GrafiteAst.Solve (loc, tactics) ->
+ Tacticals.solve_tactics (List.map (tactic_of_ast status) tactics)
+ | GrafiteAst.Progress (loc, tactic) ->
+ Tacticals.progress_tactic (tactic_of_ast status tactic)
+ (* First order tactics *)
| GrafiteAst.Absurd (_, term) -> Tactics.absurd term
| GrafiteAst.Apply (_, term) -> Tactics.apply term
| GrafiteAst.ApplyS (_, term, params) ->
| GrafiteAst.Generalize (_,pattern,ident) ->
let names = match ident with None -> [] | Some id -> [id] in
Tactics.generalize ~mk_fresh_name_callback:(namer_of names) pattern
- | GrafiteAst.Goal (_, n) -> Tactics.set_goal n
| GrafiteAst.IdTac _ -> Tactics.id
| GrafiteAst.Intros (_, None, names) ->
PrimitiveTactics.intros_tac ~mk_fresh_name_callback:(namer_of names) ()
| GrafiteAst.Generalize _
| GrafiteAst.Elim _
| GrafiteAst.Cut _
- | GrafiteAst.Decompose _ -> true, true
- (* tactics we don't want to reorder goals. I think only Goal needs this. *)
- | GrafiteAst.Goal _ -> false, true
+ | GrafiteAst.Decompose _ -> true
(* tactics like apply *)
- | _ -> true, false
+ | _ -> false
let reorder_metasenv start refine tactic goals current_goal always_opens_a_goal=
let module PEH = ProofEngineHelpers in
let metasenv_after_refinement = GrafiteTypes.get_proof_metasenv status in
let proof = GrafiteTypes.get_current_proof status in
let proof_status = proof, goal in
- let needs_reordering, always_opens_a_goal = classify_tactic tactic in
+ let always_opens_a_goal = classify_tactic tactic in
let tactic = tactic_of_ast status tactic in
let (proof, opened) = ProofEngineTypes.apply_tactic tactic proof_status in
let after = ProofEngineTypes.goals_of_proof proof in
let opened_goals, closed_goals = Tacticals.goals_diff ~before ~after ~opened in
let proof, opened_goals =
- if needs_reordering then begin
- let uri, metasenv_after_tactic, 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
- proof', opened_goals
- end
- else
- proof, opened_goals
+ let uri, metasenv_after_tactic, 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
+ proof', opened_goals
in
let incomplete_proof =
match status.GrafiteTypes.proof_status with
let metasenv_after_refinement = GrafiteTypes.get_proof_metasenv status in
let proof = GrafiteTypes.get_current_proof status in
let proof_status = proof, goal in
- let needs_reordering, always_opens_a_goal = classify_tactic tactic in
+ let always_opens_a_goal = classify_tactic tactic in
let tactic = tactic_of_ast status tactic in
let tactic = patch tactic in
let (proof, opened) = ProofEngineTypes.apply_tactic tactic proof_status in
let after = ProofEngineTypes.goals_of_proof proof in
let opened_goals, closed_goals = Tacticals.goals_diff ~before ~after ~opened in
let proof, opened_goals =
- if needs_reordering then begin
- let uri, metasenv_after_tactic, 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
- proof', opened_goals
- end
- else
- proof, opened_goals
+ let uri, metasenv_after_tactic, 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
+ proof', opened_goals
in
let incomplete_proof =
match status.GrafiteTypes.proof_status with
{status with GrafiteTypes.proof_status = GrafiteTypes.No_proof},
List.map fst compounds
-let eval_tactical ~disambiguate_tactic status tac =
- let apply_tactic = apply_tactic ~disambiguate_tactic in
- let module MatitaStatus =
- struct
- type input_status = GrafiteTypes.status * ProofEngineTypes.goal
-
- type output_status =
- GrafiteTypes.status * ProofEngineTypes.goal list * ProofEngineTypes.goal list
-
- type tactic = input_status -> output_status
-
- let mk_tactic tac = tac
- let apply_tactic tac = tac
- let goals (_, opened, closed) = opened, closed
- let get_stack (status, _) = GrafiteTypes.get_stack status
-
- let set_stack stack (status, opened, closed) =
- GrafiteTypes.set_stack stack status, opened, closed
-
- let inject (status, _) = (status, [], [])
- let focus goal (status, _, _) = (status, goal)
- end
- in
-(*
- let rec atomic_tactical_of_ast (text,prefix_len,tac) =
- match tac with
- | GrafiteAst.Tactic (loc, tactic) ->
- cic_tactic_of_ast ~disambiguate_tactic (text,prefix_len,tactic)
- (status,~-1)
- | GrafiteAst.Seq (loc,tacticals) ->
- Tacticals.seq
- (List.map atomic_tactical_of_ast
- (List.map (fun x -> text,prefix_len,x) tacticals))
- | _ -> assert false
- in
-*)
- let module MatitaTacticals = Continuationals.Make(MatitaStatus) in
- let tactical_of_ast l (text,prefix_len,tac) =
- let apply_tactic t = apply_tactic (text, prefix_len, t) in
- match tac with
- | GrafiteAst.Tactic (loc, tactic) ->
- MatitaTacticals.eval
- (MatitaTacticals.Tactical
- (MatitaTacticals.Tactic
- (MatitaStatus.mk_tactic (apply_tactic tactic))))
-(*
- | GrafiteAst.Seq (loc, tacticals) -> (* tac1; tac2; ... *)
- assert (l > 0);
- MatitaTacticals.seq ~tactics:(List.map (tactical_of_ast (l+1)) tacticals)
- | GrafiteAst.Do (loc, n, tactical) ->
- MatitaTacticals.do_tactic ~n ~tactic:(tactical_of_ast (l+1) tactical)
-*)
- | GrafiteAst.Repeat (loc, GrafiteAst.Tactic (_,tactical)) ->
- MatitaTacticals.eval
- (MatitaTacticals.Tactical
- (MatitaTacticals.Tactic
- (MatitaStatus.mk_tactic
- (apply_atomic_tactical ~disambiguate_tactic
- ~patch:(fun tactic -> Tacticals.repeat_tactic ~tactic)
- (text,prefix_len,tactical)))))
-(*
- | GrafiteAst.Then (loc, tactical, tacticals) -> (* tac; [ tac1 | ... ] *)
- assert (l > 0);
- MatitaTacticals.thens ~start:(tactical_of_ast (l+1) tactical)
- ~continuations:(List.map (tactical_of_ast (l+1)) tacticals)
-*)
- | GrafiteAst.First (loc, [GrafiteAst.Tactic (_,tacticals)]) ->
- MatitaTacticals.eval
- (MatitaTacticals.Tactical
- (MatitaTacticals.Tactic
- (MatitaStatus.mk_tactic
- (apply_atomic_tactical ~disambiguate_tactic
- ~patch:(fun tactic ->Tacticals.first ~tactics:["",tactic])
- (text,prefix_len,tacticals)))))
- | GrafiteAst.Try (loc, GrafiteAst.Tactic (_,tactical)) ->
- MatitaTacticals.eval
- (MatitaTacticals.Tactical
- (MatitaTacticals.Tactic
- (MatitaStatus.mk_tactic
- (apply_atomic_tactical ~disambiguate_tactic
- ~patch:(fun tactic -> Tacticals.try_tactic ~tactic)
- (text,prefix_len,tactical)))))
- | GrafiteAst.Solve (loc, [GrafiteAst.Tactic (_,tacticals)]) ->
- MatitaTacticals.eval
- (MatitaTacticals.Tactical
- (MatitaTacticals.Tactic
- (MatitaStatus.mk_tactic
- (apply_atomic_tactical ~disambiguate_tactic
- ~patch:(fun tactic ->Tacticals.solve_tactics ~tactics:["",tactic])
- (text,prefix_len,tacticals)))))
- | GrafiteAst.Progress (loc, GrafiteAst.Tactic (_,tactical)) ->
- MatitaTacticals.eval
- (MatitaTacticals.Tactical
- (MatitaTacticals.Tactic
- (MatitaStatus.mk_tactic
- (apply_atomic_tactical ~disambiguate_tactic
- ~patch:(fun tactic -> Tacticals.progress_tactic ~tactic)
- (text,prefix_len,tactical)))))
- | GrafiteAst.Skip _loc ->
- MatitaTacticals.eval (MatitaTacticals.Tactical MatitaTacticals.Skip)
- | GrafiteAst.Dot _loc ->
- MatitaTacticals.eval (MatitaTacticals.Dot)
- | GrafiteAst.Semicolon _loc ->
- MatitaTacticals.eval (MatitaTacticals.Semicolon)
- | GrafiteAst.Branch _loc ->
- MatitaTacticals.eval MatitaTacticals.Branch
- | GrafiteAst.Shift _loc ->
- MatitaTacticals.eval MatitaTacticals.Shift
- | GrafiteAst.Pos (_loc, i) ->
- MatitaTacticals.eval (MatitaTacticals.Pos i)
- | GrafiteAst.Merge _loc ->
- MatitaTacticals.eval MatitaTacticals.Merge
- | GrafiteAst.Focus (_loc, goals) ->
- MatitaTacticals.eval (MatitaTacticals.Focus goals)
- | GrafiteAst.Unfocus _loc ->
- MatitaTacticals.eval MatitaTacticals.Unfocus
- | GrafiteAst.Wildcard _loc ->
- MatitaTacticals.eval MatitaTacticals.Wildcard
- in
- let status, _, _ = tactical_of_ast 0 tac (status, ~-1) in
+module MatitaStatus =
+ struct
+ type input_status = GrafiteTypes.status * ProofEngineTypes.goal
+
+ type output_status =
+ GrafiteTypes.status * ProofEngineTypes.goal list * ProofEngineTypes.goal list
+
+ type tactic = input_status -> output_status
+
+ let mk_tactic tac = tac
+ let apply_tactic tac = tac
+ let goals (_, opened, closed) = opened, closed
+ let get_stack (status, _) = GrafiteTypes.get_stack status
+
+ let set_stack stack (status, opened, closed) =
+ GrafiteTypes.set_stack stack status, opened, closed
+
+ let inject (status, _) = (status, [], [])
+ let focus goal (status, _, _) = (status, goal)
+ end
+
+module MatitaTacticals = Continuationals.Make(MatitaStatus)
+
+let tactic_of_ast' tac =
+ MatitaTacticals.Tactical (MatitaTacticals.Tactic (MatitaStatus.mk_tactic tac))
+
+let punctuation_tactical_of_ast (text,prefix_len,punct) =
+ match punct with
+ | GrafiteAst.Dot _loc -> MatitaTacticals.Dot
+ | GrafiteAst.Semicolon _loc -> MatitaTacticals.Semicolon
+ | GrafiteAst.Branch _loc -> MatitaTacticals.Branch
+ | GrafiteAst.Shift _loc -> MatitaTacticals.Shift
+ | GrafiteAst.Pos (_loc, i) -> MatitaTacticals.Pos i
+ | GrafiteAst.Merge _loc -> MatitaTacticals.Merge
+ | GrafiteAst.Wildcard _loc -> MatitaTacticals.Wildcard
+
+let non_punctuation_tactical_of_ast (text,prefix_len,punct) =
+ match punct with
+ | GrafiteAst.Focus (_loc,goals) -> MatitaTacticals.Focus goals
+ | GrafiteAst.Unfocus _loc -> MatitaTacticals.Unfocus
+ | GrafiteAst.Skip _loc -> MatitaTacticals.Tactical MatitaTacticals.Skip
+
+let eval_tactical status tac =
+ let status, _, _ = MatitaTacticals.eval tac (status, ~-1) in
let status = (* is proof completed? *)
match status.GrafiteTypes.proof_status with
| GrafiteTypes.Incomplete_proof
} and eval_executable = {ee_go = fun ~disambiguate_tactic ~disambiguate_command
~disambiguate_macro opts status (text,prefix_len,ex) ->
match ex with
- | GrafiteAst.Tactical (_, tac, None) ->
- eval_tactical ~disambiguate_tactic status (text,prefix_len,tac),[]
- | GrafiteAst.Tactical (_, tac, Some punct) ->
+ | GrafiteAst.Tactic (_, Some tac, punct) ->
+ let tac = apply_tactic ~disambiguate_tactic (text,prefix_len,tac) in
+ let status = eval_tactical status (tactic_of_ast' tac) in
+ eval_tactical status
+ (punctuation_tactical_of_ast (text,prefix_len,punct)),[]
+ | GrafiteAst.Tactic (_, None, punct) ->
+ eval_tactical status
+ (punctuation_tactical_of_ast (text,prefix_len,punct)),[]
+ | GrafiteAst.NonPunctuationTactical (_, tac, punct) ->
let status =
- eval_tactical ~disambiguate_tactic status (text,prefix_len,tac) in
- eval_tactical ~disambiguate_tactic status (text,prefix_len,punct),[]
+ eval_tactical status
+ (non_punctuation_tactical_of_ast (text,prefix_len,tac))
+ in
+ eval_tactical status
+ (punctuation_tactical_of_ast (text,prefix_len,punct)),[]
| GrafiteAst.Command (_, cmd) ->
eval_command.ec_go ~disambiguate_command opts status (text,prefix_len,cmd)
| GrafiteAst.Macro (loc, macro) ->
projects / helm.git / blobdiff