| 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
projects / helm.git / blobdiff