ask_confirmation: title:string -> message:string -> [`YES | `NO | `CANCEL];
}
-let eval_with_engine include_paths guistuff lexicon_status grafite_status user_goal
+let eval_with_engine include_paths guistuff grafite_status user_goal
skipped_txt nonskipped_txt st
=
let module TAPp = GrafiteAstPp in
let enriched_history_fragment =
MatitaEngine.eval_ast ~do_heavy_checks:(Helm_registry.get_bool
"matita.do_heavy_checks")
- lexicon_status grafite_status (text,prefix_len,st)
+ grafite_status (text,prefix_len,st)
in
let enriched_history_fragment = List.rev enriched_history_fragment in
(* really fragile *)
stupid_indenter script
;;
-let rec eval_macro include_paths (buffer : GText.buffer) guistuff lexicon_status grafite_status user_goal unparsed_text parsed_text script mac =
+let rec eval_macro include_paths (buffer : GText.buffer) guistuff grafite_status user_goal unparsed_text parsed_text script mac =
let module TAPp = GrafiteAstPp in
let module MQ = MetadataQuery in
let module MDB = LibraryDb in
let loc = HExtlib.floc_of_loc (0,text_len) in
let statement = `Ast (GrafiteParser.LSome (ast loc),text) in
let res,_,_parsed_text_len =
- eval_statement include_paths buffer guistuff lexicon_status
+ eval_statement include_paths buffer guistuff
grafite_status user_goal script statement
in
(* we need to replace all the parsed_text *)
in
let t_and_ty = Cic.Cast (term,ty) in
guistuff.mathviewer#show_entry (`Cic (t_and_ty,metasenv));
- [({grafite_status with proof_status = No_proof},lexicon_status), parsed_text ],"",
+ [({grafite_status with proof_status = No_proof}), parsed_text ],"",
parsed_text_length
| TA.Check (_,term) ->
let metasenv = GrafiteTypes.get_proof_metasenv grafite_status in
[], str, String.length parsed_text
and eval_executable include_paths (buffer : GText.buffer) guistuff
-lexicon_status grafite_status user_goal unparsed_text skipped_txt nonskipped_txt
+grafite_status user_goal unparsed_text skipped_txt nonskipped_txt
script ex loc
=
let module TAPp = GrafiteAstPp in
~where:((buffer#get_iter_at_mark (`NAME "locked"))#forward_chars
(Glib.Utf8.length skipped_txt))) ;
eval_with_engine include_paths
- guistuff lexicon_status grafite_status user_goal skipped_txt nonskipped_txt
+ guistuff grafite_status user_goal skipped_txt nonskipped_txt
(TA.Executable (loc, ex))
with
MatitaTypes.Cancel -> [], "", 0
None -> []
| Some n -> GrafiteTypes.get_proof_context grafite_status n in
let grafite_status,macro = lazy_macro context in
- eval_macro include_paths buffer guistuff lexicon_status grafite_status
+ eval_macro include_paths buffer guistuff grafite_status
user_goal unparsed_text (skipped_txt ^ nonskipped_txt) script macro
-and eval_statement include_paths (buffer : GText.buffer) guistuff lexicon_status
+and eval_statement include_paths (buffer : GText.buffer) guistuff
grafite_status user_goal script statement
=
let (lexicon_status,st), unparsed_text =
if Pcre.pmatch ~rex:only_dust_RE text then raise Margin;
let ast =
wrap_with_make include_paths
- (GrafiteParser.parse_statement (Ulexing.from_utf8_string text)) lexicon_status
+ (GrafiteParser.parse_statement (Ulexing.from_utf8_string text))
+ (GrafiteTypes.get_lexicon grafite_status)
in
ast, text
- | `Ast (st, text) -> (lexicon_status, st), text
+ | `Ast (st, text) -> (GrafiteTypes.get_lexicon grafite_status, st), text
in
+ let grafite_status = GrafiteTypes.set_lexicon lexicon_status grafite_status in
let text_of_loc floc =
let nonskipped_txt,_ = MatitaGtkMisc.utf8_parsed_text unparsed_text floc in
let start, stop = HExtlib.loc_of_floc floc in
match st with
| GrafiteParser.LNone loc ->
let parsed_text, _, _, parsed_text_length = text_of_loc loc in
- [(grafite_status,lexicon_status),parsed_text],"",
+ [grafite_status,parsed_text],"",
parsed_text_length
| GrafiteParser.LSome (GrafiteAst.Comment (loc, _)) ->
let parsed_text, _, _, parsed_text_length = text_of_loc loc in
let s = String.sub unparsed_text parsed_text_length remain_len in
let s,text,len =
try
- eval_statement include_paths buffer guistuff lexicon_status
+ eval_statement include_paths buffer guistuff
grafite_status user_goal script (`Raw s)
with
HExtlib.Localized (floc, exn) ->
let _, nonskipped, skipped, parsed_text_length =
text_of_loc loc
in
- eval_executable include_paths buffer guistuff lexicon_status
+ eval_executable include_paths buffer guistuff
grafite_status user_goal unparsed_text skipped nonskipped script ex loc
let fresh_script_id =
BuildTimeConf.core_notation_script
in
let grafite_status = GrafiteSync.init lexicon_status baseuri in
- grafite_status,lexicon_status
+ grafite_status
in
let read_include_paths file =
try
(* history can't be empty, the invariant above grant that it contains at
* least the init grafite_status *)
- method grafite_status = match history with (s,_)::_ -> s | _ -> assert false
- method lexicon_status = match history with (_,ss)::_ -> ss | _ -> assert false
+ method grafite_status = match history with s::_ -> s | _ -> assert false
method private _advance ?statement () =
let s = match statement with Some s -> s | None -> self#getFuture in
HLog.debug ("evaluating: " ^ first_line s ^ " ...");
let entries, newtext, parsed_len =
try
- eval_statement self#include_paths buffer guistuff self#lexicon_status
+ eval_statement self#include_paths buffer guistuff
self#grafite_status userGoal self (`Raw s)
with End_of_file -> raise Margin
in
with Failure _ -> None)
| _ -> userGoal <- None
- method private _retract offset lexicon_status grafite_status new_statements
+ method private _retract offset grafite_status new_statements
new_history
=
- let cur_grafite_status,cur_lexicon_status =
+ let cur_grafite_status =
match history with s::_ -> s | [] -> assert false
in
- LexiconSync.time_travel ~present:cur_lexicon_status ~past:lexicon_status;
+ LexiconSync.time_travel
+ ~present:(GrafiteTypes.get_lexicon cur_grafite_status)
+ ~past:(GrafiteTypes.get_lexicon grafite_status);
GrafiteSync.time_travel ~present:cur_grafite_status ~past:grafite_status;
statements <- new_statements;
history <- new_history;
method retract () =
try
- let cmp,new_statements,new_history,(grafite_status,lexicon_status) =
+ let cmp,new_statements,new_history,grafite_status =
match statements,history with
stat::statements, _::(status::_ as history) ->
assert (Glib.Utf8.validate stat);
| [],[_] -> raise Margin
| _,_ -> assert false
in
- self#_retract cmp lexicon_status grafite_status new_statements
+ self#_retract cmp grafite_status new_statements
new_history;
self#notify
with
val mutable observers = []
- method addObserver (o: LexiconEngine.status -> GrafiteTypes.status -> unit) =
+ method addObserver (o: GrafiteTypes.status -> unit) =
observers <- o :: observers
method private notify =
- let lexicon_status = self#lexicon_status in
let grafite_status = self#grafite_status in
- List.iter (fun o -> o lexicon_status grafite_status) observers
+ List.iter (fun o -> o grafite_status) observers
method loadFromString s =
buffer#set_text s;
end
method private goto_top =
- let grafite_status,lexicon_status =
+ let grafite_status =
let rec last x = function
| [] -> x
| hd::tl -> last hd tl
in
- last (self#grafite_status,self#lexicon_status) history
+ last (self#grafite_status) history
in
(* FIXME: this is not correct since there is no undo for
* library_objects.set_default... *)
GrafiteSync.time_travel ~present:self#grafite_status ~past:grafite_status;
- LexiconSync.time_travel ~present:self#lexicon_status ~past:lexicon_status
+ LexiconSync.time_travel
+ ~present:(GrafiteTypes.get_lexicon self#grafite_status)
+ ~past:(GrafiteTypes.get_lexicon grafite_status)
method private reset_buffer =
statements <- [];
in
let rec back_until_cursor len = (* go backward until locked < cursor *)
function
- statements, ((grafite_status,lexicon_status)::_ as history)
+ statements, ((grafite_status)::_ as history)
when len <= 0 ->
- self#_retract (icmp - len) lexicon_status grafite_status statements
+ self#_retract (icmp - len) grafite_status statements
history
| statement::tl1, _::tl2 ->
back_until_cursor (len - MatitaGtkMisc.utf8_string_length statement) (tl1,tl2)
| GrafiteParser.LSome (GrafiteAst.Executable _) -> false
in
try
- is_there_only_comments self#lexicon_status self#getFuture
+ is_there_only_comments
+ (GrafiteTypes.get_lexicon self#grafite_status) self#getFuture
with
| LexiconEngine.IncludedFileNotCompiled _
| HExtlib.Localized _
projects / helm.git / blobdiff