X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fmatita%2Fmatita.ml;h=c3fdb2459c89e7fe580a74c07664e5c0d5270120;hb=86af949158e013178557c7fec7662ac06fae753c;hp=3c543d5c179a1602acb6b17b288d60a11bf0ef5a;hpb=06c2b37f3d7d4e14cabeef3b18211e5d12b9b4eb;p=helm.git diff --git a/helm/matita/matita.ml b/helm/matita/matita.ml index 3c543d5c1..c3fdb2459 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 @@ -23,126 +23,71 @@ * http://helm.cs.unibo.it/ *) -open MatitaGtkMisc - -(** {2 Internal status} *) - -let (get_proof, set_proof, has_proof) = - let (current_proof: MatitaTypes.proof option ref) = ref None in - ((fun () -> - match !current_proof with - | Some proof -> proof - | None -> failwith "No current proof"), - (fun proof -> (* TODO Zack: this function should probably be smarter taking - care also of unregistering notifications subscriber and so on *) - current_proof := proof), - (fun () -> !current_proof <> None)) - -(** {2 Settings} *) - -let debug_print = MatitaTypes.debug_print +open Printf -let save_dom = - let domImpl = lazy (Gdome.domImplementation ()) in - fun ~doc ~dest -> - ignore - ((Lazy.force domImpl)#saveDocumentToFile ~doc ~name:dest ~indent:true ()) +open MatitaGtkMisc +open MatitaTypes (** {2 Initialization} *) -let _ = Helm_registry.load_from "matita.conf.xml" -let _ = GMain.Main.init () -let gui = new MatitaGui.gui (Helm_registry.get "matita.glade_file") -let parserr = new MatitaDisambiguator.parserr () -let mqiconn = MQIConn.init () -let disambiguator = - new MatitaDisambiguator.disambiguator ~parserr ~mqiconn - ~chooseUris:(interactive_user_uri_choice ~gui) - ~chooseInterp:(interactive_interp_choice ~gui) - () -let proof_viewer = - let mml_of_cic_object = BuildTimeConf.Transformer.mml_of_cic_object in -(* - let frame = GBin.frame ~packing:(gui#proof#scrolledProof#add) ~show:true () in - MatitaMathView.proof_viewer ~show:true ~packing:(frame#add) () -*) - MatitaMathView.proof_viewer ~show:true ~packing:(gui#proof#scrolledProof#add) () -(* -let sequent_viewer = - let mml_of_cic_sequent = BuildTimeConf.Transformer.mml_of_cic_sequent in - MatitaMathView.sequent_viewer ~mml_of_cic_sequent ~show:true - ~packing:(gui#main#scrolledSequents#add) () -*) - -let new_proof (proof: MatitaTypes.proof) = - (* TODO Zack a lot: - * - ids_to_inner_types, ids_to_inner_sorts handling - * - sequent viewer notification - *) - let xmldump_observer _ _ = print_endline proof#toString in - let proof_observer _ (status, metadata) = - debug_print "proof_observer"; - let (acic, ids_to_terms, ids_to_father_ids, ids_to_inner_sorts, - ids_to_inner_types, ids_to_conjectures, ids_to_hypotheses) = - metadata - in - let ((uri_opt, _, _, _), _) = status in - let uri = MatitaTypes.unopt_uri uri_opt in - debug_print "apply transformation"; - let mathml = - BuildTimeConf.Transformer.mml_of_cic_object - ~explode_all:true uri acic ids_to_inner_sorts ids_to_inner_types - in - if BuildTimeConf.debug then save_dom ~doc:mathml ~dest:"/tmp/matita.xml"; - proof_viewer#load_proof mathml metadata; - debug_print "/proof_observer" +let _ = MatitaInit.initialize_all () + +(** {2 GUI callbacks} *) + +let gui = MatitaGui.instance () + +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 - ignore (proof#attach_observer ~interested_in:StatefulProofEngine.all_events - xmldump_observer); - ignore (proof#attach_observer ~interested_in:StatefulProofEngine.all_events - proof_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 () - -let proof_handler = - { MatitaTypes.get_proof = get_proof; - MatitaTypes.set_proof = set_proof; - MatitaTypes.has_proof = has_proof; - MatitaTypes.new_proof = new_proof; - MatitaTypes.quit = quit; - } - -let interpreter = - let console = gui#console in - new MatitaInterpreter.interpreter ~disambiguator ~proof_handler ~console () - + gui#sourceView#source_buffer#begin_not_undoable_action (); + s#reset (); + s#template (); + gui#sourceView#source_buffer#end_not_undoable_action (); + s + + (* 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)) + 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 ((proof, goal) as status) -> + sequents_viewer#load_sequents status; + sequents_viewer#goto_sequent goal + | 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 + script#addObserver sequents_observer; + script#addObserver browser_observer - (** *) + (** {{{ Debugging *) let _ = if BuildTimeConf.debug then begin gui#main#debugMenu#misc#show (); @@ -152,28 +97,104 @@ 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 "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 getter settings" (fun _ -> + prerr_endline (Http_getter_env.env_to_string ())); + 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 "dump coercions Db" (fun _ -> + List.iter + (fun (s,t,u) -> + MatitaLog.debug + (UriManager.name_of_uri u ^ ":" + ^ UriManager.name_of_uri s ^ " -> " ^ UriManager.name_of_uri t)) + (CoercDb.to_list ())); + addDebugItem "print top-level grammar entries" + CicNotationParser.print_l2_pattern; + addDebugItem "dump moo to stderr" (fun _ -> + let status = (MatitaScript.instance ())#status in + List.iter (fun cmd -> prerr_endline + (GrafiteAstPp.pp_command cmd)) (List.rev status.moo_content_rev)); + addDebugItem "rotate light bulbs" + (fun _ -> + let nb = gui#main#hintNotebook in + nb#goto_page ((nb#current_page + 1) mod 3)); end - (** *) + (** Debugging }}} *) + + (** {2 Command line parsing} *) + +let debug = ref false +let args = ref [] +let add_arg arg = args := arg :: !args -let _ = GtkThread.main () +let arg_spec = + let std_arg_spec = [] in + let debug_arg_spec = + if BuildTimeConf.debug then + [ "-debug", Arg.Set debug, + "Do not catch top-level exception (useful for backtrace inspection)"; ] + else [] + in + std_arg_spec @ debug_arg_spec + +let usage () = + let heading = sprintf "Matita v%s\nUsage: " BuildTimeConf.version in + if Helm_registry.get "matita.mode" = "cicbrowser" then + heading ^ "cicbrowser [ URL | Whelp query ]\nOptions:" + else + heading ^ "matita [ FILE ]" + +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 _ = + set_matita_mode (); + Arg.parse arg_spec add_arg (usage ()); + Helm_registry.set_bool "matita.catch_top_level_exn" (not !debug); + at_exit (fun () -> print_endline "\nThanks for using Matita!\n"); + Sys.catch_break true; + 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 (); + end; + try + GtkThread.main () + with Sys.Break -> () + +(* vim:set foldmethod=marker: *)