clean_baseuri: bool
}
-type statement =
- (CicNotationPt.term, CicNotationPt.term, GrafiteAst.reduction, GrafiteAst.obj,
- string)
- GrafiteAst.statement
-
(** 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 *)
| GrafiteAst.Absurd (_, term) -> Tactics.absurd term
| GrafiteAst.Apply (_, term) -> Tactics.apply term
| GrafiteAst.Assumption _ -> Tactics.assumption
- | GrafiteAst.Auto (_,depth,width,paramodulation) ->
- AutoTactic.auto_tac ?depth ?width ?paramodulation
+ | GrafiteAst.Auto (_,depth,width,paramodulation,full) ->
+ AutoTactic.auto_tac ?depth ?width ?paramodulation ?full
~dbd:(MatitaDb.instance ()) ()
| GrafiteAst.Change (_, pattern, with_what) ->
Tactics.change ~pattern with_what
| [x], _ -> x
| _ -> assert false
-let disambiguate_term status_ref term =
+ (** @param term not meaningful when context is given *)
+let disambiguate_term ?context status_ref goal term =
let status = !status_ref in
+ let context =
+ match context with
+ | Some c -> c
+ | None -> MatitaTypes.get_proof_context status goal
+ in
let (diff, metasenv, cic, _) =
singleton
(MatitaDisambiguator.disambiguate_term ~dbd:(MatitaDb.instance ())
~aliases:status.aliases ~universe:(Some status.multi_aliases)
- ~context:(MatitaMisc.get_proof_context status)
- ~metasenv:(MatitaMisc.get_proof_metasenv status) term)
+ ~context ~metasenv:(MatitaTypes.get_proof_metasenv status) term)
in
let status = MatitaTypes.set_metasenv metasenv status in
let status = MatitaSync.set_proof_aliases status diff in
| `Unfold None
| `Whd as kind -> kind
-let disambiguate_tactic status tactic =
+let disambiguate_tactic status goal tactic =
let status_ref = ref status in
let tactic =
match tactic with
| GrafiteAst.Absurd (loc, term) ->
- let cic = disambiguate_term status_ref term in
+ let cic = disambiguate_term status_ref goal term in
GrafiteAst.Absurd (loc, cic)
| GrafiteAst.Apply (loc, term) ->
- let cic = disambiguate_term status_ref term in
+ let cic = disambiguate_term status_ref goal term in
GrafiteAst.Apply (loc, cic)
| GrafiteAst.Assumption loc -> GrafiteAst.Assumption loc
- | GrafiteAst.Auto (loc,depth,width,paramodulation) ->
- GrafiteAst.Auto (loc,depth,width,paramodulation)
+ | GrafiteAst.Auto (loc,depth,width,paramodulation,full) ->
+ GrafiteAst.Auto (loc,depth,width,paramodulation,full)
| GrafiteAst.Change (loc, pattern, with_what) ->
let with_what = disambiguate_lazy_term status_ref with_what in
let pattern = disambiguate_pattern status_ref pattern in
| GrafiteAst.Clear (loc,id) -> GrafiteAst.Clear (loc,id)
| GrafiteAst.ClearBody (loc,id) -> GrafiteAst.ClearBody (loc,id)
| GrafiteAst.Compare (loc,term) ->
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term status_ref goal term in
GrafiteAst.Compare (loc,term)
| GrafiteAst.Constructor (loc,n) -> GrafiteAst.Constructor (loc,n)
| GrafiteAst.Contradiction loc -> GrafiteAst.Contradiction loc
| GrafiteAst.Cut (loc, ident, term) ->
- let cic = disambiguate_term status_ref term in
+ let cic = disambiguate_term status_ref goal term in
GrafiteAst.Cut (loc, ident, cic)
| GrafiteAst.DecideEquality loc -> GrafiteAst.DecideEquality loc
| GrafiteAst.Decompose (loc, types, what, names) ->
let disambiguate types = function
| GrafiteAst.Type _ -> assert false
| GrafiteAst.Ident id ->
- (match disambiguate_term status_ref (CicNotationPt.Ident (id, None)) with
+ (match disambiguate_term status_ref goal
+ (CicNotationPt.Ident (id, None))
+ with
| Cic.MutInd (uri, tyno, _) ->
(GrafiteAst.Type (uri, tyno) :: types)
- | _ -> raise Disambiguate.NoWellTypedInterpretation)
+ | _ -> raise (MatitaDisambiguator.DisambiguationError [[lazy "Decompose works only on inductive types"]]))
in
let types = List.fold_left disambiguate [] types in
GrafiteAst.Decompose (loc, types, what, names)
| GrafiteAst.Discriminate (loc,term) ->
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term status_ref goal term in
GrafiteAst.Discriminate(loc,term)
| GrafiteAst.Exact (loc, term) ->
- let cic = disambiguate_term status_ref term in
+ let cic = disambiguate_term status_ref goal term in
GrafiteAst.Exact (loc, cic)
| GrafiteAst.Elim (loc, what, Some using, depth, idents) ->
- let what = disambiguate_term status_ref what in
- let using = disambiguate_term status_ref using in
+ let what = disambiguate_term status_ref goal what in
+ let using = disambiguate_term status_ref goal using in
GrafiteAst.Elim (loc, what, Some using, depth, idents)
| GrafiteAst.Elim (loc, what, None, depth, idents) ->
- let what = disambiguate_term status_ref what in
+ let what = disambiguate_term status_ref goal what in
GrafiteAst.Elim (loc, what, None, depth, idents)
| GrafiteAst.ElimType (loc, what, Some using, depth, idents) ->
- let what = disambiguate_term status_ref what in
- let using = disambiguate_term status_ref using in
+ let what = disambiguate_term status_ref goal what in
+ let using = disambiguate_term status_ref goal using in
GrafiteAst.ElimType (loc, what, Some using, depth, idents)
| GrafiteAst.ElimType (loc, what, None, depth, idents) ->
- let what = disambiguate_term status_ref what in
+ let what = disambiguate_term status_ref goal what in
GrafiteAst.ElimType (loc, what, None, depth, idents)
| GrafiteAst.Exists loc -> GrafiteAst.Exists loc
| GrafiteAst.Fail loc -> GrafiteAst.Fail loc
| GrafiteAst.Goal (loc, g) -> GrafiteAst.Goal (loc, g)
| GrafiteAst.IdTac loc -> GrafiteAst.IdTac loc
| GrafiteAst.Injection (loc, term) ->
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term status_ref goal term in
GrafiteAst.Injection (loc,term)
| GrafiteAst.Intros (loc, num, names) -> GrafiteAst.Intros (loc, num, names)
| GrafiteAst.LApply (loc, depth, to_what, what, ident) ->
let f term to_what =
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term status_ref goal term in
term :: to_what
in
let to_what = List.fold_right f to_what [] in
- let what = disambiguate_term status_ref what in
+ let what = disambiguate_term status_ref goal what in
GrafiteAst.LApply (loc, depth, to_what, what, ident)
| GrafiteAst.Left loc -> GrafiteAst.Left loc
| GrafiteAst.LetIn (loc, term, name) ->
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term status_ref goal term in
GrafiteAst.LetIn (loc,term,name)
| GrafiteAst.Reduce (loc, red_kind, pattern) ->
let pattern = disambiguate_pattern status_ref pattern in
let with_what = disambiguate_lazy_term status_ref with_what in
GrafiteAst.Replace (loc, pattern, with_what)
| GrafiteAst.Rewrite (loc, dir, t, pattern) ->
- let term = disambiguate_term status_ref t in
+ let term = disambiguate_term status_ref goal t in
let pattern = disambiguate_pattern status_ref pattern in
GrafiteAst.Rewrite (loc, dir, term, pattern)
| GrafiteAst.Right loc -> GrafiteAst.Right loc
| GrafiteAst.Split loc -> GrafiteAst.Split loc
| GrafiteAst.Symmetry loc -> GrafiteAst.Symmetry loc
| GrafiteAst.Transitivity (loc, term) ->
- let cic = disambiguate_term status_ref term in
+ let cic = disambiguate_term status_ref goal term in
GrafiteAst.Transitivity (loc, cic)
in
status_ref, tactic
let reorder_metasenv start refine tactic goals current_goal always_opens_a_goal=
let module PEH = ProofEngineHelpers in
+(* let print_m name metasenv =
+ prerr_endline (">>>>> " ^ name);
+ prerr_endline (CicMetaSubst.ppmetasenv [] metasenv)
+ in *)
(* phase one calculates:
* new_goals_from_refine: goals added by refine
* head_goal: the first goal opened by ythe tactic
if always_opens_a_goal then
metas_for_tactic_head @ metas_for_refine_goals @
metas_for_tactic_goals
- else
+ else begin
+(* print_m "metas_for_refine_goals" metas_for_refine_goals;
+ print_m "metas_for_tactic_head" metas_for_tactic_head;
+ print_m "metas_for_tactic_goals" metas_for_tactic_goals; *)
metas_for_refine_goals @ metas_for_tactic_head @
metas_for_tactic_goals
+ end
in
let goals = List.map (fun (metano, _, _) -> metano) produced_metas in
produced_metas, goals
let after = extract after_l in
before, after
in
- (* DEBUG CODE
- let print_m name metasenv =
- prerr_endline (">>>>> " ^ name);
- prerr_endline (CicMetaSubst.ppmetasenv metasenv [])
- in
+(* |+ DEBUG CODE +|
print_m "BEGIN" start;
prerr_endline ("goal was: " ^ string_of_int current_goal);
prerr_endline ("and metas from refine are:");
print_m "metas_for_tactic_head" metas_for_tactic_head;
print_m "metas_for_refine_goals" metas_for_refine_goals;
print_m "metas_for_tactic_goals" metas_for_tactic_goals;
+ print_m "produced_metas" produced_metas;
print_m "after" after;
- FINE DEBUG CODE *)
+|+ FINE DEBUG CODE +| *)
before @ produced_metas @ after, goals
(* maybe we only need special cases for apply and goal *)
| GrafiteAst.IdTac _
| 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
(* tactics like apply *)
| _ -> true, false
-let apply_tactic tactic status =
- let starting_metasenv = MatitaMisc.get_proof_metasenv status in
- let status_ref, tactic = disambiguate_tactic status tactic in
- let metasenv_after_refinement = MatitaMisc.get_proof_metasenv !status_ref in
- let proof_status = MatitaMisc.get_proof_status !status_ref in
+let apply_tactic tactic (status, goal) =
+(* prerr_endline "apply_tactic"; *)
+(* prerr_endline (Continuationals.Stack.pp (MatitaTypes.get_stack status)); *)
+ let starting_metasenv = MatitaTypes.get_proof_metasenv status in
+ let before = List.map (fun g, _, _ -> g) starting_metasenv in
+(* prerr_endline "disambiguate"; *)
+ let status_ref, tactic = disambiguate_tactic status goal tactic in
+ let metasenv_after_refinement = MatitaTypes.get_proof_metasenv !status_ref in
+ let proof = MatitaTypes.get_current_proof !status_ref in
+ let proof_status = proof, goal in
let needs_reordering, always_opens_a_goal = classify_tactic tactic in
let tactic = tactic_of_ast tactic in
(* apply tactic will change the status pointed by status_ref ... *)
- let current_goal = let _, g = proof_status in g in
- let (proof, goals) = ProofEngineTypes.apply_tactic tactic proof_status in
- let proof, goals =
- if needs_reordering then
+(* prerr_endline "apply_tactic bassa"; *)
+ 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
+(* prerr_endline("before: " ^ String.concat ", " (List.map string_of_int before));
+prerr_endline("after: " ^ String.concat ", " (List.map string_of_int after));
+prerr_endline("opened: " ^ String.concat ", " (List.map string_of_int opened)); *)
+(* prerr_endline("opened_goals: " ^ String.concat ", " (List.map string_of_int opened_goals));
+prerr_endline("closed_goals: " ^ String.concat ", " (List.map string_of_int closed_goals)); *)
+ let proof, opened_goals =
+ if needs_reordering then begin
let uri, metasenv_after_tactic, t, ty = proof in
- let reordered_metasenv, goals =
- reorder_metasenv starting_metasenv metasenv_after_refinement
- metasenv_after_tactic goals current_goal always_opens_a_goal in
- (uri, reordered_metasenv, t, ty), goals
- else
- proof, goals
+(* prerr_endline ("goal prima del riordino: " ^ String.concat " " (List.map string_of_int (ProofEngineTypes.goals_of_proof proof))); *)
+ 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 in
+(* prerr_endline ("goal dopo il riordino: " ^ String.concat " " (List.map string_of_int (ProofEngineTypes.goals_of_proof proof'))); *)
+ proof', opened_goals
+ end
+ else
+ proof, opened_goals
in
- let dummy = -1 in
- { !status_ref with
- proof_status = MatitaTypes.Incomplete_proof (proof,dummy) },
- goals
+ let incomplete_proof =
+ match !status_ref.proof_status with
+ | Incomplete_proof p -> p
+ | _ -> assert false
+ in
+ { !status_ref with proof_status =
+ Incomplete_proof { incomplete_proof with proof = proof } },
+ opened_goals, closed_goals
module MatitaStatus =
- struct
- type input_status = MatitaTypes.status
- type output_status = MatitaTypes.status * ProofEngineTypes.goal list
- type tactic = input_status -> output_status
+struct
+ type input_status = MatitaTypes.status * ProofEngineTypes.goal
- let focus (status,_) goal =
- let proof,_ = MatitaMisc.get_proof_status status in
- {status with proof_status = MatitaTypes.Incomplete_proof (proof,goal)}
+ type output_status =
+ MatitaTypes.status * ProofEngineTypes.goal list * ProofEngineTypes.goal list
- let goals (_,goals) = goals
-
- let set_goals (status,_) goals = status,goals
-
- let id_tac status =
- apply_tactic (GrafiteAst.IdTac DisambiguateTypes.dummy_floc) status
+ type tactic = input_status -> output_status
+ let id_tactic = apply_tactic (GrafiteAst.IdTac DisambiguateTypes.dummy_floc)
let mk_tactic tac = tac
-
let apply_tactic tac = tac
+ let goals (_, opened, closed) = opened, closed
+ let set_goals (opened, closed) (status, _, _) = (status, opened, closed)
+ let get_stack (status, _) = MatitaTypes.get_stack status
- end
+ let set_stack stack (status, opened, closed) =
+ MatitaTypes.set_stack stack status, opened, closed
-module MatitaTacticals = Tacticals.Make(MatitaStatus)
+ let inject (status, _) = (status, [], [])
+ let focus goal (status, _, _) = (status, goal)
+end
+
+module MatitaTacticals = Tacticals.Make (MatitaStatus)
let eval_tactical status tac =
- let rec tactical_of_ast tac =
- match tac with
- | GrafiteAst.Tactic (loc, tactic) -> apply_tactic tactic
+ let rec tactical_of_ast l tac =
+ match tac with
+ | GrafiteAst.Tactic (loc, tactic) ->
+ MatitaTacticals.tactic (MatitaStatus.mk_tactic (apply_tactic tactic))
| GrafiteAst.Seq (loc, tacticals) -> (* tac1; tac2; ... *)
- MatitaTacticals.seq ~tactics:(List.map tactical_of_ast tacticals)
- | GrafiteAst.Do (loc, num, tactical) ->
- MatitaTacticals.do_tactic ~n:num ~tactic:(tactical_of_ast tactical)
+ 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, tactical) ->
- MatitaTacticals.repeat_tactic ~tactic:(tactical_of_ast tactical)
+ MatitaTacticals.repeat_tactic ~tactic:(tactical_of_ast (l+1) tactical)
| GrafiteAst.Then (loc, tactical, tacticals) -> (* tac; [ tac1 | ... ] *)
- MatitaTacticals.thens ~start:(tactical_of_ast tactical)
- ~continuations:(List.map tactical_of_ast tacticals)
+ assert (l > 0);
+ MatitaTacticals.thens ~start:(tactical_of_ast (l+1) tactical)
+ ~continuations:(List.map (tactical_of_ast (l+1)) tacticals)
| GrafiteAst.First (loc, tacticals) ->
MatitaTacticals.first
- ~tactics:(List.map (fun t -> "", tactical_of_ast t) tacticals)
+ ~tactics:(List.map (fun t -> "", tactical_of_ast (l+1) t) tacticals)
| GrafiteAst.Try (loc, tactical) ->
- MatitaTacticals.try_tactic ~tactic:(tactical_of_ast tactical)
+ MatitaTacticals.try_tactic ~tactic:(tactical_of_ast (l+1) tactical)
| GrafiteAst.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)
+ ~tactics:(List.map (fun t -> "", tactical_of_ast (l+1) t) tacticals)
+
+ | GrafiteAst.Skip loc -> MatitaTacticals.skip
+ | 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.Focus (loc, goals) -> MatitaTacticals.focus goals
+ | GrafiteAst.Unfocus loc -> MatitaTacticals.unfocus
in
- { status with proof_status = new_status }
+ let status, _, _ = tactical_of_ast 0 tac (status, ~-1) in
+ let status = (* is proof completed? *)
+ match status.proof_status with
+ | Incomplete_proof { stack = stack; proof = proof }
+ when Continuationals.Stack.is_empty stack ->
+ { status with proof_status = Proof proof }
+ | _ -> status
+ in
+ status
let eval_coercion status coercion =
let coer_uri,coer_ty =
in
let ty_src,ty_tgt = extract_last_two_p coer_ty in
let context = [] in
- let src_uri =
- let ty_src = CicReduction.whd context ty_src in
- CicUtil.uri_of_term ty_src
- in
- let tgt_uri =
- let ty_tgt = CicReduction.whd context ty_tgt in
- CicUtil.uri_of_term ty_tgt
- in
+ let src_uri = CoercDb.coerc_carr_of_term (CicReduction.whd context ty_src) in
+ let tgt_uri = CoercDb.coerc_carr_of_term (CicReduction.whd context ty_tgt) in
let new_coercions =
- (* also adds them to the Db *)
CoercGraph.close_coercion_graph src_uri tgt_uri coer_uri in
let status =
- List.fold_left (fun s (uri,o,_) -> MatitaSync.add_obj uri o status)
+ List.fold_left (fun s (uri,o,_) ->
+ let status = MatitaSync.add_obj uri o status in
+ {status with coercions = uri :: status.coercions})
status new_coercions in
+ let status = {status with coercions = coer_uri :: status.coercions} in
let statement_of name =
GrafiteAst.Coercion (DisambiguateTypes.dummy_floc,
(CicNotationPt.Ident (name, None)))
with
CicTypeChecker.TypeCheckerFailure s ->
MatitaLog.message
- ("Unable to create projection " ^ name ^ " cause: " ^ s);
+ ("Unable to create projection " ^ name ^ " cause: " ^ (Lazy.force s));
status
| CicEnvironment.Object_not_found uri ->
let depend = UriManager.name_of_uri uri in
) status projections
(* to avoid a long list of recursive functions *)
-let eval_from_stream_ref = ref (fun _ _ _ -> assert false);;
+let eval_from_moo_ref = ref (fun _ _ _ -> assert false);;
let disambiguate_obj status obj =
let uri =
match obj with
GrafiteAst.Inductive (_,(name,_,_,_)::_)
| GrafiteAst.Record (_,name,_,_) ->
- Some (UriManager.uri_of_string (MatitaMisc.qualify status name ^ ".ind"))
+ Some (UriManager.uri_of_string (MatitaTypes.qualify status name ^ ".ind"))
| GrafiteAst.Inductive _ -> assert false
| GrafiteAst.Theorem _ -> None in
let (diff, metasenv, cic, _) =
let status = MatitaSync.set_proof_aliases status diff in
status, cic
-let disambiguate_command status = function
+let disambiguate_command status =
+ function
| GrafiteAst.Alias _
| GrafiteAst.Default _
| GrafiteAst.Drop _
| GrafiteAst.Dump _
| GrafiteAst.Include _
| GrafiteAst.Interpretation _
+ | GrafiteAst.Metadata _
| GrafiteAst.Notation _
| GrafiteAst.Qed _
| GrafiteAst.Render _
status,cmd
| GrafiteAst.Coercion (loc, term) ->
let status_ref = ref status in
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term ~context:[] status_ref ~-1 term in
!status_ref, GrafiteAst.Coercion (loc,term)
| GrafiteAst.Obj (loc,obj) ->
let status,obj = disambiguate_obj status obj in
with Unix.Unix_error _ as exc -> raise (UnableToInclude path)
;;
-let profiler_include = CicUtil.profile "include"
-
let eval_command opts status cmd =
let status,cmd = disambiguate_command status cmd in
let cmd,notation_ids' = CicNotation.process_notation cmd in
add_moo_content [cmd] status
| GrafiteAst.Include (loc, path) ->
let absolute_path = make_absolute opts.include_paths path in
- let moopath = MatitaMisc.obj_file_of_script absolute_path in
- let ic =
- try open_in moopath with Sys_error _ ->
- raise (IncludedFileNotCompiled moopath) in
- let stream = Ulexing.from_utf8_channel ic in
+ let moopath = MatitacleanLib.obj_file_of_script absolute_path in
let status = ref status in
- profiler_include.CicUtil.profile
- (!eval_from_stream_ref status stream) (fun _ _ -> ());
- close_in ic;
- !status
+ if not (Sys.file_exists moopath) then
+ raise (IncludedFileNotCompiled moopath);
+ !eval_from_moo_ref status moopath (fun _ _ -> ());
+ !status
+ | GrafiteAst.Metadata (loc, m) ->
+ (match m with
+ | GrafiteAst.Dependency uri -> MatitaTypes.add_moo_metadata [m] status
+ | GrafiteAst.Baseuri _ -> status)
| GrafiteAst.Set (loc, name, value) ->
- let value =
- if name = "baseuri" then
- let v = MatitaMisc.strip_trailing_slash value in
- try
- ignore (String.index v ' ');
- command_error "baseuri can't contain spaces"
- with Not_found -> v
- else
- value
+ let status =
+ if name = "baseuri" then begin
+ let value =
+ let v = MatitaMisc.strip_trailing_slash value in
+ try
+ ignore (String.index v ' ');
+ command_error "baseuri can't contain spaces"
+ with Not_found -> v
+ in
+ if not (MatitaMisc.is_empty value) && opts.clean_baseuri then begin
+ MatitaLog.warn ("baseuri " ^ value ^ " is not empty");
+ MatitaLog.message ("cleaning baseuri " ^ value);
+ MatitacleanLib.clean_baseuris [value]
+ end;
+ add_moo_metadata [GrafiteAst.Baseuri value] status
+ end else
+ status
in
- if not (MatitaMisc.is_empty value) then
- begin
- MatitaLog.warn ("baseuri " ^ value ^ " is not empty");
- if opts.clean_baseuri then
- begin
- MatitaLog.message ("cleaning baseuri " ^ value);
- MatitacleanLib.clean_baseuris [value]
- end
- end;
set_option status name value
| GrafiteAst.Drop loc -> raise Drop
| GrafiteAst.Qed loc ->
command_error
("Someone allows to start a thm without giving the "^
"name/uri. This should be fixed!")
- | _-> command_error "You can't qed an uncomplete theorem"
+ | _-> command_error "You can't Qed an incomplete theorem"
in
let suri = UriManager.string_of_uri uri in
if metasenv <> [] then
let name = UriManager.name_of_uri uri in
let obj = Cic.Constant (name,Some bo,ty,[],[]) in
MatitaSync.add_obj uri obj status
- | GrafiteAst.Coercion (loc, coercion) ->
- eval_coercion status coercion
+ | GrafiteAst.Coercion (loc, coercion) -> eval_coercion status coercion
| GrafiteAst.Alias (loc, spec) ->
let diff =
(*CSC: Warning: this code should be factorized with the corresponding
MatitaSync.set_proof_aliases status diff
| GrafiteAst.Render _ -> assert false (* ZACK: to be removed *)
| GrafiteAst.Dump _ -> assert false (* ZACK: to be removed *)
- | GrafiteAst.Interpretation (_, dsc, (symbol, _), _) as stm ->
- let status' = add_moo_content [stm] status in
+ | GrafiteAst.Interpretation (_, dsc, (symbol, _), cic_appl_pattern) as stm ->
+ let status = add_moo_content [stm] status in
+ let uris =
+ List.map
+ (fun uri -> GrafiteAst.Dependency (UriManager.buri_of_uri uri))
+ (CicNotationUtil.find_appl_pattern_uris cic_appl_pattern)
+ in
let diff =
[DisambiguateTypes.Symbol (symbol, 0),
DisambiguateChoices.lookup_symbol_by_dsc symbol dsc]
in
- MatitaSync.set_proof_aliases status' diff
+ let status = MatitaSync.set_proof_aliases status diff in
+ let status = MatitaTypes.add_moo_metadata uris status in
+ status
| GrafiteAst.Notation _ as stm -> add_moo_content [stm] status
| GrafiteAst.Obj (loc,obj) ->
let ext,name =
(match types with (name,_,_,_)::_ -> name | _ -> assert false)
| _ -> assert false in
let uri =
- UriManager.uri_of_string (MatitaMisc.qualify status name ^ ext)
+ UriManager.uri_of_string (MatitaTypes.qualify status name ^ ext)
in
- let metasenv = MatitaMisc.get_proof_metasenv status in
+ let metasenv = MatitaTypes.get_proof_metasenv status in
match obj with
| Cic.CurrentProof (_,metasenv',bo,ty,_,_) ->
let name = UriManager.name_of_uri uri in
match metasenv' with (goalno,_,_)::_ -> goalno | _ -> assert false
in
let initial_proof = (Some uri, metasenv, bo, ty) in
- { status with proof_status = Incomplete_proof (initial_proof,goalno)}
+ let initial_stack = Continuationals.Stack.of_metasenv metasenv in
+ { status with proof_status =
+ Incomplete_proof { proof = initial_proof; stack = initial_stack } }
| _ ->
if metasenv <> [] then
command_error (
let eval_executable opts status ex =
match ex with
- | GrafiteAst.Tactical (_, tac) -> eval_tactical status tac
+ | GrafiteAst.Tactical (_, tac, None) -> eval_tactical status tac
+ | GrafiteAst.Tactical (_, tac, Some punct) ->
+ let status = eval_tactical status tac in
+ eval_tactical status punct
| GrafiteAst.Command (_, cmd) -> eval_command opts status cmd
| GrafiteAst.Macro (_, mac) ->
command_error (sprintf "The macro %s can't be in a script"
let eval_comment status c = status
-
let eval_ast
?(do_heavy_checks=false) ?(include_paths=[]) ?(clean_baseuri=true) status st
=
| GrafiteAst.Executable (_,ex) -> eval_executable opts status ex
| GrafiteAst.Comment (_,c) -> eval_comment status c
+let eval_from_moo ?do_heavy_checks ?include_paths ?clean_baseuri status fname cb
+=
+ let ast_of_cmd cmd =
+ GrafiteAst.Executable (DisambiguateTypes.dummy_floc,
+ GrafiteAst.Command (DisambiguateTypes.dummy_floc,
+ (GrafiteAst.reash_cmd_uris cmd)))
+ in
+ let moo, metadata = MatitaMoo.load_moo fname in
+ List.iter
+ (fun ast ->
+ let ast = ast_of_cmd ast in
+ cb !status ast;
+ status :=
+ eval_ast ?do_heavy_checks ?include_paths ?clean_baseuri !status ast)
+ moo;
+ List.iter
+ (fun m ->
+ let ast =
+ ast_of_cmd (GrafiteAst.Metadata (DisambiguateTypes.dummy_floc, m))
+ in
+ cb !status ast;
+ status :=
+ eval_ast ?do_heavy_checks ?include_paths ?clean_baseuri !status ast)
+ metadata
+
let eval_from_stream
?do_heavy_checks ?include_paths ?clean_baseuri status str cb
=
while true do
let ast = GrafiteParser.parse_statement str in
cb !status ast;
- status := eval_ast ?do_heavy_checks ?include_paths ?clean_baseuri !status ast
+ status :=
+ eval_ast ?do_heavy_checks ?include_paths ?clean_baseuri !status ast
done
with End_of_file -> ()
(* to avoid a long list of recursive functions *)
-let _ = eval_from_stream_ref := eval_from_stream
+let _ = eval_from_moo_ref := eval_from_moo
let eval_from_stream_greedy
?do_heavy_checks ?include_paths ?clean_baseuri status str cb
let eval_string ?do_heavy_checks ?include_paths ?clean_baseuri status str =
eval_from_stream
?do_heavy_checks ?include_paths ?clean_baseuri status
- (Ulexing.from_utf8_string str) (fun _ _ ->())
+ (Ulexing.from_utf8_string str) (fun _ _ -> ())
let default_options () =
(*
lazy {
aliases = DisambiguateTypes.Environment.empty;
multi_aliases = DisambiguateTypes.Environment.empty;
- moo_content_rev = [];
+ moo_content_rev = [], [];
proof_status = No_proof;
options = default_options ();
objects = [];
+ coercions = [];
notation_ids = [];
}
projects / helm.git / blobdiff