+class script ~(source_view: GSourceView.source_view)
+ ~(init: MatitaTypes.status)
+ ~(mathviewer: MatitaTypes.mathViewer)
+ ~set_star
+ ~ask_confirmation
+ ~urichooser
+ ~develcreator
+ () =
+let buffer = source_view#buffer in
+let source_buffer = source_view#source_buffer in
+object (self)
+ val scriptId = fresh_script_id ()
+
+ val guistuff = {
+ mathviewer = mathviewer;
+ urichooser = urichooser;
+ ask_confirmation = ask_confirmation;
+ develcreator = develcreator;
+ filenamedata = (None, None)}
+
+ method private getFilename =
+ match guistuff.filenamedata with Some f,_ -> f | _ -> assert false
+
+ method filename = self#getFilename
+
+ method private ppFilename =
+ match guistuff.filenamedata with
+ | Some f,_ -> f
+ | None,_ -> sprintf ".unnamed%d.ma" scriptId
+
+ initializer
+ ignore (GMain.Timeout.add ~ms:300000
+ ~callback:(fun _ -> self#_saveToBackupFile ();true));
+ ignore (buffer#connect#modified_changed
+ (fun _ -> set_star (Filename.basename self#ppFilename) buffer#modified))
+
+ val mutable statements = []; (** executed statements *)
+ val mutable history = [ init ];
+ (** list of states before having executed statements. Head element of this
+ * list is the current state, last element is the state at the beginning of
+ * the script.
+ * Invariant: this list length is 1 + length of statements *)
+
+ (** goal as seen by the user (i.e. metano corresponding to current tab) *)
+ val mutable userGoal = ~-1
+
+ (** text mark and tag representing locked part of a script *)
+ val locked_mark =
+ buffer#create_mark ~name:"locked" ~left_gravity:true buffer#start_iter
+ val locked_tag = buffer#create_tag [`BACKGROUND "lightblue"; `EDITABLE false]
+ val error_tag = buffer#create_tag [`UNDERLINE `SINGLE; `FOREGROUND "red"]
+
+ method locked_mark = locked_mark
+ method locked_tag = locked_tag
+
+ (* history can't be empty, the invariant above grant that it contains at
+ * least the init status *)
+ method status = match history with hd :: _ -> hd | _ -> assert false
+
+ method private _advance ?statement () =
+ let rec aux st =
+ let baseoffset = (buffer#get_iter_at_mark (`MARK locked_mark))#offset in
+ let (entries, parsed_len) =
+ eval_statement baseoffset 0 error_tag buffer guistuff self#status
+ userGoal self st
+ in
+ let (new_statuses, new_statements, new_asts) =
+ let statuses, statements = List.split entries in
+ let texts, asts = List.split statements in
+ statuses, texts, asts
+ in
+ history <- List.rev new_statuses @ history;
+ statements <- List.rev new_statements @ statements;
+ let start = buffer#get_iter_at_mark (`MARK locked_mark) in
+ let new_text = String.concat "" new_statements in
+ if statement <> None then
+ buffer#insert ~iter:start new_text
+ else
+ let s = match st with `Raw s | `Ast (_, s) -> s in
+ if new_text <> String.sub s 0 parsed_len then
+ begin
+ let stop = start#copy#forward_chars parsed_len in
+ buffer#delete ~start ~stop;
+ buffer#insert ~iter:start new_text;
+ end;
+ self#moveMark (String.length new_text);
+ (*
+ (match List.rev new_asts with (* advance again on punctuation *)
+ | TA.Executable (_, TA.Tactical (_, tac, _)) :: _ ->
+ let baseoffset =
+ (buffer#get_iter_at_mark (`MARK locked_mark))#offset
+ in
+ let text = self#getFuture in
+ (try
+ (match parse_statement baseoffset 0 ?error_tag:None buffer text with
+ | TA.Executable (loc, TA.Tactical (_, tac, None)) as st
+ when GrafiteAst.is_punctuation tac ->
+ let len = snd (CicNotationPt.loc_of_floc loc) in
+ aux (`Ast (st, String.sub text 0 len))
+ | _ -> ())
+ with CicNotationParser.Parse_error _ | End_of_file -> ())
+ | _ -> ())
+ *)
+ in
+ let s = match statement with Some s -> s | None -> self#getFuture in
+ MatitaLog.debug ("evaluating: " ^ first_line s ^ " ...");
+ (try aux (`Raw s) with End_of_file -> raise Margin)
+
+ method private _retract offset status new_statements new_history =
+ let cur_status = match history with s::_ -> s | [] -> assert false in
+ MatitaSync.time_travel ~present:cur_status ~past:status;
+ statements <- new_statements;
+ history <- new_history;
+ self#moveMark (- offset)
+
+ method advance ?statement () =
+ try
+ self#_advance ?statement ();
+ self#notify
+ with
+ | Margin -> self#notify
+ | exc -> self#notify; raise exc
+
+ method retract () =
+ try
+ let cmp,new_statements,new_history,status =
+ match statements,history with
+ stat::statements, _::(status::_ as history) ->
+ String.length stat, statements, history, status
+ | [],[_] -> raise Margin
+ | _,_ -> assert false
+ in
+ self#_retract cmp status new_statements new_history;
+ self#notify
+ with
+ | Margin -> self#notify
+ | exc -> self#notify; raise exc
+
+ method private getFuture =
+ buffer#get_text ~start:(buffer#get_iter_at_mark (`MARK locked_mark))
+ ~stop:buffer#end_iter ()
+
+
+ (** @param rel_offset relative offset from current position of locked_mark *)
+ method private moveMark rel_offset =
+ let mark = `MARK locked_mark in
+ let old_insert = buffer#get_iter_at_mark `INSERT in
+ buffer#remove_tag locked_tag ~start:buffer#start_iter ~stop:buffer#end_iter;
+ let current_mark_pos = buffer#get_iter_at_mark mark in
+ let new_mark_pos =
+ match rel_offset with
+ | 0 -> current_mark_pos
+ | n when n > 0 -> current_mark_pos#forward_chars n
+ | n (* when n < 0 *) -> current_mark_pos#backward_chars (abs n)
+ in
+ buffer#move_mark mark ~where:new_mark_pos;
+ buffer#apply_tag locked_tag ~start:buffer#start_iter ~stop:new_mark_pos;
+ buffer#move_mark `INSERT old_insert;
+ let mark_position = buffer#get_iter_at_mark mark in
+ if source_view#move_mark_onscreen mark then
+ begin
+ buffer#move_mark mark mark_position;
+ source_view#scroll_to_mark ~use_align:true ~xalign:1.0 ~yalign:0.1 mark;
+ end;
+ while Glib.Main.pending () do ignore(Glib.Main.iteration false); done
+
+ method clean_dirty_lock =
+ let lock_mark_iter = buffer#get_iter_at_mark (`MARK locked_mark) in
+ buffer#remove_tag locked_tag ~start:buffer#start_iter ~stop:buffer#end_iter;
+ buffer#apply_tag locked_tag ~start:buffer#start_iter ~stop:lock_mark_iter
+
+ val mutable observers = []
+
+ method addObserver (o: MatitaTypes.status -> unit) =
+ observers <- o :: observers
+
+ method private notify =
+ let status = self#status in
+ List.iter (fun o -> o status) observers
+
+ method loadFromFile f =
+ buffer#set_text (HExtlib.input_file f);
+ self#reset_buffer;
+ buffer#set_modified false
+
+ method assignFileName file =
+ let abspath = MatitaMisc.absolute_path file in
+ let devel = MatitamakeLib.development_for_dir (Filename.dirname abspath) in
+ guistuff.filenamedata <- Some abspath, devel
+
+ method saveToFile () =
+ let oc = open_out self#getFilename in
+ output_string oc (buffer#get_text ~start:buffer#start_iter
+ ~stop:buffer#end_iter ());
+ close_out oc;
+ buffer#set_modified false
+
+ method private _saveToBackupFile () =
+ if buffer#modified then
+ begin
+ let f = self#ppFilename ^ "~" in
+ let oc = open_out f in
+ output_string oc (buffer#get_text ~start:buffer#start_iter
+ ~stop:buffer#end_iter ());
+ close_out oc;
+ MatitaLog.debug ("backup " ^ f ^ " saved")
+ end
+
+ method private goto_top =
+ MatitaSync.time_travel ~present:self#status ~past:init
+
+ method private reset_buffer =
+ statements <- [];
+ history <- [ init ];
+ userGoal <- ~-1;
+ self#notify;
+ buffer#remove_tag locked_tag ~start:buffer#start_iter ~stop:buffer#end_iter;
+ buffer#move_mark (`MARK locked_mark) ~where:buffer#start_iter
+
+ method reset () =
+ self#reset_buffer;
+ source_buffer#begin_not_undoable_action ();
+ buffer#delete ~start:buffer#start_iter ~stop:buffer#end_iter;
+ source_buffer#end_not_undoable_action ();
+ buffer#set_modified false
+
+ method template () =
+ let template = HExtlib.input_file BuildTimeConf.script_template in
+ buffer#insert ~iter:(buffer#get_iter `START) template;
+ guistuff.filenamedata <-
+ (None,MatitamakeLib.development_for_dir (Unix.getcwd ()));
+ buffer#set_modified false;
+ set_star (Filename.basename self#ppFilename) false
+
+ method goto (pos: [`Top | `Bottom | `Cursor]) () =
+ let old_locked_mark =
+ `MARK
+ (buffer#create_mark ~name:"old_locked_mark"
+ ~left_gravity:true (buffer#get_iter_at_mark (`MARK locked_mark))) in
+ let getpos _ = buffer#get_iter_at_mark (`MARK locked_mark) in
+ let getoldpos _ = buffer#get_iter_at_mark old_locked_mark in
+ let dispose_old_locked_mark () = buffer#delete_mark old_locked_mark in
+ match pos with
+ | `Top ->
+ dispose_old_locked_mark ();
+ self#goto_top;
+ self#reset_buffer;
+ self#notify
+ | `Bottom ->
+ (try
+ let rec dowhile () =
+ self#_advance ();
+ let newpos = getpos () in
+ if (getoldpos ())#compare newpos < 0 then
+ begin
+ buffer#move_mark old_locked_mark newpos;
+ dowhile ()
+ end
+ in
+ dowhile ();
+ dispose_old_locked_mark ();
+ self#notify
+ with
+ | Margin -> dispose_old_locked_mark (); self#notify
+ | exc -> dispose_old_locked_mark (); self#notify; raise exc)
+ | `Cursor ->
+ let locked_iter () = buffer#get_iter_at_mark (`NAME "locked") in
+ let cursor_iter () = buffer#get_iter_at_mark `INSERT in
+ let remember =
+ `MARK
+ (buffer#create_mark ~name:"initial_insert"
+ ~left_gravity:true (cursor_iter ())) in
+ let dispose_remember () = buffer#delete_mark remember in
+ let remember_iter () =
+ buffer#get_iter_at_mark (`NAME "initial_insert") in
+ let cmp () = (locked_iter ())#offset - (remember_iter ())#offset in
+ let icmp = cmp () in
+ let forward_until_cursor () = (* go forward until locked > cursor *)
+ let rec aux () =
+ self#_advance ();
+ if cmp () < 0 && (getoldpos ())#compare (getpos ()) < 0
+ then
+ begin
+ buffer#move_mark old_locked_mark (getpos ());
+ aux ()
+ end
+ in
+ aux ()
+ in
+ let rec back_until_cursor len = (* go backward until locked < cursor *)
+ function
+ statements, (status::_ as history) when len <= 0 ->
+ self#_retract (icmp - len) status statements history
+ | statement::tl1, _::tl2 ->
+ back_until_cursor (len - String.length statement) (tl1,tl2)
+ | _,_ -> assert false
+ in
+ (try
+ begin
+ if icmp < 0 then (* locked < cursor *)
+ (forward_until_cursor (); self#notify)
+ else if icmp > 0 then (* locked > cursor *)
+ (back_until_cursor icmp (statements,history); self#notify)
+ else (* cursor = locked *)
+ ()
+ end ;
+ dispose_remember ();
+ dispose_old_locked_mark ();
+ with
+ | Margin -> dispose_remember (); dispose_old_locked_mark (); self#notify
+ | exc -> dispose_remember (); dispose_old_locked_mark ();
+ self#notify; raise exc)
+
+ method onGoingProof () =
+ match self#status.proof_status with
+ | No_proof | Proof _ -> false
+ | Incomplete_proof _ -> true
+ | Intermediate _ -> assert false
+
+(* method proofStatus = MatitaTypes.get_proof_status self#status *)
+ method proofMetasenv = MatitaTypes.get_proof_metasenv self#status
+ method proofContext = MatitaTypes.get_proof_context self#status userGoal
+ method proofConclusion = MatitaTypes.get_proof_conclusion self#status userGoal
+ method stack = MatitaTypes.get_stack self#status
+ method setGoal n = userGoal <- n
+ method goal = userGoal
+
+ method eos =
+ let s = self#getFuture in
+ let rec is_there_and_executable s =
+ if Pcre.pmatch ~rex:only_dust_RE s then raise Margin;
+ let st = GrafiteParser.parse_statement (Ulexing.from_utf8_string s) in
+ match st with
+ | GrafiteAst.Comment (loc,_)->
+ let parsed_text_length = snd (CicNotationPt.loc_of_floc loc) in
+ let remain_len = String.length s - parsed_text_length in
+ let next = String.sub s parsed_text_length remain_len in
+ is_there_and_executable next
+ | GrafiteAst.Executable (loc, ex) -> false
+ in
+ try
+ is_there_and_executable s
+ with
+ | CicNotationParser.Parse_error _ -> false
+ | Margin | End_of_file -> true
+
+ (* debug *)
+ method dump () =
+ MatitaLog.debug "script status:";
+ MatitaLog.debug ("history size: " ^ string_of_int (List.length history));
+ MatitaLog.debug (sprintf "%d statements:" (List.length statements));
+ List.iter MatitaLog.debug statements;
+ MatitaLog.debug ("Current file name: " ^
+ (match guistuff.filenamedata with
+ |None,_ -> "[ no name ]"
+ | Some f,_ -> f));
+
+end
+
+let _script = ref None
+
+let script ~source_view ~init ~mathviewer ~urichooser ~develcreator ~ask_confirmation ~set_star ()
+=
+ let s = new script
+ ~source_view ~init ~mathviewer ~ask_confirmation ~urichooser ~develcreator ~set_star ()
+ in
+ _script := Some s;
+ s