X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fmatita%2Fmatita.ml;h=11ae70642bf6b36c5f59e2b644648ca23522c7e7;hb=4167cea65ca58897d1a3dbb81ff95de5074700cc;hp=6e57c2e8ffd7614eb280330a8aaa249ac2f198cd;hpb=92b20571ab97c7d662304926c113fc42292b4435;p=helm.git diff --git a/helm/matita/matita.ml b/helm/matita/matita.ml index 6e57c2e8f..11ae70642 100644 --- a/helm/matita/matita.ml +++ b/helm/matita/matita.ml @@ -1,4 +1,4 @@ -(* Copyright (C) 2004, HELM Team. +(* Copyright (C) 2004-2005, HELM Team. * * This file is part of HELM, an Hypertextual, Electronic * Library of Mathematics, developed at the Computer Science @@ -27,170 +27,71 @@ open Printf open MatitaGtkMisc open MatitaTypes -open MatitaMisc (** {2 Initialization} *) -let _ = - Helm_registry.load_from "matita.conf.xml"; - GtkMain.Rc.add_default_file BuildTimeConf.gtkrc; - GMain.Main.init () +let _ = MatitaInit.initialize_all () +let _ = Paramodulation.Saturation.init () (* ALB to link paramodulation *) -let parserr = new MatitaDisambiguator.parserr () -let dbd = - Mysql.quick_connect - ~host:(Helm_registry.get "db.host") - ~user:(Helm_registry.get "db.user") - ~database:(Helm_registry.get "db.database") - () -let _ = MetadataDb.clean ~dbd ~owner:(Helm_registry.get "matita.owner") -let gui = MatitaGui.instance () -let disambiguator = - new MatitaDisambiguator.disambiguator ~parserr ~dbd - ~chooseUris:(interactive_user_uri_choice ~gui) - ~chooseInterp:(interactive_interp_choice ~gui) - () +(** {2 GUI callbacks} *) -let currentProof = new MatitaProof.currentProof +let gui = MatitaGui.instance () -let sequent_viewer = MatitaMathView.sequent_viewer ~show:true () -let sequents_viewer = - let set_goal goal = - if not (currentProof#onGoing ()) then assert false; - currentProof#proof#set_goal goal +let script = + let s = + MatitaScript.script + ~source_view:gui#sourceView + ~init:(Lazy.force MatitaEngine.initial_status) + ~mathviewer:(MatitaMathView.mathViewer ()) + ~urichooser:(fun uris -> + try + MatitaGui.interactive_uri_choice ~selection_mode:`SINGLE + ~title:"Matita: URI chooser" + ~msg:"Select the URI" ~hide_uri_entry:true + ~hide_try:true ~ok_label:"_Apply" ~ok_action:`SELECT + ~copy_cb:(fun s -> gui#sourceView#buffer#insert ("\n"^s^"\n")) + () ~id:"boh?" uris + with MatitaTypes.Cancel -> []) + ~set_star:gui#setStar + ~ask_confirmation: + (fun ~title ~message -> + MatitaGtkMisc.ask_confirmation ~title ~message + ~parent:gui#main#toplevel ()) + ~develcreator:gui#createDevelopment + () in - MatitaMathView.sequents_viewer ~notebook:gui#main#sequentsNotebook - ~sequent_viewer ~set_goal () -let _ = (* attach observers to proof status *) - let browser_observer _ _ = MatitaMathView.refresh_all_browsers () in - let sequents_observer _ (((_, metasenv, _, _), goal_opt), ()) = - sequents_viewer#reset; - (match goal_opt with - | None -> () - | Some goal -> - sequents_viewer#load_sequents metasenv; - sequents_viewer#goto_sequent goal) - in - currentProof#addObserver sequents_observer; - currentProof#addObserver browser_observer; - currentProof#connect `Quit (fun () -> - (* quit program, asking for confirmation if needed *) - if not (currentProof#onGoing ()) || - (ask_confirmation ~gui - ~msg:("Proof in progress, are you sure you want to quit?") ()) - then - GMain.Main.quit (); - false); - currentProof#connect `Abort (fun () -> sequents_viewer#reset; false) - -let currentProof = (currentProof :> MatitaTypes.currentProof) -let mathViewer = - MatitaMathView.mathViewer ~disambiguator - ~currentProof:(currentProof :> MatitaTypes.currentProof) () -let interpreter = - let console = (gui#console :> MatitaTypes.console) in - new MatitaInterpreter.interpreter - ~disambiguator ~currentProof:(currentProof :> MatitaTypes.currentProof) - ~console ~mathViewer ~dbd () + gui#sourceView#source_buffer#begin_not_undoable_action (); + s#reset (); + s#template (); + gui#sourceView#source_buffer#end_not_undoable_action (); + s + + (* math viewers *) let _ = - let href_callback uri = - let term = CicAst.Uri (UriManager.string_of_uri uri, None) in - ignore (interpreter#evalAst (TacticAst.Command (TacticAst.Check term))) - in - sequent_viewer#set_href_callback (Some href_callback) - -(** {2 Script window handling} *) - -let script_forward _ = - let buf = gui#script#scriptTextView#buffer in - let locked_iter = buf#get_iter_at_mark (`NAME "locked") in - let (success, hide) = - interpreter#evalPhrase - (buf#get_text ~start:locked_iter ~stop:buf#end_iter ()) - in - if success then - gui#lockScript (locked_iter#offset + interpreter#endOffset) - -let script_jump _ = - let buf = gui#script#scriptTextView#buffer in - let locked_iter = buf#get_iter_at_mark (`NAME "locked") in - let cursor_iter = buf#get_iter_at_mark (`NAME "insert") in - let raw_text = buf#get_text ~start:locked_iter ~stop:cursor_iter () in - let len = String.length raw_text in - let rec parse offset = - if offset < len then begin - let (success, hide) = - interpreter#evalPhrase (String.sub raw_text offset (len - offset)) - in - if success then begin - let new_offset = interpreter#endOffset + offset in - gui#lockScript (new_offset + locked_iter#offset); - parse new_offset - end else - raise Exit - end - in - try - parse 0 - with Exit -> () - -let script_back _ = not_implemented "script_back" - -let load_script fname = - gui#script#scriptTextView#buffer#set_text (input_file fname); - gui#script#scriptWin#show (); - gui#main#showScriptMenuItem#set_active true - -(** {2 GUI callbacks} *) - -let _ = - gui#setQuitCallback currentProof#quit; - gui#setPhraseCallback interpreter#evalPhrase; - gui#main#debugMenu#misc#hide (); - ignore (gui#main#newProofMenuItem#connect#activate (fun _ -> - gui#console#clear (); - gui#console#show ~msg:"theorem " ())); - ignore (gui#main#openMenuItem#connect#activate (fun _ -> - match gui#chooseFile () with - | None -> () - | Some f when is_proof_script f -> load_script f - | Some f -> - gui#console#echo_error (sprintf - "Don't know what to do with file: %s\nUnrecognized file format." - f))); - ignore (gui#main#newCicBrowserMenuItem#connect#activate (fun _ -> - let currentProof = (currentProof :> MatitaTypes.currentProof) in - ignore (MatitaMathView.cicBrowser ~disambiguator ~currentProof ()))); - connect_button gui#script#scriptWinForwardButton script_forward; - connect_button gui#script#scriptWinBackButton script_back; - connect_button gui#script#scriptWinJumpButton script_jump; - let module A = TacticAst in - let hole = CicAst.UserInput in - let tac ast _ = ignore (interpreter#evalAst (A.Tactic ast)) in - let tac_w_term ast _ = -(* gui#console#clear (); *) - gui#console#show ~msg:(TacticAstPp.pp_tactic ast) (); - gui#main#mainWin#present () + let cic_math_view = MatitaMathView.cicMathView_instance () in + let sequents_viewer = MatitaMathView.sequentsViewer_instance () in + sequents_viewer#load_logo; + cic_math_view#set_href_callback + (Some (fun uri -> (MatitaMathView.cicBrowser ())#load + (`Uri (UriManager.uri_of_string uri)))); + let browser_observer _ = MatitaMathView.refresh_all_browsers () in + let sequents_observer status = + sequents_viewer#reset; + match status.proof_status with + | Incomplete_proof ({ stack = stack } as incomplete_proof) -> + sequents_viewer#load_sequents incomplete_proof; + (try + script#setGoal (Continuationals.Stack.find_goal stack); + sequents_viewer#goto_sequent script#goal + with Failure _ -> script#setGoal ~-1); + | Proof proof -> sequents_viewer#load_logo_with_qed + | No_proof -> sequents_viewer#load_logo + | Intermediate _ -> assert false (* only the engine may be in this state *) in - let tbar = gui#toolbar in - connect_button tbar#introsButton (tac (A.Intros (None, []))); - connect_button tbar#applyButton (tac_w_term (A.Apply hole)); - connect_button tbar#exactButton (tac_w_term (A.Exact hole)); - connect_button tbar#elimButton (tac_w_term (A.Elim (hole, None))); - connect_button tbar#elimTypeButton (tac_w_term (A.ElimType hole)); - connect_button tbar#splitButton (tac A.Split); - connect_button tbar#leftButton (tac A.Left); - connect_button tbar#rightButton (tac A.Right); - connect_button tbar#existsButton (tac A.Exists); - connect_button tbar#reflexivityButton (tac A.Reflexivity); - connect_button tbar#symmetryButton (tac A.Symmetry); - connect_button tbar#transitivityButton (tac_w_term (A.Transitivity hole)); - connect_button tbar#assumptionButton (tac A.Assumption); - connect_button tbar#cutButton (tac_w_term (A.Cut hole)); - connect_button tbar#autoButton (tac A.Auto) - - (** *) + script#addObserver sequents_observer; + script#addObserver browser_observer + (** {{{ Debugging *) let _ = if BuildTimeConf.debug then begin gui#main#debugMenu#misc#show (); @@ -200,38 +101,108 @@ let _ = in ignore (item#connect#activate callback) in - addDebugItem "toggle auto disambiguation" (fun _ -> - Helm_registry.set_bool "matita.auto_disambiguation" - (not (Helm_registry.get_bool "matita.auto_disambiguation"))); - addDebugItem "dump proof status to stdout" (fun _ -> - print_endline (currentProof#proof#toString)); addDebugItem "dump environment to \"env.dump\"" (fun _ -> let oc = open_out "env.dump" in CicEnvironment.dump_to_channel oc; close_out oc); - addDebugItem "print selected terms" (fun () -> - let i = ref 0 in + addDebugItem "load environment from \"env.dump\"" (fun _ -> + let ic = open_in "env.dump" in + CicEnvironment.restore_from_channel ic; + close_in ic); + addDebugItem "dump universes" (fun _ -> + List.iter (fun (u,_,g) -> + prerr_endline (UriManager.string_of_uri u); + CicUniv.print_ugraph g) (CicEnvironment.list_obj ()) + ); + addDebugItem "dump environment content" (fun _ -> + List.iter (fun (u,_,_) -> + prerr_endline (UriManager.string_of_uri u)) + (CicEnvironment.list_obj ())); + addDebugItem "print selections" (fun () -> + let cicMathView = MatitaMathView.cicMathView_instance () in + List.iter MatitaLog.debug (cicMathView#string_of_selections)); + addDebugItem "dump script status" script#dump; + addDebugItem "dump configuration file to ./foo.conf.xml" (fun _ -> + Helm_registry.save_to "./foo.conf.xml"); + addDebugItem "dump metasenv" + (fun _ -> + if script#onGoingProof () then + MatitaLog.debug (CicMetaSubst.ppmetasenv [] script#proofMetasenv)); + addDebugItem "dump coercions Db" (fun _ -> List.iter - (fun t -> incr i; debug_print (sprintf "%d: %s" !i (CicPp.ppterm t))) - sequent_viewer#get_selected_terms); - addDebugItem "refresh all browsers" MatitaMathView.refresh_all_browsers; + (fun (s,t,u) -> + MatitaLog.debug + (UriManager.name_of_uri u ^ ":" + ^ CoercDb.name_of_carr s ^ " -> " ^ CoercDb.name_of_carr t)) + (CoercDb.to_list ())); + addDebugItem "print top-level grammar entries" + CicNotationParser.print_l2_pattern; + addDebugItem "dump moo to stderr" (fun _ -> + let status = (MatitaScript.current ())#status in + let moo, metadata = status.moo_content_rev in + List.iter (fun cmd -> prerr_endline + (GrafiteAstPp.pp_command cmd)) (List.rev moo); + List.iter (fun m -> prerr_endline + (GrafiteAstPp.pp_metadata m)) metadata); + addDebugItem "print metasenv goals and stack to stderr" + (fun _ -> + prerr_endline ("metasenv goals: " ^ String.concat " " + (List.map (fun (g, _, _) -> string_of_int g) + (MatitaScript.current ())#proofMetasenv)); + prerr_endline ("stack: " ^ Continuationals.Stack.pp + (MatitaTypes.get_stack (MatitaScript.current ())#status))); +(* addDebugItem "ask record choice" + (fun _ -> + MatitaLog.debug (string_of_int + (MatitaGtkMisc.ask_record_choice ~gui ~title:"title" ~message:"msg" + ~fields:["a"; "b"; "c"] + ~records:[ + ["0"; "0"; "0"]; ["0"; "0"; "1"]; ["0"; "1"; "0"]; ["0"; "1"; "1"]; + ["1"; "0"; "0"]; ["1"; "0"; "1"]; ["1"; "1"; "0"]; ["1"; "1"; "1"]] + ()))); *) + addDebugItem "rotate light bulbs" + (fun _ -> + let nb = gui#main#hintNotebook in + nb#goto_page ((nb#current_page + 1) mod 3)); + addDebugItem "print runtime dir" + (fun _ -> + prerr_endline BuildTimeConf.runtime_base_dir); + addDebugItem "disable all (pretty printing) notations" + (fun _ -> CicNotation.set_active_notations []); + addDebugItem "enable all (pretty printing) notations" + (fun _ -> + CicNotation.set_active_notations + (List.map fst (CicNotation.get_all_notations ()))); end + (** Debugging }}} *) + + (** {2 Command line parsing} *) - (** *) +let set_matita_mode () = + let matita_mode = + if Filename.basename Sys.argv.(0) = "cicbrowser" + then "cicbrowser" + else "matita" + in + Helm_registry.set "matita.mode" matita_mode + + (** {2 Main} *) let _ = -(* CicEnvironment.set_trust (fun _ -> false); *) -(* - (try - load_script Sys.argv.(1) - with Invalid_argument _ -> ()); -*) - if Pcre.pmatch ~pat:"cicbrowser$" Sys.argv.(0) then begin - ignore (MatitaMathView.cicBrowser ~disambiguator ~currentProof ()) - end else begin + set_matita_mode (); + at_exit (fun () -> print_endline "\nThanks for using Matita!\n"); + Sys.catch_break true; + let args = Helm_registry.get_list Helm_registry.string "matita.args" in + if Helm_registry.get "matita.mode" = "cicbrowser" then (* cicbrowser *) + let browser = MatitaMathView.cicBrowser () in + let uri = match args with [] -> "cic:/" | _ -> String.concat " " args in + browser#loadInput uri + else begin (* matita *) + (try gui#loadScript (List.hd args) with Failure _ -> ()); gui#main#mainWin#show (); - gui#toolbar#toolBarWin#show (); - gui#console#show () end; - GtkThread.main () + try + GtkThread.main () + with Sys.Break -> () +(* vim:set foldmethod=marker: *)