X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fmatita%2Fmatita.ml;h=a422ece1655ba7321d9ce31d1cb5fb68aaf74d0a;hb=6915a58db8db95966b9519d1d984d895e7b5fe39;hp=e565c03a787e6f0c1cd6b4eaaef9afba9b1048cf;hpb=6b7f04b45232e6c690cacf5815c85c39de1f52b3;p=helm.git diff --git a/helm/matita/matita.ml b/helm/matita/matita.ml index e565c03a7..a422ece16 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 @@ -29,179 +29,75 @@ open MatitaGtkMisc open MatitaTypes open MatitaMisc -(** {2 Internal status} *) - -let (get_proof, set_proof, has_proof) = - let (current_proof: MatitaTypes.proof option ref) = ref None in - ((fun () -> (* get_proof *) - match !current_proof with - | Some proof -> proof - | None -> failwith "No current proof"), - (fun proof -> (* set_proof *) - current_proof := proof), - (fun () -> (* has_proof *) - !current_proof <> None)) - (** {2 Initialization} *) let _ = - Helm_registry.load_from "matita.conf.xml"; - GtkMain.Rc.add_default_file BuildTimeConf.gtkrc; - GMain.Main.init () -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 gui = MatitaGui.instance () -let disambiguator = - new MatitaDisambiguator.disambiguator ~parserr ~dbd - ~chooseUris:(interactive_user_uri_choice ~gui) - ~chooseInterp:(interactive_interp_choice ~gui) - () -let proof_viewer = - let frame = GBin.frame ~packing:(gui#proof#scrolledProof#add) ~show:true () in - MatitaMathView.proof_viewer ~show:true ~packing:(frame#add) () -let sequent_viewer = MatitaMathView.sequent_viewer ~show:true () -let sequents_viewer = - let set_goal goal = - debug_print (sprintf "Setting goal %d" goal); - if not (has_proof ()) then assert false; - (get_proof ())#set_goal goal - in - MatitaMathView.sequents_viewer ~notebook:gui#main#sequentsNotebook - ~sequent_viewer ~set_goal () - -let new_proof (proof: MatitaTypes.proof) = - let xmldump_observer _ _ = print_endline proof#toString in - let proof_observer _ (status, ()) = - debug_print "proof_observer"; - let ((uri_opt, _, _, _), _) = status in - let uri = MatitaTypes.unopt_uri uri_opt in - debug_print "apply transformation"; - proof_viewer#load_proof status; - debug_print "/proof_observer" - 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 - ignore (proof#attach_observer ~interested_in:StatefulProofEngine.all_events - sequents_observer); - ignore (proof#attach_observer ~interested_in:StatefulProofEngine.all_events - proof_observer); - ignore (proof#attach_observer ~interested_in:StatefulProofEngine.all_events - xmldump_observer); - proof#notify; - set_proof (Some proof) - -let quit () = (* quit program, asking for confirmation if needed *) - if not (has_proof ()) || - (ask_confirmation ~gui - ~msg:("Proof in progress, are you sure you want to quit?") ()) - then - GMain.Main.quit () + Helm_registry.load_from "matita.conf.xml"; (* read conf *) + Http_getter.init (); + MetadataTypes.ownerize_tables (Helm_registry.get "matita.owner"); + MatitaDb.clean_owner_environment (); + MatitaDb.create_owner_environment (); + GtkMain.Rc.add_default_file BuildTimeConf.gtkrc; (* loads gtk rc files *) + ignore (GMain.Main.init ()); -let abort_proof () = - if has_proof () then begin - set_proof None; - sequents_viewer#reset - end + (* environment trust *) + CicEnvironment.set_trust + (let trust = Helm_registry.get_bool "matita.environment_trust" in + fun _ -> trust) -let proof_handler = - { MatitaTypes.get_proof = get_proof; - MatitaTypes.abort_proof = abort_proof; - MatitaTypes.set_proof = set_proof; - MatitaTypes.has_proof = has_proof; - MatitaTypes.new_proof = new_proof; - MatitaTypes.quit = quit; - } +(** {2 GUI callbacks} *) -let interpreter = - let console = gui#console in - new MatitaInterpreter.interpreter ~disambiguator ~proof_handler ~console () +let gui = MatitaGui.instance () - (** prompt the user for the textual input of a term and disambiguate it *) -let ask_term ?(title = "term input") ?(msg = "insert term") () = - match gui#askText ~title ~msg () with - | Some t -> - let (_, _, term) = disambiguator#disambiguateTerm (Stream.of_string t) in - Some term - | None -> None +let _ = + ignore (gui#main#newCicBrowserMenuItem#connect#activate (fun _ -> + ignore (MatitaMathView.cicBrowser ()))); + (* disambiguator callback *) + MatitaDisambiguator.set_choose_uris_callback + (MatitaGui.interactive_uri_choice ()); + MatitaDisambiguator.set_choose_interp_callback + (MatitaGui.interactive_interp_choice ()) + +let script = + MatitaScript.script + ~buffer:gui#main#scriptTextView#buffer + ~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" + ~copy_cb:(fun s -> gui#main#scriptTextView#buffer#insert ("\n"^s^"\n")) + () ~id:"boh?" uris + with MatitaTypes.Cancel -> []) + () + (* math viewers *) let _ = - gui#setQuitCallback quit; - gui#setPhraseCallback interpreter#evalPhrase; - gui#main#debugMenu#misc#hide (); - ignore (gui#main#newProofMenuItem#connect#activate (fun _ -> - if has_proof () && - not (ask_confirmation ~gui - ~msg:("Proof in progress, are you sure you want to start a new one?") - ()) - then - () (* abort new proof process *) - else - let input = ask_text ~gui ~msg:"Insert proof goal" ~multiline:true () in - let (env, metasenv, expr) = - disambiguator#disambiguateTerm (Stream.of_string input) - in - let proof = MatitaProof.proof ~typ:expr ~metasenv () in - new_proof proof)); - ignore (gui#main#openMenuItem#connect#activate (fun _ -> - match gui#chooseFile () with - | None -> () - | Some f when is_proof_script f -> - gui#script#scriptTextView#buffer#set_text (input_file f); - gui#script#scriptWin#show (); - gui#main#showScriptMenuItem#set_active true - | Some f -> - gui#console#echo_error (sprintf - "Don't know what to do with file: %s\nUnrecognized file format." - f))); - let tac_w_term name tac _ = - match ask_term ~title:name ~msg:("term for " ^ name) () with - | Some term -> (get_proof ())#apply_tactic (tac ~term) - | None -> () + let sequent_viewer = MatitaMathView.sequentViewer_instance () in + let sequents_viewer = MatitaMathView.sequentsViewer_instance () in + sequent_viewer#set_href_callback + (Some (fun uri -> (MatitaMathView.cicBrowser ())#load (`Uri uri))); + let browser_observer _ = MatitaMathView.refresh_all_browsers () in + let sequents_observer status = + sequents_viewer#reset; + match status.proof_status with + | Incomplete_proof ((proof, goal) as status) -> + sequents_viewer#load_sequents status; + sequents_viewer#goto_sequent goal + | Proof proof -> + prerr_endline "sequents_viewer#load_logo_with_qed (no proof)"; () + | No_proof -> + prerr_endline "sequents_viewer#load_logo (no proof)"; () + | Intermediate _ -> + assert false (* only the engine may be in this state *) in - let tac _ tac _ = (get_proof ())#apply_tactic tac in - let tbar = gui#toolbar in - ignore (tbar#introsButton#connect#clicked (tac "intros" (Tactics.intros ()))); - ignore (tbar#applyButton#connect#clicked (tac_w_term "apply" Tactics.apply)); - ignore (tbar#exactButton#connect#clicked (tac_w_term "exact" Tactics.exact)); - ignore (tbar#elimButton#connect#clicked (tac_w_term "elim" - Tactics.elim_intros_simpl)); - ignore (tbar#elimTypeButton#connect#clicked (tac_w_term "elim type" - Tactics.elim_type)); - ignore (tbar#splitButton#connect#clicked (tac "split" Tactics.split)); - ignore (tbar#leftButton#connect#clicked (tac "left" Tactics.left)); - ignore (tbar#rightButton#connect#clicked (tac "right" Tactics.right)); - ignore (tbar#existsButton#connect#clicked (tac "exists" Tactics.exists)); - ignore (tbar#reflexivityButton#connect#clicked (tac "reflexivity" - Tactics.reflexivity)); - ignore (tbar#symmetryButton#connect#clicked (tac "symmetry" - Tactics.symmetry)); - ignore (tbar#transitivityButton#connect#clicked (tac_w_term "transitivity" - Tactics.transitivity)); - ignore (tbar#assumptionButton#connect#clicked (tac "assumption" - Tactics.assumption)); - ignore (tbar#cutButton#connect#clicked (tac_w_term "cut" - (Tactics.cut ?mk_fresh_name_callback:None))); - ignore (tbar#autoButton#connect#clicked (tac "auto" (Tactics.auto ~dbd))) + script#addObserver sequents_observer; + script#addObserver browser_observer (** *) - -let save_dom = - let domImpl = lazy (Gdome.domImplementation ()) in - fun ~doc ~dest -> - ignore - ((Lazy.force domImpl)#saveDocumentToFile ~doc ~name:dest ~indent:true ()) - let _ = if BuildTimeConf.debug then begin gui#main#debugMenu#misc#show (); @@ -211,29 +107,76 @@ let _ = in ignore (item#connect#activate callback) in - addDebugItem "interactive user uri choice" (fun _ -> - try - let uris = - interactive_user_uri_choice ~gui ~selection_mode:`MULTIPLE - ~msg:"messaggio" ~nonvars_button:true - ["cic:/uno.con"; "cic:/due.var"; "cic:/tre.con"; "cic:/quattro.con"; - "cic:/cinque.var"] - in - List.iter prerr_endline uris - with MatitaGtkMisc.Cancel -> MatitaTypes.error "no choice"); - addDebugItem "toggle auto disambiguation" (fun _ -> - Helm_registry.set_bool "matita.auto_disambiguation" - (not (Helm_registry.get_bool "matita.auto_disambiguation"))); - addDebugItem "mono line text input" (fun _ -> - prerr_endline (ask_text ~gui ~title:"title" ~msg:"message" ())); - addDebugItem "multi line text input" (fun _ -> - prerr_endline - (ask_text ~gui ~title:"title" ~multiline:true ~msg:"message" ())); - addDebugItem "dump proof status to stdout" (fun _ -> - print_endline ((get_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 "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 "print selected terms" (fun () -> + let i = ref 0 in + List.iter + (fun t -> + incr i; + MatitaLog.debug (sprintf "%d: %s" !i (CicPp.ppterm t))) + (MatitaMathView.sequentViewer_instance ())#get_selected_terms); + addDebugItem "dump getter settings" (fun _ -> + prerr_endline (Http_getter_env.env_to_string ())); + addDebugItem "getter: update" + (fun _ -> + ignore (Thread.create (fun () -> + MatitaLog.message "Rebuilding getter maps in background ..."; + Http_getter.update (); + MatitaLog.message "Getter maps successfully rebuilt.") ())); + addDebugItem "getter: getalluris" (fun _ -> + List.iter prerr_endline (Http_getter.getalluris ())); + addDebugItem "dump script status" script#dump; + addDebugItem "dump metasenv" + (fun _ -> + if script#onGoingProof () then + MatitaLog.debug (CicMetaSubst.ppmetasenv script#proofMetasenv [])); + addDebugItem "rotate light bulbs" + (fun _ -> + let nb = gui#main#hintNotebook in + nb#goto_page ((nb#current_page + 1) mod 3)); + (* + addDebugItem "print (on stdout) \"statement\" grammar entry" + (fun _ -> + Grammar.print_entry Format.std_formatter + (Grammar.Entry.obj CicTextualParser2.statement); + Format.pp_print_flush Format.std_formatter ());*) end (** *) -let _ = GtkThread.main () +let _ = + at_exit + (fun () -> + Http_getter_logger.log "Sync map tree to disk..."; + Http_getter.sync_dump_file (); + print_endline "\nThanks for using Matita!\n"); + Sys.catch_break true; + (try + gui#loadScript Sys.argv.(1); + with Invalid_argument _ -> ()); + if Filename.basename Sys.argv.(0) = "cicbrowser" then begin (* cicbrowser *) + Helm_registry.set "matita.mode" "cicbrowser"; + let browser = MatitaMathView.cicBrowser () in + try + browser#load (`Uri Sys.argv.(1)) + with Invalid_argument _ -> () + end else begin (* matita *) + Helm_registry.set "matita.mode" "matita"; + gui#main#mainWin#show (); + end; + try + GtkThread.main () + with Sys.Break -> ()