From 6b649aba925b6f7462da07599fe67ebb12a3460e Mon Sep 17 00:00:00 2001 From: Samuel Mimram Date: Wed, 28 Jul 2004 21:54:47 +0000 Subject: Imported Upstream version 8.0pl1 --- ide/.coqide-gtk2rc | 49 + ide/FAQ | 73 + ide/blaster_window.ml | 183 ++ ide/command_windows.ml | 151 ++ ide/command_windows.mli | 22 + ide/config_lexer.mll | 68 + ide/config_parser.mly | 43 + ide/coq.ml | 479 +++++ ide/coq.mli | 66 + ide/coq.png | Bin 0 -> 9103 bytes ide/coq_commands.ml | 406 ++++ ide/coq_tactics.ml | 131 ++ ide/coq_tactics.mli | 12 + ide/coqide.ml | 3386 +++++++++++++++++++++++++++++ ide/coqide.mli | 16 + ide/extract_index.mll | 31 + ide/find_phrase.mll | 66 + ide/highlight.mll | 115 + ide/ideutils.ml | 307 +++ ide/ideutils.mli | 79 + ide/index_urls.txt | 563 +++++ ide/preferences.ml | 540 +++++ ide/preferences.mli | 67 + ide/undo.ml | 178 ++ ide/undo.mli | 35 + ide/utf8.v | 56 + ide/utf8_convert.mll | 51 + ide/utils/configwin.ml | 74 + ide/utils/configwin.mli | 300 +++ ide/utils/configwin_html_config.ml | 83 + ide/utils/configwin_ihm.ml | 1435 +++++++++++++ ide/utils/configwin_keys.ml | 4175 ++++++++++++++++++++++++++++++++++++ ide/utils/configwin_messages.ml | 51 + ide/utils/configwin_types.ml | 299 +++ ide/utils/editable_cells.ml | 114 + ide/utils/okey.ml | 185 ++ ide/utils/okey.mli | 114 + ide/utils/uoptions.ml | 772 +++++++ ide/utils/uoptions.mli | 148 ++ 39 files changed, 14923 insertions(+) create mode 100644 ide/.coqide-gtk2rc create mode 100644 ide/FAQ create mode 100644 ide/blaster_window.ml create mode 100644 ide/command_windows.ml create mode 100644 ide/command_windows.mli create mode 100644 ide/config_lexer.mll create mode 100644 ide/config_parser.mly create mode 100644 ide/coq.ml create mode 100644 ide/coq.mli create mode 100644 ide/coq.png create mode 100644 ide/coq_commands.ml create mode 100644 ide/coq_tactics.ml create mode 100644 ide/coq_tactics.mli create mode 100644 ide/coqide.ml create mode 100644 ide/coqide.mli create mode 100644 ide/extract_index.mll create mode 100644 ide/find_phrase.mll create mode 100644 ide/highlight.mll create mode 100644 ide/ideutils.ml create mode 100644 ide/ideutils.mli create mode 100644 ide/index_urls.txt create mode 100644 ide/preferences.ml create mode 100644 ide/preferences.mli create mode 100644 ide/undo.ml create mode 100644 ide/undo.mli create mode 100644 ide/utf8.v create mode 100644 ide/utf8_convert.mll create mode 100644 ide/utils/configwin.ml create mode 100644 ide/utils/configwin.mli create mode 100644 ide/utils/configwin_html_config.ml create mode 100644 ide/utils/configwin_ihm.ml create mode 100644 ide/utils/configwin_keys.ml create mode 100644 ide/utils/configwin_messages.ml create mode 100644 ide/utils/configwin_types.ml create mode 100644 ide/utils/editable_cells.ml create mode 100644 ide/utils/okey.ml create mode 100644 ide/utils/okey.mli create mode 100644 ide/utils/uoptions.ml create mode 100644 ide/utils/uoptions.mli (limited to 'ide') diff --git a/ide/.coqide-gtk2rc b/ide/.coqide-gtk2rc new file mode 100644 index 00000000..11c53dad --- /dev/null +++ b/ide/.coqide-gtk2rc @@ -0,0 +1,49 @@ +# Some default functions for CoqIde. You may copy the file in your HOME and +# edit as you want. See +# http://developer.gnome.org/doc/API/2.0/gtk/gtk-Resource-Files.html +# for a complete set of options +# To set the font of the text windows, edit the .coqiderc file through the menus. + +gtk-key-theme-name = "Emacs" + +#pixmap_path "/home/" + +binding "text" { + bind "k" { "set-anchor" () + "move-cursor" (display-line-ends,1,0) + "move-cursor" (visual-positions,1,0) + "cut-clipboard" () + } + bind "w" { "cut-clipboard" () } + +# For UTF-8 inputs ! +# bind "F11" {"insert-at-cursor" ("∀")} +# bind "F12" {"insert-at-cursor" ("∃")} +} +class "GtkTextView" binding "text" + + +style "views" { +base[NORMAL] = "CornSilk" +# bg_pixmap[NORMAL] = "background.jpg" +} +class "GtkTextView" style "views" + +widget "*.*.*.*.*.ScriptWindow" style "views" +widget "*.*.*.*.GoalWindow" style "views" +widget "*.*.*.*.MessageWindow" style "views" + +gtk-font-name = "Sans 12" + +style "location" { +font_name = "Sans 10" +} +widget "*location*" style "location" + + +gtk-can-change-accels = 1 + +style "men" { +# +} +widget "GtkMenu" style "men" diff --git a/ide/FAQ b/ide/FAQ new file mode 100644 index 00000000..2079ef6c --- /dev/null +++ b/ide/FAQ @@ -0,0 +1,73 @@ + CoqIde FAQ + +Q0) What is CoqIde? +R0: A powerfull graphical interface for Coq. See http://coq.inria.fr. for more informations. + +Q1) How to enable Emacs keybindings? +R1: Insert + gtk-key-theme-name = "Emacs" + in your ".coqide-gtk2rc" file. It may be in the current dir + or in $HOME dir. This is done by default. + +Q2) How to enable antialiased fonts? +R2) Set the GDK_USE_XFT variable to 1. This is by default with Gtk >= 2.2. + If some of your fonts are not available, set GDK_USE_XFT to 0. + +Q4) How to use those Forall and Exists pretty symbols? +R4) Thanks to the Notation features in Coq, you just need to insert these + lines in your Coq Buffer : +====================================================================== +Notation "∀ x : t, P" := (forall x:t, P) (at level 200, x ident). +Notation "∃ x : t, P" := (exists x:t, P) (at level 200, x ident). +====================================================================== +Copy/Paste of these lines from this file will not work outside of CoqIde. +You need to load a file containing these lines or to enter the "∀" +using an input method (see Q5). To try it just use "Require utf8" from inside +CoqIde. +To enable these notations automatically start coqide with + coqide -l utf8 +In the ide subdir of Coq library, you will find a sample utf8.v with some +pretty simple notations. + +Q5) How to define an input method for non ASCII symbols? +R5)-First solution : type "2200" to enter a forall in the script widow. + 2200 is the hexadecimal code for forall in unicode charts and is encoded as "∀" + in UTF-8. + 2203 is for exists. See http://www.unicode.org for more codes. +-Second solution : rebind "a" to forall and "e" to exists. + Under X11, you need to use something like + xmodmap -e "keycode 24 = a A F13 F13" + xmodmap -e "keycode 26 = e E F14 F14" + and then to add + bind "F13" {"insert-at-cursor" ("∀")} + bind "F14" {"insert-at-cursor" ("∃")} + to your "binding "text"" section in .coqiderc-gtk2rc. + The strange ("∀") argument is the UTF-8 encoding for + 0x2200. + You can compute these encodings using the lablgtk2 toplevel with + Glib.Utf8.from_unichar 0x2200;; + Further symbols can be bound on higher Fxx keys or on even on other keys you + do not need . + +Q6) How to build a custom CoqIde with user ml code? +R6) Use + coqmktop -ide -byte m1.cmo...mi.cmo + or + coqmktop -ide -opt m1.cmx...mi.cmx + +Q7) How to customize the shortcuts for menus? +R7) Two solutions are offered: + - Edit $HOME/.coqide.keys by hand or + - Add "gtk-can-change-accels = 1" in your .coqide-gtk2rc file. Then + from CoqIde, you may select a menu entry and press the desired + shortcut. + +Q8) What encoding should I use? What is this \x{iiii} in my file? +R8) The encoding option is related to the way files are saved. + Keep it as UTF-8 until it becomes important for you to exchange files + with non UTF-8 aware applications. + If you choose something else than UTF-8, then missing characters will + be encoded by \x{....} or \x{........} where each dot is an hex. digit. + The number between braces is the hexadecimal UNICODE index for the + missing character. + diff --git a/ide/blaster_window.ml b/ide/blaster_window.ml new file mode 100644 index 00000000..cca788c2 --- /dev/null +++ b/ide/blaster_window.ml @@ -0,0 +1,183 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* Coq.tried_tactic) + (on_click:unit -> unit) + = + let root_iter = + try Hashtbl.find roots root + with Not_found -> + let nr = new_arg root in + Hashtbl.add roots root nr; + nr + in + let nt = new_tac root_iter name in + let old_val = try MyMap.find root tbl with Not_found -> MyMap.empty in + tbl <- MyMap.add root (MyMap.add name (nt,compute,on_click) old_val) tbl + + method clear () = + model#clear (); + tbl <- MyMap.empty; + Hashtbl.clear roots; + + method blaster () = + view#expand_all (); + try MyMap.iter + (fun root_name l -> + try + MyMap.iter + (fun name (nt,compute,on_click) -> + match compute () with + | Coq.Interrupted -> + prerr_endline "Interrupted"; + raise Stop + | Coq.Failed -> + prerr_endline "Failed"; + ignore (model#remove nt) + (* model#set ~row:nt ~column:status false; + model#set ~row:nt ~column:nb_goals "N/A" + *) + | Coq.Success n -> + prerr_endline "Success"; + model#set ~row:nt ~column:status true; + model#set ~row:nt ~column:nb_goals (string_of_int n); + if n= -1 then raise Done + ) + l + with Done -> ()) + tbl; + Condition.signal blaster_killed; + prerr_endline "End of blaster"; + with Stop -> + Condition.signal blaster_killed; + prerr_endline "End of blaster (stopped !)"; + + initializer + ignore (window#event#connect#delete (fun _ -> window#misc#hide(); true)); + ignore (view#selection#connect#after#changed ~callback: + begin fun () -> + prerr_endline "selection changed"; + List.iter + (fun path ->let pt = GtkTree.TreePath.to_string path in + let it = model#get_iter path in + prerr_endline (string_of_bool (model#iter_is_valid it)); + let name = model#get + ~row:(if String.length pt >1 then begin + ignore (GtkTree.TreePath.up path); + model#get_iter path + end else it + ) + ~column:argument in + let tactic = model#get ~row:it ~column:tactic in + prerr_endline ("Got name: "^name); + let success = model#get ~row:it ~column:status in + if success then try + prerr_endline "Got success"; + let _,_,f = MyMap.find tactic (MyMap.find name tbl) in + f (); + (* window#misc#hide () *) + with _ -> () + ) + view#selection#get_selected_rows + end); + +(* needs lablgtk2 update ignore (view#connect#after#row_activated + (fun path vcol -> + prerr_endline "Activated"; + ); +*) +end + +let blaster_window = ref None + +let main n = blaster_window := Some (new blaster_window n) + +let present_blaster_window () = match !blaster_window with + | None -> failwith "No blaster window." + | Some c -> c#window#misc#show (* present*) (); c + + +let blaster_window () = match !blaster_window with + | None -> failwith "No blaster window." + | Some c -> c + + diff --git a/ide/command_windows.ml b/ide/command_windows.ml new file mode 100644 index 00000000..42b65048 --- /dev/null +++ b/ide/command_windows.ml @@ -0,0 +1,151 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* notebook#remove_page notebook#current_page) + () + in +object(self) + val window = window +(* + val menubar = menubar +*) + val new_page_menu = new_page_menu + val notebook = notebook + method window = window + method new_command ?command ?term () = + let frame = GBin.frame + ~shadow_type:`ETCHED_OUT + ~packing:notebook#append_page + () + in + notebook#goto_page (notebook#page_num frame#coerce); + let vbox = GPack.vbox ~homogeneous:false ~packing:frame#add () in + let hbox = GPack.hbox ~homogeneous:false ~packing:vbox#pack () in + let combo = GEdit.combo ~popdown_strings:Coq_commands.state_preserving + ~enable_arrow_keys:true + ~allow_empty:false + ~value_in_list:false (* true is not ok with disable_activate...*) + ~packing:hbox#pack + () + in + combo#disable_activate (); + let on_activate c () = + if List.mem combo#entry#text Coq_commands.state_preserving then c () + else prerr_endline "Not a state preserving command" + in + let entry = GEdit.entry ~packing:(hbox#pack ~expand:true) () in + entry#misc#set_can_default true; + let r_bin = + GBin.scrolled_window + ~vpolicy:`AUTOMATIC + ~hpolicy:`AUTOMATIC + ~packing:(vbox#pack ~fill:true ~expand:true) () in + let ok_b = GButton.button ~label:"Ok" ~packing:(hbox#pack ~expand:false) () in + let result = GText.view ~packing:r_bin#add () in + result#misc#set_can_focus true; (* false causes problems for selection *) + result#set_editable false; + let callback () = + let com = combo#entry#text in + let phrase = + if String.get com (String.length com - 1) = '.' + then com ^ " " else com ^ " " ^ entry#text ^" . " + in + try + ignore(Coq.interp false phrase); + result#buffer#set_text + ("Result for command " ^ phrase ^ ":\n" ^ Ideutils.read_stdout ()) + with e -> + let (s,loc) = Coq.process_exn e in + assert (Glib.Utf8.validate s); + result#buffer#set_text s + in + ignore (combo#entry#connect#activate ~callback:(on_activate callback)); + ignore (ok_b#connect#clicked ~callback:(on_activate callback)); + + begin match command,term with + | None,None -> () + | Some c, None -> + combo#entry#set_text c; + + | Some c, Some t -> + combo#entry#set_text c; + entry#set_text t + + | None , Some t -> + entry#set_text t + end; + on_activate callback (); + entry#misc#grab_focus (); + entry#misc#grab_default (); + ignore (entry#connect#activate ~callback); + ignore (combo#entry#connect#activate ~callback); + self#window#present () + + initializer + ignore (new_page_menu#connect#clicked self#new_command); + ignore (window#event#connect#delete (fun _ -> window#misc#hide(); true)); +end + +let command_window = ref None + +let main () = command_window := Some (new command_window ()) + +let command_window () = match !command_window with + | None -> failwith "No command window." + | Some c -> c diff --git a/ide/command_windows.mli b/ide/command_windows.mli new file mode 100644 index 00000000..014be777 --- /dev/null +++ b/ide/command_windows.mli @@ -0,0 +1,22 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* + object + method new_command : ?command:string -> ?term:string -> unit -> unit + method window : GWindow.window + end + +val main : unit -> unit + +val command_window : unit -> command_window + + diff --git a/ide/config_lexer.mll b/ide/config_lexer.mll new file mode 100644 index 00000000..1c0720d1 --- /dev/null +++ b/ide/config_lexer.mll @@ -0,0 +1,68 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* s)) } + | _ { let c = lexeme_start lexbuf in + eprintf ".coqiderc: invalid character (%d)\n@." c; + token lexbuf } + | eof { EOF } + +and string = parse + | '"' { Buffer.add_char string_buffer '"' } + | '\\' '"' | _ + { Buffer.add_string string_buffer (lexeme lexbuf); string lexbuf } + | eof { eprintf ".coqiderc: unterminated string\n@." } + +{ + + let load_file f = + let c = open_in f in + let lb = from_channel c in + let m = Config_parser.prefs token lb in + close_in c; + m + + let print_file f m = + let c = open_out f in + let fmt = formatter_of_out_channel c in + let rec print_list fmt = function + | [] -> () + | s :: sl -> fprintf fmt "%S@ %a" s print_list sl + in + Stringmap.iter + (fun k s -> fprintf fmt "@[%s = %a@]@\n" k print_list s) m; + fprintf fmt "@."; + close_out c + +} diff --git a/ide/config_parser.mly b/ide/config_parser.mly new file mode 100644 index 00000000..48005efe --- /dev/null +++ b/ide/config_parser.mly @@ -0,0 +1,43 @@ +/***********************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* IDENT STRING +%token EQUAL EOF + +%type <(string list) Util.Stringmap.t> prefs +%start prefs + +%% + +prefs: + pref_list EOF { $1 } +; + +pref_list: + pref_list pref { let (k,d) = $2 in Stringmap.add k d $1 } + | /* epsilon */ { Stringmap.empty } +; + +pref: + IDENT EQUAL string_list { ($1, List.rev $3) } +; + +string_list: + string_list STRING { $2 :: $1 } + | /* epsilon */ { [] } +; + diff --git a/ide/coq.ml b/ide/coq.ml new file mode 100644 index 00000000..e582f2d9 --- /dev/null +++ b/ide/coq.ml @@ -0,0 +1,479 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* " + in + Printf.sprintf + "The Coq Proof Assistant, version %s (%s)\ + \nConfigured on %s\ + \nArchitecture %s running %s operating system\ + \nGtk version is %s\ + \nThis is the %s version (%s is the best one for this architecture and OS)\ + \n" + Coq_config.version date Coq_config.compile_date + Coq_config.arch Sys.os_type + (let x,y,z = GMain.Main.version in Printf.sprintf "%d.%d.%d" x y z) + (if Mltop.get () = Mltop.Native then "native" else "bytecode") + (if Coq_config.best="opt" then "native" else "bytecode") + +let is_in_coq_lib dir = + prerr_endline ("Is it a coq theory ? : "^dir); + try + let stat = Unix.stat dir in + List.exists + (fun s -> + try + let fdir = Filename.concat + Coq_config.coqlib + (Filename.concat "theories" s) + in + prerr_endline (" Comparing to: "^fdir); + let fstat = Unix.stat fdir in + (fstat.Unix.st_dev = stat.Unix.st_dev) && + (fstat.Unix.st_ino = stat.Unix.st_ino) && + (prerr_endline " YES";true) + with _ -> prerr_endline " No(because of a local exn)";false + ) + Coq_config.theories_dirs + with _ -> prerr_endline " No(because of a global exn)";false + +let is_in_coq_path f = + try + let base = Filename.chop_extension (Filename.basename f) in + let _ = Library.locate_qualified_library + (Libnames.make_qualid Names.empty_dirpath + (Names.id_of_string base)) in + prerr_endline (f ^ "is in coq path"); + true + with _ -> + prerr_endline (f ^ "is NOT in coq path"); + false + +let is_in_proof_mode () = + try ignore (get_pftreestate ()); true with _ -> false + +let user_error_loc l s = + raise (Stdpp.Exc_located (l, Util.UserError ("CoqIde", s))) + +let interp verbosely s = + prerr_endline "Starting interp..."; + prerr_endline s; + let pa = Pcoq.Gram.parsable (Stream.of_string s) in + let pe = Pcoq.Gram.Entry.parse Pcoq.main_entry pa in + match pe with + | None -> assert false + | Some((loc,vernac) as last) -> + match vernac with + | VernacDefinition _ | VernacStartTheoremProof _ + | VernacBeginSection _ | VernacGoal _ + | VernacDefineModule _ | VernacDeclareModuleType _ + | VernacDeclareTacticDefinition _ + when is_in_proof_mode () -> + user_error_loc loc (str "CoqIDE do not support nested goals") + | VernacDebug _ -> + user_error_loc loc (str "Debug mode not available within CoqIDE") + | VernacResetName _ + | VernacResetInitial + | VernacBack _ + | VernacAbort _ + | VernacAbortAll + | VernacRestart + | VernacSuspend + | VernacResume _ + | VernacUndo _ -> + user_error_loc loc (str "Use CoqIDE navigation instead") + | _ -> + begin + match vernac with + | VernacPrintOption _ + | VernacCheckMayEval _ + | VernacGlobalCheck _ + | VernacPrint _ + | VernacSearch _ + -> !flash_info + "Warning: query commands should not be inserted in scripts" + | VernacDefinition (_,_,DefineBody _,_) + | VernacInductive _ + | VernacFixpoint _ + | VernacCoFixpoint _ + | VernacEndProof _ + -> Options.make_silent (not verbosely) + | _ -> () + end; + Vernac.raw_do_vernac (Pcoq.Gram.parsable (Stream.of_string s)); + Options.make_silent true; + prerr_endline ("...Done with interp of : "^s); + last + +let interp_and_replace s = + let result = interp false s in + let msg = read_stdout () in + result,msg + +let nb_subgoals pf = + List.length (fst (Refiner.frontier (Tacmach.proof_of_pftreestate pf))) + +type tried_tactic = + | Interrupted + | Success of int (* nb of goals after *) + | Failed + +let try_interptac s = + try + prerr_endline ("Starting try_interptac: "^s); + let pf = get_pftreestate () in + let pe = Pcoq.Gram.Entry.parse + Pcoq.main_entry + (Pcoq.Gram.parsable (Stream.of_string s)) + in match pe with + | Some (loc,(VernacSolve (n, tac, _))) -> + let tac = Tacinterp.interp tac in + let pf' = solve_nth_pftreestate n tac pf in + prerr_endline "Success"; + let nb_goals = nb_subgoals pf' - nb_subgoals pf in + Success nb_goals + | _ -> + prerr_endline "try_interptac: not a tactic"; Failed + with + | Sys.Break | Stdpp.Exc_located (_,Sys.Break) + -> prerr_endline "try_interp: interrupted"; Interrupted + | Stdpp.Exc_located (_,e) -> prerr_endline ("try_interp: failed ("^(Printexc.to_string e)); Failed + | e -> Failed + +let is_tactic = function + | VernacSolve _ -> true + | _ -> false + + +let rec is_pervasive_exn = function + | Out_of_memory | Stack_overflow | Sys.Break -> true + | Error_in_file (_,_,e) -> is_pervasive_exn e + | Stdpp.Exc_located (_,e) -> is_pervasive_exn e + | DuringCommandInterp (_,e) -> is_pervasive_exn e + | _ -> false + +let print_toplevel_error exc = + let (dloc,exc) = + match exc with + | DuringCommandInterp (loc,ie) -> + if loc = dummy_loc then (None,ie) else (Some loc, ie) + | _ -> (None, exc) + in + let (loc,exc) = + match exc with + | Stdpp.Exc_located (loc, ie) -> (Some loc),ie + | Error_in_file (s, (_,fname, loc), ie) -> None, ie + | _ -> dloc,exc + in + match exc with + | End_of_input -> str "Please report: End of input",None + | Vernacexpr.ProtectedLoop -> + str "ProtectedLoop not allowed by coqide!",None + | Vernacexpr.Drop -> str "Drop is not allowed by coqide!",None + | Vernacexpr.Quit -> str "Quit is not allowed by coqide! Use menus.",None + | _ -> + (try Cerrors.explain_exn exc with e -> + str "Failed to explain error. This is an internal Coq error. Please report.\n" + ++ str (Printexc.to_string e)), + (if is_pervasive_exn exc then None else loc) + +let process_exn e = let s,loc= print_toplevel_error e in (msgnl s,loc) + +let interp_last last = + prerr_string "*"; + try + vernac_com (States.with_heavy_rollback Vernacentries.interp) last + with e -> + let s,_ = process_exn e in prerr_endline ("Replay during undo failed because: "^s); + raise e + + +type hyp = env * evar_map * + ((identifier * string) * constr option * constr) * + (string * string) +type concl = env * evar_map * constr * string +type goal = hyp list * concl + +let prepare_hyp sigma env ((i,c,d) as a) = + env, sigma, + ((i,string_of_id i),c,d), + (msg (pr_var_decl env a), msg (prterm_env_at_top env d)) + +let prepare_hyps sigma env = + assert (rel_context env = []); + let hyps = + fold_named_context + (fun env d acc -> let hyp = prepare_hyp sigma env d in hyp :: acc) + env ~init:[] + in + List.rev hyps + +let prepare_goal sigma g = + let env = evar_env g in + (prepare_hyps sigma env, + (env, sigma, g.evar_concl, msg (prterm_env_at_top env g.evar_concl))) + +let get_current_goals () = + let pfts = get_pftreestate () in + let gls = fst (Refiner.frontier (Tacmach.proof_of_pftreestate pfts)) in + let sigma = Tacmach.evc_of_pftreestate pfts in + List.map (prepare_goal sigma) gls + +let get_current_goals_nb () = + try List.length (get_current_goals ()) with _ -> 0 + + +let print_no_goal () = + let pfts = get_pftreestate () in + let gls = fst (Refiner.frontier (Tacmach.proof_of_pftreestate pfts)) in + assert (gls = []); + let sigma = Tacmach.project (Tacmach.top_goal_of_pftreestate pfts) in + msg (Proof_trees.pr_subgoals_existential sigma gls) + + +type word_class = Normal | Kwd | Reserved + + +let kwd = [(* "Compile";"Inductive";"Qed";"Type";"end";"Axiom"; + "Definition";"Load";"Quit";"Variable";"in";"Cases";"FixPoint"; + "Parameter";"Set";"of";"CoFixpoint";"Grammar";"Proof";"Syntax"; + "using";"CoInductive";"Hypothesis";"Prop";"Theorem"; + *) + "Add"; "AddPath"; "Axiom"; "Chapter"; "CoFixpoint"; + "CoInductive"; "Defined"; "Definition"; + "End"; "Export"; "Fact"; "Fix"; "Fixpoint"; "Global"; "Grammar"; "Hint"; + "Hypothesis"; "Immediate"; "Implicits"; "Import"; "Inductive"; + "Infix"; "Lemma"; "Load"; "Local"; + "Match"; "Module"; "Module Type"; + "Mutual"; "Parameter"; "Print"; "Proof"; "Qed"; + "Record"; "Recursive"; "Remark"; "Require"; "Save"; "Scheme"; + "Section"; "Show"; "Syntactic"; "Syntax"; "Tactic"; "Theorem"; + "Unset"; "Variable"; "Variables"; +] + +let reserved = [] + +module SHashtbl = + Hashtbl.Make + (struct + type t = string + let equal = ( = ) + let hash = Hashtbl.hash + end) + + +let word_tbl = SHashtbl.create 37 +let _ = + List.iter (fun w -> SHashtbl.add word_tbl w Kwd) kwd; + List.iter (fun w -> SHashtbl.add word_tbl w Reserved) reserved + +let word_class s = + try + SHashtbl.find word_tbl s + with Not_found -> Normal + +type reset_info = NoReset | Reset of Names.identifier * bool ref + +let compute_reset_info = function + | VernacDefinition (_, (_,id), DefineBody _, _) + | VernacBeginSection (_,id) + | VernacDefineModule ((_,id), _, _, _) + | VernacDeclareModule ((_,id), _, _, _) + | VernacDeclareModuleType ((_,id), _, _) + | VernacAssumption (_, (_,((_,id)::_,_))::_) + | VernacInductive (_, ((_,id),_,_,_,_) :: _) -> + Reset (id, ref true) + | VernacDefinition (_, (_,id), ProveBody _, _) + | VernacStartTheoremProof (_, (_,id), _, _, _) -> + Reset (id, ref false) + | _ -> NoReset + +let reset_initial () = + prerr_endline "Reset initial called"; flush stderr; + Vernacentries.abort_refine Lib.reset_initial () + +let reset_to id = + prerr_endline ("Reset called with "^(string_of_id id)); + Vernacentries.abort_refine Lib.reset_name (Util.dummy_loc,id) +let reset_to_mod id = + prerr_endline ("Reset called to Mod/Sect with "^(string_of_id id)); + Vernacentries.abort_refine Lib.reset_mod (Util.dummy_loc,id) + + +let hyp_menu (env, sigma, ((coqident,ident),_,ast),(s,pr_ast)) = + [("clear "^ident),("clear "^ident^"."); + + ("apply "^ident), + ("apply "^ident^"."); + + ("exact "^ident), + ("exact "^ident^"."); + + ("generalize "^ident), + ("generalize "^ident^"."); + + ("absurd <"^ident^">"), + ("absurd "^ + pr_ast + ^".") ] @ + + (if is_equation ast then + [ "discriminate "^ident, "discriminate "^ident^"."; + "injection "^ident, "injection "^ident^"." ] + else + []) @ + + (let _,t = splay_prod env sigma ast in + if is_equation t then + [ "rewrite "^ident, "rewrite "^ident^"."; + "rewrite <- "^ident, "rewrite <- "^ident^"." ] + else + []) @ + + [("elim "^ident), + ("elim "^ident^"."); + + ("inversion "^ident), + ("inversion "^ident^"."); + + ("inversion clear "^ident), + ("inversion_clear "^ident^".")] + +let concl_menu (_,_,concl,_) = + let is_eq = is_equation concl in + ["intro", "intro."; + "intros", "intros."; + "intuition","intuition." ] @ + + (if is_eq then + ["reflexivity", "reflexivity."; + "discriminate", "discriminate."; + "symmetry", "symmetry." ] + else + []) @ + + ["assumption" ,"assumption."; + "omega", "omega."; + "ring", "ring."; + "auto with *", "auto with *."; + "eauto with *", "eauto with *."; + "tauto", "tauto."; + "trivial", "trivial."; + "decide equality", "decide equality."; + + "simpl", "simpl."; + "subst", "subst."; + + "red", "red."; + "split", "split."; + "left", "left."; + "right", "right."; + ] + + +let id_of_name = function + | Names.Anonymous -> id_of_string "x" + | Names.Name x -> x + +let make_cases s = + let qualified_name = Libnames.qualid_of_string s in + let glob_ref = Nametab.locate qualified_name in + match glob_ref with + | Libnames.IndRef i -> + let _, + { + Declarations.mind_nparams = np ; + Declarations.mind_consnames = carr ; + Declarations.mind_nf_lc = tarr } + = Global.lookup_inductive i + in + Util.array_fold_right2 + (fun n t l -> + let (al,_) = Term.decompose_prod t in + let al,_ = Util.list_chop (List.length al - np) al in + let rec rename avoid = function + | [] -> [] + | (n,_)::l -> + let n' = next_global_ident_away true + (id_of_name n) + avoid + in (string_of_id n')::(rename (n'::avoid) l) + in + let al' = rename [] (List.rev al) in + (string_of_id n :: al') :: l + ) + carr + tarr + [] + | _ -> raise Not_found + +let is_state_preserving = function + | VernacPrint _ | VernacPrintOption _ | VernacGlobalCheck _ + | VernacCheckMayEval _ | VernacSearch _ | VernacLocate _ + | VernacShow _ | VernacMemOption _ | VernacComments _ + | VernacChdir None | VernacNop -> + prerr_endline "state preserving command found"; true + | _ -> + false + + +let current_status () = + let path = msg (Libnames.pr_dirpath (Lib.cwd ())) in + let path = if path = "Top" then "Ready" else "Ready in " ^ String.sub path 4 (String.length path - 4) in + try + path ^ ", proving " ^ (Names.string_of_id (Pfedit.get_current_proof_name ())) + with _ -> path + + diff --git a/ide/coq.mli b/ide/coq.mli new file mode 100644 index 00000000..bcebd4e6 --- /dev/null +++ b/ide/coq.mli @@ -0,0 +1,66 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* string + +val init : unit -> string list +val interp : bool -> string -> Util.loc * Vernacexpr.vernac_expr +val interp_last : Util.loc * Vernacexpr.vernac_expr -> unit +val interp_and_replace : string -> (Util.loc * Vernacexpr.vernac_expr) * string + +val is_tactic : Vernacexpr.vernac_expr -> bool +val is_state_preserving : Vernacexpr.vernac_expr -> bool + +(* type hyp = (identifier * constr option * constr) * string *) + +type hyp = env * evar_map * + ((identifier*string) * constr option * constr) * (string * string) +type concl = env * evar_map * constr * string +type goal = hyp list * concl + +val get_current_goals : unit -> goal list + +val get_current_goals_nb : unit -> int + +val print_no_goal : unit -> string + +val process_exn : exn -> string*(Util.loc option) + +type reset_info = NoReset | Reset of Names.identifier * bool ref + +val compute_reset_info : Vernacexpr.vernac_expr -> reset_info +val reset_initial : unit -> unit +val reset_to : identifier -> unit +val reset_to_mod : identifier -> unit + +val hyp_menu : hyp -> (string * string) list +val concl_menu : concl -> (string * string) list + +val is_in_coq_lib : string -> bool +val is_in_coq_path : string -> bool + +val make_cases : string -> string list list + + +type tried_tactic = + | Interrupted + | Success of int (* nb of goals after *) + | Failed + +val try_interptac: string -> tried_tactic + +(* Message to display in lower status bar. *) + +val current_status : unit -> string diff --git a/ide/coq.png b/ide/coq.png new file mode 100644 index 00000000..011203f7 Binary files /dev/null and b/ide/coq.png differ diff --git a/ide/coq_commands.ml b/ide/coq_commands.ml new file mode 100644 index 00000000..1169d438 --- /dev/null +++ b/ide/coq_commands.ml @@ -0,0 +1,406 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* "; + "dependent rewrite <-"; + "destruct"; + "discriminate"; + "do"; + "double induction"; + ]; + + [ + "eapply"; + "eauto"; + "eauto with"; + "eexact"; + "elim"; + "elim __ using"; + "elim __ with"; + "elimtype"; + "exact"; + "exists"; + ]; + + [ + "fail"; + "field"; + "first"; + "firstorder"; + "firstorder using"; + "firstorder with"; + "fix"; + "fix __ with"; + "fold"; + "fold __ in"; + "fourier"; + "functional induction"; + ]; + + [ + "generalize"; + "generalize dependent"; + ]; + + [ + "hnf"; + ]; + + [ + "idtac"; + "induction"; + "info"; + "injection"; + "instantiate (__:=__)"; + "intro"; + "intro after"; + "intro __ after"; + "intros"; + "intros until"; + "intuition"; + "inversion"; + "inversion __ in"; + "inversion __ using"; + "inversion __ using __ in"; + "inversion__clear"; + "inversion__clear __ in"; + ]; + + [ + "jp "; + "jp"; + ]; + + [ + "lapply"; + "lazy"; + "lazy in"; + "left"; + ]; + + [ + "move __ after"; + ]; + + [ + "omega"; + ]; + + [ + "pattern"; + "pose"; + "pose __:=__)"; + "progress"; + ]; + + [ + "quote"; + ]; + + [ + "red"; + "red in"; + "refine"; + "reflexivity"; + "rename __ into"; + "repeat"; + "replace __ with"; + "rewrite"; + "rewrite __ in"; + "rewrite <-"; + "rewrite <- __ in"; + "right"; + "ring"; + ]; + + [ + "set"; + "set (__:=__)"; + "setoid__replace"; + "setoid__rewrite"; + "simpl"; + "simpl __ in"; + "simple destruct"; + "simple induction"; + "simple inversion"; + "simplify__eq"; + "solve"; + "split"; +(* "split__Rabs"; + "split__Rmult"; +*) + "subst"; + "symmetry"; + "symmetry in"; + ]; + + [ + "tauto"; + "transitivity"; + "trivial"; + "try"; + ]; + + [ + "unfold"; + "unfold __ in"; + ]; +] + + diff --git a/ide/coq_tactics.ml b/ide/coq_tactics.ml new file mode 100644 index 00000000..4dd20b47 --- /dev/null +++ b/ide/coq_tactics.ml @@ -0,0 +1,131 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* "; + "Dependent Rewrite <-"; + "Derive Inversion"; + "Destruct"; + "Discriminate"; + "DiscrR"; + "Do"; + "Double Induction"; + "EApply"; + "EAuto"; + "Elim ... using"; + "Elim ... with"; + "ElimType"; + "Exact"; + "Exists"; + "Fail"; + "Field"; + "First"; + "Fold"; + "Fourier"; + "Generalize"; + "Generalize Dependent"; + "Print Hint"; + "Hnf"; + "Idtac"; + "Induction"; + "Info"; + "Injection"; + "Intro"; + "Intro ... after"; + "Intro after"; + "Intros"; + "Intros pattern"; + "Intros until"; + "Intuition"; + "Inversion"; + "Inversion ... in"; + "Inversion ... using"; + "Inversion ... using ... in"; + "Inversion_clear"; + "Inversion_clear ... in"; + "LApply"; + "Lazy"; + "Left"; + "LetTac"; + "Move"; + "NewDestruct"; + "NewInduction"; + "Omega"; + "Orelse"; + "Pattern"; + "Pose"; + "Prolog"; + "Quote"; + "Red"; + "Refine"; + "Reflexivity"; + "Rename"; + "Repeat"; + "Replace ... with"; + "Rewrite"; + "Rewrite ->"; + "Rewrite -> ... in"; + "Rewrite <-"; + "Rewrite <- ... in"; + "Rewrite ... in"; + "Right"; + "Ring"; + "Setoid_replace"; + "Setoid_rewrite"; + "Simpl"; + "Simple Inversion"; + "Simplify_eq"; + "Solve"; + "Split"; + "SplitAbsolu"; + "SplitRmult"; + "Subst"; + "Symmetry"; + "Tacticals"; + "Tauto"; + "Transitivity"; + "Trivial"; + "Try"; + "tactic macros"; + "Unfold"; + "Unfold ... in"; +] diff --git a/ide/coq_tactics.mli b/ide/coq_tactics.mli new file mode 100644 index 00000000..8d603346 --- /dev/null +++ b/ide/coq_tactics.mli @@ -0,0 +1,12 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* failwith "Internal error in out_some" | Some f -> f + +let cb_ = ref None +let cb () = ((out_some !cb_):GData.clipboard) +let last_cb_content = ref "" + +let (message_view:GText.view option ref) = ref None +let (proof_view:GText.view option ref) = ref None + +let (_notebook:GPack.notebook option ref) = ref None +let notebook () = out_some !_notebook + + +(* Tabs contain the name of the edited file and 2 status informations: + Saved state + Focused proof buffer *) +let decompose_tab w = + let vbox = new GPack.box ((Gobject.try_cast w "GtkBox"):Gtk.box Gtk.obj) in + let l = vbox#children in + match l with + | [img;lbl] -> + let img = new GMisc.image + ((Gobject.try_cast img#as_widget "GtkImage"): + Gtk.image Gtk.obj) + in + let lbl = GMisc.label_cast lbl in + vbox,img,lbl + | _ -> assert false + +let set_tab_label i n = + let nb = notebook () in + let _,_,lbl = decompose_tab (nb#get_tab_label(nb#get_nth_page i))#as_widget + in + lbl#set_use_markup true; + (* lbl#set_text n *) lbl#set_label n + + +let set_tab_image ~icon i = + let nb = notebook () in + let _,img,_ = decompose_tab (nb#get_tab_label(nb#get_nth_page i))#as_widget + in + img#set_icon_size `SMALL_TOOLBAR; + img#set_stock icon + +let set_current_tab_image ~icon = set_tab_image ~icon (notebook())#current_page + +let set_current_tab_label n = set_tab_label (notebook())#current_page n + +let get_tab_label i = + let nb = notebook () in + let _,_,lbl = decompose_tab (nb#get_tab_label(nb#get_nth_page i))#as_widget + in + lbl#text + +let get_full_tab_label i = + let nb = notebook () in + let _,_,lbl = decompose_tab (nb#get_tab_label(nb#get_nth_page i))#as_widget + in + lbl + +let get_current_tab_label () = get_tab_label (notebook())#current_page + +let get_current_page () = + let i = (notebook())#current_page in + (notebook())#get_nth_page i + +(* This function must remove "focused proof" decoration *) +let reset_tab_label i = + set_tab_label i (get_tab_label i) + +let to_do_on_page_switch = ref [] + +module Vector = struct + exception Found of int + type 'a t = ('a option) array ref + let create () = ref [||] + let length t = Array.length !t + let get t i = out_some (Array.get !t i) + let set t i v = Array.set !t i (Some v) + let remove t i = Array.set !t i None + let append t e = t := Array.append !t [|Some e|]; (Array.length !t)-1 + let iter f t = Array.iter (function | None -> () | Some x -> f x) !t + let find_or_fail f t = + let test i = function | None -> () | Some e -> if f e then raise (Found i) in + Array.iteri test t + + let exists f t = + let l = Array.length !t in + let rec test i = + (i < l) && (((!t.(i) <> None) && f (out_some !t.(i))) || test (i+1)) + in + test 0 +end + +type 'a viewable_script = + {view : Undo.undoable_view; + mutable analyzed_view : 'a option; + } + + +class type analyzed_views= +object('self) + val mutable act_id : GtkSignal.id option + val current_all : 'self viewable_script + val mutable deact_id : GtkSignal.id option + val input_buffer : GText.buffer + val input_view : Undo.undoable_view + val last_array : string array + val mutable last_index : bool + val message_buffer : GText.buffer + val message_view : GText.view + val proof_buffer : GText.buffer + val proof_view : GText.view + val mutable is_active : bool + val mutable read_only : bool + val mutable filename : string option + val mutable stats : Unix.stats option + val mutable detached_views : GWindow.window list + method without_auto_complete : 'a 'b. ('a -> 'b) -> 'a -> 'b + method set_auto_complete : bool -> unit + + method kill_detached_views : unit -> unit + method add_detached_view : GWindow.window -> unit + method remove_detached_view : GWindow.window -> unit + + method view : Undo.undoable_view + method filename : string option + method stats : Unix.stats option + method set_filename : string option -> unit + method update_stats : unit + method revert : unit + method auto_save : unit + method save : string -> bool + method save_as : string -> bool + method read_only : bool + method set_read_only : bool -> unit + method is_active : bool + method activate : unit -> unit + method active_keypress_handler : GdkEvent.Key.t -> bool + method backtrack_to : GText.iter -> unit + method backtrack_to_no_lock : GText.iter -> unit + method clear_message : unit + method deactivate : unit -> unit + method disconnected_keypress_handler : GdkEvent.Key.t -> bool + method electric_handler : GtkSignal.id + method find_phrase_starting_at : + GText.iter -> (GText.iter * GText.iter) option + method get_insert : GText.iter + method get_start_of_input : GText.iter + method go_to_insert : unit + method indent_current_line : unit + method insert_command : string -> string -> unit + method tactic_wizard : string list -> unit + method insert_message : string -> unit + method insert_this_phrase_on_success : + bool -> bool -> bool -> string -> string -> bool + method process_next_phrase : bool -> bool -> bool -> bool + method process_until_iter_or_error : GText.iter -> unit + method process_until_end_or_error : unit + method recenter_insert : unit + method reset_initial : unit + method send_to_coq : + bool -> bool -> string -> + bool -> bool -> bool -> (Util.loc * Vernacexpr.vernac_expr) option + method set_message : string -> unit + method show_goals : unit + method show_goals_full : unit + method undo_last_step : unit + method help_for_keyword : unit -> unit + method complete_at_offset : int -> bool + + method blaster : unit -> unit +end + +let (input_views:analyzed_views viewable_script Vector.t) = Vector.create () + + +let signals_to_crash = [Sys.sigabrt; Sys.sigalrm; Sys.sigfpe; Sys.sighup; + Sys.sigill; Sys.sigpipe; Sys.sigquit; + (* Sys.sigsegv; Sys.sigterm;*) Sys.sigusr2] + +let crash_save i = +(* ignore (Unix.sigprocmask Unix.SIG_BLOCK signals_to_crash);*) + Pervasives.prerr_endline "Trying to save all buffers in .crashcoqide files"; + let count = ref 0 in + Vector.iter + (function {view=view; analyzed_view = Some av } -> + (let filename = match av#filename with + | None -> + incr count; + "Unnamed_coqscript_"^(string_of_int !count)^".crashcoqide" + | Some f -> f^".crashcoqide" + in + try + if try_export filename (view#buffer#get_text ()) then + Pervasives.prerr_endline ("Saved "^filename) + else Pervasives.prerr_endline ("Could not save "^filename) + with _ -> Pervasives.prerr_endline ("Could not save "^filename)) + | _ -> Pervasives.prerr_endline "Unanalyzed view found. Please report." + ) + input_views; + Pervasives.prerr_endline "Done. Please report."; + if i <> 127 then exit i + +let ignore_break () = + List.iter + (fun i -> + try Sys.set_signal i (Sys.Signal_handle crash_save) + with _ -> prerr_endline "Signal ignored (normal if Win32)") + signals_to_crash; + Sys.set_signal Sys.sigint Sys.Signal_ignore + +(* Locking machinery for Coq kernel *) +let coq_computing = Mutex.create () + +(* To prevent Coq from interrupting during undoing...*) +let coq_may_stop = Mutex.create () + +let break () = + prerr_endline "User break received:"; + if not (Mutex.try_lock coq_computing) then + begin + prerr_endline " trying to stop computation:"; + if Mutex.try_lock coq_may_stop then begin + Util.interrupt := true; + prerr_endline " interrupt flag set. Computation should stop soon..."; + Mutex.unlock coq_may_stop + end else prerr_endline " interruption refused (may not stop now)"; + end + else begin + Mutex.unlock coq_computing; + prerr_endline " ignored (not computing)" + end + +let full_do_if_not_computing text f x = + ignore + (Thread.create + (async + (fun () -> + if Mutex.try_lock coq_computing + then + begin + prerr_endline ("Launching thread " ^ text); + let w = Blaster_window.blaster_window () in + if not (Mutex.try_lock w#lock) then begin + break (); + let lck = Mutex.create () in + Mutex.lock lck; + prerr_endline "Waiting on blaster..."; + Condition.wait w#blaster_killed lck; + prerr_endline "Waiting on blaster ok"; + Mutex.unlock lck + end else Mutex.unlock w#lock; + let idle = + Glib.Timeout.add ~ms:300 + ~callback:(fun () -> !pulse ();true) in + begin + prerr_endline "Getting lock"; + try + f x; + Glib.Timeout.remove idle; + prerr_endline "Releasing lock"; + Mutex.unlock coq_computing; + with e -> + Glib.Timeout.remove idle; + prerr_endline "Releasing lock (on error)"; + Mutex.unlock coq_computing; + raise e + end + end + else + prerr_endline + "Discarded order (computations are ongoing)")) + ()) + +let do_if_not_computing text f x = + ignore (full_do_if_not_computing text f x) + + +let add_input_view tv = + Vector.append input_views tv + +let get_input_view i = + if 0 <= i && i < Vector.length input_views + then + Vector.get input_views i + else raise Not_found + +let active_view = ref None + +let get_active_view () = Vector.get input_views (out_some !active_view) + +let set_active_view i = + (match !active_view with None -> () | Some i -> + reset_tab_label i); + (notebook ())#goto_page i; + let txt = get_current_tab_label () in + set_current_tab_label (""^txt^""); + active_view := Some i + +let set_current_view i = (notebook ())#goto_page i + +let kill_input_view i = + let v = Vector.get input_views i in + (match v.analyzed_view with + | Some v -> v#kill_detached_views () + | None -> ()); + v.view#destroy (); + v.analyzed_view <- None; + Vector.remove input_views i + +let get_current_view_page () = (notebook ())#current_page +let get_current_view () = Vector.get input_views (notebook ())#current_page +let remove_current_view_page () = + let c = (notebook ())#current_page in + kill_input_view c; + ((notebook ())#get_nth_page c)#misc#hide () + + +let is_word_char c = + Glib.Unichar.isalnum c || c = underscore || c = prime || c = arobase + +let starts_word it = + prerr_endline ("Starts word ? '"^(Glib.Utf8.from_unichar it#char)^"'"); + (not it#copy#nocopy#backward_char || + (let c = it#backward_char#char in + not (is_word_char c))) + +let ends_word it = + (not it#copy#nocopy#forward_char || + let c = it#forward_char#char in + not (Glib.Unichar.isalnum c || c = underscore || c = prime || c = arobase) + ) + +let inside_word it = + let c = it#char in + not (starts_word it) && + not (ends_word it) && + (Glib.Unichar.isalnum c || c = underscore || c = prime || c = arobase) + +let is_on_word_limit it = inside_word it || ends_word it + +let rec find_word_start it = + prerr_endline "Find word start"; + if not it#nocopy#backward_char then + (prerr_endline "find_word_start: cannot backward"; it) + else if is_word_char it#char + then find_word_start it + else (it#nocopy#forward_char; + prerr_endline ("Word start at: "^(string_of_int it#offset));it) +let find_word_start (it:GText.iter) = find_word_start it#copy + +let rec find_word_end it = + prerr_endline "Find word end"; + if let c = it#char in c<>0 && is_word_char c + then begin + ignore (it#nocopy#forward_char); + find_word_end it + end else (prerr_endline ("Word end at: "^(string_of_int it#offset));it) +let find_word_end it = find_word_end it#copy + + +let get_word_around it = + let start = find_word_start it in + let stop = find_word_end it in + start,stop + + +let rec complete_backward w (it:GText.iter) = + prerr_endline "Complete backward..."; + match it#backward_search w with + | None -> (prerr_endline "backward_search failed";None) + | Some (start,stop) -> + prerr_endline ("complete_backward got a match:"^(string_of_int start#offset)^(string_of_int stop#offset)); + if starts_word start then + let ne = find_word_end stop in + if ne#compare stop = 0 + then complete_backward w start + else Some (start,stop,ne) + else complete_backward w start + +let rec complete_forward w (it:GText.iter) = + prerr_endline "Complete forward..."; + match it#forward_search w with + | None -> None + | Some (start,stop) -> + if starts_word start then + let ne = find_word_end stop in + if ne#compare stop = 0 then + complete_forward w stop + else Some (stop,stop,ne) + else complete_forward w stop + +(* Reset this to None on page change ! *) +let (last_completion:(string*int*int*bool) option ref) = ref None + +let () = to_do_on_page_switch := + (fun i -> last_completion := None)::!to_do_on_page_switch + +let rec complete input_buffer w (offset:int) = + match !last_completion with + | Some (lw,loffset,lpos,backward) + when lw=w && loffset=offset -> + begin + let iter = input_buffer#get_iter (`OFFSET lpos) in + if backward then + match complete_backward w iter with + | None -> + last_completion := + Some (lw,loffset, + (find_word_end + (input_buffer#get_iter (`OFFSET loffset)))#offset , + false); + None + | Some (ss,start,stop) as result -> + last_completion := + Some (w,offset,ss#offset,true); + result + else + match complete_forward w iter with + | None -> + last_completion := None; + None + | Some (ss,start,stop) as result -> + last_completion := + Some (w,offset,ss#offset,false); + result + end + | _ -> begin + match complete_backward w (input_buffer#get_iter (`OFFSET offset)) with + | None -> + last_completion := + Some (w,offset,(find_word_end (input_buffer#get_iter + (`OFFSET offset)))#offset,false); + complete input_buffer w offset + | Some (ss,start,stop) as result -> + last_completion := Some (w,offset,ss#offset,true); + result + end + +let get_current_word () = + let av = out_some ((get_current_view ()).analyzed_view) in + match GtkBase.Clipboard.wait_for_text (cb ())#as_clipboard with + | None -> + prerr_endline "None selected"; + let it = av#get_insert in + let start = find_word_start it in + let stop = find_word_end start in + av#view#buffer#move_mark `SEL_BOUND start; + av#view#buffer#move_mark `INSERT stop; + av#view#buffer#get_text ~slice:true ~start ~stop () + | Some t -> + prerr_endline "Some selected"; + prerr_endline t; + t + + +let input_channel b ic = + let buf = String.create 1024 and len = ref 0 in + while len := input ic buf 0 1024; !len > 0 do + Buffer.add_substring b buf 0 !len + done + +let with_file name ~f = + let ic = open_in_gen [Open_rdonly;Open_creat] 0o644 name in + try f ic; close_in ic with exn -> + close_in ic; !flash_info ("Error: "^Printexc.to_string exn) + +type info = {start:GText.mark; + stop:GText.mark; + ast:Util.loc * Vernacexpr.vernac_expr; + reset_info:Coq.reset_info; + } + +exception Size of int +let (processed_stack:info Stack.t) = Stack.create () +let push x = Stack.push x processed_stack +let pop () = try Stack.pop processed_stack with Stack.Empty -> raise (Size 0) +let top () = try Stack.top processed_stack with Stack.Empty -> raise (Size 0) +let is_empty () = Stack.is_empty processed_stack + + +(* push a new Coq phrase *) + +let update_on_end_of_proof id = + let lookup_lemma = function + | { ast = _, ( VernacDefinition (_, _, ProveBody _, _) + | VernacDeclareTacticDefinition _ + | VernacStartTheoremProof _) ; + reset_info = Reset (_, r) } -> + if not !r then begin + prerr_endline "Toggling Reset info to true"; + r := true; raise Exit end + else begin + prerr_endline "Toggling Changing Reset id"; + r := false + end + | { ast = _, (VernacAbort _ | VernacAbortAll | VernacGoal _) } -> raise Exit + | _ -> () + in + try Stack.iter lookup_lemma processed_stack with Exit -> () + +let update_on_end_of_segment id = + let lookup_section = function + | { ast = _, ( VernacBeginSection id' + | VernacDefineModule (id',_,_,None) + | VernacDeclareModule (id',_,_,None) + | VernacDeclareModuleType (id',_,None)); + reset_info = Reset (_, r) } + when id = id' -> raise Exit + | { reset_info = Reset (_, r) } -> r := false + | _ -> () + in + try Stack.iter lookup_section processed_stack with Exit -> () + +let push_phrase start_of_phrase_mark end_of_phrase_mark ast = + let x = {start = start_of_phrase_mark; + stop = end_of_phrase_mark; + ast = ast; + reset_info = Coq.compute_reset_info (snd ast) + } + in + push x; + match snd ast with + | VernacEndProof (Proved (_, None)) -> update_on_end_of_proof () + | VernacEndSegment id -> update_on_end_of_segment id + | _ -> () + +let repush_phrase x = + let x = { x with reset_info = Coq.compute_reset_info (snd x.ast) } in + push x; + match snd x.ast with + | VernacEndProof (Proved (_, None)) -> update_on_end_of_proof () + | VernacEndSegment id -> update_on_end_of_segment id + | _ -> () + +(* For electric handlers *) +exception Found + +(* For find_phrase_starting_at *) +exception Stop of int + +let activate_input i = + (match !active_view with + | None -> () + | Some n -> + let a_v = out_some (Vector.get input_views n).analyzed_view in + a_v#deactivate (); + a_v#reset_initial + ); + let activate_function = (out_some (Vector.get input_views i).analyzed_view)#activate in + activate_function (); + set_active_view i + +let warning msg = + GToolbox.message_box ~title:"Warning" + ~icon:(let img = GMisc.image () in + img#set_stock `DIALOG_WARNING; + img#set_icon_size `DIALOG; + img#coerce) + msg + + +class analyzed_view index = + let {view = input_view_} as current_all_ = get_input_view index in + let proof_view_ = out_some !proof_view in + let message_view_ = out_some !message_view in +object(self) + val current_all = current_all_ + val input_view = current_all_.view + val proof_view = out_some !proof_view + val message_view = out_some !message_view + val input_buffer = input_view_#buffer + val proof_buffer = proof_view_#buffer + val message_buffer = message_view_#buffer + val mutable is_active = false + val mutable read_only = false + val mutable filename = None + val mutable stats = None + val mutable last_modification_time = 0. + val mutable last_auto_save_time = 0. + val mutable detached_views = [] + + val mutable auto_complete_on = !current.auto_complete + + method private toggle_auto_complete = + auto_complete_on <- not auto_complete_on + method set_auto_complete t = auto_complete_on <- t + method without_auto_complete : 'a 'b. ('a -> 'b) -> 'a -> 'b = fun f x -> + let old = auto_complete_on in + self#set_auto_complete false; + let y = f x in + self#set_auto_complete old; + y + method add_detached_view (w:GWindow.window) = + detached_views <- w::detached_views + method remove_detached_view (w:GWindow.window) = + detached_views <- List.filter (fun e -> w#misc#get_oid<>e#misc#get_oid) detached_views + + method kill_detached_views () = + List.iter (fun w -> w#destroy ()) detached_views; + detached_views <- [] + + method view = input_view + method filename = filename + method stats = stats + method set_filename f = + filename <- f; + match f with + | Some f -> stats <- my_stat f + | None -> () + + method update_stats = + match filename with + | Some f -> stats <- my_stat f + | _ -> () + + method revert = + match filename with + | Some f -> begin + let do_revert () = begin + !push_info "Reverting buffer"; + try + if is_active then self#reset_initial; + let b = Buffer.create 1024 in + with_file f ~f:(input_channel b); + let s = try_convert (Buffer.contents b) in + input_buffer#set_text s; + self#update_stats; + input_buffer#place_cursor input_buffer#start_iter; + input_buffer#set_modified false; + !pop_info (); + !flash_info "Buffer reverted"; + Highlight.highlight_all input_buffer; + with _ -> + !pop_info (); + !flash_info "Warning: could not revert buffer"; + end + in + if input_buffer#modified then + match (GToolbox.question_box + ~title:"Modified buffer changed on disk" + ~buttons:["Revert from File"; + "Overwrite File"; + "Disable Auto Revert"] + ~default:0 + ~icon:(stock_to_widget `DIALOG_WARNING) + "Some unsaved buffers changed on disk" + ) + with 1 -> do_revert () + | 2 -> if self#save f then !flash_info "Overwritten" else + !flash_info "Could not overwrite file" + | _ -> + prerr_endline "Auto revert set to false"; + !current.global_auto_revert <- false; + disconnect_revert_timer () + else do_revert () + end + | None -> () + + method save f = + if try_export f (input_buffer#get_text ()) then begin + filename <- Some f; + input_buffer#set_modified false; + stats <- my_stat f; + (match self#auto_save_name with + | None -> () + | Some fn -> try Sys.remove fn with _ -> ()); + true + end + else false + + method private auto_save_name = + match filename with + | None -> None + | Some f -> + let dir = Filename.dirname f in + let base = (fst !current.auto_save_name) ^ + (Filename.basename f) ^ + (snd !current.auto_save_name) + in Some (Filename.concat dir base) + + method private need_auto_save = + input_buffer#modified && + last_modification_time > last_auto_save_time + + method auto_save = + if self#need_auto_save then begin + match self#auto_save_name with + | None -> () + | Some fn -> + try + last_auto_save_time <- Unix.time(); + prerr_endline ("Autosave time : "^(string_of_float (Unix.time()))); + if try_export fn (input_buffer#get_text ()) then begin + !flash_info ~delay:1000 "Autosaved" + end + else warning + ("Autosave failed (check if " ^ fn ^ " is writable)") + with _ -> + warning ("Autosave: unexpected error while writing "^fn) + end + + method save_as f = + if Sys.file_exists f then + match (GToolbox.question_box ~title:"File exists on disk" + ~buttons:["Overwrite"; + "Cancel";] + ~default:1 + ~icon: + (let img = GMisc.image () in + img#set_stock `DIALOG_WARNING; + img#set_icon_size `DIALOG; + img#coerce) + ("File "^f^"already exists") + ) + with 1 -> self#save f + | _ -> false + else self#save f + + method set_read_only b = read_only<-b + method read_only = read_only + method is_active = is_active + method insert_message s = + message_buffer#insert s; + message_view#misc#draw None + + method set_message s = + message_buffer#set_text s; + message_view#misc#draw None + + method clear_message = message_buffer#set_text "" + val mutable last_index = true + val last_array = [|"";""|] + method get_start_of_input = input_buffer#get_iter_at_mark (`NAME "start_of_input") + + method get_insert = get_insert input_buffer + + method recenter_insert = + (* BUG : to investigate further: + FIXED : Never call GMain.* in thread ! + PLUS : GTK BUG ??? Cannot be called from a thread... + ADDITION: using sync instead of async causes deadlock...*) + ignore (GtkThread.async ( + input_view#scroll_to_mark + ~use_align:false + ~yalign:0.75 + ~within_margin:0.25) + `INSERT) + + + method indent_current_line = + let get_nb_space it = + let it = it#copy in + let nb_sep = ref 0 in + let continue = ref true in + while !continue do + if it#char = space then begin + incr nb_sep; + if not it#nocopy#forward_char then continue := false; + end else continue := false + done; + !nb_sep + in + let previous_line = self#get_insert in + if previous_line#nocopy#backward_line then begin + let previous_line_spaces = get_nb_space previous_line in + let current_line_start = self#get_insert#set_line_offset 0 in + let current_line_spaces = get_nb_space current_line_start in + if input_buffer#delete_interactive + ~start:current_line_start + ~stop:(current_line_start#forward_chars current_line_spaces) + () + then + let current_line_start = self#get_insert#set_line_offset 0 in + input_buffer#insert + ~iter:current_line_start + (String.make previous_line_spaces ' ') + end + + + method show_goals = + try + proof_view#buffer#set_text ""; + let s = Coq.get_current_goals () in + match s with + | [] -> proof_buffer#insert (Coq.print_no_goal ()) + | (hyps,concl)::r -> + let goal_nb = List.length s in + proof_buffer#insert (Printf.sprintf "%d subgoal%s\n" + goal_nb + (if goal_nb<=1 then "" else "s")); + List.iter + (fun ((_,_,_,(s,_)) as hyp) -> + proof_buffer#insert (s^"\n")) + hyps; + proof_buffer#insert (String.make 38 '_' ^ "(1/"^ + (string_of_int goal_nb)^ + ")\n") + ; + let _,_,_,sconcl = concl in + proof_buffer#insert sconcl; + proof_buffer#insert "\n"; + let my_mark = `NAME "end_of_conclusion" in + proof_buffer#move_mark + ~where:((proof_buffer#get_iter_at_mark `INSERT)) my_mark; + proof_buffer#insert "\n\n"; + let i = ref 1 in + List.iter + (function (_,(_,_,_,concl)) -> + incr i; + proof_buffer#insert (String.make 38 '_' ^"("^ + (string_of_int !i)^ + "/"^ + (string_of_int goal_nb)^ + ")\n"); + proof_buffer#insert concl; + proof_buffer#insert "\n\n"; + ) + r; + ignore (proof_view#scroll_to_mark my_mark) + with e -> prerr_endline ("Don't worry be happy despite: "^Printexc.to_string e) + + + val mutable full_goal_done = true + + method show_goals_full = + if not full_goal_done then + begin + try + proof_view#buffer#set_text ""; + let s = Coq.get_current_goals () in + let last_shown_area = proof_buffer#create_tag [`BACKGROUND "light green"] + in + match s with + | [] -> proof_buffer#insert (Coq.print_no_goal ()) + | (hyps,concl)::r -> + let goal_nb = List.length s in + proof_buffer#insert (Printf.sprintf "%d subgoal%s\n" + goal_nb + (if goal_nb<=1 then "" else "s")); + let coq_menu commands = + let tag = proof_buffer#create_tag [] + in + ignore + (tag#connect#event ~callback: + (fun ~origin ev it -> + begin match GdkEvent.get_type ev with + | `BUTTON_PRESS -> + let ev = (GdkEvent.Button.cast ev) in + if (GdkEvent.Button.button ev) = 3 + then begin + let loc_menu = GMenu.menu () in + let factory = new GMenu.factory loc_menu in + let add_coq_command (cp,ip) = + ignore + (factory#add_item cp + ~callback: + (fun () -> ignore + (self#insert_this_phrase_on_success + true + true + false + ("progress "^ip^"\n") + (ip^"\n")) + ) + ) + in + List.iter add_coq_command commands; + loc_menu#popup + ~button:3 + ~time:(GdkEvent.Button.time ev); + end + | `MOTION_NOTIFY -> + proof_buffer#remove_tag + ~start:proof_buffer#start_iter + ~stop:proof_buffer#end_iter + last_shown_area; + prerr_endline "Before find_tag_limits"; + + let s,e = find_tag_limits tag + (new GText.iter it) + in + prerr_endline "After find_tag_limits"; + proof_buffer#apply_tag + ~start:s + ~stop:e + last_shown_area; + + prerr_endline "Applied tag"; + () + | _ -> () + end;false + ) + ); + tag + in + List.iter + (fun ((_,_,_,(s,_)) as hyp) -> + let tag = coq_menu (hyp_menu hyp) in + proof_buffer#insert ~tags:[tag] (s^"\n")) + hyps; + proof_buffer#insert + (String.make 38 '_' ^"(1/"^ + (string_of_int goal_nb)^ + ")\n") + ; + let tag = coq_menu (concl_menu concl) in + let _,_,_,sconcl = concl in + proof_buffer#insert ~tags:[tag] sconcl; + proof_buffer#insert "\n"; + let my_mark = `NAME "end_of_conclusion" in + proof_buffer#move_mark + ~where:((proof_buffer#get_iter_at_mark `INSERT)) my_mark; + proof_buffer#insert "\n\n"; + let i = ref 1 in + List.iter + (function (_,(_,_,_,concl)) -> + incr i; + proof_buffer#insert + (String.make 38 '_' ^"("^ + (string_of_int !i)^ + "/"^ + (string_of_int goal_nb)^ + ")\n"); + proof_buffer#insert concl; + proof_buffer#insert "\n\n"; + ) + r; + ignore (proof_view#scroll_to_mark my_mark) ; + full_goal_done <- true; + with e -> prerr_endline (Printexc.to_string e) + end + + method send_to_coq verbosely replace phrase show_output show_error localize = + try + full_goal_done <- false; + prerr_endline "Send_to_coq starting now"; + if replace then begin + let r,info = +(* full_do_if_not_computing "coq eval and replace" *) + Coq.interp_and_replace ("Info " ^ phrase) + in + let msg = read_stdout () in + self#insert_message (if show_output then msg else ""); + + Some r + + end else begin + let r = Some (Coq.interp verbosely phrase) in + let msg = read_stdout () in + self#insert_message (if show_output then msg else ""); + r + end + with e -> + (if show_error then + let (s,loc) = Coq.process_exn e in + assert (Glib.Utf8.validate s); + self#set_message s; + message_view#misc#draw None; + if localize then + (match Util.option_app Util.unloc loc with + | None -> () + | Some (start,stop) -> + let convert_pos = byte_offset_to_char_offset phrase in + let start = convert_pos start in + let stop = convert_pos stop in + let i = self#get_start_of_input in + let starti = i#forward_chars start in + let stopi = i#forward_chars stop in + input_buffer#apply_tag_by_name "error" + ~start:starti + ~stop:stopi; + input_buffer#place_cursor starti; + )); + None + + method find_phrase_starting_at (start:GText.iter) = + prerr_endline "find_phrase_starting_at starting now"; + let trash_bytes = ref "" in + let end_iter = start#copy in + let lexbuf_function s count = + let i = ref 0 in + let n_trash = String.length !trash_bytes in + String.blit !trash_bytes 0 s 0 n_trash; + i := n_trash; + try + while !i <= count - 1 do + let c = end_iter#char in + if c = 0 then raise (Stop !i); + let c' = Glib.Utf8.from_unichar c in + let n = String.length c' in + if (n<=0) then exit (-2); + if n > count - !i then + begin + let ri = count - !i in + String.blit c' 0 s !i ri; + trash_bytes := String.sub c' ri (n-ri); + i := count ; + end else begin + String.blit c' 0 s !i n; + i:= !i + n + end; + if not end_iter#nocopy#forward_char then + raise (Stop !i) + done; + count + with Stop x -> + x + in + try + trash_bytes := ""; + let phrase = Find_phrase.get (Lexing.from_function lexbuf_function) + in + end_iter#nocopy#set_offset (start#offset + !Find_phrase.length); + Some (start,end_iter) + with + | Find_phrase.EOF s -> + (* Phrase is at the end of the buffer*) + let si = start#offset in + let ei = si + !Find_phrase.length in + end_iter#nocopy#set_offset (ei - 1); + input_buffer#insert ~iter:end_iter "\n"; + Some (input_buffer#get_iter (`OFFSET si), + input_buffer#get_iter (`OFFSET ei)) + | _ -> None + + method complete_at_offset (offset:int) = + prerr_endline ("Completion at offset : " ^ string_of_int offset); + let it () = input_buffer#get_iter (`OFFSET offset) in + let iit = it () in + let start = find_word_start iit in + if ends_word iit then + let w = input_buffer#get_text + ~start + ~stop:iit + () + in + if String.length w <> 0 then begin + prerr_endline ("Completion of prefix : '" ^ w^"'"); + match complete input_buffer w start#offset with + | None -> false + | Some (ss,start,stop) -> + let completion = input_buffer#get_text ~start ~stop () in + ignore (input_buffer#delete_selection ()); + ignore (input_buffer#insert_interactive completion); + input_buffer#move_mark `SEL_BOUND (it())#backward_char; + true + end else false + else false + + + method process_next_phrase verbosely display_goals do_highlight = + begin + try + self#clear_message; + prerr_endline "process_next_phrase starting now"; + if do_highlight then begin + !push_info "Coq is computing"; + input_view#set_editable false; + end; + begin match (self#find_phrase_starting_at self#get_start_of_input) + with + | None -> + if do_highlight then begin + input_view#set_editable true; + !pop_info (); + end; false + | Some(start,stop) -> + prerr_endline "process_next_phrase : to_process highlight"; + let b = input_buffer in + if do_highlight then begin + input_buffer#apply_tag_by_name ~start ~stop "to_process"; + prerr_endline "process_next_phrase : to_process applied"; + end; + prerr_endline "process_next_phrase : getting phrase"; + let phrase = start#get_slice ~stop in + let r = + match self#send_to_coq verbosely false phrase true true true with + | Some ast -> + begin + b#move_mark ~where:stop (`NAME "start_of_input"); + b#apply_tag_by_name "processed" ~start ~stop; + if (self#get_insert#compare) stop <= 0 then + begin + b#place_cursor stop; + self#recenter_insert + end; + let start_of_phrase_mark = `MARK (b#create_mark start) in + let end_of_phrase_mark = `MARK (b#create_mark stop) in + push_phrase + start_of_phrase_mark + end_of_phrase_mark ast; + if display_goals then self#show_goals; + true + end + | None -> false + in + if do_highlight then begin + b#remove_tag_by_name ~start ~stop "to_process" ; + input_view#set_editable true; + !pop_info (); + end; + r; + end + with e -> raise e + end + + method insert_this_phrase_on_success + show_output show_msg localize coqphrase insertphrase = + match self#send_to_coq false false coqphrase show_output show_msg localize with + | Some ast -> + begin + let stop = self#get_start_of_input in + if stop#starts_line then + input_buffer#insert ~iter:stop insertphrase + else input_buffer#insert ~iter:stop ("\n"^insertphrase); + let start = self#get_start_of_input in + input_buffer#move_mark ~where:stop (`NAME "start_of_input"); + input_buffer#apply_tag_by_name "processed" ~start ~stop; + if (self#get_insert#compare) stop <= 0 then + input_buffer#place_cursor stop; + let start_of_phrase_mark = `MARK (input_buffer#create_mark start) + in + let end_of_phrase_mark = `MARK (input_buffer#create_mark stop) in + push_phrase start_of_phrase_mark end_of_phrase_mark ast; + self#show_goals; + (*Auto insert save on success... + try (match Coq.get_current_goals () with + | [] -> + (match self#send_to_coq "Save.\n" true true true with + | Some ast -> + begin + let stop = self#get_start_of_input in + if stop#starts_line then + input_buffer#insert ~iter:stop "Save.\n" + else input_buffer#insert ~iter:stop "\nSave.\n"; + let start = self#get_start_of_input in + input_buffer#move_mark ~where:stop (`NAME "start_of_input"); + input_buffer#apply_tag_by_name "processed" ~start ~stop; + if (self#get_insert#compare) stop <= 0 then + input_buffer#place_cursor stop; + let start_of_phrase_mark = `MARK (input_buffer#create_mark start) + in + let end_of_phrase_mark = `MARK (input_buffer#create_mark stop) in + push_phrase start_of_phrase_mark end_of_phrase_mark ast + end + | None -> ()) + | _ -> ()) + with _ -> ()*) + true + end + | None -> self#insert_message ("Unsuccessfully tried: "^coqphrase); + false + + method process_until_iter_or_error stop = + let stop' = `OFFSET stop#offset in + let start = self#get_start_of_input#copy in + let start' = `OFFSET start#offset in + input_buffer#apply_tag_by_name + ~start + ~stop + "to_process"; + input_view#set_editable false; + !push_info "Coq is computing"; + process_pending (); + (try + while ((stop#compare self#get_start_of_input>=0) + && (self#process_next_phrase false false false)) + do Util.check_for_interrupt () done + with Sys.Break -> + prerr_endline "Interrupted during process_until_iter_or_error"); + self#show_goals; + (* Start and stop might be invalid if an eol was added at eof *) + let start = input_buffer#get_iter start' in + let stop = input_buffer#get_iter stop' in + input_buffer#remove_tag_by_name ~start ~stop "to_process" ; + input_view#set_editable true; + !pop_info() + + method process_until_end_or_error = + self#process_until_iter_or_error input_buffer#end_iter + + method reset_initial = + Stack.iter + (function inf -> + let start = input_buffer#get_iter_at_mark inf.start in + let stop = input_buffer#get_iter_at_mark inf.stop in + input_buffer#move_mark ~where:start (`NAME "start_of_input"); + input_buffer#remove_tag_by_name "processed" ~start ~stop; + input_buffer#delete_mark inf.start; + input_buffer#delete_mark inf.stop; + ) + processed_stack; + Stack.clear processed_stack; + self#clear_message; + Coq.reset_initial () + + + (* backtrack Coq to the phrase preceding iterator [i] *) + method backtrack_to_no_lock i = + prerr_endline "Backtracking_to iter starts now."; + (* re-synchronize Coq to the current state of the stack *) + let rec synchro () = + if is_empty () then + Coq.reset_initial () + else begin + let t = pop () in + begin match t.reset_info with + | Reset (id, ({contents=true} as v)) -> v:=false; + (match snd t.ast with + | VernacBeginSection _ | VernacDefineModule _ + | VernacDeclareModule _ | VernacDeclareModuleType _ + | VernacEndSegment _ + -> reset_to_mod id + | _ -> reset_to id) + | _ -> synchro () + end; + interp_last t.ast; + repush_phrase t + end + in + let add_undo t = match t with | Some n -> Some (succ n) | None -> None + in + (* pop Coq commands until we reach iterator [i] *) + let rec pop_commands done_smthg undos = + if is_empty () then + done_smthg, undos + else + let t = top () in + if i#compare (input_buffer#get_iter_at_mark t.stop) < 0 then begin + ignore (pop ()); + let undos = if is_tactic (snd t.ast) then add_undo undos else None in + pop_commands true undos + end else + done_smthg, undos + in + let done_smthg, undos = pop_commands false (Some 0) in + prerr_endline "Popped commands"; + if done_smthg then + begin + try + (match undos with + | None -> synchro () + | Some n -> try Pfedit.undo n with _ -> synchro ()); + let start = if is_empty () then input_buffer#start_iter + else input_buffer#get_iter_at_mark (top ()).stop + in + prerr_endline "Removing (long) processed tag..."; + input_buffer#remove_tag_by_name + ~start + ~stop:self#get_start_of_input + "processed"; + prerr_endline "Moving (long) start_of_input..."; + input_buffer#move_mark ~where:start (`NAME "start_of_input"); + self#show_goals; + clear_stdout (); + self#clear_message; + with _ -> + !push_info "WARNING: undo failed badly -> Coq might be in an inconsistent state. +Please restart and report NOW."; + end + else prerr_endline "backtrack_to : discarded (...)" + + method backtrack_to i = + if Mutex.try_lock coq_may_stop then + (!push_info "Undoing...";self#backtrack_to_no_lock i ; Mutex.unlock coq_may_stop; + !pop_info ()) + else prerr_endline "backtrack_to : discarded (lock is busy)" + + method go_to_insert = + let point = self#get_insert in + if point#compare self#get_start_of_input>=0 + then self#process_until_iter_or_error point + else self#backtrack_to point + + method undo_last_step = + if Mutex.try_lock coq_may_stop then + (!push_info "Undoing last step..."; + (try + let last_command = top () in + let start = input_buffer#get_iter_at_mark last_command.start in + let update_input () = + prerr_endline "Removing processed tag..."; + input_buffer#remove_tag_by_name + ~start + ~stop:(input_buffer#get_iter_at_mark last_command.stop) + "processed"; + prerr_endline "Moving start_of_input"; + input_buffer#move_mark + ~where:start + (`NAME "start_of_input"); + input_buffer#place_cursor start; + self#recenter_insert; + self#show_goals; + self#clear_message + in + begin match last_command with + | {ast=_, (VernacSolve _ | VernacTime (VernacSolve _))} -> + begin + try Pfedit.undo 1; ignore (pop ()); update_input () + with _ -> self#backtrack_to_no_lock start + end + | {ast=_,t;reset_info=Reset (id, {contents=true})} -> + ignore (pop ()); + (match t with + | VernacBeginSection _ | VernacDefineModule _ + | VernacDeclareModule _ | VernacDeclareModuleType _ + | VernacEndSegment _ + -> reset_to_mod id + | _ -> reset_to id); + update_input () + | { ast = _, ( VernacStartTheoremProof _ + | VernacGoal _ + | VernacDeclareTacticDefinition _ + | VernacDefinition (_,_,ProveBody _,_)); + reset_info=Reset(id,{contents=false})} -> + ignore (pop ()); + (try + Pfedit.delete_current_proof () + with e -> + begin + prerr_endline "WARNING : found a closed environment"; + raise e + end); + update_input () + | { ast = (_, a) } when is_state_preserving a -> + ignore (pop ()); + update_input () + | _ -> + self#backtrack_to_no_lock start + end; + with + | Size 0 -> (* !flash_info "Nothing to Undo"*)() + ); + !pop_info (); + Mutex.unlock coq_may_stop) + else prerr_endline "undo_last_step discarded" + + + method blaster () = + + ignore (Thread.create + (fun () -> + prerr_endline "Blaster called"; + let c = Blaster_window.present_blaster_window () in + if Mutex.try_lock c#lock then begin + c#clear (); + let current_gls = try get_current_goals () with _ -> [] in + let gls_nb = List.length current_gls in + + let set_goal i (s,t) = + let gnb = string_of_int i in + let s = gnb ^":"^s in + let t' = gnb ^": progress "^t in + let t'' = gnb ^": "^t in + c#set + ("Goal "^gnb) + s + (fun () -> try_interptac t') + (fun () -> self#insert_command t'' t'') + in + let set_current_goal (s,t) = + c#set + "Goal 1" + s + (fun () -> try_interptac ("progress "^t)) + (fun () -> self#insert_command t t) + in + begin match current_gls with + | [] -> () + | (hyp_l,current_gl)::r -> + List.iter set_current_goal (concl_menu current_gl); + List.iter + (fun hyp -> + List.iter set_current_goal (hyp_menu hyp)) + hyp_l; + let i = ref 2 in + List.iter + (fun (hyp_l,gl) -> + List.iter (set_goal !i) (concl_menu gl); + incr i) + r + end; + let _ = c#blaster () in + Mutex.unlock c#lock + end else prerr_endline "Blaster discarded") + ()) + + method insert_command cp ip = + self#clear_message; + ignore (self#insert_this_phrase_on_success true false false cp ip) + + method tactic_wizard l = + self#clear_message; + ignore + (List.exists + (fun p -> + self#insert_this_phrase_on_success true false false + ("progress "^p^".\n") (p^".\n")) l) + + method active_keypress_handler k = + let state = GdkEvent.Key.state k in + begin + match state with + | l when List.mem `MOD1 l -> + let k = GdkEvent.Key.keyval k in + if GdkKeysyms._Return=k + then ignore( + if (input_buffer#insert_interactive "\n") then + begin + let i= self#get_insert#backward_word_start in + prerr_endline "active_kp_hf: Placing cursor"; + self#process_until_iter_or_error i + end); + true + | l when List.mem `CONTROL l -> + let k = GdkEvent.Key.keyval k in + if GdkKeysyms._Break=k + then break (); + false + | l -> + if GdkEvent.Key.keyval k = GdkKeysyms._Tab then begin + prerr_endline "active_kp_handler for Tab"; + self#indent_current_line; + true + end else false + end + method disconnected_keypress_handler k = + match GdkEvent.Key.state k with + | l when List.mem `CONTROL l -> + let k = GdkEvent.Key.keyval k in + if GdkKeysyms._c=k + then break (); + false + | l -> false + + + val mutable deact_id = None + val mutable act_id = None + + method deactivate () = + is_active <- false; + (match act_id with None -> () + | Some id -> + reset_initial (); + input_view#misc#disconnect id; + prerr_endline "DISCONNECTED old active : "; + print_id id; + ); + deact_id <- Some + (input_view#event#connect#key_press self#disconnected_keypress_handler); + prerr_endline "CONNECTED inactive : "; + print_id (out_some deact_id) + + method activate () = + is_active <- true; + (match deact_id with None -> () + | Some id -> input_view#misc#disconnect id; + prerr_endline "DISCONNECTED old inactive : "; + print_id id + ); + act_id <- Some + (input_view#event#connect#key_press self#active_keypress_handler); + prerr_endline "CONNECTED active : "; + print_id (out_some act_id); + let dir = (match + (out_some ((Vector.get input_views index).analyzed_view)) + #filename + with + | None -> () + | Some f -> + if not (is_in_coq_path f) then + begin + let dir = Filename.dirname f in + ignore (Coq.interp false + (Printf.sprintf "Add LoadPath \"%s\". " dir)) + end) + in () + + + + method electric_handler = + input_buffer#connect#insert_text ~callback: + (fun it x -> + begin try + if last_index then begin + last_array.(0)<-x; + if (last_array.(1) ^ last_array.(0) = ".\n") then raise Found + end else begin + last_array.(1)<-x; + if (last_array.(0) ^ last_array.(1) = ".\n") then raise Found + end + with Found -> + begin + ignore (self#process_next_phrase false true true) + end; + end; + last_index <- not last_index;) + + method private electric_paren tag = + let oparen_code = Glib.Utf8.to_unichar "(" (ref 0) in + let cparen_code = Glib.Utf8.to_unichar ")" (ref 0) in + ignore (input_buffer#connect#insert_text ~callback: + (fun it x -> + input_buffer#remove_tag + ~start:input_buffer#start_iter + ~stop:input_buffer#end_iter + tag; + if x = "" then () else + match x.[String.length x - 1] with + | ')' -> + let hit = self#get_insert in + let count = ref 0 in + if hit#nocopy#backward_find_char + (fun c -> + if c = oparen_code && !count = 0 then true + else if c = cparen_code then + (incr count;false) + else if c = oparen_code then + (decr count;false) + else false + ) + then + begin + prerr_endline "Found matching parenthesis"; + input_buffer#apply_tag tag ~start:hit ~stop:hit#forward_char + end + else () + | _ -> ()) + ) + + method help_for_keyword () = + + browse_keyword (self#insert_message) (get_current_word ()) + + initializer + ignore (message_buffer#connect#insert_text + ~callback:(fun it s -> ignore + (message_view#scroll_to_mark + ~use_align:false + ~within_margin:0.49 + `INSERT))); + ignore (input_buffer#connect#insert_text + ~callback:(fun it s -> + if (it#compare self#get_start_of_input)<0 + then GtkSignal.stop_emit (); + if String.length s > 1 then + (prerr_endline "insert_text: Placing cursor";input_buffer#place_cursor it))); + ignore (input_buffer#connect#after#apply_tag + ~callback:(fun tag ~start ~stop -> + if (start#compare self#get_start_of_input)>=0 + then + input_buffer#remove_tag_by_name + ~start + ~stop + "processed" + ) + ); + ignore (input_buffer#connect#after#insert_text + ~callback:(fun it s -> + if auto_complete_on && + String.length s = 1 && s <> " " && s <> "\n" + then + let v = out_some (get_current_view ()).analyzed_view + in + let has_completed = + v#complete_at_offset + ((v#view#buffer#get_iter `SEL_BOUND)#offset) + in + if has_completed then + input_buffer#move_mark `SEL_BOUND (input_buffer#get_iter `SEL_BOUND)#forward_char; + + + ) + ); + ignore (input_buffer#connect#modified_changed + ~callback: + (fun () -> + if input_buffer#modified then + set_tab_image index + ~icon:(match (out_some (current_all.analyzed_view))#filename with + | None -> `SAVE_AS + | Some _ -> `SAVE + ) + else set_tab_image index ~icon:`YES; + )); + ignore (input_buffer#connect#changed + ~callback:(fun () -> + last_modification_time <- Unix.time (); + let r = input_view#visible_rect in + let stop = + input_view#get_iter_at_location + ~x:(Gdk.Rectangle.x r + Gdk.Rectangle.width r) + ~y:(Gdk.Rectangle.y r + Gdk.Rectangle.height r) + in + input_buffer#remove_tag_by_name + ~start:self#get_start_of_input + ~stop + "error"; + Highlight.highlight_around_current_line + input_buffer + ) + ); + ignore (input_buffer#add_selection_clipboard (cb())); + let paren_highlight_tag = input_buffer#create_tag ~name:"paren" [`BACKGROUND "purple"] in + self#electric_paren paren_highlight_tag; + ignore (input_buffer#connect#after#mark_set + ~callback:(fun it (m:Gtk.text_mark) -> + !set_location + (Printf.sprintf + "Line: %5d Char: %3d" (self#get_insert#line + 1) + (self#get_insert#line_offset + 1)); + match GtkText.Mark.get_name m with + | Some "insert" -> + input_buffer#remove_tag + ~start:input_buffer#start_iter + ~stop:input_buffer#end_iter + paren_highlight_tag; + | Some s -> + prerr_endline (s^" moved") + | None -> () ) + ); + ignore (input_buffer#connect#insert_text + (fun it s -> + prerr_endline "Should recenter ?"; + if String.contains s '\n' then begin + prerr_endline "Should recenter : yes"; + self#recenter_insert + end)) +end + +let create_input_tab filename = + let b = GText.buffer () in + let tablabel = GMisc.label () in + let v_box = GPack.hbox ~homogeneous:false () in + let image = GMisc.image ~packing:v_box#pack () in + let label = GMisc.label ~text:filename ~packing:v_box#pack () in + let fr1 = GBin.frame ~shadow_type:`ETCHED_OUT + ~packing:((notebook ())#append_page + ~tab_label:v_box#coerce) () + in + let sw1 = GBin.scrolled_window + ~vpolicy:`AUTOMATIC + ~hpolicy:`AUTOMATIC + ~packing:fr1#add () + in + let tv1 = Undo.undoable_view ~buffer:b ~packing:(sw1#add) () in + prerr_endline ("Language: "^ b#start_iter#language); + tv1#misc#set_name "ScriptWindow"; + let _ = tv1#set_editable true in + let _ = tv1#set_wrap_mode `NONE in + b#place_cursor ~where:(b#start_iter); + ignore (tv1#event#connect#button_press ~callback: + (fun ev -> GdkEvent.Button.button ev = 3)); +(* ignore (tv1#event#connect#button_press ~callback: + (fun ev -> + if (GdkEvent.Button.button ev=2) then + (try + prerr_endline "Paste invoked"; + GtkSignal.emit_unit + (get_current_view()).view#as_view + GtkText.View.Signals.paste_clipboard; + true + with _ -> false) + else false + ));*) + tv1#misc#grab_focus (); + ignore (tv1#buffer#create_mark + ~name:"start_of_input" + tv1#buffer#start_iter); + ignore (tv1#buffer#create_tag + ~name:"kwd" + [`FOREGROUND "blue"]); + ignore (tv1#buffer#create_tag + ~name:"decl" + [`FOREGROUND "orange red"]); + ignore (tv1#buffer#create_tag + ~name:"comment" + [`FOREGROUND "brown"]); + ignore (tv1#buffer#create_tag + ~name:"reserved" + [`FOREGROUND "dark red"]); + ignore (tv1#buffer#create_tag + ~name:"error" + [`UNDERLINE `DOUBLE ; `FOREGROUND "red"]); + ignore (tv1#buffer#create_tag + ~name:"to_process" + [`BACKGROUND "light blue" ;`EDITABLE false]); + ignore (tv1#buffer#create_tag + ~name:"processed" + [`BACKGROUND "light green" ;`EDITABLE false]); + ignore (tv1#buffer#create_tag + ~name:"found" + [`BACKGROUND "blue"; `FOREGROUND "white"]); + tv1 + + +let last_make = ref "";; +let last_make_index = ref 0;; +let search_compile_error_regexp = + Str.regexp + "File \"\\([^\"]+\\)\", line \\([0-9]+\\), characters \\([0-9]+\\)-\\([0-9]+\\)";; + +let search_next_error () = + let _ = Str.search_forward search_compile_error_regexp !last_make !last_make_index in + let f = Str.matched_group 1 !last_make + and l = int_of_string (Str.matched_group 2 !last_make) + and b = int_of_string (Str.matched_group 3 !last_make) + and e = int_of_string (Str.matched_group 4 !last_make) + and msg_index = Str.match_beginning () + in + last_make_index := Str.group_end 4; + (f,l,b,e, + String.sub !last_make msg_index (String.length !last_make - msg_index)) + +let main files = + (* Statup preferences *) + load_pref (); + + (* Main window *) + let w = GWindow.window + ~wm_class:"CoqIde" ~wm_name:"CoqIde" + ~allow_grow:true ~allow_shrink:true + ~width:!current.window_width ~height:!current.window_height + ~title:"CoqIde" () + in +(* + let icon_image = Filename.concat lib_ide "coq.ico" in + let icon = GdkPixbuf.from_file icon_image in + w#set_icon (Some icon); +*) + let vbox = GPack.vbox ~homogeneous:false ~packing:w#add () in + + + (* Menu bar *) + let menubar = GMenu.menu_bar ~packing:vbox#pack () in + + (* Toolbar *) + let toolbar = GButton.toolbar + ~orientation:`HORIZONTAL + ~style:`ICONS + ~tooltips:true + ~packing:(* handle#add *) + (vbox#pack ~expand:false ~fill:false) + () + in + show_toolbar := + (fun b -> if b then toolbar#misc#show () else toolbar#misc#hide ()); + + let factory = new GMenu.factory ~accel_path:"/" menubar in + let accel_group = factory#accel_group in + + (* File Menu *) + let file_menu = factory#add_submenu "_File" in + + let file_factory = new GMenu.factory ~accel_path:"/File/" file_menu ~accel_group in + + (* File/Load Menu *) + let load f = + let f = absolute_filename f in + try + prerr_endline "Loading file starts"; + Vector.find_or_fail + (function + | {analyzed_view=Some av} -> + (match av#filename with + | None -> false + | Some fn -> same_file f fn) + | _ -> false) + !input_views; + prerr_endline "Loading: must open"; + let b = Buffer.create 1024 in + prerr_endline "Loading: get raw content"; + with_file f ~f:(input_channel b); + prerr_endline "Loading: convert content"; + let s = do_convert (Buffer.contents b) in + prerr_endline "Loading: create view"; + let view = create_input_tab (Glib.Convert.filename_to_utf8 + (Filename.basename f)) + in + prerr_endline "Loading: change font"; + view#misc#modify_font !current.text_font; + prerr_endline "Loading: adding view"; + let index = add_input_view {view = view; + analyzed_view = None; + } + in + let av = (new analyzed_view index) in + prerr_endline "Loading: register view"; + (get_input_view index).analyzed_view <- Some av; + prerr_endline "Loading: set filename"; + av#set_filename (Some f); + prerr_endline "Loading: stats"; + av#update_stats; + let input_buffer = view#buffer in + prerr_endline "Loading: fill buffer"; + input_buffer#set_text s; + input_buffer#place_cursor input_buffer#start_iter; + prerr_endline ("Loading: switch to view "^ string_of_int index); + set_current_view index; + set_tab_image index ~icon:`YES; + prerr_endline "Loading: highlight"; + Highlight.highlight_all input_buffer; + input_buffer#set_modified false; + prerr_endline "Loading: clear undo"; + av#view#clear_undo; + prerr_endline "Loading: success" + with + | Vector.Found i -> set_current_view i + | e -> !flash_info ("Load failed: "^(Printexc.to_string e)) + in + let load_m = file_factory#add_item "_Open/Create" + ~key:GdkKeysyms._O in + let load_f () = + match select_file ~title:"Load file" () with + | None -> () + | (Some f) as fn -> load f + in + ignore (load_m#connect#activate (load_f)); + + (* File/Save Menu *) + let save_m = file_factory#add_item "_Save" + ~key:GdkKeysyms._S in + + + let save_f () = + let current = get_current_view () in + try + (match (out_some current.analyzed_view)#filename with + | None -> + begin match GToolbox.select_file ~title:"Save file" () + with + | None -> () + | Some f -> + if (out_some current.analyzed_view)#save_as f then begin + set_current_tab_label (Filename.basename f); + !flash_info ("File " ^ f ^ " saved") + end + else warning ("Save Failed (check if " ^ f ^ " is writable)") + end + | Some f -> + if (out_some current.analyzed_view)#save f then + !flash_info ("File " ^ f ^ " saved") + else warning ("Save Failed (check if " ^ f ^ " is writable)") + + ) + with + | e -> warning "Save: unexpected error" + in + ignore (save_m#connect#activate save_f); + + (* File/Save As Menu *) + let saveas_m = file_factory#add_item "S_ave as" + in + let saveas_f () = + let current = get_current_view () in + try (match (out_some current.analyzed_view)#filename with + | None -> + begin match GToolbox.select_file ~title:"Save file as" () + with + | None -> () + | Some f -> + if (out_some current.analyzed_view)#save_as f then begin + set_current_tab_label (Filename.basename f); + !flash_info "Saved" + end + else !flash_info "Save Failed" + end + | Some f -> + begin match GToolbox.select_file + ~dir:(ref (Filename.dirname f)) + ~filename:(Filename.basename f) + ~title:"Save file as" () + with + | None -> () + | Some f -> + if (out_some current.analyzed_view)#save_as f then begin + set_current_tab_label (Filename.basename f); + !flash_info "Saved" + end else !flash_info "Save Failed" + end); + with e -> !flash_info "Save Failed" + in + ignore (saveas_m#connect#activate saveas_f); + + (* File/Save All Menu *) + let saveall_m = file_factory#add_item "Sa_ve All" in + let saveall_f () = + Vector.iter + (function + | {view = view ; analyzed_view = Some av} as full -> + begin match av#filename with + | None -> () + | Some f -> + ignore (av#save f) + end + | _ -> () + ) input_views + in + let has_something_to_save () = + Vector.exists + (function + | {view=view} -> view#buffer#modified + ) + input_views + in + ignore (saveall_m#connect#activate saveall_f); + + (* File/Revert Menu *) + let revert_m = file_factory#add_item "_Revert All Buffers" in + let revert_f () = + Vector.iter + (function + {view = view ; analyzed_view = Some av} as full -> + (try + match av#filename,av#stats with + | Some f,Some stats -> + let new_stats = Unix.stat f in + if new_stats.Unix.st_mtime > stats.Unix.st_mtime + then av#revert + | Some _, None -> av#revert + | _ -> () + with _ -> av#revert) + | _ -> () + ) input_views + in + ignore (revert_m#connect#activate revert_f); + + (* File/Close Menu *) + let close_m = file_factory#add_item "_Close Buffer" in + let close_f () = + let v = out_some !active_view in + let act = get_current_view_page () in + if v = act then !flash_info "Cannot close an active view" + else remove_current_view_page () + in + ignore (close_m#connect#activate close_f); + + (* File/Print Menu *) + let print_f () = + let v = get_current_view () in + let av = out_some v.analyzed_view in + match av#filename with + | None -> + !flash_info "Cannot print: this buffer has no name" + | Some f -> + let cmd = + "cd " ^ Filename.dirname f ^ "; " ^ + !current.cmd_coqdoc ^ " -ps " ^ Filename.basename f ^ + " | " ^ !current.cmd_print + in + let s,_ = run_command av#insert_message cmd in + !flash_info (cmd ^ if s = Unix.WEXITED 0 then " succeeded" else " failed") + in + let print_m = file_factory#add_item "_Print" ~callback:print_f in + + (* File/Export to Menu *) + let export_f kind () = + let v = get_current_view () in + let av = out_some v.analyzed_view in + match av#filename with + | None -> + !flash_info "Cannot print: this buffer has no name" + | Some f -> + let basef = Filename.basename f in + let output = + let basef_we = try Filename.chop_extension basef with _ -> basef in + match kind with + | "latex" -> basef_we ^ ".tex" + | "dvi" | "ps" | "html" -> basef_we ^ "." ^ kind + | _ -> assert false + in + let cmd = + "cd " ^ Filename.dirname f ^ "; " ^ + !current.cmd_coqdoc ^ " --" ^ kind ^ " -o " ^ output ^ " " ^ basef + in + let s,_ = run_command av#insert_message cmd in + !flash_info (cmd ^ + if s = Unix.WEXITED 0 + then " succeeded" + else " failed") + in + let file_export_m = file_factory#add_submenu "E_xport to" in + + let file_export_factory = new GMenu.factory ~accel_path:"/Export/" file_export_m ~accel_group in + let export_html_m = + file_export_factory#add_item "_Html" ~callback:(export_f "html") + in + let export_latex_m = + file_export_factory#add_item "_LaTeX" ~callback:(export_f "latex") + in + let export_dvi_m = + file_export_factory#add_item "_Dvi" ~callback:(export_f "dvi") + in + let export_ps_m = + file_export_factory#add_item "_Ps" ~callback:(export_f "ps") + in + + (* File/Rehighlight Menu *) + let rehighlight_m = file_factory#add_item "Reh_ighlight" ~key:GdkKeysyms._L in + ignore (rehighlight_m#connect#activate + (fun () -> + Highlight.highlight_all + (get_current_view()).view#buffer; + (out_some (get_current_view()).analyzed_view)#recenter_insert)); + + (* File/Quit Menu *) + let quit_f () = + save_pref(); + if has_something_to_save () then + match (GToolbox.question_box ~title:"Quit" + ~buttons:["Save Named Buffers and Quit"; + "Quit without Saving"; + "Don't Quit"] + ~default:0 + ~icon: + (let img = GMisc.image () in + img#set_stock `DIALOG_WARNING; + img#set_icon_size `DIALOG; + img#coerce) + "There are unsaved buffers" + ) + with 1 -> saveall_f () ; exit 0 + | 2 -> exit 0 + | _ -> () + else exit 0 + in + let quit_m = file_factory#add_item "_Quit" ~key:GdkKeysyms._Q + ~callback:quit_f + in + ignore (w#event#connect#delete (fun _ -> quit_f (); true)); + + (* Edit Menu *) + let edit_menu = factory#add_submenu "_Edit" in + let edit_f = new GMenu.factory ~accel_path:"/Edit/" edit_menu ~accel_group in + ignore(edit_f#add_item "_Undo" ~key:GdkKeysyms._u ~callback: + (do_if_not_computing "undo" + (fun () -> + ignore ((out_some ((get_current_view()).analyzed_view))# + without_auto_complete + (fun () -> (get_current_view()).view#undo) ())))); + ignore(edit_f#add_item "_Clear Undo Stack" + (* ~key:GdkKeysyms._exclam *) + ~callback: + (fun () -> + ignore (get_current_view()).view#clear_undo)); + ignore(edit_f#add_separator ()); + ignore(edit_f#add_item "Cut" ~key:GdkKeysyms._X ~callback: + (do_if_not_computing "cut" + (fun () -> GtkSignal.emit_unit + (get_current_view()).view#as_view + GtkText.View.S.cut_clipboard))); + ignore(edit_f#add_item "Copy" ~key:GdkKeysyms._C ~callback: + (fun () -> GtkSignal.emit_unit + (get_current_view()).view#as_view + GtkText.View.S.copy_clipboard)); + ignore(edit_f#add_item "Paste" ~key:GdkKeysyms._V ~callback: + (do_if_not_computing "paste" + (fun () -> + try GtkSignal.emit_unit + (get_current_view()).view#as_view + GtkText.View.S.paste_clipboard + with _ -> prerr_endline "EMIT PASTE FAILED"))); + ignore (edit_f#add_separator ()); + + +(* + let toggle_auto_complete_i = + edit_f#add_check_item "_Auto Completion" + ~active:!current.auto_complete + ~callback: + in +*) +(* + auto_complete := + (fun b -> match (get_current_view()).analyzed_view with + | Some av -> av#set_auto_complete b + | None -> ()); +*) + + let last_found = ref None in + let search_backward = ref false in + let find_w = GWindow.window + (* ~wm_class:"CoqIde" ~wm_name:"CoqIde" *) + (* ~allow_grow:true ~allow_shrink:true *) + (* ~width:!current.window_width ~height:!current.window_height *) + ~position:`CENTER + ~title:"CoqIde search/replace" () + in + let find_box = GPack.table + ~columns:3 ~rows:5 + ~col_spacings:10 ~row_spacings:10 ~border_width:10 + ~homogeneous:false ~packing:find_w#add () in + + let find_lbl = + GMisc.label ~text:"Find:" + ~xalign:1.0 + ~packing:(find_box#attach ~left:0 ~top:0 ~fill:`X) () + in + let find_entry = GEdit.entry + ~editable: true + ~packing: (find_box#attach ~left:1 ~top:0 ~expand:`X) + () + in + let replace_lbl = + GMisc.label ~text:"Replace with:" + ~xalign:1.0 + ~packing:(find_box#attach ~left:0 ~top:1 ~fill:`X) () + in + let replace_entry = GEdit.entry + ~editable: true + ~packing: (find_box#attach ~left:1 ~top:1 ~expand:`X) + () + in + let case_sensitive_check = + GButton.check_button + ~label:"case sensitive" + ~active:true + ~packing: (find_box#attach ~left:1 ~top:2) + () + in +(* + let find_backwards_check = + GButton.check_button + ~label:"search backwards" + ~active:false + ~packing: (find_box#attach ~left:1 ~top:3) + () + in +*) + let close_find_button = + GButton.button + ~label:"Close" + ~packing: (find_box#attach ~left:2 ~top:0) + () + in + let replace_button = + GButton.button + ~label:"Replace" + ~packing: (find_box#attach ~left:2 ~top:1) + () + in + let replace_find_button = + GButton.button + ~label:"Replace and find" + ~packing: (find_box#attach ~left:2 ~top:2) + () + in + let find_again_button = + GButton.button + ~label:"_Find again" + ~packing: (find_box#attach ~left:2 ~top:3) + () + in + let find_again_backward_button = + GButton.button + ~label:"Find _backward" + ~packing: (find_box#attach ~left:2 ~top:4) + () + in + let last_find () = + let v = (get_current_view()).view in + let b = v#buffer in + let start,stop = + match !last_found with + | None -> let i = b#get_iter_at_mark `INSERT in (i,i) + | Some(start,stop) -> + let start = b#get_iter_at_mark start + and stop = b#get_iter_at_mark stop + in + b#remove_tag_by_name ~start ~stop "found"; + last_found:=None; + start,stop + in + (v,b,start,stop) + in + let do_replace () = + let v = (get_current_view()).view in + let b = v#buffer in + match !last_found with + | None -> () + | Some(start,stop) -> + let start = b#get_iter_at_mark start + and stop = b#get_iter_at_mark stop + in + b#delete ~start ~stop; + b#insert ~iter:start replace_entry#text; + last_found:=None + in + let find_from (v : Undo.undoable_view) + (b : GText.buffer) (starti : GText.iter) text = + prerr_endline ("Searching for " ^ text); + match (if !search_backward then starti#backward_search text + else starti#forward_search text) + with + | None -> () + | Some(start,stop) -> + b#apply_tag_by_name "found" ~start ~stop; + let start = `MARK (b#create_mark start) + and stop = `MARK (b#create_mark stop) + in + v#scroll_to_mark ~use_align:false ~yalign:0.75 ~within_margin:0.25 + stop; + last_found := Some(start,stop) + in + let do_find () = + let (v,b,starti,_) = last_find () in + find_from v b starti find_entry#text + in + let do_replace_find () = + do_replace(); + do_find() + in + let close_find () = + let (v,b,_,stop) = last_find () in + b#place_cursor stop; + find_w#misc#hide(); + v#coerce#misc#grab_focus() + in + to_do_on_page_switch := + (fun i -> if find_w#misc#visible then close_find()):: + !to_do_on_page_switch; + let find_again_forward () = + search_backward := false; + let (v,b,start,_) = last_find () in + let start = start#forward_chars 1 in + find_from v b start find_entry#text + in + let find_again_backward () = + search_backward := true; + let (v,b,start,_) = last_find () in + let start = start#backward_chars 1 in + find_from v b start find_entry#text + in + let key_find ev = + let s = GdkEvent.Key.state ev and k = GdkEvent.Key.keyval ev in + if k = GdkKeysyms._Escape then + begin + let (v,b,_,stop) = last_find () in + find_w#misc#hide(); + v#coerce#misc#grab_focus(); + true + end + else if k = GdkKeysyms._Return then + begin + close_find(); + true + end + else if List.mem `CONTROL s && k = GdkKeysyms._f then + begin + find_again_forward (); + true + end + else if List.mem `CONTROL s && k = GdkKeysyms._b then + begin + find_again_backward (); + true + end + else false (* to let default callback execute *) + in + let find_f ~backward () = + search_backward := backward; + find_w#show (); + find_w#present (); + find_entry#misc#grab_focus () + in + let find_i = edit_f#add_item "_Find in buffer" + ~key:GdkKeysyms._F + ~callback:(find_f ~backward:false) + in + let find_back_i = edit_f#add_item "Find _backwards" + ~key:GdkKeysyms._B + ~callback:(find_f ~backward:true) + in + let _ = close_find_button#connect#clicked close_find in + let _ = replace_button#connect#clicked do_replace in + let _ = replace_find_button#connect#clicked do_replace_find in + let _ = find_again_button#connect#clicked find_again_forward in + let _ = find_again_backward_button#connect#clicked find_again_backward in + let _ = find_entry#connect#changed do_find in + let _ = find_entry#event#connect#key_press ~callback:key_find in + let _ = find_w#event#connect#delete (fun _ -> find_w#misc#hide(); true) in +(* + let search_if = edit_f#add_item "Search _forward" + ~key:GdkKeysyms._greater + in + let search_ib = edit_f#add_item "Search _backward" + ~key:GdkKeysyms._less + in +*) +(* + let complete_i = edit_f#add_item "_Complete" + ~key:GdkKeysyms._comma + ~callback: + (do_if_not_computing + (fun b -> + let v = out_some (get_current_view ()).analyzed_view + + in v#complete_at_offset + ((v#view#buffer#get_iter `SEL_BOUND)#offset) + )) + in + complete_i#misc#set_state `INSENSITIVE; +*) + + ignore(edit_f#add_item "Complete Word" ~key:GdkKeysyms._slash ~callback: + (do_if_not_computing "complete word" + (fun () -> + ignore ( + let av = out_some ((get_current_view()).analyzed_view) in + av#complete_at_offset (av#get_insert)#offset + )))); + + ignore(edit_f#add_separator ()); + (* external editor *) + let _ = + edit_f#add_item "External editor" ~callback: + (fun () -> + let av = out_some ((get_current_view()).analyzed_view) in + match av#filename with + | None -> () + | Some f -> + save_f (); + let l,r = !current.cmd_editor in + let _ = run_command av#insert_message (l ^ f ^ r) in + av#revert) + in + let _ = edit_f#add_separator () in + (* Preferences *) + let reset_revert_timer () = + disconnect_revert_timer (); + if !current.global_auto_revert then + revert_timer := Some + (GMain.Timeout.add ~ms:!current.global_auto_revert_delay + ~callback: + (fun () -> + do_if_not_computing "revert" (fun () -> revert_f ()) (); + true)) + in reset_revert_timer (); (* to enable statup preferences timer *) + + let auto_save_f () = + Vector.iter + (function + {view = view ; analyzed_view = Some av} as full -> + (try + av#auto_save + with _ -> ()) + | _ -> () + ) + input_views + in + + let reset_auto_save_timer () = + disconnect_auto_save_timer (); + if !current.auto_save then + auto_save_timer := Some + (GMain.Timeout.add ~ms:!current.auto_save_delay + ~callback: + (fun () -> + do_if_not_computing "autosave" (fun () -> auto_save_f ()) (); + true)) + in reset_auto_save_timer (); (* to enable statup preferences timer *) + + + let edit_prefs_m = + edit_f#add_item "_Preferences" + ~callback:(fun () -> configure ();reset_revert_timer ()) + in +(* + let save_prefs_m = + configuration_factory#add_item "_Save preferences" + ~callback:(fun () -> save_pref ()) + in +*) + (* Navigation Menu *) + let navigation_menu = factory#add_submenu "_Navigation" in + let navigation_factory = + new GMenu.factory navigation_menu + ~accel_path:"/Navigation/" + ~accel_group + ~accel_modi:!current.modifier_for_navigation + in + let do_or_activate f () = + let current = get_current_view () in + let analyzed_view = out_some current.analyzed_view in + if analyzed_view#is_active then + ignore (f analyzed_view) + else + begin + !flash_info "New proof started"; + activate_input (notebook ())#current_page; + ignore (f analyzed_view) + end + in + + let do_or_activate f = + do_if_not_computing "do_or_activate" (do_or_activate (fun av -> f av ; !pop_info();!push_info (Coq.current_status()))) + in + + let add_to_menu_toolbar text ~tooltip ?key ~callback icon = + begin + match key with None -> () + | Some key -> ignore (navigation_factory#add_item text ~key ~callback) + end; + ignore (toolbar#insert_button + ~tooltip + ~text:tooltip + ~icon:(stock_to_widget ~size:`LARGE_TOOLBAR icon) + ~callback + ()) + in + add_to_menu_toolbar + "_Save" + ~tooltip:"Save current buffer" + (* ~key:GdkKeysyms._Down *) + ~callback:save_f + `SAVE; + add_to_menu_toolbar + "_Forward" + ~tooltip:"Forward one command" + ~key:GdkKeysyms._Down + ~callback:(do_or_activate (fun a -> a#process_next_phrase true true true)) + `GO_DOWN; + add_to_menu_toolbar "_Backward" + ~tooltip:"Backward one command" + ~key:GdkKeysyms._Up + ~callback:(do_or_activate (fun a -> a#undo_last_step)) + `GO_UP; +(* + add_to_menu_toolbar + "_Forward to" + ~tooltip:"Forward to" + ~key:GdkKeysyms._Right + ~callback:(do_or_activate (fun a -> a#process_until_insert_or_error)) + `GOTO_LAST; + add_to_menu_toolbar + "_Backward to" + ~tooltip:"Backward to" + ~key:GdkKeysyms._Left + ~callback:(do_or_activate (fun a-> a#backtrack_to_insert)) + `GOTO_FIRST; +*) + add_to_menu_toolbar + "_Go to" + ~tooltip:"Go to cursor" + ~key:GdkKeysyms._Right + ~callback:(do_or_activate (fun a-> a#go_to_insert)) + `JUMP_TO; + add_to_menu_toolbar + "_Start" + ~tooltip:"Go to start" + ~key:GdkKeysyms._Home + ~callback:(do_or_activate (fun a -> a#reset_initial)) + `GOTO_TOP; + add_to_menu_toolbar + "_End" + ~tooltip:"Go to end" + ~key:GdkKeysyms._End + ~callback:(do_or_activate (fun a -> a#process_until_end_or_error)) + `GOTO_BOTTOM; + add_to_menu_toolbar "_Interrupt" + ~tooltip:"Interrupt computations" + ~key:GdkKeysyms._Break + ~callback:break + `STOP + ; + + (* Tactics Menu *) + let tactics_menu = factory#add_submenu "_Try Tactics" in + let tactics_factory = + new GMenu.factory tactics_menu + ~accel_path:"/Tactics/" + ~accel_group + ~accel_modi:!current.modifier_for_tactics + in + let do_if_active_raw f () = + let current = get_current_view () in + let analyzed_view = out_some current.analyzed_view in + if analyzed_view#is_active then ignore (f analyzed_view) + in + let do_if_active f = do_if_not_computing "do_if_active" (do_if_active_raw f) in + +(* + let blaster_i = + tactics_factory#add_item "_Blaster" + ~key:GdkKeysyms._b + ~callback: (do_if_active_raw (fun a -> a#blaster ())) + (* Custom locking mechanism! *) + in + blaster_i#misc#set_state `INSENSITIVE; +*) + + ignore (tactics_factory#add_item "_auto" + ~key:GdkKeysyms._a + ~callback:(do_if_active (fun a -> a#insert_command "progress auto.\n" "auto.\n")) + ); + ignore (tactics_factory#add_item "_auto with *" + ~key:GdkKeysyms._asterisk + ~callback:(do_if_active (fun a -> a#insert_command + "progress auto with *.\n" + "auto with *.\n"))); + ignore (tactics_factory#add_item "_eauto" + ~key:GdkKeysyms._e + ~callback:(do_if_active (fun a -> a#insert_command + "progress eauto.\n" + "eauto.\n")) + ); + ignore (tactics_factory#add_item "_eauto with *" + ~key:GdkKeysyms._ampersand + ~callback:(do_if_active (fun a -> a#insert_command + "progress eauto with *.\n" + "eauto with *.\n")) + ); + ignore (tactics_factory#add_item "_intuition" + ~key:GdkKeysyms._i + ~callback:(do_if_active (fun a -> a#insert_command + "progress intuition.\n" + "intuition.\n")) + ); + ignore (tactics_factory#add_item "_omega" + ~key:GdkKeysyms._o + ~callback:(do_if_active (fun a -> a#insert_command + "omega.\n" "omega.\n")) + ); + ignore (tactics_factory#add_item "_simpl" + ~key:GdkKeysyms._s + ~callback:(do_if_active (fun a -> a#insert_command "progress simpl.\n" "simpl.\n" )) + ); + ignore (tactics_factory#add_item "_tauto" + ~key:GdkKeysyms._p + ~callback:(do_if_active (fun a -> a#insert_command "tauto.\n" "tauto.\n" )) + ); + ignore (tactics_factory#add_item "_trivial" + ~key:GdkKeysyms._v + ~callback:(do_if_active( fun a -> a#insert_command "progress trivial.\n" "trivial.\n" )) + ); + + + ignore (toolbar#insert_button + ~tooltip:"Proof Wizard" + ~text:"Wizard" + ~icon:(stock_to_widget ~size:`LARGE_TOOLBAR `DIALOG_INFO) + ~callback:(do_if_active (fun a -> a#tactic_wizard + !current.automatic_tactics + )) + ()); + + ignore (tactics_factory#add_item "" + ~key:GdkKeysyms._dollar + ~callback:(do_if_active (fun a -> a#tactic_wizard + !current.automatic_tactics + )) + ); + + ignore (tactics_factory#add_separator ()); + let add_simple_template (factory: GMenu.menu GMenu.factory) + (menu_text, text) = + let text = + let l = String.length text - 1 in + if String.get text l = '.' + then text ^"\n" + else text ^" " + in + ignore (factory#add_item menu_text + ~callback: + (do_if_not_computing "simple template" + (fun () -> let {view = view } = get_current_view () in + ignore (view#buffer#insert_interactive text)))) + in + List.iter + (fun l -> + match l with + | [] -> () + | [s] -> add_simple_template tactics_factory ("_"^s, s) + | s::_ -> + let a = "_@..." in + a.[1] <- s.[0]; + let f = tactics_factory#add_submenu a in + let ff = new GMenu.factory f ~accel_group in + List.iter + (fun x -> + add_simple_template + ff + ((String.sub x 0 1)^ + "_"^ + (String.sub x 1 (String.length x - 1)), + x)) + l + ) + Coq_commands.tactics; + + (* Templates Menu *) + let templates_menu = factory#add_submenu "Te_mplates" in + let templates_factory = new GMenu.factory templates_menu + ~accel_path:"/Templates/" + ~accel_group + ~accel_modi:!current.modifier_for_templates + in + let add_complex_template (menu_text, text, offset, len, key) = + (* Templates/Lemma *) + let callback = do_if_not_computing "complex template" + (fun () -> + let {view = view } = get_current_view () in + if view#buffer#insert_interactive text then begin + let iter = view#buffer#get_iter_at_mark `INSERT in + ignore (iter#nocopy#backward_chars offset); + view#buffer#move_mark `INSERT iter; + ignore (iter#nocopy#backward_chars len); + view#buffer#move_mark `SEL_BOUND iter; + end) + in + ignore (templates_factory#add_item menu_text ~callback ?key) + in + add_complex_template + ("_Lemma __", "Lemma new_lemma : .\nProof.\n\nSave.\n", + 19, 9, Some GdkKeysyms._L); + add_complex_template + ("_Theorem __", "Theorem new_theorem : .\nProof.\n\nSave.\n", + 19, 11, Some GdkKeysyms._T); + add_complex_template + ("_Definition __", "Definition ident := .\n", + 6, 5, Some GdkKeysyms._D); + add_complex_template + ("_Inductive __", "Inductive ident : :=\n | : .\n", + 14, 5, Some GdkKeysyms._I); + add_complex_template + ("_Fixpoint __", "Fixpoint ident (_ : _) {struct _} : _ :=\n.\n", + 29, 5, Some GdkKeysyms._F); + add_complex_template("_Scheme __", + "Scheme new_scheme := Induction for _ Sort _ +with _ := Induction for _ Sort _.\n",61,10, Some GdkKeysyms._S); + + (* Template for match *) + let callback () = + let w = get_current_word () in + try + let cases = Coq.make_cases w + in + let print c = function + | [x] -> Format.fprintf c " | %s => _@\n" x + | x::l -> Format.fprintf c " | (%s%a) => _@\n" x + (print_list (fun c s -> Format.fprintf c " %s" s)) l + | [] -> assert false + in + let b = Buffer.create 1024 in + let fmt = Format.formatter_of_buffer b in + Format.fprintf fmt "@[match var with@\n%aend@]@." + (print_list print) cases; + let s = Buffer.contents b in + prerr_endline s; + let {view = view } = get_current_view () in + ignore (view#buffer#delete_selection ()); + let m = view#buffer#create_mark + (view#buffer#get_iter `INSERT) + in + if view#buffer#insert_interactive s then + let i = view#buffer#get_iter (`MARK m) in + let _ = i#nocopy#forward_chars 9 in + view#buffer#place_cursor i; + view#buffer#move_mark ~where:(i#backward_chars 3) + `SEL_BOUND + with Not_found -> !flash_info "Not an inductive type" + in + ignore (templates_factory#add_item "match ..." + ~key:GdkKeysyms._C + ~callback + ); + +(* + let add_simple_template (factory: GMenu.menu GMenu.factory) + (menu_text, text) = + let text = + let l = String.length text - 1 in + if String.get text l = '.' + then text ^"\n" + else text ^" " + in + ignore (factory#add_item menu_text + ~callback: + (do_if_not_computing "simple template" + (fun () -> let {view = view } = get_current_view () in + ignore (view#buffer#insert_interactive text)))) + in +*) + ignore (templates_factory#add_separator ()); +(* + List.iter (add_simple_template templates_factory) + [ "_auto", "auto "; + "_auto with *", "auto with * "; + "_eauto", "eauto "; + "_eauto with *", "eauto with * "; + "_intuition", "intuition "; + "_omega", "omega "; + "_simpl", "simpl "; + "_tauto", "tauto "; + "tri_vial", "trivial "; + ]; + ignore (templates_factory#add_separator ()); +*) + List.iter + (fun l -> + match l with + | [] -> () + | [s] -> add_simple_template templates_factory ("_"^s, s) + | s::_ -> + let a = "_@..." in + a.[1] <- s.[0]; + let f = templates_factory#add_submenu a in + let ff = new GMenu.factory f ~accel_group in + List.iter + (fun x -> + add_simple_template + ff + ((String.sub x 0 1)^ + "_"^ + (String.sub x 1 (String.length x - 1)), + x)) + l + ) + Coq_commands.commands; + + (* Queries Menu *) + let queries_menu = factory#add_submenu "_Queries" in + let queries_factory = new GMenu.factory queries_menu ~accel_group + ~accel_path:"/Queries" + ~accel_modi:[] + in + + (* Command/Show commands *) + let _ = + queries_factory#add_item "_SearchAbout " ~key:GdkKeysyms._F2 + ~callback:(fun () -> let term = get_current_word () in + (Command_windows.command_window ())#new_command + ~command:"SearchAbout" + ~term + ()) + in + let _ = + queries_factory#add_item "_Check " ~key:GdkKeysyms._F3 + ~callback:(fun () -> let term = get_current_word () in + (Command_windows.command_window ())#new_command + ~command:"Check" + ~term + ()) + in + let _ = + queries_factory#add_item "_Print " ~key:GdkKeysyms._F4 + ~callback:(fun () -> let term = get_current_word () in + (Command_windows.command_window ())#new_command + ~command:"Print" + ~term + ()) + in + + (* Externals *) + let externals_menu = factory#add_submenu "_Compile" in + let externals_factory = new GMenu.factory externals_menu + ~accel_path:"/Compile/" + ~accel_group + ~accel_modi:[] + in + + (* Command/Compile Menu *) + let compile_f () = + let v = get_current_view () in + let av = out_some v.analyzed_view in + save_f (); + match av#filename with + | None -> + !flash_info "Active buffer has no name" + | Some f -> + let s,res = run_command + av#insert_message + (!current.cmd_coqc ^ " " ^ f) + in + if s = Unix.WEXITED 0 then + !flash_info (f ^ " successfully compiled") + else begin + !flash_info (f ^ " failed to compile"); + activate_input (notebook ())#current_page; + av#process_until_end_or_error; + av#insert_message "Compilation output:\n"; + av#insert_message res + end + in + let compile_m = + externals_factory#add_item "_Compile Buffer" ~callback:compile_f + in + + (* Command/Make Menu *) + let make_f () = + let v = get_active_view () in + let av = out_some v.analyzed_view in +(* + save_f (); +*) + av#insert_message "Command output:\n"; + let s,res = run_command av#insert_message !current.cmd_make in + last_make := res; + last_make_index := 0; + !flash_info (!current.cmd_make ^ if s = Unix.WEXITED 0 then " succeeded" else " failed") + in + let make_m = externals_factory#add_item "_Make" + ~key:GdkKeysyms._F6 + ~callback:make_f + in + + + (* Compile/Next Error *) + let next_error () = + try + let file,line,start,stop,error_msg = search_next_error () in + load file; + let v = get_current_view () in + let av = out_some v.analyzed_view in + let input_buffer = v.view#buffer in +(* + let init = input_buffer#start_iter in + let i = init#forward_lines (line-1) in +*) +(* + let convert_pos = byte_offset_to_char_offset phrase in + let start = convert_pos start in + let stop = convert_pos stop in +*) +(* + let starti = i#forward_chars start in + let stopi = i#forward_chars stop in +*) + let starti = input_buffer#get_iter_at_byte ~line:(line-1) start in + let stopi = input_buffer#get_iter_at_byte ~line:(line-1) stop in + input_buffer#apply_tag_by_name "error" + ~start:starti + ~stop:stopi; + input_buffer#place_cursor starti; + av#set_message error_msg; + v.view#misc#grab_focus () + with Not_found -> + last_make_index := 0; + let v = get_current_view () in + let av = out_some v.analyzed_view in + av#set_message "No more errors.\n" + in + let next_error_m = + externals_factory#add_item "_Next error" + ~key:GdkKeysyms._F7 + ~callback:next_error in + + + (* Command/CoqMakefile Menu*) + let coq_makefile_f () = + let v = get_active_view () in + let av = out_some v.analyzed_view in + let s,res = run_command av#insert_message !current.cmd_coqmakefile in + !flash_info + (!current.cmd_coqmakefile ^ if s = Unix.WEXITED 0 then " succeeded" else " failed") + in + let _ = externals_factory#add_item "_Make makefile" ~callback:coq_makefile_f + in + (* Windows Menu *) + let configuration_menu = factory#add_submenu "_Windows" in + let configuration_factory = new GMenu.factory configuration_menu ~accel_path:"/Windows" ~accel_group + in + let queries_show_m = + configuration_factory#add_item + "Show _Query Window" + (* + ~key:GdkKeysyms._F12 + *) + ~callback:(Command_windows.command_window ())#window#present + in + let toolbar_show_m = + configuration_factory#add_item + "Show/Hide _Toolbar" + ~callback:(fun () -> + !current.show_toolbar <- not !current.show_toolbar; + !show_toolbar !current.show_toolbar) + in + let detach_menu = configuration_factory#add_item + "Detach _Script Window" + ~callback: + (do_if_not_computing "detach script window" + (fun () -> + let nb = notebook () in + if nb#misc#toplevel#get_oid=w#coerce#get_oid then + begin + let nw = GWindow.window ~show:true () in + let parent = out_some nb#misc#parent in + ignore (nw#connect#destroy + ~callback: + (fun () -> nb#misc#reparent parent)); + nw#add_accel_group accel_group; + nb#misc#reparent nw#coerce + end + )) + in + let detach_current_view = + configuration_factory#add_item + "Detach _View" + ~callback: + (do_if_not_computing "detach view" + (fun () -> + match get_current_view () with + | {view=v;analyzed_view=Some av} -> + let w = GWindow.window ~show:true + ~width:(!current.window_width/2) + ~height:(!current.window_height) + ~title:(match av#filename with + | None -> "*Unnamed*" + | Some f -> f) + () + in + let sb = GBin.scrolled_window + ~packing:w#add () + in + let nv = GText.view + ~buffer:v#buffer + ~packing:sb#add + () + in + nv#misc#modify_font + !current.text_font; + ignore (w#connect#destroy + ~callback: + (fun () -> av#remove_detached_view w)); + av#add_detached_view w + | _ -> () + + )) + in + (* Help Menu *) + + let help_menu = factory#add_submenu "_Help" in + let help_factory = new GMenu.factory help_menu + ~accel_path:"/Help/" + ~accel_modi:[] + ~accel_group in + let _ = help_factory#add_item "Browse Coq _Manual" + ~callback: + (fun () -> + let av = out_some ((get_current_view ()).analyzed_view) in + browse av#insert_message (!current.doc_url ^ "main.html")) in + let _ = help_factory#add_item "Browse Coq _Library" + ~callback: + (fun () -> + let av = out_some ((get_current_view ()).analyzed_view) in + browse av#insert_message !current.library_url) in + let _ = + help_factory#add_item "Help for _keyword" ~key:GdkKeysyms._F1 + ~callback:(fun () -> + let av = out_some ((get_current_view ()).analyzed_view) in + av#help_for_keyword ()) + in + let _ = help_factory#add_separator () in +(* + let faq_m = help_factory#add_item "_FAQ" in +*) + let about_m = help_factory#add_item "_About" in + + (* End of menu *) + + (* The vertical Separator between Scripts and Goals *) + let hb = GPack.paned `HORIZONTAL ~border_width:3 ~packing:vbox#add () in + _notebook := Some (GPack.notebook ~scrollable:true + ~packing:hb#add1 + ()); + let nb = notebook () in + let fr2 = GBin.frame ~shadow_type:`ETCHED_OUT ~packing:hb#add2 () in + let hb2 = GPack.paned `VERTICAL ~border_width:3 ~packing:fr2#add () in + let sw2 = GBin.scrolled_window + ~vpolicy:`AUTOMATIC + ~hpolicy:`AUTOMATIC + ~packing:(hb2#add) () in + let sw3 = GBin.scrolled_window + ~vpolicy:`AUTOMATIC + ~hpolicy:`AUTOMATIC + ~packing:(hb2#add) () in + let lower_hbox = GPack.hbox ~homogeneous:false ~packing:vbox#pack () in + let status_bar = GMisc.statusbar ~packing:(lower_hbox#pack ~expand:true) () + in + let search_lbl = GMisc.label ~text:"Search:" + ~show:false + ~packing:(lower_hbox#pack ~expand:false) () + in + let search_history = ref [] in + let search_input = GEdit.combo ~popdown_strings:!search_history + ~enable_arrow_keys:true + ~show:false + ~packing:(lower_hbox#pack ~expand:false) () + in + search_input#disable_activate (); + let ready_to_wrap_search = ref false in + + let start_of_search = ref None in + let start_of_found = ref None in + let end_of_found = ref None in + let search_forward = ref true in + let matched_word = ref None in + + let memo_search () = + matched_word := Some search_input#entry#text + +(* if not (List.mem search_input#entry#text !search_history) then + (search_history := + search_input#entry#text::!search_history; + search_input#set_popdown_strings !search_history); + start_of_search := None; + ready_to_wrap_search := false +*) + + in + let end_search () = + prerr_endline "End Search"; + memo_search (); + let v = (get_current_view ()).view in + v#buffer#move_mark `SEL_BOUND (v#buffer#get_iter_at_mark `INSERT); + v#coerce#misc#grab_focus (); + search_input#entry#set_text ""; + search_lbl#misc#hide (); + search_input#misc#hide () + in + let end_search_focus_out () = + prerr_endline "End Search(focus out)"; + memo_search (); + let v = (get_current_view ()).view in + v#buffer#move_mark `SEL_BOUND (v#buffer#get_iter_at_mark `INSERT); + search_input#entry#set_text ""; + search_lbl#misc#hide (); + search_input#misc#hide () + in + ignore (search_input#entry#connect#activate ~callback:end_search); + ignore (search_input#entry#event#connect#key_press + ~callback:(fun k -> let kv = GdkEvent.Key.keyval k in + if + kv = GdkKeysyms._Right + || kv = GdkKeysyms._Up + || kv = GdkKeysyms._Left + || (kv = GdkKeysyms._g + && (List.mem `CONTROL (GdkEvent.Key.state k))) + then end_search (); + false)); + ignore (search_input#entry#event#connect#focus_out + ~callback:(fun _ -> end_search_focus_out (); false)); + to_do_on_page_switch := + (fun i -> + start_of_search := None; + ready_to_wrap_search:=false)::!to_do_on_page_switch; + +(* TODO : make it work !!! *) + let rec search_f () = + search_lbl#misc#show (); + search_input#misc#show (); + + prerr_endline "search_f called"; + if !start_of_search = None then begin + (* A full new search is starting *) + start_of_search := + Some ((get_current_view ()).view#buffer#create_mark + ((get_current_view ()).view#buffer#get_iter_at_mark `INSERT)); + start_of_found := !start_of_search; + end_of_found := !start_of_search; + matched_word := Some ""; + end; + let txt = search_input#entry#text in + let v = (get_current_view ()).view in + let iit = v#buffer#get_iter_at_mark `SEL_BOUND + and insert_iter = v#buffer#get_iter_at_mark `INSERT + in + prerr_endline ("SELBOUND="^(string_of_int iit#offset)); + prerr_endline ("INSERT="^(string_of_int insert_iter#offset)); + + (match + if !search_forward then iit#forward_search txt + else let npi = iit#forward_chars (Glib.Utf8.length txt) in + match + (npi#offset = (v#buffer#get_iter_at_mark `INSERT)#offset), + (let t = iit#get_text ~stop:npi in + !flash_info (t^"\n"^txt); + t = txt) + with + | true,true -> + (!flash_info "T,T";iit#backward_search txt) + | false,true -> !flash_info "F,T";Some (iit,npi) + | _,false -> + (iit#backward_search txt) + + with + | None -> + if !ready_to_wrap_search then begin + ready_to_wrap_search := false; + !flash_info "Search wrapped"; + v#buffer#place_cursor + (if !search_forward then v#buffer#start_iter else + v#buffer#end_iter); + search_f () + end else begin + if !search_forward then !flash_info "Search at end" + else !flash_info "Search at start"; + ready_to_wrap_search := true + end + | Some (start,stop) -> + prerr_endline "search: before moving marks"; + prerr_endline ("SELBOUND="^(string_of_int (v#buffer#get_iter_at_mark `SEL_BOUND)#offset)); + prerr_endline ("INSERT="^(string_of_int (v#buffer#get_iter_at_mark `INSERT)#offset)); + + v#buffer#move_mark `SEL_BOUND start; + v#buffer#move_mark `INSERT stop; + prerr_endline "search: after moving marks"; + prerr_endline ("SELBOUND="^(string_of_int (v#buffer#get_iter_at_mark `SEL_BOUND)#offset)); + prerr_endline ("INSERT="^(string_of_int (v#buffer#get_iter_at_mark `INSERT)#offset)); + v#scroll_to_mark `SEL_BOUND + ) + in + ignore (search_input#entry#event#connect#key_release + ~callback: + (fun ev -> + if GdkEvent.Key.keyval ev = GdkKeysyms._Escape then begin + let v = (get_current_view ()).view in + (match !start_of_search with + | None -> + prerr_endline "search_key_rel: Placing sel_bound"; + v#buffer#move_mark + `SEL_BOUND + (v#buffer#get_iter_at_mark `INSERT) + | Some mk -> let it = v#buffer#get_iter_at_mark + (`MARK mk) in + prerr_endline "search_key_rel: Placing cursor"; + v#buffer#place_cursor it; + start_of_search := None + ); + search_input#entry#set_text ""; + v#coerce#misc#grab_focus (); + end; + false + )); + ignore (search_input#entry#connect#changed search_f); + +(* + ignore (search_if#connect#activate + ~callback:(fun b -> + search_forward:= true; + search_input#entry#coerce#misc#grab_focus (); + search_f (); + ) + ); + ignore (search_ib#connect#activate + ~callback:(fun b -> + search_forward:= false; + + (* Must restore the SEL_BOUND mark after + grab_focus ! *) + let v = (get_current_view ()).view in + let old_sel = v#buffer#get_iter_at_mark `SEL_BOUND + in + search_input#entry#coerce#misc#grab_focus (); + v#buffer#move_mark `SEL_BOUND old_sel; + search_f (); + )); +*) + let status_context = status_bar#new_context "Messages" in + let flash_context = status_bar#new_context "Flash" in + ignore (status_context#push "Ready"); + status := Some status_bar; + push_info := (fun s -> ignore (status_context#push s)); + pop_info := (fun () -> status_context#pop ()); + flash_info := (fun ?(delay=5000) s -> flash_context#flash ~delay s); + + (* Location display *) + let l = GMisc.label + ~text:"Line: 1 Char: 1" + ~packing:lower_hbox#pack () in + l#coerce#misc#set_name "location"; + set_location := l#set_text; + + (* Progress Bar *) + pulse := + (let pb = GRange.progress_bar ~pulse_step:0.2 ~packing:lower_hbox#pack () + in pb#set_text "CoqIde started";pb)#pulse; + let tv2 = GText.view ~packing:(sw2#add) () in + tv2#misc#set_name "GoalWindow"; + let _ = tv2#set_editable false in + let tb2 = tv2#buffer in + let tv3 = GText.view ~packing:(sw3#add) () in + tv2#misc#set_name "MessageWindow"; + let _ = tv2#set_wrap_mode `CHAR in + let _ = tv3#set_wrap_mode `WORD in + let _ = tv3#set_editable false in + let _ = GtkBase.Widget.add_events tv2#as_widget + [`ENTER_NOTIFY;`POINTER_MOTION] in + let _ = tv2#event#connect#motion_notify + ~callback: + (fun e -> + (do_if_not_computing "motion notify" + (fun e -> + let win = match tv2#get_window `WIDGET with + | None -> assert false + | Some w -> w + in + let x,y = Gdk.Window.get_pointer_location win in + let b_x,b_y = tv2#window_to_buffer_coords + ~tag:`WIDGET + ~x + ~y + in + let it = tv2#get_iter_at_location ~x:b_x ~y:b_y in + let tags = it#tags in + List.iter + ( fun t -> + ignore (GtkText.Tag.event + t#as_tag + tv2#as_widget + e + it#as_iter)) + tags; + false)) e; + false) + in + change_font := + (fun fd -> + tv2#misc#modify_font fd; + tv3#misc#modify_font fd; + Vector.iter + (fun {view=view} -> view#misc#modify_font fd) + input_views; + ); + let about (b:GText.buffer) = + (try + let image = Filename.concat lib_ide "coq.png" in + let startup_image = GdkPixbuf.from_file image in + b#insert_pixbuf ~iter:b#start_iter + ~pixbuf:startup_image; + b#insert ~iter:b#start_iter "\t\t"; + with _ -> ()); + let about_string = + "\nCoqIDE: an Integrated Development Environment for Coq\n\ + \nMain author : Benjamin Monate\ + \nContributors : Jean-Christophe Filliâtre\ + \n Pierre Letouzey, Claude Marché\n\ + \nFeature wish or bug report: use Web interface\n\ + \n\thttp://coq.inria.fr/bin/coq-bugs\n\ + \nVersion information\ + \n-------------------\n" + in + if Glib.Utf8.validate about_string + then b#insert about_string; + let coq_version = Coq.version () in + if Glib.Utf8.validate coq_version + then b#insert coq_version; + + in + about tv2#buffer; + w#add_accel_group accel_group; + (* Remove default pango menu for textviews *) + ignore (tv2#event#connect#button_press ~callback: + (fun ev -> GdkEvent.Button.button ev = 3)); + ignore (tv3#event#connect#button_press ~callback: + (fun ev -> GdkEvent.Button.button ev = 3)); + tv2#misc#set_can_focus true; + tv3#misc#set_can_focus true; + ignore (tv2#buffer#create_mark + ~name:"end_of_conclusion" + tv2#buffer#start_iter); + ignore (tv3#buffer#create_tag + ~name:"error" + [`FOREGROUND "red"]); + w#show (); + message_view := Some tv3; + proof_view := Some tv2; + tv2#misc#modify_font !current.text_font; + tv3#misc#modify_font !current.text_font; + ignore (about_m#connect#activate + ~callback:(fun () -> tv2#buffer#set_text ""; about tv2#buffer)); +(* + ignore (faq_m#connect#activate + ~callback:(fun () -> + load (Filename.concat lib_ide "FAQ"))); + +*) + resize_window := (fun () -> + w#resize + ~width:!current.window_width + ~height:!current.window_height); + + ignore (w#misc#connect#size_allocate + (let old_w = ref 0 + and old_h = ref 0 in + fun {Gtk.width=w;Gtk.height=h} -> + if !old_w <> w or !old_h <> h then + begin + old_h := h; + old_w := w; + hb#set_position (w/2); + hb2#set_position (h/2); + !current.window_height <- h; + !current.window_width <- w; + end + )); + ignore(nb#connect#switch_page + ~callback: + (fun i -> + prerr_endline ("switch_page: starts " ^ string_of_int i); + List.iter (function f -> f i) !to_do_on_page_switch; + prerr_endline "switch_page: success") + ); + ignore(tv2#event#connect#enter_notify + (fun _ -> + if !current.contextual_menus_on_goal then + begin + let w = (out_some (get_active_view ()).analyzed_view) in + !push_info "Computing advanced goal's menus"; + prerr_endline "Entering Goal Window. Computing Menus...."; + w#show_goals_full; + prerr_endline "....Done with Goal menu"; + !pop_info(); + end; + false; + )); + if List.length files >=1 then + begin + List.iter (fun f -> + if Sys.file_exists f then load f else + if Filename.check_suffix f ".v" + then load f + else load (f^".v")) files; + activate_input 0 + end + else + begin + let view = create_input_tab "*Unnamed Buffer*" in + let index = add_input_view {view = view; + analyzed_view = None; + } + in + (get_input_view index).analyzed_view <- Some (new analyzed_view index); + activate_input index; + set_tab_image index ~icon:`YES; + view#misc#modify_font !current.text_font + end; + +;; + +let start () = + let files = Coq.init () in + ignore_break (); + GtkMain.Rc.add_default_file (Filename.concat lib_ide ".coqide-gtk2rc"); + (try + GtkMain.Rc.add_default_file (Filename.concat System.home ".coqide-gtk2rc"); + with Not_found -> ()); + ignore (GtkMain.Main.init ()); + GtkData.AccelGroup.set_default_mod_mask + (Some [`CONTROL;`SHIFT;`MOD1;`MOD3;`MOD4]); + cb_ := Some (GData.clipboard Gdk.Atom.primary); + ignore ( + Glib.Message.set_log_handler ~domain:"Gtk" ~levels:[`ERROR;`FLAG_FATAL; + `WARNING;`CRITICAL] + (fun ~level msg -> failwith ("Coqide internal error: " ^ msg))); + Command_windows.main (); + Blaster_window.main 9; + main files; + while true do + try + GtkThread.main () + with + | Sys.Break -> prerr_endline "Interrupted." ; flush stderr + | e -> + Pervasives.prerr_endline ("CoqIde unexpected error:" ^ (Printexc.to_string e)); + flush stderr; + crash_save 127 + done + diff --git a/ide/coqide.mli b/ide/coqide.mli new file mode 100644 index 00000000..15e28fea --- /dev/null +++ b/ide/coqide.mli @@ -0,0 +1,16 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* unit diff --git a/ide/extract_index.mll b/ide/extract_index.mll new file mode 100644 index 00000000..4a8c37f1 --- /dev/null +++ b/ide/extract_index.mll @@ -0,0 +1,31 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* " [^ ',']* ", " + { let s = lexeme lexbuf in + let n = String.length s in + String.sub s 8 (n - 15), extract_index_url lexbuf } + | "
  • " [^ ',']* ", " + { let s = lexeme lexbuf in + let n = String.length s in + String.sub s 4 (n - 6), extract_index_url lexbuf } + +and extract_index_url = parse + | " () + end + with _ -> ()); + highlighting := false + end + + let highlight_current_line input_buffer = + try + let i = get_insert input_buffer in + highlight_slice input_buffer (i#set_line_offset 0) i + with _ -> () + + let highlight_around_current_line input_buffer = + try + let i = get_insert input_buffer in + highlight_slice input_buffer + (i#backward_lines 10) + (ignore (i#nocopy#forward_lines 10);i) + + with _ -> () + + let highlight_all input_buffer = + try + highlight_slice input_buffer input_buffer#start_iter input_buffer#end_iter + with _ -> () + +} diff --git a/ide/ideutils.ml b/ide/ideutils.ml new file mode 100644 index 00000000..8ec0e9e4 --- /dev/null +++ b/ide/ideutils.ml @@ -0,0 +1,307 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* failwith "not ready") +let pop_info = ref (function s -> failwith "not ready") +let flash_info = ref (fun ?delay s -> failwith "not ready") + +let set_location = ref (function s -> failwith "not ready") + +let pulse = ref (function () -> failwith "not ready") + + +let debug = Options.debug + +let prerr_endline s = + if !debug then (prerr_endline s;flush stderr) +let prerr_string s = + if !debug then (prerr_string s;flush stderr) + +let lib_ide = Filename.concat Coq_config.coqlib "ide" + +let get_insert input_buffer = input_buffer#get_iter_at_mark `INSERT + +let is_char_start c = let code = Char.code c in code < 0x80 || code >= 0xc0 + +let byte_offset_to_char_offset s byte_offset = + if (byte_offset < String.length s) then begin + let count_delta = ref 0 in + for i = 0 to byte_offset do + let code = Char.code s.[i] in + if code >= 0x80 && code < 0xc0 then incr count_delta + done; + byte_offset - !count_delta + end + else begin + let count_delta = ref 0 in + for i = 0 to String.length s - 1 do + let code = Char.code s.[i] in + if code >= 0x80 && code < 0xc0 then incr count_delta + done; + byte_offset - !count_delta + end + +let process_pending () = + prerr_endline "Pending process";() +(* try + while Glib.Main.pending () do + ignore (Glib.Main.iteration false) + done + with e -> + prerr_endline "Pending problems : expect a crash very soon"; + raise e +*) + +let print_id id = + prerr_endline ("GOT sig id :"^(string_of_int (Obj.magic id))) + + +let do_convert s = + Utf8_convert.f + (if Glib.Utf8.validate s then begin + prerr_endline "Input is UTF-8";s + end else + let from_loc () = + let _,char_set = Glib.Convert.get_charset () in + !flash_info + ("Converting from locale ("^char_set^")"); + Glib.Convert.convert_with_fallback ~to_codeset:"UTF-8" ~from_codeset:char_set s + in + let from_manual () = + !flash_info + ("Converting from "^ !current.encoding_manual); + Glib.Convert.convert s ~to_codeset:"UTF-8" ~from_codeset:!current.encoding_manual + in + if !current.encoding_use_utf8 || !current.encoding_use_locale then begin + try + from_loc () + with _ -> from_manual () + end else begin + try + from_manual () + with _ -> from_loc () + end) + +let try_convert s = + try + do_convert s + with _ -> + "(* Fatal error: wrong encoding in input. +Please choose a correct encoding in the preference panel.*)";; + + +let try_export file_name s = + try let s = + try if !current.encoding_use_utf8 then begin + (prerr_endline "UTF-8 is enforced" ;s) + end else if !current.encoding_use_locale then begin + let is_unicode,char_set = Glib.Convert.get_charset () in + if is_unicode then + (prerr_endline "Locale is UTF-8" ;s) + else + (prerr_endline ("Locale is "^char_set); + Glib.Convert.convert_with_fallback ~from_codeset:"UTF-8" ~to_codeset:char_set s) + end else + (prerr_endline ("Manual charset is "^ !current.encoding_manual); + Glib.Convert.convert_with_fallback ~from_codeset:"UTF-8" ~to_codeset:!current.encoding_manual s) + with e -> (prerr_endline ("Error ("^(Printexc.to_string e)^") in transcoding: falling back to UTF-8") ;s) + in + let oc = open_out file_name in + output_string oc s; + close_out oc; + true + with e -> prerr_endline (Printexc.to_string e);false + +let my_stat f = try Some (Unix.stat f) with _ -> None + +let revert_timer = ref None +let disconnect_revert_timer () = match !revert_timer with + | None -> () + | Some id -> GMain.Timeout.remove id; revert_timer := None + +let auto_save_timer = ref None +let disconnect_auto_save_timer () = match !auto_save_timer with + | None -> () + | Some id -> GMain.Timeout.remove id; auto_save_timer := None + +let highlight_timer = ref None +let set_highlight_timer f = + match !highlight_timer with + | None -> + revert_timer := + Some (GMain.Timeout.add ~ms:2000 + ~callback:(fun () -> f (); highlight_timer := None; true)) + | Some id -> + GMain.Timeout.remove id; + revert_timer := + Some (GMain.Timeout.add ~ms:2000 + ~callback:(fun () -> f (); highlight_timer := None; true)) + + +(* Get back the standard coq out channels *) +let read_stdout,clear_stdout = + let out_buff = Buffer.create 100 in + Pp_control.std_ft := Format.formatter_of_buffer out_buff; + (fun () -> Format.pp_print_flush !Pp_control.std_ft (); + let r = Buffer.contents out_buff in + Buffer.clear out_buff; r), + (fun () -> + Format.pp_print_flush !Pp_control.std_ft (); Buffer.clear out_buff) + + +let last_dir = ref "" +let select_file ~title ?(dir = last_dir) ?(filename="") () = + let fs = + if Filename.is_relative filename then begin + if !dir <> "" then + let filename = Filename.concat !dir filename in + GWindow.file_selection ~show_fileops:true ~modal:true ~title ~filename () + else + GWindow.file_selection ~show_fileops:true ~modal:true ~title () + end else begin + dir := Filename.dirname filename; + GWindow.file_selection ~show_fileops:true ~modal:true ~title ~filename () + end + in + fs#complete ~filter:""; + ignore (fs#connect#destroy ~callback: GMain.Main.quit); + let file = ref None in + ignore (fs#ok_button#connect#clicked ~callback: + begin fun () -> + file := Some fs#filename; + dir := Filename.dirname fs#filename; + fs#destroy () + end); + ignore (fs # cancel_button # connect#clicked ~callback:fs#destroy); + fs # show (); + GMain.Main.main (); + !file + + +let find_tag_start (tag :GText.tag) (it:GText.iter) = + let it = it#copy in + let tag = Some tag in + while not (it#begins_tag tag) && it#nocopy#backward_char do + () + done; + it +let find_tag_stop (tag :GText.tag) (it:GText.iter) = + let it = it#copy in + let tag = Some tag in + while not (it#ends_tag tag) && it#nocopy#forward_char do + () + done; + it +let find_tag_limits (tag :GText.tag) (it:GText.iter) = + (find_tag_start tag it , find_tag_stop tag it) + +(* explanations ?? *) +let async = + if Sys.os_type <> "Unix" then GtkThread.async else + (fun x -> x) + +let stock_to_widget ?(size=`DIALOG) s = + let img = GMisc.image () + in img#set_stock s; + img#coerce + +let rec print_list print fmt = function + | [] -> () + | [x] -> print fmt x + | x :: r -> print fmt x; print_list print fmt r + + +let run_command f c = + let result = Buffer.create 127 in + let cin,cout,cerr = Unix.open_process_full c (Unix.environment ()) in + let buff = String.make 127 ' ' in + let buffe = String.make 127 ' ' in + let n = ref 0 in + let ne = ref 0 in + + while n:= input cin buff 0 127 ; ne := input cerr buffe 0 127 ; + !n+ !ne <> 0 + do + let r = try_convert (String.sub buff 0 !n) in + f r; + Buffer.add_string result r; + let r = try_convert (String.sub buffe 0 !ne) in + f r; + Buffer.add_string result r + done; + (Unix.close_process_full (cin,cout,cerr), Buffer.contents result) + +let browse f url = + let l,r = !current.cmd_browse in + let (s,res) = run_command f (l ^ url ^ r) in + () + +let url_for_keyword = + let ht = Hashtbl.create 97 in + begin try + let cin = open_in (Filename.concat lib_ide "index_urls.txt") in + try while true do + let s = input_line cin in + try + let i = String.index s ',' in + let k = String.sub s 0 i in + let u = String.sub s (i + 1) (String.length s - i - 1) in + Hashtbl.add ht k u + with _ -> + () + done with End_of_file -> + close_in cin + with _ -> + () + end; + (Hashtbl.find ht : string -> string) + + +let browse_keyword f text = + try let u = url_for_keyword text in browse f (!current.doc_url ^ u) + with _ -> () + + +let underscore = Glib.Utf8.to_unichar "_" (ref 0) + +let arobase = Glib.Utf8.to_unichar "@" (ref 0) +let prime = Glib.Utf8.to_unichar "'" (ref 0) +let bn = Glib.Utf8.to_unichar "\n" (ref 0) +let space = Glib.Utf8.to_unichar " " (ref 0) +let tab = Glib.Utf8.to_unichar "\t" (ref 0) + + +(* + checks if two file names refer to the same (existing) file +*) + +let same_file f1 f2 = + try + let s1 = Unix.stat f1 + and s2 = Unix.stat f2 + in + (s1.Unix.st_dev = s2.Unix.st_dev) && + (s1.Unix.st_ino = s2.Unix.st_ino) + with + Unix.Unix_error _ -> false + +let absolute_filename f = + if Filename.is_relative f then + Filename.concat (Sys.getcwd ()) f + else f + diff --git a/ide/ideutils.mli b/ide/ideutils.mli new file mode 100644 index 00000000..7c225e0e --- /dev/null +++ b/ide/ideutils.mli @@ -0,0 +1,79 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* unit) -> 'a -> unit +val browse : (string -> unit) -> string -> unit +val browse_keyword : (string -> unit) -> string -> unit +val byte_offset_to_char_offset : string -> int -> int +val clear_stdout : unit -> unit +val debug : bool ref +val disconnect_revert_timer : unit -> unit +val disconnect_auto_save_timer : unit -> unit +val do_convert : string -> string +val find_tag_limits : GText.tag -> GText.iter -> GText.iter * GText.iter +val find_tag_start : GText.tag -> GText.iter -> GText.iter +val find_tag_stop : GText.tag -> GText.iter -> GText.iter +val get_insert : < get_iter_at_mark : [> `INSERT] -> 'a; .. > -> 'a + +val is_char_start : char -> bool + +val lib_ide : string +val my_stat : string -> Unix.stats option + +val prerr_endline : string -> unit +val prerr_string : string -> unit +val print_id : 'a -> unit + +val process_pending : unit -> unit +val read_stdout : unit -> string +val revert_timer : GMain.Timeout.id option ref +val auto_save_timer : GMain.Timeout.id option ref +val select_file : + title:string -> + ?dir:string ref -> ?filename:string -> unit -> string option +val set_highlight_timer : (unit -> 'a) -> unit +val try_convert : string -> string +val try_export : string -> string -> bool +val stock_to_widget : ?size:Gtk.Tags.icon_size -> GtkStock.id -> GObj.widget + +open Format +val print_list : (formatter -> 'a -> unit) -> formatter -> 'a list -> unit + +val run_command : (string -> unit) -> string -> Unix.process_status*string + + +val prime : Glib.unichar +val underscore : Glib.unichar +val arobase : Glib.unichar +val bn : Glib.unichar +val space : Glib.unichar +val tab : Glib.unichar + + +val status : GMisc.statusbar option ref +val push_info : (string -> unit) ref +val pop_info : (unit -> unit) ref +val flash_info : (?delay:int -> string -> unit) ref + +val set_location : (string -> unit) ref + +val pulse : (unit -> unit) ref + + +(* + checks if two file names refer to the same (existing) file +*) + +val same_file : string -> string -> bool + +(* + returns an absolute filename equivalent to given filename +*) +val absolute_filename : string -> string diff --git a/ide/index_urls.txt b/ide/index_urls.txt new file mode 100644 index 00000000..fea61809 --- /dev/null +++ b/ide/index_urls.txt @@ -0,0 +1,563 @@ ++,node.0.2.0.html#@default146 +-,node.0.2.1.html#@default247 +2,node.1.2.9.html#@default514 +;,node.1.2.12.html#@default547 +?,node.1.0.6.html#@default358 +?,node.1.2.1.html#@default410 +&,node.0.2.0.html#@default164 +{A}+{B},node.0.2.0.html#@default174 +{x:A & (P x)},node.0.2.0.html#@default163 +{x:A | (P x)},node.0.2.0.html#@default157 +|,node.0.2.0.html#@default158 +A*B,node.0.2.0.html#@default150 +A+{B},node.0.2.0.html#@default178 +A+B,node.0.2.0.html#@default145 +Abort,node.1.1.0.html#@default385 +Absolute names,node.0.1.6.html#@default85 +Abstract,node.1.2.12.html#@default559 +Absurd,node.1.2.3.html#@default442 +Acc,node.0.2.0.html#@default215 +Acc_inv,node.0.2.0.html#@default216 +Acc_rec,node.0.2.0.html#@default217 +Add Abstract Ring,node.3.7.4.html#@default643 +Add Abstract Semi Ring,node.3.7.4.html#@default644 +Add Field,node.1.2.10.html#@default526 +Add LoadPath,node.1.0.4.html#@default338 +Add ML Path,node.1.0.4.html#@default342 +Add Morphism,node.3.8.2.html#@default647 +Add Printing If,node.0.1.1.html#@default67 +Add Printing Let,node.0.1.1.html#@default63 +Add Rec LoadPath,node.1.0.4.html#@default339 +Add Rec ML Path,node.1.0.4.html#@default343 +Add Ring,node.1.2.10.html#@default523 +Add Semi Ring,node.1.2.10.html#@default524 +Add Setoid,node.3.8.1.html#@default646 +All,node.0.2.0.html#@default110 +AllT,node.0.2.0.html#@default224 +Apply,node.1.2.2.html#@default427 +Apply ... with,node.1.2.2.html#@default428 +Arithmetical notations,node.0.2.1.html#@default244 +Arity,node.0.3.4.html#@default288 +Assert,node.1.2.2.html#@default433 +Associativity,node.2.0.1.html#@default571 +Assumption,node.1.2.2.html#@default412 +Auto,node.1.2.10.html#@default515 +AutoRewrite,node.1.2.10.html#@default528 +Axiom,node.0.0.2.html#@default24 +abstractions,node.0.0.1.html#@default16 +absurd,node.0.2.0.html#@default121 +absurd_set,node.0.2.0.html#@default188 +all,node.0.2.0.html#@default109 +allT,node.0.2.0.html#@default223 +and,node.0.2.0.html#@default99 +and_rec,node.0.2.0.html#@default189 +applications,node.0.0.1.html#@default18 +Back,node.1.0.5.html#@default348 +Bad Magic Number,node.1.0.3.html#@default331 +Begin Silent,node.1.0.7.html#@default366 +Binding list,node.1.2.2.html#@default441 +beta-reduction,node.0.3.2.html#@default274 +bool,node.0.2.0.html#@default135 +bool_choice,node.0.2.0.html#@default181 +byte-code,node.3.0.0.html#@default574 +Calculus of (Co)Inductive Constructions,node.0.3.html#@default255 +Canonical Structure,node.0.1.7.html#@default91 +Case,node.1.2.6.html#@default468 +Case ... with,node.1.2.6.html#@default469 +Cases,node.3.2.html#@default593 +Cases...of...end,node.0.0.1.html#@default21 +Cbv,node.1.2.4.html#@default445 +Cd,node.1.0.4.html#@default337 +Change,node.1.2.2.html#@default438 +Change ... in,node.1.2.2.html#@default440 +Chapter,node.0.1.3.html#@default73 +Check,node.1.0.1.html#@default308 +Choice,node.0.2.0.html#@default179 +Choice2,node.0.2.0.html#@default180 +CIC,node.0.3.html#@default254 +Clear,node.1.2.2.html#@default414 +ClearBody,node.1.2.2.html#@default415 +Coercion,node.3.3.5.html#@default601 +Coercion Local,node.3.3.5.html#@default602 +Coercions,node.0.1.8.html#@default92 +and sections,node.3.3.9.html#@default616 +classes,node.3.3.1.html#@default596 +FUNCLASS,node.3.3.2.html#@default597 +identity,node.3.3.3.html#@default599 +inheritance graph,node.3.3.4.html#@default600 +presentation,node.3.3.html#@default595 +SORTCLASS,node.3.3.2.html#@default598 +CoFixpoint,node.0.0.2.html#@default40 +CoInductive,node.0.0.2.html#@default38 +Comments,node.0.0.0.html#@default2 +Compare,node.1.2.8.html#@default489 +Compiled files,node.1.0.3.html#@default327 +Compute,node.1.2.4.html#@default447 +Connectives,node.0.2.0.html#@default94 +Constant,node.0.0.2.html#@default31 +Constructor,node.1.2.5.html#@default455 +Constructor ... with,node.1.2.5.html#@default456 +Context,node.0.3.1.html#@default263 +Contradiction,node.1.2.3.html#@default443 +Contributions,node.0.2.2.html#@default253 +Conversion rules,node.0.3.2.html#@default273 +Conversion tactics,node.1.2.4.html#@default444 +coqdep,node.3.1.1.html#@default582 +coq_Makefile,node.3.1.2.html#@default584 +coqmktop,node.3.1.0.html#@default579 +coq-tex,node.3.1.3.html#@default586 +coqweb,node.3.1.3.html#@default587 +Correctness,node.3.5.html#@default619 +Cut,node.1.2.2.html#@default434 +CutRewrite,node.1.2.7.html#@default482 +congr_eqT,node.0.2.0.html#@default241 +conj,node.0.2.0.html#@default100 +coqc,node.3.0.html#@default573 +coqtop,node.3.0.html#@default572 +Datatypes,node.0.2.0.html#@default132 +Debugger,node.3.1.0.html#@default580 +Decide Equality,node.1.2.8.html#@default488 +Declarations,node.0.0.2.html#@default23 +Declare ML Module,node.1.0.3.html#@default333 +Decompose,node.1.2.6.html#@default473 +Decompose Record,node.1.2.6.html#@default475 +Decompose Sum,node.1.2.6.html#@default474 +Defined,node.0.0.2.html#@default48 +Definition,node.0.0.2.html#@default33 +Definitions,node.0.0.2.html#@default29 +Dependencies,node.3.1.1.html#@default581 +Dependent Inversion,node.1.2.9.html#@default501 +Dependent Inversion ... with,node.1.2.9.html#@default503 +Dependent Inversion_clear,node.1.2.9.html#@default502 +Dependent Inversion_clear ... with,node.1.2.9.html#@default504 +Dependent Rewrite ->,node.1.2.8.html#@default495 +Dependent Rewrite <-,node.1.2.8.html#@default496 +Derive Dependent Inversion,node.1.2.9.html#@default511 +Derive Dependent Inversion_clear,node.1.2.9.html#@default512 +Derive Inversion,node.1.2.9.html#@default508 +Derive Inversion_clear,node.1.2.9.html#@default509 +Derive Inversion_clear ... with,node.1.2.9.html#@default510 +Destruct,node.1.2.6.html#@default466 +Discriminate,node.1.2.8.html#@default490 +DiscrR,node.0.2.1.html#@default250 +Do,node.1.2.12.html#@default542 +Double Induction,node.1.2.6.html#@default472 +Drop,node.1.0.7.html#@default365 +delta-reduction,node.0.0.2.html#@default30 +EApply,node.1.2.2.html#@default429 +EAuto,node.1.2.10.html#@default517 +Elim ... using,node.1.2.6.html#@default463 +Elim ... with,node.1.2.6.html#@default462 +Singleton elimination,node.0.3.4.html#@default294 +Elimination sorts,node.0.3.4.html#@default291 +ElimType,node.1.2.6.html#@default464 +Emacs,node.3.1.5.html#@default589 +EmptyT,node.0.2.0.html#@default233 +End,node.0.1.3.html#@default74 +End Silent,node.1.0.7.html#@default368 +Environment,node.0.0.2.html#@default32 +Environment variables,node.3.0.3.html#@default577 +Equality,node.0.2.0.html#@default118 +Eval,node.1.0.1.html#@default309 +EX,node.0.2.0.html#@default113 +EXT,node.0.2.0.html#@default229 +Ex,node.0.2.0.html#@default112 +Ex2,node.0.2.0.html#@default116 +Exact,node.1.2.1.html#@default408 +Exc,node.0.2.0.html#@default182 +Except,node.0.2.0.html#@default187 +Exists,node.1.2.5.html#@default458 +Explicitation of implicit arguments,node.0.1.7.html#@default88 +ExT,node.0.2.0.html#@default228 +ExT2,node.0.2.0.html#@default231 +Extensive grammars,node.1.0.6.html#@default362 +Extract Constant,node.3.6.1.html#@default637 +Extract Inductive,node.3.6.1.html#@default638 +Extraction,node.3.6.html#@default623 +Extraction,node.1.0.1.html#@default310 +Extraction Inline,node.3.6.1.html#@default633 +Extraction Language,node.3.6.1.html#@default628 +Extraction Module,node.3.6.0.html#@default626 +Extraction NoInline,node.3.6.1.html#@default634 +eq,node.0.2.0.html#@default119 +eq_add_S,node.0.2.0.html#@default193 +eq_ind_r,node.0.2.0.html#@default126 +eq_rec,node.0.2.0.html#@default186 +eq_rec_r,node.0.2.0.html#@default127 +eq_rect,node.0.2.0.html#@default128 +eq_rect_r,node.0.2.0.html#@default129 +eq_S,node.0.2.0.html#@default190 +eqT,node.0.2.0.html#@default236 +eqT_ind_r,node.0.2.0.html#@default242 +eqT_rec_r,node.0.2.0.html#@default243 +error,node.0.2.0.html#@default184 +ex,node.0.2.0.html#@default111 +ex2,node.0.2.0.html#@default115 +ex_intro,node.0.2.0.html#@default114 +ex_intro2,node.0.2.0.html#@default117 +exist,node.0.2.0.html#@default160 +exist2,node.0.2.0.html#@default162 +existS,node.0.2.0.html#@default166 +existS2,node.0.2.0.html#@default170 +exT,node.0.2.0.html#@default227 +exT2,node.0.2.0.html#@default232 +exT_intro,node.0.2.0.html#@default230 +Fact,node.0.0.2.html#@default44 +Fail,node.1.2.12.html#@default540 +False,node.0.2.0.html#@default97 +False_rec,node.0.2.0.html#@default185 +Field,node.1.2.10.html#@default525 +First,node.1.2.12.html#@default553 +Fix,node.0.3.4.html#@default298 +Fix_F,node.0.2.0.html#@default219 +Fix_F_eq,node.0.2.0.html#@default222 +Fix_F_inv,node.0.2.0.html#@default221 +Fixpoint,node.0.0.2.html#@default39 +Focus,node.1.1.1.html#@default392 +Fold,node.1.2.4.html#@default453 +Fourier,node.1.2.10.html#@default527 +Fst,node.0.2.0.html#@default155 +f_equal,node.0.2.0.html#@default124 +f_equali,node.0.2.0.html#@default130 +false,node.0.2.0.html#@default137 +fix_eq,node.0.2.0.html#@default220 +fst,node.0.2.0.html#@default153 +Gallina,node.0.0.html#@default0 +gallina,node.3.1.6.html#@default591 +Generalize,node.1.2.2.html#@default436 +Generalize Dependent,node.1.2.2.html#@default437 +Global Variable,node.3.5.2.html#@default620 +Goal,node.0.0.2.html#@default50 +Grammar,node.1.0.6.html#@default361 +ge,node.0.2.0.html#@default208 +gen,node.0.2.0.html#@default226 +goal,node.1.2.html#@default405 +gt,node.0.2.0.html#@default209 +Head normal form,node.0.3.2.html#@default286 +Hint,node.1.2.11.html#@default531 +Hint Rewrite,node.1.2.10.html#@default529 +Hints databases,node.1.2.11.html#@default530 +Hints Immediate,node.1.2.11.html#@default533 +Hints Resolve,node.1.2.11.html#@default532 +Hints Unfold,node.1.2.11.html#@default534 +Hnf,node.1.2.4.html#@default449 +HTML,node.3.1.4.html#@default588 +Hypothesis,node.0.0.2.html#@default28 +I,node.0.2.0.html#@default96 +Identity Coercion,node.3.3.5.html#@default605 +Idtac,node.1.2.12.html#@default538 +IF,node.0.2.0.html#@default107 +proof of,node.3.5.html#@default618 +Implicit Arguments Off,node.1.0.6.html#@default355 +Implicit Arguments On,node.1.0.6.html#@default354 +Implicits,node.1.0.6.html#@default356 +Induction,node.1.2.6.html#@default465 +Inductive,node.0.0.2.html#@default36 +Inductive definitions,node.0.0.2.html#@default35 +Infix,node.1.0.6.html#@default363 +Info,node.1.2.12.html#@default557 +Injection,node.1.2.8.html#@default492 +Inspect,node.1.0.0.html#@default305 +Intro,node.1.2.2.html#@default418 +Intro ... after,node.1.2.2.html#@default426 +Intro after,node.1.2.2.html#@default425 +Intros,node.1.2.2.html#@default422 +Intros pattern,node.1.2.6.html#@default471 +Intros until,node.1.2.2.html#@default423 +Intuition,node.1.2.10.html#@default520 +Inversion,node.1.2.9.html#@default497 +Inversion ... in,node.1.2.9.html#@default499 +Inversion ... using,node.1.2.9.html#@default505 +Inversion ... using ... in,node.1.2.9.html#@default506 +Inversion_clear,node.1.2.9.html#@default498 +Inversion_clear ... in,node.1.2.9.html#@default500 +IsSucc,node.0.2.0.html#@default195 +if ... then ... else,node.0.1.1.html#@default55 +iff,node.0.2.0.html#@default106 +implicit arguments,node.0.1.7.html#@default86 +inl,node.0.2.0.html#@default147 +inleft,node.0.2.0.html#@default176 +inr,node.0.2.0.html#@default148 +inright,node.0.2.0.html#@default177 +iota-reduction,node.0.3.2.html#@default275 +LApply,node.1.2.2.html#@default430 +Lazy,node.1.2.4.html#@default446 +Left,node.1.2.5.html#@default459 +Lemma,node.0.0.2.html#@default42 +LetTac,node.1.2.2.html#@default431 +Lexical conventions,node.0.0.0.html#@default1 +Libraries,node.0.1.5.html#@default82 +Load,node.1.0.2.html#@default325 +Load Verbose,node.1.0.2.html#@default326 +Loadpath,node.1.0.4.html#@default335 +Local,node.0.0.2.html#@default34 +Local definitions,node.0.0.1.html#@default19 +Locate,node.1.0.1.html#@default323 +Locate Library,node.1.0.4.html#@default346 +Logical paths,node.0.1.5.html#@default83 +le,node.0.2.0.html#@default204 +le_n,node.0.2.0.html#@default205 +le_S,node.0.2.0.html#@default206 +left,node.0.2.0.html#@default172 +let ... in,node.0.1.1.html#@default56 +let-in,node.0.0.1.html#@default20 +local context,node.1.1.html#@default372 +lt,node.0.2.0.html#@default207 +Makefile,node.3.1.2.html#@default583 +Man pages,node.3.1.7.html#@default592 +ML-like patterns,node.0.1.1.html#@default54 +Module,node.0.1.4.html#@default75 +Module Type,node.0.1.4.html#@default78 +Move,node.1.2.2.html#@default416 +Mutual Inductive,node.0.0.2.html#@default37 +mult,node.0.2.0.html#@default201 +mult_n_O,node.0.2.0.html#@default202 +mult_n_Sm,node.0.2.0.html#@default203 +NewDestruct,node.1.2.6.html#@default467 +NewInduction,node.1.2.6.html#@default461 +None,node.0.2.0.html#@default143 +Normal form,node.0.3.2.html#@default285 +Notation,node.2.0.0.html#@default569 +Notations for real numbers,node.0.2.1.html#@default249 +n_Sn,node.0.2.0.html#@default197 +nat,node.0.2.0.html#@default138 +nat_case,node.0.2.0.html#@default210 +nat_double_ind,node.0.2.0.html#@default211 +native code,node.3.0.0.html#@default575 +not,node.0.2.0.html#@default98 +not_eq_S,node.0.2.0.html#@default194 +notT,node.0.2.0.html#@default235 +O,node.0.2.0.html#@default139 +O_S,node.0.2.0.html#@default196 +Omega,node.1.2.10.html#@default521 +Opaque,node.1.0.1.html#@default311 +Options of the command line,node.3.0.4.html#@default578 +Orelse,node.1.2.12.html#@default544 +option,node.0.2.0.html#@default141 +or,node.0.2.0.html#@default103 +or_introl,node.0.2.0.html#@default104 +or_intror,node.0.2.0.html#@default105 +Parameter,node.0.0.2.html#@default25 +Pattern,node.1.2.4.html#@default454 +Peano's arithmetic notations,node.0.2.1.html#@default248 +Pose,node.1.2.2.html#@default432 +Positivity,node.0.3.4.html#@default287 +Precedences,node.2.0.1.html#@default570 +Pretty printing,node.1.0.6.html#@default360 +Print,node.1.0.0.html#@default302 +Print All,node.1.0.0.html#@default304 +Print Classes,node.3.3.6.html#@default606 +Print Coercion Paths,node.3.3.6.html#@default609 +Print Coercions,node.3.3.6.html#@default607 +Print Extraction Inline,node.3.6.1.html#@default635 +Print Graph,node.3.3.6.html#@default608 +Print Hint,node.1.2.11.html#@default535 +Print HintDb,node.1.2.11.html#@default536 +Print LoadPath,node.1.0.4.html#@default341 +Print ML Modules,node.1.0.3.html#@default334 +Print ML Path,node.1.0.4.html#@default344 +Print Module,node.0.1.4.html#@default80 +Print Module Type,node.0.1.4.html#@default81 +Print Modules,node.1.0.3.html#@default332 +Print Proof,node.1.0.0.html#@default303 +Print Section,node.1.0.0.html#@default306 +Print Table Printing If,node.0.1.1.html#@default70 +Print Table Printing Let,node.0.1.1.html#@default66 +Programming,node.0.2.0.html#@default131 +Prolog,node.1.2.10.html#@default518 +Prompt,node.1.1.html#@default371 +Proof,node.0.0.2.html#@default45 +Proof editing,node.1.1.html#@default370 +Proof General,node.3.1.5.html#@default590 +Proof term,node.1.1.html#@default373 +Prop,node.0.0.1.html#@default11 +Pwd,node.1.0.4.html#@default336 +pair,node.0.2.0.html#@default152 +plus,node.0.2.0.html#@default198 +plus_n_O,node.0.2.0.html#@default199 +plus_n_Sm,node.0.2.0.html#@default200 +pred,node.0.2.0.html#@default191 +pred_Sn,node.0.2.0.html#@default192 +prod,node.0.2.0.html#@default149 +products,node.0.0.1.html#@default17 +proj1,node.0.2.0.html#@default101 +proj2,node.0.2.0.html#@default102 +projS1,node.0.2.0.html#@default167 +projS2,node.0.2.0.html#@default168 +Qed,node.0.0.2.html#@default47 +Qualified identifiers,node.0.1.6.html#@default84 +Quantifiers,node.0.2.0.html#@default108 +Quit,node.1.0.7.html#@default364 +Quote,node.1.2.9.html#@default513 +?,node.0.1.7.html#@default90 +Read Module,node.1.0.3.html#@default328 +Record,node.0.1.0.html#@default52 +Recursion,node.0.2.0.html#@default213 +Recursive arguments,node.0.3.4.html#@default300 +Recursive Extraction,node.3.6.0.html#@default625 +Recursive Extraction Module,node.3.6.0.html#@default627 +Red,node.1.2.4.html#@default448 +Refine,node.1.2.1.html#@default409 +Reflexivity,node.1.2.7.html#@default484 +Remark,node.0.0.2.html#@default43 +Remove LoadPath,node.1.0.4.html#@default340 +Remove Printing If,node.0.1.1.html#@default68 +Remove Printing Let,node.0.1.1.html#@default64 +Rename,node.1.2.2.html#@default417 +Replace ... with,node.1.2.7.html#@default483 +Require,node.1.0.3.html#@default329 +Require Export,node.1.0.3.html#@default330 +Reset,node.1.0.5.html#@default347 +Reset Extraction Inline,node.3.6.1.html#@default636 +Reset Initial,node.1.0.5.html#@default350 +Resource file,node.3.0.2.html#@default576 +Restart,node.1.1.1.html#@default391 +Restore State,node.1.0.5.html#@default349 +Resume,node.1.1.0.html#@default387 +Rewrite,node.1.2.7.html#@default476 +Rewrite ->,node.1.2.7.html#@default477 +Rewrite -> ... in,node.1.2.7.html#@default480 +Rewrite <-,node.1.2.7.html#@default478 +Rewrite <- ... in,node.1.2.7.html#@default481 +Rewrite ... in,node.1.2.7.html#@default479 +Right,node.1.2.5.html#@default460 +Ring,node.1.2.10.html#@default522 +refl_eqT,node.0.2.0.html#@default237 +refl_equal,node.0.2.0.html#@default120 +right,node.0.2.0.html#@default173 +S,node.0.2.0.html#@default140 +Save,node.0.0.2.html#@default49 +Scheme,node.1.2.13.html#@default561 +Script file,node.1.0.2.html#@default324 +Search,node.1.0.1.html#@default313 +Search ... inside ...,node.1.0.1.html#@default317 +Search ... outside ...,node.1.0.1.html#@default320 +SearchAbout,node.1.0.1.html#@default314 +SearchPattern,node.1.0.1.html#@default315 +SearchPattern ... outside ...,node.1.0.1.html#@default321 +SearchRewrite,node.1.0.1.html#@default316 +SearchRewrite ... inside ...,node.1.0.1.html#@default319 +SearchRewrite ... outside ...,node.1.0.1.html#@default322 +Section,node.0.1.3.html#@default72 +Sections,node.0.1.3.html#@default71 +Set,node.0.0.1.html#@default10 +Set Extraction AutoInline,node.3.6.1.html#@default631 +Set Extraction Optimize,#@default629 +Set Hyps_limit,node.1.1.2.html#@default402 +Set Implicit Arguments,node.0.1.7.html#@default87 +Set Printing Coercion,node.3.3.7.html#@default612 +Set Printing Coercions,node.3.3.7.html#@default610 +Set Printing Synth,node.0.1.1.html#@default60 +Set Printing Wildcard,node.0.1.1.html#@default57 +Set Undo,node.1.1.1.html#@default389 +Setoid_replace,node.3.8.html#@default645 +Setoid_rewrite,node.3.8.3.html#@default649 +Show,node.1.1.2.html#@default394 +Show Conjectures,node.1.1.2.html#@default399 +Show Implicits,node.1.1.2.html#@default395 +Show Intro,node.1.1.2.html#@default400 +Show Intros,node.1.1.2.html#@default401 +Show Programs,node.3.5.2.html#@default621 +Show Proof,node.1.1.2.html#@default398 +Show Script,node.1.1.2.html#@default396 +Show Tree,node.1.1.2.html#@default397 +Silent mode,node.1.0.7.html#@default367 +Simpl,node.1.2.4.html#@default450 +Simple Inversion,node.1.2.9.html#@default507 +Simplify_eq,node.1.2.8.html#@default494 +Small inductive type,node.0.3.4.html#@default292 +Snd,node.0.2.0.html#@default156 +Solve,node.1.2.12.html#@default555 +Some,node.0.2.0.html#@default142 +Sorts,node.0.0.1.html#@default8 +Split,node.1.2.5.html#@default457 +SplitAbsolu,node.0.2.1.html#@default251 +SplitRmult,node.0.2.1.html#@default252 +Strong elimination,node.0.3.4.html#@default293 +Structure,node.3.3.8.html#@default615 +Subst,node.1.2.7.html#@default487 +Substitution,node.0.3.0.html#@default262 +Suspend,node.1.1.0.html#@default386 +Symmetry,node.1.2.7.html#@default485 +Syntactic Definition,node.0.1.7.html#@default89 +Syntax,node.1.0.6.html#@default359 +sig,node.0.2.0.html#@default159 +sig2,node.0.2.0.html#@default161 +sigS,node.0.2.0.html#@default165 +sigS2,node.0.2.0.html#@default169 +snd,node.0.2.0.html#@default154 +sort,node.0.0.1.html#@default7 +specif,node.0.0.1.html#@default14 +subgoal,node.1.2.html#@default406 +sum,node.0.2.0.html#@default144 +sum_eqT,node.0.2.0.html#@default238 +sumbool,node.0.2.0.html#@default171 +sumor,node.0.2.0.html#@default175 +sym_eq,node.0.2.0.html#@default122 +sym_not_eq,node.0.2.0.html#@default125 +sym_not_eqT,node.0.2.0.html#@default239 +Tactic Definition,node.1.2.14.html#@default563 +Tacticals,node.1.2.12.html#@default537 +Do,node.1.2.12.html#@default543 +Fail,node.1.2.12.html#@default541 +First,node.1.2.12.html#@default554 +Solve,node.1.2.12.html#@default556 +Idtac,node.1.2.12.html#@default539 +Info,node.1.2.12.html#@default558 +Orelse,node.1.2.12.html#@default545 +Repeat,node.1.2.12.html#@default546 +Try,node.1.2.12.html#@default552 +Tactics,node.1.2.html#@default404 +Tauto,node.1.2.10.html#@default519 +Terms,node.0.0.1.html#@default5 +Test Printing If,node.0.1.1.html#@default69 +Test Printing Let,node.0.1.1.html#@default65 +Test Printing Synth,node.0.1.1.html#@default62 +Test Printing Wildcard,node.0.1.1.html#@default59 +Theorem,node.0.0.2.html#@default41 +Theories,node.0.2.html#@default93 +Time,node.1.0.7.html#@default369 +Transitivity,node.1.2.7.html#@default486 +Transparent,node.1.0.1.html#@default312 +Trivial,node.1.2.10.html#@default516 +True,node.0.2.0.html#@default95 +Try,node.1.2.12.html#@default551 +Type,node.0.0.1.html#@default9 +Type of constructor,node.0.3.4.html#@default289 +Typing rules,node.0.3.1.html#@default265 +Ax,node.0.3.1.html#@default266 +Cases,node.0.3.4.html#@default296 +Const,node.0.3.1.html#@default268 +Conv,node.0.3.2.html#@default282 +Fix,node.0.3.4.html#@default299 +Lam,node.0.3.1.html#@default270 +Let,node.0.3.1.html#@default272 +Prod,node.0.3.1.html#@default269 +Var,node.0.3.1.html#@default267 +tactic macros,node.1.2.14.html#@default562 +trans_eq,node.0.2.0.html#@default123 +trans_eqT,node.0.2.0.html#@default240 +true,node.0.2.0.html#@default136 +tt,node.0.2.0.html#@default134 +Undo,node.1.1.1.html#@default388 +Unfocus,node.1.1.1.html#@default393 +Unfold,node.1.2.4.html#@default451 +Unfold ... in,node.1.2.4.html#@default452 +UnitT,node.0.2.0.html#@default234 +Unset Extraction AutoInline,node.3.6.1.html#@default632 +Unset Extraction Optimize,#@default630 +Unset Hyps_limit,node.1.1.2.html#@default403 +Unset Implicit Arguments,node.1.0.6.html#@default353 +Unset Printing Coercion,node.3.3.7.html#@default613 +Unset Printing Coercions,node.3.3.7.html#@default611 +Unset Printing Synth,node.0.1.1.html#@default61 +Unset Printing Wildcard,node.0.1.1.html#@default58 +Unset Undo,node.1.1.1.html#@default390 +unit,node.0.2.0.html#@default133 +Variable,node.0.0.2.html#@default26 +Variables,node.0.0.2.html#@default27 +value,node.0.2.0.html#@default183 +Well founded induction,node.0.2.0.html#@default214 +Well foundedness,node.0.2.0.html#@default212 +Write State,node.1.0.5.html#@default351 +well_founded,node.0.2.0.html#@default218 diff --git a/ide/preferences.ml b/ide/preferences.ml new file mode 100644 index 00000000..8743b99b --- /dev/null +++ b/ide/preferences.ml @@ -0,0 +1,540 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* "MOD1" + | `MOD2 -> "MOD2" + | `MOD3 -> "MOD3" + | `MOD4 -> "MOD4" + | `MOD5 -> "MOD5" + | `BUTTON1 -> "BUTTON1" + | `BUTTON2 -> "BUTTON2" + | `BUTTON3 -> "BUTTON3" + | `BUTTON4 -> "BUTTON4" + | `BUTTON5 -> "BUTTON5" + | `CONTROL -> "CONTROL" + | `LOCK -> "LOCK" + | `SHIFT -> "SHIFT" + +let (str_to_mod:string -> Gdk.Tags.modifier) = + function + | "MOD1" -> `MOD1 + | "MOD2" -> `MOD2 + | "MOD3" -> `MOD3 + | "MOD4" -> `MOD4 + | "MOD5" -> `MOD5 + | "BUTTON1" -> `BUTTON1 + | "BUTTON2" -> `BUTTON2 + | "BUTTON3" -> `BUTTON3 + | "BUTTON4" -> `BUTTON4 + | "BUTTON5" -> `BUTTON5 + | "CONTROL" -> `CONTROL + | "LOCK" -> `LOCK + | "SHIFT" -> `SHIFT + | s -> `MOD1 + +type pref = + { + mutable cmd_coqc : string; + mutable cmd_make : string; + mutable cmd_coqmakefile : string; + mutable cmd_coqdoc : string; + + mutable global_auto_revert : bool; + mutable global_auto_revert_delay : int; + + mutable auto_save : bool; + mutable auto_save_delay : int; + mutable auto_save_name : string * string; + + mutable encoding_use_locale : bool; + mutable encoding_use_utf8 : bool; + mutable encoding_manual : string; + + mutable automatic_tactics : string list; + mutable cmd_print : string; + + mutable modifier_for_navigation : Gdk.Tags.modifier list; + mutable modifier_for_templates : Gdk.Tags.modifier list; + mutable modifier_for_tactics : Gdk.Tags.modifier list; + mutable modifiers_valid : Gdk.Tags.modifier list; + + mutable cmd_browse : string * string; + mutable cmd_editor : string * string; + + mutable text_font : Pango.font_description; + + mutable doc_url : string; + mutable library_url : string; + + mutable show_toolbar : bool; + mutable contextual_menus_on_goal : bool; + mutable window_width : int; + mutable window_height :int; + mutable query_window_width : int; + mutable query_window_height : int; +(* + mutable use_utf8_notation : bool; +*) + mutable auto_complete : bool; + } + +let (current:pref ref) = + ref { + cmd_coqc = "coqc"; + cmd_make = "make"; + cmd_coqmakefile = "coq_makefile -o makefile *.v"; + cmd_coqdoc = "coqdoc -q -g"; + cmd_print = "lpr"; + + global_auto_revert = false; + global_auto_revert_delay = 10000; + + auto_save = false; + auto_save_delay = 10000; + auto_save_name = "#","#"; + + encoding_use_locale = true; + encoding_use_utf8 = false; + encoding_manual = "ISO_8859-1"; + + automatic_tactics = ["trivial"; "tauto"; "auto"; "omega"; + "auto with *"; "intuition" ]; + + modifier_for_navigation = [`CONTROL; `MOD1]; + modifier_for_templates = [`MOD4]; + modifier_for_tactics = [`CONTROL; `MOD1]; + modifiers_valid = [`SHIFT; `CONTROL; `MOD1; `MOD4]; + + + cmd_browse = + if Sys.os_type = "Win32" + then "C:\\PROGRA~1\\INTERN~1\\IEXPLORE ", "" + else "netscape -remote \"OpenURL(", ")\""; + cmd_editor = + if Sys.os_type = "Win32" + then "NOTEPAD ", "" + else "emacs ", ""; + + text_font = Pango.Font.from_string "sans 12"; + + doc_url = "http://coq.inria.fr/doc/"; + library_url = "http://coq.inria.fr/library/"; + + show_toolbar = true; + contextual_menus_on_goal = true; + window_width = 800; + window_height = 600; + query_window_width = 600; + query_window_height = 400; +(* + use_utf8_notation = false; +*) + auto_complete = false + } + + +let change_font = ref (fun f -> ()) + +let show_toolbar = ref (fun x -> ()) + +let auto_complete = ref (fun x -> ()) + +let contextual_menus_on_goal = ref (fun x -> ()) + +let resize_window = ref (fun () -> ()) + +let save_pref () = + (try GtkData.AccelMap.save accel_file + with _ -> ()); + let p = !current in + try + let add = Stringmap.add in + let (++) x f = f x in + Stringmap.empty ++ + add "cmd_coqc" [p.cmd_coqc] ++ + add "cmd_make" [p.cmd_make] ++ + add "cmd_coqmakefile" [p.cmd_coqmakefile] ++ + add "cmd_coqdoc" [p.cmd_coqdoc] ++ + add "global_auto_revert" [string_of_bool p.global_auto_revert] ++ + add "global_auto_revert_delay" + [string_of_int p.global_auto_revert_delay] ++ + add "auto_save" [string_of_bool p.auto_save] ++ + add "auto_save_delay" [string_of_int p.auto_save_delay] ++ + add "auto_save_name" [fst p.auto_save_name; snd p.auto_save_name] ++ + + add "encoding_use_locale" [string_of_bool p.encoding_use_locale] ++ + add "encoding_use_utf8" [string_of_bool p.encoding_use_utf8] ++ + add "encoding_manual" [p.encoding_manual] ++ + + add "automatic_tactics" + (List.rev p.automatic_tactics) ++ + add "cmd_print" [p.cmd_print] ++ + add "modifier_for_navigation" + (List.map mod_to_str p.modifier_for_navigation) ++ + add "modifier_for_templates" + (List.map mod_to_str p.modifier_for_templates) ++ + add "modifier_for_tactics" + (List.map mod_to_str p.modifier_for_tactics) ++ + add "modifiers_valid" + (List.map mod_to_str p.modifiers_valid) ++ + add "cmd_browse" [fst p.cmd_browse; snd p.cmd_browse] ++ + add "cmd_editor" [fst p.cmd_editor; snd p.cmd_editor] ++ + + add "text_font" [Pango.Font.to_string p.text_font] ++ + + add "doc_url" [p.doc_url] ++ + add "library_url" [p.library_url] ++ + add "show_toolbar" [string_of_bool p.show_toolbar] ++ + add "contextual_menus_on_goal" + [string_of_bool p.contextual_menus_on_goal] ++ + add "window_height" [string_of_int p.window_height] ++ + add "window_width" [string_of_int p.window_width] ++ + add "query_window_height" [string_of_int p.query_window_height] ++ + add "query_window_width" [string_of_int p.query_window_width] ++ + add "auto_complete" [string_of_bool p.auto_complete] ++ + Config_lexer.print_file pref_file + with _ -> prerr_endline "Could not save preferences." + + +let load_pref () = + (try GtkData.AccelMap.load accel_file with _ -> ()); + let p = !current in + try + let m = Config_lexer.load_file pref_file in + let np = { p with cmd_coqc = p.cmd_coqc } in + let set k f = try let v = Stringmap.find k m in f v with _ -> () in + let set_hd k f = set k (fun v -> f (List.hd v)) in + let set_bool k f = set_hd k (fun v -> f (bool_of_string v)) in + let set_int k f = set_hd k (fun v -> f (int_of_string v)) in + let set_pair k f = set k (function [v1;v2] -> f v1 v2 | _ -> raise Exit) in + set_hd "cmd_coqc" (fun v -> np.cmd_coqc <- v); + set_hd "cmd_make" (fun v -> np.cmd_make <- v); + set_hd "cmd_coqmakefile" (fun v -> np.cmd_coqmakefile <- v); + set_hd "cmd_coqdoc" (fun v -> np.cmd_coqdoc <- v); + set_bool "global_auto_revert" (fun v -> np.global_auto_revert <- v); + set_int "global_auto_revert_delay" + (fun v -> np.global_auto_revert_delay <- v); + set_bool "auto_save" (fun v -> np.auto_save <- v); + set_int "auto_save_delay" (fun v -> np.auto_save_delay <- v); + set_pair "auto_save_name" (fun v1 v2 -> np.auto_save_name <- (v1,v2)); + set_bool "encoding_use_locale" (fun v -> np.encoding_use_locale <- v); + set_bool "encoding_use_utf8" (fun v -> np.encoding_use_utf8 <- v); + set_hd "encoding_manual" (fun v -> np.encoding_manual <- v); + set "automatic_tactics" + (fun v -> np.automatic_tactics <- v); + set_hd "cmd_print" (fun v -> np.cmd_print <- v); + set "modifier_for_navigation" + (fun v -> np.modifier_for_navigation <- List.map str_to_mod v); + set "modifier_for_templates" + (fun v -> np.modifier_for_templates <- List.map str_to_mod v); + set "modifier_for_tactics" + (fun v -> np.modifier_for_tactics <- List.map str_to_mod v); + set "modifiers_valid" + (fun v -> np.modifiers_valid <- List.map str_to_mod v); + set_pair "cmd_browse" (fun v1 v2 -> np.cmd_browse <- (v1,v2)); + set_pair "cmd_editor" (fun v1 v2 -> np.cmd_editor <- (v1,v2)); + set_hd "text_font" (fun v -> np.text_font <- Pango.Font.from_string v); + set_hd "doc_url" (fun v -> np.doc_url <- v); + set_hd "library_url" (fun v -> np.library_url <- v); + set_bool "show_toolbar" (fun v -> np.show_toolbar <- v); + set_bool "contextual_menus_on_goal" + (fun v -> np.contextual_menus_on_goal <- v); + set_int "window_width" (fun v -> np.window_width <- v); + set_int "window_height" (fun v -> np.window_height <- v); + set_int "query_window_width" (fun v -> np.query_window_width <- v); + set_int "query_window_height" (fun v -> np.query_window_height <- v); + set_bool "auto_complete" (fun v -> np.auto_complete <- v); + current := np; +(* + Format.printf "in laod_pref: current.text_font = %s@." (Pango.Font.to_string !current.text_font); +*) + with e -> + prerr_endline ("Could not load preferences ("^ + (Printexc.to_string e)^").") + + +let configure () = + let cmd_coqc = + string + ~f:(fun s -> !current.cmd_coqc <- s) + " coqc" !current.cmd_coqc in + let cmd_make = + string + ~f:(fun s -> !current.cmd_make <- s) + " make" !current.cmd_make in + let cmd_coqmakefile = + string + ~f:(fun s -> !current.cmd_coqmakefile <- s) + "coqmakefile" !current.cmd_coqmakefile in + let cmd_coqdoc = + string + ~f:(fun s -> !current.cmd_coqdoc <- s) + " coqdoc" !current.cmd_coqdoc in + let cmd_print = + string + ~f:(fun s -> !current.cmd_print <- s) + " Print ps" !current.cmd_print in + + let config_font = + let box = GPack.hbox () in + let w = GMisc.font_selection () in + w#set_preview_text + "Goal (∃n : nat, n ≤ 0)∧(∀x,y,z, x∈y⋃z↔x∈y∨x∈z)."; + box#pack w#coerce; + ignore (w#misc#connect#realize + ~callback:(fun () -> w#set_font_name + (Pango.Font.to_string !current.text_font))); + custom + ~label:"Fonts for text" + box + (fun () -> + let fd = w#font_name in + !current.text_font <- (Pango.Font.from_string fd) ; +(* + Format.printf "in config_font: current.text_font = %s@." (Pango.Font.to_string !current.text_font); +*) + !change_font !current.text_font) + true + in +(* + let show_toolbar = + bool + ~f:(fun s -> + !current.show_toolbar <- s; + !show_toolbar s) + "Show toolbar" !current.show_toolbar + in + let window_height = + string + ~f:(fun s -> !current.window_height <- (try int_of_string s with _ -> 600); + !resize_window (); + ) + "Window height" + (string_of_int !current.window_height) + in + let window_width = + string + ~f:(fun s -> !current.window_width <- + (try int_of_string s with _ -> 800)) + "Window width" + (string_of_int !current.window_width) + in +*) + let auto_complete = + bool + ~f:(fun s -> + !current.auto_complete <- s; + !auto_complete s) + "Auto Complete" !current.auto_complete + in + +(* let use_utf8_notation = + bool + ~f:(fun b -> + !current.use_utf8_notation <- b; + ) + "Use Unicode Notation: " !current.use_utf8_notation + in +*) +(* + let config_appearance = [show_toolbar; window_width; window_height] in +*) + let global_auto_revert = + bool + ~f:(fun s -> !current.global_auto_revert <- s) + "Enable global auto revert" !current.global_auto_revert + in + let global_auto_revert_delay = + string + ~f:(fun s -> !current.global_auto_revert_delay <- + (try int_of_string s with _ -> 10000)) + "Global auto revert delay (ms)" + (string_of_int !current.global_auto_revert_delay) + in + + let auto_save = + bool + ~f:(fun s -> !current.auto_save <- s) + "Enable auto save" !current.auto_save + in + let auto_save_delay = + string + ~f:(fun s -> !current.auto_save_delay <- + (try int_of_string s with _ -> 10000)) + "Auto save delay (ms)" + (string_of_int !current.auto_save_delay) + in + + let encodings = + combo + "File charset encoding " + ~f:(fun s -> + match s with + | "UTF-8" -> + !current.encoding_use_utf8 <- true; + !current.encoding_use_locale <- false + | "LOCALE" -> + !current.encoding_use_utf8 <- false; + !current.encoding_use_locale <- true + | _ -> + !current.encoding_use_utf8 <- false; + !current.encoding_use_locale <- false; + !current.encoding_manual <- s; + ) + ~new_allowed: true + ["UTF-8";"LOCALE";!current.encoding_manual] + (if !current.encoding_use_utf8 then "UTF-8" + else if !current.encoding_use_locale then "LOCALE" else !current.encoding_manual) + in + let modifier_for_tactics = + modifiers + ~allow:!current.modifiers_valid + ~f:(fun l -> !current.modifier_for_tactics <- l) + "Modifiers for Tactics Menu" + !current.modifier_for_tactics + in + let modifier_for_templates = + modifiers + ~allow:!current.modifiers_valid + ~f:(fun l -> !current.modifier_for_templates <- l) + "Modifiers for Templates Menu" + !current.modifier_for_templates + in + let modifier_for_navigation = + modifiers + ~allow:!current.modifiers_valid + ~f:(fun l -> !current.modifier_for_navigation <- l) + "Modifiers for Navigation Menu" + !current.modifier_for_navigation + in + let modifiers_valid = + modifiers + ~f:(fun l -> !current.modifiers_valid <- l) + "Allowed modifiers" + !current.modifiers_valid + in + let mod_msg = + string + "Needs restart to apply!" + ~editable:false + "" + in + + let cmd_editor = + string + ~f:(fun s -> + !current.cmd_editor <- + try + let i = String.index s '%' in + let pre = (String.sub s 0 i) in + if String.length s - 1 = i then + pre,"" + else + let post = String.sub s (i+2) (String.length s - i - 2) in + prerr_endline pre; + prerr_endline post; + pre,post + with Not_found -> s,"" + ) + ~help:"(%s for file name)" + "External editor" + ((fst !current.cmd_editor)^"%s"^(snd !current.cmd_editor)) + in + let cmd_browse = + string + ~f:(fun s -> + !current.cmd_browse <- + try + let i = String.index s '%' in + let pre = (String.sub s 0 i) in + if String.length s - 1 = i then + pre,"" + else + let post = String.sub s (i+2) (String.length s - i - 2) in + prerr_endline pre; + prerr_endline post; + pre,post + with Not_found -> s,"" + ) + ~help:"(%s for url)" + " Browser" + ((fst !current.cmd_browse)^"%s"^(snd !current.cmd_browse)) + in + let doc_url = + string ~f:(fun s -> !current.doc_url <- s) " Manual URL" !current.doc_url in + let library_url = + string ~f:(fun s -> !current.library_url <- s) "Library URL" !current.library_url in + + let automatic_tactics = + strings + ~f:(fun l -> !current.automatic_tactics <- l) + ~add:(fun () -> [""]) + "Wizard tactics to try in order" + !current.automatic_tactics + + in + + let contextual_menus_on_goal = + bool + ~f:(fun s -> + !current.contextual_menus_on_goal <- s; + !contextual_menus_on_goal s) + "Contextual menus on goal" !current.contextual_menus_on_goal + in + + let misc = [contextual_menus_on_goal;auto_complete] in + +(* ATTENTION !!!!! L'onglet Fonts doit etre en premier pour eviter un bug !!!! + (shame on Benjamin) *) + let cmds = + [Section("Fonts", + [config_font]); + Section("Files", + [global_auto_revert;global_auto_revert_delay; + auto_save; auto_save_delay; (* auto_save_name*) + encodings; + ]); +(* + Section("Appearance", + config_appearance); +*) + Section("Externals", + [cmd_coqc;cmd_make;cmd_coqmakefile; cmd_coqdoc; cmd_print; + cmd_editor; + cmd_browse;doc_url;library_url]); + Section("Tactics Wizard", + [automatic_tactics]); + Section("Shortcuts", + [modifiers_valid; modifier_for_tactics; + modifier_for_templates; modifier_for_navigation;mod_msg]); + Section("Misc", + misc)] + in +(* + Format.printf "before edit: current.text_font = %s@." (Pango.Font.to_string !current.text_font); +*) + let x = edit ~width:500 "Customizations" cmds in +(* + Format.printf "after edit: current.text_font = %s@." (Pango.Font.to_string !current.text_font); +*) + match x with + | Return_apply | Return_ok -> save_pref () + | Return_cancel -> () + diff --git a/ide/preferences.mli b/ide/preferences.mli new file mode 100644 index 00000000..b4be283d --- /dev/null +++ b/ide/preferences.mli @@ -0,0 +1,67 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* unit +val load_pref : unit -> unit + +val current : pref ref + +val configure : unit -> unit + +val change_font : ( Pango.font_description -> unit) ref +val show_toolbar : (bool -> unit) ref +val auto_complete : (bool -> unit) ref +val resize_window : (unit -> unit) ref diff --git a/ide/undo.ml b/ide/undo.ml new file mode 100644 index 00000000..54449515 --- /dev/null +++ b/ide/undo.ml @@ -0,0 +1,178 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* Delete (s,i,l) + | Delete (s,i,l) -> Insert (s,i,l) + +class undoable_view (tv:Gtk.text_view Gtk.obj) = + let undo_lock = ref true in +object(self) + inherit GText.view tv as super + val history = (Stack.create () : action Stack.t) + val redo = (Queue.create () : action Queue.t) + val nredo = (Stack.create () : action Stack.t) + + method private dump_debug = + if false (* !debug *) then begin + prerr_endline "==========Stack top============="; + Stack.iter + (fun e -> match e with + | Insert(s,p,l) -> + Printf.eprintf "Insert of '%s' at %d (length %d)\n" s p l + | Delete(s,p,l) -> + Printf.eprintf "Delete '%s' from %d (length %d)\n" s p l) + history; + Printf.eprintf "Stack size %d\n" (Stack.length history); + prerr_endline "==========Stack Bottom=========="; + prerr_endline "==========Queue start============="; + Queue.iter + (fun e -> match e with + | Insert(s,p,l) -> + Printf.eprintf "Insert of '%s' at %d (length %d)\n" s p l + | Delete(s,p,l) -> + Printf.eprintf "Delete '%s' from %d (length %d)\n" s p l) + redo; + Printf.eprintf "Stack size %d\n" (Queue.length redo); + prerr_endline "==========Queue End==========" + + end + + method clear_undo = Stack.clear history; Stack.clear nredo; Queue.clear redo + + method undo = if !undo_lock then begin + undo_lock := false; + prerr_endline "UNDO"; + try begin + let r = + match Stack.pop history with + | Insert(s,p,l) as act -> + let start = self#buffer#get_iter_at_char p in + (self#buffer#delete_interactive + ~start + ~stop:(start#forward_chars l) + ()) or + (Stack.push act history; false) + | Delete(s,p,l) as act -> + let iter = self#buffer#get_iter_at_char p in + (self#buffer#insert_interactive ~iter s) or + (Stack.push act history; false) + in if r then begin + process_pending (); + let act = Stack.pop history in + Queue.push act redo; + Stack.push act nredo + end; + undo_lock := true; + r + end + with Stack.Empty -> + undo_lock := true; + false + end else + (prerr_endline "UNDO DISCARDED"; true) + + method redo = prerr_endline "REDO"; true + initializer +(* INCORRECT: is called even while undoing... + ignore (self#buffer#connect#mark_set + ~callback: + (fun it tm -> if !undo_lock && not (Queue.is_empty redo) then begin + Stack.iter (fun e -> Stack.push (neg e) history) nredo; + Stack.clear nredo; + Queue.iter (fun e -> Stack.push e history) redo; + Queue.clear redo; + end) + ); +*) + ignore (self#buffer#connect#insert_text + ~callback: + (fun it s -> + if !undo_lock && not (Queue.is_empty redo) then begin + Stack.iter (fun e -> Stack.push (neg e) history) nredo; + Stack.clear nredo; + Queue.iter (fun e -> Stack.push e history) redo; + Queue.clear redo; + end; + let pos = it#offset in +(* if Stack.is_empty history or + s=" " or s="\t" or s="\n" or + (match Stack.top history with + | Insert(old,opos,olen) -> + opos + olen <> pos + | _ -> true) + then *) + Stack.push (Insert(s,it#offset,Glib.Utf8.length s)) history + (*else begin + match Stack.pop history with + | Insert(olds,offset,len) -> + Stack.push + (Insert(olds^s, + offset, + len+(Glib.Utf8.length s))) + history + | _ -> assert false + end*); + self#dump_debug + )); + ignore (self#buffer#connect#delete_range + ~callback: + (fun ~start ~stop -> + if !undo_lock && not (Queue.is_empty redo) then begin + Queue.iter (fun e -> Stack.push e history) redo; + Queue.clear redo; + end; + let start_offset = start#offset in + let stop_offset = stop#offset in + let s = self#buffer#get_text ~start ~stop () in +(* if Stack.is_empty history or (match Stack.top history with + | Delete(old,opos,olen) -> + olen=1 or opos <> start_offset + | _ -> true + ) + then +*) Stack.push + (Delete(s, + start_offset, + stop_offset - start_offset + )) + history + (* else begin + match Stack.pop history with + | Delete(olds,offset,len) -> + Stack.push + (Delete(olds^s, + offset, + len+(Glib.Utf8.length s))) + history + | _ -> assert false + + end*); + self#dump_debug + )) +end + +let undoable_view ?(buffer:GText.buffer option) = + GtkText.View.make_params [] + ~cont:(GContainer.pack_container + ~create: + (fun pl -> let w = match buffer with + | None -> GtkText.View.create [] + | Some b -> GtkText.View.create_with_buffer b#as_buffer + in + Gobject.set_params w pl; ((new undoable_view w):undoable_view))) + + diff --git a/ide/undo.mli b/ide/undo.mli new file mode 100644 index 00000000..6c7492ab --- /dev/null +++ b/ide/undo.mli @@ -0,0 +1,35 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* +object + inherit GText.view + method undo : bool + method redo : bool + method clear_undo : unit +end + +val undoable_view : + ?buffer:GText.buffer -> + ?editable:bool -> + ?cursor_visible:bool -> + ?justification:GtkEnums.justification -> + ?wrap_mode:GtkEnums.wrap_mode -> + ?border_width:int -> + ?width:int -> + ?height:int -> + ?packing:(GObj.widget -> unit) -> + ?show:bool -> + unit -> + undoable_view + + diff --git a/ide/utf8.v b/ide/utf8.v new file mode 100644 index 00000000..574f2e65 --- /dev/null +++ b/ide/utf8.v @@ -0,0 +1,56 @@ +(* -*- coding:utf-8 -* *) +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* y) (at level 90, right associativity): type_scope. +Notation "x ↔ y" := (x <-> y) (at level 95, no associativity): type_scope. +Notation "⌉ x" := (~x) (at level 75, right associativity) : type_scope. + + +(* Abstraction *) +(* Not nice +Notation "'λ' x : T , y" := ([x:T] y) (at level 1, x,T,y at level 10). +Notation "'λ' x := T , y" := ([x:=T] y) (at level 1, x,T,y at level 10). +*) + +(* Arithmetic *) +Notation "x ≤ y" := (le x y) (at level 70, no associativity). +Notation "x ≥ y" := (ge x y) (at level 70, no associativity). + +(* test *) +(* +Goal ∀ x, True -> (∃ y , x ≥ y + 1) ∨ x ≤ 0. +*) + +(* Integer Arithmetic *) +(* TODO +Notation "x ≤ y" := (Zle x y) (at level 1, y at level 10). +*) diff --git a/ide/utf8_convert.mll b/ide/utf8_convert.mll new file mode 100644 index 00000000..4c88adc5 --- /dev/null +++ b/ide/utf8_convert.mll @@ -0,0 +1,51 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* s + in + let c = if Glib.Utf8.validate code then code else s in + Buffer.add_string b c; + entry lexbuf + } + | _ + { let s = lexeme lexbuf in + Buffer.add_string b s; + entry lexbuf} + | eof + { + let s = Buffer.contents b in Buffer.reset b ; s + } + + +{ + let f s = + let lb = from_string s in + Buffer.reset b; + entry lb +} diff --git a/ide/utils/configwin.ml b/ide/utils/configwin.ml new file mode 100644 index 00000000..de6a7c57 --- /dev/null +++ b/ide/utils/configwin.ml @@ -0,0 +1,74 @@ +(**************************************************************************) +(* Cameleon *) +(* *) +(* Copyright (C) 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. *) +(* *) +(* This program is free software; you can redistribute it and/or modify *) +(* it under the terms of the GNU General Public License as published by *) +(* the Free Software Foundation; either version 2 of the License, or *) +(* any later version. *) +(* *) +(* This program is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) +(* GNU General Public License for more details. *) +(* *) +(* You should have received a copy of the GNU General Public License *) +(* along with this program; if not, write to the Free Software *) +(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *) +(* 02111-1307 USA *) +(* *) +(* Contact: Maxence.Guesdon@inria.fr *) +(**************************************************************************) + +type parameter_kind = Configwin_types.parameter_kind + +type configuration_structure = + Configwin_types.configuration_structure = + Section of string * parameter_kind list + | Section_list of string * configuration_structure list + +type return_button = + Configwin_types.return_button = + Return_apply + | Return_ok + | Return_cancel + +module KeyOption = Configwin_types.KeyOption + +let string = Configwin_ihm.string +let text = Configwin_ihm.text +let strings = Configwin_ihm.strings +let list = Configwin_ihm.list +let bool = Configwin_ihm.bool +let filename = Configwin_ihm.filename +let filenames = Configwin_ihm.filenames +let color = Configwin_ihm.color +let font = Configwin_ihm.font +let combo = Configwin_ihm.combo +let custom = Configwin_ihm.custom +let date = Configwin_ihm.date +let hotkey = Configwin_ihm.hotkey +let modifiers = Configwin_ihm.modifiers +let html = Configwin_ihm.html + +let edit + ?(apply=(fun () -> ())) + title ?(width=400) ?(height=400) + conf_struct_list = + Configwin_ihm.edit ~with_apply: true ~apply title ~width ~height conf_struct_list + +let get = Configwin_ihm.edit ~with_apply: false ~apply: (fun () -> ()) + +let simple_edit + ?(apply=(fun () -> ())) + title ?width ?height + param_list = Configwin_ihm.simple_edit ~with_apply: true ~apply title ?width ?height param_list + +let simple_get = Configwin_ihm.simple_edit + ~with_apply: false ~apply: (fun () -> ()) + +let box = Configwin_ihm.box + +let tabbed_box = Configwin_ihm.tabbed_box diff --git a/ide/utils/configwin.mli b/ide/utils/configwin.mli new file mode 100644 index 00000000..078befc6 --- /dev/null +++ b/ide/utils/configwin.mli @@ -0,0 +1,300 @@ +(**************************************************************************) +(* Cameleon *) +(* *) +(* Copyright (C) 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. *) +(* *) +(* This program is free software; you can redistribute it and/or modify *) +(* it under the terms of the GNU General Public License as published by *) +(* the Free Software Foundation; either version 2 of the License, or *) +(* any later version. *) +(* *) +(* This program is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) +(* GNU General Public License for more details. *) +(* *) +(* You should have received a copy of the GNU General Public License *) +(* along with this program; if not, write to the Free Software *) +(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *) +(* 02111-1307 USA *) +(* *) +(* Contact: Maxence.Guesdon@inria.fr *) +(**************************************************************************) + +(** This module is the interface of the Configwin library. *) + +(** {2 Types} *) + +(** This type represents the different kinds of parameters. *) +type parameter_kind;; + +(** This type represents the structure of the configuration window. *) +type configuration_structure = + | Section of string * parameter_kind list + (** label of the section, parameters *) + | Section_list of string * configuration_structure list + (** label of the section, list of the sub sections *) +;; + +(** To indicate what button pushed the user when the window is closed. *) +type return_button = + Return_apply + (** The user clicked on Apply at least once before + closing the window with Cancel or the window manager. *) + | Return_ok + (** The user closed the window with the ok button. *) + | Return_cancel + (** The user closed the window with the cancel + button or the window manager but never clicked + on the apply button.*) + + +(** {2 The key option class (to use with the {!Uoptions} library)} *) + +module KeyOption : sig + val string_to_key : string -> (Gdk.Tags.modifier list * int) + val key_to_string : (Gdk.Tags.modifier list * int) -> string + val t : (Gdk.Tags.modifier list * int) Uoptions.option_class +end + +(** {2 Functions to create parameters} *) + +(** [string label value] creates a string parameter. + @param editable indicate if the value is editable (default is [true]). + @param expand indicate if the entry widget must expand or not (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). +*) +val string : ?editable: bool -> ?expand: bool -> ?help: string -> + ?f: (string -> unit) -> string -> string -> parameter_kind + +(** [bool label value] creates a boolean parameter. + @param editable indicate if the value is editable (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). +*) +val bool : ?editable: bool -> ?help: string -> + ?f: (bool -> unit) -> string -> bool -> parameter_kind + +(** [strings label value] creates a string list parameter. + @param editable indicate if the value is editable (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). + @param add the function returning a list of strings when the user wants to add strings + (default returns an empty list). + @param eq the comparison function, used not to have doubles in list. Default + is [Pervasives.(=)]. If you want to allow doubles in the list, give a function + always returning false. +*) +val strings : ?editable: bool -> ?help: string -> + ?f: (string list -> unit) -> + ?eq: (string -> string -> bool) -> + ?add: (unit -> string list) -> + string -> string list -> parameter_kind + +(** [list label f_strings value] creates a list parameter. + [f_strings] is a function taking a value and returning a list + of strings to display it. The list length should be the same for + any value, and the same as the titles list length. The [value] + is the initial list. + @param editable indicate if the value is editable (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). + @param eq the comparison function, used not to have doubles in list. Default + is [Pervasives.(=)]. If you want to allow doubles in the list, give a function + always returning false. + @param edit an optional function to use to edit an element of the list. + The function returns an element, no matter if element was changed or not. + When this function is given, a "Edit" button appears next to the list. + @param add the function returning a list of values when the user wants to add values + (default returns an empty list). + @param titles an optional list of titles for the list. If the [f_strings] + function returns a list with more than one element, then you must give + a list of titles. + @param color an optional function returning the optional color for a given element. + This color is used to display the element in the list. The default function returns + no color for any element. +*) +val list : ?editable: bool -> ?help: string -> + ?f: ('a list -> unit) -> + ?eq: ('a -> 'a -> bool) -> + ?edit: ('a -> 'a) -> + ?add: (unit -> 'a list) -> + ?titles: string list -> + ?color: ('a -> string option) -> + string -> + ('a -> string list) -> + 'a list -> + parameter_kind + +(** [color label value] creates a color parameter. + @param editable indicate if the value is editable (default is [true]). + @param expand indicate if the entry widget must expand or not (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). +*) +val color : ?editable: bool -> ?expand: bool -> ?help: string -> + ?f: (string -> unit) -> string -> string -> parameter_kind + +(** [font label value] creates a font parameter. + @param editable indicate if the value is editable (default is [true]). + @param expand indicate if the entry widget must expand or not (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). +*) +val font : ?editable: bool -> ?expand: bool -> ?help: string -> + ?f: (string -> unit) -> string -> string -> parameter_kind + +(** [combo label choices value] creates a combo parameter. + @param editable indicate if the value is editable (default is [true]). + @param expand indicate if the entry widget must expand or not (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). + @param new_allowed indicate if a entry not in the list of choices is accepted + (default is [false]). + @param blank_allowed indicate if the empty selection [""] is accepted + (default is [false]). +*) +val combo : ?editable: bool -> ?expand: bool -> ?help: string -> + ?f: (string -> unit) -> + ?new_allowed: bool -> ?blank_allowed: bool -> + string -> string list -> string -> parameter_kind + +(** [text label value] creates a text parameter. + @param editable indicate if the value is editable (default is [true]). + @param expand indicate if the box for the text must expand or not (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). +*) +val text : ?editable: bool -> ?expand: bool -> ?help: string -> + ?f: (string -> unit) -> string -> string -> parameter_kind + +(** Same as {!Configwin.text} but html bindings are available + in the text widget. Use the [configwin_html_config] utility + to edit your bindings. +*) +val html : ?editable: bool -> ?expand: bool -> ?help: string -> + ?f: (string -> unit) -> string -> string -> parameter_kind + +(** [filename label value] creates a filename parameter. + @param editable indicate if the value is editable (default is [true]). + @param expand indicate if the entry widget must expand or not (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). +*) +val filename : ?editable: bool -> ?expand: bool -> ?help: string -> + ?f: (string -> unit) -> string -> string -> parameter_kind + +(** [filenames label value] creates a filename list parameter. + @param editable indicate if the value is editable (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). + @param eq the comparison function, used not to have doubles in list. Default + is [Pervasives.(=)]. If you want to allow doubles in the list, give a function + always returning false. +*) +val filenames : ?editable: bool -> ?help: string -> + ?f: (string list -> unit) -> + ?eq: (string -> string -> bool) -> + string -> string list -> parameter_kind + +(** [date label value] creates a date parameter. + @param editable indicate if the value is editable (default is [true]). + @param expand indicate if the entry widget must expand or not (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). + @param f_string the function used to display the date as a string. The parameter + is a tupe [(day,month,year)], where [month] is between [0] and [11]. The default + function creates the string [year/month/day]. +*) +val date : ?editable: bool -> ?expand: bool -> ?help: string -> + ?f: ((int * int * int) -> unit) -> + ?f_string: ((int * int * int -> string)) -> + string -> (int * int * int) -> parameter_kind + +(** [hotkey label value] creates a hot key parameter. + A hot key is defined by a list of modifiers and a key code. + @param editable indicate if the value is editable (default is [true]). + @param expand indicate if the entry widget must expand or not (default is [true]). + @param help an optional help message. + @param f the function called to apply the value (default function does nothing). +*) +val hotkey : ?editable: bool -> ?expand: bool -> ?help: string -> + ?f: ((Gdk.Tags.modifier list * int) -> unit) -> + string -> (Gdk.Tags.modifier list * int) -> parameter_kind + +val modifiers : ?editable: bool -> ?expand: bool -> ?help: string -> + ?allow:(Gdk.Tags.modifier list) -> + ?f: (Gdk.Tags.modifier list -> unit) -> + string -> Gdk.Tags.modifier list -> parameter_kind + + +(** [custom box f expand] creates a custom parameter, with + the given [box], the [f] function is called when the user + wants to apply his changes, and [expand] indicates if the box + must expand in its father. + @param label if a value is specified, a the box is packed into a frame. +*) +val custom : ?label: string -> GPack.box -> (unit -> unit) -> bool -> parameter_kind + +(** {2 Functions creating configuration windows and boxes} *) + +(** This function takes a configuration structure and creates a window + to configure the various parameters. + @param apply this function is called when the apply button is clicked, after + giving new values to parameters. +*) +val edit : + ?apply: (unit -> unit) -> + string -> + ?width:int -> + ?height:int -> + configuration_structure list -> + return_button + +(** This function takes a configuration structure and creates a window used + to get the various parameters from the user. It is the same window as edit but + there is no apply button.*) +val get : + string -> + ?width:int -> + ?height:int -> + configuration_structure list -> + return_button + +(** This function takes a list of parameter specifications and + creates a window to configure the various parameters. + @param apply this function is called when the apply button is clicked, after + giving new values to parameters.*) +val simple_edit : + ?apply: (unit -> unit) -> + string -> + ?width:int -> + ?height:int -> + parameter_kind list -> return_button + +(** This function takes a list of parameter specifications and + creates a window to configure the various parameters, + without Apply button.*) +val simple_get : + string -> + ?width:int -> + ?height:int -> + parameter_kind list -> return_button + +(** Create a [GPack.box] with the list of given parameters, + and the given list of buttons (defined by their label and callback). + Before calling the callback of a button, the [apply] function + of each parameter is called. +*) +val box : parameter_kind list -> + (string * (unit -> unit)) list -> GPack.box + +(** Create a [GPack.box] with the list of given configuration structure list, + and the given list of buttons (defined by their label and callback). + Before calling the callback of a button, the [apply] function + of each parameter is called. +*) +val tabbed_box : configuration_structure list -> + (string * (unit -> unit)) list -> GPack.box diff --git a/ide/utils/configwin_html_config.ml b/ide/utils/configwin_html_config.ml new file mode 100644 index 00000000..fc2913d1 --- /dev/null +++ b/ide/utils/configwin_html_config.ml @@ -0,0 +1,83 @@ +(**************************************************************************) +(* Cameleon *) +(* *) +(* Copyright (C) 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. *) +(* *) +(* This program is free software; you can redistribute it and/or modify *) +(* it under the terms of the GNU General Public License as published by *) +(* the Free Software Foundation; either version 2 of the License, or *) +(* any later version. *) +(* *) +(* This program is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) +(* GNU General Public License for more details. *) +(* *) +(* You should have received a copy of the GNU General Public License *) +(* along with this program; if not, write to the Free Software *) +(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *) +(* 02111-1307 USA *) +(* *) +(* Contact: Maxence.Guesdon@inria.fr *) +(**************************************************************************) + +(** The HTML editor bindings configurator. *) + +module C = Configwin_ihm +open Configwin_types +open Uoptions + +let simple_get = C.simple_edit + ~with_apply: false ~apply: (fun () -> ()) + +let params_hb hb = + let p_key = C.hotkey + ~f: (fun k -> hb.html_key <- k) Configwin_messages.mKey + hb.html_key + in + let p_begin = C.string + ~f: (fun s -> hb.html_begin <- s) + Configwin_messages.html_begin + hb.html_begin + in + let p_end = C.string + ~f: (fun s -> hb.html_end <- s) + Configwin_messages.html_end + hb.html_end + in + [ p_key ; p_begin ; p_end ] + +let edit_hb hb = + ignore (simple_get Configwin_messages.mEdit (params_hb hb)); + hb + +let add () = + let hb = { html_key = KeyOption.string_to_key "C-a" ; + html_begin = "" ; + html_end = "" ; + } + in + match simple_get Configwin_messages.mAdd (params_hb hb) with + Return_ok -> [hb] + | _ -> [] + +let main () = + ignore (GMain.Main.init ()); + let (ini, bindings) = C.html_config_file_and_option () in + let param = C.list + ~f: (fun l -> bindings =:= l ; Uoptions.save_with_help ini) + ~eq: (fun hb1 hb2 -> hb1.html_key = hb2.html_key) + ~edit: edit_hb + ~add: add + ~titles: [ Configwin_messages.mKey ; Configwin_messages.html_begin ; + Configwin_messages.html_end ] + Configwin_messages.shortcuts + (fun hb -> [ KeyOption.key_to_string hb.html_key ; + hb.html_begin ; hb.html_end ]) + !!bindings + in + ignore (simple_get ~width: 300 ~height: 400 + Configwin_messages.html_config [param]) + +let _ = main () diff --git a/ide/utils/configwin_ihm.ml b/ide/utils/configwin_ihm.ml new file mode 100644 index 00000000..03ca706c --- /dev/null +++ b/ide/utils/configwin_ihm.ml @@ -0,0 +1,1435 @@ +(**************************************************************************) +(* Cameleon *) +(* *) +(* Copyright (C) 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. *) +(* *) +(* This program is free software; you can redistribute it and/or modify *) +(* it under the terms of the GNU General Public License as published by *) +(* the Free Software Foundation; either version 2 of the License, or *) +(* any later version. *) +(* *) +(* This program is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) +(* GNU General Public License for more details. *) +(* *) +(* You should have received a copy of the GNU General Public License *) +(* along with this program; if not, write to the Free Software *) +(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *) +(* 02111-1307 USA *) +(* *) +(* Contact: Maxence.Guesdon@inria.fr *) +(**************************************************************************) + +(** This module contains the gui functions of Confgiwin.*) + +open Configwin_types + +module O = Uoptions + + +(** The file where the html config is. *) +let file_html_config = Filename.concat Configwin_messages.home ".configwin_html" + +(** Return the ini file for the html config, and the option for bindings. *) +let html_config_file_and_option () = + let ini = O.create_options_file file_html_config in + let bindings = O.define_option ini ["bindings"] + "" + (O.list_option Configwin_types.Html_binding.t) + [ { html_key = KeyOption.string_to_key "A-b" ; + html_begin = ""; + html_end = "" ; + } ; + { html_key = KeyOption.string_to_key "A-i" ; + html_begin = ""; + html_end = "" ; + } + ] + in + O.load ini ; + (ini, bindings) + + +(** This variable contains the last directory where the user selected a file.*) +let last_dir = ref "";; + +(** This function allows the user to select a file and returns the + selected file name. An optional function allows to change the + behaviour of the ok button. + A VOIR : mutli-selection ? *) +let select_files ?dir + ?(fok : (string -> unit) option) + the_title = + let files = ref ([] : string list) in + let fs = GWindow.file_selection ~modal:true + ~title: the_title () in + (* we set the previous directory, if no directory is given *) + ( + match dir with + None -> + if !last_dir <> "" then + let _ = fs#set_filename !last_dir in + () + else + () + | Some dir -> + let _ = fs#set_filename !last_dir in + () + ); + + let _ = fs # connect#destroy ~callback: GMain.Main.quit in + let _ = fs # ok_button # connect#clicked ~callback: + (match fok with + None -> + (fun () -> files := [fs#filename] ; fs#destroy ()) + | Some f -> + (fun () -> f fs#filename) + ) + in + let _ = fs # cancel_button # connect#clicked ~callback:fs#destroy in + fs # show (); + GMain.Main.main (); + match !files with + | [] -> + [] + | [""] -> + [] + | l -> + (* we keep the directory in last_dir *) + last_dir := Filename.dirname (List.hd l); + l +;; + +(** Make the user select a date. *) +let select_date title (day,mon,year) = + let v_opt = ref None in + let window = GWindow.dialog ~modal:true ~title () in + let hbox = GPack.hbox ~border_width:10 ~packing:window#vbox#add () in + let cal = GMisc.calendar ~packing: (hbox#pack ~expand: true) () in + cal#select_month ~month: mon ~year: year ; + cal#select_day day; + let bbox = window#action_area in + + let bok = GButton.button ~label: Configwin_messages.mOk + ~packing:(bbox#pack ~expand:true ~padding:4) () + in + let bcancel = GButton.button ~label: Configwin_messages.mCancel + ~packing:(bbox#pack ~expand:true ~padding:4) () + in + ignore (bok#connect#clicked ~callback: + (fun () -> v_opt := Some (cal#date); window#destroy ())); + ignore(bcancel#connect#clicked ~callback: window#destroy); + + bok#grab_default (); + ignore(window#connect#destroy ~callback: GMain.Main.quit); + window#set_position `CENTER; + window#show (); + GMain.Main.main (); + !v_opt + + +(** This class builds a frame with a clist and two buttons : + one to add items and one to remove the selected items. + The class takes in parameter a function used to add items and + a string list ref which is used to store the content of the clist. + At last, a title for the frame is also in parameter, so that + each instance of the class creates a frame. *) +class ['a] list_selection_box (listref : 'a list ref) + titles_opt + help_opt + f_edit_opt + f_strings + f_color + (eq : 'a -> 'a -> bool) + add_function title editable = + let wev = GBin.event_box () in + let wf = GBin.frame ~label: title ~packing: wev#add () in + let hbox = GPack.hbox ~packing: wf#add () in + (* the scroll window and the clist *) + let wscroll = GBin.scrolled_window + ~vpolicy: `AUTOMATIC + ~hpolicy: `AUTOMATIC + ~packing: (hbox#pack ~expand: true) () + in + let wlist = match titles_opt with + None -> + GList.clist ~selection_mode: `MULTIPLE + ~titles_show: false + ~packing: wscroll#add () + | Some l -> + GList.clist ~selection_mode: `MULTIPLE + ~titles: l + ~titles_show: true + ~packing: wscroll#add () + in + let _ = + match help_opt with + None -> () + | Some help -> + let tooltips = GData.tooltips () in + ignore (wf#connect#destroy ~callback: tooltips#destroy); + tooltips#set_tip wev#coerce ~text: help ~privat: help + in (* the vbox for the buttons *) + let vbox_buttons = GPack.vbox () in + let _ = + if editable then + let _ = hbox#pack ~expand: false vbox_buttons#coerce in + () + else + () + in + let wb_add = GButton.button + ~label: Configwin_messages.mAdd + ~packing: (vbox_buttons#pack ~expand:false ~padding:2) + () + in + let wb_edit = GButton.button + ~label: Configwin_messages.mEdit + () + in + let _ = match f_edit_opt with + None -> () + | Some _ -> vbox_buttons#pack ~expand:false ~padding:2 wb_edit#coerce + in + let wb_up = GButton.button + ~label: Configwin_messages.mUp + ~packing: (vbox_buttons#pack ~expand:false ~padding:2) + () + in + let wb_remove = GButton.button + ~label: Configwin_messages.mRemove + ~packing: (vbox_buttons#pack ~expand:false ~padding:2) + () + in + object (self) + (** the list of selected rows *) + val mutable list_select = [] + + (** This method returns the frame created. *) + method box = wev + + method update l = + (* set the new list in the provided listref *) + listref := l; + (* insert the elements in the clist *) + wlist#freeze (); + wlist#clear (); + List.iter + (fun ele -> + ignore (wlist#append (f_strings ele)); + match f_color ele with + None -> () + | Some c -> + try wlist#set_row ~foreground: (`NAME c) (wlist#rows - 1) + with _ -> () + ) + !listref; + + (match titles_opt with + None -> wlist#columns_autosize () + | Some _ -> GToolbox.autosize_clist wlist); + wlist#thaw (); + (* the list of selectd elements is now empty *) + list_select <- [] + + (** Move up the selected rows. *) + method up_selected = + let rec iter n selrows l = + match selrows with + [] -> (l, []) + | m :: qrows -> + match l with + [] -> ([],[]) + | [_] -> (l,[]) + | e1 :: e2 :: q when m = n + 1 -> + let newl, newrows = iter (n+1) qrows (e1 :: q) in + (e2 :: newl, n :: newrows) + | e1 :: q -> + let newl, newrows = iter (n+1) selrows q in + (e1 :: newl, newrows) + in + let sorted_select = List.sort compare list_select in + let new_list, new_rows = iter 0 sorted_select !listref in + self#update new_list; + List.iter (fun n -> wlist#select n 0) new_rows + + (** Make the user edit the first selected row. *) + method edit_selected f_edit = + let sorted_select = List.sort compare list_select in + match sorted_select with + [] -> () + | n :: _ -> + try + let ele = List.nth !listref n in + let ele2 = f_edit ele in + let rec iter m = function + [] -> [] + | e :: q -> + if n = m then + ele2 :: q + else + e :: (iter (m+1) q) + in + self#update (iter 0 !listref); + wlist#select n 0 + with + Not_found -> + () + + initializer + (** create the functions called when the buttons are clicked *) + let f_add () = + (* get the files to add with the function provided *) + let l = add_function () in + (* remove from the list the ones which are already in + the listref, using the eq predicate *) + let l2 = List.fold_left + (fun acc -> fun ele -> + if List.exists (eq ele) acc then + acc + else + acc @ [ele]) + !listref + l + in + self#update l2 + in + let f_remove () = + (* remove the selected items from the listref and the clist *) + let rec iter n = function + [] -> [] + | h :: q -> + if List.mem n list_select then + iter (n+1) q + else + h :: (iter (n+1) q) + in + let new_list = iter 0 !listref in + self#update new_list + in + (* connect the functions to the buttons *) + ignore (wb_add#connect#clicked f_add); + ignore (wb_remove#connect#clicked f_remove); + ignore (wb_up#connect#clicked (fun () -> self#up_selected)); + ( + match f_edit_opt with + None -> () + | Some f -> ignore (wb_edit#connect#clicked (fun () -> self#edit_selected f)) + ); + (* connect the selection and deselection of items in the clist *) + let f_select ~row ~column ~event = + try + list_select <- row :: list_select + with + Failure _ -> + () + in + let f_unselect ~row ~column ~event = + try + let new_list_select = List.filter (fun n -> n <> row) list_select in + list_select <- new_list_select + with + Failure _ -> + () + in + (* connect the select and deselect events *) + ignore(wlist#connect#select_row f_select); + ignore(wlist#connect#unselect_row f_unselect); + + (* initialize the clist with the listref *) + self#update !listref + end;; + + +(** This class is used to build a box for a string parameter.*) +class string_param_box param = + let hbox = GPack.hbox () in + let wev = GBin.event_box ~packing: (hbox#pack ~expand: false ~padding: 2) () in + let wl = GMisc.label ~text: param.string_label ~packing: wev#add () in + let we = GEdit.entry + ~editable: param.string_editable + ~packing: (hbox#pack ~expand: param.string_expand ~padding: 2) + () + in + let _ = + match param.string_help with + None -> () + | Some help -> + let tooltips = GData.tooltips () in + ignore (hbox#connect#destroy ~callback: tooltips#destroy); + tooltips#set_tip wev#coerce ~text: help ~privat: help + in + let _ = we#set_text param.string_value in + + object (self) + (** This method returns the main box ready to be packed. *) + method box = hbox#coerce + (** This method applies the new value of the parameter. *) + method apply = + let new_value = we#text in + if new_value <> param.string_value then + let _ = param.string_f_apply new_value in + param.string_value <- new_value + else + () + end ;; + +(** This class is used to build a box for a combo parameter.*) +class combo_param_box param = + let hbox = GPack.hbox () in + let wev = GBin.event_box ~packing: (hbox#pack ~expand: false ~padding: 2) () in + let wl = GMisc.label ~text: param.combo_label ~packing: wev#add () in + let wc = GEdit.combo + ~popdown_strings: param.combo_choices + ~value_in_list: (not param.combo_new_allowed) +(* ~ok_if_empty: param.combo_blank_allowed*) + ~packing: (hbox#pack ~expand: param.combo_expand ~padding: 2) + () + in + let _ = + match param.combo_help with + None -> () + | Some help -> + let tooltips = GData.tooltips () in + ignore (hbox#connect#destroy ~callback:tooltips#destroy); + tooltips#set_tip wev#coerce ~text: help ~privat: help + in + let _ = wc#entry#set_editable param.combo_editable in + let _ = wc#entry#set_text param.combo_value in + + object (self) + (** This method returns the main box ready to be packed. *) + method box = hbox#coerce + (** This method applies the new value of the parameter. *) + method apply = + let new_value = wc#entry#text in + if new_value <> param.combo_value then + let _ = param.combo_f_apply new_value in + param.combo_value <- new_value + else + () + end ;; + +(** Class used to pack a custom box. *) +class custom_param_box param = + let top = + match param.custom_framed with + None -> param.custom_box#coerce + | Some l -> + let wf = GBin.frame ~label: l () in + wf#add param.custom_box#coerce; + wf#coerce + in + object (self) + method box = top + method apply = param.custom_f_apply () + end + +(** This class is used to build a box for a color parameter.*) +class color_param_box param = + let v = ref param.color_value in + let hbox = GPack.hbox () in + let wb = GButton.button ~label: param.color_label + ~packing: (hbox#pack ~expand: false ~padding: 2) () + in + let w_test = GMisc.arrow + ~kind: `RIGHT + ~shadow: `OUT + ~width: 20 + ~height: 20 + ~packing: (hbox#pack ~expand: false ~padding: 2 ) + () + in + let we = GEdit.entry + ~editable: param.color_editable + ~packing: (hbox#pack ~expand: param.color_expand ~padding: 2) + () + in + let _ = + match param.color_help with + None -> () + | Some help -> + let tooltips = GData.tooltips () in + ignore (hbox#connect#destroy ~callback: tooltips#destroy); + tooltips#set_tip wb#coerce ~text: help ~privat: help + in + let set_color s = + let style = w_test#misc#style#copy in + ( + try style#set_bg [ (`NORMAL, `NAME s) ; ] + with _ -> () + ); + w_test#misc#set_style style + in + let _ = set_color !v in + let _ = we#set_text !v in + let f_sel () = + let dialog = GWindow.color_selection_dialog + ~title: param.color_label + ~modal: true + ~show: true + () + in + let wb_ok = dialog#ok_button in + let wb_cancel = dialog#cancel_button in + let _ = dialog#connect#destroy GMain.Main.quit in + let _ = wb_ok#connect#clicked + (fun () -> + (* let color = dialog#colorsel#get_color in + let r = int_of_float (ceil (color.Gtk.red *. 255.)) in + let g = int_of_float (ceil (color.Gtk.green *. 255.)) in + let b = int_of_float (ceil (color.Gtk.blue *. 255.)) in + let s = Printf.sprintf "#%2X%2X%2X" r g b in + let _ = + for i = 1 to (String.length s) - 1 do + if s.[i] = ' ' then s.[i] <- '0' + done + in + we#set_text s ; + set_color s;*) + dialog#destroy () + ) + in + let _ = wb_cancel#connect#clicked dialog#destroy in + GMain.Main.main () + in + let _ = + if param.color_editable then ignore (wb#connect#clicked f_sel) + in + + object (self) + (** This method returns the main box ready to be packed. *) + method box = hbox#coerce + (** This method applies the new value of the parameter. *) + method apply = + let new_value = we#text in + if new_value <> param.color_value then + let _ = param.color_f_apply new_value in + param.color_value <- new_value + else + () + end ;; + +(** This class is used to build a box for a font parameter.*) +class font_param_box param = + let v = ref param.font_value in + let hbox = GPack.hbox () in + let wb = GButton.button ~label: param.font_label + ~packing: (hbox#pack ~expand: false ~padding: 2) () + in + let we = GEdit.entry + ~editable: false + ~packing: (hbox#pack ~expand: param.font_expand ~padding: 2) + () + in + let _ = + match param.font_help with + None -> () + | Some help -> + let tooltips = GData.tooltips () in + ignore (hbox#connect#destroy ~callback: tooltips#destroy); + tooltips#set_tip wb#coerce ~text: help ~privat: help + in + let set_entry_font font_opt = + match font_opt with + None -> () + | Some s -> + let style = we#misc#style#copy in + ( + try + let font = Gdk.Font.load_fontset s in + style#set_font font + with _ -> () + ); + we#misc#set_style style + in + let _ = set_entry_font (Some !v) in + let _ = we#set_text !v in + let f_sel () = + let dialog = GWindow.font_selection_dialog + ~title: param.font_label + ~modal: true + ~show: true + () + in + dialog#selection#set_font_name !v; + let wb_ok = dialog#ok_button in + let wb_cancel = dialog#cancel_button in + let _ = dialog#connect#destroy GMain.Main.quit in + let _ = wb_ok#connect#clicked + (fun () -> + let font_opt = dialog#selection#font_name in +(* we#set_text (match font_opt with None -> "" | Some s -> s) ; + set_entry_font font_opt;*) + dialog#destroy () + ) + in + let _ = wb_cancel#connect#clicked dialog#destroy in + GMain.Main.main () + in + let _ = if param.font_editable then ignore (wb#connect#clicked f_sel) in + + object (self) + (** This method returns the main box ready to be packed. *) + method box = hbox#coerce + (** This method applies the new value of the parameter. *) + method apply = + let new_value = we#text in + if new_value <> param.font_value then + let _ = param.font_f_apply new_value in + param.font_value <- new_value + else + () + end ;; + +(** This class is used to build a box for a text parameter.*) +class text_param_box param = + let hbox = GPack.hbox ~height: 100 () in + let wev = GBin.event_box ~packing: (hbox#pack ~expand: false ~padding: 2) () in + let wl = GMisc.label ~text: param.string_label ~packing: wev#add () in + let wscroll = GBin.scrolled_window + ~vpolicy: `AUTOMATIC + ~hpolicy: `AUTOMATIC + ~packing: (hbox#pack ~expand: true ~padding: 2) () + in + let wt = GText.view ~packing:wscroll#add () in +(* let _ = wt#coerce#misc#set_size_request ~height:100 in *) + let _ = wt#set_editable param.string_editable in + let _ = + match param.string_help with + None -> () + | Some help -> + let tooltips = GData.tooltips () in + ignore (hbox#connect#destroy ~callback: tooltips#destroy); + tooltips#set_tip wev#coerce ~text: help ~privat: help + in + let _ = wt#buffer#insert param.string_value in + + object (self) + val wt = wt + (** This method returns the main box ready to be packed. *) + method box = hbox#coerce + (** This method applies the new value of the parameter. *) + method apply = + let new_value = wt#buffer#get_text () in + if new_value <> param.string_value then + let _ = param.string_f_apply new_value in + param.string_value <- new_value + else + () + end ;; + +(** This class is used to build a box a html parameter. *) +class html_param_box param = + object (self) + inherit text_param_box param + + method private exec html_start html_end () = + let s,e = wt#buffer#selection_bounds in + if s#compare e = 0 then + wt#buffer#insert (html_start^html_end) + else begin + ignore (wt#buffer#insert ~iter:e html_end); + ignore (wt#buffer#insert ~iter:s html_start); + wt#buffer#place_cursor + (e#forward_chars (String.length (html_start^html_end))) + end + initializer + let (_,html_bindings) = html_config_file_and_option () in + let add_shortcut hb = + let (mods, k) = hb.html_key in + Okey.add wt ~mods k (self#exec hb.html_begin hb.html_end) + in + List.iter add_shortcut (O.(!!) html_bindings) + end + +(** This class is used to build a box for a boolean parameter.*) +class bool_param_box param = + let wchk = GButton.check_button + ~label: param.bool_label + () + in + let _ = + match param.bool_help with + None -> () + | Some help -> + let tooltips = GData.tooltips () in + ignore (wchk#connect#destroy ~callback: tooltips#destroy); + tooltips#set_tip wchk#coerce ~text: help ~privat: help + in + let _ = wchk#set_active param.bool_value in + let _ = wchk#misc#set_sensitive param.bool_editable in + + object (self) + (** This method returns the check button ready to be packed. *) + method box = wchk#coerce + (** This method applies the new value of the parameter. *) + method apply = + let new_value = wchk#active in + if new_value <> param.bool_value then + let _ = param.bool_f_apply new_value in + param.bool_value <- new_value + else + () + end ;; + +(** This class is used to build a box for a file name parameter.*) +class filename_param_box param = + let hbox = GPack.hbox () in + let wb = GButton.button ~label: param.string_label + ~packing: (hbox#pack ~expand: false ~padding: 2) () + in + let we = GEdit.entry + ~editable: param.string_editable + ~packing: (hbox#pack ~expand: param.string_expand ~padding: 2) + () + in + let _ = + match param.string_help with + None -> () + | Some help -> + let tooltips = GData.tooltips () in + ignore (hbox#connect#destroy ~callback: tooltips#destroy); + tooltips#set_tip wb#coerce ~text: help ~privat: help + in + let _ = we#set_text param.string_value in + + let f_click () = + match select_files param.string_label with + [] -> + () + | f :: _ -> + we#set_text f + in + let _ = + if param.string_editable then + let _ = wb#connect#clicked f_click in + () + else + () + in + + object (self) + (** This method returns the main box ready to be packed. *) + method box = hbox#coerce + (** This method applies the new value of the parameter. *) + method apply = + let new_value = we#text in + if new_value <> param.string_value then + let _ = param.string_f_apply new_value in + param.string_value <- new_value + else + () + end ;; + +(** This class is used to build a box for a hot key parameter.*) +class hotkey_param_box param = + let hbox = GPack.hbox () in + let wev = GBin.event_box ~packing: (hbox#pack ~expand: false ~padding: 2) () in + let wl = GMisc.label ~text: param.hk_label + ~packing: wev#add () + in + let we = GEdit.entry + ~editable: false + ~packing: (hbox#pack ~expand: param.hk_expand ~padding: 2) + () + in + let value = ref param.hk_value in + let _ = + match param.hk_help with + None -> () + | Some help -> + let tooltips = GData.tooltips () in + ignore (hbox#connect#destroy ~callback: tooltips#destroy); + tooltips#set_tip wev#coerce ~text: help ~privat: help + in + let _ = we#set_text (KeyOption.key_to_string param.hk_value) in + let mods_we_dont_care = [`MOD2 ; `MOD3 ; `MOD4 ; `MOD5 ; `LOCK] in + let capture ev = + let key = GdkEvent.Key.keyval ev in + let modifiers = GdkEvent.Key.state ev in + let mods = List.filter + (fun m -> not (List.mem m mods_we_dont_care)) + modifiers + in + value := (mods, key); + we#set_text (KeyOption.key_to_string !value); + false + in + let _ = + if param.hk_editable then + ignore (we#event#connect#key_press capture) + else + () + in + + object (self) + (** This method returns the main box ready to be packed. *) + method box = hbox#coerce + (** This method applies the new value of the parameter. *) + method apply = + let new_value = !value in + if new_value <> param.hk_value then + let _ = param.hk_f_apply new_value in + param.hk_value <- new_value + else + () + end ;; + +class modifiers_param_box param = + let hbox = GPack.hbox () in + let wev = GBin.event_box ~packing: (hbox#pack ~expand: false ~padding: 2) () in + let wl = GMisc.label ~text: param.md_label + ~packing: wev#add () + in + let we = GEdit.entry + ~editable: false + ~packing: (hbox#pack ~expand: param.md_expand ~padding: 2) + () + in + let value = ref param.md_value in + let _ = + match param.md_help with + None -> () + | Some help -> + let tooltips = GData.tooltips () in + ignore (hbox#connect#destroy ~callback: tooltips#destroy); + tooltips#set_tip wev#coerce ~text: help ~privat: help + in + let _ = we#set_text (KeyOption.modifiers_to_string param.md_value) in + let mods_we_care = param.md_allow in + let capture ev = + let modifiers = GdkEvent.Key.state ev in + let mods = List.filter + (fun m -> (List.mem m mods_we_care)) + modifiers + in + value := mods; + we#set_text (KeyOption.modifiers_to_string !value); + false + in + let _ = + if param.md_editable then + ignore (we#event#connect#key_press capture) + else + () + in + + object (self) + (** This method returns the main box ready to be packed. *) + method box = hbox#coerce + (** This method applies the new value of the parameter. *) + method apply = + let new_value = !value in + if new_value <> param.md_value then + let _ = param.md_f_apply new_value in + param.md_value <- new_value + else + () + end ;; + +(** This class is used to build a box for a date parameter.*) +class date_param_box param = + let v = ref param.date_value in + let hbox = GPack.hbox () in + let wb = GButton.button ~label: param.date_label + ~packing: (hbox#pack ~expand: false ~padding: 2) () + in + let we = GEdit.entry + ~editable: false + ~packing: (hbox#pack ~expand: param.date_expand ~padding: 2) + () + in + let _ = + match param.date_help with + None -> () + | Some help -> + let tooltips = GData.tooltips () in + ignore (hbox#connect#destroy ~callback: tooltips#destroy); + tooltips#set_tip wb#coerce ~text: help ~privat: help + in + let _ = we#set_text (param.date_f_string param.date_value) in + + let f_click () = + match select_date param.date_label !v with + None -> () + | Some (y,m,d) -> + v := (d,m,y) ; + we#set_text (param.date_f_string (d,m,y)) + in + let _ = + if param.date_editable then + let _ = wb#connect#clicked f_click in + () + else + () + in + + object (self) + (** This method returns the main box ready to be packed. *) + method box = hbox#coerce + (** This method applies the new value of the parameter. *) + method apply = + if !v <> param.date_value then + let _ = param.date_f_apply !v in + param.date_value <- !v + else + () + end ;; + +(** This class is used to build a box for a parameter whose values are a list.*) +class ['a] list_param_box (param : 'a list_param) = + let listref = ref param.list_value in + let frame_selection = new list_selection_box + listref + param.list_titles + param.list_help + param.list_f_edit + param.list_strings + param.list_color + param.list_eq + param.list_f_add param.list_label param.list_editable + in + + object (self) + (** This method returns the main box ready to be packed. *) + method box = frame_selection#box#coerce + (** This method applies the new value of the parameter. *) + method apply = + param.list_f_apply !listref ; + param.list_value <- !listref + end ;; + +(** This class is used to build a box from a configuration structure + and adds the page to the given notebook. *) +class configuration_box conf_struct (notebook : GPack.notebook) = + (* we build different widgets, according to the conf_struct parameter *) + let main_box = GPack.vbox () in + let (label, child_boxes) = + match conf_struct with + Section (label, param_list) -> + let f parameter = + match parameter with + String_param p -> + let box = new string_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Combo_param p -> + let box = new combo_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Text_param p -> + let box = new text_param_box p in + let _ = main_box#pack ~expand: p.string_expand ~padding: 2 box#box in + box + | Bool_param p -> + let box = new bool_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Filename_param p -> + let box = new filename_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | List_param f -> + let box = f () in + let _ = main_box#pack ~expand: true ~padding: 2 box#box in + box + | Custom_param p -> + let box = new custom_param_box p in + let _ = main_box#pack ~expand: p.custom_expand ~padding: 2 box#box in + box + | Color_param p -> + let box = new color_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Font_param p -> + let box = new font_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Date_param p -> + let box = new date_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Hotkey_param p -> + let box = new hotkey_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Modifiers_param p -> + let box = new modifiers_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Html_param p -> + let box = new html_param_box p in + let _ = main_box#pack ~expand: p.string_expand ~padding: 2 box#box in + box + in + let list_children_boxes = List.map f param_list in + + (label, list_children_boxes) + + | Section_list (label, struct_list) -> + let wnote = GPack.notebook + (*homogeneous_tabs: true*) + ~scrollable: true + ~show_tabs: true + ~tab_border: 3 + ~packing: (main_box#pack ~expand: true) + () + in + (* we create all the children boxes *) + let f structure = + let new_box = new configuration_box structure wnote in + new_box + in + let list_child_boxes = List.map f struct_list in + (label, list_child_boxes) + + in + let page_label = GMisc.label ~text: label () in + let _ = notebook#append_page + ~tab_label: page_label#coerce + main_box#coerce + in + + object (self) + (** This method returns the main box ready to be packed. *) + method box = main_box#coerce + (** This method make the new values of the paramters applied, recursively in + all boxes.*) + method apply = + List.iter (fun box -> box#apply) child_boxes + end +;; + +(** Create a vbox with the list of given configuration structure list, + and the given list of buttons (defined by their label and callback). + Before calling the callback of a button, the [apply] function + of each parameter is called. +*) +let tabbed_box conf_struct_list buttons = + let vbox = GPack.vbox () in + let wnote = GPack.notebook + (*homogeneous_tabs: true*) + ~scrollable: true + ~show_tabs: true + ~tab_border: 3 + ~packing: (vbox#pack ~expand: true) + () + in + let list_param_box = + List.map (fun conf_struct -> new configuration_box conf_struct wnote) + conf_struct_list + in + let f_apply () = + List.iter (fun param_box -> param_box#apply) list_param_box ; + in + let hbox_buttons = GPack.hbox ~packing: (vbox#pack ~expand: false ~padding: 4) () in + let rec iter_buttons ?(grab=false) = function + [] -> + () + | (label, callb) :: q -> + let b = GButton.button ~label: label + ~packing:(hbox_buttons#pack ~expand:true ~fill: true ~padding:4) () + in + ignore (b#connect#clicked ~callback: + (fun () -> f_apply (); callb ())); + (* If it's the first button then give it the focus *) + if grab then b#grab_default (); + + iter_buttons q + in + iter_buttons ~grab: true buttons; + + vbox + +(** This function takes a configuration structure list and creates a window + to configure the various parameters. *) +let edit ?(with_apply=true) + ?(apply=(fun () -> ())) + title ?(width=400) ?(height=400) + conf_struct_list = + let return = ref Return_cancel in + let window = GWindow.window + ~position:`CENTER + ~modal: true ~title: title + ~width: width ~height: height () + in + let _ = window#connect#destroy ~callback: GMain.Main.quit in + let vbox = GPack.vbox ~packing: window#add () in + let wnote = GPack.notebook + (*homogeneous_tabs: true*) + ~scrollable: true + ~show_tabs: true + ~tab_border: 3 + ~packing: (vbox#pack ~expand: true) + () + in + let list_param_box = + List.map (fun conf_struct -> new configuration_box conf_struct wnote) + conf_struct_list + in + + let hbox_buttons = GPack.hbox ~packing: (vbox#pack ~expand: false ~padding: 4) () in + let bApply = GButton.button + ~stock:`APPLY + ~label: Configwin_messages.mApply + () + in + if with_apply then hbox_buttons#pack ~expand: true ~padding: 3 bApply#coerce; + let bOk = GButton.button + ~stock:`OK + ~label: Configwin_messages.mOk + ~packing: (hbox_buttons#pack ~expand: true ~padding: 3) + () + in + let bCancel = GButton.button + ~stock:`CANCEL + ~label: Configwin_messages.mCancel + ~packing: (hbox_buttons#pack ~expand: true ~padding: 3) + () + in + (* we connect the click on the apply button *) + let f_apply () = + List.iter (fun param_box -> param_box#apply) list_param_box ; + apply (); + return := Return_apply + in + let _ = bApply#connect#clicked f_apply in + (* we connect the click on the ok button : the same than apply but we then close the window *) + let f_ok () = + List.iter (fun param_box -> param_box#apply) list_param_box ; + return := Return_ok ; + window#destroy () + in + let _ = bOk#connect#clicked f_ok in + (* we connect the click on the cancel button : close the window *) + let f_cancel () = window#destroy () in + let _ = bCancel#connect#clicked f_cancel in + + let _ = window#event#connect#key_press ~callback: + (fun k -> if GdkEvent.Key.keyval k = GdkKeysyms._Escape then f_cancel ();false) + in + let _ = window#show () in + GMain.Main.main () ; + !return + + +(** Create a vbox with the list of given parameters, + and the given list of buttons (defined by their label and callback). + Before calling the callback of a button, the [apply] function + of each parameter is called. +*) +let box param_list buttons = + let main_box = GPack.vbox () in + let f parameter = + match parameter with + String_param p -> + let box = new string_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Combo_param p -> + let box = new combo_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Text_param p -> + let box = new text_param_box p in + let _ = main_box#pack ~expand: p.string_expand ~padding: 2 box#box in + box + | Bool_param p -> + let box = new bool_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Filename_param p -> + let box = new filename_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | List_param f -> + let box = f () in + let _ = main_box#pack ~expand: true ~padding: 2 box#box in + box + | Custom_param p -> + let box = new custom_param_box p in + let _ = main_box#pack ~expand: p.custom_expand ~padding: 2 box#box in + box + | Color_param p -> + let box = new color_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Font_param p -> + let box = new font_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Date_param p -> + let box = new date_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Hotkey_param p -> + let box = new hotkey_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Modifiers_param p -> + let box = new modifiers_param_box p in + let _ = main_box#pack ~expand: false ~padding: 2 box#box in + box + | Html_param p -> + let box = new html_param_box p in + let _ = main_box#pack ~expand: p.string_expand ~padding: 2 box#box in + box + in + let list_param_box = List.map f param_list in + let f_apply () = + List.iter (fun param_box -> param_box#apply) list_param_box + in + let hbox_buttons = GPack.hbox ~packing: (main_box#pack ~expand: false ~padding: 4) () in + let rec iter_buttons ?(grab=false) = function + [] -> + () + | (label, callb) :: q -> + let b = GButton.button ~label: label + ~packing:(hbox_buttons#pack ~expand:true ~fill: true ~padding:4) () + in + ignore (b#connect#clicked ~callback: + (fun () -> f_apply (); callb ())); + (* If it's the first button then give it the focus *) + if grab then b#grab_default (); + + iter_buttons q + in + iter_buttons ~grab: true buttons; + + main_box + + +(** This function takes a list of parameter specifications and + creates a window to configure the various parameters.*) +let simple_edit ?(with_apply=true) + ?(apply=(fun () -> ())) + title ?width ?height + param_list = + let return = ref Return_cancel in + let window = GWindow.window ~modal: true ~title: title () in + let _ = match width, height with + None, None -> () + | Some w, None -> window#misc#set_size_request ~width: w () + | None, Some h -> window#misc#set_size_request ~height: h () + | Some w, Some h -> window#misc#set_size_request ~width: w ~height: h () + in + let _ = window#connect#destroy ~callback: GMain.Main.quit in + let buttons = + (if with_apply then + [Configwin_messages.mApply, fun () -> apply (); return := Return_apply] + else + [] + ) @ [ + (Configwin_messages.mOk, fun () -> return := Return_ok ; window#destroy ()) ; + (Configwin_messages.mCancel, window#destroy) ; + ] + in + let box = box param_list buttons in + window#add box#coerce; + let _ = window#show () in + GMain.Main.main () ; + !return + +let edit_string l s = + match GToolbox.input_string ~title: l ~text: s Configwin_messages.mValue with + None -> s + | Some s2 -> s2 + +(** Create a string param. *) +let string ?(editable=true) ?(expand=true) ?help ?(f=(fun _ -> ())) label v = + String_param + { + string_label = label ; + string_help = help ; + string_value = v ; + string_editable = editable ; + string_f_apply = f ; + string_expand = expand ; + } + +(** Create a bool param. *) +let bool ?(editable=true) ?help ?(f=(fun _ -> ())) label v = + Bool_param + { + bool_label = label ; + bool_help = help ; + bool_value = v ; + bool_editable = editable ; + bool_f_apply = f ; + } + +(** Create a list param. *) +let list ?(editable=true) ?help + ?(f=(fun (_:'a list) -> ())) + ?(eq=Pervasives.(=)) + ?(edit:('a -> 'a) option) + ?(add=(fun () -> ([] : 'a list))) + ?titles ?(color=(fun (_:'a) -> (None : string option))) + label (f_strings : 'a -> string list) v = + List_param + (fun () -> + Obj.magic + (new list_param_box + { + list_label = label ; + list_help = help ; + list_value = v ; + list_editable = editable ; + list_titles = titles; + list_eq = eq ; + list_strings = f_strings ; + list_color = color ; + list_f_edit = edit ; + list_f_add = add ; + list_f_apply = f ; + } + ) + ) + +(** Create a strings param. *) +let strings ?(editable=true) ?help + ?(f=(fun _ -> ())) + ?(eq=Pervasives.(=)) + ?(add=(fun () -> [])) label v = + list ~editable ?help ~f ~eq ~edit: (edit_string label) ~add label (fun s -> [s]) v + +(** Create a color param. *) +let color ?(editable=true) ?(expand=true) ?help ?(f=(fun _ -> ())) label v = + Color_param + { + color_label = label ; + color_help = help ; + color_value = v ; + color_editable = editable ; + color_f_apply = f ; + color_expand = expand ; + } + +(** Create a font param. *) +let font ?(editable=true) ?(expand=true) ?help ?(f=(fun _ -> ())) label v = + Font_param + { + font_label = label ; + font_help = help ; + font_value = v ; + font_editable = editable ; + font_f_apply = f ; + font_expand = expand ; + } + +(** Create a combo param. *) +let combo ?(editable=true) ?(expand=true) ?help ?(f=(fun _ -> ())) + ?(new_allowed=false) + ?(blank_allowed=false) label choices v = + Combo_param + { + combo_label = label ; + combo_help = help ; + combo_value = v ; + combo_editable = editable ; + combo_choices = choices ; + combo_new_allowed = new_allowed ; + combo_blank_allowed = blank_allowed ; + combo_f_apply = f ; + combo_expand = expand ; + } + +(** Create a text param. *) +let text ?(editable=true) ?(expand=true) ?help ?(f=(fun _ -> ())) label v = + Text_param + { + string_label = label ; + string_help = help ; + string_value = v ; + string_editable = editable ; + string_f_apply = f ; + string_expand = expand ; + } + +(** Create a html param. *) +let html ?(editable=true) ?(expand=true) ?help ?(f=(fun _ -> ())) label v = + Html_param + { + string_label = label ; + string_help = help ; + string_value = v ; + string_editable = editable ; + string_f_apply = f ; + string_expand = expand ; + } + +(** Create a filename param. *) +let filename ?(editable=true) ?(expand=true)?help ?(f=(fun _ -> ())) label v = + Filename_param + { + string_label = label ; + string_help = help ; + string_value = v ; + string_editable = editable ; + string_f_apply = f ; + string_expand = expand ; + } + +(** Create a filenames param.*) +let filenames ?(editable=true) ?help ?(f=(fun _ -> ())) + ?(eq=Pervasives.(=)) + label v = + let add () = select_files label in + list ~editable ?help ~f ~eq ~add label (fun s -> [s]) v + +(** Create a date param. *) +let date ?(editable=true) ?(expand=true) ?help ?(f=(fun _ -> ())) + ?(f_string=(fun(d,m,y)-> Printf.sprintf "%d/%d/%d" y (m+1) d)) + label v = + Date_param + { + date_label = label ; + date_help = help ; + date_value = v ; + date_editable = editable ; + date_f_string = f_string ; + date_f_apply = f ; + date_expand = expand ; + } + +(** Create a hot key param. *) +let hotkey ?(editable=true) ?(expand=true) ?help ?(f=(fun _ -> ())) label v = + Hotkey_param + { + hk_label = label ; + hk_help = help ; + hk_value = v ; + hk_editable = editable ; + hk_f_apply = f ; + hk_expand = expand ; + } + +let modifiers + ?(editable=true) + ?(expand=true) + ?help + ?(allow=[`CONTROL;`SHIFT;`LOCK;`MOD1;`MOD1;`MOD2;`MOD3;`MOD4;`MOD5]) + ?(f=(fun _ -> ())) label v = + Modifiers_param + { + md_label = label ; + md_help = help ; + md_value = v ; + md_editable = editable ; + md_f_apply = f ; + md_expand = expand ; + md_allow = allow ; + } + +(** Create a custom param.*) +let custom ?label box f expand = + Custom_param + { + custom_box = box ; + custom_f_apply = f ; + custom_expand = expand ; + custom_framed = label ; + } diff --git a/ide/utils/configwin_keys.ml b/ide/utils/configwin_keys.ml new file mode 100644 index 00000000..9c867845 --- /dev/null +++ b/ide/utils/configwin_keys.ml @@ -0,0 +1,4175 @@ +(**************************************************************************) +(* Cameleon *) +(* *) +(* Copyright (C) 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. *) +(* *) +(* This program is free software; you can redistribute it and/or modify *) +(* it under the terms of the GNU General Public License as published by *) +(* the Free Software Foundation; either version 2 of the License, or *) +(* any later version. *) +(* *) +(* This program is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) +(* GNU General Public License for more details. *) +(* *) +(* You should have received a copy of the GNU General Public License *) +(* along with this program; if not, write to the Free Software *) +(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *) +(* 02111-1307 USA *) +(* *) +(* Contact: Maxence.Guesdon@inria.fr *) +(**************************************************************************) + +(** Key codes + + Ce fichier provient de X11/keysymdef.h + les noms des symboles deviennent : XK_ -> xk_ + + Thanks to Fabrice Le Fessant. +*) + +let xk_VoidSymbol = 0xFFFFFF (** void symbol *) + + +(** TTY Functions, cleverly chosen to map to ascii, for convenience of + programming, but could have been arbitrary (at the cost of lookup + tables in client code. +*) + +let xk_BackSpace = 0xFF08 (** back space, back char *) +let xk_Tab = 0xFF09 +let xk_Linefeed = 0xFF0A (** Linefeed, LF *) +let xk_Clear = 0xFF0B +let xk_Return = 0xFF0D (** Return, enter *) +let xk_Pause = 0xFF13 (** Pause, hold *) +let xk_Scroll_Lock = 0xFF14 +let xk_Sys_Req = 0xFF15 +let xk_Escape = 0xFF1B +let xk_Delete = 0xFFFF (** Delete, rubout *) + + + +(** International & multi-key character composition *) + +let xk_Multi_key = 0xFF20 (** Multi-key character compose *) + +(** Japanese keyboard support *) + +let xk_Kanji = 0xFF21 (** Kanji, Kanji convert *) +let xk_Muhenkan = 0xFF22 (** Cancel Conversion *) +let xk_Henkan_Mode = 0xFF23 (** Start/Stop Conversion *) +let xk_Henkan = 0xFF23 (** Alias for Henkan_Mode *) +let xk_Romaji = 0xFF24 (** to Romaji *) +let xk_Hiragana = 0xFF25 (** to Hiragana *) +let xk_Katakana = 0xFF26 (** to Katakana *) +let xk_Hiragana_Katakana = 0xFF27 (** Hiragana/Katakana toggle *) +let xk_Zenkaku = 0xFF28 (** to Zenkaku *) +let xk_Hankaku = 0xFF29 (** to Hankaku *) +let xk_Zenkaku_Hankaku = 0xFF2A (** Zenkaku/Hankaku toggle *) +let xk_Touroku = 0xFF2B (** Add to Dictionary *) +let xk_Massyo = 0xFF2C (** Delete from Dictionary *) +let xk_Kana_Lock = 0xFF2D (** Kana Lock *) +let xk_Kana_Shift = 0xFF2E (** Kana Shift *) +let xk_Eisu_Shift = 0xFF2F (** Alphanumeric Shift *) +let xk_Eisu_toggle = 0xFF30 (** Alphanumeric toggle *) + +(** = 0xFF31 thru = 0xFF3F are under xk_KOREAN *) + +(** Cursor control & motion *) + +let xk_Home = 0xFF50 +let xk_Left = 0xFF51 (** Move left, left arrow *) +let xk_Up = 0xFF52 (** Move up, up arrow *) +let xk_Right = 0xFF53 (** Move right, right arrow *) +let xk_Down = 0xFF54 (** Move down, down arrow *) +let xk_Prior = 0xFF55 (** Prior, previous *) +let xk_Page_Up = 0xFF55 +let xk_Next = 0xFF56 (** Next *) +let xk_Page_Down = 0xFF56 +let xk_End = 0xFF57 (** EOL *) +let xk_Begin = 0xFF58 (** BOL *) + + +(** Misc Functions *) + +let xk_Select = 0xFF60 (** Select, mark *) +let xk_Print = 0xFF61 +let xk_Execute = 0xFF62 (** Execute, run, do *) +let xk_Insert = 0xFF63 (** Insert, insert here *) +let xk_Undo = 0xFF65 (** Undo, oops *) +let xk_Redo = 0xFF66 (** redo, again *) +let xk_Menu = 0xFF67 +let xk_Find = 0xFF68 (** Find, search *) +let xk_Cancel = 0xFF69 (** Cancel, stop, abort, exit *) +let xk_Help = 0xFF6A (** Help *) +let xk_Break = 0xFF6B +let xk_Mode_switch = 0xFF7E (** Character set switch *) +let xk_script_switch = 0xFF7E (** Alias for mode_switch *) +let xk_Num_Lock = 0xFF7F + +(** Keypad Functions, keypad numbers cleverly chosen to map to ascii *) + +let xk_KP_Space = 0xFF80 (** space *) +let xk_KP_Tab = 0xFF89 +let xk_KP_Enter = 0xFF8D (** enter *) +let xk_KP_F1 = 0xFF91 (** PF1, KP_A, ... *) +let xk_KP_F2 = 0xFF92 +let xk_KP_F3 = 0xFF93 +let xk_KP_F4 = 0xFF94 +let xk_KP_Home = 0xFF95 +let xk_KP_Left = 0xFF96 +let xk_KP_Up = 0xFF97 +let xk_KP_Right = 0xFF98 +let xk_KP_Down = 0xFF99 +let xk_KP_Prior = 0xFF9A +let xk_KP_Page_Up = 0xFF9A +let xk_KP_Next = 0xFF9B +let xk_KP_Page_Down = 0xFF9B +let xk_KP_End = 0xFF9C +let xk_KP_Begin = 0xFF9D +let xk_KP_Insert = 0xFF9E +let xk_KP_Delete = 0xFF9F +let xk_KP_Equal = 0xFFBD (** equals *) +let xk_KP_Multiply = 0xFFAA +let xk_KP_Add = 0xFFAB +let xk_KP_Separator = 0xFFAC (** separator, often comma *) +let xk_KP_Subtract = 0xFFAD +let xk_KP_Decimal = 0xFFAE +let xk_KP_Divide = 0xFFAF + +let xk_KP_0 = 0xFFB0 +let xk_KP_1 = 0xFFB1 +let xk_KP_2 = 0xFFB2 +let xk_KP_3 = 0xFFB3 +let xk_KP_4 = 0xFFB4 +let xk_KP_5 = 0xFFB5 +let xk_KP_6 = 0xFFB6 +let xk_KP_7 = 0xFFB7 +let xk_KP_8 = 0xFFB8 +let xk_KP_9 = 0xFFB9 + + + +(* + * Auxilliary Functions; note the duplicate definitions for left and right + * function keys; Sun keyboards and a few other manufactures have such + * function key groups on the left and/or right sides of the keyboard. + * We've not found a keyboard with more than 35 function keys total. + *) + +let xk_F1 = 0xFFBE +let xk_F2 = 0xFFBF +let xk_F3 = 0xFFC0 +let xk_F4 = 0xFFC1 +let xk_F5 = 0xFFC2 +let xk_F6 = 0xFFC3 +let xk_F7 = 0xFFC4 +let xk_F8 = 0xFFC5 +let xk_F9 = 0xFFC6 +let xk_F10 = 0xFFC7 +let xk_F11 = 0xFFC8 +let xk_L1 = 0xFFC8 +let xk_F12 = 0xFFC9 +let xk_L2 = 0xFFC9 +let xk_F13 = 0xFFCA +let xk_L3 = 0xFFCA +let xk_F14 = 0xFFCB +let xk_L4 = 0xFFCB +let xk_F15 = 0xFFCC +let xk_L5 = 0xFFCC +let xk_F16 = 0xFFCD +let xk_L6 = 0xFFCD +let xk_F17 = 0xFFCE +let xk_L7 = 0xFFCE +let xk_F18 = 0xFFCF +let xk_L8 = 0xFFCF +let xk_F19 = 0xFFD0 +let xk_L9 = 0xFFD0 +let xk_F20 = 0xFFD1 +let xk_L10 = 0xFFD1 +let xk_F21 = 0xFFD2 +let xk_R1 = 0xFFD2 +let xk_F22 = 0xFFD3 +let xk_R2 = 0xFFD3 +let xk_F23 = 0xFFD4 +let xk_R3 = 0xFFD4 +let xk_F24 = 0xFFD5 +let xk_R4 = 0xFFD5 +let xk_F25 = 0xFFD6 +let xk_R5 = 0xFFD6 +let xk_F26 = 0xFFD7 +let xk_R6 = 0xFFD7 +let xk_F27 = 0xFFD8 +let xk_R7 = 0xFFD8 +let xk_F28 = 0xFFD9 +let xk_R8 = 0xFFD9 +let xk_F29 = 0xFFDA +let xk_R9 = 0xFFDA +let xk_F30 = 0xFFDB +let xk_R10 = 0xFFDB +let xk_F31 = 0xFFDC +let xk_R11 = 0xFFDC +let xk_F32 = 0xFFDD +let xk_R12 = 0xFFDD +let xk_F33 = 0xFFDE +let xk_R13 = 0xFFDE +let xk_F34 = 0xFFDF +let xk_R14 = 0xFFDF +let xk_F35 = 0xFFE0 +let xk_R15 = 0xFFE0 + +(** Modifiers *) + +let xk_Shift_L = 0xFFE1 (** Left shift *) +let xk_Shift_R = 0xFFE2 (** Right shift *) +let xk_Control_L = 0xFFE3 (** Left control *) +let xk_Control_R = 0xFFE4 (** Right control *) +let xk_Caps_Lock = 0xFFE5 (** Caps lock *) +let xk_Shift_Lock = 0xFFE6 (** Shift lock *) + +let xk_Meta_L = 0xFFE7 (** Left meta *) +let xk_Meta_R = 0xFFE8 (** Right meta *) +let xk_Alt_L = 0xFFE9 (** Left alt *) +let xk_Alt_R = 0xFFEA (** Right alt *) +let xk_Super_L = 0xFFEB (** Left super *) +let xk_Super_R = 0xFFEC (** Right super *) +let xk_Hyper_L = 0xFFED (** Left hyper *) +let xk_Hyper_R = 0xFFEE (** Right hyper *) + + +(* + * ISO 9995 Function and Modifier Keys + * Byte 3 = = 0xFE + *) + + +let xk_ISO_Lock = 0xFE01 +let xk_ISO_Level2_Latch = 0xFE02 +let xk_ISO_Level3_Shift = 0xFE03 +let xk_ISO_Level3_Latch = 0xFE04 +let xk_ISO_Level3_Lock = 0xFE05 +let xk_ISO_Group_Shift = 0xFF7E (** Alias for mode_switch *) +let xk_ISO_Group_Latch = 0xFE06 +let xk_ISO_Group_Lock = 0xFE07 +let xk_ISO_Next_Group = 0xFE08 +let xk_ISO_Next_Group_Lock = 0xFE09 +let xk_ISO_Prev_Group = 0xFE0A +let xk_ISO_Prev_Group_Lock = 0xFE0B +let xk_ISO_First_Group = 0xFE0C +let xk_ISO_First_Group_Lock = 0xFE0D +let xk_ISO_Last_Group = 0xFE0E +let xk_ISO_Last_Group_Lock = 0xFE0F + +let xk_ISO_Left_Tab = 0xFE20 +let xk_ISO_Move_Line_Up = 0xFE21 +let xk_ISO_Move_Line_Down = 0xFE22 +let xk_ISO_Partial_Line_Up = 0xFE23 +let xk_ISO_Partial_Line_Down = 0xFE24 +let xk_ISO_Partial_Space_Left = 0xFE25 +let xk_ISO_Partial_Space_Right = 0xFE26 +let xk_ISO_Set_Margin_Left = 0xFE27 +let xk_ISO_Set_Margin_Right = 0xFE28 +let xk_ISO_Release_Margin_Left = 0xFE29 +let xk_ISO_Release_Margin_Right = 0xFE2A +let xk_ISO_Release_Both_Margins = 0xFE2B +let xk_ISO_Fast_Cursor_Left = 0xFE2C +let xk_ISO_Fast_Cursor_Right = 0xFE2D +let xk_ISO_Fast_Cursor_Up = 0xFE2E +let xk_ISO_Fast_Cursor_Down = 0xFE2F +let xk_ISO_Continuous_Underline = 0xFE30 +let xk_ISO_Discontinuous_Underline = 0xFE31 +let xk_ISO_Emphasize = 0xFE32 +let xk_ISO_Center_Object = 0xFE33 +let xk_ISO_Enter = 0xFE34 + +let xk_dead_grave = 0xFE50 +let xk_dead_acute = 0xFE51 +let xk_dead_circumflex = 0xFE52 +let xk_dead_tilde = 0xFE53 +let xk_dead_macron = 0xFE54 +let xk_dead_breve = 0xFE55 +let xk_dead_abovedot = 0xFE56 +let xk_dead_diaeresis = 0xFE57 +let xk_dead_abovering = 0xFE58 +let xk_dead_doubleacute = 0xFE59 +let xk_dead_caron = 0xFE5A +let xk_dead_cedilla = 0xFE5B +let xk_dead_ogonek = 0xFE5C +let xk_dead_iota = 0xFE5D +let xk_dead_voiced_sound = 0xFE5E +let xk_dead_semivoiced_sound = 0xFE5F +let xk_dead_belowdot = 0xFE60 + +let xk_First_Virtual_Screen = 0xFED0 +let xk_Prev_Virtual_Screen = 0xFED1 +let xk_Next_Virtual_Screen = 0xFED2 +let xk_Last_Virtual_Screen = 0xFED4 +let xk_Terminate_Server = 0xFED5 + +let xk_AccessX_Enable = 0xFE70 +let xk_AccessX_Feedback_Enable = 0xFE71 +let xk_RepeatKeys_Enable = 0xFE72 +let xk_SlowKeys_Enable = 0xFE73 +let xk_BounceKeys_Enable = 0xFE74 +let xk_StickyKeys_Enable = 0xFE75 +let xk_MouseKeys_Enable = 0xFE76 +let xk_MouseKeys_Accel_Enable = 0xFE77 +let xk_Overlay1_Enable = 0xFE78 +let xk_Overlay2_Enable = 0xFE79 +let xk_AudibleBell_Enable = 0xFE7A + +let xk_Pointer_Left = 0xFEE0 +let xk_Pointer_Right = 0xFEE1 +let xk_Pointer_Up = 0xFEE2 +let xk_Pointer_Down = 0xFEE3 +let xk_Pointer_UpLeft = 0xFEE4 +let xk_Pointer_UpRight = 0xFEE5 +let xk_Pointer_DownLeft = 0xFEE6 +let xk_Pointer_DownRight = 0xFEE7 +let xk_Pointer_Button_Dflt = 0xFEE8 +let xk_Pointer_Button1 = 0xFEE9 +let xk_Pointer_Button2 = 0xFEEA +let xk_Pointer_Button3 = 0xFEEB +let xk_Pointer_Button4 = 0xFEEC +let xk_Pointer_Button5 = 0xFEED +let xk_Pointer_DblClick_Dflt = 0xFEEE +let xk_Pointer_DblClick1 = 0xFEEF +let xk_Pointer_DblClick2 = 0xFEF0 +let xk_Pointer_DblClick3 = 0xFEF1 +let xk_Pointer_DblClick4 = 0xFEF2 +let xk_Pointer_DblClick5 = 0xFEF3 +let xk_Pointer_Drag_Dflt = 0xFEF4 +let xk_Pointer_Drag1 = 0xFEF5 +let xk_Pointer_Drag2 = 0xFEF6 +let xk_Pointer_Drag3 = 0xFEF7 +let xk_Pointer_Drag4 = 0xFEF8 +let xk_Pointer_Drag5 = 0xFEFD + +let xk_Pointer_EnableKeys = 0xFEF9 +let xk_Pointer_Accelerate = 0xFEFA +let xk_Pointer_DfltBtnNext = 0xFEFB +let xk_Pointer_DfltBtnPrev = 0xFEFC + + + +(* + * 3270 Terminal Keys + * Byte 3 = = 0xFD + *) + + +let xk_3270_Duplicate = 0xFD01 +let xk_3270_FieldMark = 0xFD02 +let xk_3270_Right2 = 0xFD03 +let xk_3270_Left2 = 0xFD04 +let xk_3270_BackTab = 0xFD05 +let xk_3270_EraseEOF = 0xFD06 +let xk_3270_EraseInput = 0xFD07 +let xk_3270_Reset = 0xFD08 +let xk_3270_Quit = 0xFD09 +let xk_3270_PA1 = 0xFD0A +let xk_3270_PA2 = 0xFD0B +let xk_3270_PA3 = 0xFD0C +let xk_3270_Test = 0xFD0D +let xk_3270_Attn = 0xFD0E +let xk_3270_CursorBlink = 0xFD0F +let xk_3270_AltCursor = 0xFD10 +let xk_3270_KeyClick = 0xFD11 +let xk_3270_Jump = 0xFD12 +let xk_3270_Ident = 0xFD13 +let xk_3270_Rule = 0xFD14 +let xk_3270_Copy = 0xFD15 +let xk_3270_Play = 0xFD16 +let xk_3270_Setup = 0xFD17 +let xk_3270_Record = 0xFD18 +let xk_3270_ChangeScreen = 0xFD19 +let xk_3270_DeleteWord = 0xFD1A +let xk_3270_ExSelect = 0xFD1B +let xk_3270_CursorSelect = 0xFD1C +let xk_3270_PrintScreen = 0xFD1D +let xk_3270_Enter = 0xFD1E + + +(* + * Latin 1 + * Byte 3 = 0 + *) + +let xk_space = 0x020 +let xk_exclam = 0x021 +let xk_quotedbl = 0x022 +let xk_numbersign = 0x023 +let xk_dollar = 0x024 +let xk_percent = 0x025 +let xk_ampersand = 0x026 +let xk_apostrophe = 0x027 +let xk_quoteright = 0x027 (** deprecated *) +let xk_parenleft = 0x028 +let xk_parenright = 0x029 +let xk_asterisk = 0x02a +let xk_plus = 0x02b +let xk_comma = 0x02c +let xk_minus = 0x02d +let xk_period = 0x02e +let xk_slash = 0x02f +let xk_0 = 0x030 +let xk_1 = 0x031 +let xk_2 = 0x032 +let xk_3 = 0x033 +let xk_4 = 0x034 +let xk_5 = 0x035 +let xk_6 = 0x036 +let xk_7 = 0x037 +let xk_8 = 0x038 +let xk_9 = 0x039 +let xk_colon = 0x03a +let xk_semicolon = 0x03b +let xk_less = 0x03c +let xk_equal = 0x03d +let xk_greater = 0x03e +let xk_question = 0x03f +let xk_at = 0x040 +let xk_A = 0x041 +let xk_B = 0x042 +let xk_C = 0x043 +let xk_D = 0x044 +let xk_E = 0x045 +let xk_F = 0x046 +let xk_G = 0x047 +let xk_H = 0x048 +let xk_I = 0x049 +let xk_J = 0x04a +let xk_K = 0x04b +let xk_L = 0x04c +let xk_M = 0x04d +let xk_N = 0x04e +let xk_O = 0x04f +let xk_P = 0x050 +let xk_Q = 0x051 +let xk_R = 0x052 +let xk_S = 0x053 +let xk_T = 0x054 +let xk_U = 0x055 +let xk_V = 0x056 +let xk_W = 0x057 +let xk_X = 0x058 +let xk_Y = 0x059 +let xk_Z = 0x05a +let xk_bracketleft = 0x05b +let xk_backslash = 0x05c +let xk_bracketright = 0x05d +let xk_asciicircum = 0x05e +let xk_underscore = 0x05f +let xk_grave = 0x060 +let xk_quoteleft = 0x060 (** deprecated *) +let xk_a = 0x061 +let xk_b = 0x062 +let xk_c = 0x063 +let xk_d = 0x064 +let xk_e = 0x065 +let xk_f = 0x066 +let xk_g = 0x067 +let xk_h = 0x068 +let xk_i = 0x069 +let xk_j = 0x06a +let xk_k = 0x06b +let xk_l = 0x06c +let xk_m = 0x06d +let xk_n = 0x06e +let xk_o = 0x06f +let xk_p = 0x070 +let xk_q = 0x071 +let xk_r = 0x072 +let xk_s = 0x073 +let xk_t = 0x074 +let xk_u = 0x075 +let xk_v = 0x076 +let xk_w = 0x077 +let xk_x = 0x078 +let xk_y = 0x079 +let xk_z = 0x07a +let xk_braceleft = 0x07b +let xk_bar = 0x07c +let xk_braceright = 0x07d +let xk_asciitilde = 0x07e + +let xk_nobreakspace = 0x0a0 +let xk_exclamdown = 0x0a1 +let xk_cent = 0x0a2 +let xk_sterling = 0x0a3 +let xk_currency = 0x0a4 +let xk_yen = 0x0a5 +let xk_brokenbar = 0x0a6 +let xk_section = 0x0a7 +let xk_diaeresis = 0x0a8 +let xk_copyright = 0x0a9 +let xk_ordfeminine = 0x0aa +let xk_guillemotleft = 0x0ab (** left angle quotation mark *) +let xk_notsign = 0x0ac +let xk_hyphen = 0x0ad +let xk_registered = 0x0ae +let xk_macron = 0x0af +let xk_degree = 0x0b0 +let xk_plusminus = 0x0b1 +let xk_twosuperior = 0x0b2 +let xk_threesuperior = 0x0b3 +let xk_acute = 0x0b4 +let xk_mu = 0x0b5 +let xk_paragraph = 0x0b6 +let xk_periodcentered = 0x0b7 +let xk_cedilla = 0x0b8 +let xk_onesuperior = 0x0b9 +let xk_masculine = 0x0ba +let xk_guillemotright = 0x0bb (** right angle quotation mark *) +let xk_onequarter = 0x0bc +let xk_onehalf = 0x0bd +let xk_threequarters = 0x0be +let xk_questiondown = 0x0bf +let xk_Agrave = 0x0c0 +let xk_Aacute = 0x0c1 +let xk_Acircumflex = 0x0c2 +let xk_Atilde = 0x0c3 +let xk_Adiaeresis = 0x0c4 +let xk_Aring = 0x0c5 +let xk_AE = 0x0c6 +let xk_Ccedilla = 0x0c7 +let xk_Egrave = 0x0c8 +let xk_Eacute = 0x0c9 +let xk_Ecircumflex = 0x0ca +let xk_Ediaeresis = 0x0cb +let xk_Igrave = 0x0cc +let xk_Iacute = 0x0cd +let xk_Icircumflex = 0x0ce +let xk_Idiaeresis = 0x0cf +let xk_ETH = 0x0d0 +let xk_Eth = 0x0d0 (** deprecated *) +let xk_Ntilde = 0x0d1 +let xk_Ograve = 0x0d2 +let xk_Oacute = 0x0d3 +let xk_Ocircumflex = 0x0d4 +let xk_Otilde = 0x0d5 +let xk_Odiaeresis = 0x0d6 +let xk_multiply = 0x0d7 +let xk_Ooblique = 0x0d8 +let xk_Ugrave = 0x0d9 +let xk_Uacute = 0x0da +let xk_Ucircumflex = 0x0db +let xk_Udiaeresis = 0x0dc +let xk_Yacute = 0x0dd +let xk_THORN = 0x0de +let xk_Thorn = 0x0de (** deprecated *) +let xk_ssharp = 0x0df +let xk_agrave = 0x0e0 +let xk_aacute = 0x0e1 +let xk_acircumflex = 0x0e2 +let xk_atilde = 0x0e3 +let xk_adiaeresis = 0x0e4 +let xk_aring = 0x0e5 +let xk_ae = 0x0e6 +let xk_ccedilla = 0x0e7 +let xk_egrave = 0x0e8 +let xk_eacute = 0x0e9 +let xk_ecircumflex = 0x0ea +let xk_ediaeresis = 0x0eb +let xk_igrave = 0x0ec +let xk_iacute = 0x0ed +let xk_icircumflex = 0x0ee +let xk_idiaeresis = 0x0ef +let xk_eth = 0x0f0 +let xk_ntilde = 0x0f1 +let xk_ograve = 0x0f2 +let xk_oacute = 0x0f3 +let xk_ocircumflex = 0x0f4 +let xk_otilde = 0x0f5 +let xk_odiaeresis = 0x0f6 +let xk_division = 0x0f7 +let xk_oslash = 0x0f8 +let xk_ugrave = 0x0f9 +let xk_uacute = 0x0fa +let xk_ucircumflex = 0x0fb +let xk_udiaeresis = 0x0fc +let xk_yacute = 0x0fd +let xk_thorn = 0x0fe +let xk_ydiaeresis = 0x0ff + + +(* + * Latin 2 + * Byte 3 = 1 + *) + + +let xk_Aogonek = 0x1a1 +let xk_breve = 0x1a2 +let xk_Lstroke = 0x1a3 +let xk_Lcaron = 0x1a5 +let xk_Sacute = 0x1a6 +let xk_Scaron = 0x1a9 +let xk_Scedilla = 0x1aa +let xk_Tcaron = 0x1ab +let xk_Zacute = 0x1ac +let xk_Zcaron = 0x1ae +let xk_Zabovedot = 0x1af +let xk_aogonek = 0x1b1 +let xk_ogonek = 0x1b2 +let xk_lstroke = 0x1b3 +let xk_lcaron = 0x1b5 +let xk_sacute = 0x1b6 +let xk_caron = 0x1b7 +let xk_scaron = 0x1b9 +let xk_scedilla = 0x1ba +let xk_tcaron = 0x1bb +let xk_zacute = 0x1bc +let xk_doubleacute = 0x1bd +let xk_zcaron = 0x1be +let xk_zabovedot = 0x1bf +let xk_Racute = 0x1c0 +let xk_Abreve = 0x1c3 +let xk_Lacute = 0x1c5 +let xk_Cacute = 0x1c6 +let xk_Ccaron = 0x1c8 +let xk_Eogonek = 0x1ca +let xk_Ecaron = 0x1cc +let xk_Dcaron = 0x1cf +let xk_Dstroke = 0x1d0 +let xk_Nacute = 0x1d1 +let xk_Ncaron = 0x1d2 +let xk_Odoubleacute = 0x1d5 +let xk_Rcaron = 0x1d8 +let xk_Uring = 0x1d9 +let xk_Udoubleacute = 0x1db +let xk_Tcedilla = 0x1de +let xk_racute = 0x1e0 +let xk_abreve = 0x1e3 +let xk_lacute = 0x1e5 +let xk_cacute = 0x1e6 +let xk_ccaron = 0x1e8 +let xk_eogonek = 0x1ea +let xk_ecaron = 0x1ec +let xk_dcaron = 0x1ef +let xk_dstroke = 0x1f0 +let xk_nacute = 0x1f1 +let xk_ncaron = 0x1f2 +let xk_odoubleacute = 0x1f5 +let xk_udoubleacute = 0x1fb +let xk_rcaron = 0x1f8 +let xk_uring = 0x1f9 +let xk_tcedilla = 0x1fe +let xk_abovedot = 0x1ff + + +(* + * Latin 3 + * Byte 3 = 2 + *) + + +let xk_Hstroke = 0x2a1 +let xk_Hcircumflex = 0x2a6 +let xk_Iabovedot = 0x2a9 +let xk_Gbreve = 0x2ab +let xk_Jcircumflex = 0x2ac +let xk_hstroke = 0x2b1 +let xk_hcircumflex = 0x2b6 +let xk_idotless = 0x2b9 +let xk_gbreve = 0x2bb +let xk_jcircumflex = 0x2bc +let xk_Cabovedot = 0x2c5 +let xk_Ccircumflex = 0x2c6 +let xk_Gabovedot = 0x2d5 +let xk_Gcircumflex = 0x2d8 +let xk_Ubreve = 0x2dd +let xk_Scircumflex = 0x2de +let xk_cabovedot = 0x2e5 +let xk_ccircumflex = 0x2e6 +let xk_gabovedot = 0x2f5 +let xk_gcircumflex = 0x2f8 +let xk_ubreve = 0x2fd +let xk_scircumflex = 0x2fe + + + +(* + * Latin 4 + * Byte 3 = 3 + *) + + +let xk_kra = 0x3a2 +let xk_kappa = 0x3a2 (** deprecated *) +let xk_Rcedilla = 0x3a3 +let xk_Itilde = 0x3a5 +let xk_Lcedilla = 0x3a6 +let xk_Emacron = 0x3aa +let xk_Gcedilla = 0x3ab +let xk_Tslash = 0x3ac +let xk_rcedilla = 0x3b3 +let xk_itilde = 0x3b5 +let xk_lcedilla = 0x3b6 +let xk_emacron = 0x3ba +let xk_gcedilla = 0x3bb +let xk_tslash = 0x3bc +let xk_ENG = 0x3bd +let xk_eng = 0x3bf +let xk_Amacron = 0x3c0 +let xk_Iogonek = 0x3c7 +let xk_Eabovedot = 0x3cc +let xk_Imacron = 0x3cf +let xk_Ncedilla = 0x3d1 +let xk_Omacron = 0x3d2 +let xk_Kcedilla = 0x3d3 +let xk_Uogonek = 0x3d9 +let xk_Utilde = 0x3dd +let xk_Umacron = 0x3de +let xk_amacron = 0x3e0 +let xk_iogonek = 0x3e7 +let xk_eabovedot = 0x3ec +let xk_imacron = 0x3ef +let xk_ncedilla = 0x3f1 +let xk_omacron = 0x3f2 +let xk_kcedilla = 0x3f3 +let xk_uogonek = 0x3f9 +let xk_utilde = 0x3fd +let xk_umacron = 0x3fe + + +(* + * Katakana + * Byte 3 = 4 + *) + + +let xk_overline = 0x47e +let xk_kana_fullstop = 0x4a1 +let xk_kana_openingbracket = 0x4a2 +let xk_kana_closingbracket = 0x4a3 +let xk_kana_comma = 0x4a4 +let xk_kana_conjunctive = 0x4a5 +let xk_kana_middledot = 0x4a5 (** deprecated *) +let xk_kana_WO = 0x4a6 +let xk_kana_a = 0x4a7 +let xk_kana_i = 0x4a8 +let xk_kana_u = 0x4a9 +let xk_kana_e = 0x4aa +let xk_kana_o = 0x4ab +let xk_kana_ya = 0x4ac +let xk_kana_yu = 0x4ad +let xk_kana_yo = 0x4ae +let xk_kana_tsu = 0x4af +let xk_kana_tu = 0x4af (** deprecated *) +let xk_prolongedsound = 0x4b0 +let xk_kana_A = 0x4b1 +let xk_kana_I = 0x4b2 +let xk_kana_U = 0x4b3 +let xk_kana_E = 0x4b4 +let xk_kana_O = 0x4b5 +let xk_kana_KA = 0x4b6 +let xk_kana_KI = 0x4b7 +let xk_kana_KU = 0x4b8 +let xk_kana_KE = 0x4b9 +let xk_kana_KO = 0x4ba +let xk_kana_SA = 0x4bb +let xk_kana_SHI = 0x4bc +let xk_kana_SU = 0x4bd +let xk_kana_SE = 0x4be +let xk_kana_SO = 0x4bf +let xk_kana_TA = 0x4c0 +let xk_kana_CHI = 0x4c1 +let xk_kana_TI = 0x4c1 (** deprecated *) +let xk_kana_TSU = 0x4c2 +let xk_kana_TU = 0x4c2 (** deprecated *) +let xk_kana_TE = 0x4c3 +let xk_kana_TO = 0x4c4 +let xk_kana_NA = 0x4c5 +let xk_kana_NI = 0x4c6 +let xk_kana_NU = 0x4c7 +let xk_kana_NE = 0x4c8 +let xk_kana_NO = 0x4c9 +let xk_kana_HA = 0x4ca +let xk_kana_HI = 0x4cb +let xk_kana_FU = 0x4cc +let xk_kana_HU = 0x4cc (** deprecated *) +let xk_kana_HE = 0x4cd +let xk_kana_HO = 0x4ce +let xk_kana_MA = 0x4cf +let xk_kana_MI = 0x4d0 +let xk_kana_MU = 0x4d1 +let xk_kana_ME = 0x4d2 +let xk_kana_MO = 0x4d3 +let xk_kana_YA = 0x4d4 +let xk_kana_YU = 0x4d5 +let xk_kana_YO = 0x4d6 +let xk_kana_RA = 0x4d7 +let xk_kana_RI = 0x4d8 +let xk_kana_RU = 0x4d9 +let xk_kana_RE = 0x4da +let xk_kana_RO = 0x4db +let xk_kana_WA = 0x4dc +let xk_kana_N = 0x4dd +let xk_voicedsound = 0x4de +let xk_semivoicedsound = 0x4df +let xk_kana_switch = 0xFF7E (** Alias for mode_switch *) + + +(* + * Arabic + * Byte 3 = 5 + *) + + +let xk_Arabic_comma = 0x5ac +let xk_Arabic_semicolon = 0x5bb +let xk_Arabic_question_mark = 0x5bf +let xk_Arabic_hamza = 0x5c1 +let xk_Arabic_maddaonalef = 0x5c2 +let xk_Arabic_hamzaonalef = 0x5c3 +let xk_Arabic_hamzaonwaw = 0x5c4 +let xk_Arabic_hamzaunderalef = 0x5c5 +let xk_Arabic_hamzaonyeh = 0x5c6 +let xk_Arabic_alef = 0x5c7 +let xk_Arabic_beh = 0x5c8 +let xk_Arabic_tehmarbuta = 0x5c9 +let xk_Arabic_teh = 0x5ca +let xk_Arabic_theh = 0x5cb +let xk_Arabic_jeem = 0x5cc +let xk_Arabic_hah = 0x5cd +let xk_Arabic_khah = 0x5ce +let xk_Arabic_dal = 0x5cf +let xk_Arabic_thal = 0x5d0 +let xk_Arabic_ra = 0x5d1 +let xk_Arabic_zain = 0x5d2 +let xk_Arabic_seen = 0x5d3 +let xk_Arabic_sheen = 0x5d4 +let xk_Arabic_sad = 0x5d5 +let xk_Arabic_dad = 0x5d6 +let xk_Arabic_tah = 0x5d7 +let xk_Arabic_zah = 0x5d8 +let xk_Arabic_ain = 0x5d9 +let xk_Arabic_ghain = 0x5da +let xk_Arabic_tatweel = 0x5e0 +let xk_Arabic_feh = 0x5e1 +let xk_Arabic_qaf = 0x5e2 +let xk_Arabic_kaf = 0x5e3 +let xk_Arabic_lam = 0x5e4 +let xk_Arabic_meem = 0x5e5 +let xk_Arabic_noon = 0x5e6 +let xk_Arabic_ha = 0x5e7 +let xk_Arabic_heh = 0x5e7 (** deprecated *) +let xk_Arabic_waw = 0x5e8 +let xk_Arabic_alefmaksura = 0x5e9 +let xk_Arabic_yeh = 0x5ea +let xk_Arabic_fathatan = 0x5eb +let xk_Arabic_dammatan = 0x5ec +let xk_Arabic_kasratan = 0x5ed +let xk_Arabic_fatha = 0x5ee +let xk_Arabic_damma = 0x5ef +let xk_Arabic_kasra = 0x5f0 +let xk_Arabic_shadda = 0x5f1 +let xk_Arabic_sukun = 0x5f2 +let xk_Arabic_switch = 0xFF7E (** Alias for mode_switch *) + + +(* + * Cyrillic + * Byte 3 = 6 + *) + +let xk_Serbian_dje = 0x6a1 +let xk_Macedonia_gje = 0x6a2 +let xk_Cyrillic_io = 0x6a3 +let xk_Ukrainian_ie = 0x6a4 +let xk_Ukranian_je = 0x6a4 (** deprecated *) +let xk_Macedonia_dse = 0x6a5 +let xk_Ukrainian_i = 0x6a6 +let xk_Ukranian_i = 0x6a6 (** deprecated *) +let xk_Ukrainian_yi = 0x6a7 +let xk_Ukranian_yi = 0x6a7 (** deprecated *) +let xk_Cyrillic_je = 0x6a8 +let xk_Serbian_je = 0x6a8 (** deprecated *) +let xk_Cyrillic_lje = 0x6a9 +let xk_Serbian_lje = 0x6a9 (** deprecated *) +let xk_Cyrillic_nje = 0x6aa +let xk_Serbian_nje = 0x6aa (** deprecated *) +let xk_Serbian_tshe = 0x6ab +let xk_Macedonia_kje = 0x6ac +let xk_Byelorussian_shortu = 0x6ae +let xk_Cyrillic_dzhe = 0x6af +let xk_Serbian_dze = 0x6af (** deprecated *) +let xk_numerosign = 0x6b0 +let xk_Serbian_DJE = 0x6b1 +let xk_Macedonia_GJE = 0x6b2 +let xk_Cyrillic_IO = 0x6b3 +let xk_Ukrainian_IE = 0x6b4 +let xk_Ukranian_JE = 0x6b4 (** deprecated *) +let xk_Macedonia_DSE = 0x6b5 +let xk_Ukrainian_I = 0x6b6 +let xk_Ukranian_I = 0x6b6 (** deprecated *) +let xk_Ukrainian_YI = 0x6b7 +let xk_Ukranian_YI = 0x6b7 (** deprecated *) +let xk_Cyrillic_JE = 0x6b8 +let xk_Serbian_JE = 0x6b8 (** deprecated *) +let xk_Cyrillic_LJE = 0x6b9 +let xk_Serbian_LJE = 0x6b9 (** deprecated *) +let xk_Cyrillic_NJE = 0x6ba +let xk_Serbian_NJE = 0x6ba (** deprecated *) +let xk_Serbian_TSHE = 0x6bb +let xk_Macedonia_KJE = 0x6bc +let xk_Byelorussian_SHORTU = 0x6be +let xk_Cyrillic_DZHE = 0x6bf +let xk_Serbian_DZE = 0x6bf (** deprecated *) +let xk_Cyrillic_yu = 0x6c0 +let xk_Cyrillic_a = 0x6c1 +let xk_Cyrillic_be = 0x6c2 +let xk_Cyrillic_tse = 0x6c3 +let xk_Cyrillic_de = 0x6c4 +let xk_Cyrillic_ie = 0x6c5 +let xk_Cyrillic_ef = 0x6c6 +let xk_Cyrillic_ghe = 0x6c7 +let xk_Cyrillic_ha = 0x6c8 +let xk_Cyrillic_i = 0x6c9 +let xk_Cyrillic_shorti = 0x6ca +let xk_Cyrillic_ka = 0x6cb +let xk_Cyrillic_el = 0x6cc +let xk_Cyrillic_em = 0x6cd +let xk_Cyrillic_en = 0x6ce +let xk_Cyrillic_o = 0x6cf +let xk_Cyrillic_pe = 0x6d0 +let xk_Cyrillic_ya = 0x6d1 +let xk_Cyrillic_er = 0x6d2 +let xk_Cyrillic_es = 0x6d3 +let xk_Cyrillic_te = 0x6d4 +let xk_Cyrillic_u = 0x6d5 +let xk_Cyrillic_zhe = 0x6d6 +let xk_Cyrillic_ve = 0x6d7 +let xk_Cyrillic_softsign = 0x6d8 +let xk_Cyrillic_yeru = 0x6d9 +let xk_Cyrillic_ze = 0x6da +let xk_Cyrillic_sha = 0x6db +let xk_Cyrillic_e = 0x6dc +let xk_Cyrillic_shcha = 0x6dd +let xk_Cyrillic_che = 0x6de +let xk_Cyrillic_hardsign = 0x6df +let xk_Cyrillic_YU = 0x6e0 +let xk_Cyrillic_A = 0x6e1 +let xk_Cyrillic_BE = 0x6e2 +let xk_Cyrillic_TSE = 0x6e3 +let xk_Cyrillic_DE = 0x6e4 +let xk_Cyrillic_IE = 0x6e5 +let xk_Cyrillic_EF = 0x6e6 +let xk_Cyrillic_GHE = 0x6e7 +let xk_Cyrillic_HA = 0x6e8 +let xk_Cyrillic_I = 0x6e9 +let xk_Cyrillic_SHORTI = 0x6ea +let xk_Cyrillic_KA = 0x6eb +let xk_Cyrillic_EL = 0x6ec +let xk_Cyrillic_EM = 0x6ed +let xk_Cyrillic_EN = 0x6ee +let xk_Cyrillic_O = 0x6ef +let xk_Cyrillic_PE = 0x6f0 +let xk_Cyrillic_YA = 0x6f1 +let xk_Cyrillic_ER = 0x6f2 +let xk_Cyrillic_ES = 0x6f3 +let xk_Cyrillic_TE = 0x6f4 +let xk_Cyrillic_U = 0x6f5 +let xk_Cyrillic_ZHE = 0x6f6 +let xk_Cyrillic_VE = 0x6f7 +let xk_Cyrillic_SOFTSIGN = 0x6f8 +let xk_Cyrillic_YERU = 0x6f9 +let xk_Cyrillic_ZE = 0x6fa +let xk_Cyrillic_SHA = 0x6fb +let xk_Cyrillic_E = 0x6fc +let xk_Cyrillic_SHCHA = 0x6fd +let xk_Cyrillic_CHE = 0x6fe +let xk_Cyrillic_HARDSIGN = 0x6ff + + +(* + * Greek + * Byte 3 = 7 + *) + + +let xk_Greek_ALPHAaccent = 0x7a1 +let xk_Greek_EPSILONaccent = 0x7a2 +let xk_Greek_ETAaccent = 0x7a3 +let xk_Greek_IOTAaccent = 0x7a4 +let xk_Greek_IOTAdiaeresis = 0x7a5 +let xk_Greek_OMICRONaccent = 0x7a7 +let xk_Greek_UPSILONaccent = 0x7a8 +let xk_Greek_UPSILONdieresis = 0x7a9 +let xk_Greek_OMEGAaccent = 0x7ab +let xk_Greek_accentdieresis = 0x7ae +let xk_Greek_horizbar = 0x7af +let xk_Greek_alphaaccent = 0x7b1 +let xk_Greek_epsilonaccent = 0x7b2 +let xk_Greek_etaaccent = 0x7b3 +let xk_Greek_iotaaccent = 0x7b4 +let xk_Greek_iotadieresis = 0x7b5 +let xk_Greek_iotaaccentdieresis = 0x7b6 +let xk_Greek_omicronaccent = 0x7b7 +let xk_Greek_upsilonaccent = 0x7b8 +let xk_Greek_upsilondieresis = 0x7b9 +let xk_Greek_upsilonaccentdieresis = 0x7ba +let xk_Greek_omegaaccent = 0x7bb +let xk_Greek_ALPHA = 0x7c1 +let xk_Greek_BETA = 0x7c2 +let xk_Greek_GAMMA = 0x7c3 +let xk_Greek_DELTA = 0x7c4 +let xk_Greek_EPSILON = 0x7c5 +let xk_Greek_ZETA = 0x7c6 +let xk_Greek_ETA = 0x7c7 +let xk_Greek_THETA = 0x7c8 +let xk_Greek_IOTA = 0x7c9 +let xk_Greek_KAPPA = 0x7ca +let xk_Greek_LAMDA = 0x7cb +let xk_Greek_LAMBDA = 0x7cb +let xk_Greek_MU = 0x7cc +let xk_Greek_NU = 0x7cd +let xk_Greek_XI = 0x7ce +let xk_Greek_OMICRON = 0x7cf +let xk_Greek_PI = 0x7d0 +let xk_Greek_RHO = 0x7d1 +let xk_Greek_SIGMA = 0x7d2 +let xk_Greek_TAU = 0x7d4 +let xk_Greek_UPSILON = 0x7d5 +let xk_Greek_PHI = 0x7d6 +let xk_Greek_CHI = 0x7d7 +let xk_Greek_PSI = 0x7d8 +let xk_Greek_OMEGA = 0x7d9 +let xk_Greek_alpha = 0x7e1 +let xk_Greek_beta = 0x7e2 +let xk_Greek_gamma = 0x7e3 +let xk_Greek_delta = 0x7e4 +let xk_Greek_epsilon = 0x7e5 +let xk_Greek_zeta = 0x7e6 +let xk_Greek_eta = 0x7e7 +let xk_Greek_theta = 0x7e8 +let xk_Greek_iota = 0x7e9 +let xk_Greek_kappa = 0x7ea +let xk_Greek_lamda = 0x7eb +let xk_Greek_lambda = 0x7eb +let xk_Greek_mu = 0x7ec +let xk_Greek_nu = 0x7ed +let xk_Greek_xi = 0x7ee +let xk_Greek_omicron = 0x7ef +let xk_Greek_pi = 0x7f0 +let xk_Greek_rho = 0x7f1 +let xk_Greek_sigma = 0x7f2 +let xk_Greek_finalsmallsigma = 0x7f3 +let xk_Greek_tau = 0x7f4 +let xk_Greek_upsilon = 0x7f5 +let xk_Greek_phi = 0x7f6 +let xk_Greek_chi = 0x7f7 +let xk_Greek_psi = 0x7f8 +let xk_Greek_omega = 0x7f9 +let xk_Greek_switch = 0xFF7E (** Alias for mode_switch *) + + +(* + * Technical + * Byte 3 = 8 + *) + + +let xk_leftradical = 0x8a1 +let xk_topleftradical = 0x8a2 +let xk_horizconnector = 0x8a3 +let xk_topintegral = 0x8a4 +let xk_botintegral = 0x8a5 +let xk_vertconnector = 0x8a6 +let xk_topleftsqbracket = 0x8a7 +let xk_botleftsqbracket = 0x8a8 +let xk_toprightsqbracket = 0x8a9 +let xk_botrightsqbracket = 0x8aa +let xk_topleftparens = 0x8ab +let xk_botleftparens = 0x8ac +let xk_toprightparens = 0x8ad +let xk_botrightparens = 0x8ae +let xk_leftmiddlecurlybrace = 0x8af +let xk_rightmiddlecurlybrace = 0x8b0 +let xk_topleftsummation = 0x8b1 +let xk_botleftsummation = 0x8b2 +let xk_topvertsummationconnector = 0x8b3 +let xk_botvertsummationconnector = 0x8b4 +let xk_toprightsummation = 0x8b5 +let xk_botrightsummation = 0x8b6 +let xk_rightmiddlesummation = 0x8b7 +let xk_lessthanequal = 0x8bc +let xk_notequal = 0x8bd +let xk_greaterthanequal = 0x8be +let xk_integral = 0x8bf +let xk_therefore = 0x8c0 +let xk_variation = 0x8c1 +let xk_infinity = 0x8c2 +let xk_nabla = 0x8c5 +let xk_approximate = 0x8c8 +let xk_similarequal = 0x8c9 +let xk_ifonlyif = 0x8cd +let xk_implies = 0x8ce +let xk_identical = 0x8cf +let xk_radical = 0x8d6 +let xk_includedin = 0x8da +let xk_includes = 0x8db +let xk_intersection = 0x8dc +let xk_union = 0x8dd +let xk_logicaland = 0x8de +let xk_logicalor = 0x8df +let xk_partialderivative = 0x8ef +let xk_function = 0x8f6 +let xk_leftarrow = 0x8fb +let xk_uparrow = 0x8fc +let xk_rightarrow = 0x8fd +let xk_downarrow = 0x8fe + + +(* + * Special + * Byte 3 = 9 + *) + + +let xk_blank = 0x9df +let xk_soliddiamond = 0x9e0 +let xk_checkerboard = 0x9e1 +let xk_ht = 0x9e2 +let xk_ff = 0x9e3 +let xk_cr = 0x9e4 +let xk_lf = 0x9e5 +let xk_nl = 0x9e8 +let xk_vt = 0x9e9 +let xk_lowrightcorner = 0x9ea +let xk_uprightcorner = 0x9eb +let xk_upleftcorner = 0x9ec +let xk_lowleftcorner = 0x9ed +let xk_crossinglines = 0x9ee +let xk_horizlinescan1 = 0x9ef +let xk_horizlinescan3 = 0x9f0 +let xk_horizlinescan5 = 0x9f1 +let xk_horizlinescan7 = 0x9f2 +let xk_horizlinescan9 = 0x9f3 +let xk_leftt = 0x9f4 +let xk_rightt = 0x9f5 +let xk_bott = 0x9f6 +let xk_topt = 0x9f7 +let xk_vertbar = 0x9f8 + + +(* + * Publishing + * Byte 3 = a + *) + + +let xk_emspace = 0xaa1 +let xk_enspace = 0xaa2 +let xk_em3space = 0xaa3 +let xk_em4space = 0xaa4 +let xk_digitspace = 0xaa5 +let xk_punctspace = 0xaa6 +let xk_thinspace = 0xaa7 +let xk_hairspace = 0xaa8 +let xk_emdash = 0xaa9 +let xk_endash = 0xaaa +let xk_signifblank = 0xaac +let xk_ellipsis = 0xaae +let xk_doubbaselinedot = 0xaaf +let xk_onethird = 0xab0 +let xk_twothirds = 0xab1 +let xk_onefifth = 0xab2 +let xk_twofifths = 0xab3 +let xk_threefifths = 0xab4 +let xk_fourfifths = 0xab5 +let xk_onesixth = 0xab6 +let xk_fivesixths = 0xab7 +let xk_careof = 0xab8 +let xk_figdash = 0xabb +let xk_leftanglebracket = 0xabc +let xk_decimalpoint = 0xabd +let xk_rightanglebracket = 0xabe +let xk_marker = 0xabf +let xk_oneeighth = 0xac3 +let xk_threeeighths = 0xac4 +let xk_fiveeighths = 0xac5 +let xk_seveneighths = 0xac6 +let xk_trademark = 0xac9 +let xk_signaturemark = 0xaca +let xk_trademarkincircle = 0xacb +let xk_leftopentriangle = 0xacc +let xk_rightopentriangle = 0xacd +let xk_emopencircle = 0xace +let xk_emopenrectangle = 0xacf +let xk_leftsinglequotemark = 0xad0 +let xk_rightsinglequotemark = 0xad1 +let xk_leftdoublequotemark = 0xad2 +let xk_rightdoublequotemark = 0xad3 +let xk_prescription = 0xad4 +let xk_minutes = 0xad6 +let xk_seconds = 0xad7 +let xk_latincross = 0xad9 +let xk_hexagram = 0xada +let xk_filledrectbullet = 0xadb +let xk_filledlefttribullet = 0xadc +let xk_filledrighttribullet = 0xadd +let xk_emfilledcircle = 0xade +let xk_emfilledrect = 0xadf +let xk_enopencircbullet = 0xae0 +let xk_enopensquarebullet = 0xae1 +let xk_openrectbullet = 0xae2 +let xk_opentribulletup = 0xae3 +let xk_opentribulletdown = 0xae4 +let xk_openstar = 0xae5 +let xk_enfilledcircbullet = 0xae6 +let xk_enfilledsqbullet = 0xae7 +let xk_filledtribulletup = 0xae8 +let xk_filledtribulletdown = 0xae9 +let xk_leftpointer = 0xaea +let xk_rightpointer = 0xaeb +let xk_club = 0xaec +let xk_diamond = 0xaed +let xk_heart = 0xaee +let xk_maltesecross = 0xaf0 +let xk_dagger = 0xaf1 +let xk_doubledagger = 0xaf2 +let xk_checkmark = 0xaf3 +let xk_ballotcross = 0xaf4 +let xk_musicalsharp = 0xaf5 +let xk_musicalflat = 0xaf6 +let xk_malesymbol = 0xaf7 +let xk_femalesymbol = 0xaf8 +let xk_telephone = 0xaf9 +let xk_telephonerecorder = 0xafa +let xk_phonographcopyright = 0xafb +let xk_caret = 0xafc +let xk_singlelowquotemark = 0xafd +let xk_doublelowquotemark = 0xafe +let xk_cursor = 0xaff + + +(* + * APL + * Byte 3 = b + *) + + +let xk_leftcaret = 0xba3 +let xk_rightcaret = 0xba6 +let xk_downcaret = 0xba8 +let xk_upcaret = 0xba9 +let xk_overbar = 0xbc0 +let xk_downtack = 0xbc2 +let xk_upshoe = 0xbc3 +let xk_downstile = 0xbc4 +let xk_underbar = 0xbc6 +let xk_jot = 0xbca +let xk_quad = 0xbcc +let xk_uptack = 0xbce +let xk_circle = 0xbcf +let xk_upstile = 0xbd3 +let xk_downshoe = 0xbd6 +let xk_rightshoe = 0xbd8 +let xk_leftshoe = 0xbda +let xk_lefttack = 0xbdc +let xk_righttack = 0xbfc + + +(* + * Hebrew + * Byte 3 = c + *) + + +let xk_hebrew_doublelowline = 0xcdf +let xk_hebrew_aleph = 0xce0 +let xk_hebrew_bet = 0xce1 +let xk_hebrew_beth = 0xce1 (** deprecated *) +let xk_hebrew_gimel = 0xce2 +let xk_hebrew_gimmel = 0xce2 (** deprecated *) +let xk_hebrew_dalet = 0xce3 +let xk_hebrew_daleth = 0xce3 (** deprecated *) +let xk_hebrew_he = 0xce4 +let xk_hebrew_waw = 0xce5 +let xk_hebrew_zain = 0xce6 +let xk_hebrew_zayin = 0xce6 (** deprecated *) +let xk_hebrew_chet = 0xce7 +let xk_hebrew_het = 0xce7 (** deprecated *) +let xk_hebrew_tet = 0xce8 +let xk_hebrew_teth = 0xce8 (** deprecated *) +let xk_hebrew_yod = 0xce9 +let xk_hebrew_finalkaph = 0xcea +let xk_hebrew_kaph = 0xceb +let xk_hebrew_lamed = 0xcec +let xk_hebrew_finalmem = 0xced +let xk_hebrew_mem = 0xcee +let xk_hebrew_finalnun = 0xcef +let xk_hebrew_nun = 0xcf0 +let xk_hebrew_samech = 0xcf1 +let xk_hebrew_samekh = 0xcf1 (** deprecated *) +let xk_hebrew_ayin = 0xcf2 +let xk_hebrew_finalpe = 0xcf3 +let xk_hebrew_pe = 0xcf4 +let xk_hebrew_finalzade = 0xcf5 +let xk_hebrew_finalzadi = 0xcf5 (** deprecated *) +let xk_hebrew_zade = 0xcf6 +let xk_hebrew_zadi = 0xcf6 (** deprecated *) +let xk_hebrew_qoph = 0xcf7 +let xk_hebrew_kuf = 0xcf7 (** deprecated *) +let xk_hebrew_resh = 0xcf8 +let xk_hebrew_shin = 0xcf9 +let xk_hebrew_taw = 0xcfa +let xk_hebrew_taf = 0xcfa (** deprecated *) +let xk_Hebrew_switch = 0xFF7E (** Alias for mode_switch *) + + +(* + * Thai + * Byte 3 = d + *) + + +let xk_Thai_kokai = 0xda1 +let xk_Thai_khokhai = 0xda2 +let xk_Thai_khokhuat = 0xda3 +let xk_Thai_khokhwai = 0xda4 +let xk_Thai_khokhon = 0xda5 +let xk_Thai_khorakhang = 0xda6 +let xk_Thai_ngongu = 0xda7 +let xk_Thai_chochan = 0xda8 +let xk_Thai_choching = 0xda9 +let xk_Thai_chochang = 0xdaa +let xk_Thai_soso = 0xdab +let xk_Thai_chochoe = 0xdac +let xk_Thai_yoying = 0xdad +let xk_Thai_dochada = 0xdae +let xk_Thai_topatak = 0xdaf +let xk_Thai_thothan = 0xdb0 +let xk_Thai_thonangmontho = 0xdb1 +let xk_Thai_thophuthao = 0xdb2 +let xk_Thai_nonen = 0xdb3 +let xk_Thai_dodek = 0xdb4 +let xk_Thai_totao = 0xdb5 +let xk_Thai_thothung = 0xdb6 +let xk_Thai_thothahan = 0xdb7 +let xk_Thai_thothong = 0xdb8 +let xk_Thai_nonu = 0xdb9 +let xk_Thai_bobaimai = 0xdba +let xk_Thai_popla = 0xdbb +let xk_Thai_phophung = 0xdbc +let xk_Thai_fofa = 0xdbd +let xk_Thai_phophan = 0xdbe +let xk_Thai_fofan = 0xdbf +let xk_Thai_phosamphao = 0xdc0 +let xk_Thai_moma = 0xdc1 +let xk_Thai_yoyak = 0xdc2 +let xk_Thai_rorua = 0xdc3 +let xk_Thai_ru = 0xdc4 +let xk_Thai_loling = 0xdc5 +let xk_Thai_lu = 0xdc6 +let xk_Thai_wowaen = 0xdc7 +let xk_Thai_sosala = 0xdc8 +let xk_Thai_sorusi = 0xdc9 +let xk_Thai_sosua = 0xdca +let xk_Thai_hohip = 0xdcb +let xk_Thai_lochula = 0xdcc +let xk_Thai_oang = 0xdcd +let xk_Thai_honokhuk = 0xdce +let xk_Thai_paiyannoi = 0xdcf +let xk_Thai_saraa = 0xdd0 +let xk_Thai_maihanakat = 0xdd1 +let xk_Thai_saraaa = 0xdd2 +let xk_Thai_saraam = 0xdd3 +let xk_Thai_sarai = 0xdd4 +let xk_Thai_saraii = 0xdd5 +let xk_Thai_saraue = 0xdd6 +let xk_Thai_sarauee = 0xdd7 +let xk_Thai_sarau = 0xdd8 +let xk_Thai_sarauu = 0xdd9 +let xk_Thai_phinthu = 0xdda +let xk_Thai_maihanakat_maitho = 0xdde +let xk_Thai_baht = 0xddf +let xk_Thai_sarae = 0xde0 +let xk_Thai_saraae = 0xde1 +let xk_Thai_sarao = 0xde2 +let xk_Thai_saraaimaimuan = 0xde3 +let xk_Thai_saraaimaimalai = 0xde4 +let xk_Thai_lakkhangyao = 0xde5 +let xk_Thai_maiyamok = 0xde6 +let xk_Thai_maitaikhu = 0xde7 +let xk_Thai_maiek = 0xde8 +let xk_Thai_maitho = 0xde9 +let xk_Thai_maitri = 0xdea +let xk_Thai_maichattawa = 0xdeb +let xk_Thai_thanthakhat = 0xdec +let xk_Thai_nikhahit = 0xded +let xk_Thai_leksun = 0xdf0 +let xk_Thai_leknung = 0xdf1 +let xk_Thai_leksong = 0xdf2 +let xk_Thai_leksam = 0xdf3 +let xk_Thai_leksi = 0xdf4 +let xk_Thai_lekha = 0xdf5 +let xk_Thai_lekhok = 0xdf6 +let xk_Thai_lekchet = 0xdf7 +let xk_Thai_lekpaet = 0xdf8 +let xk_Thai_lekkao = 0xdf9 + + +(* + * Korean + * Byte 3 = e + *) + + + +let xk_Hangul = 0xff31 (** Hangul start/stop(toggle) *) +let xk_Hangul_Start = 0xff32 (** Hangul start *) +let xk_Hangul_End = 0xff33 (** Hangul end, English start *) +let xk_Hangul_Hanja = 0xff34 (** Start Hangul->Hanja Conversion *) +let xk_Hangul_Jamo = 0xff35 (** Hangul Jamo mode *) +let xk_Hangul_Romaja = 0xff36 (** Hangul Romaja mode *) +let xk_Hangul_Codeinput = 0xff37 (** Hangul code input mode *) +let xk_Hangul_Jeonja = 0xff38 (** Jeonja mode *) +let xk_Hangul_Banja = 0xff39 (** Banja mode *) +let xk_Hangul_PreHanja = 0xff3a (** Pre Hanja conversion *) +let xk_Hangul_PostHanja = 0xff3b (** Post Hanja conversion *) +let xk_Hangul_SingleCandidate = 0xff3c (** Single candidate *) +let xk_Hangul_MultipleCandidate = 0xff3d (** Multiple candidate *) +let xk_Hangul_PreviousCandidate = 0xff3e (** Previous candidate *) +let xk_Hangul_Special = 0xff3f (** Special symbols *) +let xk_Hangul_switch = 0xFF7E (** Alias for mode_switch *) + +(** Hangul Consonant Characters *) +let xk_Hangul_Kiyeog = 0xea1 +let xk_Hangul_SsangKiyeog = 0xea2 +let xk_Hangul_KiyeogSios = 0xea3 +let xk_Hangul_Nieun = 0xea4 +let xk_Hangul_NieunJieuj = 0xea5 +let xk_Hangul_NieunHieuh = 0xea6 +let xk_Hangul_Dikeud = 0xea7 +let xk_Hangul_SsangDikeud = 0xea8 +let xk_Hangul_Rieul = 0xea9 +let xk_Hangul_RieulKiyeog = 0xeaa +let xk_Hangul_RieulMieum = 0xeab +let xk_Hangul_RieulPieub = 0xeac +let xk_Hangul_RieulSios = 0xead +let xk_Hangul_RieulTieut = 0xeae +let xk_Hangul_RieulPhieuf = 0xeaf +let xk_Hangul_RieulHieuh = 0xeb0 +let xk_Hangul_Mieum = 0xeb1 +let xk_Hangul_Pieub = 0xeb2 +let xk_Hangul_SsangPieub = 0xeb3 +let xk_Hangul_PieubSios = 0xeb4 +let xk_Hangul_Sios = 0xeb5 +let xk_Hangul_SsangSios = 0xeb6 +let xk_Hangul_Ieung = 0xeb7 +let xk_Hangul_Jieuj = 0xeb8 +let xk_Hangul_SsangJieuj = 0xeb9 +let xk_Hangul_Cieuc = 0xeba +let xk_Hangul_Khieuq = 0xebb +let xk_Hangul_Tieut = 0xebc +let xk_Hangul_Phieuf = 0xebd +let xk_Hangul_Hieuh = 0xebe + +(** Hangul Vowel Characters *) +let xk_Hangul_A = 0xebf +let xk_Hangul_AE = 0xec0 +let xk_Hangul_YA = 0xec1 +let xk_Hangul_YAE = 0xec2 +let xk_Hangul_EO = 0xec3 +let xk_Hangul_E = 0xec4 +let xk_Hangul_YEO = 0xec5 +let xk_Hangul_YE = 0xec6 +let xk_Hangul_O = 0xec7 +let xk_Hangul_WA = 0xec8 +let xk_Hangul_WAE = 0xec9 +let xk_Hangul_OE = 0xeca +let xk_Hangul_YO = 0xecb +let xk_Hangul_U = 0xecc +let xk_Hangul_WEO = 0xecd +let xk_Hangul_WE = 0xece +let xk_Hangul_WI = 0xecf +let xk_Hangul_YU = 0xed0 +let xk_Hangul_EU = 0xed1 +let xk_Hangul_YI = 0xed2 +let xk_Hangul_I = 0xed3 + +(** Hangul syllable-final (JongSeong) Characters *) +let xk_Hangul_J_Kiyeog = 0xed4 +let xk_Hangul_J_SsangKiyeog = 0xed5 +let xk_Hangul_J_KiyeogSios = 0xed6 +let xk_Hangul_J_Nieun = 0xed7 +let xk_Hangul_J_NieunJieuj = 0xed8 +let xk_Hangul_J_NieunHieuh = 0xed9 +let xk_Hangul_J_Dikeud = 0xeda +let xk_Hangul_J_Rieul = 0xedb +let xk_Hangul_J_RieulKiyeog = 0xedc +let xk_Hangul_J_RieulMieum = 0xedd +let xk_Hangul_J_RieulPieub = 0xede +let xk_Hangul_J_RieulSios = 0xedf +let xk_Hangul_J_RieulTieut = 0xee0 +let xk_Hangul_J_RieulPhieuf = 0xee1 +let xk_Hangul_J_RieulHieuh = 0xee2 +let xk_Hangul_J_Mieum = 0xee3 +let xk_Hangul_J_Pieub = 0xee4 +let xk_Hangul_J_PieubSios = 0xee5 +let xk_Hangul_J_Sios = 0xee6 +let xk_Hangul_J_SsangSios = 0xee7 +let xk_Hangul_J_Ieung = 0xee8 +let xk_Hangul_J_Jieuj = 0xee9 +let xk_Hangul_J_Cieuc = 0xeea +let xk_Hangul_J_Khieuq = 0xeeb +let xk_Hangul_J_Tieut = 0xeec +let xk_Hangul_J_Phieuf = 0xeed +let xk_Hangul_J_Hieuh = 0xeee + +(** Ancient Hangul Consonant Characters *) +let xk_Hangul_RieulYeorinHieuh = 0xeef +let xk_Hangul_SunkyeongeumMieum = 0xef0 +let xk_Hangul_SunkyeongeumPieub = 0xef1 +let xk_Hangul_PanSios = 0xef2 +let xk_Hangul_KkogjiDalrinIeung = 0xef3 +let xk_Hangul_SunkyeongeumPhieuf = 0xef4 +let xk_Hangul_YeorinHieuh = 0xef5 + +(** Ancient Hangul Vowel Characters *) +let xk_Hangul_AraeA = 0xef6 +let xk_Hangul_AraeAE = 0xef7 + +(** Ancient Hangul syllable-final (JongSeong) Characters *) +let xk_Hangul_J_PanSios = 0xef8 +let xk_Hangul_J_KkogjiDalrinIeung = 0xef9 +let xk_Hangul_J_YeorinHieuh = 0xefa + +(** Korean currency symbol *) +let xk_Korean_Won = 0xeff + + + +let name_to_keysym = [ +"VoidSymbol",0xFFFFFF; +"BackSpace",0xFF08; +"Tab",0xFF09; +"Linefeed",0xFF0A; +"Clear",0xFF0B; +"Return",0xFF0D; +"Pause",0xFF13; +"Scroll_Lock",0xFF14; +"Sys_Req",0xFF15; +"Escape",0xFF1B; +"Delete",0xFFFF; +"Multi_key",0xFF20; +"Kanji",0xFF21; +"Muhenkan",0xFF22; +"Henkan_Mode",0xFF23; +"Henkan",0xFF23; +"Romaji",0xFF24; +"Hiragana",0xFF25; +"Katakana",0xFF26; +"Hiragana_Katakana",0xFF27; +"Zenkaku",0xFF28; +"Hankaku",0xFF29; +"Zenkaku_Hankaku",0xFF2A; +"Touroku",0xFF2B; +"Massyo",0xFF2C; +"Kana_Lock",0xFF2D; +"Kana_Shift",0xFF2E; +"Eisu_Shift",0xFF2F; +"Eisu_toggle",0xFF30; +"Home",0xFF50; +"Left",0xFF51; +"Up",0xFF52; +"Right",0xFF53; +"Down",0xFF54; +"Prior",0xFF55; +"Page_Up",0xFF55; +"Next",0xFF56; +"Page_Down",0xFF56; +"End",0xFF57; +"Begin",0xFF58; +"Select",0xFF60; +"Print",0xFF61; +"Execute",0xFF62; +"Insert",0xFF63; +"Undo",0xFF65; +"Redo",0xFF66; +"Menu",0xFF67; +"Find",0xFF68; +"Cancel",0xFF69; +"Help",0xFF6A; +"Break",0xFF6B; +"Mode_switch",0xFF7E; +"script_switch",0xFF7E; +"Num_Lock",0xFF7F; +"KP_Space",0xFF80; +"KP_Tab",0xFF89; +"KP_Enter",0xFF8D; +"KP_F1",0xFF91; +"KP_F2",0xFF92; +"KP_F3",0xFF93; +"KP_F4",0xFF94; +"KP_Home",0xFF95; +"KP_Left",0xFF96; +"KP_Up",0xFF97; +"KP_Right",0xFF98; +"KP_Down",0xFF99; +"KP_Prior",0xFF9A; +"KP_Page_Up",0xFF9A; +"KP_Next",0xFF9B; +"KP_Page_Down",0xFF9B; +"KP_End",0xFF9C; +"KP_Begin",0xFF9D; +"KP_Insert",0xFF9E; +"KP_Delete",0xFF9F; +"KP_Equal",0xFFBD; +"KP_Multiply",0xFFAA; +"KP_Add",0xFFAB; +"KP_Separator",0xFFAC; +"KP_Subtract",0xFFAD; +"KP_Decimal",0xFFAE; +"KP_Divide",0xFFAF; +"KP_0",0xFFB0; +"KP_1",0xFFB1; +"KP_2",0xFFB2; +"KP_3",0xFFB3; +"KP_4",0xFFB4; +"KP_5",0xFFB5; +"KP_6",0xFFB6; +"KP_7",0xFFB7; +"KP_8",0xFFB8; +"KP_9",0xFFB9; +"F1",0xFFBE; +"F2",0xFFBF; +"F3",0xFFC0; +"F4",0xFFC1; +"F5",0xFFC2; +"F6",0xFFC3; +"F7",0xFFC4; +"F8",0xFFC5; +"F9",0xFFC6; +"F10",0xFFC7; +"F11",0xFFC8; +"L1",0xFFC8; +"F12",0xFFC9; +"L2",0xFFC9; +"F13",0xFFCA; +"L3",0xFFCA; +"F14",0xFFCB; +"L4",0xFFCB; +"F15",0xFFCC; +"L5",0xFFCC; +"F16",0xFFCD; +"L6",0xFFCD; +"F17",0xFFCE; +"L7",0xFFCE; +"F18",0xFFCF; +"L8",0xFFCF; +"F19",0xFFD0; +"L9",0xFFD0; +"F20",0xFFD1; +"L10",0xFFD1; +"F21",0xFFD2; +"R1",0xFFD2; +"F22",0xFFD3; +"R2",0xFFD3; +"F23",0xFFD4; +"R3",0xFFD4; +"F24",0xFFD5; +"R4",0xFFD5; +"F25",0xFFD6; +"R5",0xFFD6; +"F26",0xFFD7; +"R6",0xFFD7; +"F27",0xFFD8; +"R7",0xFFD8; +"F28",0xFFD9; +"R8",0xFFD9; +"F29",0xFFDA; +"R9",0xFFDA; +"F30",0xFFDB; +"R10",0xFFDB; +"F31",0xFFDC; +"R11",0xFFDC; +"F32",0xFFDD; +"R12",0xFFDD; +"F33",0xFFDE; +"R13",0xFFDE; +"F34",0xFFDF; +"R14",0xFFDF; +"F35",0xFFE0; +"R15",0xFFE0; +"Shift_L",0xFFE1; +"Shift_R",0xFFE2; +"Control_L",0xFFE3; +"Control_R",0xFFE4; +"Caps_Lock",0xFFE5; +"Shift_Lock",0xFFE6; +"Meta_L",0xFFE7; +"Meta_R",0xFFE8; +"Alt_L",0xFFE9; +"Alt_R",0xFFEA; +"Super_L",0xFFEB; +"Super_R",0xFFEC; +"Hyper_L",0xFFED; +"Hyper_R",0xFFEE; +"ISO_Lock",0xFE01; +"ISO_Level2_Latch",0xFE02; +"ISO_Level3_Shift",0xFE03; +"ISO_Level3_Latch",0xFE04; +"ISO_Level3_Lock",0xFE05; +"ISO_Group_Shift",0xFF7E; +"ISO_Group_Latch",0xFE06; +"ISO_Group_Lock",0xFE07; +"ISO_Next_Group",0xFE08; +"ISO_Next_Group_Lock",0xFE09; +"ISO_Prev_Group",0xFE0A; +"ISO_Prev_Group_Lock",0xFE0B; +"ISO_First_Group",0xFE0C; +"ISO_First_Group_Lock",0xFE0D; +"ISO_Last_Group",0xFE0E; +"ISO_Last_Group_Lock",0xFE0F; +"ISO_Left_Tab",0xFE20; +"ISO_Move_Line_Up",0xFE21; +"ISO_Move_Line_Down",0xFE22; +"ISO_Partial_Line_Up",0xFE23; +"ISO_Partial_Line_Down",0xFE24; +"ISO_Partial_Space_Left",0xFE25; +"ISO_Partial_Space_Right",0xFE26; +"ISO_Set_Margin_Left",0xFE27; +"ISO_Set_Margin_Right",0xFE28; +"ISO_Release_Margin_Left",0xFE29; +"ISO_Release_Margin_Right",0xFE2A; +"ISO_Release_Both_Margins",0xFE2B; +"ISO_Fast_Cursor_Left",0xFE2C; +"ISO_Fast_Cursor_Right",0xFE2D; +"ISO_Fast_Cursor_Up",0xFE2E; +"ISO_Fast_Cursor_Down",0xFE2F; +"ISO_Continuous_Underline",0xFE30; +"ISO_Discontinuous_Underline",0xFE31; +"ISO_Emphasize",0xFE32; +"ISO_Center_Object",0xFE33; +"ISO_Enter",0xFE34; +"dead_grave",0xFE50; +"dead_acute",0xFE51; +"dead_circumflex",0xFE52; +"dead_tilde",0xFE53; +"dead_macron",0xFE54; +"dead_breve",0xFE55; +"dead_abovedot",0xFE56; +"dead_diaeresis",0xFE57; +"dead_abovering",0xFE58; +"dead_doubleacute",0xFE59; +"dead_caron",0xFE5A; +"dead_cedilla",0xFE5B; +"dead_ogonek",0xFE5C; +"dead_iota",0xFE5D; +"dead_voiced_sound",0xFE5E; +"dead_semivoiced_sound",0xFE5F; +"dead_belowdot",0xFE60; +"First_Virtual_Screen",0xFED0; +"Prev_Virtual_Screen",0xFED1; +"Next_Virtual_Screen",0xFED2; +"Last_Virtual_Screen",0xFED4; +"Terminate_Server",0xFED5; +"AccessX_Enable",0xFE70; +"AccessX_Feedback_Enable",0xFE71; +"RepeatKeys_Enable",0xFE72; +"SlowKeys_Enable",0xFE73; +"BounceKeys_Enable",0xFE74; +"StickyKeys_Enable",0xFE75; +"MouseKeys_Enable",0xFE76; +"MouseKeys_Accel_Enable",0xFE77; +"Overlay1_Enable",0xFE78; +"Overlay2_Enable",0xFE79; +"AudibleBell_Enable",0xFE7A; +"Pointer_Left",0xFEE0; +"Pointer_Right",0xFEE1; +"Pointer_Up",0xFEE2; +"Pointer_Down",0xFEE3; +"Pointer_UpLeft",0xFEE4; +"Pointer_UpRight",0xFEE5; +"Pointer_DownLeft",0xFEE6; +"Pointer_DownRight",0xFEE7; +"Pointer_Button_Dflt",0xFEE8; +"Pointer_Button1",0xFEE9; +"Pointer_Button2",0xFEEA; +"Pointer_Button3",0xFEEB; +"Pointer_Button4",0xFEEC; +"Pointer_Button5",0xFEED; +"Pointer_DblClick_Dflt",0xFEEE; +"Pointer_DblClick1",0xFEEF; +"Pointer_DblClick2",0xFEF0; +"Pointer_DblClick3",0xFEF1; +"Pointer_DblClick4",0xFEF2; +"Pointer_DblClick5",0xFEF3; +"Pointer_Drag_Dflt",0xFEF4; +"Pointer_Drag1",0xFEF5; +"Pointer_Drag2",0xFEF6; +"Pointer_Drag3",0xFEF7; +"Pointer_Drag4",0xFEF8; +"Pointer_Drag5",0xFEFD; +"Pointer_EnableKeys",0xFEF9; +"Pointer_Accelerate",0xFEFA; +"Pointer_DfltBtnNext",0xFEFB; +"Pointer_DfltBtnPrev",0xFEFC; +"3270_Duplicate",0xFD01; +"3270_FieldMark",0xFD02; +"3270_Right2",0xFD03; +"3270_Left2",0xFD04; +"3270_BackTab",0xFD05; +"3270_EraseEOF",0xFD06; +"3270_EraseInput",0xFD07; +"3270_Reset",0xFD08; +"3270_Quit",0xFD09; +"3270_PA1",0xFD0A; +"3270_PA2",0xFD0B; +"3270_PA3",0xFD0C; +"3270_Test",0xFD0D; +"3270_Attn",0xFD0E; +"3270_CursorBlink",0xFD0F; +"3270_AltCursor",0xFD10; +"3270_KeyClick",0xFD11; +"3270_Jump",0xFD12; +"3270_Ident",0xFD13; +"3270_Rule",0xFD14; +"3270_Copy",0xFD15; +"3270_Play",0xFD16; +"3270_Setup",0xFD17; +"3270_Record",0xFD18; +"3270_ChangeScreen",0xFD19; +"3270_DeleteWord",0xFD1A; +"3270_ExSelect",0xFD1B; +"3270_CursorSelect",0xFD1C; +"3270_PrintScreen",0xFD1D; +"3270_Enter",0xFD1E; +"space",0x020; +"exclam",0x021; +"quotedbl",0x022; +"numbersign",0x023; +"dollar",0x024; +"percent",0x025; +"ampersand",0x026; +"apostrophe",0x027; +"quoteright",0x027; +"parenleft",0x028; +"parenright",0x029; +"asterisk",0x02a; +"plus",0x02b; +"comma",0x02c; +"minus",0x02d; +"period",0x02e; +"slash",0x02f; +"0",0x030; +"1",0x031; +"2",0x032; +"3",0x033; +"4",0x034; +"5",0x035; +"6",0x036; +"7",0x037; +"8",0x038; +"9",0x039; +"colon",0x03a; +"semicolon",0x03b; +"less",0x03c; +"equal",0x03d; +"greater",0x03e; +"question",0x03f; +"at",0x040; +"A",0x041; +"B",0x042; +"C",0x043; +"D",0x044; +"E",0x045; +"F",0x046; +"G",0x047; +"H",0x048; +"I",0x049; +"J",0x04a; +"K",0x04b; +"L",0x04c; +"M",0x04d; +"N",0x04e; +"O",0x04f; +"P",0x050; +"Q",0x051; +"R",0x052; +"S",0x053; +"T",0x054; +"U",0x055; +"V",0x056; +"W",0x057; +"X",0x058; +"Y",0x059; +"Z",0x05a; +"bracketleft",0x05b; +"backslash",0x05c; +"bracketright",0x05d; +"asciicircum",0x05e; +"underscore",0x05f; +"grave",0x060; +"quoteleft",0x060; +"a",0x061; +"b",0x062; +"c",0x063; +"d",0x064; +"e",0x065; +"f",0x066; +"g",0x067; +"h",0x068; +"i",0x069; +"j",0x06a; +"k",0x06b; +"l",0x06c; +"m",0x06d; +"n",0x06e; +"o",0x06f; +"p",0x070; +"q",0x071; +"r",0x072; +"s",0x073; +"t",0x074; +"u",0x075; +"v",0x076; +"w",0x077; +"x",0x078; +"y",0x079; +"z",0x07a; +"braceleft",0x07b; +"bar",0x07c; +"braceright",0x07d; +"asciitilde",0x07e; +"nobreakspace",0x0a0; +"exclamdown",0x0a1; +"cent",0x0a2; +"sterling",0x0a3; +"currency",0x0a4; +"yen",0x0a5; +"brokenbar",0x0a6; +"section",0x0a7; +"diaeresis",0x0a8; +"copyright",0x0a9; +"ordfeminine",0x0aa; +"guillemotleft",0x0ab; +"notsign",0x0ac; +"hyphen",0x0ad; +"registered",0x0ae; +"macron",0x0af; +"degree",0x0b0; +"plusminus",0x0b1; +"twosuperior",0x0b2; +"threesuperior",0x0b3; +"acute",0x0b4; +"mu",0x0b5; +"paragraph",0x0b6; +"periodcentered",0x0b7; +"cedilla",0x0b8; +"onesuperior",0x0b9; +"masculine",0x0ba; +"guillemotright",0x0bb; +"onequarter",0x0bc; +"onehalf",0x0bd; +"threequarters",0x0be; +"questiondown",0x0bf; +"Agrave",0x0c0; +"Aacute",0x0c1; +"Acircumflex",0x0c2; +"Atilde",0x0c3; +"Adiaeresis",0x0c4; +"Aring",0x0c5; +"AE",0x0c6; +"Ccedilla",0x0c7; +"Egrave",0x0c8; +"Eacute",0x0c9; +"Ecircumflex",0x0ca; +"Ediaeresis",0x0cb; +"Igrave",0x0cc; +"Iacute",0x0cd; +"Icircumflex",0x0ce; +"Idiaeresis",0x0cf; +"ETH",0x0d0; +"Eth",0x0d0; +"Ntilde",0x0d1; +"Ograve",0x0d2; +"Oacute",0x0d3; +"Ocircumflex",0x0d4; +"Otilde",0x0d5; +"Odiaeresis",0x0d6; +"multiply",0x0d7; +"Ooblique",0x0d8; +"Ugrave",0x0d9; +"Uacute",0x0da; +"Ucircumflex",0x0db; +"Udiaeresis",0x0dc; +"Yacute",0x0dd; +"THORN",0x0de; +"Thorn",0x0de; +"ssharp",0x0df; +"agrave",0x0e0; +"aacute",0x0e1; +"acircumflex",0x0e2; +"atilde",0x0e3; +"adiaeresis",0x0e4; +"aring",0x0e5; +"ae",0x0e6; +"ccedilla",0x0e7; +"egrave",0x0e8; +"eacute",0x0e9; +"ecircumflex",0x0ea; +"ediaeresis",0x0eb; +"igrave",0x0ec; +"iacute",0x0ed; +"icircumflex",0x0ee; +"idiaeresis",0x0ef; +"eth",0x0f0; +"ntilde",0x0f1; +"ograve",0x0f2; +"oacute",0x0f3; +"ocircumflex",0x0f4; +"otilde",0x0f5; +"odiaeresis",0x0f6; +"division",0x0f7; +"oslash",0x0f8; +"ugrave",0x0f9; +"uacute",0x0fa; +"ucircumflex",0x0fb; +"udiaeresis",0x0fc; +"yacute",0x0fd; +"thorn",0x0fe; +"ydiaeresis",0x0ff; +"Aogonek",0x1a1; +"breve",0x1a2; +"Lstroke",0x1a3; +"Lcaron",0x1a5; +"Sacute",0x1a6; +"Scaron",0x1a9; +"Scedilla",0x1aa; +"Tcaron",0x1ab; +"Zacute",0x1ac; +"Zcaron",0x1ae; +"Zabovedot",0x1af; +"aogonek",0x1b1; +"ogonek",0x1b2; +"lstroke",0x1b3; +"lcaron",0x1b5; +"sacute",0x1b6; +"caron",0x1b7; +"scaron",0x1b9; +"scedilla",0x1ba; +"tcaron",0x1bb; +"zacute",0x1bc; +"doubleacute",0x1bd; +"zcaron",0x1be; +"zabovedot",0x1bf; +"Racute",0x1c0; +"Abreve",0x1c3; +"Lacute",0x1c5; +"Cacute",0x1c6; +"Ccaron",0x1c8; +"Eogonek",0x1ca; +"Ecaron",0x1cc; +"Dcaron",0x1cf; +"Dstroke",0x1d0; +"Nacute",0x1d1; +"Ncaron",0x1d2; +"Odoubleacute",0x1d5; +"Rcaron",0x1d8; +"Uring",0x1d9; +"Udoubleacute",0x1db; +"Tcedilla",0x1de; +"racute",0x1e0; +"abreve",0x1e3; +"lacute",0x1e5; +"cacute",0x1e6; +"ccaron",0x1e8; +"eogonek",0x1ea; +"ecaron",0x1ec; +"dcaron",0x1ef; +"dstroke",0x1f0; +"nacute",0x1f1; +"ncaron",0x1f2; +"odoubleacute",0x1f5; +"udoubleacute",0x1fb; +"rcaron",0x1f8; +"uring",0x1f9; +"tcedilla",0x1fe; +"abovedot",0x1ff; +"Hstroke",0x2a1; +"Hcircumflex",0x2a6; +"Iabovedot",0x2a9; +"Gbreve",0x2ab; +"Jcircumflex",0x2ac; +"hstroke",0x2b1; +"hcircumflex",0x2b6; +"idotless",0x2b9; +"gbreve",0x2bb; +"jcircumflex",0x2bc; +"Cabovedot",0x2c5; +"Ccircumflex",0x2c6; +"Gabovedot",0x2d5; +"Gcircumflex",0x2d8; +"Ubreve",0x2dd; +"Scircumflex",0x2de; +"cabovedot",0x2e5; +"ccircumflex",0x2e6; +"gabovedot",0x2f5; +"gcircumflex",0x2f8; +"ubreve",0x2fd; +"scircumflex",0x2fe; +"kra",0x3a2; +"kappa",0x3a2; +"Rcedilla",0x3a3; +"Itilde",0x3a5; +"Lcedilla",0x3a6; +"Emacron",0x3aa; +"Gcedilla",0x3ab; +"Tslash",0x3ac; +"rcedilla",0x3b3; +"itilde",0x3b5; +"lcedilla",0x3b6; +"emacron",0x3ba; +"gcedilla",0x3bb; +"tslash",0x3bc; +"ENG",0x3bd; +"eng",0x3bf; +"Amacron",0x3c0; +"Iogonek",0x3c7; +"Eabovedot",0x3cc; +"Imacron",0x3cf; +"Ncedilla",0x3d1; +"Omacron",0x3d2; +"Kcedilla",0x3d3; +"Uogonek",0x3d9; +"Utilde",0x3dd; +"Umacron",0x3de; +"amacron",0x3e0; +"iogonek",0x3e7; +"eabovedot",0x3ec; +"imacron",0x3ef; +"ncedilla",0x3f1; +"omacron",0x3f2; +"kcedilla",0x3f3; +"uogonek",0x3f9; +"utilde",0x3fd; +"umacron",0x3fe; +"overline",0x47e; +"kana_fullstop",0x4a1; +"kana_openingbracket",0x4a2; +"kana_closingbracket",0x4a3; +"kana_comma",0x4a4; +"kana_conjunctive",0x4a5; +"kana_middledot",0x4a5; +"kana_WO",0x4a6; +"kana_a",0x4a7; +"kana_i",0x4a8; +"kana_u",0x4a9; +"kana_e",0x4aa; +"kana_o",0x4ab; +"kana_ya",0x4ac; +"kana_yu",0x4ad; +"kana_yo",0x4ae; +"kana_tsu",0x4af; +"kana_tu",0x4af; +"prolongedsound",0x4b0; +"kana_A",0x4b1; +"kana_I",0x4b2; +"kana_U",0x4b3; +"kana_E",0x4b4; +"kana_O",0x4b5; +"kana_KA",0x4b6; +"kana_KI",0x4b7; +"kana_KU",0x4b8; +"kana_KE",0x4b9; +"kana_KO",0x4ba; +"kana_SA",0x4bb; +"kana_SHI",0x4bc; +"kana_SU",0x4bd; +"kana_SE",0x4be; +"kana_SO",0x4bf; +"kana_TA",0x4c0; +"kana_CHI",0x4c1; +"kana_TI",0x4c1; +"kana_TSU",0x4c2; +"kana_TU",0x4c2; +"kana_TE",0x4c3; +"kana_TO",0x4c4; +"kana_NA",0x4c5; +"kana_NI",0x4c6; +"kana_NU",0x4c7; +"kana_NE",0x4c8; +"kana_NO",0x4c9; +"kana_HA",0x4ca; +"kana_HI",0x4cb; +"kana_FU",0x4cc; +"kana_HU",0x4cc; +"kana_HE",0x4cd; +"kana_HO",0x4ce; +"kana_MA",0x4cf; +"kana_MI",0x4d0; +"kana_MU",0x4d1; +"kana_ME",0x4d2; +"kana_MO",0x4d3; +"kana_YA",0x4d4; +"kana_YU",0x4d5; +"kana_YO",0x4d6; +"kana_RA",0x4d7; +"kana_RI",0x4d8; +"kana_RU",0x4d9; +"kana_RE",0x4da; +"kana_RO",0x4db; +"kana_WA",0x4dc; +"kana_N",0x4dd; +"voicedsound",0x4de; +"semivoicedsound",0x4df; +"kana_switch",0xFF7E; +"Arabic_comma",0x5ac; +"Arabic_semicolon",0x5bb; +"Arabic_question_mark",0x5bf; +"Arabic_hamza",0x5c1; +"Arabic_maddaonalef",0x5c2; +"Arabic_hamzaonalef",0x5c3; +"Arabic_hamzaonwaw",0x5c4; +"Arabic_hamzaunderalef",0x5c5; +"Arabic_hamzaonyeh",0x5c6; +"Arabic_alef",0x5c7; +"Arabic_beh",0x5c8; +"Arabic_tehmarbuta",0x5c9; +"Arabic_teh",0x5ca; +"Arabic_theh",0x5cb; +"Arabic_jeem",0x5cc; +"Arabic_hah",0x5cd; +"Arabic_khah",0x5ce; +"Arabic_dal",0x5cf; +"Arabic_thal",0x5d0; +"Arabic_ra",0x5d1; +"Arabic_zain",0x5d2; +"Arabic_seen",0x5d3; +"Arabic_sheen",0x5d4; +"Arabic_sad",0x5d5; +"Arabic_dad",0x5d6; +"Arabic_tah",0x5d7; +"Arabic_zah",0x5d8; +"Arabic_ain",0x5d9; +"Arabic_ghain",0x5da; +"Arabic_tatweel",0x5e0; +"Arabic_feh",0x5e1; +"Arabic_qaf",0x5e2; +"Arabic_kaf",0x5e3; +"Arabic_lam",0x5e4; +"Arabic_meem",0x5e5; +"Arabic_noon",0x5e6; +"Arabic_ha",0x5e7; +"Arabic_heh",0x5e7; +"Arabic_waw",0x5e8; +"Arabic_alefmaksura",0x5e9; +"Arabic_yeh",0x5ea; +"Arabic_fathatan",0x5eb; +"Arabic_dammatan",0x5ec; +"Arabic_kasratan",0x5ed; +"Arabic_fatha",0x5ee; +"Arabic_damma",0x5ef; +"Arabic_kasra",0x5f0; +"Arabic_shadda",0x5f1; +"Arabic_sukun",0x5f2; +"Arabic_switch",0xFF7E; +"Serbian_dje",0x6a1; +"Macedonia_gje",0x6a2; +"Cyrillic_io",0x6a3; +"Ukrainian_ie",0x6a4; +"Ukranian_je",0x6a4; +"Macedonia_dse",0x6a5; +"Ukrainian_i",0x6a6; +"Ukranian_i",0x6a6; +"Ukrainian_yi",0x6a7; +"Ukranian_yi",0x6a7; +"Cyrillic_je",0x6a8; +"Serbian_je",0x6a8; +"Cyrillic_lje",0x6a9; +"Serbian_lje",0x6a9; +"Cyrillic_nje",0x6aa; +"Serbian_nje",0x6aa; +"Serbian_tshe",0x6ab; +"Macedonia_kje",0x6ac; +"Byelorussian_shortu",0x6ae; +"Cyrillic_dzhe",0x6af; +"Serbian_dze",0x6af; +"numerosign",0x6b0; +"Serbian_DJE",0x6b1; +"Macedonia_GJE",0x6b2; +"Cyrillic_IO",0x6b3; +"Ukrainian_IE",0x6b4; +"Ukranian_JE",0x6b4; +"Macedonia_DSE",0x6b5; +"Ukrainian_I",0x6b6; +"Ukranian_I",0x6b6; +"Ukrainian_YI",0x6b7; +"Ukranian_YI",0x6b7; +"Cyrillic_JE",0x6b8; +"Serbian_JE",0x6b8; +"Cyrillic_LJE",0x6b9; +"Serbian_LJE",0x6b9; +"Cyrillic_NJE",0x6ba; +"Serbian_NJE",0x6ba; +"Serbian_TSHE",0x6bb; +"Macedonia_KJE",0x6bc; +"Byelorussian_SHORTU",0x6be; +"Cyrillic_DZHE",0x6bf; +"Serbian_DZE",0x6bf; +"Cyrillic_yu",0x6c0; +"Cyrillic_a",0x6c1; +"Cyrillic_be",0x6c2; +"Cyrillic_tse",0x6c3; +"Cyrillic_de",0x6c4; +"Cyrillic_ie",0x6c5; +"Cyrillic_ef",0x6c6; +"Cyrillic_ghe",0x6c7; +"Cyrillic_ha",0x6c8; +"Cyrillic_i",0x6c9; +"Cyrillic_shorti",0x6ca; +"Cyrillic_ka",0x6cb; +"Cyrillic_el",0x6cc; +"Cyrillic_em",0x6cd; +"Cyrillic_en",0x6ce; +"Cyrillic_o",0x6cf; +"Cyrillic_pe",0x6d0; +"Cyrillic_ya",0x6d1; +"Cyrillic_er",0x6d2; +"Cyrillic_es",0x6d3; +"Cyrillic_te",0x6d4; +"Cyrillic_u",0x6d5; +"Cyrillic_zhe",0x6d6; +"Cyrillic_ve",0x6d7; +"Cyrillic_softsign",0x6d8; +"Cyrillic_yeru",0x6d9; +"Cyrillic_ze",0x6da; +"Cyrillic_sha",0x6db; +"Cyrillic_e",0x6dc; +"Cyrillic_shcha",0x6dd; +"Cyrillic_che",0x6de; +"Cyrillic_hardsign",0x6df; +"Cyrillic_YU",0x6e0; +"Cyrillic_A",0x6e1; +"Cyrillic_BE",0x6e2; +"Cyrillic_TSE",0x6e3; +"Cyrillic_DE",0x6e4; +"Cyrillic_IE",0x6e5; +"Cyrillic_EF",0x6e6; +"Cyrillic_GHE",0x6e7; +"Cyrillic_HA",0x6e8; +"Cyrillic_I",0x6e9; +"Cyrillic_SHORTI",0x6ea; +"Cyrillic_KA",0x6eb; +"Cyrillic_EL",0x6ec; +"Cyrillic_EM",0x6ed; +"Cyrillic_EN",0x6ee; +"Cyrillic_O",0x6ef; +"Cyrillic_PE",0x6f0; +"Cyrillic_YA",0x6f1; +"Cyrillic_ER",0x6f2; +"Cyrillic_ES",0x6f3; +"Cyrillic_TE",0x6f4; +"Cyrillic_U",0x6f5; +"Cyrillic_ZHE",0x6f6; +"Cyrillic_VE",0x6f7; +"Cyrillic_SOFTSIGN",0x6f8; +"Cyrillic_YERU",0x6f9; +"Cyrillic_ZE",0x6fa; +"Cyrillic_SHA",0x6fb; +"Cyrillic_E",0x6fc; +"Cyrillic_SHCHA",0x6fd; +"Cyrillic_CHE",0x6fe; +"Cyrillic_HARDSIGN",0x6ff; +"Greek_ALPHAaccent",0x7a1; +"Greek_EPSILONaccent",0x7a2; +"Greek_ETAaccent",0x7a3; +"Greek_IOTAaccent",0x7a4; +"Greek_IOTAdiaeresis",0x7a5; +"Greek_OMICRONaccent",0x7a7; +"Greek_UPSILONaccent",0x7a8; +"Greek_UPSILONdieresis",0x7a9; +"Greek_OMEGAaccent",0x7ab; +"Greek_accentdieresis",0x7ae; +"Greek_horizbar",0x7af; +"Greek_alphaaccent",0x7b1; +"Greek_epsilonaccent",0x7b2; +"Greek_etaaccent",0x7b3; +"Greek_iotaaccent",0x7b4; +"Greek_iotadieresis",0x7b5; +"Greek_iotaaccentdieresis",0x7b6; +"Greek_omicronaccent",0x7b7; +"Greek_upsilonaccent",0x7b8; +"Greek_upsilondieresis",0x7b9; +"Greek_upsilonaccentdieresis",0x7ba; +"Greek_omegaaccent",0x7bb; +"Greek_ALPHA",0x7c1; +"Greek_BETA",0x7c2; +"Greek_GAMMA",0x7c3; +"Greek_DELTA",0x7c4; +"Greek_EPSILON",0x7c5; +"Greek_ZETA",0x7c6; +"Greek_ETA",0x7c7; +"Greek_THETA",0x7c8; +"Greek_IOTA",0x7c9; +"Greek_KAPPA",0x7ca; +"Greek_LAMDA",0x7cb; +"Greek_LAMBDA",0x7cb; +"Greek_MU",0x7cc; +"Greek_NU",0x7cd; +"Greek_XI",0x7ce; +"Greek_OMICRON",0x7cf; +"Greek_PI",0x7d0; +"Greek_RHO",0x7d1; +"Greek_SIGMA",0x7d2; +"Greek_TAU",0x7d4; +"Greek_UPSILON",0x7d5; +"Greek_PHI",0x7d6; +"Greek_CHI",0x7d7; +"Greek_PSI",0x7d8; +"Greek_OMEGA",0x7d9; +"Greek_alpha",0x7e1; +"Greek_beta",0x7e2; +"Greek_gamma",0x7e3; +"Greek_delta",0x7e4; +"Greek_epsilon",0x7e5; +"Greek_zeta",0x7e6; +"Greek_eta",0x7e7; +"Greek_theta",0x7e8; +"Greek_iota",0x7e9; +"Greek_kappa",0x7ea; +"Greek_lamda",0x7eb; +"Greek_lambda",0x7eb; +"Greek_mu",0x7ec; +"Greek_nu",0x7ed; +"Greek_xi",0x7ee; +"Greek_omicron",0x7ef; +"Greek_pi",0x7f0; +"Greek_rho",0x7f1; +"Greek_sigma",0x7f2; +"Greek_finalsmallsigma",0x7f3; +"Greek_tau",0x7f4; +"Greek_upsilon",0x7f5; +"Greek_phi",0x7f6; +"Greek_chi",0x7f7; +"Greek_psi",0x7f8; +"Greek_omega",0x7f9; +"Greek_switch",0xFF7E; +"leftradical",0x8a1; +"topleftradical",0x8a2; +"horizconnector",0x8a3; +"topintegral",0x8a4; +"botintegral",0x8a5; +"vertconnector",0x8a6; +"topleftsqbracket",0x8a7; +"botleftsqbracket",0x8a8; +"toprightsqbracket",0x8a9; +"botrightsqbracket",0x8aa; +"topleftparens",0x8ab; +"botleftparens",0x8ac; +"toprightparens",0x8ad; +"botrightparens",0x8ae; +"leftmiddlecurlybrace",0x8af; +"rightmiddlecurlybrace",0x8b0; +"topleftsummation",0x8b1; +"botleftsummation",0x8b2; +"topvertsummationconnector",0x8b3; +"botvertsummationconnector",0x8b4; +"toprightsummation",0x8b5; +"botrightsummation",0x8b6; +"rightmiddlesummation",0x8b7; +"lessthanequal",0x8bc; +"notequal",0x8bd; +"greaterthanequal",0x8be; +"integral",0x8bf; +"therefore",0x8c0; +"variation",0x8c1; +"infinity",0x8c2; +"nabla",0x8c5; +"approximate",0x8c8; +"similarequal",0x8c9; +"ifonlyif",0x8cd; +"implies",0x8ce; +"identical",0x8cf; +"radical",0x8d6; +"includedin",0x8da; +"includes",0x8db; +"intersection",0x8dc; +"union",0x8dd; +"logicaland",0x8de; +"logicalor",0x8df; +"partialderivative",0x8ef; +"function",0x8f6; +"leftarrow",0x8fb; +"uparrow",0x8fc; +"rightarrow",0x8fd; +"downarrow",0x8fe; +"blank",0x9df; +"soliddiamond",0x9e0; +"checkerboard",0x9e1; +"ht",0x9e2; +"ff",0x9e3; +"cr",0x9e4; +"lf",0x9e5; +"nl",0x9e8; +"vt",0x9e9; +"lowrightcorner",0x9ea; +"uprightcorner",0x9eb; +"upleftcorner",0x9ec; +"lowleftcorner",0x9ed; +"crossinglines",0x9ee; +"horizlinescan1",0x9ef; +"horizlinescan3",0x9f0; +"horizlinescan5",0x9f1; +"horizlinescan7",0x9f2; +"horizlinescan9",0x9f3; +"leftt",0x9f4; +"rightt",0x9f5; +"bott",0x9f6; +"topt",0x9f7; +"vertbar",0x9f8; +"emspace",0xaa1; +"enspace",0xaa2; +"em3space",0xaa3; +"em4space",0xaa4; +"digitspace",0xaa5; +"punctspace",0xaa6; +"thinspace",0xaa7; +"hairspace",0xaa8; +"emdash",0xaa9; +"endash",0xaaa; +"signifblank",0xaac; +"ellipsis",0xaae; +"doubbaselinedot",0xaaf; +"onethird",0xab0; +"twothirds",0xab1; +"onefifth",0xab2; +"twofifths",0xab3; +"threefifths",0xab4; +"fourfifths",0xab5; +"onesixth",0xab6; +"fivesixths",0xab7; +"careof",0xab8; +"figdash",0xabb; +"leftanglebracket",0xabc; +"decimalpoint",0xabd; +"rightanglebracket",0xabe; +"marker",0xabf; +"oneeighth",0xac3; +"threeeighths",0xac4; +"fiveeighths",0xac5; +"seveneighths",0xac6; +"trademark",0xac9; +"signaturemark",0xaca; +"trademarkincircle",0xacb; +"leftopentriangle",0xacc; +"rightopentriangle",0xacd; +"emopencircle",0xace; +"emopenrectangle",0xacf; +"leftsinglequotemark",0xad0; +"rightsinglequotemark",0xad1; +"leftdoublequotemark",0xad2; +"rightdoublequotemark",0xad3; +"prescription",0xad4; +"minutes",0xad6; +"seconds",0xad7; +"latincross",0xad9; +"hexagram",0xada; +"filledrectbullet",0xadb; +"filledlefttribullet",0xadc; +"filledrighttribullet",0xadd; +"emfilledcircle",0xade; +"emfilledrect",0xadf; +"enopencircbullet",0xae0; +"enopensquarebullet",0xae1; +"openrectbullet",0xae2; +"opentribulletup",0xae3; +"opentribulletdown",0xae4; +"openstar",0xae5; +"enfilledcircbullet",0xae6; +"enfilledsqbullet",0xae7; +"filledtribulletup",0xae8; +"filledtribulletdown",0xae9; +"leftpointer",0xaea; +"rightpointer",0xaeb; +"club",0xaec; +"diamond",0xaed; +"heart",0xaee; +"maltesecross",0xaf0; +"dagger",0xaf1; +"doubledagger",0xaf2; +"checkmark",0xaf3; +"ballotcross",0xaf4; +"musicalsharp",0xaf5; +"musicalflat",0xaf6; +"malesymbol",0xaf7; +"femalesymbol",0xaf8; +"telephone",0xaf9; +"telephonerecorder",0xafa; +"phonographcopyright",0xafb; +"caret",0xafc; +"singlelowquotemark",0xafd; +"doublelowquotemark",0xafe; +"cursor",0xaff; +"leftcaret",0xba3; +"rightcaret",0xba6; +"downcaret",0xba8; +"upcaret",0xba9; +"overbar",0xbc0; +"downtack",0xbc2; +"upshoe",0xbc3; +"downstile",0xbc4; +"underbar",0xbc6; +"jot",0xbca; +"quad",0xbcc; +"uptack",0xbce; +"circle",0xbcf; +"upstile",0xbd3; +"downshoe",0xbd6; +"rightshoe",0xbd8; +"leftshoe",0xbda; +"lefttack",0xbdc; +"righttack",0xbfc; +"hebrew_doublelowline",0xcdf; +"hebrew_aleph",0xce0; +"hebrew_bet",0xce1; +"hebrew_beth",0xce1; +"hebrew_gimel",0xce2; +"hebrew_gimmel",0xce2; +"hebrew_dalet",0xce3; +"hebrew_daleth",0xce3; +"hebrew_he",0xce4; +"hebrew_waw",0xce5; +"hebrew_zain",0xce6; +"hebrew_zayin",0xce6; +"hebrew_chet",0xce7; +"hebrew_het",0xce7; +"hebrew_tet",0xce8; +"hebrew_teth",0xce8; +"hebrew_yod",0xce9; +"hebrew_finalkaph",0xcea; +"hebrew_kaph",0xceb; +"hebrew_lamed",0xcec; +"hebrew_finalmem",0xced; +"hebrew_mem",0xcee; +"hebrew_finalnun",0xcef; +"hebrew_nun",0xcf0; +"hebrew_samech",0xcf1; +"hebrew_samekh",0xcf1; +"hebrew_ayin",0xcf2; +"hebrew_finalpe",0xcf3; +"hebrew_pe",0xcf4; +"hebrew_finalzade",0xcf5; +"hebrew_finalzadi",0xcf5; +"hebrew_zade",0xcf6; +"hebrew_zadi",0xcf6; +"hebrew_qoph",0xcf7; +"hebrew_kuf",0xcf7; +"hebrew_resh",0xcf8; +"hebrew_shin",0xcf9; +"hebrew_taw",0xcfa; +"hebrew_taf",0xcfa; +"Hebrew_switch",0xFF7E; +"Thai_kokai",0xda1; +"Thai_khokhai",0xda2; +"Thai_khokhuat",0xda3; +"Thai_khokhwai",0xda4; +"Thai_khokhon",0xda5; +"Thai_khorakhang",0xda6; +"Thai_ngongu",0xda7; +"Thai_chochan",0xda8; +"Thai_choching",0xda9; +"Thai_chochang",0xdaa; +"Thai_soso",0xdab; +"Thai_chochoe",0xdac; +"Thai_yoying",0xdad; +"Thai_dochada",0xdae; +"Thai_topatak",0xdaf; +"Thai_thothan",0xdb0; +"Thai_thonangmontho",0xdb1; +"Thai_thophuthao",0xdb2; +"Thai_nonen",0xdb3; +"Thai_dodek",0xdb4; +"Thai_totao",0xdb5; +"Thai_thothung",0xdb6; +"Thai_thothahan",0xdb7; +"Thai_thothong",0xdb8; +"Thai_nonu",0xdb9; +"Thai_bobaimai",0xdba; +"Thai_popla",0xdbb; +"Thai_phophung",0xdbc; +"Thai_fofa",0xdbd; +"Thai_phophan",0xdbe; +"Thai_fofan",0xdbf; +"Thai_phosamphao",0xdc0; +"Thai_moma",0xdc1; +"Thai_yoyak",0xdc2; +"Thai_rorua",0xdc3; +"Thai_ru",0xdc4; +"Thai_loling",0xdc5; +"Thai_lu",0xdc6; +"Thai_wowaen",0xdc7; +"Thai_sosala",0xdc8; +"Thai_sorusi",0xdc9; +"Thai_sosua",0xdca; +"Thai_hohip",0xdcb; +"Thai_lochula",0xdcc; +"Thai_oang",0xdcd; +"Thai_honokhuk",0xdce; +"Thai_paiyannoi",0xdcf; +"Thai_saraa",0xdd0; +"Thai_maihanakat",0xdd1; +"Thai_saraaa",0xdd2; +"Thai_saraam",0xdd3; +"Thai_sarai",0xdd4; +"Thai_saraii",0xdd5; +"Thai_saraue",0xdd6; +"Thai_sarauee",0xdd7; +"Thai_sarau",0xdd8; +"Thai_sarauu",0xdd9; +"Thai_phinthu",0xdda; +"Thai_maihanakat_maitho",0xdde; +"Thai_baht",0xddf; +"Thai_sarae",0xde0; +"Thai_saraae",0xde1; +"Thai_sarao",0xde2; +"Thai_saraaimaimuan",0xde3; +"Thai_saraaimaimalai",0xde4; +"Thai_lakkhangyao",0xde5; +"Thai_maiyamok",0xde6; +"Thai_maitaikhu",0xde7; +"Thai_maiek",0xde8; +"Thai_maitho",0xde9; +"Thai_maitri",0xdea; +"Thai_maichattawa",0xdeb; +"Thai_thanthakhat",0xdec; +"Thai_nikhahit",0xded; +"Thai_leksun",0xdf0; +"Thai_leknung",0xdf1; +"Thai_leksong",0xdf2; +"Thai_leksam",0xdf3; +"Thai_leksi",0xdf4; +"Thai_lekha",0xdf5; +"Thai_lekhok",0xdf6; +"Thai_lekchet",0xdf7; +"Thai_lekpaet",0xdf8; +"Thai_lekkao",0xdf9; +"Hangul",0xff31; +"Hangul_Start",0xff32; +"Hangul_End",0xff33; +"Hangul_Hanja",0xff34; +"Hangul_Jamo",0xff35; +"Hangul_Romaja",0xff36; +"Hangul_Codeinput",0xff37; +"Hangul_Jeonja",0xff38; +"Hangul_Banja",0xff39; +"Hangul_PreHanja",0xff3a; +"Hangul_PostHanja",0xff3b; +"Hangul_SingleCandidate",0xff3c; +"Hangul_MultipleCandidate",0xff3d; +"Hangul_PreviousCandidate",0xff3e; +"Hangul_Special",0xff3f; +"Hangul_switch",0xFF7E; +"Hangul_Kiyeog",0xea1; +"Hangul_SsangKiyeog",0xea2; +"Hangul_KiyeogSios",0xea3; +"Hangul_Nieun",0xea4; +"Hangul_NieunJieuj",0xea5; +"Hangul_NieunHieuh",0xea6; +"Hangul_Dikeud",0xea7; +"Hangul_SsangDikeud",0xea8; +"Hangul_Rieul",0xea9; +"Hangul_RieulKiyeog",0xeaa; +"Hangul_RieulMieum",0xeab; +"Hangul_RieulPieub",0xeac; +"Hangul_RieulSios",0xead; +"Hangul_RieulTieut",0xeae; +"Hangul_RieulPhieuf",0xeaf; +"Hangul_RieulHieuh",0xeb0; +"Hangul_Mieum",0xeb1; +"Hangul_Pieub",0xeb2; +"Hangul_SsangPieub",0xeb3; +"Hangul_PieubSios",0xeb4; +"Hangul_Sios",0xeb5; +"Hangul_SsangSios",0xeb6; +"Hangul_Ieung",0xeb7; +"Hangul_Jieuj",0xeb8; +"Hangul_SsangJieuj",0xeb9; +"Hangul_Cieuc",0xeba; +"Hangul_Khieuq",0xebb; +"Hangul_Tieut",0xebc; +"Hangul_Phieuf",0xebd; +"Hangul_Hieuh",0xebe; +"Hangul_A",0xebf; +"Hangul_AE",0xec0; +"Hangul_YA",0xec1; +"Hangul_YAE",0xec2; +"Hangul_EO",0xec3; +"Hangul_E",0xec4; +"Hangul_YEO",0xec5; +"Hangul_YE",0xec6; +"Hangul_O",0xec7; +"Hangul_WA",0xec8; +"Hangul_WAE",0xec9; +"Hangul_OE",0xeca; +"Hangul_YO",0xecb; +"Hangul_U",0xecc; +"Hangul_WEO",0xecd; +"Hangul_WE",0xece; +"Hangul_WI",0xecf; +"Hangul_YU",0xed0; +"Hangul_EU",0xed1; +"Hangul_YI",0xed2; +"Hangul_I",0xed3; +"Hangul_J_Kiyeog",0xed4; +"Hangul_J_SsangKiyeog",0xed5; +"Hangul_J_KiyeogSios",0xed6; +"Hangul_J_Nieun",0xed7; +"Hangul_J_NieunJieuj",0xed8; +"Hangul_J_NieunHieuh",0xed9; +"Hangul_J_Dikeud",0xeda; +"Hangul_J_Rieul",0xedb; +"Hangul_J_RieulKiyeog",0xedc; +"Hangul_J_RieulMieum",0xedd; +"Hangul_J_RieulPieub",0xede; +"Hangul_J_RieulSios",0xedf; +"Hangul_J_RieulTieut",0xee0; +"Hangul_J_RieulPhieuf",0xee1; +"Hangul_J_RieulHieuh",0xee2; +"Hangul_J_Mieum",0xee3; +"Hangul_J_Pieub",0xee4; +"Hangul_J_PieubSios",0xee5; +"Hangul_J_Sios",0xee6; +"Hangul_J_SsangSios",0xee7; +"Hangul_J_Ieung",0xee8; +"Hangul_J_Jieuj",0xee9; +"Hangul_J_Cieuc",0xeea; +"Hangul_J_Khieuq",0xeeb; +"Hangul_J_Tieut",0xeec; +"Hangul_J_Phieuf",0xeed; +"Hangul_J_Hieuh",0xeee; +"Hangul_RieulYeorinHieuh",0xeef; +"Hangul_SunkyeongeumMieum",0xef0; +"Hangul_SunkyeongeumPieub",0xef1; +"Hangul_PanSios",0xef2; +"Hangul_KkogjiDalrinIeung",0xef3; +"Hangul_SunkyeongeumPhieuf",0xef4; +"Hangul_YeorinHieuh",0xef5; +"Hangul_AraeA",0xef6; +"Hangul_AraeAE",0xef7; +"Hangul_J_PanSios",0xef8; +"Hangul_J_KkogjiDalrinIeung",0xef9; +"Hangul_J_YeorinHieuh",0xefa; +"Korean_Won",0xeff; +] +let keysym_to_name = [ +0xFFFFFF,"VoidSymbol"; +0xFF08,"BackSpace"; +0xFF09,"Tab"; +0xFF0A,"Linefeed"; +0xFF0B,"Clear"; +0xFF0D,"Return"; +0xFF13,"Pause"; +0xFF14,"Scroll_Lock"; +0xFF15,"Sys_Req"; +0xFF1B,"Escape"; +0xFFFF,"Delete"; +0xFF20,"Multi_key"; +0xFF21,"Kanji"; +0xFF22,"Muhenkan"; +0xFF23,"Henkan_Mode"; +0xFF23,"Henkan"; +0xFF24,"Romaji"; +0xFF25,"Hiragana"; +0xFF26,"Katakana"; +0xFF27,"Hiragana_Katakana"; +0xFF28,"Zenkaku"; +0xFF29,"Hankaku"; +0xFF2A,"Zenkaku_Hankaku"; +0xFF2B,"Touroku"; +0xFF2C,"Massyo"; +0xFF2D,"Kana_Lock"; +0xFF2E,"Kana_Shift"; +0xFF2F,"Eisu_Shift"; +0xFF30,"Eisu_toggle"; +0xFF50,"Home"; +0xFF51,"Left"; +0xFF52,"Up"; +0xFF53,"Right"; +0xFF54,"Down"; +0xFF55,"Prior"; +0xFF55,"Page_Up"; +0xFF56,"Next"; +0xFF56,"Page_Down"; +0xFF57,"End"; +0xFF58,"Begin"; +0xFF60,"Select"; +0xFF61,"Print"; +0xFF62,"Execute"; +0xFF63,"Insert"; +0xFF65,"Undo"; +0xFF66,"Redo"; +0xFF67,"Menu"; +0xFF68,"Find"; +0xFF69,"Cancel"; +0xFF6A,"Help"; +0xFF6B,"Break"; +0xFF7E,"Mode_switch"; +0xFF7E,"script_switch"; +0xFF7F,"Num_Lock"; +0xFF80,"KP_Space"; +0xFF89,"KP_Tab"; +0xFF8D,"KP_Enter"; +0xFF91,"KP_F1"; +0xFF92,"KP_F2"; +0xFF93,"KP_F3"; +0xFF94,"KP_F4"; +0xFF95,"KP_Home"; +0xFF96,"KP_Left"; +0xFF97,"KP_Up"; +0xFF98,"KP_Right"; +0xFF99,"KP_Down"; +0xFF9A,"KP_Prior"; +0xFF9A,"KP_Page_Up"; +0xFF9B,"KP_Next"; +0xFF9B,"KP_Page_Down"; +0xFF9C,"KP_End"; +0xFF9D,"KP_Begin"; +0xFF9E,"KP_Insert"; +0xFF9F,"KP_Delete"; +0xFFBD,"KP_Equal"; +0xFFAA,"KP_Multiply"; +0xFFAB,"KP_Add"; +0xFFAC,"KP_Separator"; +0xFFAD,"KP_Subtract"; +0xFFAE,"KP_Decimal"; +0xFFAF,"KP_Divide"; +0xFFB0,"KP_0"; +0xFFB1,"KP_1"; +0xFFB2,"KP_2"; +0xFFB3,"KP_3"; +0xFFB4,"KP_4"; +0xFFB5,"KP_5"; +0xFFB6,"KP_6"; +0xFFB7,"KP_7"; +0xFFB8,"KP_8"; +0xFFB9,"KP_9"; +0xFFBE,"F1"; +0xFFBF,"F2"; +0xFFC0,"F3"; +0xFFC1,"F4"; +0xFFC2,"F5"; +0xFFC3,"F6"; +0xFFC4,"F7"; +0xFFC5,"F8"; +0xFFC6,"F9"; +0xFFC7,"F10"; +0xFFC8,"F11"; +0xFFC8,"L1"; +0xFFC9,"F12"; +0xFFC9,"L2"; +0xFFCA,"F13"; +0xFFCA,"L3"; +0xFFCB,"F14"; +0xFFCB,"L4"; +0xFFCC,"F15"; +0xFFCC,"L5"; +0xFFCD,"F16"; +0xFFCD,"L6"; +0xFFCE,"F17"; +0xFFCE,"L7"; +0xFFCF,"F18"; +0xFFCF,"L8"; +0xFFD0,"F19"; +0xFFD0,"L9"; +0xFFD1,"F20"; +0xFFD1,"L10"; +0xFFD2,"F21"; +0xFFD2,"R1"; +0xFFD3,"F22"; +0xFFD3,"R2"; +0xFFD4,"F23"; +0xFFD4,"R3"; +0xFFD5,"F24"; +0xFFD5,"R4"; +0xFFD6,"F25"; +0xFFD6,"R5"; +0xFFD7,"F26"; +0xFFD7,"R6"; +0xFFD8,"F27"; +0xFFD8,"R7"; +0xFFD9,"F28"; +0xFFD9,"R8"; +0xFFDA,"F29"; +0xFFDA,"R9"; +0xFFDB,"F30"; +0xFFDB,"R10"; +0xFFDC,"F31"; +0xFFDC,"R11"; +0xFFDD,"F32"; +0xFFDD,"R12"; +0xFFDE,"F33"; +0xFFDE,"R13"; +0xFFDF,"F34"; +0xFFDF,"R14"; +0xFFE0,"F35"; +0xFFE0,"R15"; +0xFFE1,"Shift_L"; +0xFFE2,"Shift_R"; +0xFFE3,"Control_L"; +0xFFE4,"Control_R"; +0xFFE5,"Caps_Lock"; +0xFFE6,"Shift_Lock"; +0xFFE7,"Meta_L"; +0xFFE8,"Meta_R"; +0xFFE9,"Alt_L"; +0xFFEA,"Alt_R"; +0xFFEB,"Super_L"; +0xFFEC,"Super_R"; +0xFFED,"Hyper_L"; +0xFFEE,"Hyper_R"; +0xFE01,"ISO_Lock"; +0xFE02,"ISO_Level2_Latch"; +0xFE03,"ISO_Level3_Shift"; +0xFE04,"ISO_Level3_Latch"; +0xFE05,"ISO_Level3_Lock"; +0xFF7E,"ISO_Group_Shift"; +0xFE06,"ISO_Group_Latch"; +0xFE07,"ISO_Group_Lock"; +0xFE08,"ISO_Next_Group"; +0xFE09,"ISO_Next_Group_Lock"; +0xFE0A,"ISO_Prev_Group"; +0xFE0B,"ISO_Prev_Group_Lock"; +0xFE0C,"ISO_First_Group"; +0xFE0D,"ISO_First_Group_Lock"; +0xFE0E,"ISO_Last_Group"; +0xFE0F,"ISO_Last_Group_Lock"; +0xFE20,"ISO_Left_Tab"; +0xFE21,"ISO_Move_Line_Up"; +0xFE22,"ISO_Move_Line_Down"; +0xFE23,"ISO_Partial_Line_Up"; +0xFE24,"ISO_Partial_Line_Down"; +0xFE25,"ISO_Partial_Space_Left"; +0xFE26,"ISO_Partial_Space_Right"; +0xFE27,"ISO_Set_Margin_Left"; +0xFE28,"ISO_Set_Margin_Right"; +0xFE29,"ISO_Release_Margin_Left"; +0xFE2A,"ISO_Release_Margin_Right"; +0xFE2B,"ISO_Release_Both_Margins"; +0xFE2C,"ISO_Fast_Cursor_Left"; +0xFE2D,"ISO_Fast_Cursor_Right"; +0xFE2E,"ISO_Fast_Cursor_Up"; +0xFE2F,"ISO_Fast_Cursor_Down"; +0xFE30,"ISO_Continuous_Underline"; +0xFE31,"ISO_Discontinuous_Underline"; +0xFE32,"ISO_Emphasize"; +0xFE33,"ISO_Center_Object"; +0xFE34,"ISO_Enter"; +0xFE50,"dead_grave"; +0xFE51,"dead_acute"; +0xFE52,"dead_circumflex"; +0xFE53,"dead_tilde"; +0xFE54,"dead_macron"; +0xFE55,"dead_breve"; +0xFE56,"dead_abovedot"; +0xFE57,"dead_diaeresis"; +0xFE58,"dead_abovering"; +0xFE59,"dead_doubleacute"; +0xFE5A,"dead_caron"; +0xFE5B,"dead_cedilla"; +0xFE5C,"dead_ogonek"; +0xFE5D,"dead_iota"; +0xFE5E,"dead_voiced_sound"; +0xFE5F,"dead_semivoiced_sound"; +0xFE60,"dead_belowdot"; +0xFED0,"First_Virtual_Screen"; +0xFED1,"Prev_Virtual_Screen"; +0xFED2,"Next_Virtual_Screen"; +0xFED4,"Last_Virtual_Screen"; +0xFED5,"Terminate_Server"; +0xFE70,"AccessX_Enable"; +0xFE71,"AccessX_Feedback_Enable"; +0xFE72,"RepeatKeys_Enable"; +0xFE73,"SlowKeys_Enable"; +0xFE74,"BounceKeys_Enable"; +0xFE75,"StickyKeys_Enable"; +0xFE76,"MouseKeys_Enable"; +0xFE77,"MouseKeys_Accel_Enable"; +0xFE78,"Overlay1_Enable"; +0xFE79,"Overlay2_Enable"; +0xFE7A,"AudibleBell_Enable"; +0xFEE0,"Pointer_Left"; +0xFEE1,"Pointer_Right"; +0xFEE2,"Pointer_Up"; +0xFEE3,"Pointer_Down"; +0xFEE4,"Pointer_UpLeft"; +0xFEE5,"Pointer_UpRight"; +0xFEE6,"Pointer_DownLeft"; +0xFEE7,"Pointer_DownRight"; +0xFEE8,"Pointer_Button_Dflt"; +0xFEE9,"Pointer_Button1"; +0xFEEA,"Pointer_Button2"; +0xFEEB,"Pointer_Button3"; +0xFEEC,"Pointer_Button4"; +0xFEED,"Pointer_Button5"; +0xFEEE,"Pointer_DblClick_Dflt"; +0xFEEF,"Pointer_DblClick1"; +0xFEF0,"Pointer_DblClick2"; +0xFEF1,"Pointer_DblClick3"; +0xFEF2,"Pointer_DblClick4"; +0xFEF3,"Pointer_DblClick5"; +0xFEF4,"Pointer_Drag_Dflt"; +0xFEF5,"Pointer_Drag1"; +0xFEF6,"Pointer_Drag2"; +0xFEF7,"Pointer_Drag3"; +0xFEF8,"Pointer_Drag4"; +0xFEFD,"Pointer_Drag5"; +0xFEF9,"Pointer_EnableKeys"; +0xFEFA,"Pointer_Accelerate"; +0xFEFB,"Pointer_DfltBtnNext"; +0xFEFC,"Pointer_DfltBtnPrev"; +0xFD01,"3270_Duplicate"; +0xFD02,"3270_FieldMark"; +0xFD03,"3270_Right2"; +0xFD04,"3270_Left2"; +0xFD05,"3270_BackTab"; +0xFD06,"3270_EraseEOF"; +0xFD07,"3270_EraseInput"; +0xFD08,"3270_Reset"; +0xFD09,"3270_Quit"; +0xFD0A,"3270_PA1"; +0xFD0B,"3270_PA2"; +0xFD0C,"3270_PA3"; +0xFD0D,"3270_Test"; +0xFD0E,"3270_Attn"; +0xFD0F,"3270_CursorBlink"; +0xFD10,"3270_AltCursor"; +0xFD11,"3270_KeyClick"; +0xFD12,"3270_Jump"; +0xFD13,"3270_Ident"; +0xFD14,"3270_Rule"; +0xFD15,"3270_Copy"; +0xFD16,"3270_Play"; +0xFD17,"3270_Setup"; +0xFD18,"3270_Record"; +0xFD19,"3270_ChangeScreen"; +0xFD1A,"3270_DeleteWord"; +0xFD1B,"3270_ExSelect"; +0xFD1C,"3270_CursorSelect"; +0xFD1D,"3270_PrintScreen"; +0xFD1E,"3270_Enter"; +0x020,"space"; +0x021,"exclam"; +0x022,"quotedbl"; +0x023,"numbersign"; +0x024,"dollar"; +0x025,"percent"; +0x026,"ampersand"; +0x027,"apostrophe"; +0x027,"quoteright"; +0x028,"parenleft"; +0x029,"parenright"; +0x02a,"asterisk"; +0x02b,"plus"; +0x02c,"comma"; +0x02d,"minus"; +0x02e,"period"; +0x02f,"slash"; +0x030,"0"; +0x031,"1"; +0x032,"2"; +0x033,"3"; +0x034,"4"; +0x035,"5"; +0x036,"6"; +0x037,"7"; +0x038,"8"; +0x039,"9"; +0x03a,"colon"; +0x03b,"semicolon"; +0x03c,"less"; +0x03d,"equal"; +0x03e,"greater"; +0x03f,"question"; +0x040,"at"; +0x041,"A"; +0x042,"B"; +0x043,"C"; +0x044,"D"; +0x045,"E"; +0x046,"F"; +0x047,"G"; +0x048,"H"; +0x049,"I"; +0x04a,"J"; +0x04b,"K"; +0x04c,"L"; +0x04d,"M"; +0x04e,"N"; +0x04f,"O"; +0x050,"P"; +0x051,"Q"; +0x052,"R"; +0x053,"S"; +0x054,"T"; +0x055,"U"; +0x056,"V"; +0x057,"W"; +0x058,"X"; +0x059,"Y"; +0x05a,"Z"; +0x05b,"bracketleft"; +0x05c,"backslash"; +0x05d,"bracketright"; +0x05e,"asciicircum"; +0x05f,"underscore"; +0x060,"grave"; +0x060,"quoteleft"; +0x061,"a"; +0x062,"b"; +0x063,"c"; +0x064,"d"; +0x065,"e"; +0x066,"f"; +0x067,"g"; +0x068,"h"; +0x069,"i"; +0x06a,"j"; +0x06b,"k"; +0x06c,"l"; +0x06d,"m"; +0x06e,"n"; +0x06f,"o"; +0x070,"p"; +0x071,"q"; +0x072,"r"; +0x073,"s"; +0x074,"t"; +0x075,"u"; +0x076,"v"; +0x077,"w"; +0x078,"x"; +0x079,"y"; +0x07a,"z"; +0x07b,"braceleft"; +0x07c,"bar"; +0x07d,"braceright"; +0x07e,"asciitilde"; +0x0a0,"nobreakspace"; +0x0a1,"exclamdown"; +0x0a2,"cent"; +0x0a3,"sterling"; +0x0a4,"currency"; +0x0a5,"yen"; +0x0a6,"brokenbar"; +0x0a7,"section"; +0x0a8,"diaeresis"; +0x0a9,"copyright"; +0x0aa,"ordfeminine"; +0x0ab,"guillemotleft"; +0x0ac,"notsign"; +0x0ad,"hyphen"; +0x0ae,"registered"; +0x0af,"macron"; +0x0b0,"degree"; +0x0b1,"plusminus"; +0x0b2,"twosuperior"; +0x0b3,"threesuperior"; +0x0b4,"acute"; +0x0b5,"mu"; +0x0b6,"paragraph"; +0x0b7,"periodcentered"; +0x0b8,"cedilla"; +0x0b9,"onesuperior"; +0x0ba,"masculine"; +0x0bb,"guillemotright"; +0x0bc,"onequarter"; +0x0bd,"onehalf"; +0x0be,"threequarters"; +0x0bf,"questiondown"; +0x0c0,"Agrave"; +0x0c1,"Aacute"; +0x0c2,"Acircumflex"; +0x0c3,"Atilde"; +0x0c4,"Adiaeresis"; +0x0c5,"Aring"; +0x0c6,"AE"; +0x0c7,"Ccedilla"; +0x0c8,"Egrave"; +0x0c9,"Eacute"; +0x0ca,"Ecircumflex"; +0x0cb,"Ediaeresis"; +0x0cc,"Igrave"; +0x0cd,"Iacute"; +0x0ce,"Icircumflex"; +0x0cf,"Idiaeresis"; +0x0d0,"ETH"; +0x0d0,"Eth"; +0x0d1,"Ntilde"; +0x0d2,"Ograve"; +0x0d3,"Oacute"; +0x0d4,"Ocircumflex"; +0x0d5,"Otilde"; +0x0d6,"Odiaeresis"; +0x0d7,"multiply"; +0x0d8,"Ooblique"; +0x0d9,"Ugrave"; +0x0da,"Uacute"; +0x0db,"Ucircumflex"; +0x0dc,"Udiaeresis"; +0x0dd,"Yacute"; +0x0de,"THORN"; +0x0de,"Thorn"; +0x0df,"ssharp"; +0x0e0,"agrave"; +0x0e1,"aacute"; +0x0e2,"acircumflex"; +0x0e3,"atilde"; +0x0e4,"adiaeresis"; +0x0e5,"aring"; +0x0e6,"ae"; +0x0e7,"ccedilla"; +0x0e8,"egrave"; +0x0e9,"eacute"; +0x0ea,"ecircumflex"; +0x0eb,"ediaeresis"; +0x0ec,"igrave"; +0x0ed,"iacute"; +0x0ee,"icircumflex"; +0x0ef,"idiaeresis"; +0x0f0,"eth"; +0x0f1,"ntilde"; +0x0f2,"ograve"; +0x0f3,"oacute"; +0x0f4,"ocircumflex"; +0x0f5,"otilde"; +0x0f6,"odiaeresis"; +0x0f7,"division"; +0x0f8,"oslash"; +0x0f9,"ugrave"; +0x0fa,"uacute"; +0x0fb,"ucircumflex"; +0x0fc,"udiaeresis"; +0x0fd,"yacute"; +0x0fe,"thorn"; +0x0ff,"ydiaeresis"; +0x1a1,"Aogonek"; +0x1a2,"breve"; +0x1a3,"Lstroke"; +0x1a5,"Lcaron"; +0x1a6,"Sacute"; +0x1a9,"Scaron"; +0x1aa,"Scedilla"; +0x1ab,"Tcaron"; +0x1ac,"Zacute"; +0x1ae,"Zcaron"; +0x1af,"Zabovedot"; +0x1b1,"aogonek"; +0x1b2,"ogonek"; +0x1b3,"lstroke"; +0x1b5,"lcaron"; +0x1b6,"sacute"; +0x1b7,"caron"; +0x1b9,"scaron"; +0x1ba,"scedilla"; +0x1bb,"tcaron"; +0x1bc,"zacute"; +0x1bd,"doubleacute"; +0x1be,"zcaron"; +0x1bf,"zabovedot"; +0x1c0,"Racute"; +0x1c3,"Abreve"; +0x1c5,"Lacute"; +0x1c6,"Cacute"; +0x1c8,"Ccaron"; +0x1ca,"Eogonek"; +0x1cc,"Ecaron"; +0x1cf,"Dcaron"; +0x1d0,"Dstroke"; +0x1d1,"Nacute"; +0x1d2,"Ncaron"; +0x1d5,"Odoubleacute"; +0x1d8,"Rcaron"; +0x1d9,"Uring"; +0x1db,"Udoubleacute"; +0x1de,"Tcedilla"; +0x1e0,"racute"; +0x1e3,"abreve"; +0x1e5,"lacute"; +0x1e6,"cacute"; +0x1e8,"ccaron"; +0x1ea,"eogonek"; +0x1ec,"ecaron"; +0x1ef,"dcaron"; +0x1f0,"dstroke"; +0x1f1,"nacute"; +0x1f2,"ncaron"; +0x1f5,"odoubleacute"; +0x1fb,"udoubleacute"; +0x1f8,"rcaron"; +0x1f9,"uring"; +0x1fe,"tcedilla"; +0x1ff,"abovedot"; +0x2a1,"Hstroke"; +0x2a6,"Hcircumflex"; +0x2a9,"Iabovedot"; +0x2ab,"Gbreve"; +0x2ac,"Jcircumflex"; +0x2b1,"hstroke"; +0x2b6,"hcircumflex"; +0x2b9,"idotless"; +0x2bb,"gbreve"; +0x2bc,"jcircumflex"; +0x2c5,"Cabovedot"; +0x2c6,"Ccircumflex"; +0x2d5,"Gabovedot"; +0x2d8,"Gcircumflex"; +0x2dd,"Ubreve"; +0x2de,"Scircumflex"; +0x2e5,"cabovedot"; +0x2e6,"ccircumflex"; +0x2f5,"gabovedot"; +0x2f8,"gcircumflex"; +0x2fd,"ubreve"; +0x2fe,"scircumflex"; +0x3a2,"kra"; +0x3a2,"kappa"; +0x3a3,"Rcedilla"; +0x3a5,"Itilde"; +0x3a6,"Lcedilla"; +0x3aa,"Emacron"; +0x3ab,"Gcedilla"; +0x3ac,"Tslash"; +0x3b3,"rcedilla"; +0x3b5,"itilde"; +0x3b6,"lcedilla"; +0x3ba,"emacron"; +0x3bb,"gcedilla"; +0x3bc,"tslash"; +0x3bd,"ENG"; +0x3bf,"eng"; +0x3c0,"Amacron"; +0x3c7,"Iogonek"; +0x3cc,"Eabovedot"; +0x3cf,"Imacron"; +0x3d1,"Ncedilla"; +0x3d2,"Omacron"; +0x3d3,"Kcedilla"; +0x3d9,"Uogonek"; +0x3dd,"Utilde"; +0x3de,"Umacron"; +0x3e0,"amacron"; +0x3e7,"iogonek"; +0x3ec,"eabovedot"; +0x3ef,"imacron"; +0x3f1,"ncedilla"; +0x3f2,"omacron"; +0x3f3,"kcedilla"; +0x3f9,"uogonek"; +0x3fd,"utilde"; +0x3fe,"umacron"; +0x47e,"overline"; +0x4a1,"kana_fullstop"; +0x4a2,"kana_openingbracket"; +0x4a3,"kana_closingbracket"; +0x4a4,"kana_comma"; +0x4a5,"kana_conjunctive"; +0x4a5,"kana_middledot"; +0x4a6,"kana_WO"; +0x4a7,"kana_a"; +0x4a8,"kana_i"; +0x4a9,"kana_u"; +0x4aa,"kana_e"; +0x4ab,"kana_o"; +0x4ac,"kana_ya"; +0x4ad,"kana_yu"; +0x4ae,"kana_yo"; +0x4af,"kana_tsu"; +0x4af,"kana_tu"; +0x4b0,"prolongedsound"; +0x4b1,"kana_A"; +0x4b2,"kana_I"; +0x4b3,"kana_U"; +0x4b4,"kana_E"; +0x4b5,"kana_O"; +0x4b6,"kana_KA"; +0x4b7,"kana_KI"; +0x4b8,"kana_KU"; +0x4b9,"kana_KE"; +0x4ba,"kana_KO"; +0x4bb,"kana_SA"; +0x4bc,"kana_SHI"; +0x4bd,"kana_SU"; +0x4be,"kana_SE"; +0x4bf,"kana_SO"; +0x4c0,"kana_TA"; +0x4c1,"kana_CHI"; +0x4c1,"kana_TI"; +0x4c2,"kana_TSU"; +0x4c2,"kana_TU"; +0x4c3,"kana_TE"; +0x4c4,"kana_TO"; +0x4c5,"kana_NA"; +0x4c6,"kana_NI"; +0x4c7,"kana_NU"; +0x4c8,"kana_NE"; +0x4c9,"kana_NO"; +0x4ca,"kana_HA"; +0x4cb,"kana_HI"; +0x4cc,"kana_FU"; +0x4cc,"kana_HU"; +0x4cd,"kana_HE"; +0x4ce,"kana_HO"; +0x4cf,"kana_MA"; +0x4d0,"kana_MI"; +0x4d1,"kana_MU"; +0x4d2,"kana_ME"; +0x4d3,"kana_MO"; +0x4d4,"kana_YA"; +0x4d5,"kana_YU"; +0x4d6,"kana_YO"; +0x4d7,"kana_RA"; +0x4d8,"kana_RI"; +0x4d9,"kana_RU"; +0x4da,"kana_RE"; +0x4db,"kana_RO"; +0x4dc,"kana_WA"; +0x4dd,"kana_N"; +0x4de,"voicedsound"; +0x4df,"semivoicedsound"; +0xFF7E,"kana_switch"; +0x5ac,"Arabic_comma"; +0x5bb,"Arabic_semicolon"; +0x5bf,"Arabic_question_mark"; +0x5c1,"Arabic_hamza"; +0x5c2,"Arabic_maddaonalef"; +0x5c3,"Arabic_hamzaonalef"; +0x5c4,"Arabic_hamzaonwaw"; +0x5c5,"Arabic_hamzaunderalef"; +0x5c6,"Arabic_hamzaonyeh"; +0x5c7,"Arabic_alef"; +0x5c8,"Arabic_beh"; +0x5c9,"Arabic_tehmarbuta"; +0x5ca,"Arabic_teh"; +0x5cb,"Arabic_theh"; +0x5cc,"Arabic_jeem"; +0x5cd,"Arabic_hah"; +0x5ce,"Arabic_khah"; +0x5cf,"Arabic_dal"; +0x5d0,"Arabic_thal"; +0x5d1,"Arabic_ra"; +0x5d2,"Arabic_zain"; +0x5d3,"Arabic_seen"; +0x5d4,"Arabic_sheen"; +0x5d5,"Arabic_sad"; +0x5d6,"Arabic_dad"; +0x5d7,"Arabic_tah"; +0x5d8,"Arabic_zah"; +0x5d9,"Arabic_ain"; +0x5da,"Arabic_ghain"; +0x5e0,"Arabic_tatweel"; +0x5e1,"Arabic_feh"; +0x5e2,"Arabic_qaf"; +0x5e3,"Arabic_kaf"; +0x5e4,"Arabic_lam"; +0x5e5,"Arabic_meem"; +0x5e6,"Arabic_noon"; +0x5e7,"Arabic_ha"; +0x5e7,"Arabic_heh"; +0x5e8,"Arabic_waw"; +0x5e9,"Arabic_alefmaksura"; +0x5ea,"Arabic_yeh"; +0x5eb,"Arabic_fathatan"; +0x5ec,"Arabic_dammatan"; +0x5ed,"Arabic_kasratan"; +0x5ee,"Arabic_fatha"; +0x5ef,"Arabic_damma"; +0x5f0,"Arabic_kasra"; +0x5f1,"Arabic_shadda"; +0x5f2,"Arabic_sukun"; +0xFF7E,"Arabic_switch"; +0x6a1,"Serbian_dje"; +0x6a2,"Macedonia_gje"; +0x6a3,"Cyrillic_io"; +0x6a4,"Ukrainian_ie"; +0x6a4,"Ukranian_je"; +0x6a5,"Macedonia_dse"; +0x6a6,"Ukrainian_i"; +0x6a6,"Ukranian_i"; +0x6a7,"Ukrainian_yi"; +0x6a7,"Ukranian_yi"; +0x6a8,"Cyrillic_je"; +0x6a8,"Serbian_je"; +0x6a9,"Cyrillic_lje"; +0x6a9,"Serbian_lje"; +0x6aa,"Cyrillic_nje"; +0x6aa,"Serbian_nje"; +0x6ab,"Serbian_tshe"; +0x6ac,"Macedonia_kje"; +0x6ae,"Byelorussian_shortu"; +0x6af,"Cyrillic_dzhe"; +0x6af,"Serbian_dze"; +0x6b0,"numerosign"; +0x6b1,"Serbian_DJE"; +0x6b2,"Macedonia_GJE"; +0x6b3,"Cyrillic_IO"; +0x6b4,"Ukrainian_IE"; +0x6b4,"Ukranian_JE"; +0x6b5,"Macedonia_DSE"; +0x6b6,"Ukrainian_I"; +0x6b6,"Ukranian_I"; +0x6b7,"Ukrainian_YI"; +0x6b7,"Ukranian_YI"; +0x6b8,"Cyrillic_JE"; +0x6b8,"Serbian_JE"; +0x6b9,"Cyrillic_LJE"; +0x6b9,"Serbian_LJE"; +0x6ba,"Cyrillic_NJE"; +0x6ba,"Serbian_NJE"; +0x6bb,"Serbian_TSHE"; +0x6bc,"Macedonia_KJE"; +0x6be,"Byelorussian_SHORTU"; +0x6bf,"Cyrillic_DZHE"; +0x6bf,"Serbian_DZE"; +0x6c0,"Cyrillic_yu"; +0x6c1,"Cyrillic_a"; +0x6c2,"Cyrillic_be"; +0x6c3,"Cyrillic_tse"; +0x6c4,"Cyrillic_de"; +0x6c5,"Cyrillic_ie"; +0x6c6,"Cyrillic_ef"; +0x6c7,"Cyrillic_ghe"; +0x6c8,"Cyrillic_ha"; +0x6c9,"Cyrillic_i"; +0x6ca,"Cyrillic_shorti"; +0x6cb,"Cyrillic_ka"; +0x6cc,"Cyrillic_el"; +0x6cd,"Cyrillic_em"; +0x6ce,"Cyrillic_en"; +0x6cf,"Cyrillic_o"; +0x6d0,"Cyrillic_pe"; +0x6d1,"Cyrillic_ya"; +0x6d2,"Cyrillic_er"; +0x6d3,"Cyrillic_es"; +0x6d4,"Cyrillic_te"; +0x6d5,"Cyrillic_u"; +0x6d6,"Cyrillic_zhe"; +0x6d7,"Cyrillic_ve"; +0x6d8,"Cyrillic_softsign"; +0x6d9,"Cyrillic_yeru"; +0x6da,"Cyrillic_ze"; +0x6db,"Cyrillic_sha"; +0x6dc,"Cyrillic_e"; +0x6dd,"Cyrillic_shcha"; +0x6de,"Cyrillic_che"; +0x6df,"Cyrillic_hardsign"; +0x6e0,"Cyrillic_YU"; +0x6e1,"Cyrillic_A"; +0x6e2,"Cyrillic_BE"; +0x6e3,"Cyrillic_TSE"; +0x6e4,"Cyrillic_DE"; +0x6e5,"Cyrillic_IE"; +0x6e6,"Cyrillic_EF"; +0x6e7,"Cyrillic_GHE"; +0x6e8,"Cyrillic_HA"; +0x6e9,"Cyrillic_I"; +0x6ea,"Cyrillic_SHORTI"; +0x6eb,"Cyrillic_KA"; +0x6ec,"Cyrillic_EL"; +0x6ed,"Cyrillic_EM"; +0x6ee,"Cyrillic_EN"; +0x6ef,"Cyrillic_O"; +0x6f0,"Cyrillic_PE"; +0x6f1,"Cyrillic_YA"; +0x6f2,"Cyrillic_ER"; +0x6f3,"Cyrillic_ES"; +0x6f4,"Cyrillic_TE"; +0x6f5,"Cyrillic_U"; +0x6f6,"Cyrillic_ZHE"; +0x6f7,"Cyrillic_VE"; +0x6f8,"Cyrillic_SOFTSIGN"; +0x6f9,"Cyrillic_YERU"; +0x6fa,"Cyrillic_ZE"; +0x6fb,"Cyrillic_SHA"; +0x6fc,"Cyrillic_E"; +0x6fd,"Cyrillic_SHCHA"; +0x6fe,"Cyrillic_CHE"; +0x6ff,"Cyrillic_HARDSIGN"; +0x7a1,"Greek_ALPHAaccent"; +0x7a2,"Greek_EPSILONaccent"; +0x7a3,"Greek_ETAaccent"; +0x7a4,"Greek_IOTAaccent"; +0x7a5,"Greek_IOTAdiaeresis"; +0x7a7,"Greek_OMICRONaccent"; +0x7a8,"Greek_UPSILONaccent"; +0x7a9,"Greek_UPSILONdieresis"; +0x7ab,"Greek_OMEGAaccent"; +0x7ae,"Greek_accentdieresis"; +0x7af,"Greek_horizbar"; +0x7b1,"Greek_alphaaccent"; +0x7b2,"Greek_epsilonaccent"; +0x7b3,"Greek_etaaccent"; +0x7b4,"Greek_iotaaccent"; +0x7b5,"Greek_iotadieresis"; +0x7b6,"Greek_iotaaccentdieresis"; +0x7b7,"Greek_omicronaccent"; +0x7b8,"Greek_upsilonaccent"; +0x7b9,"Greek_upsilondieresis"; +0x7ba,"Greek_upsilonaccentdieresis"; +0x7bb,"Greek_omegaaccent"; +0x7c1,"Greek_ALPHA"; +0x7c2,"Greek_BETA"; +0x7c3,"Greek_GAMMA"; +0x7c4,"Greek_DELTA"; +0x7c5,"Greek_EPSILON"; +0x7c6,"Greek_ZETA"; +0x7c7,"Greek_ETA"; +0x7c8,"Greek_THETA"; +0x7c9,"Greek_IOTA"; +0x7ca,"Greek_KAPPA"; +0x7cb,"Greek_LAMDA"; +0x7cb,"Greek_LAMBDA"; +0x7cc,"Greek_MU"; +0x7cd,"Greek_NU"; +0x7ce,"Greek_XI"; +0x7cf,"Greek_OMICRON"; +0x7d0,"Greek_PI"; +0x7d1,"Greek_RHO"; +0x7d2,"Greek_SIGMA"; +0x7d4,"Greek_TAU"; +0x7d5,"Greek_UPSILON"; +0x7d6,"Greek_PHI"; +0x7d7,"Greek_CHI"; +0x7d8,"Greek_PSI"; +0x7d9,"Greek_OMEGA"; +0x7e1,"Greek_alpha"; +0x7e2,"Greek_beta"; +0x7e3,"Greek_gamma"; +0x7e4,"Greek_delta"; +0x7e5,"Greek_epsilon"; +0x7e6,"Greek_zeta"; +0x7e7,"Greek_eta"; +0x7e8,"Greek_theta"; +0x7e9,"Greek_iota"; +0x7ea,"Greek_kappa"; +0x7eb,"Greek_lamda"; +0x7eb,"Greek_lambda"; +0x7ec,"Greek_mu"; +0x7ed,"Greek_nu"; +0x7ee,"Greek_xi"; +0x7ef,"Greek_omicron"; +0x7f0,"Greek_pi"; +0x7f1,"Greek_rho"; +0x7f2,"Greek_sigma"; +0x7f3,"Greek_finalsmallsigma"; +0x7f4,"Greek_tau"; +0x7f5,"Greek_upsilon"; +0x7f6,"Greek_phi"; +0x7f7,"Greek_chi"; +0x7f8,"Greek_psi"; +0x7f9,"Greek_omega"; +0xFF7E,"Greek_switch"; +0x8a1,"leftradical"; +0x8a2,"topleftradical"; +0x8a3,"horizconnector"; +0x8a4,"topintegral"; +0x8a5,"botintegral"; +0x8a6,"vertconnector"; +0x8a7,"topleftsqbracket"; +0x8a8,"botleftsqbracket"; +0x8a9,"toprightsqbracket"; +0x8aa,"botrightsqbracket"; +0x8ab,"topleftparens"; +0x8ac,"botleftparens"; +0x8ad,"toprightparens"; +0x8ae,"botrightparens"; +0x8af,"leftmiddlecurlybrace"; +0x8b0,"rightmiddlecurlybrace"; +0x8b1,"topleftsummation"; +0x8b2,"botleftsummation"; +0x8b3,"topvertsummationconnector"; +0x8b4,"botvertsummationconnector"; +0x8b5,"toprightsummation"; +0x8b6,"botrightsummation"; +0x8b7,"rightmiddlesummation"; +0x8bc,"lessthanequal"; +0x8bd,"notequal"; +0x8be,"greaterthanequal"; +0x8bf,"integral"; +0x8c0,"therefore"; +0x8c1,"variation"; +0x8c2,"infinity"; +0x8c5,"nabla"; +0x8c8,"approximate"; +0x8c9,"similarequal"; +0x8cd,"ifonlyif"; +0x8ce,"implies"; +0x8cf,"identical"; +0x8d6,"radical"; +0x8da,"includedin"; +0x8db,"includes"; +0x8dc,"intersection"; +0x8dd,"union"; +0x8de,"logicaland"; +0x8df,"logicalor"; +0x8ef,"partialderivative"; +0x8f6,"function"; +0x8fb,"leftarrow"; +0x8fc,"uparrow"; +0x8fd,"rightarrow"; +0x8fe,"downarrow"; +0x9df,"blank"; +0x9e0,"soliddiamond"; +0x9e1,"checkerboard"; +0x9e2,"ht"; +0x9e3,"ff"; +0x9e4,"cr"; +0x9e5,"lf"; +0x9e8,"nl"; +0x9e9,"vt"; +0x9ea,"lowrightcorner"; +0x9eb,"uprightcorner"; +0x9ec,"upleftcorner"; +0x9ed,"lowleftcorner"; +0x9ee,"crossinglines"; +0x9ef,"horizlinescan1"; +0x9f0,"horizlinescan3"; +0x9f1,"horizlinescan5"; +0x9f2,"horizlinescan7"; +0x9f3,"horizlinescan9"; +0x9f4,"leftt"; +0x9f5,"rightt"; +0x9f6,"bott"; +0x9f7,"topt"; +0x9f8,"vertbar"; +0xaa1,"emspace"; +0xaa2,"enspace"; +0xaa3,"em3space"; +0xaa4,"em4space"; +0xaa5,"digitspace"; +0xaa6,"punctspace"; +0xaa7,"thinspace"; +0xaa8,"hairspace"; +0xaa9,"emdash"; +0xaaa,"endash"; +0xaac,"signifblank"; +0xaae,"ellipsis"; +0xaaf,"doubbaselinedot"; +0xab0,"onethird"; +0xab1,"twothirds"; +0xab2,"onefifth"; +0xab3,"twofifths"; +0xab4,"threefifths"; +0xab5,"fourfifths"; +0xab6,"onesixth"; +0xab7,"fivesixths"; +0xab8,"careof"; +0xabb,"figdash"; +0xabc,"leftanglebracket"; +0xabd,"decimalpoint"; +0xabe,"rightanglebracket"; +0xabf,"marker"; +0xac3,"oneeighth"; +0xac4,"threeeighths"; +0xac5,"fiveeighths"; +0xac6,"seveneighths"; +0xac9,"trademark"; +0xaca,"signaturemark"; +0xacb,"trademarkincircle"; +0xacc,"leftopentriangle"; +0xacd,"rightopentriangle"; +0xace,"emopencircle"; +0xacf,"emopenrectangle"; +0xad0,"leftsinglequotemark"; +0xad1,"rightsinglequotemark"; +0xad2,"leftdoublequotemark"; +0xad3,"rightdoublequotemark"; +0xad4,"prescription"; +0xad6,"minutes"; +0xad7,"seconds"; +0xad9,"latincross"; +0xada,"hexagram"; +0xadb,"filledrectbullet"; +0xadc,"filledlefttribullet"; +0xadd,"filledrighttribullet"; +0xade,"emfilledcircle"; +0xadf,"emfilledrect"; +0xae0,"enopencircbullet"; +0xae1,"enopensquarebullet"; +0xae2,"openrectbullet"; +0xae3,"opentribulletup"; +0xae4,"opentribulletdown"; +0xae5,"openstar"; +0xae6,"enfilledcircbullet"; +0xae7,"enfilledsqbullet"; +0xae8,"filledtribulletup"; +0xae9,"filledtribulletdown"; +0xaea,"leftpointer"; +0xaeb,"rightpointer"; +0xaec,"club"; +0xaed,"diamond"; +0xaee,"heart"; +0xaf0,"maltesecross"; +0xaf1,"dagger"; +0xaf2,"doubledagger"; +0xaf3,"checkmark"; +0xaf4,"ballotcross"; +0xaf5,"musicalsharp"; +0xaf6,"musicalflat"; +0xaf7,"malesymbol"; +0xaf8,"femalesymbol"; +0xaf9,"telephone"; +0xafa,"telephonerecorder"; +0xafb,"phonographcopyright"; +0xafc,"caret"; +0xafd,"singlelowquotemark"; +0xafe,"doublelowquotemark"; +0xaff,"cursor"; +0xba3,"leftcaret"; +0xba6,"rightcaret"; +0xba8,"downcaret"; +0xba9,"upcaret"; +0xbc0,"overbar"; +0xbc2,"downtack"; +0xbc3,"upshoe"; +0xbc4,"downstile"; +0xbc6,"underbar"; +0xbca,"jot"; +0xbcc,"quad"; +0xbce,"uptack"; +0xbcf,"circle"; +0xbd3,"upstile"; +0xbd6,"downshoe"; +0xbd8,"rightshoe"; +0xbda,"leftshoe"; +0xbdc,"lefttack"; +0xbfc,"righttack"; +0xcdf,"hebrew_doublelowline"; +0xce0,"hebrew_aleph"; +0xce1,"hebrew_bet"; +0xce1,"hebrew_beth"; +0xce2,"hebrew_gimel"; +0xce2,"hebrew_gimmel"; +0xce3,"hebrew_dalet"; +0xce3,"hebrew_daleth"; +0xce4,"hebrew_he"; +0xce5,"hebrew_waw"; +0xce6,"hebrew_zain"; +0xce6,"hebrew_zayin"; +0xce7,"hebrew_chet"; +0xce7,"hebrew_het"; +0xce8,"hebrew_tet"; +0xce8,"hebrew_teth"; +0xce9,"hebrew_yod"; +0xcea,"hebrew_finalkaph"; +0xceb,"hebrew_kaph"; +0xcec,"hebrew_lamed"; +0xced,"hebrew_finalmem"; +0xcee,"hebrew_mem"; +0xcef,"hebrew_finalnun"; +0xcf0,"hebrew_nun"; +0xcf1,"hebrew_samech"; +0xcf1,"hebrew_samekh"; +0xcf2,"hebrew_ayin"; +0xcf3,"hebrew_finalpe"; +0xcf4,"hebrew_pe"; +0xcf5,"hebrew_finalzade"; +0xcf5,"hebrew_finalzadi"; +0xcf6,"hebrew_zade"; +0xcf6,"hebrew_zadi"; +0xcf7,"hebrew_qoph"; +0xcf7,"hebrew_kuf"; +0xcf8,"hebrew_resh"; +0xcf9,"hebrew_shin"; +0xcfa,"hebrew_taw"; +0xcfa,"hebrew_taf"; +0xFF7E,"Hebrew_switch"; +0xda1,"Thai_kokai"; +0xda2,"Thai_khokhai"; +0xda3,"Thai_khokhuat"; +0xda4,"Thai_khokhwai"; +0xda5,"Thai_khokhon"; +0xda6,"Thai_khorakhang"; +0xda7,"Thai_ngongu"; +0xda8,"Thai_chochan"; +0xda9,"Thai_choching"; +0xdaa,"Thai_chochang"; +0xdab,"Thai_soso"; +0xdac,"Thai_chochoe"; +0xdad,"Thai_yoying"; +0xdae,"Thai_dochada"; +0xdaf,"Thai_topatak"; +0xdb0,"Thai_thothan"; +0xdb1,"Thai_thonangmontho"; +0xdb2,"Thai_thophuthao"; +0xdb3,"Thai_nonen"; +0xdb4,"Thai_dodek"; +0xdb5,"Thai_totao"; +0xdb6,"Thai_thothung"; +0xdb7,"Thai_thothahan"; +0xdb8,"Thai_thothong"; +0xdb9,"Thai_nonu"; +0xdba,"Thai_bobaimai"; +0xdbb,"Thai_popla"; +0xdbc,"Thai_phophung"; +0xdbd,"Thai_fofa"; +0xdbe,"Thai_phophan"; +0xdbf,"Thai_fofan"; +0xdc0,"Thai_phosamphao"; +0xdc1,"Thai_moma"; +0xdc2,"Thai_yoyak"; +0xdc3,"Thai_rorua"; +0xdc4,"Thai_ru"; +0xdc5,"Thai_loling"; +0xdc6,"Thai_lu"; +0xdc7,"Thai_wowaen"; +0xdc8,"Thai_sosala"; +0xdc9,"Thai_sorusi"; +0xdca,"Thai_sosua"; +0xdcb,"Thai_hohip"; +0xdcc,"Thai_lochula"; +0xdcd,"Thai_oang"; +0xdce,"Thai_honokhuk"; +0xdcf,"Thai_paiyannoi"; +0xdd0,"Thai_saraa"; +0xdd1,"Thai_maihanakat"; +0xdd2,"Thai_saraaa"; +0xdd3,"Thai_saraam"; +0xdd4,"Thai_sarai"; +0xdd5,"Thai_saraii"; +0xdd6,"Thai_saraue"; +0xdd7,"Thai_sarauee"; +0xdd8,"Thai_sarau"; +0xdd9,"Thai_sarauu"; +0xdda,"Thai_phinthu"; +0xdde,"Thai_maihanakat_maitho"; +0xddf,"Thai_baht"; +0xde0,"Thai_sarae"; +0xde1,"Thai_saraae"; +0xde2,"Thai_sarao"; +0xde3,"Thai_saraaimaimuan"; +0xde4,"Thai_saraaimaimalai"; +0xde5,"Thai_lakkhangyao"; +0xde6,"Thai_maiyamok"; +0xde7,"Thai_maitaikhu"; +0xde8,"Thai_maiek"; +0xde9,"Thai_maitho"; +0xdea,"Thai_maitri"; +0xdeb,"Thai_maichattawa"; +0xdec,"Thai_thanthakhat"; +0xded,"Thai_nikhahit"; +0xdf0,"Thai_leksun"; +0xdf1,"Thai_leknung"; +0xdf2,"Thai_leksong"; +0xdf3,"Thai_leksam"; +0xdf4,"Thai_leksi"; +0xdf5,"Thai_lekha"; +0xdf6,"Thai_lekhok"; +0xdf7,"Thai_lekchet"; +0xdf8,"Thai_lekpaet"; +0xdf9,"Thai_lekkao"; +0xff31,"Hangul"; +0xff32,"Hangul_Start"; +0xff33,"Hangul_End"; +0xff34,"Hangul_Hanja"; +0xff35,"Hangul_Jamo"; +0xff36,"Hangul_Romaja"; +0xff37,"Hangul_Codeinput"; +0xff38,"Hangul_Jeonja"; +0xff39,"Hangul_Banja"; +0xff3a,"Hangul_PreHanja"; +0xff3b,"Hangul_PostHanja"; +0xff3c,"Hangul_SingleCandidate"; +0xff3d,"Hangul_MultipleCandidate"; +0xff3e,"Hangul_PreviousCandidate"; +0xff3f,"Hangul_Special"; +0xFF7E,"Hangul_switch"; +0xea1,"Hangul_Kiyeog"; +0xea2,"Hangul_SsangKiyeog"; +0xea3,"Hangul_KiyeogSios"; +0xea4,"Hangul_Nieun"; +0xea5,"Hangul_NieunJieuj"; +0xea6,"Hangul_NieunHieuh"; +0xea7,"Hangul_Dikeud"; +0xea8,"Hangul_SsangDikeud"; +0xea9,"Hangul_Rieul"; +0xeaa,"Hangul_RieulKiyeog"; +0xeab,"Hangul_RieulMieum"; +0xeac,"Hangul_RieulPieub"; +0xead,"Hangul_RieulSios"; +0xeae,"Hangul_RieulTieut"; +0xeaf,"Hangul_RieulPhieuf"; +0xeb0,"Hangul_RieulHieuh"; +0xeb1,"Hangul_Mieum"; +0xeb2,"Hangul_Pieub"; +0xeb3,"Hangul_SsangPieub"; +0xeb4,"Hangul_PieubSios"; +0xeb5,"Hangul_Sios"; +0xeb6,"Hangul_SsangSios"; +0xeb7,"Hangul_Ieung"; +0xeb8,"Hangul_Jieuj"; +0xeb9,"Hangul_SsangJieuj"; +0xeba,"Hangul_Cieuc"; +0xebb,"Hangul_Khieuq"; +0xebc,"Hangul_Tieut"; +0xebd,"Hangul_Phieuf"; +0xebe,"Hangul_Hieuh"; +0xebf,"Hangul_A"; +0xec0,"Hangul_AE"; +0xec1,"Hangul_YA"; +0xec2,"Hangul_YAE"; +0xec3,"Hangul_EO"; +0xec4,"Hangul_E"; +0xec5,"Hangul_YEO"; +0xec6,"Hangul_YE"; +0xec7,"Hangul_O"; +0xec8,"Hangul_WA"; +0xec9,"Hangul_WAE"; +0xeca,"Hangul_OE"; +0xecb,"Hangul_YO"; +0xecc,"Hangul_U"; +0xecd,"Hangul_WEO"; +0xece,"Hangul_WE"; +0xecf,"Hangul_WI"; +0xed0,"Hangul_YU"; +0xed1,"Hangul_EU"; +0xed2,"Hangul_YI"; +0xed3,"Hangul_I"; +0xed4,"Hangul_J_Kiyeog"; +0xed5,"Hangul_J_SsangKiyeog"; +0xed6,"Hangul_J_KiyeogSios"; +0xed7,"Hangul_J_Nieun"; +0xed8,"Hangul_J_NieunJieuj"; +0xed9,"Hangul_J_NieunHieuh"; +0xeda,"Hangul_J_Dikeud"; +0xedb,"Hangul_J_Rieul"; +0xedc,"Hangul_J_RieulKiyeog"; +0xedd,"Hangul_J_RieulMieum"; +0xede,"Hangul_J_RieulPieub"; +0xedf,"Hangul_J_RieulSios"; +0xee0,"Hangul_J_RieulTieut"; +0xee1,"Hangul_J_RieulPhieuf"; +0xee2,"Hangul_J_RieulHieuh"; +0xee3,"Hangul_J_Mieum"; +0xee4,"Hangul_J_Pieub"; +0xee5,"Hangul_J_PieubSios"; +0xee6,"Hangul_J_Sios"; +0xee7,"Hangul_J_SsangSios"; +0xee8,"Hangul_J_Ieung"; +0xee9,"Hangul_J_Jieuj"; +0xeea,"Hangul_J_Cieuc"; +0xeeb,"Hangul_J_Khieuq"; +0xeec,"Hangul_J_Tieut"; +0xeed,"Hangul_J_Phieuf"; +0xeee,"Hangul_J_Hieuh"; +0xeef,"Hangul_RieulYeorinHieuh"; +0xef0,"Hangul_SunkyeongeumMieum"; +0xef1,"Hangul_SunkyeongeumPieub"; +0xef2,"Hangul_PanSios"; +0xef3,"Hangul_KkogjiDalrinIeung"; +0xef4,"Hangul_SunkyeongeumPhieuf"; +0xef5,"Hangul_YeorinHieuh"; +0xef6,"Hangul_AraeA"; +0xef7,"Hangul_AraeAE"; +0xef8,"Hangul_J_PanSios"; +0xef9,"Hangul_J_KkogjiDalrinIeung"; +0xefa,"Hangul_J_YeorinHieuh"; +0xeff,"Korean_Won"; +] diff --git a/ide/utils/configwin_messages.ml b/ide/utils/configwin_messages.ml new file mode 100644 index 00000000..a6085138 --- /dev/null +++ b/ide/utils/configwin_messages.ml @@ -0,0 +1,51 @@ +(**************************************************************************) +(* Cameleon *) +(* *) +(* Copyright (C) 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. *) +(* *) +(* This program is free software; you can redistribute it and/or modify *) +(* it under the terms of the GNU General Public License as published by *) +(* the Free Software Foundation; either version 2 of the License, or *) +(* any later version. *) +(* *) +(* This program is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) +(* GNU General Public License for more details. *) +(* *) +(* You should have received a copy of the GNU General Public License *) +(* along with this program; if not, write to the Free Software *) +(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *) +(* 02111-1307 USA *) +(* *) +(* Contact: Maxence.Guesdon@inria.fr *) +(**************************************************************************) + +(** Module containing the messages of Configwin.*) + +let software = "Configwin";; +let version = "1.3";; + +let html_config = "Configwin bindings configurator for html parameters" + +let home = + try Sys.getenv "HOME" + with Not_found -> "" + +let mCapture = "Capture";; +let mType_key = "Type key" ;; +let mAdd = "Add";; +let mRemove = "Remove";; +let mUp = "Up";; +let mEdit = "Edit";; +let mOk = "Ok";; +let mCancel = "Cancel";; +let mApply = "Apply";; +let mValue = "Value" +let mKey = "Key" + +let shortcuts = "Shortcuts" +let html_end = "End with" +let html_begin = "Begin with" + diff --git a/ide/utils/configwin_types.ml b/ide/utils/configwin_types.ml new file mode 100644 index 00000000..ee8ec70c --- /dev/null +++ b/ide/utils/configwin_types.ml @@ -0,0 +1,299 @@ +(**************************************************************************) +(* Cameleon *) +(* *) +(* Copyright (C) 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. *) +(* *) +(* This program is free software; you can redistribute it and/or modify *) +(* it under the terms of the GNU General Public License as published by *) +(* the Free Software Foundation; either version 2 of the License, or *) +(* any later version. *) +(* *) +(* This program is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) +(* GNU General Public License for more details. *) +(* *) +(* You should have received a copy of the GNU General Public License *) +(* along with this program; if not, write to the Free Software *) +(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *) +(* 02111-1307 USA *) +(* *) +(* Contact: Maxence.Guesdon@inria.fr *) +(**************************************************************************) + +(** This module contains the types used in Configwin. *) + +open Uoptions + +(** A module to define key options, with the {!Uoptions} module. *) +module KeyOption = struct + let name_to_keysym = + ("Button1", Configwin_keys.xk_Pointer_Button1) :: + ("Button2", Configwin_keys.xk_Pointer_Button2) :: + ("Button3", Configwin_keys.xk_Pointer_Button3) :: + ("Button4", Configwin_keys.xk_Pointer_Button4) :: + ("Button5", Configwin_keys.xk_Pointer_Button5) :: + Configwin_keys.name_to_keysym + + let string_to_key s = + let mask = ref [] in + let key = try + let pos = String.rindex s '-' in + for i = 0 to pos - 1 do + let m = match s.[i] with + 'C' -> `CONTROL + | 'S' -> `SHIFT + | 'L' -> `LOCK + | 'M' -> `MOD1 + | 'A' -> `MOD1 + | '1' -> `MOD1 + | '2' -> `MOD2 + | '3' -> `MOD3 + | '4' -> `MOD4 + | '5' -> `MOD5 + | _ -> + prerr_endline s; + raise Not_found + in + mask := m :: !mask + done; + String.sub s (pos+1) (String.length s - pos - 1) + with _ -> + s + in + try + !mask, List.assoc key name_to_keysym + with + e -> + prerr_endline s; + raise e + + let key_to_string (m, k) = + let s = List.assoc k Configwin_keys.keysym_to_name in + match m with + [] -> s + | _ -> + let rec iter m s = + match m with + [] -> s + | c :: m -> + iter m (( + match c with + `CONTROL -> "C" + | `SHIFT -> "S" + | `LOCK -> "L" + | `MOD1 -> "A" + | `MOD2 -> "2" + | `MOD3 -> "3" + | `MOD4 -> "4" + | `MOD5 -> "5" + | _ -> raise Not_found + ) ^ s) + in + iter m ("-" ^ s) + + let modifiers_to_string m = + let rec iter m s = + match m with + [] -> s + | c :: m -> + iter m (( + match c with + `CONTROL -> "" + | `SHIFT -> "" + | `LOCK -> "" + | `MOD1 -> "" + | `MOD2 -> "" + | `MOD3 -> "" + | `MOD4 -> "" + | `MOD5 -> "" + | _ -> raise Not_found + ) ^ s) + in + iter m "" + + let value_to_key v = + match v with + StringValue s -> string_to_key s + | _ -> + prerr_endline "value_to_key"; + raise Not_found + + let key_to_value k = + StringValue (key_to_string k) + + let (t : (Gdk.Tags.modifier list * int) option_class) = + define_option_class "Key" value_to_key key_to_value +end + +(** This type represents a string or filename parameter. *) +type string_param = { + string_label : string; (** the label of the parameter *) + mutable string_value : string; (** the current value of the parameter *) + string_editable : bool ; (** indicates if the value can be changed *) + string_f_apply : (string -> unit) ; (** the function to call to apply the new value of the parameter *) + string_help : string option ; (** optional help string *) + string_expand : bool ; (** expand or not *) + } ;; + +(** This type represents a boolean parameter. *) +type bool_param = { + bool_label : string; (** the label of the parameter *) + mutable bool_value : bool; (** the current value of the parameter *) + bool_editable : bool ; (** indicates if the value can be changed *) + bool_f_apply : (bool -> unit) ; (** the function to call to apply the new value of the parameter *) + bool_help : string option ; (** optional help string *) + } ;; + +(** This type represents a parameter whose value is a list of ['a]. *) +type 'a list_param = { + list_label : string; (** the label of the parameter *) + mutable list_value : 'a list; (** the current value of the parameter *) + list_titles : string list option; (** the titles of columns, if they must be displayed *) + list_f_edit : ('a -> 'a) option; (** optional edition function *) + list_eq : ('a -> 'a -> bool) ; (** the comparison function used to get list without doubles *) + list_strings : ('a -> string list); (** the function to get a string list from a ['a]. *) + list_color : ('a -> string option) ; (** a function to get the optional color of an element *) + list_editable : bool ; (** indicates if the value can be changed *) + list_f_add : unit -> 'a list ; (** the function to call to add list *) + list_f_apply : ('a list -> unit) ; (** the function to call to apply the new value of the parameter *) + list_help : string option ; (** optional help string *) + } ;; + +type combo_param = { + combo_label : string ; + mutable combo_value : string ; + combo_choices : string list ; + combo_editable : bool ; + combo_blank_allowed : bool ; + combo_new_allowed : bool ; + combo_f_apply : (string -> unit); + combo_help : string option ; (** optional help string *) + combo_expand : bool ; (** expand the entry widget or not *) + } ;; + +type custom_param = { + custom_box : GPack.box ; + custom_f_apply : (unit -> unit) ; + custom_expand : bool ; + custom_framed : string option ; (** optional label for an optional frame *) + } ;; + +type color_param = { + color_label : string; (** the label of the parameter *) + mutable color_value : string; (** the current value of the parameter *) + color_editable : bool ; (** indicates if the value can be changed *) + color_f_apply : (string -> unit) ; (** the function to call to apply the new value of the parameter *) + color_help : string option ; (** optional help string *) + color_expand : bool ; (** expand the entry widget or not *) + } ;; + +type date_param = { + date_label : string ; (** the label of the parameter *) + mutable date_value : int * int * int ; (** day, month, year *) + date_editable : bool ; (** indicates if the value can be changed *) + date_f_string : (int * int * int) -> string ; + (** the function used to display the current value (day, month, year) *) + date_f_apply : ((int * int * int) -> unit) ; + (** the function to call to apply the new value (day, month, year) of the parameter *) + date_help : string option ; (** optional help string *) + date_expand : bool ; (** expand the entry widget or not *) + } ;; + +type font_param = { + font_label : string ; (** the label of the parameter *) + mutable font_value : string ; (** the font name *) + font_editable : bool ; (** indicates if the value can be changed *) + font_f_apply : (string -> unit) ; + (** the function to call to apply the new value of the parameter *) + font_help : string option ; (** optional help string *) + font_expand : bool ; (** expand the entry widget or not *) + } ;; + + +type hotkey_param = { + hk_label : string ; (** the label of the parameter *) + mutable hk_value : (Gdk.Tags.modifier list * int) ; + (** The value, as a list of modifiers and a key code *) + hk_editable : bool ; (** indicates if the value can be changed *) + hk_f_apply : ((Gdk.Tags.modifier list * int) -> unit) ; + (** the function to call to apply the new value of the paramter *) + hk_help : string option ; (** optional help string *) + hk_expand : bool ; (** expand or not *) + } + +type modifiers_param = { + md_label : string ; (** the label of the parameter *) + mutable md_value : Gdk.Tags.modifier list ; + (** The value, as a list of modifiers and a key code *) + md_editable : bool ; (** indicates if the value can be changed *) + md_f_apply : Gdk.Tags.modifier list -> unit ; + (** the function to call to apply the new value of the paramter *) + md_help : string option ; (** optional help string *) + md_expand : bool ; (** expand or not *) + md_allow : Gdk.Tags.modifier list + } + +(** This type represents the different kinds of parameters. *) +type parameter_kind = + String_param of string_param + | List_param of (unit -> ) + | Filename_param of string_param + | Bool_param of bool_param + | Text_param of string_param + | Combo_param of combo_param + | Custom_param of custom_param + | Color_param of color_param + | Date_param of date_param + | Font_param of font_param + | Hotkey_param of hotkey_param + | Modifiers_param of modifiers_param + | Html_param of string_param +;; + +(** This type represents the structure of the configuration window. *) +type configuration_structure = + | Section of string * parameter_kind list (** label of the section, parameters *) + | Section_list of string * configuration_structure list (** label of the section, list of the sub sections *) +;; + +(** To indicate what button was pushed by the user when the window is closed. *) +type return_button = + Return_apply (** The user clicked on Apply at least once before + closing the window with Cancel or the window manager. *) + | Return_ok (** The user closed the window with the ok button. *) + | Return_cancel (** The user closed the window with the cancel + button or the window manager but never clicked + on the apply button.*) + +(** {2 Bindings in the html editor} *) + +type html_binding = { + mutable html_key : (Gdk.Tags.modifier list * int) ; + mutable html_begin : string ; + mutable html_end : string ; + } + +module Html_binding = struct + let value_to_hb v = + match v with + List [StringValue hk ; StringValue debut; StringValue fin ] + | SmallList [StringValue hk ; StringValue debut; StringValue fin ] -> + { html_key = KeyOption.string_to_key hk ; + html_begin = debut ; + html_end = fin ; + } + | _ -> + prerr_endline "Html_binding.value_to_hb"; + raise Not_found + + let hb_to_value hb = + SmallList [ StringValue (KeyOption.key_to_string hb.html_key) ; + StringValue hb.html_begin ; + StringValue hb.html_end ; + ] + + let (t : html_binding option_class) = + define_option_class "html_binding" value_to_hb hb_to_value +end diff --git a/ide/utils/editable_cells.ml b/ide/utils/editable_cells.ml new file mode 100644 index 00000000..e6d2f4d4 --- /dev/null +++ b/ide/utils/editable_cells.ml @@ -0,0 +1,114 @@ +open GTree +open Gobject + +let create l = + let hbox = GPack.hbox () in + let scw = GBin.scrolled_window + ~hpolicy:`AUTOMATIC + ~vpolicy:`AUTOMATIC + ~packing:(hbox#pack ~expand:true) () in + + let columns = new GTree.column_list in + let command_col = columns#add Data.string in + let coq_col = columns#add Data.string in + let store = GTree.list_store columns + in + +(* populate the store *) + let _ = List.iter (fun (x,y) -> + let row = store#append () in + store#set ~row ~column:command_col x; + store#set ~row ~column:coq_col y) + l + in + let view = GTree.view ~model:store ~packing:scw#add_with_viewport () in + + (* Alternate colors for the rows *) + view#set_rules_hint true; + + let renderer_comm = GTree.cell_renderer_text [`EDITABLE true] in + ignore (renderer_comm#connect#edited + ~callback:(fun (path:Gtk.tree_path) (s:string) -> + store#set + ~row:(store#get_iter path) + ~column:command_col s)); + let first = + GTree.view_column ~title:"Coq Command to try" + ~renderer:(renderer_comm,["text",command_col]) + () + in ignore (view#append_column first); + + let renderer_coq = GTree.cell_renderer_text [`EDITABLE true] in + ignore(renderer_coq#connect#edited + ~callback:(fun (path:Gtk.tree_path) (s:string) -> + store#set + ~row:(store#get_iter path) + ~column:coq_col s)); + let second = + GTree.view_column ~title:"Coq Command to insert" + ~renderer:(renderer_coq,["text",coq_col]) + () + in ignore (view#append_column second); + + let vbox = GPack.button_box `VERTICAL ~packing:hbox#pack ~layout:`SPREAD () + in + let up = GButton.button ~stock:`GO_UP ~label:"Up" ~packing:(vbox#pack ~expand:true ~fill:false) () in + let down = GButton.button + ~stock:`GO_DOWN + ~label:"Down" + ~packing:(vbox#pack ~expand:true ~fill:false) () + in + let add = GButton.button ~stock:`ADD + ~label:"Add" + ~packing:(vbox#pack ~expand:true ~fill:false) + () + in + let remove = GButton.button ~stock:`REMOVE + ~label:"Remove" + ~packing:(vbox#pack ~expand:true ~fill:false) () + in + + ignore (add#connect#clicked + ~callback:(fun b -> + let n = store#append () in + view#selection#select_iter n)); + ignore (remove#connect#clicked + ~callback:(fun b -> match view#selection#get_selected_rows with + | [] -> () + | path::_ -> + let iter = store#get_iter path in + ignore (store#remove iter); + )); + ignore (up#connect#clicked + ~callback:(fun b -> + match view#selection#get_selected_rows with + | [] -> () + | path::_ -> + let iter = store#get_iter path in + GtkTree.TreePath.prev path; + let upiter = store#get_iter path in + ignore (store#swap iter upiter); + )); + ignore (down#connect#clicked + ~callback:(fun b -> + match view#selection#get_selected_rows with + | [] -> () + | path::_ -> + let iter = store#get_iter path in + GtkTree.TreePath.next path; + try let upiter = store#get_iter path in + ignore (store#swap iter upiter) + with _ -> () + )); + let get_data () = + let start_path = GtkTree.TreePath.from_string "0" in + let start_iter = store#get_iter start_path in + let rec all acc = + let new_acc = (store#get ~row:start_iter ~column:command_col, + store#get ~row:start_iter ~column:coq_col)::acc + in + if store#iter_next start_iter then all new_acc else List.rev new_acc + in all [] + in + (hbox,get_data) + diff --git a/ide/utils/okey.ml b/ide/utils/okey.ml new file mode 100644 index 00000000..17e371f5 --- /dev/null +++ b/ide/utils/okey.ml @@ -0,0 +1,185 @@ +(**************************************************************************) +(* Cameleon *) +(* *) +(* Copyright (C) 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. *) +(* *) +(* This program is free software; you can redistribute it and/or modify *) +(* it under the terms of the GNU General Public License as published by *) +(* the Free Software Foundation; either version 2 of the License, or *) +(* any later version. *) +(* *) +(* This program is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) +(* GNU General Public License for more details. *) +(* *) +(* You should have received a copy of the GNU General Public License *) +(* along with this program; if not, write to the Free Software *) +(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *) +(* 02111-1307 USA *) +(* *) +(* Contact: Maxence.Guesdon@inria.fr *) +(**************************************************************************) + +type modifier = Gdk.Tags.modifier + +type handler = { + cond : (unit -> bool) ; + cback : (unit -> unit) ; + } + +type handler_spec = int * int * Gdk.keysym + (** mods * mask * key *) + +let int_of_modifier = function + `SHIFT -> 1 + | `LOCK -> 2 + | `CONTROL -> 4 + | `MOD1 -> 8 + | `MOD2 -> 16 + | `MOD3 -> 32 + | `MOD4 -> 64 + | `MOD5 -> 128 + | `BUTTON1 -> 256 + | `BUTTON2 -> 512 + | `BUTTON3 -> 1024 + | `BUTTON4 -> 2048 + | `BUTTON5 -> 4096 + +let print_modifier l = + List.iter + (fun m -> + print_string + (((function + `SHIFT -> "SHIFT" + | `LOCK -> "LOCK" + | `CONTROL -> "CONTROL" + | `MOD1 -> "MOD1" + | `MOD2 -> "MOD2" + | `MOD3 -> "MOD3" + | `MOD4 -> "MOD4" + | `MOD5 -> "MOD5" + | `BUTTON1 -> "B1" + | `BUTTON2 -> "B2" + | `BUTTON3 -> "B3" + | `BUTTON4 -> "B4" + | `BUTTON5 -> "B5") + m)^" ") + ) + l; + print_newline () + +let int_of_modifiers l = + List.fold_left (fun acc -> fun m -> acc + (int_of_modifier m)) 0 l + +module H = + struct + type t = handler_spec * handler + let equal (m,k) (mods, mask, key) = + (k = key) && ((m land mask) = mods) + + let filter_with_mask mods mask key l = + List.filter (fun a -> (fst a) <> (mods, mask, key)) l + + let find_handlers mods key l = + List.map snd + (List.filter + (fun ((m,ma,k),_) -> equal (mods,key) (m,ma,k)) + l + ) + + end + +let (table : (int, H.t list ref) Hashtbl.t) = Hashtbl.create 13 + +let key_press w ev = + let key = GdkEvent.Key.keyval ev in + let modifiers = GdkEvent.Key.state ev in + try + let (r : H.t list ref) = Hashtbl.find table w#get_oid in + let l = H.find_handlers (int_of_modifiers modifiers) key !r in + let b = ref true in + List.iter + (fun h -> + if h.cond () then + (h.cback () ; b := false) + else + () + ) + l; + !b + with + Not_found -> + true + +let associate_key_press w = + ignore ((w#event#connect#key_press ~callback: (key_press w)) : GtkSignal.id) + +let default_modifiers = ref ([] : modifier list) +let default_mask = ref ([`MOD2 ; `MOD3 ; `MOD4 ; `MOD5 ; `LOCK] : modifier list) + +let set_default_modifiers l = default_modifiers := l +let set_default_mask l = default_mask := l + +let remove_widget (w : < event : GObj.event_ops ; get_oid : int ; ..>) () = + try + let r = Hashtbl.find table w#get_oid in + r := [] + with + Not_found -> + () + +let add1 ?(remove=false) w + ?(cond=(fun () -> true)) + ?(mods= !default_modifiers) + ?(mask= !default_mask) + k callback = + let r = + try Hashtbl.find table w#get_oid + with Not_found -> + let r = ref [] in + Hashtbl.add table w#get_oid r; + ignore (w#connect#destroy ~callback: (remove_widget w)); + associate_key_press w; + r + in + let n_mods = int_of_modifiers mods in + let n_mask = lnot (int_of_modifiers mask) in + let new_h = { cond = cond ; cback = callback } in + if remove then + ( + let l = H.filter_with_mask n_mods n_mask k !r in + r := ((n_mods, n_mask, k), new_h) :: l + ) + else + r := ((n_mods, n_mask, k), new_h) :: !r + +let add w + ?(cond=(fun () -> true)) + ?(mods= !default_modifiers) + ?(mask= !default_mask) + k callback = + add1 w ~cond ~mods ~mask k callback + +let add_list w + ?(cond=(fun () -> true)) + ?(mods= !default_modifiers) + ?(mask= !default_mask) + k_list callback = + List.iter (fun k -> add w ~cond ~mods ~mask k callback) k_list + +let set w + ?(cond=(fun () -> true)) + ?(mods= !default_modifiers) + ?(mask= !default_mask) + k callback = + add1 ~remove: true w ~cond ~mods ~mask k callback + +let set_list w + ?(cond=(fun () -> true)) + ?(mods= !default_modifiers) + ?(mask= !default_mask) + k_list callback = + List.iter (fun k -> set w ~cond ~mods ~mask k callback) k_list + diff --git a/ide/utils/okey.mli b/ide/utils/okey.mli new file mode 100644 index 00000000..a0effe72 --- /dev/null +++ b/ide/utils/okey.mli @@ -0,0 +1,114 @@ +(**************************************************************************) +(* Cameleon *) +(* *) +(* Copyright (C) 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. *) +(* *) +(* This program is free software; you can redistribute it and/or modify *) +(* it under the terms of the GNU General Public License as published by *) +(* the Free Software Foundation; either version 2 of the License, or *) +(* any later version. *) +(* *) +(* This program is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) +(* GNU General Public License for more details. *) +(* *) +(* You should have received a copy of the GNU General Public License *) +(* along with this program; if not, write to the Free Software *) +(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *) +(* 02111-1307 USA *) +(* *) +(* Contact: Maxence.Guesdon@inria.fr *) +(**************************************************************************) + +(** Okey interface. + + Once the lib is compiled and installed, you can use it by referencing + it with the [Okey] module. You must add [okey.cmo] or [okey.cmx] + on the commande line when you link. +*) + +type modifier = Gdk.Tags.modifier + +(** Set the default modifier list. The first default value is [[]].*) +val set_default_modifiers : modifier list -> unit + +(** Set the default modifier mask. The first default value is + [[`MOD2 ; `MOD3 ; `MOD4 ; `MOD5 ; `LOCK]]. + The mask defines the modifiers not taken into account + when looking for the handler of a key press event. +*) +val set_default_mask : modifier list -> unit + +(** [add widget key callback] associates the [callback] function to the event + "key_press" with the given [key] for the given [widget]. + + @param remove when true, the previous handlers for the given key and modifier + list are not kept. + @param cond this function is a guard: the [callback] function is not called + if the [cond] function returns [false]. + The default [cond] function always returns [true]. + + @param mods the list of modifiers. If not given, the default modifiers + are used. + You can set the default modifiers with function {!Okey.set_default_modifiers}. + + @param mask the list of modifiers which must not be taken + into account to trigger the given handler. [mods] + and [mask] must not have common modifiers. If not given, the default mask + is used. + You can set the default modifiers mask with function {!Okey.set_default_mask}. +*) +val add : + < connect : < destroy : callback: (unit -> unit) -> GtkSignal.id; .. >; + event : GObj.event_ops; get_oid : int; .. > -> + ?cond: (unit -> bool) -> + ?mods: modifier list -> + ?mask: modifier list -> + Gdk.keysym -> + (unit -> unit) -> + unit + +(** It calls {!Okey.add} for each given key.*) +val add_list : + < connect : < destroy : callback: (unit -> unit) -> GtkSignal.id; .. >; + event : GObj.event_ops; get_oid : int; .. > -> + ?cond: (unit -> bool) -> + ?mods: modifier list -> + ?mask: modifier list -> + Gdk.keysym list -> + (unit -> unit) -> + unit + +(** Like {!Okey.add} but the previous handlers for the + given modifiers and key are not kept.*) +val set : + < connect : < destroy : callback: (unit -> unit) -> GtkSignal.id; .. >; + event : GObj.event_ops; get_oid : int; .. > -> + ?cond: (unit -> bool) -> + ?mods: modifier list -> + ?mask: modifier list -> + Gdk.keysym -> + (unit -> unit) -> + unit + +(** It calls {!Okey.set} for each given key.*) +val set_list : + < connect : < destroy : callback: (unit -> unit) -> GtkSignal.id; .. >; + event : GObj.event_ops; get_oid : int; .. > -> + ?cond: (unit -> bool) -> + ?mods: modifier list -> + ?mask: modifier list -> + Gdk.keysym list -> + (unit -> unit) -> + unit + +(** Remove the handlers associated to the given widget. + This is automatically done when a widget is destroyed but + you can do it yourself. *) +val remove_widget : + < connect : < destroy : callback: (unit -> unit) -> GtkSignal.id; .. >; + event : GObj.event_ops; get_oid : int; .. > -> + unit -> + unit diff --git a/ide/utils/uoptions.ml b/ide/utils/uoptions.ml new file mode 100644 index 00000000..416f5769 --- /dev/null +++ b/ide/utils/uoptions.ml @@ -0,0 +1,772 @@ +(**************************************************************************) +(* Cameleon *) +(* *) +(* Copyright (C) 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. *) +(* *) +(* This program is free software; you can redistribute it and/or modify *) +(* it under the terms of the GNU General Public License as published by *) +(* the Free Software Foundation; either version 2 of the License, or *) +(* any later version. *) +(* *) +(* This program is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) +(* GNU General Public License for more details. *) +(* *) +(* You should have received a copy of the GNU General Public License *) +(* along with this program; if not, write to the Free Software *) +(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *) +(* 02111-1307 USA *) +(* *) +(* Contact: Maxence.Guesdon@inria.fr *) +(**************************************************************************) + +(** Simple options: + This will enable very simple configuration, by a mouse-based configurator. + Options will be defined by a special function, which will also check + if a value has been provided by the user in its .gwmlrc file. + The .gwmlrc will be created by a dedicated tool, which could be used + to generate both .gwmlrc and .efunsrc files. + +Note: this is redundant, since such options could also be better set +in the .Xdefaults file (using Xrm to load them). Maybe we should merge +both approaches in a latter release. + + Code from Fabrice Le Fessant. + + *) + +type option_value = + Module of option_module + | StringValue of string + | IntValue of int + | FloatValue of float + | List of option_value list + | SmallList of option_value list +and option_module = (string * option_value) list +;; + + + +type 'a option_class = + { class_name : string; + from_value : option_value -> 'a; + to_value : 'a -> option_value; + mutable class_hooks : ('a option_record -> unit) list } + +and 'a option_record = + { option_name : string list; + option_class : 'a option_class; + mutable option_value : 'a; + option_help : string; + mutable option_hooks : (unit -> unit) list; + mutable string_wrappers : (('a -> string) * (string -> 'a)) option; + option_file : options_file; + } + +and options_file = { + mutable file_name : string; + mutable file_options : Obj.t option_record list; + mutable file_rc : option_module; + mutable file_pruned : bool; + } +;; + +let create_options_file name = + ignore + ( + if not (Sys.file_exists name) then + let oc = open_out name in + close_out oc + ); + { + file_name = name; + file_options =[]; + file_rc = []; + file_pruned = false; + } + +let set_options_file opfile name = opfile.file_name <- name + +let + define_option_class + (class_name : string) + (from_value : option_value -> 'a) + (to_value : 'a -> option_value) = + let c = + {class_name = class_name; + from_value = from_value; + to_value = to_value; + class_hooks = []} + in + c +;; + +(* +let filename = + ref + (Filename.concat Sysenv.home + ("." ^ Filename.basename Sys.argv.(0) ^ "rc")) +;; +let gwmlrc = ref [];; + +let options = ref [];; +*) + +let rec find_value list m = + match list with + [] -> raise Not_found + | name :: tail -> + let m = List.assoc name m in + match m, tail with + _, [] -> m + | Module m, _ :: _ -> find_value tail m + | _ -> raise Not_found +;; + +let prune_file file = + file.file_pruned <- true + +let + define_option + (opfile : options_file) + (option_name : string list) + (option_help : string) + (option_class : 'a option_class) + (default_value : 'a) = + let o = + {option_name = option_name; + option_help = option_help; + option_class = option_class; + option_value = default_value; + string_wrappers = None; + option_hooks = []; + option_file = opfile; } + in + opfile.file_options <- (Obj.magic o : Obj.t option_record) :: + opfile.file_options; + o.option_value <- + begin try o.option_class.from_value (find_value option_name + opfile.file_rc) with + Not_found -> default_value + | e -> + Printf.printf "Options.define_option, for option %s: " + (match option_name with + [] -> "???" + | name :: _ -> name); + Printf.printf "%s" (Printexc.to_string e); + print_newline (); + default_value + end; + o +;; + + +open Genlex;; + +let lexer = make_lexer ["="; "{"; "}"; "["; "]"; ";"; "("; ")"; ","; "."];; + +let rec parse_gwmlrc (strm__ : _ Stream.t) = + match + try Some (parse_id strm__) with + Stream.Failure -> None + with + Some id -> + begin match Stream.peek strm__ with + Some (Kwd "=") -> + Stream.junk strm__; + let v = + try parse_option strm__ with + Stream.Failure -> raise (Stream.Error "") + in + let eof = + try parse_gwmlrc strm__ with + Stream.Failure -> raise (Stream.Error "") + in + (id, v) :: eof + | _ -> raise (Stream.Error "") + end + | _ -> [] +and parse_option (strm__ : _ Stream.t) = + match Stream.peek strm__ with + Some (Kwd "{") -> + Stream.junk strm__; + let v = + try parse_gwmlrc strm__ with + Stream.Failure -> raise (Stream.Error "") + in + begin match Stream.peek strm__ with + Some (Kwd "}") -> Stream.junk strm__; Module v + | _ -> raise (Stream.Error "") + end + | Some (Ident s) -> Stream.junk strm__; StringValue s + | Some (String s) -> Stream.junk strm__; StringValue s + | Some (Int i) -> Stream.junk strm__; IntValue i + | Some (Float f) -> Stream.junk strm__; FloatValue f + | Some (Char c) -> + Stream.junk strm__; + StringValue (let s = String.create 1 in s.[0] <- c; s) + | Some (Kwd "[") -> + Stream.junk strm__; + let v = + try parse_list strm__ with + Stream.Failure -> raise (Stream.Error "") + in + List v + | Some (Kwd "(") -> + Stream.junk strm__; + let v = + try parse_list strm__ with + Stream.Failure -> raise (Stream.Error "") + in + List v + | _ -> raise Stream.Failure +and parse_id (strm__ : _ Stream.t) = + match Stream.peek strm__ with + Some (Ident s) -> Stream.junk strm__; s + | Some (String s) -> Stream.junk strm__; s + | _ -> raise Stream.Failure +and parse_list (strm__ : _ Stream.t) = + match Stream.peek strm__ with + Some (Kwd ";") -> + Stream.junk strm__; + begin try parse_list strm__ with + Stream.Failure -> raise (Stream.Error "") + end + | Some (Kwd ",") -> + Stream.junk strm__; + begin try parse_list strm__ with + Stream.Failure -> raise (Stream.Error "") + end + | Some (Kwd ".") -> + Stream.junk strm__; + begin try parse_list strm__ with + Stream.Failure -> raise (Stream.Error "") + end + | _ -> + match + try Some (parse_option strm__) with + Stream.Failure -> None + with + Some v -> + let t = + try parse_list strm__ with + Stream.Failure -> raise (Stream.Error "") + in + v :: t + | _ -> + match Stream.peek strm__ with + Some (Kwd "]") -> Stream.junk strm__; [] + | Some (Kwd ")") -> Stream.junk strm__; [] + | _ -> raise Stream.Failure +;; + +let exec_hooks o = + List.iter + (fun f -> + try f () with + _ -> ()) + o.option_hooks +;; + +let exec_chooks o = + List.iter + (fun f -> + try f o with + _ -> ()) + o.option_class.class_hooks +;; + +let really_load filename options = + let temp_file = filename ^ ".tmp" in + if Sys.file_exists temp_file then begin + Printf.printf + "File %s exists\n" temp_file; + Printf.printf + "An error may have occurred during previous configuration save.\n"; + Printf.printf + "Please, check your configurations files, and rename/remove this file\n"; + Printf.printf "before restarting"; + print_newline (); + exit 1 + end + else + let ic = open_in filename in + let s = Stream.of_channel ic in + try + let stream = lexer s in + let list = + try parse_gwmlrc stream with + e -> + Printf.printf "At pos %d/%d" (Stream.count s) (Stream.count stream); + print_newline (); + raise e + in + List.iter + (fun o -> + try + o.option_value <- + o.option_class.from_value (find_value o.option_name list); + exec_chooks o; + exec_hooks o + with + e -> + () + ) + options; + list + with + e -> + Printf.printf "Error %s in %s" (Printexc.to_string e) filename; + print_newline (); + [] +;; + +let load opfile = + try opfile.file_rc <- really_load opfile.file_name opfile.file_options with + Not_found -> + Printf.printf "No %s found" opfile.file_name; print_newline () +;; + +let append opfile filename = + try opfile.file_rc <- + really_load filename opfile.file_options @ opfile.file_rc with + Not_found -> + Printf.printf "No %s found" filename; print_newline () +;; + +let ( !! ) o = o.option_value;; +let ( =:= ) o v = o.option_value <- v; exec_chooks o; exec_hooks o;; + +let value_to_string v = + match v with + StringValue s -> s + | IntValue i -> string_of_int i + | FloatValue f -> string_of_float f + | _ -> failwith "Options: not a string option" +;; + +let string_to_value s = StringValue s;; + +let value_to_int v = + match v with + StringValue s -> int_of_string s + | IntValue i -> i + | _ -> failwith "Options: not an int option" +;; + +let int_to_value i = IntValue i;; + +(* The Pervasives version is too restrictive *) +let bool_of_string s = + match String.lowercase s with + "true" -> true + | "false" -> false + | "yes" -> true + | "no" -> false + | "y" -> true + | "n" -> false + | _ -> invalid_arg "bool_of_string" +;; + +let value_to_bool v = + match v with + StringValue s -> bool_of_string s + | IntValue v when v = 0 -> false + | IntValue v when v = 1 -> true + | _ -> failwith "Options: not a bool option" +;; +let bool_to_value i = StringValue (string_of_bool i);; + +let value_to_float v = + match v with + StringValue s -> float_of_string s + | FloatValue f -> f + | _ -> failwith "Options: not a float option" +;; + +let float_to_value i = FloatValue i;; + +let value_to_string2 v = + match v with + List [s1; s2] | SmallList [s1;s2] -> + value_to_string s1, value_to_string s2 + | _ -> failwith "Options: not a string2 option" +;; + +let string2_to_value (s1, s2) = SmallList [StringValue s1; StringValue s2];; + +let value_to_list v2c v = + match v with + List l | SmallList l -> List.rev (List.rev_map v2c l) + | StringValue s -> failwith (Printf.sprintf + "Options: not a list option (StringValue [%s])" s) + | FloatValue _ -> failwith "Options: not a list option (FloatValue)" + | IntValue _ -> failwith "Options: not a list option (IntValue)" + | Module _ -> failwith "Options: not a list option (Module)" +;; + +let list_to_value c2v l = + List + (List.fold_right + (fun v list -> + try c2v v :: list with + _ -> list) + l []) +;; + +let smalllist_to_value c2v l = + SmallList + (List.fold_right + (fun v list -> + try c2v v :: list with + _ -> list) + l []) +;; + +let string_option = + define_option_class "String" value_to_string string_to_value +;; +let color_option = + define_option_class "Color" value_to_string string_to_value +;; +let font_option = define_option_class "Font" value_to_string string_to_value;; + +let int_option = define_option_class "Int" value_to_int int_to_value;; + +let bool_option = define_option_class "Bool" value_to_bool bool_to_value;; +let float_option = define_option_class "Float" value_to_float float_to_value;; + +let string2_option = + define_option_class "String2" value_to_string2 string2_to_value +;; + +let list_option cl = + define_option_class (cl.class_name ^ " List") (value_to_list cl.from_value) + (list_to_value cl.to_value) +;; + +let smalllist_option cl = + define_option_class (cl.class_name ^ " List") (value_to_list cl.from_value) + (smalllist_to_value cl.to_value) +;; + +let to_value cl = cl.to_value;; +let from_value cl = cl.from_value;; + +let value_to_sum l v = + match v with + StringValue s -> List.assoc s l + | _ -> failwith "Options: not a sum option" +;; + +let sum_to_value l v = StringValue (List.assq v l);; + +let sum_option l = + let ll = List.map (fun (a1, a2) -> a2, a1) l in + define_option_class "Sum" (value_to_sum l) (sum_to_value ll) +;; + +let exit_exn = Exit;; +let safe_string s = + if s = "" then "\"\"" + else + try + match s.[0] with + 'a'..'z' | 'A'..'Z' -> + for i = 1 to String.length s - 1 do + match s.[i] with + 'a'..'z' | 'A'..'Z' | '_' | '0'..'9' -> () + | _ -> raise exit_exn + done; + s + | _ -> + if string_of_int (int_of_string s) = s || + string_of_float (float_of_string s) = s then + s + else raise exit_exn + with + _ -> Printf.sprintf "\"%s\"" (String.escaped s) +;; + +let with_help = ref false;; + +let rec save_module indent oc list = + let subm = ref [] in + List.iter + (fun (name, help, value) -> + match name with + [] -> assert false + | [name] -> + if !with_help && help <> "" then + Printf.fprintf oc "(* %s *)\n" help; + Printf.fprintf oc "%s %s = " indent (safe_string name); + save_value indent oc value; + Printf.fprintf oc "\n" + | m :: tail -> + let p = + try List.assoc m !subm with + _ -> let p = ref [] in subm := (m, p) :: !subm; p + in + p := (tail, help, value) :: !p) + list; + List.iter + (fun (m, p) -> + Printf.fprintf oc "%s %s = {\n" indent (safe_string m); + save_module (indent ^ " ") oc !p; + Printf.fprintf oc "%s}\n" indent) + !subm +and save_list indent oc list = + match list with + [] -> () + | [v] -> save_value indent oc v + | v :: tail -> + save_value indent oc v; Printf.fprintf oc ", "; save_list indent oc tail +and save_list_nl indent oc list = + match list with + [] -> () + | [v] -> Printf.fprintf oc "\n%s" indent; save_value indent oc v + | v :: tail -> + Printf.fprintf oc "\n%s" indent; + save_value indent oc v; + Printf.fprintf oc ";"; + save_list_nl indent oc tail +and save_value indent oc v = + match v with + StringValue s -> Printf.fprintf oc "%s" (safe_string s) + | IntValue i -> Printf.fprintf oc "%d" i + | FloatValue f -> Printf.fprintf oc "%f" f + | List l -> + Printf.fprintf oc "["; + save_list_nl (indent ^ " ") oc l; + Printf.fprintf oc "]" + | SmallList l -> + Printf.fprintf oc "("; + save_list (indent ^ " ") oc l; + Printf.fprintf oc ")" + | Module m -> + Printf.fprintf oc "{"; + save_module_fields (indent ^ " ") oc m; + Printf.fprintf oc "}" + +and save_module_fields indent oc m = + match m with + [] -> () + | (name, v) :: tail -> + Printf.fprintf oc "%s %s = " indent (safe_string name); + save_value indent oc v; + Printf.fprintf oc "\n"; + save_module_fields indent oc tail +;; + +let save opfile = + let filename = opfile.file_name in + let temp_file = filename ^ ".tmp" in + let old_file = filename ^ ".old" in + let oc = open_out temp_file in + save_module "" oc + (List.map + (fun o -> + o.option_name, o.option_help, + (try + o.option_class.to_value o.option_value + with + e -> + Printf.printf "Error while saving option \"%s\": %s" + (try List.hd o.option_name with + _ -> "???") + (Printexc.to_string e); + print_newline (); + StringValue "")) + (List.rev opfile.file_options)); + if not opfile.file_pruned then begin + Printf.fprintf oc + "\n(*\n The following options are not used (errors, obsolete, ...) \n*)\n"; + List.iter + (fun (name, value) -> + try + List.iter + (fun o -> + match o.option_name with + n :: _ -> if n = name then raise Exit + | _ -> ()) + opfile.file_options; + Printf.fprintf oc "%s = " (safe_string name); + save_value " " oc value; + Printf.fprintf oc "\n" + with + _ -> ()) + opfile.file_rc; + end; + close_out oc; + (try Sys.rename filename old_file with _ -> ()); + (try Sys.rename temp_file filename with _ -> ()) +;; + +let save_with_help opfile = + with_help := true; + begin try save opfile with + _ -> () + end; + with_help := false +;; + +let option_hook option f = option.option_hooks <- f :: option.option_hooks;; + +let class_hook option_class f = + option_class.class_hooks <- f :: option_class.class_hooks +;; + +let rec iter_order f list = + match list with + [] -> () + | v :: tail -> f v; iter_order f tail +;; + +let help oc opfile = + List.iter + (fun o -> + Printf.fprintf oc "OPTION \""; + begin match o.option_name with + [] -> Printf.fprintf oc "???" + | [name] -> Printf.fprintf oc "%s" name + | name :: tail -> + Printf.fprintf oc "%s" name; + iter_order (fun name -> Printf.fprintf oc ":%s" name) o.option_name + end; + Printf.fprintf oc "\" (TYPE \"%s\"): %s\n CURRENT: \n" + o.option_class.class_name o.option_help; + begin try + save_value "" oc (o.option_class.to_value o.option_value) + with + _ -> () + end; + Printf.fprintf oc "\n") + opfile.file_options; + flush oc +;; + + +let tuple2_to_value (c1, c2) (a1, a2) = + SmallList [to_value c1 a1; to_value c2 a2] +;; + +let value_to_tuple2 (c1, c2) v = + match v with + List [v1; v2] -> from_value c1 v1, from_value c2 v2 + | SmallList [v1; v2] -> from_value c1 v1, from_value c2 v2 + | List l | SmallList l -> + Printf.printf "list of %d" (List.length l); + print_newline (); + failwith "Options: not a tuple2 list option" + | _ -> failwith "Options: not a tuple2 option" +;; + +let tuple2_option p = + define_option_class "tuple2_option" (value_to_tuple2 p) (tuple2_to_value p) +;; + +let tuple3_to_value (c1, c2, c3) (a1, a2, a3) = + SmallList [to_value c1 a1; to_value c2 a2; to_value c3 a3] +;; +let value_to_tuple3 (c1, c2, c3) v = + match v with + List [v1; v2; v3] -> from_value c1 v1, from_value c2 v2, from_value c3 v3 + | SmallList [v1; v2; v3] -> + from_value c1 v1, from_value c2 v2, from_value c3 v3 + | _ -> failwith "Options: not a tuple3 option" +;; + +let tuple3_option p = + define_option_class "tuple3_option" (value_to_tuple3 p) (tuple3_to_value p) +;; + +let tuple4_to_value (c1, c2, c3, c4) (a1, a2, a3, a4) = + SmallList [to_value c1 a1; to_value c2 a2; to_value c3 a3; to_value c4 a4] +;; +let value_to_tuple4 (c1, c2, c3, c4) v = + match v with + List [v1; v2; v3; v4] -> + (from_value c1 v1, from_value c2 v2, from_value c3 v3, from_value c4 v4) + | SmallList [v1; v2; v3; v4] -> + (from_value c1 v1, from_value c2 v2, from_value c3 v3, from_value c4 v4) + | _ -> failwith "Options: not a tuple4 option" +;; + +let tuple4_option p = + define_option_class "tuple4_option" (value_to_tuple4 p) (tuple4_to_value p) +;; + + +let shortname o = String.concat ":" o.option_name;; +let get_class o = o.option_class;; +let get_help o = + let help = o.option_help in if help = "" then "No Help Available" else help +;; + + +let simple_options opfile = + let list = ref [] in + List.iter (fun o -> + match o.option_name with + [] | _ :: _ :: _ -> () + | [name] -> + match o.option_class.to_value o.option_value with + Module _ | SmallList _ | List _ -> + begin + match o.string_wrappers with + None -> () + | Some (to_string, from_string) -> + list := (name, to_string o.option_value) :: !list + end + | v -> + list := (name, value_to_string v) :: !list + ) opfile.file_options; + !list + +let get_option opfile name = + let rec iter name list = + match list with + [] -> raise Not_found + | o :: list -> + if o.option_name = name then o + else iter name list + in + iter [name] opfile.file_options + + +let set_simple_option opfile name v = + let o = get_option opfile name in + begin + match o.string_wrappers with + None -> + o.option_value <- o.option_class.from_value (string_to_value v); + | Some (_, from_string) -> + o.option_value <- from_string v + end; + exec_chooks o; exec_hooks o;; + +let get_simple_option opfile name = + let o = get_option opfile name in + match o.string_wrappers with + None -> + value_to_string (o.option_class.to_value o.option_value) + | Some (to_string, _) -> + to_string o.option_value + +let set_option_hook opfile name hook = + let o = get_option opfile name in + o.option_hooks <- hook :: o.option_hooks + +let set_string_wrappers o to_string from_string = + o.string_wrappers <- Some (to_string, from_string) + +let simple_args opfile = + List.map (fun (name, v) -> + ("-" ^ name), + Arg.String (set_simple_option opfile name), + (Printf.sprintf " : \t%s (current: %s)" + (get_option opfile name).option_help + v) + ) (simple_options opfile) diff --git a/ide/utils/uoptions.mli b/ide/utils/uoptions.mli new file mode 100644 index 00000000..a323ac60 --- /dev/null +++ b/ide/utils/uoptions.mli @@ -0,0 +1,148 @@ +(**************************************************************************) +(* Cameleon *) +(* *) +(* Copyright (C) 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. *) +(* *) +(* This program is free software; you can redistribute it and/or modify *) +(* it under the terms of the GNU General Public License as published by *) +(* the Free Software Foundation; either version 2 of the License, or *) +(* any later version. *) +(* *) +(* This program is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) +(* GNU General Public License for more details. *) +(* *) +(* You should have received a copy of the GNU General Public License *) +(* along with this program; if not, write to the Free Software *) +(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *) +(* 02111-1307 USA *) +(* *) +(* Contact: Maxence.Guesdon@inria.fr *) +(**************************************************************************) + +(** + This module implements a simple mechanism to handle program options files. + An options file is defined as a set of [variable = value] lines, + where value can be a simple string, a list of values (between brackets +or parentheses) or a set of [variable = value] lines between braces. +The option file is automatically loaded and saved, and options are +manipulated inside the program as easily as references. + + Code from Fabrice Le Fessant. +*) + +type 'a option_class +(** The abstract type for a class of options. A class is a set of options +which use the same conversion functions from loading and saving.*) + +type 'a option_record +(** The abstract type for an option *) + +type options_file + +val create_options_file : string -> options_file +val set_options_file : options_file -> string -> unit +val prune_file : options_file -> unit + +(** {2 Operations on option files} *) + +val load : options_file -> unit +(** [load file] loads the option file. All options whose value is specified + in the option file are updated. *) + +val append : options_file -> string -> unit +(** [append filename] loads the specified option file. All options whose +value is specified in this file are updated. *) + +val save : options_file -> unit +(** [save file] saves all the options values to the option file. *) + +val save_with_help : options_file -> unit +(** [save_with_help ()] saves all the options values to the option file, + with the help provided for each option. *) + +(** {2 Creating options} *) + +val define_option : options_file -> + string list -> string -> 'a option_class -> 'a -> 'a option_record +val option_hook : 'a option_record -> (unit -> unit) -> unit + +val string_option : string option_class +val color_option : string option_class +val font_option : string option_class +val int_option : int option_class +val bool_option : bool option_class +val float_option : float option_class +val string2_option : (string * string) option_class + + (* parameterized options *) +val list_option : 'a option_class -> 'a list option_class +val smalllist_option : 'a option_class -> 'a list option_class +val sum_option : (string * 'a) list -> 'a option_class +val tuple2_option : + 'a option_class * 'b option_class -> ('a * 'b) option_class +val tuple3_option : 'a option_class * 'b option_class * 'c option_class -> + ('a * 'b * 'c) option_class +val tuple4_option : + 'a option_class * 'b option_class * 'c option_class * 'd option_class -> + ('a * 'b * 'c * 'd) option_class + +(** {2 Using options} *) + +val ( !! ) : 'a option_record -> 'a +val ( =:= ) : 'a option_record -> 'a -> unit + +val shortname : 'a option_record -> string +val get_help : 'a option_record -> string + +(** {2 Creating new option classes} *) + +val get_class : 'a option_record -> 'a option_class + +val class_hook : 'a option_class -> ('a option_record -> unit) -> unit + +type option_value = + Module of option_module +| StringValue of string +| IntValue of int +| FloatValue of float +| List of option_value list +| SmallList of option_value list + +and option_module = + (string * option_value) list + +val define_option_class : + string -> (option_value -> 'a) -> ('a -> option_value) -> 'a option_class + +val to_value : 'a option_class -> 'a -> option_value +val from_value : 'a option_class -> option_value -> 'a + +val value_to_string : option_value -> string +val string_to_value : string -> option_value +val value_to_int : option_value -> int +val int_to_value : int -> option_value +val bool_of_string : string -> bool +val value_to_bool : option_value -> bool +val bool_to_value : bool -> option_value +val value_to_float : option_value -> float +val float_to_value : float -> option_value +val value_to_string2 : option_value -> string * string +val string2_to_value : string * string -> option_value +val value_to_list : (option_value -> 'a) -> option_value -> 'a list +val list_to_value : ('a -> option_value) -> 'a list -> option_value +val smalllist_to_value : ('a -> option_value) -> 'a list -> option_value + +val set_simple_option : options_file -> string -> string -> unit +val simple_options : options_file -> (string * string) list +val get_simple_option : options_file -> string -> string +val set_option_hook : options_file -> string -> (unit -> unit) -> unit + +val set_string_wrappers : 'a option_record -> + ('a -> string) -> (string -> 'a) -> unit + +(** {2 Other functions} *) + +val simple_args : options_file -> (string * Arg.spec * string) list -- cgit v1.2.3 From 6497f27021fec4e01f2182014f2bb1989b4707f9 Mon Sep 17 00:00:00 2001 From: Samuel Mimram Date: Mon, 31 Jan 2005 14:34:14 +0000 Subject: Imported Upstream version 8.0pl2 --- .depend | 6183 ++++++++++++++++++------------------- .depend.coq | 2 +- CHANGES | 17 + Makefile | 33 +- configure | 6 +- contrib/funind/tacinv.ml4 | 61 +- contrib/funind/tacinvutils.ml | 7 +- contrib/interface/xlate.ml | 12 +- dev/top_printers.ml | 6 +- ide/command_windows.mli | 2 +- ide/coq.mli | 2 +- ide/coq_tactics.mli | 2 +- ide/coqide.ml | 4 +- ide/coqide.mli | 2 +- ide/find_phrase.mll | 10 +- ide/highlight.mll | 9 +- ide/ideutils.mli | 2 +- ide/preferences.mli | 2 +- ide/undo.mli | 2 +- interp/constrextern.mli | 2 +- interp/constrintern.ml | 28 +- interp/constrintern.mli | 4 +- interp/coqlib.mli | 4 +- interp/doc.tex | 6 +- interp/genarg.ml | 11 +- interp/genarg.mli | 35 +- interp/ppextend.mli | 2 +- interp/symbols.ml | 4 +- interp/symbols.mli | 14 +- interp/topconstr.ml | 16 +- interp/topconstr.mli | 8 +- kernel/conv_oracle.mli | 2 +- kernel/declarations.mli | 10 +- kernel/environ.mli | 4 +- kernel/esubst.mli | 2 +- kernel/inductive.mli | 4 +- kernel/mod_typing.mli | 2 +- kernel/modops.mli | 4 +- lib/bignat.mli | 4 +- lib/compat.ml4 | 11 +- lib/heap.mli | 2 +- lib/predicate.mli | 2 +- lib/profile.mli | 2 +- lib/rtree.mli | 4 +- lib/util.ml | 5 +- library/declaremods.mli | 6 +- library/lib.ml | 14 +- library/lib.mli | 9 +- library/libnames.mli | 8 +- library/libobject.mli | 4 +- library/library.ml | 14 +- library/nameops.ml | 6 +- library/nameops.mli | 4 +- library/nametab.mli | 9 +- parsing/argextend.ml4 | 19 +- parsing/coqast.mli | 6 +- parsing/doc.tex | 9 + parsing/egrammar.ml | 18 +- parsing/egrammar.mli | 13 +- parsing/esyntax.mli | 12 +- parsing/extend.mli | 7 +- parsing/g_constr.ml4 | 4 +- parsing/g_constrnew.ml4 | 4 +- parsing/g_natsyntax.ml | 4 +- parsing/g_tactic.ml4 | 11 +- parsing/g_tacticnew.ml4 | 14 +- parsing/g_vernac.ml4 | 6 +- parsing/g_vernacnew.ml4 | 5 +- parsing/g_zsyntax.ml | 13 +- parsing/pcoq.ml4 | 10 +- parsing/pcoq.mli | 5 +- parsing/ppconstr.ml | 5 +- parsing/ppconstr.mli | 2 +- parsing/pptactic.ml | 9 +- parsing/pptactic.mli | 2 +- parsing/printer.mli | 6 +- parsing/q_coqast.ml4 | 16 +- pretyping/cases.ml | 172 +- pretyping/evarconv.ml | 9 +- pretyping/evarutil.ml | 38 +- pretyping/inductiveops.ml | 6 +- pretyping/inductiveops.mli | 4 +- pretyping/matching.mli | 4 +- pretyping/pattern.ml | 5 +- pretyping/rawterm.ml | 6 +- pretyping/rawterm.mli | 10 +- pretyping/tacred.ml | 12 +- pretyping/tacred.mli | 4 +- pretyping/termops.mli | 4 +- proofs/clenv.ml | 4 +- proofs/clenv.mli | 6 +- proofs/evar_refiner.ml | 3 +- proofs/evar_refiner.mli | 6 +- proofs/refiner.mli | 3 +- proofs/tacexpr.ml | 2 +- proofs/tacmach.mli | 6 +- scripts/coqc.ml | 13 +- tactics/auto.ml | 70 +- tactics/auto.mli | 4 +- tactics/autorewrite.ml | 9 +- tactics/equality.ml | 83 +- tactics/extraargs.mli | 2 +- tactics/extratactics.ml4 | 12 +- tactics/extratactics.mli | 2 +- tactics/hiddentac.mli | 6 +- tactics/setoid_replace.mli | 2 +- tactics/tacinterp.ml | 69 +- tactics/tacticals.mli | 4 +- tactics/tactics.ml | 14 +- tactics/tactics.mli | 3 +- test-suite/check | 2 +- test-suite/success/RecTutorial.v8 | 1229 ++++++++ test-suite/success/univers.v | 21 + theories/Arith/Arith.v | 5 +- theories/Init/Notations.v | 6 +- theories/Logic/Berardi.v | 6 +- theories/Logic/ChoiceFacts.v | 8 +- theories/Logic/Diaconescu.v | 28 +- theories/Logic/JMeq.v | 13 +- theories/Logic/RelationalChoice.v | 4 +- theories/ZArith/ZArith.v | 3 +- tools/coq_makefile.ml4 | 12 +- tools/coqdoc/index.mll | 4 +- toplevel/class.ml | 12 +- toplevel/command.ml | 49 +- toplevel/coqtop.ml | 4 +- toplevel/himsg.ml | 50 +- toplevel/metasyntax.ml | 149 +- toplevel/recordobj.mli | 2 +- toplevel/usage.ml | 14 +- toplevel/vernacentries.mli | 6 +- toplevel/vernacexpr.ml | 2 +- translate/ppconstrnew.ml | 53 +- translate/ppconstrnew.mli | 2 +- translate/pptacticnew.mli | 4 +- translate/ppvernacnew.ml | 4 +- translate/ppvernacnew.mli | 2 +- 137 files changed, 5323 insertions(+), 3798 deletions(-) create mode 100644 parsing/doc.tex create mode 100644 test-suite/success/RecTutorial.v8 (limited to 'ide') diff --git a/.depend b/.depend index 5ac89a4e..d158d8dc 100644 --- a/.depend +++ b/.depend @@ -1,743 +1,744 @@ ide/config_parser.cmi: lib/util.cmi -ide/coq.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - kernel/term.cmi lib/util.cmi toplevel/vernacexpr.cmo -interp/constrextern.cmi: kernel/environ.cmi library/impargs.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi pretyping/rawterm.cmi kernel/sign.cmi \ - interp/symbols.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi lib/util.cmi -interp/constrintern.cmi: parsing/coqast.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/impargs.cmi library/libnames.cmi \ - kernel/names.cmi pretyping/pattern.cmi pretyping/rawterm.cmi \ - kernel/sign.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi -interp/coqlib.cmi: library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi kernel/term.cmi -interp/genarg.cmi: pretyping/evd.cmi library/libnames.cmi kernel/names.cmi \ - lib/pp.cmi pretyping/rawterm.cmi kernel/term.cmi interp/topconstr.cmi \ - lib/util.cmi -interp/modintern.cmi: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi interp/topconstr.cmi -interp/ppextend.cmi: kernel/names.cmi lib/pp.cmi -interp/reserve.cmi: kernel/names.cmi pretyping/rawterm.cmi lib/util.cmi -interp/symbols.cmi: lib/bignat.cmi pretyping/classops.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi lib/pp.cmi \ - interp/ppextend.cmi pretyping/rawterm.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -interp/syntax_def.cmi: kernel/names.cmi pretyping/rawterm.cmi \ - interp/topconstr.cmi lib/util.cmi -interp/topconstr.cmi: lib/bignat.cmi lib/dyn.cmi library/libnames.cmi \ - kernel/names.cmi lib/pp.cmi pretyping/rawterm.cmi kernel/term.cmi \ - lib/util.cmi -kernel/closure.cmi: kernel/environ.cmi kernel/esubst.cmi kernel/names.cmi \ - lib/pp.cmi kernel/term.cmi -kernel/conv_oracle.cmi: kernel/closure.cmi kernel/names.cmi -kernel/cooking.cmi: kernel/declarations.cmi kernel/environ.cmi \ - kernel/names.cmi kernel/term.cmi kernel/univ.cmi -kernel/declarations.cmi: kernel/names.cmi lib/rtree.cmi kernel/sign.cmi \ - kernel/term.cmi kernel/univ.cmi -kernel/entries.cmi: kernel/names.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi -kernel/environ.cmi: kernel/declarations.cmi kernel/names.cmi kernel/sign.cmi \ - kernel/term.cmi kernel/univ.cmi +ide/coq.cmi: toplevel/vernacexpr.cmo lib/util.cmi kernel/term.cmi \ + kernel/names.cmi pretyping/evd.cmi kernel/environ.cmi +interp/constrextern.cmi: lib/util.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi interp/symbols.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi library/impargs.cmi \ + kernel/environ.cmi +interp/constrintern.cmi: interp/topconstr.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi pretyping/rawterm.cmi \ + pretyping/pattern.cmi kernel/names.cmi library/libnames.cmi \ + library/impargs.cmi pretyping/evd.cmi kernel/environ.cmi \ + parsing/coqast.cmi +interp/coqlib.cmi: kernel/term.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi +interp/genarg.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi lib/pp.cmi kernel/names.cmi library/libnames.cmi \ + pretyping/evd.cmi +interp/modintern.cmi: interp/topconstr.cmi kernel/environ.cmi \ + kernel/entries.cmi kernel/declarations.cmi +interp/ppextend.cmi: lib/pp.cmi kernel/names.cmi +interp/reserve.cmi: lib/util.cmi pretyping/rawterm.cmi kernel/names.cmi +interp/symbols.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi interp/ppextend.cmi lib/pp.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi pretyping/classops.cmi \ + lib/bignat.cmi +interp/syntax_def.cmi: lib/util.cmi interp/topconstr.cmi \ + pretyping/rawterm.cmi kernel/names.cmi +interp/topconstr.cmi: lib/util.cmi kernel/term.cmi pretyping/rawterm.cmi \ + lib/pp.cmi kernel/names.cmi library/libnames.cmi lib/dyn.cmi \ + lib/bignat.cmi +kernel/closure.cmi: kernel/term.cmi lib/pp.cmi kernel/names.cmi \ + kernel/esubst.cmi kernel/environ.cmi +kernel/conv_oracle.cmi: kernel/names.cmi kernel/closure.cmi +kernel/cooking.cmi: kernel/univ.cmi kernel/term.cmi kernel/names.cmi \ + kernel/environ.cmi kernel/declarations.cmi +kernel/declarations.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + lib/rtree.cmi kernel/names.cmi +kernel/entries.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi +kernel/environ.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi kernel/declarations.cmi kernel/esubst.cmi: lib/util.cmi -kernel/indtypes.cmi: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/names.cmi kernel/term.cmi kernel/typeops.cmi \ - kernel/univ.cmi -kernel/inductive.cmi: kernel/declarations.cmi kernel/environ.cmi \ - kernel/names.cmi kernel/term.cmi kernel/univ.cmi -kernel/modops.cmi: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/names.cmi kernel/univ.cmi lib/util.cmi -kernel/mod_typing.cmi: kernel/declarations.cmi kernel/entries.cmi \ +kernel/indtypes.cmi: kernel/univ.cmi kernel/typeops.cmi kernel/term.cmi \ + kernel/names.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi +kernel/inductive.cmi: kernel/univ.cmi kernel/term.cmi kernel/names.cmi \ + kernel/environ.cmi kernel/declarations.cmi +kernel/mod_typing.cmi: kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi +kernel/modops.cmi: lib/util.cmi kernel/univ.cmi kernel/names.cmi \ + kernel/environ.cmi kernel/entries.cmi kernel/declarations.cmi +kernel/names.cmi: lib/predicate.cmi lib/pp.cmi +kernel/reduction.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ kernel/environ.cmi -kernel/names.cmi: lib/pp.cmi lib/predicate.cmi -kernel/reduction.cmi: kernel/environ.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi -kernel/safe_typing.cmi: kernel/cooking.cmi kernel/declarations.cmi \ - kernel/entries.cmi kernel/environ.cmi kernel/names.cmi kernel/term.cmi \ - kernel/univ.cmi -kernel/sign.cmi: kernel/names.cmi kernel/term.cmi -kernel/subtyping.cmi: kernel/declarations.cmi kernel/environ.cmi \ - kernel/univ.cmi -kernel/term.cmi: kernel/esubst.cmi kernel/names.cmi kernel/univ.cmi -kernel/term_typing.cmi: kernel/cooking.cmi kernel/declarations.cmi \ - kernel/entries.cmi kernel/environ.cmi kernel/inductive.cmi \ - kernel/names.cmi kernel/term.cmi kernel/typeops.cmi kernel/univ.cmi -kernel/type_errors.cmi: kernel/environ.cmi kernel/names.cmi kernel/term.cmi -kernel/typeops.cmi: kernel/entries.cmi kernel/environ.cmi kernel/names.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/univ.cmi -kernel/univ.cmi: kernel/names.cmi lib/pp.cmi +kernel/safe_typing.cmi: kernel/univ.cmi kernel/term.cmi kernel/names.cmi \ + kernel/environ.cmi kernel/entries.cmi kernel/declarations.cmi \ + kernel/cooking.cmi +kernel/sign.cmi: kernel/term.cmi kernel/names.cmi +kernel/subtyping.cmi: kernel/univ.cmi kernel/environ.cmi \ + kernel/declarations.cmi +kernel/term.cmi: kernel/univ.cmi kernel/names.cmi kernel/esubst.cmi +kernel/term_typing.cmi: kernel/univ.cmi kernel/typeops.cmi kernel/term.cmi \ + kernel/names.cmi kernel/inductive.cmi kernel/environ.cmi \ + kernel/entries.cmi kernel/declarations.cmi kernel/cooking.cmi +kernel/type_errors.cmi: kernel/term.cmi kernel/names.cmi kernel/environ.cmi +kernel/typeops.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi kernel/environ.cmi kernel/entries.cmi +kernel/univ.cmi: lib/pp.cmi kernel/names.cmi lib/bignat.cmi: lib/pp.cmi lib/pp.cmi: lib/pp_control.cmi -library/declare.cmi: kernel/cooking.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi library/dischargedhypsmap.cmi kernel/entries.cmi \ - kernel/indtypes.cmi library/libnames.cmi library/libobject.cmi \ - kernel/names.cmi library/nametab.cmi kernel/safe_typing.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/univ.cmi -library/declaremods.cmi: kernel/entries.cmi kernel/environ.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - kernel/names.cmi lib/pp.cmi kernel/safe_typing.cmi lib/util.cmi -library/dischargedhypsmap.cmi: kernel/environ.cmi library/libnames.cmi \ - library/nametab.cmi kernel/term.cmi -library/global.cmi: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/indtypes.cmi library/libnames.cmi \ - kernel/names.cmi kernel/safe_typing.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi -library/goptions.cmi: library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi kernel/term.cmi lib/util.cmi -library/impargs.cmi: kernel/environ.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi kernel/term.cmi interp/topconstr.cmi -library/lib.cmi: library/libnames.cmi library/libobject.cmi kernel/names.cmi \ - library/summary.cmi lib/util.cmi -library/libnames.cmi: kernel/names.cmi lib/pp.cmi lib/predicate.cmi \ - kernel/term.cmi lib/util.cmi -library/libobject.cmi: library/libnames.cmi kernel/names.cmi -library/library.cmi: library/libnames.cmi library/libobject.cmi \ - kernel/names.cmi lib/pp.cmi lib/system.cmi lib/util.cmi -library/nameops.cmi: kernel/names.cmi lib/pp.cmi kernel/term.cmi -library/nametab.cmi: library/libnames.cmi kernel/names.cmi lib/pp.cmi \ - lib/util.cmi lib/rtree.cmi: lib/pp.cmi lib/system.cmi: lib/pp.cmi -lib/util.cmi: lib/compat.cmo lib/pp.cmi -parsing/ast.cmi: parsing/coqast.cmi lib/dyn.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi lib/pp.cmi interp/topconstr.cmi \ - lib/util.cmi -parsing/coqast.cmi: lib/dyn.cmi library/libnames.cmi kernel/names.cmi \ - lib/util.cmi -parsing/egrammar.cmi: parsing/ast.cmi parsing/coqast.cmi parsing/extend.cmi \ - interp/genarg.cmi kernel/names.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/esyntax.cmi: parsing/ast.cmi parsing/coqast.cmi parsing/extend.cmi \ - lib/pp.cmi interp/ppextend.cmi interp/symbols.cmi interp/topconstr.cmi -parsing/extend.cmi: parsing/ast.cmi parsing/coqast.cmi interp/genarg.cmi \ - kernel/names.cmi lib/pp.cmi interp/ppextend.cmi interp/topconstr.cmi \ - lib/util.cmi -parsing/g_minicoq.cmi: kernel/environ.cmi kernel/names.cmi lib/pp.cmi \ - kernel/term.cmi -parsing/lexer.cmi: lib/pp.cmi lib/util.cmi -parsing/pcoq.cmi: parsing/ast.cmi lib/bignat.cmi parsing/coqast.cmi \ - library/decl_kinds.cmo parsing/extend.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/ppconstr.cmi: parsing/coqast.cmi kernel/environ.cmi \ - parsing/extend.cmi library/libnames.cmi kernel/names.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -parsing/pptactic.cmi: interp/genarg.cmi library/libnames.cmi lib/pp.cmi \ - pretyping/pretyping.cmi proofs/proof_type.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo kernel/term.cmi interp/topconstr.cmi lib/util.cmi -parsing/prettyp.cmi: pretyping/classops.cmi kernel/environ.cmi \ - library/impargs.cmi library/lib.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi pretyping/reductionops.cmi \ - kernel/safe_typing.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi -parsing/printer.cmi: kernel/environ.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi pretyping/pattern.cmi lib/pp.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi -parsing/printmod.cmi: kernel/names.cmi lib/pp.cmi -parsing/search.cmi: kernel/environ.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi pretyping/pattern.cmi lib/pp.cmi kernel/term.cmi -parsing/termast.cmi: parsing/coqast.cmi kernel/environ.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi pretyping/rawterm.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi -pretyping/cases.cmi: kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/evd.cmi pretyping/inductiveops.cmi kernel/names.cmi \ - pretyping/rawterm.cmi kernel/term.cmi lib/util.cmi -pretyping/cbv.cmi: kernel/closure.cmi kernel/environ.cmi kernel/esubst.cmi \ - kernel/names.cmi kernel/term.cmi -pretyping/classops.cmi: library/decl_kinds.cmo kernel/environ.cmi \ - pretyping/evd.cmi library/libnames.cmi library/libobject.cmi \ - kernel/names.cmi library/nametab.cmi lib/pp.cmi kernel/term.cmi -pretyping/coercion.cmi: kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/evd.cmi kernel/names.cmi pretyping/rawterm.cmi kernel/sign.cmi \ - kernel/term.cmi lib/util.cmi -pretyping/detyping.cmi: kernel/environ.cmi kernel/names.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi -pretyping/evarconv.cmi: kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/reductionops.cmi kernel/sign.cmi kernel/term.cmi -pretyping/evarutil.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi lib/util.cmi -pretyping/evd.cmi: kernel/names.cmi kernel/sign.cmi kernel/term.cmi -pretyping/indrec.cmi: kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi pretyping/inductiveops.cmi kernel/names.cmi \ - kernel/term.cmi -pretyping/inductiveops.cmi: kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi kernel/names.cmi kernel/sign.cmi kernel/term.cmi -pretyping/instantiate.cmi: kernel/environ.cmi pretyping/evd.cmi \ - kernel/names.cmi kernel/sign.cmi kernel/term.cmi -pretyping/matching.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - pretyping/pattern.cmi kernel/term.cmi pretyping/termops.cmi -pretyping/pattern.cmi: kernel/environ.cmi library/libnames.cmi \ - kernel/names.cmi library/nametab.cmi lib/pp.cmi pretyping/rawterm.cmi \ - kernel/sign.cmi kernel/term.cmi -pretyping/pretype_errors.cmi: kernel/environ.cmi pretyping/evd.cmi \ - pretyping/inductiveops.cmi kernel/names.cmi lib/pp.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi kernel/term.cmi lib/util.cmi -pretyping/pretyping.cmi: lib/dyn.cmi kernel/environ.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi kernel/names.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi kernel/term.cmi -pretyping/rawterm.cmi: lib/dyn.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi kernel/sign.cmi kernel/term.cmi kernel/univ.cmi \ - lib/util.cmi -pretyping/recordops.cmi: pretyping/classops.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi kernel/names.cmi \ - library/nametab.cmi kernel/term.cmi -pretyping/reductionops.cmi: kernel/closure.cmi kernel/environ.cmi \ - pretyping/evd.cmi kernel/names.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi -pretyping/retyping.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - pretyping/pattern.cmi kernel/term.cmi pretyping/termops.cmi -pretyping/tacred.cmi: kernel/closure.cmi kernel/environ.cmi pretyping/evd.cmi \ - library/libnames.cmi kernel/names.cmi pretyping/rawterm.cmi \ - pretyping/reductionops.cmi kernel/term.cmi -pretyping/termops.cmi: kernel/environ.cmi kernel/names.cmi lib/pp.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/univ.cmi lib/util.cmi -pretyping/typing.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/term.cmi -proofs/clenv.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - lib/pp.cmi pretyping/pretyping.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi -proofs/evar_refiner.cmi: kernel/environ.cmi pretyping/evd.cmi \ - kernel/names.cmi proofs/proof_type.cmi proofs/refiner.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo kernel/term.cmi interp/topconstr.cmi -proofs/logic.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - lib/pp.cmi proofs/proof_type.cmi kernel/sign.cmi kernel/term.cmi -proofs/pfedit.cmi: library/decl_kinds.cmo kernel/entries.cmi \ - kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi lib/pp.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -proofs/proof_trees.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - lib/pp.cmi proofs/proof_type.cmi kernel/sign.cmi kernel/term.cmi \ - lib/util.cmi -proofs/proof_type.cmi: kernel/environ.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - kernel/term.cmi lib/util.cmi -proofs/refiner.cmi: pretyping/evd.cmi lib/pp.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi kernel/sign.cmi proofs/tacexpr.cmo kernel/term.cmi \ - pretyping/termops.cmi -proofs/tacmach.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - lib/pp.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi proofs/refiner.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo pretyping/tacred.cmi kernel/term.cmi \ - pretyping/termops.cmi interp/topconstr.cmi -proofs/tactic_debug.cmi: kernel/environ.cmi kernel/names.cmi \ - pretyping/pattern.cmi lib/pp.cmi proofs/proof_type.cmi proofs/tacexpr.cmo \ - kernel/term.cmi -tactics/auto.cmi: tactics/btermdn.cmi proofs/clenv.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/libnames.cmi kernel/names.cmi \ - pretyping/pattern.cmi lib/pp.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi kernel/term.cmi lib/util.cmi toplevel/vernacexpr.cmo -tactics/autorewrite.cmi: proofs/tacexpr.cmo proofs/tacmach.cmi \ - kernel/term.cmi -tactics/btermdn.cmi: pretyping/pattern.cmi kernel/term.cmi -tactics/contradiction.cmi: kernel/names.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/term.cmi -tactics/dhyp.cmi: kernel/names.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - interp/topconstr.cmi toplevel/vernacexpr.cmo -tactics/eauto.cmi: proofs/proof_type.cmi proofs/tacexpr.cmo kernel/term.cmi -tactics/elim.cmi: interp/genarg.cmi kernel/names.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi proofs/tacmach.cmi tactics/tacticals.cmi \ - kernel/term.cmi -tactics/equality.cmi: kernel/environ.cmi pretyping/evd.cmi \ - tactics/hipattern.cmi kernel/names.cmi pretyping/pattern.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi -tactics/extraargs.cmi: parsing/pcoq.cmi proofs/proof_type.cmi \ - proofs/tacexpr.cmo kernel/term.cmi interp/topconstr.cmi -tactics/extratactics.cmi: interp/genarg.cmi kernel/names.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/term.cmi -tactics/hiddentac.cmi: interp/genarg.cmi kernel/names.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi pretyping/tacred.cmi tactics/tacticals.cmi \ - kernel/term.cmi -tactics/hipattern.cmi: interp/coqlib.cmi pretyping/evd.cmi kernel/names.cmi \ - pretyping/pattern.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - kernel/sign.cmi proofs/tacmach.cmi kernel/term.cmi lib/util.cmi -tactics/inv.cmi: interp/genarg.cmi kernel/names.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi kernel/term.cmi -tactics/leminv.cmi: kernel/names.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/term.cmi interp/topconstr.cmi -tactics/nbtermdn.cmi: tactics/btermdn.cmi pretyping/pattern.cmi \ - kernel/term.cmi -tactics/refine.cmi: pretyping/pretyping.cmi proofs/tacmach.cmi \ - kernel/term.cmi -tactics/setoid_replace.cmi: kernel/names.cmi proofs/proof_type.cmi \ - kernel/term.cmi interp/topconstr.cmi -tactics/tacinterp.cmi: parsing/coqast.cmi lib/dyn.cmi kernel/environ.cmi \ - pretyping/evd.cmi interp/genarg.cmi kernel/names.cmi library/nametab.cmi \ - lib/pp.cmi proofs/proof_type.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - pretyping/tacred.cmi proofs/tactic_debug.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -tactics/tacticals.cmi: proofs/clenv.cmi interp/genarg.cmi kernel/names.cmi \ - pretyping/pattern.cmi proofs/proof_type.cmi kernel/reduction.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi kernel/term.cmi -tactics/tactics.cmi: proofs/clenv.cmi kernel/environ.cmi \ - proofs/evar_refiner.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/reduction.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - pretyping/tacred.cmi tactics/tacticals.cmi kernel/term.cmi \ - interp/topconstr.cmi -tactics/termdn.cmi: pretyping/pattern.cmi kernel/term.cmi -toplevel/cerrors.cmi: lib/pp.cmi lib/util.cmi -toplevel/class.cmi: pretyping/classops.cmi library/decl_kinds.cmo \ - library/declare.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi proofs/tacexpr.cmo kernel/term.cmi -toplevel/command.cmi: library/decl_kinds.cmo library/declare.cmi \ - kernel/entries.cmi kernel/environ.cmi pretyping/evd.cmi \ - library/libnames.cmi library/library.cmi kernel/names.cmi \ - library/nametab.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - pretyping/tacred.cmi kernel/term.cmi interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo +lib/util.cmi: lib/pp.cmi lib/compat.cmo +library/declare.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/safe_typing.cmi library/nametab.cmi kernel/names.cmi \ + library/libobject.cmi library/libnames.cmi kernel/indtypes.cmi \ + kernel/entries.cmi library/dischargedhypsmap.cmi kernel/declarations.cmi \ + library/decl_kinds.cmo kernel/cooking.cmi +library/declaremods.cmi: lib/util.cmi kernel/safe_typing.cmi lib/pp.cmi \ + kernel/names.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi kernel/environ.cmi kernel/entries.cmi +library/dischargedhypsmap.cmi: kernel/term.cmi library/nametab.cmi \ + library/libnames.cmi kernel/environ.cmi +library/global.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/safe_typing.cmi kernel/names.cmi library/libnames.cmi \ + kernel/indtypes.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi +library/goptions.cmi: lib/util.cmi kernel/term.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi library/libnames.cmi +library/impargs.cmi: interp/topconstr.cmi kernel/term.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi kernel/environ.cmi +library/lib.cmi: lib/util.cmi library/summary.cmi kernel/names.cmi \ + library/libobject.cmi library/libnames.cmi +library/libnames.cmi: lib/util.cmi kernel/term.cmi lib/predicate.cmi \ + lib/pp.cmi kernel/names.cmi +library/libobject.cmi: kernel/names.cmi library/libnames.cmi +library/library.cmi: lib/util.cmi lib/system.cmi lib/pp.cmi kernel/names.cmi \ + library/libobject.cmi library/libnames.cmi +library/nameops.cmi: kernel/term.cmi lib/pp.cmi kernel/names.cmi +library/nametab.cmi: lib/util.cmi lib/pp.cmi kernel/names.cmi \ + library/libnames.cmi +parsing/ast.cmi: lib/util.cmi interp/topconstr.cmi lib/pp.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi lib/dyn.cmi \ + parsing/coqast.cmi +parsing/coqast.cmi: lib/util.cmi kernel/names.cmi library/libnames.cmi \ + lib/dyn.cmi +parsing/egrammar.cmi: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo pretyping/rawterm.cmi \ + interp/ppextend.cmi kernel/names.cmi interp/genarg.cmi parsing/extend.cmi \ + parsing/coqast.cmi parsing/ast.cmi +parsing/esyntax.cmi: interp/topconstr.cmi interp/symbols.cmi \ + interp/ppextend.cmi lib/pp.cmi parsing/extend.cmi parsing/coqast.cmi \ + parsing/ast.cmi +parsing/extend.cmi: lib/util.cmi interp/topconstr.cmi interp/ppextend.cmi \ + lib/pp.cmi kernel/names.cmi interp/genarg.cmi parsing/coqast.cmi \ + parsing/ast.cmi +parsing/g_minicoq.cmi: kernel/term.cmi lib/pp.cmi kernel/names.cmi \ + kernel/environ.cmi +parsing/lexer.cmi: lib/util.cmi lib/pp.cmi +parsing/pcoq.cmi: toplevel/vernacexpr.cmo lib/util.cmi interp/topconstr.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi kernel/names.cmi \ + library/libnames.cmi interp/genarg.cmi parsing/extend.cmi \ + library/decl_kinds.cmo parsing/coqast.cmi lib/bignat.cmi parsing/ast.cmi +parsing/ppconstr.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi \ + kernel/names.cmi library/libnames.cmi parsing/extend.cmi \ + kernel/environ.cmi parsing/coqast.cmi +parsing/pptactic.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi proofs/proof_type.cmi \ + pretyping/pretyping.cmi lib/pp.cmi library/libnames.cmi interp/genarg.cmi +parsing/prettyp.cmi: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/safe_typing.cmi pretyping/reductionops.cmi \ + lib/pp.cmi library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + library/lib.cmi library/impargs.cmi kernel/environ.cmi \ + pretyping/classops.cmi +parsing/printer.cmi: pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi lib/pp.cmi pretyping/pattern.cmi \ + library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + kernel/environ.cmi +parsing/printmod.cmi: lib/pp.cmi kernel/names.cmi +parsing/search.cmi: kernel/term.cmi lib/pp.cmi pretyping/pattern.cmi \ + library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + kernel/environ.cmi +parsing/termast.cmi: pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi kernel/environ.cmi \ + parsing/coqast.cmi +pretyping/cases.cmi: lib/util.cmi kernel/term.cmi pretyping/rawterm.cmi \ + kernel/names.cmi pretyping/inductiveops.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi +pretyping/cbv.cmi: kernel/term.cmi kernel/names.cmi kernel/esubst.cmi \ + kernel/environ.cmi kernel/closure.cmi +pretyping/classops.cmi: kernel/term.cmi lib/pp.cmi library/nametab.cmi \ + kernel/names.cmi library/libobject.cmi library/libnames.cmi \ + pretyping/evd.cmi kernel/environ.cmi library/decl_kinds.cmo +pretyping/coercion.cmi: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi kernel/names.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi +pretyping/detyping.cmi: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + kernel/sign.cmi pretyping/rawterm.cmi kernel/names.cmi kernel/environ.cmi +pretyping/evarconv.cmi: kernel/term.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi pretyping/evarutil.cmi kernel/environ.cmi +pretyping/evarutil.cmi: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi +pretyping/evd.cmi: kernel/term.cmi kernel/sign.cmi kernel/names.cmi +pretyping/indrec.cmi: kernel/term.cmi kernel/names.cmi \ + pretyping/inductiveops.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi +pretyping/inductiveops.cmi: kernel/term.cmi kernel/sign.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/declarations.cmi +pretyping/instantiate.cmi: kernel/term.cmi kernel/sign.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi +pretyping/matching.cmi: pretyping/termops.cmi kernel/term.cmi \ + pretyping/pattern.cmi kernel/names.cmi pretyping/evd.cmi \ + kernel/environ.cmi +pretyping/pattern.cmi: kernel/term.cmi kernel/sign.cmi pretyping/rawterm.cmi \ + lib/pp.cmi library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + kernel/environ.cmi +pretyping/pretype_errors.cmi: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi lib/pp.cmi kernel/names.cmi \ + pretyping/inductiveops.cmi pretyping/evd.cmi kernel/environ.cmi +pretyping/pretyping.cmi: kernel/term.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi kernel/names.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi lib/dyn.cmi +pretyping/rawterm.cmi: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + lib/dyn.cmi +pretyping/recordops.cmi: kernel/term.cmi library/nametab.cmi kernel/names.cmi \ + library/library.cmi library/libobject.cmi library/libnames.cmi \ + pretyping/classops.cmi +pretyping/reductionops.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi pretyping/evd.cmi kernel/environ.cmi kernel/closure.cmi +pretyping/retyping.cmi: pretyping/termops.cmi kernel/term.cmi \ + pretyping/pattern.cmi kernel/names.cmi pretyping/evd.cmi \ + kernel/environ.cmi +pretyping/tacred.cmi: kernel/term.cmi pretyping/reductionops.cmi \ + pretyping/rawterm.cmi kernel/names.cmi library/libnames.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/closure.cmi +pretyping/termops.cmi: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi lib/pp.cmi kernel/names.cmi kernel/environ.cmi +pretyping/typing.cmi: kernel/term.cmi pretyping/evd.cmi kernel/environ.cmi +proofs/clenv.cmi: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + kernel/sign.cmi pretyping/reductionops.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi pretyping/pretyping.cmi lib/pp.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi +proofs/evar_refiner.cmi: interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo kernel/sign.cmi proofs/refiner.cmi \ + proofs/proof_type.cmi kernel/names.cmi pretyping/evd.cmi \ + kernel/environ.cmi +proofs/logic.cmi: kernel/term.cmi kernel/sign.cmi proofs/proof_type.cmi \ + lib/pp.cmi kernel/names.cmi pretyping/evd.cmi kernel/environ.cmi +proofs/pfedit.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi lib/pp.cmi \ + kernel/names.cmi pretyping/evd.cmi kernel/environ.cmi kernel/entries.cmi \ + library/decl_kinds.cmo +proofs/proof_trees.cmi: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + proofs/proof_type.cmi lib/pp.cmi kernel/names.cmi pretyping/evd.cmi \ + kernel/environ.cmi +proofs/proof_type.cmi: lib/util.cmi kernel/term.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi pretyping/evd.cmi \ + kernel/environ.cmi +proofs/refiner.cmi: pretyping/termops.cmi kernel/term.cmi proofs/tacexpr.cmo \ + kernel/sign.cmi proofs/proof_type.cmi proofs/proof_trees.cmi lib/pp.cmi \ + pretyping/evd.cmi +proofs/tacmach.cmi: interp/topconstr.cmi pretyping/termops.cmi \ + kernel/term.cmi pretyping/tacred.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + proofs/refiner.cmi kernel/reduction.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi lib/pp.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi +proofs/tactic_debug.cmi: kernel/term.cmi proofs/tacexpr.cmo \ + proofs/proof_type.cmi lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi \ + kernel/environ.cmi +tactics/auto.cmi: toplevel/vernacexpr.cmo lib/util.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi lib/pp.cmi \ + pretyping/pattern.cmi kernel/names.cmi library/libnames.cmi \ + pretyping/evd.cmi kernel/environ.cmi proofs/clenv.cmi tactics/btermdn.cmi +tactics/autorewrite.cmi: kernel/term.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo +tactics/btermdn.cmi: kernel/term.cmi pretyping/pattern.cmi +tactics/contradiction.cmi: kernel/term.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi kernel/names.cmi +tactics/dhyp.cmi: toplevel/vernacexpr.cmo interp/topconstr.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/names.cmi +tactics/eauto.cmi: kernel/term.cmi proofs/tacexpr.cmo proofs/proof_type.cmi +tactics/elim.cmi: kernel/term.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi kernel/names.cmi \ + interp/genarg.cmi +tactics/equality.cmi: kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + kernel/sign.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + pretyping/pattern.cmi kernel/names.cmi tactics/hipattern.cmi \ + pretyping/evd.cmi kernel/environ.cmi +tactics/extraargs.cmi: interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo proofs/proof_type.cmi parsing/pcoq.cmi +tactics/extratactics.cmi: kernel/term.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi kernel/names.cmi interp/genarg.cmi +tactics/hiddentac.cmi: kernel/term.cmi tactics/tacticals.cmi \ + pretyping/tacred.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi proofs/proof_type.cmi kernel/names.cmi \ + interp/genarg.cmi +tactics/hipattern.cmi: lib/util.cmi kernel/term.cmi proofs/tacmach.cmi \ + kernel/sign.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + pretyping/pattern.cmi kernel/names.cmi pretyping/evd.cmi \ + interp/coqlib.cmi +tactics/inv.cmi: kernel/term.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi kernel/names.cmi interp/genarg.cmi +tactics/leminv.cmi: interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi kernel/names.cmi +tactics/nbtermdn.cmi: kernel/term.cmi pretyping/pattern.cmi \ + tactics/btermdn.cmi +tactics/refine.cmi: kernel/term.cmi proofs/tacmach.cmi \ + pretyping/pretyping.cmi +tactics/setoid_replace.cmi: interp/topconstr.cmi kernel/term.cmi \ + proofs/proof_type.cmi kernel/names.cmi +tactics/tacinterp.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tactic_debug.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo proofs/proof_type.cmi lib/pp.cmi library/nametab.cmi \ + kernel/names.cmi interp/genarg.cmi pretyping/evd.cmi kernel/environ.cmi \ + lib/dyn.cmi parsing/coqast.cmi +tactics/tacticals.cmi: kernel/term.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + kernel/sign.cmi kernel/reduction.cmi proofs/proof_type.cmi \ + pretyping/pattern.cmi kernel/names.cmi interp/genarg.cmi proofs/clenv.cmi +tactics/tactics.cmi: interp/topconstr.cmi kernel/term.cmi \ + tactics/tacticals.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo kernel/sign.cmi kernel/reduction.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi pretyping/evd.cmi \ + proofs/evar_refiner.cmi kernel/environ.cmi proofs/clenv.cmi +tactics/termdn.cmi: kernel/term.cmi pretyping/pattern.cmi +toplevel/cerrors.cmi: lib/util.cmi lib/pp.cmi +toplevel/class.cmi: kernel/term.cmi proofs/tacexpr.cmo library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi library/declare.cmi \ + library/decl_kinds.cmo pretyping/classops.cmi +toplevel/command.cmi: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi kernel/term.cmi pretyping/tacred.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi library/nametab.cmi \ + kernel/names.cmi library/library.cmi library/libnames.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/entries.cmi \ + library/declare.cmi library/decl_kinds.cmo toplevel/coqinit.cmi: kernel/names.cmi toplevel/discharge.cmi: kernel/names.cmi -toplevel/fhimsg.cmi: kernel/environ.cmi kernel/names.cmi lib/pp.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/type_errors.cmi -toplevel/himsg.cmi: pretyping/cases.cmi kernel/environ.cmi \ - kernel/indtypes.cmi proofs/logic.cmi kernel/names.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi kernel/type_errors.cmi -toplevel/metasyntax.cmi: pretyping/classops.cmi interp/constrintern.cmi \ - parsing/extend.cmi library/libnames.cmi interp/ppextend.cmi \ - interp/symbols.cmi proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -toplevel/mltop.cmi: library/libobject.cmi kernel/names.cmi +toplevel/fhimsg.cmi: kernel/type_errors.cmi kernel/term.cmi kernel/sign.cmi \ + lib/pp.cmi kernel/names.cmi kernel/environ.cmi +toplevel/himsg.cmi: kernel/type_errors.cmi pretyping/pretype_errors.cmi \ + lib/pp.cmi kernel/names.cmi proofs/logic.cmi kernel/indtypes.cmi \ + kernel/environ.cmi pretyping/cases.cmi +toplevel/metasyntax.cmi: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo interp/symbols.cmi \ + interp/ppextend.cmi library/libnames.cmi parsing/extend.cmi \ + interp/constrintern.cmi pretyping/classops.cmi +toplevel/mltop.cmi: kernel/names.cmi library/libobject.cmi toplevel/protectedtoplevel.cmi: lib/pp.cmi -toplevel/record.cmi: kernel/names.cmi kernel/sign.cmi kernel/term.cmi \ - interp/topconstr.cmi toplevel/vernacexpr.cmo -toplevel/recordobj.cmi: library/libnames.cmi proofs/tacexpr.cmo -toplevel/searchisos.cmi: library/libobject.cmi kernel/names.cmi \ - kernel/term.cmi -toplevel/toplevel.cmi: parsing/pcoq.cmi lib/pp.cmi -toplevel/vernacentries.cmi: kernel/environ.cmi pretyping/evd.cmi \ - library/libnames.cmi kernel/names.cmi kernel/term.cmi \ - interp/topconstr.cmi toplevel/vernacexpr.cmo toplevel/vernacinterp.cmi +toplevel/record.cmi: toplevel/vernacexpr.cmo interp/topconstr.cmi \ + kernel/term.cmi kernel/sign.cmi kernel/names.cmi +toplevel/recordobj.cmi: proofs/tacexpr.cmo library/libnames.cmi +toplevel/searchisos.cmi: kernel/term.cmi kernel/names.cmi \ + library/libobject.cmi +toplevel/toplevel.cmi: lib/pp.cmi parsing/pcoq.cmi +toplevel/vernac.cmi: toplevel/vernacexpr.cmo lib/util.cmi parsing/pcoq.cmi +toplevel/vernacentries.cmi: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + interp/topconstr.cmi kernel/term.cmi kernel/names.cmi \ + library/libnames.cmi pretyping/evd.cmi kernel/environ.cmi toplevel/vernacinterp.cmi: proofs/tacexpr.cmo -toplevel/vernac.cmi: parsing/pcoq.cmi lib/util.cmi toplevel/vernacexpr.cmo -translate/ppconstrnew.cmi: parsing/coqast.cmi kernel/environ.cmi \ - parsing/extend.cmi interp/genarg.cmi library/libnames.cmi \ - kernel/names.cmi pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi \ - interp/ppextend.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - kernel/term.cmi interp/topconstr.cmi lib/util.cmi -translate/pptacticnew.cmi: kernel/environ.cmi interp/genarg.cmi \ - kernel/names.cmi lib/pp.cmi proofs/proof_type.cmi proofs/tacexpr.cmo \ - interp/topconstr.cmi -translate/ppvernacnew.cmi: parsing/ast.cmi parsing/coqast.cmi \ - kernel/environ.cmi parsing/extend.cmi interp/genarg.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi parsing/pcoq.cmi lib/pp.cmi parsing/ppconstr.cmi \ - interp/ppextend.cmi parsing/pptactic.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -contrib/cc/ccalgo.cmi: kernel/names.cmi kernel/term.cmi -contrib/cc/ccproof.cmi: contrib/cc/ccalgo.cmi kernel/names.cmi -contrib/correctness/past.cmi: kernel/names.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -contrib/correctness/pcicenv.cmi: kernel/names.cmi kernel/sign.cmi \ - kernel/term.cmi +translate/ppconstrnew.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi interp/ppextend.cmi lib/pp.cmi \ + parsing/pcoq.cmi pretyping/pattern.cmi kernel/names.cmi \ + library/libnames.cmi interp/genarg.cmi parsing/extend.cmi \ + kernel/environ.cmi parsing/coqast.cmi +translate/pptacticnew.cmi: interp/topconstr.cmi proofs/tacexpr.cmo \ + proofs/proof_type.cmi lib/pp.cmi kernel/names.cmi interp/genarg.cmi \ + kernel/environ.cmi +translate/ppvernacnew.cmi: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo pretyping/rawterm.cmi \ + parsing/pptactic.cmi interp/ppextend.cmi parsing/ppconstr.cmi lib/pp.cmi \ + parsing/pcoq.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi interp/genarg.cmi parsing/extend.cmi \ + kernel/environ.cmi parsing/coqast.cmi parsing/ast.cmi +contrib/cc/ccalgo.cmi: kernel/term.cmi kernel/names.cmi +contrib/cc/ccproof.cmi: kernel/names.cmi contrib/cc/ccalgo.cmi +contrib/correctness/past.cmi: lib/util.cmi interp/topconstr.cmi \ + kernel/term.cmi kernel/names.cmi contrib/correctness/pcic.cmi: pretyping/rawterm.cmi +contrib/correctness/pcicenv.cmi: kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi contrib/correctness/pdb.cmi: kernel/names.cmi -contrib/correctness/peffect.cmi: kernel/names.cmi lib/pp.cmi -contrib/correctness/penv.cmi: library/libnames.cmi kernel/names.cmi \ - kernel/term.cmi -contrib/correctness/perror.cmi: kernel/names.cmi lib/pp.cmi lib/util.cmi +contrib/correctness/peffect.cmi: lib/pp.cmi kernel/names.cmi +contrib/correctness/penv.cmi: kernel/term.cmi kernel/names.cmi \ + library/libnames.cmi +contrib/correctness/perror.cmi: lib/util.cmi lib/pp.cmi kernel/names.cmi contrib/correctness/pextract.cmi: kernel/names.cmi -contrib/correctness/pmisc.cmi: kernel/names.cmi lib/pp.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi +contrib/correctness/pmisc.cmi: lib/util.cmi interp/topconstr.cmi \ + kernel/term.cmi lib/pp.cmi kernel/names.cmi contrib/correctness/pmlize.cmi: kernel/names.cmi -contrib/correctness/pmonad.cmi: kernel/names.cmi kernel/term.cmi +contrib/correctness/pmonad.cmi: kernel/term.cmi kernel/names.cmi contrib/correctness/pred.cmi: kernel/term.cmi -contrib/correctness/prename.cmi: kernel/names.cmi lib/pp.cmi -contrib/correctness/psyntax.cmi: parsing/pcoq.cmi interp/topconstr.cmi +contrib/correctness/prename.cmi: lib/pp.cmi kernel/names.cmi +contrib/correctness/psyntax.cmi: interp/topconstr.cmi parsing/pcoq.cmi contrib/correctness/ptactic.cmi: proofs/tacmach.cmi -contrib/correctness/ptype.cmi: kernel/names.cmi kernel/term.cmi -contrib/correctness/ptyping.cmi: kernel/names.cmi kernel/term.cmi \ - interp/topconstr.cmi -contrib/correctness/putil.cmi: kernel/names.cmi lib/pp.cmi kernel/term.cmi +contrib/correctness/ptype.cmi: kernel/term.cmi kernel/names.cmi +contrib/correctness/ptyping.cmi: interp/topconstr.cmi kernel/term.cmi \ + kernel/names.cmi +contrib/correctness/putil.cmi: kernel/term.cmi lib/pp.cmi kernel/names.cmi contrib/correctness/pwp.cmi: kernel/term.cmi -contrib/extraction/common.cmi: contrib/extraction/miniml.cmi \ - contrib/extraction/mlutil.cmi kernel/names.cmi -contrib/extraction/extract_env.cmi: library/libnames.cmi kernel/names.cmi -contrib/extraction/extraction.cmi: kernel/declarations.cmi kernel/environ.cmi \ - library/libnames.cmi contrib/extraction/miniml.cmi kernel/names.cmi \ - kernel/term.cmi -contrib/extraction/haskell.cmi: contrib/extraction/miniml.cmi \ - kernel/names.cmi lib/pp.cmi -contrib/extraction/miniml.cmi: library/libnames.cmi kernel/names.cmi \ - lib/pp.cmi lib/util.cmi -contrib/extraction/mlutil.cmi: library/libnames.cmi \ - contrib/extraction/miniml.cmi kernel/names.cmi kernel/term.cmi \ - lib/util.cmi -contrib/extraction/modutil.cmi: kernel/declarations.cmi kernel/environ.cmi \ - library/libnames.cmi contrib/extraction/miniml.cmi kernel/names.cmi -contrib/extraction/ocaml.cmi: library/libnames.cmi \ - contrib/extraction/miniml.cmi kernel/names.cmi lib/pp.cmi -contrib/extraction/scheme.cmi: contrib/extraction/miniml.cmi kernel/names.cmi \ - lib/pp.cmi -contrib/extraction/table.cmi: kernel/environ.cmi library/libnames.cmi \ - contrib/extraction/miniml.cmi kernel/names.cmi kernel/term.cmi -contrib/first-order/formula.cmi: kernel/closure.cmi library/libnames.cmi \ - kernel/names.cmi proofs/proof_type.cmi kernel/sign.cmi proofs/tacmach.cmi \ - kernel/term.cmi -contrib/first-order/ground.cmi: proofs/proof_type.cmi \ - contrib/first-order/sequent.cmi proofs/tacmach.cmi -contrib/first-order/instances.cmi: contrib/first-order/formula.cmi \ - library/libnames.cmi kernel/names.cmi contrib/first-order/rules.cmi \ - contrib/first-order/sequent.cmi proofs/tacmach.cmi kernel/term.cmi \ - contrib/first-order/unify.cmi -contrib/first-order/rules.cmi: library/libnames.cmi kernel/names.cmi \ - contrib/first-order/sequent.cmi proofs/tacmach.cmi kernel/term.cmi -contrib/first-order/sequent.cmi: tactics/auto.cmi \ - contrib/first-order/formula.cmi lib/heap.cmi library/libnames.cmi \ - kernel/names.cmi proofs/proof_type.cmi proofs/tacmach.cmi kernel/term.cmi \ - lib/util.cmi +contrib/extraction/common.cmi: kernel/names.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi +contrib/extraction/extract_env.cmi: kernel/names.cmi library/libnames.cmi +contrib/extraction/extraction.cmi: kernel/term.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi kernel/environ.cmi \ + kernel/declarations.cmi +contrib/extraction/haskell.cmi: lib/pp.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi +contrib/extraction/miniml.cmi: lib/util.cmi lib/pp.cmi kernel/names.cmi \ + library/libnames.cmi +contrib/extraction/mlutil.cmi: lib/util.cmi kernel/term.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi +contrib/extraction/modutil.cmi: kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi kernel/environ.cmi \ + kernel/declarations.cmi +contrib/extraction/ocaml.cmi: lib/pp.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi +contrib/extraction/scheme.cmi: lib/pp.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi +contrib/extraction/table.cmi: kernel/term.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi kernel/environ.cmi +contrib/first-order/formula.cmi: kernel/term.cmi proofs/tacmach.cmi \ + kernel/sign.cmi proofs/proof_type.cmi kernel/names.cmi \ + library/libnames.cmi kernel/closure.cmi +contrib/first-order/ground.cmi: proofs/tacmach.cmi \ + contrib/first-order/sequent.cmi proofs/proof_type.cmi +contrib/first-order/instances.cmi: contrib/first-order/unify.cmi \ + kernel/term.cmi proofs/tacmach.cmi contrib/first-order/sequent.cmi \ + contrib/first-order/rules.cmi kernel/names.cmi library/libnames.cmi \ + contrib/first-order/formula.cmi +contrib/first-order/rules.cmi: kernel/term.cmi proofs/tacmach.cmi \ + contrib/first-order/sequent.cmi kernel/names.cmi library/libnames.cmi +contrib/first-order/sequent.cmi: lib/util.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/proof_type.cmi kernel/names.cmi \ + library/libnames.cmi lib/heap.cmi contrib/first-order/formula.cmi \ + tactics/auto.cmi contrib/first-order/unify.cmi: kernel/term.cmi -contrib/funind/tacinvutils.cmi: interp/coqlib.cmi tactics/equality.cmi \ - pretyping/evd.cmi pretyping/inductiveops.cmi kernel/names.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_type.cmi pretyping/reductionops.cmi \ - tactics/refine.cmi tactics/tacinterp.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi -contrib/interface/blast.cmi: proofs/proof_type.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi -contrib/interface/dad.cmi: proofs/proof_type.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi interp/topconstr.cmi -contrib/interface/debug_tac.cmi: proofs/proof_type.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi -contrib/interface/name_to_ast.cmi: parsing/coqast.cmi library/libnames.cmi \ - toplevel/vernacexpr.cmo -contrib/interface/pbp.cmi: kernel/names.cmi proofs/proof_type.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi -contrib/interface/showproof.cmi: contrib/interface/ascent.cmi \ - proofs/clenv.cmi parsing/coqast.cmi kernel/declarations.cmi \ - kernel/environ.cmi pretyping/evd.cmi kernel/inductive.cmi \ - kernel/names.cmi proofs/pfedit.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi kernel/reduction.cmi \ - contrib/interface/showproof_ct.cmo kernel/sign.cmi kernel/term.cmi \ - contrib/interface/translate.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacinterp.cmi -contrib/interface/translate.cmi: contrib/interface/ascent.cmi \ - kernel/environ.cmi pretyping/evd.cmi proofs/proof_type.cmi \ - kernel/term.cmi +contrib/funind/tacinvutils.cmi: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi tactics/tacinterp.cmi tactics/refine.cmi \ + pretyping/reductionops.cmi proofs/proof_type.cmi parsing/printer.cmi \ + lib/pp.cmi kernel/names.cmi pretyping/inductiveops.cmi pretyping/evd.cmi \ + tactics/equality.cmi interp/coqlib.cmi +contrib/interface/blast.cmi: proofs/tacmach.cmi proofs/tacexpr.cmo \ + proofs/proof_type.cmi +contrib/interface/dad.cmi: interp/topconstr.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo proofs/proof_type.cmi +contrib/interface/debug_tac.cmi: proofs/tacmach.cmi proofs/tacexpr.cmo \ + proofs/proof_type.cmi +contrib/interface/name_to_ast.cmi: toplevel/vernacexpr.cmo \ + library/libnames.cmi parsing/coqast.cmi +contrib/interface/pbp.cmi: proofs/tacmach.cmi proofs/tacexpr.cmo \ + proofs/proof_type.cmi kernel/names.cmi +contrib/interface/showproof.cmi: toplevel/vernacinterp.cmi lib/util.cmi \ + pretyping/typing.cmi contrib/interface/translate.cmi kernel/term.cmi \ + kernel/sign.cmi contrib/interface/showproof_ct.cmo kernel/reduction.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi parsing/printer.cmi \ + lib/pp.cmi proofs/pfedit.cmi kernel/names.cmi kernel/inductive.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/declarations.cmi \ + parsing/coqast.cmi proofs/clenv.cmi contrib/interface/ascent.cmi +contrib/interface/translate.cmi: kernel/term.cmi proofs/proof_type.cmi \ + pretyping/evd.cmi kernel/environ.cmi contrib/interface/ascent.cmi contrib/interface/vtp.cmi: contrib/interface/ascent.cmi -contrib/interface/xlate.cmi: contrib/interface/ascent.cmi kernel/names.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi toplevel/vernacexpr.cmo -contrib/jprover/jall.cmi: contrib/jprover/jlogic.cmi \ - contrib/jprover/jterm.cmi contrib/jprover/opname.cmi +contrib/interface/xlate.cmi: toplevel/vernacexpr.cmo interp/topconstr.cmi \ + proofs/tacexpr.cmo kernel/names.cmi contrib/interface/ascent.cmi +contrib/jprover/jall.cmi: contrib/jprover/opname.cmi \ + contrib/jprover/jterm.cmi contrib/jprover/jlogic.cmi contrib/jprover/jlogic.cmi: contrib/jprover/jterm.cmi contrib/jprover/jterm.cmi: contrib/jprover/opname.cmi -contrib/xml/doubleTypeInference.cmi: contrib/xml/acic.cmo kernel/environ.cmi \ - pretyping/evd.cmi kernel/names.cmi kernel/term.cmi -contrib/xml/xmlcommand.cmi: contrib/xml/acic.cmo pretyping/evd.cmi \ - library/libnames.cmi contrib/xml/proof2aproof.cmo proofs/proof_type.cmi \ - kernel/term.cmi contrib/xml/xml.cmi +contrib/xml/doubleTypeInference.cmi: kernel/term.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi contrib/xml/acic.cmo +contrib/xml/xmlcommand.cmi: contrib/xml/xml.cmi kernel/term.cmi \ + proofs/proof_type.cmi contrib/xml/proof2aproof.cmo library/libnames.cmi \ + pretyping/evd.cmi contrib/xml/acic.cmo ide/utils/configwin.cmi: ide/utils/uoptions.cmi tools/coqdoc/output.cmi: tools/coqdoc/index.cmi tools/coqdoc/pretty.cmi: tools/coqdoc/index.cmi config/coq_config.cmo: config/coq_config.cmi config/coq_config.cmx: config/coq_config.cmi -dev/db_printers.cmo: kernel/names.cmi lib/pp.cmi -dev/db_printers.cmx: kernel/names.cmx lib/pp.cmx -dev/top_printers.cmo: parsing/ast.cmi toplevel/cerrors.cmi proofs/clenv.cmi \ - kernel/closure.cmi interp/constrextern.cmi kernel/declarations.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/libnames.cmi \ - library/libobject.cmi library/nameops.cmi kernel/names.cmi lib/pp.cmi \ - parsing/pptactic.cmi parsing/printer.cmi proofs/proof_trees.cmi \ - proofs/refiner.cmi kernel/sign.cmi lib/system.cmi proofs/tacmach.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/univ.cmi -dev/top_printers.cmx: parsing/ast.cmx toplevel/cerrors.cmx proofs/clenv.cmx \ - kernel/closure.cmx interp/constrextern.cmx kernel/declarations.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/libnames.cmx \ - library/libobject.cmx library/nameops.cmx kernel/names.cmx lib/pp.cmx \ - parsing/pptactic.cmx parsing/printer.cmx proofs/proof_trees.cmx \ - proofs/refiner.cmx kernel/sign.cmx lib/system.cmx proofs/tacmach.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/univ.cmx +dev/db_printers.cmo: lib/pp.cmi kernel/names.cmi +dev/db_printers.cmx: lib/pp.cmx kernel/names.cmx +dev/top_printers.cmo: kernel/univ.cmi pretyping/termops.cmi kernel/term.cmi \ + proofs/tacmach.cmi lib/system.cmi kernel/sign.cmi proofs/refiner.cmi \ + proofs/proof_trees.cmi parsing/printer.cmi parsing/pptactic.cmi \ + lib/pp.cmi kernel/names.cmi library/nameops.cmi library/libobject.cmi \ + library/libnames.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi interp/constrintern.cmi interp/constrextern.cmi \ + kernel/closure.cmi proofs/clenv.cmi toplevel/cerrors.cmi parsing/ast.cmi +dev/top_printers.cmx: kernel/univ.cmx pretyping/termops.cmx kernel/term.cmx \ + proofs/tacmach.cmx lib/system.cmx kernel/sign.cmx proofs/refiner.cmx \ + proofs/proof_trees.cmx parsing/printer.cmx parsing/pptactic.cmx \ + lib/pp.cmx kernel/names.cmx library/nameops.cmx library/libobject.cmx \ + library/libnames.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx interp/constrintern.cmx interp/constrextern.cmx \ + kernel/closure.cmx proofs/clenv.cmx toplevel/cerrors.cmx parsing/ast.cmx doc/parse.cmo: parsing/ast.cmi doc/parse.cmx: parsing/ast.cmx -ide/blaster_window.cmo: ide/coq.cmi ide/ideutils.cmi -ide/blaster_window.cmx: ide/coq.cmx ide/ideutils.cmx -ide/command_windows.cmo: ide/coq.cmi ide/coq_commands.cmo ide/ideutils.cmi \ +ide/blaster_window.cmo: ide/ideutils.cmi ide/coq.cmi +ide/blaster_window.cmx: ide/ideutils.cmx ide/coq.cmx +ide/command_windows.cmo: ide/ideutils.cmi ide/coq_commands.cmo ide/coq.cmi \ ide/command_windows.cmi -ide/command_windows.cmx: ide/coq.cmx ide/coq_commands.cmx ide/ideutils.cmx \ +ide/command_windows.cmx: ide/ideutils.cmx ide/coq_commands.cmx ide/coq.cmx \ ide/command_windows.cmi -ide/config_lexer.cmo: ide/config_parser.cmi lib/util.cmi -ide/config_lexer.cmx: ide/config_parser.cmx lib/util.cmx +ide/config_lexer.cmo: lib/util.cmi ide/config_parser.cmi +ide/config_lexer.cmx: lib/util.cmx ide/config_parser.cmx ide/config_parser.cmo: lib/util.cmi ide/config_parser.cmi ide/config_parser.cmx: lib/util.cmx ide/config_parser.cmi -ide/coqide.cmo: ide/blaster_window.cmo ide/command_windows.cmi ide/coq.cmi \ - ide/coq_commands.cmo ide/find_phrase.cmo ide/highlight.cmo \ - ide/ideutils.cmi proofs/pfedit.cmi ide/preferences.cmi lib/system.cmi \ - ide/undo.cmi lib/util.cmi toplevel/vernacexpr.cmo ide/coqide.cmi -ide/coqide.cmx: ide/blaster_window.cmx ide/command_windows.cmx ide/coq.cmx \ - ide/coq_commands.cmx ide/find_phrase.cmx ide/highlight.cmx \ - ide/ideutils.cmx proofs/pfedit.cmx ide/preferences.cmx lib/system.cmx \ - ide/undo.cmx lib/util.cmx toplevel/vernacexpr.cmx ide/coqide.cmi -ide/coq.cmo: toplevel/cerrors.cmi config/coq_config.cmi toplevel/coqtop.cmi \ - kernel/declarations.cmi kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/evd.cmi library/global.cmi tactics/hipattern.cmi \ - ide/ideutils.cmi library/lib.cmi library/libnames.cmi library/library.cmi \ - toplevel/mltop.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - parsing/pcoq.cmi proofs/pfedit.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_trees.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - library/states.cmi tactics/tacinterp.cmi proofs/tacmach.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi toplevel/vernac.cmi \ - toplevel/vernacentries.cmi toplevel/vernacexpr.cmo ide/coq.cmi -ide/coq.cmx: toplevel/cerrors.cmx config/coq_config.cmx toplevel/coqtop.cmx \ - kernel/declarations.cmx kernel/environ.cmx pretyping/evarutil.cmx \ - pretyping/evd.cmx library/global.cmx tactics/hipattern.cmx \ - ide/ideutils.cmx library/lib.cmx library/libnames.cmx library/library.cmx \ - toplevel/mltop.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - parsing/pcoq.cmx proofs/pfedit.cmx lib/pp.cmx parsing/printer.cmx \ - proofs/proof_trees.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - library/states.cmx tactics/tacinterp.cmx proofs/tacmach.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx toplevel/vernac.cmx \ - toplevel/vernacentries.cmx toplevel/vernacexpr.cmx ide/coq.cmi +ide/coq.cmo: toplevel/vernacexpr.cmo toplevel/vernacentries.cmi \ + toplevel/vernac.cmi lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + proofs/tacmach.cmi tactics/tacinterp.cmi library/states.cmi \ + proofs/refiner.cmi pretyping/reductionops.cmi proofs/proof_trees.cmi \ + parsing/printer.cmi lib/pp.cmi proofs/pfedit.cmi parsing/pcoq.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi toplevel/mltop.cmi \ + library/library.cmi library/libnames.cmi library/lib.cmi ide/ideutils.cmi \ + tactics/hipattern.cmi library/global.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi kernel/declarations.cmi \ + toplevel/coqtop.cmi config/coq_config.cmi toplevel/cerrors.cmi \ + ide/coq.cmi +ide/coq.cmx: toplevel/vernacexpr.cmx toplevel/vernacentries.cmx \ + toplevel/vernac.cmx lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + proofs/tacmach.cmx tactics/tacinterp.cmx library/states.cmx \ + proofs/refiner.cmx pretyping/reductionops.cmx proofs/proof_trees.cmx \ + parsing/printer.cmx lib/pp.cmx proofs/pfedit.cmx parsing/pcoq.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx toplevel/mltop.cmx \ + library/library.cmx library/libnames.cmx library/lib.cmx ide/ideutils.cmx \ + tactics/hipattern.cmx library/global.cmx pretyping/evd.cmx \ + pretyping/evarutil.cmx kernel/environ.cmx kernel/declarations.cmx \ + toplevel/coqtop.cmx config/coq_config.cmx toplevel/cerrors.cmx \ + ide/coq.cmi ide/coq_tactics.cmo: ide/coq_tactics.cmi ide/coq_tactics.cmx: ide/coq_tactics.cmi +ide/coqide.cmo: toplevel/vernacexpr.cmo lib/util.cmi ide/undo.cmi \ + lib/system.cmi ide/preferences.cmi proofs/pfedit.cmi ide/ideutils.cmi \ + ide/highlight.cmo ide/find_phrase.cmo ide/coq_commands.cmo ide/coq.cmi \ + ide/command_windows.cmi ide/blaster_window.cmo ide/coqide.cmi +ide/coqide.cmx: toplevel/vernacexpr.cmx lib/util.cmx ide/undo.cmx \ + lib/system.cmx ide/preferences.cmx proofs/pfedit.cmx ide/ideutils.cmx \ + ide/highlight.cmx ide/find_phrase.cmx ide/coq_commands.cmx ide/coq.cmx \ + ide/command_windows.cmx ide/blaster_window.cmx ide/coqide.cmi ide/find_phrase.cmo: ide/ideutils.cmi ide/find_phrase.cmx: ide/ideutils.cmx ide/highlight.cmo: ide/ideutils.cmi ide/highlight.cmx: ide/ideutils.cmx -ide/ideutils.cmo: config/coq_config.cmi lib/options.cmi lib/pp_control.cmi \ - ide/preferences.cmi ide/utf8_convert.cmo ide/ideutils.cmi -ide/ideutils.cmx: config/coq_config.cmx lib/options.cmx lib/pp_control.cmx \ - ide/preferences.cmx ide/utf8_convert.cmx ide/ideutils.cmi -ide/preferences.cmo: ide/config_lexer.cmo ide/utils/configwin.cmi \ - lib/system.cmi lib/util.cmi ide/preferences.cmi -ide/preferences.cmx: ide/config_lexer.cmx ide/utils/configwin.cmx \ - lib/system.cmx lib/util.cmx ide/preferences.cmi +ide/ideutils.cmo: ide/utf8_convert.cmo ide/preferences.cmi lib/pp_control.cmi \ + lib/options.cmi config/coq_config.cmi ide/ideutils.cmi +ide/ideutils.cmx: ide/utf8_convert.cmx ide/preferences.cmx lib/pp_control.cmx \ + lib/options.cmx config/coq_config.cmx ide/ideutils.cmi +ide/preferences.cmo: lib/util.cmi lib/system.cmi ide/utils/configwin.cmi \ + ide/config_lexer.cmo ide/preferences.cmi +ide/preferences.cmx: lib/util.cmx lib/system.cmx ide/utils/configwin.cmx \ + ide/config_lexer.cmx ide/preferences.cmi ide/undo.cmo: ide/ideutils.cmi ide/undo.cmi ide/undo.cmx: ide/ideutils.cmx ide/undo.cmi -interp/constrextern.cmo: lib/bignat.cmi pretyping/classops.cmi \ - kernel/declarations.cmi pretyping/detyping.cmi kernel/environ.cmi \ - library/global.cmi library/impargs.cmi kernel/inductive.cmi \ - library/lib.cmi library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - pretyping/rawterm.cmi pretyping/recordops.cmi interp/reserve.cmi \ - kernel/sign.cmi interp/symbols.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi kernel/univ.cmi lib/util.cmi interp/constrextern.cmi -interp/constrextern.cmx: lib/bignat.cmx pretyping/classops.cmx \ - kernel/declarations.cmx pretyping/detyping.cmx kernel/environ.cmx \ - library/global.cmx library/impargs.cmx kernel/inductive.cmx \ - library/lib.cmx library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - pretyping/rawterm.cmx pretyping/recordops.cmx interp/reserve.cmx \ - kernel/sign.cmx interp/symbols.cmx kernel/term.cmx pretyping/termops.cmx \ - interp/topconstr.cmx kernel/univ.cmx lib/util.cmx interp/constrextern.cmi -interp/constrintern.cmo: lib/bignat.cmi kernel/declarations.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi \ - library/impargs.cmi kernel/inductive.cmi parsing/lexer.cmi \ - library/lib.cmi library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi pretyping/pretyping.cmi \ - pretyping/rawterm.cmi pretyping/recordops.cmi interp/reserve.cmi \ - pretyping/retyping.cmi kernel/sign.cmi interp/symbols.cmi \ - interp/syntax_def.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi lib/util.cmi interp/constrintern.cmi -interp/constrintern.cmx: lib/bignat.cmx kernel/declarations.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx \ - library/impargs.cmx kernel/inductive.cmx parsing/lexer.cmx \ - library/lib.cmx library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx pretyping/pretyping.cmx \ - pretyping/rawterm.cmx pretyping/recordops.cmx interp/reserve.cmx \ - pretyping/retyping.cmx kernel/sign.cmx interp/symbols.cmx \ - interp/syntax_def.cmx kernel/term.cmx pretyping/termops.cmx \ - interp/topconstr.cmx lib/util.cmx interp/constrintern.cmi -interp/coqlib.cmo: interp/constrextern.cmi library/libnames.cmi \ - kernel/names.cmi library/nametab.cmi lib/options.cmi \ - pretyping/pattern.cmi lib/pp.cmi kernel/term.cmi lib/util.cmi \ +interp/constrextern.cmo: lib/util.cmi kernel/univ.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi interp/symbols.cmi kernel/sign.cmi \ + interp/reserve.cmi pretyping/recordops.cmi pretyping/rawterm.cmi \ + lib/pp.cmi pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi library/lib.cmi \ + kernel/inductive.cmi library/impargs.cmi library/global.cmi \ + kernel/environ.cmi pretyping/detyping.cmi kernel/declarations.cmi \ + pretyping/classops.cmi lib/bignat.cmi interp/constrextern.cmi +interp/constrextern.cmx: lib/util.cmx kernel/univ.cmx interp/topconstr.cmx \ + pretyping/termops.cmx kernel/term.cmx interp/symbols.cmx kernel/sign.cmx \ + interp/reserve.cmx pretyping/recordops.cmx pretyping/rawterm.cmx \ + lib/pp.cmx pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx library/lib.cmx \ + kernel/inductive.cmx library/impargs.cmx library/global.cmx \ + kernel/environ.cmx pretyping/detyping.cmx kernel/declarations.cmx \ + pretyping/classops.cmx lib/bignat.cmx interp/constrextern.cmi +interp/constrintern.cmo: lib/util.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi interp/syntax_def.cmi \ + interp/symbols.cmi kernel/sign.cmi pretyping/retyping.cmi \ + interp/reserve.cmi pretyping/recordops.cmi pretyping/rawterm.cmi \ + pretyping/pretyping.cmi pretyping/pretype_errors.cmi lib/pp.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi library/lib.cmi \ + parsing/lexer.cmi kernel/inductive.cmi library/impargs.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi lib/bignat.cmi interp/constrintern.cmi +interp/constrintern.cmx: lib/util.cmx interp/topconstr.cmx \ + pretyping/termops.cmx kernel/term.cmx interp/syntax_def.cmx \ + interp/symbols.cmx kernel/sign.cmx pretyping/retyping.cmx \ + interp/reserve.cmx pretyping/recordops.cmx pretyping/rawterm.cmx \ + pretyping/pretyping.cmx pretyping/pretype_errors.cmx lib/pp.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx library/lib.cmx \ + parsing/lexer.cmx kernel/inductive.cmx library/impargs.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx lib/bignat.cmx interp/constrintern.cmi +interp/coqlib.cmo: lib/util.cmi kernel/term.cmi lib/pp.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi interp/constrextern.cmi \ interp/coqlib.cmi -interp/coqlib.cmx: interp/constrextern.cmx library/libnames.cmx \ - kernel/names.cmx library/nametab.cmx lib/options.cmx \ - pretyping/pattern.cmx lib/pp.cmx kernel/term.cmx lib/util.cmx \ +interp/coqlib.cmx: lib/util.cmx kernel/term.cmx lib/pp.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx interp/constrextern.cmx \ interp/coqlib.cmi -interp/genarg.cmo: pretyping/evd.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi pretyping/rawterm.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi interp/genarg.cmi -interp/genarg.cmx: pretyping/evd.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx pretyping/rawterm.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx interp/genarg.cmi -interp/modintern.cmo: interp/constrintern.cmi kernel/entries.cmi \ - pretyping/evd.cmi library/libnames.cmi kernel/modops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi interp/topconstr.cmi lib/util.cmi \ - interp/modintern.cmi -interp/modintern.cmx: interp/constrintern.cmx kernel/entries.cmx \ - pretyping/evd.cmx library/libnames.cmx kernel/modops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx interp/topconstr.cmx lib/util.cmx \ - interp/modintern.cmi -interp/ppextend.cmo: kernel/names.cmi lib/pp.cmi lib/util.cmi \ +interp/genarg.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi lib/pp.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi pretyping/evd.cmi interp/genarg.cmi +interp/genarg.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + pretyping/rawterm.cmx lib/pp.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx pretyping/evd.cmx interp/genarg.cmi +interp/modintern.cmo: lib/util.cmi interp/topconstr.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi kernel/modops.cmi \ + library/libnames.cmi pretyping/evd.cmi kernel/entries.cmi \ + interp/constrintern.cmi interp/modintern.cmi +interp/modintern.cmx: lib/util.cmx interp/topconstr.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx kernel/modops.cmx \ + library/libnames.cmx pretyping/evd.cmx kernel/entries.cmx \ + interp/constrintern.cmx interp/modintern.cmi +interp/ppextend.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi \ interp/ppextend.cmi -interp/ppextend.cmx: kernel/names.cmx lib/pp.cmx lib/util.cmx \ +interp/ppextend.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx \ interp/ppextend.cmi -interp/reserve.cmo: library/lib.cmi library/libobject.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi pretyping/rawterm.cmi \ - library/summary.cmi lib/util.cmi interp/reserve.cmi -interp/reserve.cmx: library/lib.cmx library/libobject.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx pretyping/rawterm.cmx \ - library/summary.cmx lib/util.cmx interp/reserve.cmi -interp/symbols.cmo: lib/bignat.cmi pretyping/classops.cmi library/global.cmi \ - lib/gmap.cmi lib/gmapl.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi kernel/names.cmi library/nametab.cmi \ - lib/options.cmi lib/pp.cmi interp/ppextend.cmi pretyping/rawterm.cmi \ - pretyping/reductionops.cmi library/summary.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi interp/symbols.cmi -interp/symbols.cmx: lib/bignat.cmx pretyping/classops.cmx library/global.cmx \ - lib/gmap.cmx lib/gmapl.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx kernel/names.cmx library/nametab.cmx \ - lib/options.cmx lib/pp.cmx interp/ppextend.cmx pretyping/rawterm.cmx \ - pretyping/reductionops.cmx library/summary.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx interp/symbols.cmi -interp/syntax_def.cmo: library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi library/summary.cmi interp/symbols.cmi \ - interp/topconstr.cmi lib/util.cmi interp/syntax_def.cmi -interp/syntax_def.cmx: library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx library/summary.cmx interp/symbols.cmx \ - interp/topconstr.cmx lib/util.cmx interp/syntax_def.cmi -interp/topconstr.cmo: lib/bignat.cmi lib/dyn.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi lib/options.cmi lib/pp.cmi \ - pretyping/rawterm.cmi kernel/term.cmi lib/util.cmi interp/topconstr.cmi -interp/topconstr.cmx: lib/bignat.cmx lib/dyn.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx lib/options.cmx lib/pp.cmx \ - pretyping/rawterm.cmx kernel/term.cmx lib/util.cmx interp/topconstr.cmi -kernel/closure.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/esubst.cmi kernel/names.cmi lib/pp.cmi kernel/term.cmi \ - lib/util.cmi kernel/closure.cmi -kernel/closure.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/esubst.cmx kernel/names.cmx lib/pp.cmx kernel/term.cmx \ - lib/util.cmx kernel/closure.cmi -kernel/conv_oracle.cmo: kernel/closure.cmi kernel/names.cmi \ +interp/reserve.cmo: lib/util.cmi library/summary.cmi pretyping/rawterm.cmi \ + lib/pp.cmi lib/options.cmi kernel/names.cmi library/nameops.cmi \ + library/libobject.cmi library/lib.cmi interp/reserve.cmi +interp/reserve.cmx: lib/util.cmx library/summary.cmx pretyping/rawterm.cmx \ + lib/pp.cmx lib/options.cmx kernel/names.cmx library/nameops.cmx \ + library/libobject.cmx library/lib.cmx interp/reserve.cmi +interp/symbols.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + library/summary.cmi pretyping/reductionops.cmi pretyping/rawterm.cmi \ + interp/ppextend.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi lib/gmapl.cmi lib/gmap.cmi library/global.cmi \ + pretyping/classops.cmi lib/bignat.cmi interp/symbols.cmi +interp/symbols.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + library/summary.cmx pretyping/reductionops.cmx pretyping/rawterm.cmx \ + interp/ppextend.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx lib/gmapl.cmx lib/gmap.cmx library/global.cmx \ + pretyping/classops.cmx lib/bignat.cmx interp/symbols.cmi +interp/syntax_def.cmo: lib/util.cmi interp/topconstr.cmi interp/symbols.cmi \ + library/summary.cmi lib/pp.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi interp/syntax_def.cmi +interp/syntax_def.cmx: lib/util.cmx interp/topconstr.cmx interp/symbols.cmx \ + library/summary.cmx lib/pp.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx interp/syntax_def.cmi +interp/topconstr.cmo: lib/util.cmi kernel/term.cmi pretyping/rawterm.cmi \ + lib/pp.cmi lib/options.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi lib/dyn.cmi lib/bignat.cmi interp/topconstr.cmi +interp/topconstr.cmx: lib/util.cmx kernel/term.cmx pretyping/rawterm.cmx \ + lib/pp.cmx lib/options.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx lib/dyn.cmx lib/bignat.cmx interp/topconstr.cmi +kernel/closure.cmo: lib/util.cmi kernel/term.cmi lib/pp.cmi kernel/names.cmi \ + kernel/esubst.cmi kernel/environ.cmi kernel/declarations.cmi \ + kernel/closure.cmi +kernel/closure.cmx: lib/util.cmx kernel/term.cmx lib/pp.cmx kernel/names.cmx \ + kernel/esubst.cmx kernel/environ.cmx kernel/declarations.cmx \ + kernel/closure.cmi +kernel/conv_oracle.cmo: kernel/names.cmi kernel/closure.cmi \ kernel/conv_oracle.cmi -kernel/conv_oracle.cmx: kernel/closure.cmx kernel/names.cmx \ +kernel/conv_oracle.cmx: kernel/names.cmx kernel/closure.cmx \ kernel/conv_oracle.cmi -kernel/cooking.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/names.cmi lib/pp.cmi kernel/reduction.cmi kernel/sign.cmi \ - kernel/term.cmi lib/util.cmi kernel/cooking.cmi -kernel/cooking.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/names.cmx lib/pp.cmx kernel/reduction.cmx kernel/sign.cmx \ - kernel/term.cmx lib/util.cmx kernel/cooking.cmi -kernel/declarations.cmo: kernel/names.cmi lib/rtree.cmi kernel/sign.cmi \ - kernel/term.cmi kernel/univ.cmi lib/util.cmi kernel/declarations.cmi -kernel/declarations.cmx: kernel/names.cmx lib/rtree.cmx kernel/sign.cmx \ - kernel/term.cmx kernel/univ.cmx lib/util.cmx kernel/declarations.cmi -kernel/entries.cmo: kernel/names.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi kernel/entries.cmi -kernel/entries.cmx: kernel/names.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/univ.cmx kernel/entries.cmi -kernel/environ.cmo: kernel/declarations.cmi kernel/names.cmi kernel/sign.cmi \ - kernel/term.cmi kernel/univ.cmi lib/util.cmi kernel/environ.cmi -kernel/environ.cmx: kernel/declarations.cmx kernel/names.cmx kernel/sign.cmx \ - kernel/term.cmx kernel/univ.cmx lib/util.cmx kernel/environ.cmi +kernel/cooking.cmo: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/reduction.cmi lib/pp.cmi kernel/names.cmi kernel/environ.cmi \ + kernel/declarations.cmi kernel/cooking.cmi +kernel/cooking.cmx: lib/util.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/reduction.cmx lib/pp.cmx kernel/names.cmx kernel/environ.cmx \ + kernel/declarations.cmx kernel/cooking.cmi +kernel/declarations.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi lib/rtree.cmi kernel/names.cmi kernel/declarations.cmi +kernel/declarations.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx lib/rtree.cmx kernel/names.cmx kernel/declarations.cmi +kernel/entries.cmo: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi kernel/entries.cmi +kernel/entries.cmx: kernel/univ.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/names.cmx kernel/entries.cmi +kernel/environ.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/names.cmi kernel/declarations.cmi \ + kernel/environ.cmi +kernel/environ.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx kernel/names.cmx kernel/declarations.cmx \ + kernel/environ.cmi kernel/esubst.cmo: lib/util.cmi kernel/esubst.cmi kernel/esubst.cmx: lib/util.cmx kernel/esubst.cmi -kernel/indtypes.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/inductive.cmi kernel/names.cmi \ - kernel/reduction.cmi lib/rtree.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/typeops.cmi kernel/univ.cmi lib/util.cmi kernel/indtypes.cmi -kernel/indtypes.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx kernel/inductive.cmx kernel/names.cmx \ - kernel/reduction.cmx lib/rtree.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/typeops.cmx kernel/univ.cmx lib/util.cmx kernel/indtypes.cmi -kernel/inductive.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/names.cmi kernel/reduction.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/type_errors.cmi kernel/univ.cmi lib/util.cmi kernel/inductive.cmi -kernel/inductive.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/names.cmx kernel/reduction.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/type_errors.cmx kernel/univ.cmx lib/util.cmx kernel/inductive.cmi -kernel/modops.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/names.cmi lib/pp.cmi kernel/term.cmi \ - kernel/univ.cmi lib/util.cmi kernel/modops.cmi -kernel/modops.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx kernel/names.cmx lib/pp.cmx kernel/term.cmx \ - kernel/univ.cmx lib/util.cmx kernel/modops.cmi -kernel/mod_typing.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/modops.cmi kernel/names.cmi \ - kernel/reduction.cmi kernel/subtyping.cmi kernel/term_typing.cmi \ - kernel/typeops.cmi kernel/univ.cmi lib/util.cmi kernel/mod_typing.cmi -kernel/mod_typing.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx kernel/modops.cmx kernel/names.cmx \ - kernel/reduction.cmx kernel/subtyping.cmx kernel/term_typing.cmx \ - kernel/typeops.cmx kernel/univ.cmx lib/util.cmx kernel/mod_typing.cmi -kernel/names.cmo: lib/hashcons.cmi lib/options.cmi lib/pp.cmi \ - lib/predicate.cmi lib/util.cmi kernel/names.cmi -kernel/names.cmx: lib/hashcons.cmx lib/options.cmx lib/pp.cmx \ - lib/predicate.cmx lib/util.cmx kernel/names.cmi -kernel/reduction.cmo: kernel/closure.cmi kernel/conv_oracle.cmi \ - kernel/declarations.cmi kernel/environ.cmi kernel/esubst.cmi \ - kernel/names.cmi kernel/sign.cmi kernel/term.cmi kernel/univ.cmi \ - lib/util.cmi kernel/reduction.cmi -kernel/reduction.cmx: kernel/closure.cmx kernel/conv_oracle.cmx \ - kernel/declarations.cmx kernel/environ.cmx kernel/esubst.cmx \ - kernel/names.cmx kernel/sign.cmx kernel/term.cmx kernel/univ.cmx \ - lib/util.cmx kernel/reduction.cmi -kernel/safe_typing.cmo: kernel/cooking.cmi kernel/declarations.cmi \ - kernel/entries.cmi kernel/environ.cmi kernel/indtypes.cmi \ - kernel/inductive.cmi kernel/mod_typing.cmi kernel/modops.cmi \ - kernel/names.cmi kernel/reduction.cmi kernel/sign.cmi \ - kernel/subtyping.cmi kernel/term.cmi kernel/term_typing.cmi \ - kernel/type_errors.cmi kernel/typeops.cmi kernel/univ.cmi lib/util.cmi \ +kernel/indtypes.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/term.cmi kernel/sign.cmi lib/rtree.cmi kernel/reduction.cmi \ + kernel/names.cmi kernel/inductive.cmi kernel/environ.cmi \ + kernel/entries.cmi kernel/declarations.cmi kernel/indtypes.cmi +kernel/indtypes.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/term.cmx kernel/sign.cmx lib/rtree.cmx kernel/reduction.cmx \ + kernel/names.cmx kernel/inductive.cmx kernel/environ.cmx \ + kernel/entries.cmx kernel/declarations.cmx kernel/indtypes.cmi +kernel/inductive.cmo: lib/util.cmi kernel/univ.cmi kernel/type_errors.cmi \ + kernel/term.cmi kernel/sign.cmi kernel/reduction.cmi kernel/names.cmi \ + kernel/environ.cmi kernel/declarations.cmi kernel/inductive.cmi +kernel/inductive.cmx: lib/util.cmx kernel/univ.cmx kernel/type_errors.cmx \ + kernel/term.cmx kernel/sign.cmx kernel/reduction.cmx kernel/names.cmx \ + kernel/environ.cmx kernel/declarations.cmx kernel/inductive.cmi +kernel/mod_typing.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/term_typing.cmi kernel/subtyping.cmi kernel/reduction.cmi \ + kernel/names.cmi kernel/modops.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi kernel/mod_typing.cmi +kernel/mod_typing.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/term_typing.cmx kernel/subtyping.cmx kernel/reduction.cmx \ + kernel/names.cmx kernel/modops.cmx kernel/environ.cmx kernel/entries.cmx \ + kernel/declarations.cmx kernel/mod_typing.cmi +kernel/modops.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi lib/pp.cmi \ + kernel/names.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi kernel/modops.cmi +kernel/modops.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx lib/pp.cmx \ + kernel/names.cmx kernel/environ.cmx kernel/entries.cmx \ + kernel/declarations.cmx kernel/modops.cmi +kernel/names.cmo: lib/util.cmi lib/predicate.cmi lib/pp.cmi lib/options.cmi \ + lib/hashcons.cmi kernel/names.cmi +kernel/names.cmx: lib/util.cmx lib/predicate.cmx lib/pp.cmx lib/options.cmx \ + lib/hashcons.cmx kernel/names.cmi +kernel/reduction.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/names.cmi kernel/esubst.cmi kernel/environ.cmi \ + kernel/declarations.cmi kernel/conv_oracle.cmi kernel/closure.cmi \ + kernel/reduction.cmi +kernel/reduction.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx kernel/names.cmx kernel/esubst.cmx kernel/environ.cmx \ + kernel/declarations.cmx kernel/conv_oracle.cmx kernel/closure.cmx \ + kernel/reduction.cmi +kernel/safe_typing.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/type_errors.cmi kernel/term_typing.cmi kernel/term.cmi \ + kernel/subtyping.cmi kernel/sign.cmi kernel/reduction.cmi \ + kernel/names.cmi kernel/modops.cmi kernel/mod_typing.cmi \ + kernel/inductive.cmi kernel/indtypes.cmi kernel/environ.cmi \ + kernel/entries.cmi kernel/declarations.cmi kernel/cooking.cmi \ kernel/safe_typing.cmi -kernel/safe_typing.cmx: kernel/cooking.cmx kernel/declarations.cmx \ - kernel/entries.cmx kernel/environ.cmx kernel/indtypes.cmx \ - kernel/inductive.cmx kernel/mod_typing.cmx kernel/modops.cmx \ - kernel/names.cmx kernel/reduction.cmx kernel/sign.cmx \ - kernel/subtyping.cmx kernel/term.cmx kernel/term_typing.cmx \ - kernel/type_errors.cmx kernel/typeops.cmx kernel/univ.cmx lib/util.cmx \ +kernel/safe_typing.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/type_errors.cmx kernel/term_typing.cmx kernel/term.cmx \ + kernel/subtyping.cmx kernel/sign.cmx kernel/reduction.cmx \ + kernel/names.cmx kernel/modops.cmx kernel/mod_typing.cmx \ + kernel/inductive.cmx kernel/indtypes.cmx kernel/environ.cmx \ + kernel/entries.cmx kernel/declarations.cmx kernel/cooking.cmx \ kernel/safe_typing.cmi -kernel/sign.cmo: kernel/names.cmi kernel/term.cmi lib/util.cmi \ +kernel/sign.cmo: lib/util.cmi kernel/term.cmi kernel/names.cmi \ kernel/sign.cmi -kernel/sign.cmx: kernel/names.cmx kernel/term.cmx lib/util.cmx \ +kernel/sign.cmx: lib/util.cmx kernel/term.cmx kernel/names.cmx \ kernel/sign.cmi -kernel/subtyping.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/inductive.cmi kernel/modops.cmi kernel/names.cmi \ - kernel/reduction.cmi kernel/term.cmi kernel/univ.cmi lib/util.cmi \ +kernel/subtyping.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/reduction.cmi kernel/names.cmi kernel/modops.cmi \ + kernel/inductive.cmi kernel/environ.cmi kernel/declarations.cmi \ kernel/subtyping.cmi -kernel/subtyping.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/inductive.cmx kernel/modops.cmx kernel/names.cmx \ - kernel/reduction.cmx kernel/term.cmx kernel/univ.cmx lib/util.cmx \ +kernel/subtyping.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/reduction.cmx kernel/names.cmx kernel/modops.cmx \ + kernel/inductive.cmx kernel/environ.cmx kernel/declarations.cmx \ kernel/subtyping.cmi -kernel/term.cmo: kernel/esubst.cmi lib/hashcons.cmi kernel/names.cmi \ - lib/pp.cmi kernel/univ.cmi lib/util.cmi kernel/term.cmi -kernel/term.cmx: kernel/esubst.cmx lib/hashcons.cmx kernel/names.cmx \ - lib/pp.cmx kernel/univ.cmx lib/util.cmx kernel/term.cmi -kernel/term_typing.cmo: kernel/cooking.cmi kernel/declarations.cmi \ - kernel/entries.cmi kernel/environ.cmi kernel/indtypes.cmi \ - kernel/inductive.cmi kernel/names.cmi kernel/reduction.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/type_errors.cmi kernel/typeops.cmi \ - kernel/univ.cmi lib/util.cmi kernel/term_typing.cmi -kernel/term_typing.cmx: kernel/cooking.cmx kernel/declarations.cmx \ - kernel/entries.cmx kernel/environ.cmx kernel/indtypes.cmx \ - kernel/inductive.cmx kernel/names.cmx kernel/reduction.cmx \ - kernel/sign.cmx kernel/term.cmx kernel/type_errors.cmx kernel/typeops.cmx \ - kernel/univ.cmx lib/util.cmx kernel/term_typing.cmi -kernel/type_errors.cmo: kernel/environ.cmi kernel/names.cmi \ - kernel/reduction.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/type_errors.cmi -kernel/type_errors.cmx: kernel/environ.cmx kernel/names.cmx \ - kernel/reduction.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/type_errors.cmi -kernel/typeops.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/inductive.cmi kernel/names.cmi \ - kernel/reduction.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/type_errors.cmi kernel/univ.cmi lib/util.cmi kernel/typeops.cmi -kernel/typeops.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx kernel/inductive.cmx kernel/names.cmx \ - kernel/reduction.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/type_errors.cmx kernel/univ.cmx lib/util.cmx kernel/typeops.cmi -kernel/univ.cmo: lib/hashcons.cmi kernel/names.cmi lib/pp.cmi lib/util.cmi \ +kernel/term.cmo: lib/util.cmi kernel/univ.cmi lib/pp.cmi kernel/names.cmi \ + lib/hashcons.cmi kernel/esubst.cmi kernel/term.cmi +kernel/term.cmx: lib/util.cmx kernel/univ.cmx lib/pp.cmx kernel/names.cmx \ + lib/hashcons.cmx kernel/esubst.cmx kernel/term.cmi +kernel/term_typing.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/type_errors.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/reduction.cmi kernel/names.cmi kernel/inductive.cmi \ + kernel/indtypes.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi kernel/cooking.cmi kernel/term_typing.cmi +kernel/term_typing.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/type_errors.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/reduction.cmx kernel/names.cmx kernel/inductive.cmx \ + kernel/indtypes.cmx kernel/environ.cmx kernel/entries.cmx \ + kernel/declarations.cmx kernel/cooking.cmx kernel/term_typing.cmi +kernel/type_errors.cmo: kernel/term.cmi kernel/sign.cmi kernel/reduction.cmi \ + kernel/names.cmi kernel/environ.cmi kernel/type_errors.cmi +kernel/type_errors.cmx: kernel/term.cmx kernel/sign.cmx kernel/reduction.cmx \ + kernel/names.cmx kernel/environ.cmx kernel/type_errors.cmi +kernel/typeops.cmo: lib/util.cmi kernel/univ.cmi kernel/type_errors.cmi \ + kernel/term.cmi kernel/sign.cmi kernel/reduction.cmi kernel/names.cmi \ + kernel/inductive.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi kernel/typeops.cmi +kernel/typeops.cmx: lib/util.cmx kernel/univ.cmx kernel/type_errors.cmx \ + kernel/term.cmx kernel/sign.cmx kernel/reduction.cmx kernel/names.cmx \ + kernel/inductive.cmx kernel/environ.cmx kernel/entries.cmx \ + kernel/declarations.cmx kernel/typeops.cmi +kernel/univ.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi lib/hashcons.cmi \ kernel/univ.cmi -kernel/univ.cmx: lib/hashcons.cmx kernel/names.cmx lib/pp.cmx lib/util.cmx \ +kernel/univ.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx lib/hashcons.cmx \ kernel/univ.cmi lib/bignat.cmo: lib/pp.cmi lib/bignat.cmi lib/bignat.cmx: lib/pp.cmx lib/bignat.cmi @@ -745,14 +746,14 @@ lib/bstack.cmo: lib/util.cmi lib/bstack.cmi lib/bstack.cmx: lib/util.cmx lib/bstack.cmi lib/dyn.cmo: lib/util.cmi lib/dyn.cmi lib/dyn.cmx: lib/util.cmx lib/dyn.cmi -lib/edit.cmo: lib/bstack.cmi lib/pp.cmi lib/util.cmi lib/edit.cmi -lib/edit.cmx: lib/bstack.cmx lib/pp.cmx lib/util.cmx lib/edit.cmi +lib/edit.cmo: lib/util.cmi lib/pp.cmi lib/bstack.cmi lib/edit.cmi +lib/edit.cmx: lib/util.cmx lib/pp.cmx lib/bstack.cmx lib/edit.cmi lib/explore.cmo: lib/explore.cmi lib/explore.cmx: lib/explore.cmi -lib/gmapl.cmo: lib/gmap.cmi lib/util.cmi lib/gmapl.cmi -lib/gmapl.cmx: lib/gmap.cmx lib/util.cmx lib/gmapl.cmi lib/gmap.cmo: lib/gmap.cmi lib/gmap.cmx: lib/gmap.cmi +lib/gmapl.cmo: lib/util.cmi lib/gmap.cmi lib/gmapl.cmi +lib/gmapl.cmx: lib/util.cmx lib/gmap.cmx lib/gmapl.cmi lib/gset.cmo: lib/gset.cmi lib/gset.cmx: lib/gset.cmi lib/hashcons.cmo: lib/hashcons.cmi @@ -761,2280 +762,2276 @@ lib/heap.cmo: lib/heap.cmi lib/heap.cmx: lib/heap.cmi lib/options.cmo: lib/util.cmi lib/options.cmi lib/options.cmx: lib/util.cmx lib/options.cmi -lib/pp_control.cmo: lib/pp_control.cmi -lib/pp_control.cmx: lib/pp_control.cmi lib/pp.cmo: lib/pp_control.cmi lib/pp.cmi lib/pp.cmx: lib/pp_control.cmx lib/pp.cmi +lib/pp_control.cmo: lib/pp_control.cmi +lib/pp_control.cmx: lib/pp_control.cmi lib/predicate.cmo: lib/predicate.cmi lib/predicate.cmx: lib/predicate.cmi lib/profile.cmo: lib/profile.cmi lib/profile.cmx: lib/profile.cmi -library/declare.cmo: library/decl_kinds.cmo kernel/declarations.cmi \ - library/dischargedhypsmap.cmi kernel/entries.cmi kernel/environ.cmi \ - library/global.cmi library/impargs.cmi kernel/indtypes.cmi \ - kernel/inductive.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi kernel/reduction.cmi \ - kernel/safe_typing.cmi kernel/sign.cmi library/summary.cmi \ - interp/symbols.cmi kernel/term.cmi kernel/type_errors.cmi \ - kernel/typeops.cmi kernel/univ.cmi lib/util.cmi library/declare.cmi -library/declare.cmx: library/decl_kinds.cmx kernel/declarations.cmx \ - library/dischargedhypsmap.cmx kernel/entries.cmx kernel/environ.cmx \ - library/global.cmx library/impargs.cmx kernel/indtypes.cmx \ - kernel/inductive.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx kernel/reduction.cmx \ - kernel/safe_typing.cmx kernel/sign.cmx library/summary.cmx \ - interp/symbols.cmx kernel/term.cmx kernel/type_errors.cmx \ - kernel/typeops.cmx kernel/univ.cmx lib/util.cmx library/declare.cmi -library/declaremods.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi library/global.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi kernel/mod_typing.cmi \ - kernel/modops.cmi kernel/names.cmi library/nametab.cmi lib/pp.cmi \ - kernel/subtyping.cmi library/summary.cmi lib/util.cmi \ +lib/rtree.cmo: lib/util.cmi lib/pp.cmi lib/rtree.cmi +lib/rtree.cmx: lib/util.cmx lib/pp.cmx lib/rtree.cmi +lib/stamps.cmo: lib/stamps.cmi +lib/stamps.cmx: lib/stamps.cmi +lib/system.cmo: lib/util.cmi lib/pp.cmi config/coq_config.cmi lib/system.cmi +lib/system.cmx: lib/util.cmx lib/pp.cmx config/coq_config.cmx lib/system.cmi +lib/tlm.cmo: lib/gset.cmi lib/gmap.cmi lib/tlm.cmi +lib/tlm.cmx: lib/gset.cmx lib/gmap.cmx lib/tlm.cmi +lib/util.cmo: lib/pp.cmi lib/compat.cmo lib/util.cmi +lib/util.cmx: lib/pp.cmx lib/compat.cmx lib/util.cmi +library/declare.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/type_errors.cmi kernel/term.cmi interp/symbols.cmi \ + library/summary.cmi kernel/sign.cmi kernel/safe_typing.cmi \ + kernel/reduction.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi kernel/inductive.cmi \ + kernel/indtypes.cmi library/impargs.cmi library/global.cmi \ + kernel/environ.cmi kernel/entries.cmi library/dischargedhypsmap.cmi \ + kernel/declarations.cmi library/decl_kinds.cmo library/declare.cmi +library/declare.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/type_errors.cmx kernel/term.cmx interp/symbols.cmx \ + library/summary.cmx kernel/sign.cmx kernel/safe_typing.cmx \ + kernel/reduction.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx kernel/inductive.cmx \ + kernel/indtypes.cmx library/impargs.cmx library/global.cmx \ + kernel/environ.cmx kernel/entries.cmx library/dischargedhypsmap.cmx \ + kernel/declarations.cmx library/decl_kinds.cmx library/declare.cmi +library/declaremods.cmo: lib/util.cmi library/summary.cmi \ + kernel/subtyping.cmi lib/pp.cmi library/nametab.cmi kernel/names.cmi \ + kernel/modops.cmi kernel/mod_typing.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi library/global.cmi \ + kernel/environ.cmi kernel/entries.cmi kernel/declarations.cmi \ library/declaremods.cmi -library/declaremods.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx library/global.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx kernel/mod_typing.cmx \ - kernel/modops.cmx kernel/names.cmx library/nametab.cmx lib/pp.cmx \ - kernel/subtyping.cmx library/summary.cmx lib/util.cmx \ +library/declaremods.cmx: lib/util.cmx library/summary.cmx \ + kernel/subtyping.cmx lib/pp.cmx library/nametab.cmx kernel/names.cmx \ + kernel/modops.cmx kernel/mod_typing.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx library/global.cmx \ + kernel/environ.cmx kernel/entries.cmx kernel/declarations.cmx \ library/declaremods.cmi -library/dischargedhypsmap.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/inductive.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi kernel/names.cmi library/nametab.cmi \ - kernel/reduction.cmi library/summary.cmi kernel/term.cmi lib/util.cmi \ - library/dischargedhypsmap.cmi -library/dischargedhypsmap.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/inductive.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx kernel/names.cmx library/nametab.cmx \ - kernel/reduction.cmx library/summary.cmx kernel/term.cmx lib/util.cmx \ - library/dischargedhypsmap.cmi -library/global.cmo: kernel/environ.cmi kernel/inductive.cmi \ - library/libnames.cmi kernel/names.cmi kernel/safe_typing.cmi \ - kernel/sign.cmi library/summary.cmi kernel/term.cmi lib/util.cmi \ +library/dischargedhypsmap.cmo: lib/util.cmi kernel/term.cmi \ + library/summary.cmi kernel/reduction.cmi library/nametab.cmi \ + kernel/names.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi kernel/inductive.cmi kernel/environ.cmi \ + kernel/declarations.cmi library/dischargedhypsmap.cmi +library/dischargedhypsmap.cmx: lib/util.cmx kernel/term.cmx \ + library/summary.cmx kernel/reduction.cmx library/nametab.cmx \ + kernel/names.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx kernel/inductive.cmx kernel/environ.cmx \ + kernel/declarations.cmx library/dischargedhypsmap.cmi +library/global.cmo: lib/util.cmi kernel/term.cmi library/summary.cmi \ + kernel/sign.cmi kernel/safe_typing.cmi kernel/names.cmi \ + library/libnames.cmi kernel/inductive.cmi kernel/environ.cmi \ library/global.cmi -library/global.cmx: kernel/environ.cmx kernel/inductive.cmx \ - library/libnames.cmx kernel/names.cmx kernel/safe_typing.cmx \ - kernel/sign.cmx library/summary.cmx kernel/term.cmx lib/util.cmx \ +library/global.cmx: lib/util.cmx kernel/term.cmx library/summary.cmx \ + kernel/sign.cmx kernel/safe_typing.cmx kernel/names.cmx \ + library/libnames.cmx kernel/inductive.cmx kernel/environ.cmx \ library/global.cmi -library/goptions.cmo: library/lib.cmi library/libnames.cmi \ - library/libobject.cmi kernel/names.cmi library/nametab.cmi lib/pp.cmi \ - library/summary.cmi kernel/term.cmi lib/util.cmi library/goptions.cmi -library/goptions.cmx: library/lib.cmx library/libnames.cmx \ - library/libobject.cmx kernel/names.cmx library/nametab.cmx lib/pp.cmx \ - library/summary.cmx kernel/term.cmx lib/util.cmx library/goptions.cmi -library/impargs.cmo: kernel/declarations.cmi kernel/environ.cmi \ - library/global.cmi kernel/inductive.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi kernel/reduction.cmi \ - library/summary.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi lib/util.cmi library/impargs.cmi -library/impargs.cmx: kernel/declarations.cmx kernel/environ.cmx \ - library/global.cmx kernel/inductive.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx kernel/reduction.cmx \ - library/summary.cmx kernel/term.cmx pretyping/termops.cmx \ - interp/topconstr.cmx lib/util.cmx library/impargs.cmi -library/lib.cmo: library/libnames.cmi library/libobject.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi library/summary.cmi lib/util.cmi library/lib.cmi -library/lib.cmx: library/libnames.cmx library/libobject.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx library/summary.cmx lib/util.cmx library/lib.cmi -library/libnames.cmo: library/nameops.cmi kernel/names.cmi lib/pp.cmi \ - lib/predicate.cmi kernel/term.cmi lib/util.cmi library/libnames.cmi -library/libnames.cmx: library/nameops.cmx kernel/names.cmx lib/pp.cmx \ - lib/predicate.cmx kernel/term.cmx lib/util.cmx library/libnames.cmi -library/libobject.cmo: lib/dyn.cmi library/libnames.cmi kernel/names.cmi \ - lib/util.cmi library/libobject.cmi -library/libobject.cmx: lib/dyn.cmx library/libnames.cmx kernel/names.cmx \ - lib/util.cmx library/libobject.cmi -library/library.cmo: library/declaremods.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi lib/options.cmi lib/pp.cmi \ - kernel/safe_typing.cmi library/summary.cmi lib/system.cmi lib/util.cmi \ +library/goptions.cmo: lib/util.cmi kernel/term.cmi library/summary.cmi \ + lib/pp.cmi library/nametab.cmi kernel/names.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi library/goptions.cmi +library/goptions.cmx: lib/util.cmx kernel/term.cmx library/summary.cmx \ + lib/pp.cmx library/nametab.cmx kernel/names.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx library/goptions.cmi +library/impargs.cmo: lib/util.cmi interp/topconstr.cmi pretyping/termops.cmi \ + kernel/term.cmi library/summary.cmi kernel/reduction.cmi lib/pp.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + kernel/inductive.cmi library/global.cmi kernel/environ.cmi \ + kernel/declarations.cmi library/impargs.cmi +library/impargs.cmx: lib/util.cmx interp/topconstr.cmx pretyping/termops.cmx \ + kernel/term.cmx library/summary.cmx kernel/reduction.cmx lib/pp.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + kernel/inductive.cmx library/global.cmx kernel/environ.cmx \ + kernel/declarations.cmx library/impargs.cmi +library/lib.cmo: lib/util.cmi library/summary.cmi lib/pp.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi +library/lib.cmx: lib/util.cmx library/summary.cmx lib/pp.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmi +library/libnames.cmo: lib/util.cmi kernel/term.cmi lib/predicate.cmi \ + lib/pp.cmi kernel/names.cmi library/nameops.cmi library/libnames.cmi +library/libnames.cmx: lib/util.cmx kernel/term.cmx lib/predicate.cmx \ + lib/pp.cmx kernel/names.cmx library/nameops.cmx library/libnames.cmi +library/libobject.cmo: lib/util.cmi kernel/names.cmi library/libnames.cmi \ + lib/dyn.cmi library/libobject.cmi +library/libobject.cmx: lib/util.cmx kernel/names.cmx library/libnames.cmx \ + lib/dyn.cmx library/libobject.cmi +library/library.cmo: lib/util.cmi lib/system.cmi library/summary.cmi \ + kernel/safe_typing.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi library/declaremods.cmi \ library/library.cmi -library/library.cmx: library/declaremods.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx lib/options.cmx lib/pp.cmx \ - kernel/safe_typing.cmx library/summary.cmx lib/system.cmx lib/util.cmx \ +library/library.cmx: lib/util.cmx lib/system.cmx library/summary.cmx \ + kernel/safe_typing.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx library/declaremods.cmx \ library/library.cmi -library/nameops.cmo: kernel/names.cmi lib/pp.cmi lib/util.cmi \ +library/nameops.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi \ library/nameops.cmi -library/nameops.cmx: kernel/names.cmx lib/pp.cmx lib/util.cmx \ +library/nameops.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx \ library/nameops.cmi -library/nametab.cmo: kernel/declarations.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi lib/pp.cmi library/summary.cmi \ - lib/util.cmi library/nametab.cmi -library/nametab.cmx: kernel/declarations.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx lib/pp.cmx library/summary.cmx \ - lib/util.cmx library/nametab.cmi -library/states.cmo: library/lib.cmi library/library.cmi library/summary.cmi \ - lib/system.cmi library/states.cmi -library/states.cmx: library/lib.cmx library/library.cmx library/summary.cmx \ - lib/system.cmx library/states.cmi -library/summary.cmo: lib/dyn.cmi lib/pp.cmi lib/util.cmi library/summary.cmi -library/summary.cmx: lib/dyn.cmx lib/pp.cmx lib/util.cmx library/summary.cmi -lib/rtree.cmo: lib/pp.cmi lib/util.cmi lib/rtree.cmi -lib/rtree.cmx: lib/pp.cmx lib/util.cmx lib/rtree.cmi -lib/stamps.cmo: lib/stamps.cmi -lib/stamps.cmx: lib/stamps.cmi -lib/system.cmo: config/coq_config.cmi lib/pp.cmi lib/util.cmi lib/system.cmi -lib/system.cmx: config/coq_config.cmx lib/pp.cmx lib/util.cmx lib/system.cmi -lib/tlm.cmo: lib/gmap.cmi lib/gset.cmi lib/tlm.cmi -lib/tlm.cmx: lib/gmap.cmx lib/gset.cmx lib/tlm.cmi -lib/util.cmo: lib/compat.cmo lib/pp.cmi lib/util.cmi -lib/util.cmx: lib/compat.cmx lib/pp.cmx lib/util.cmi -parsing/argextend.cmo: parsing/ast.cmi interp/genarg.cmi parsing/pcoq.cmi \ - parsing/q_coqast.cmo parsing/q_util.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/argextend.cmx: parsing/ast.cmx interp/genarg.cmx parsing/pcoq.cmx \ - parsing/q_coqast.cmx parsing/q_util.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx -parsing/ast.cmo: parsing/coqast.cmi lib/dyn.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi lib/pp.cmi interp/topconstr.cmi \ - lib/util.cmi parsing/ast.cmi -parsing/ast.cmx: parsing/coqast.cmx lib/dyn.cmx interp/genarg.cmx \ - library/libnames.cmx kernel/names.cmx lib/pp.cmx interp/topconstr.cmx \ - lib/util.cmx parsing/ast.cmi -parsing/coqast.cmo: lib/dyn.cmi lib/hashcons.cmi library/libnames.cmi \ - kernel/names.cmi lib/util.cmi parsing/coqast.cmi -parsing/coqast.cmx: lib/dyn.cmx lib/hashcons.cmx library/libnames.cmx \ - kernel/names.cmx lib/util.cmx parsing/coqast.cmi -parsing/egrammar.cmo: parsing/ast.cmi lib/bignat.cmi parsing/extend.cmi \ - interp/genarg.cmi parsing/lexer.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi library/summary.cmi proofs/tacexpr.cmo interp/topconstr.cmi \ - lib/util.cmi toplevel/vernacexpr.cmo parsing/egrammar.cmi -parsing/egrammar.cmx: parsing/ast.cmx lib/bignat.cmx parsing/extend.cmx \ - interp/genarg.cmx parsing/lexer.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx library/summary.cmx proofs/tacexpr.cmx interp/topconstr.cmx \ - lib/util.cmx toplevel/vernacexpr.cmx parsing/egrammar.cmi -parsing/esyntax.cmo: parsing/ast.cmi parsing/coqast.cmi parsing/extend.cmi \ - lib/gmap.cmi lib/gmapl.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi interp/ppextend.cmi \ - interp/symbols.cmi interp/topconstr.cmi lib/util.cmi parsing/esyntax.cmi -parsing/esyntax.cmx: parsing/ast.cmx parsing/coqast.cmx parsing/extend.cmx \ - lib/gmap.cmx lib/gmapl.cmx library/libnames.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx interp/ppextend.cmx \ - interp/symbols.cmx interp/topconstr.cmx lib/util.cmx parsing/esyntax.cmi -parsing/extend.cmo: parsing/ast.cmi parsing/coqast.cmi interp/genarg.cmi \ - parsing/lexer.cmi library/libnames.cmi kernel/names.cmi lib/options.cmi \ - lib/pp.cmi interp/ppextend.cmi pretyping/rawterm.cmi interp/topconstr.cmi \ - lib/util.cmi parsing/extend.cmi -parsing/extend.cmx: parsing/ast.cmx parsing/coqast.cmx interp/genarg.cmx \ - parsing/lexer.cmx library/libnames.cmx kernel/names.cmx lib/options.cmx \ - lib/pp.cmx interp/ppextend.cmx pretyping/rawterm.cmx interp/topconstr.cmx \ - lib/util.cmx parsing/extend.cmi -parsing/g_basevernac.cmo: parsing/ast.cmi interp/constrintern.cmi \ - parsing/coqast.cmi pretyping/evd.cmi parsing/extend.cmi \ - library/global.cmi library/goptions.cmi parsing/lexer.cmi \ - toplevel/metasyntax.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi interp/ppextend.cmi parsing/termast.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/g_basevernac.cmx: parsing/ast.cmx interp/constrintern.cmx \ - parsing/coqast.cmx pretyping/evd.cmx parsing/extend.cmx \ - library/global.cmx library/goptions.cmx parsing/lexer.cmx \ - toplevel/metasyntax.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx interp/ppextend.cmx parsing/termast.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx -parsing/g_cases.cmo: parsing/g_constr.cmo library/libnames.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -parsing/g_cases.cmx: parsing/g_constr.cmx library/libnames.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx -parsing/g_constr.cmo: parsing/lexer.cmi library/libnames.cmi kernel/names.cmi \ - lib/options.cmi pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi \ - pretyping/rawterm.cmi kernel/term.cmi interp/topconstr.cmi lib/util.cmi -parsing/g_constr.cmx: parsing/lexer.cmx library/libnames.cmx kernel/names.cmx \ - lib/options.cmx pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx \ - pretyping/rawterm.cmx kernel/term.cmx interp/topconstr.cmx lib/util.cmx -parsing/g_constrnew.cmo: lib/bignat.cmi parsing/coqast.cmi parsing/lexer.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi kernel/term.cmi interp/topconstr.cmi \ - lib/util.cmi -parsing/g_constrnew.cmx: lib/bignat.cmx parsing/coqast.cmx parsing/lexer.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx pretyping/rawterm.cmx kernel/term.cmx interp/topconstr.cmx \ - lib/util.cmx -parsing/g_ltac.cmo: parsing/ast.cmi interp/genarg.cmi library/libnames.cmi \ - kernel/names.cmi lib/options.cmi pretyping/pattern.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo interp/topconstr.cmi \ - lib/util.cmi toplevel/vernacexpr.cmo -parsing/g_ltac.cmx: parsing/ast.cmx interp/genarg.cmx library/libnames.cmx \ - kernel/names.cmx lib/options.cmx pretyping/pattern.cmx parsing/pcoq.cmx \ - lib/pp.cmx pretyping/rawterm.cmx proofs/tacexpr.cmx interp/topconstr.cmx \ - lib/util.cmx toplevel/vernacexpr.cmx -parsing/g_ltacnew.cmo: parsing/ast.cmi interp/genarg.cmi kernel/names.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/g_ltacnew.cmx: parsing/ast.cmx interp/genarg.cmx kernel/names.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx pretyping/rawterm.cmx \ - proofs/tacexpr.cmx interp/topconstr.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx -parsing/g_minicoq.cmo: kernel/environ.cmi parsing/lexer.cmi kernel/names.cmi \ - lib/pp.cmi kernel/term.cmi kernel/univ.cmi lib/util.cmi \ +library/nametab.cmo: lib/util.cmi library/summary.cmi lib/pp.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + kernel/declarations.cmi library/nametab.cmi +library/nametab.cmx: lib/util.cmx library/summary.cmx lib/pp.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + kernel/declarations.cmx library/nametab.cmi +library/states.cmo: lib/system.cmi library/summary.cmi library/library.cmi \ + library/lib.cmi library/states.cmi +library/states.cmx: lib/system.cmx library/summary.cmx library/library.cmx \ + library/lib.cmx library/states.cmi +library/summary.cmo: lib/util.cmi lib/pp.cmi lib/dyn.cmi library/summary.cmi +library/summary.cmx: lib/util.cmx lib/pp.cmx lib/dyn.cmx library/summary.cmi +parsing/argextend.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + parsing/q_util.cmi parsing/q_coqast.cmo parsing/pcoq.cmi \ + interp/genarg.cmi parsing/ast.cmi +parsing/argextend.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + parsing/q_util.cmx parsing/q_coqast.cmx parsing/pcoq.cmx \ + interp/genarg.cmx parsing/ast.cmx +parsing/ast.cmo: lib/util.cmi interp/topconstr.cmi lib/pp.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi lib/dyn.cmi \ + parsing/coqast.cmi parsing/ast.cmi +parsing/ast.cmx: lib/util.cmx interp/topconstr.cmx lib/pp.cmx \ + kernel/names.cmx library/libnames.cmx interp/genarg.cmx lib/dyn.cmx \ + parsing/coqast.cmx parsing/ast.cmi +parsing/coqast.cmo: lib/util.cmi kernel/names.cmi library/libnames.cmi \ + lib/hashcons.cmi lib/dyn.cmi parsing/coqast.cmi +parsing/coqast.cmx: lib/util.cmx kernel/names.cmx library/libnames.cmx \ + lib/hashcons.cmx lib/dyn.cmx parsing/coqast.cmi +parsing/egrammar.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo library/summary.cmi \ + interp/ppextend.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + parsing/lexer.cmi interp/genarg.cmi parsing/extend.cmi lib/bignat.cmi \ + parsing/ast.cmi parsing/egrammar.cmi +parsing/egrammar.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx proofs/tacexpr.cmx library/summary.cmx \ + interp/ppextend.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + parsing/lexer.cmx interp/genarg.cmx parsing/extend.cmx lib/bignat.cmx \ + parsing/ast.cmx parsing/egrammar.cmi +parsing/esyntax.cmo: lib/util.cmi interp/topconstr.cmi interp/symbols.cmi \ + interp/ppextend.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi lib/gmapl.cmi lib/gmap.cmi \ + parsing/extend.cmi parsing/coqast.cmi parsing/ast.cmi parsing/esyntax.cmi +parsing/esyntax.cmx: lib/util.cmx interp/topconstr.cmx interp/symbols.cmx \ + interp/ppextend.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx lib/gmapl.cmx lib/gmap.cmx \ + parsing/extend.cmx parsing/coqast.cmx parsing/ast.cmx parsing/esyntax.cmi +parsing/extend.cmo: lib/util.cmi interp/topconstr.cmi pretyping/rawterm.cmi \ + interp/ppextend.cmi lib/pp.cmi lib/options.cmi kernel/names.cmi \ + library/libnames.cmi parsing/lexer.cmi interp/genarg.cmi \ + parsing/coqast.cmi parsing/ast.cmi parsing/extend.cmi +parsing/extend.cmx: lib/util.cmx interp/topconstr.cmx pretyping/rawterm.cmx \ + interp/ppextend.cmx lib/pp.cmx lib/options.cmx kernel/names.cmx \ + library/libnames.cmx parsing/lexer.cmx interp/genarg.cmx \ + parsing/coqast.cmx parsing/ast.cmx parsing/extend.cmi +parsing/g_basevernac.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + parsing/termast.cmi interp/ppextend.cmi lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi kernel/names.cmi toplevel/metasyntax.cmi \ + parsing/lexer.cmi library/goptions.cmi library/global.cmi \ + parsing/extend.cmi pretyping/evd.cmi parsing/coqast.cmi \ + interp/constrintern.cmi parsing/ast.cmi +parsing/g_basevernac.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + parsing/termast.cmx interp/ppextend.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx kernel/names.cmx toplevel/metasyntax.cmx \ + parsing/lexer.cmx library/goptions.cmx library/global.cmx \ + parsing/extend.cmx pretyping/evd.cmx parsing/coqast.cmx \ + interp/constrintern.cmx parsing/ast.cmx +parsing/g_cases.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + lib/pp.cmi parsing/pcoq.cmi lib/options.cmi library/libnames.cmi \ + parsing/g_constr.cmo +parsing/g_cases.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + lib/pp.cmx parsing/pcoq.cmx lib/options.cmx library/libnames.cmx \ + parsing/g_constr.cmx +parsing/g_constr.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi pretyping/pattern.cmi \ + lib/options.cmi kernel/names.cmi library/libnames.cmi parsing/lexer.cmi +parsing/g_constr.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx pretyping/pattern.cmx \ + lib/options.cmx kernel/names.cmx library/libnames.cmx parsing/lexer.cmx +parsing/g_constrnew.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi parsing/lexer.cmi \ + parsing/coqast.cmi lib/bignat.cmi +parsing/g_constrnew.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx parsing/lexer.cmx \ + parsing/coqast.cmx lib/bignat.cmx +parsing/g_ltac.cmo: toplevel/vernacexpr.cmo lib/util.cmi interp/topconstr.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi \ + pretyping/pattern.cmi lib/options.cmi kernel/names.cmi \ + library/libnames.cmi interp/genarg.cmi parsing/ast.cmi +parsing/g_ltac.cmx: toplevel/vernacexpr.cmx lib/util.cmx interp/topconstr.cmx \ + proofs/tacexpr.cmx pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx \ + pretyping/pattern.cmx lib/options.cmx kernel/names.cmx \ + library/libnames.cmx interp/genarg.cmx parsing/ast.cmx +parsing/g_ltacnew.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo pretyping/rawterm.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi kernel/names.cmi interp/genarg.cmi \ + parsing/ast.cmi +parsing/g_ltacnew.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx proofs/tacexpr.cmx pretyping/rawterm.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx kernel/names.cmx interp/genarg.cmx \ + parsing/ast.cmx +parsing/g_minicoq.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + lib/pp.cmi kernel/names.cmi parsing/lexer.cmi kernel/environ.cmi \ parsing/g_minicoq.cmi -parsing/g_minicoq.cmx: kernel/environ.cmx parsing/lexer.cmx kernel/names.cmx \ - lib/pp.cmx kernel/term.cmx kernel/univ.cmx lib/util.cmx \ +parsing/g_minicoq.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + lib/pp.cmx kernel/names.cmx parsing/lexer.cmx kernel/environ.cmx \ parsing/g_minicoq.cmi -parsing/g_module.cmo: parsing/ast.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi interp/topconstr.cmi lib/util.cmi -parsing/g_module.cmx: parsing/ast.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx interp/topconstr.cmx lib/util.cmx -parsing/g_natsyntax.cmo: parsing/ast.cmi lib/bignat.cmi parsing/coqast.cmi \ - interp/coqlib.cmi parsing/esyntax.cmi parsing/extend.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi interp/symbols.cmi parsing/termast.cmi \ - lib/util.cmi parsing/g_natsyntax.cmi -parsing/g_natsyntax.cmx: parsing/ast.cmx lib/bignat.cmx parsing/coqast.cmx \ - interp/coqlib.cmx parsing/esyntax.cmx parsing/extend.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx pretyping/rawterm.cmx interp/symbols.cmx parsing/termast.cmx \ - lib/util.cmx parsing/g_natsyntax.cmi -parsing/g_prim.cmo: lib/bignat.cmi parsing/coqast.cmi library/libnames.cmi \ - kernel/names.cmi library/nametab.cmi parsing/pcoq.cmi \ - interp/topconstr.cmi -parsing/g_prim.cmx: lib/bignat.cmx parsing/coqast.cmx library/libnames.cmx \ - kernel/names.cmx library/nametab.cmx parsing/pcoq.cmx \ - interp/topconstr.cmx -parsing/g_primnew.cmo: lib/bignat.cmi parsing/coqast.cmi parsing/lexer.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - parsing/pcoq.cmi lib/pp.cmi interp/topconstr.cmi lib/util.cmi -parsing/g_primnew.cmx: lib/bignat.cmx parsing/coqast.cmx parsing/lexer.cmx \ - library/libnames.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - parsing/pcoq.cmx lib/pp.cmx interp/topconstr.cmx lib/util.cmx -parsing/g_proofs.cmo: interp/genarg.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/g_proofs.cmx: interp/genarg.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx proofs/tacexpr.cmx interp/topconstr.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx -parsing/g_proofsnew.cmo: parsing/g_vernacnew.cmo interp/genarg.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi proofs/tacexpr.cmo \ - interp/topconstr.cmi lib/util.cmi toplevel/vernacexpr.cmo -parsing/g_proofsnew.cmx: parsing/g_vernacnew.cmx interp/genarg.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx proofs/tacexpr.cmx \ - interp/topconstr.cmx lib/util.cmx toplevel/vernacexpr.cmx -parsing/g_rsyntax.cmo: parsing/ast.cmi lib/bignat.cmi parsing/coqast.cmi \ - parsing/esyntax.cmi parsing/extend.cmi library/libnames.cmi \ - kernel/names.cmi library/nametab.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi interp/symbols.cmi parsing/termast.cmi \ - interp/topconstr.cmi lib/util.cmi -parsing/g_rsyntax.cmx: parsing/ast.cmx lib/bignat.cmx parsing/coqast.cmx \ - parsing/esyntax.cmx parsing/extend.cmx library/libnames.cmx \ - kernel/names.cmx library/nametab.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx pretyping/rawterm.cmx interp/symbols.cmx parsing/termast.cmx \ - interp/topconstr.cmx lib/util.cmx -parsing/g_tactic.cmo: parsing/ast.cmi interp/genarg.cmi parsing/lexer.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi \ - pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi -parsing/g_tactic.cmx: parsing/ast.cmx interp/genarg.cmx parsing/lexer.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx \ - pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx pretyping/rawterm.cmx \ - proofs/tacexpr.cmx interp/topconstr.cmx lib/util.cmx -parsing/g_tacticnew.cmo: parsing/ast.cmi interp/genarg.cmi parsing/lexer.cmi \ - kernel/names.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - pretyping/rawterm.cmi proofs/tacexpr.cmo interp/topconstr.cmi \ - lib/util.cmi -parsing/g_tacticnew.cmx: parsing/ast.cmx interp/genarg.cmx parsing/lexer.cmx \ - kernel/names.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - pretyping/rawterm.cmx proofs/tacexpr.cmx interp/topconstr.cmx \ - lib/util.cmx -parsing/g_vernac.cmo: parsing/ast.cmi toplevel/class.cmi \ - library/decl_kinds.cmo parsing/g_basevernac.cmo parsing/g_proofs.cmo \ - interp/genarg.cmi library/goptions.cmi kernel/names.cmi lib/options.cmi \ - parsing/pcoq.cmi lib/pp.cmi toplevel/recordobj.cmi interp/topconstr.cmi \ - lib/util.cmi toplevel/vernacexpr.cmo -parsing/g_vernac.cmx: parsing/ast.cmx toplevel/class.cmx \ - library/decl_kinds.cmx parsing/g_basevernac.cmx parsing/g_proofs.cmx \ - interp/genarg.cmx library/goptions.cmx kernel/names.cmx lib/options.cmx \ - parsing/pcoq.cmx lib/pp.cmx toplevel/recordobj.cmx interp/topconstr.cmx \ - lib/util.cmx toplevel/vernacexpr.cmx -parsing/g_vernacnew.cmo: parsing/ast.cmi toplevel/class.cmi \ - parsing/coqast.cmi library/decl_kinds.cmo parsing/egrammar.cmi \ - parsing/extend.cmi parsing/g_constrnew.cmo interp/genarg.cmi \ - library/goptions.cmi parsing/lexer.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - interp/ppextend.cmi toplevel/recordobj.cmi interp/topconstr.cmi \ - lib/util.cmi toplevel/vernacexpr.cmo -parsing/g_vernacnew.cmx: parsing/ast.cmx toplevel/class.cmx \ - parsing/coqast.cmx library/decl_kinds.cmx parsing/egrammar.cmx \ - parsing/extend.cmx parsing/g_constrnew.cmx interp/genarg.cmx \ - library/goptions.cmx parsing/lexer.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - interp/ppextend.cmx toplevel/recordobj.cmx interp/topconstr.cmx \ - lib/util.cmx toplevel/vernacexpr.cmx -parsing/g_zsyntax.cmo: parsing/ast.cmi lib/bignat.cmi parsing/coqast.cmi \ - interp/coqlib.cmi parsing/esyntax.cmi parsing/extend.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi interp/symbols.cmi parsing/termast.cmi \ - interp/topconstr.cmi lib/util.cmi parsing/g_zsyntax.cmi -parsing/g_zsyntax.cmx: parsing/ast.cmx lib/bignat.cmx parsing/coqast.cmx \ - interp/coqlib.cmx parsing/esyntax.cmx parsing/extend.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx pretyping/rawterm.cmx interp/symbols.cmx parsing/termast.cmx \ - interp/topconstr.cmx lib/util.cmx parsing/g_zsyntax.cmi -parsing/lexer.cmo: lib/options.cmi lib/pp.cmi lib/util.cmi parsing/lexer.cmi -parsing/lexer.cmx: lib/options.cmx lib/pp.cmx lib/util.cmx parsing/lexer.cmi -parsing/pcoq.cmo: parsing/ast.cmi parsing/coqast.cmi library/decl_kinds.cmo \ - parsing/extend.cmi interp/genarg.cmi parsing/lexer.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi lib/pp.cmi \ - interp/ppextend.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - interp/topconstr.cmi lib/util.cmi parsing/pcoq.cmi -parsing/pcoq.cmx: parsing/ast.cmx parsing/coqast.cmx library/decl_kinds.cmx \ - parsing/extend.cmx interp/genarg.cmx parsing/lexer.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx lib/pp.cmx \ - interp/ppextend.cmx pretyping/rawterm.cmx proofs/tacexpr.cmx \ - interp/topconstr.cmx lib/util.cmx parsing/pcoq.cmi -parsing/ppconstr.cmo: parsing/ast.cmi lib/bignat.cmi interp/constrextern.cmi \ - parsing/coqast.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi pretyping/pattern.cmi lib/pp.cmi interp/ppextend.cmi \ - pretyping/rawterm.cmi interp/symbols.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi parsing/ppconstr.cmi -parsing/ppconstr.cmx: parsing/ast.cmx lib/bignat.cmx interp/constrextern.cmx \ - parsing/coqast.cmx pretyping/evd.cmx interp/genarg.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx pretyping/pattern.cmx lib/pp.cmx interp/ppextend.cmx \ - pretyping/rawterm.cmx interp/symbols.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx parsing/ppconstr.cmi -parsing/pptactic.cmo: kernel/closure.cmi interp/constrextern.cmi lib/dyn.cmi \ - parsing/extend.cmi interp/genarg.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - pretyping/pattern.cmi lib/pp.cmi parsing/ppconstr.cmi \ - translate/ppconstrnew.cmi parsing/printer.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo kernel/term.cmi interp/topconstr.cmi lib/util.cmi \ - parsing/pptactic.cmi -parsing/pptactic.cmx: kernel/closure.cmx interp/constrextern.cmx lib/dyn.cmx \ - parsing/extend.cmx interp/genarg.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - pretyping/pattern.cmx lib/pp.cmx parsing/ppconstr.cmx \ - translate/ppconstrnew.cmx parsing/printer.cmx pretyping/rawterm.cmx \ - proofs/tacexpr.cmx kernel/term.cmx interp/topconstr.cmx lib/util.cmx \ - parsing/pptactic.cmi -parsing/prettyp.cmo: pretyping/classops.cmi interp/constrextern.cmi \ - kernel/declarations.cmi library/declare.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi library/impargs.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi pretyping/instantiate.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi parsing/printer.cmi parsing/printmod.cmi kernel/reduction.cmi \ - pretyping/reductionops.cmi kernel/safe_typing.cmi kernel/sign.cmi \ - interp/symbols.cmi interp/syntax_def.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi parsing/prettyp.cmi -parsing/prettyp.cmx: pretyping/classops.cmx interp/constrextern.cmx \ - kernel/declarations.cmx library/declare.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx library/impargs.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx pretyping/instantiate.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx parsing/printer.cmx parsing/printmod.cmx kernel/reduction.cmx \ - pretyping/reductionops.cmx kernel/safe_typing.cmx kernel/sign.cmx \ - interp/symbols.cmx interp/syntax_def.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx parsing/prettyp.cmi -parsing/printer.cmo: parsing/ast.cmi interp/constrextern.cmi \ - parsing/coqast.cmi library/declare.cmi lib/dyn.cmi kernel/environ.cmi \ - parsing/esyntax.cmi parsing/extend.cmi library/global.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - parsing/ppconstr.cmi translate/ppconstrnew.cmi interp/ppextend.cmi \ - kernel/sign.cmi kernel/term.cmi parsing/termast.cmi pretyping/termops.cmi \ - lib/util.cmi parsing/printer.cmi -parsing/printer.cmx: parsing/ast.cmx interp/constrextern.cmx \ - parsing/coqast.cmx library/declare.cmx lib/dyn.cmx kernel/environ.cmx \ - parsing/esyntax.cmx parsing/extend.cmx library/global.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - parsing/ppconstr.cmx translate/ppconstrnew.cmx interp/ppextend.cmx \ - kernel/sign.cmx kernel/term.cmx parsing/termast.cmx pretyping/termops.cmx \ - lib/util.cmx parsing/printer.cmi -parsing/printmod.cmo: kernel/declarations.cmi library/global.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi lib/util.cmi parsing/printmod.cmi -parsing/printmod.cmx: kernel/declarations.cmx library/global.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx lib/util.cmx parsing/printmod.cmi -parsing/q_coqast.cmo: parsing/coqast.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi parsing/pcoq.cmi parsing/q_util.cmi \ - pretyping/rawterm.cmi proofs/tacexpr.cmo interp/topconstr.cmi \ - lib/util.cmi -parsing/q_coqast.cmx: parsing/coqast.cmx interp/genarg.cmx \ - library/libnames.cmx kernel/names.cmx parsing/pcoq.cmx parsing/q_util.cmx \ - pretyping/rawterm.cmx proofs/tacexpr.cmx interp/topconstr.cmx \ - lib/util.cmx +parsing/g_module.cmo: lib/util.cmi interp/topconstr.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi parsing/ast.cmi +parsing/g_module.cmx: lib/util.cmx interp/topconstr.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx parsing/ast.cmx +parsing/g_natsyntax.cmo: lib/util.cmi parsing/termast.cmi interp/symbols.cmi \ + pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi parsing/extend.cmi \ + parsing/esyntax.cmi interp/coqlib.cmi parsing/coqast.cmi lib/bignat.cmi \ + parsing/ast.cmi parsing/g_natsyntax.cmi +parsing/g_natsyntax.cmx: lib/util.cmx parsing/termast.cmx interp/symbols.cmx \ + pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx parsing/extend.cmx \ + parsing/esyntax.cmx interp/coqlib.cmx parsing/coqast.cmx lib/bignat.cmx \ + parsing/ast.cmx parsing/g_natsyntax.cmi +parsing/g_prim.cmo: interp/topconstr.cmi parsing/pcoq.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi parsing/coqast.cmi lib/bignat.cmi +parsing/g_prim.cmx: interp/topconstr.cmx parsing/pcoq.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx parsing/coqast.cmx lib/bignat.cmx +parsing/g_primnew.cmo: lib/util.cmi interp/topconstr.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi library/nametab.cmi kernel/names.cmi \ + library/libnames.cmi parsing/lexer.cmi parsing/coqast.cmi lib/bignat.cmi +parsing/g_primnew.cmx: lib/util.cmx interp/topconstr.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx library/nametab.cmx kernel/names.cmx \ + library/libnames.cmx parsing/lexer.cmx parsing/coqast.cmx lib/bignat.cmx +parsing/g_proofs.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi interp/genarg.cmi +parsing/g_proofs.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx proofs/tacexpr.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx interp/genarg.cmx +parsing/g_proofsnew.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi interp/genarg.cmi parsing/g_vernacnew.cmo +parsing/g_proofsnew.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx proofs/tacexpr.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx interp/genarg.cmx parsing/g_vernacnew.cmx +parsing/g_rsyntax.cmo: lib/util.cmi interp/topconstr.cmi parsing/termast.cmi \ + interp/symbols.cmi pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + parsing/extend.cmi parsing/esyntax.cmi parsing/coqast.cmi lib/bignat.cmi \ + parsing/ast.cmi +parsing/g_rsyntax.cmx: lib/util.cmx interp/topconstr.cmx parsing/termast.cmx \ + interp/symbols.cmx pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/libnames.cmx \ + parsing/extend.cmx parsing/esyntax.cmx parsing/coqast.cmx lib/bignat.cmx \ + parsing/ast.cmx +parsing/g_tactic.cmo: lib/util.cmi interp/topconstr.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi pretyping/pattern.cmi \ + lib/options.cmi kernel/names.cmi library/libnames.cmi parsing/lexer.cmi \ + interp/genarg.cmi parsing/ast.cmi +parsing/g_tactic.cmx: lib/util.cmx interp/topconstr.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx pretyping/pattern.cmx \ + lib/options.cmx kernel/names.cmx library/libnames.cmx parsing/lexer.cmx \ + interp/genarg.cmx parsing/ast.cmx +parsing/g_tacticnew.cmo: lib/util.cmi interp/topconstr.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi parsing/lexer.cmi interp/genarg.cmi parsing/ast.cmi +parsing/g_tacticnew.cmx: lib/util.cmx interp/topconstr.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx parsing/lexer.cmx interp/genarg.cmx parsing/ast.cmx +parsing/g_vernac.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi toplevel/recordobj.cmi lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi kernel/names.cmi library/goptions.cmi interp/genarg.cmi \ + parsing/g_proofs.cmo parsing/g_basevernac.cmo library/decl_kinds.cmo \ + toplevel/class.cmi parsing/ast.cmi +parsing/g_vernac.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx toplevel/recordobj.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx kernel/names.cmx library/goptions.cmx interp/genarg.cmx \ + parsing/g_proofs.cmx parsing/g_basevernac.cmx library/decl_kinds.cmx \ + toplevel/class.cmx parsing/ast.cmx +parsing/g_vernacnew.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi toplevel/recordobj.cmi interp/ppextend.cmi \ + lib/pp.cmi parsing/pcoq.cmi lib/options.cmi kernel/names.cmi \ + library/nameops.cmi parsing/lexer.cmi library/goptions.cmi \ + interp/genarg.cmi parsing/g_constrnew.cmo parsing/extend.cmi \ + parsing/egrammar.cmi library/decl_kinds.cmo parsing/coqast.cmi \ + toplevel/class.cmi parsing/ast.cmi +parsing/g_vernacnew.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx toplevel/recordobj.cmx interp/ppextend.cmx \ + lib/pp.cmx parsing/pcoq.cmx lib/options.cmx kernel/names.cmx \ + library/nameops.cmx parsing/lexer.cmx library/goptions.cmx \ + interp/genarg.cmx parsing/g_constrnew.cmx parsing/extend.cmx \ + parsing/egrammar.cmx library/decl_kinds.cmx parsing/coqast.cmx \ + toplevel/class.cmx parsing/ast.cmx +parsing/g_zsyntax.cmo: lib/util.cmi interp/topconstr.cmi parsing/termast.cmi \ + interp/symbols.cmi pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi kernel/names.cmi library/libnames.cmi parsing/extend.cmi \ + parsing/esyntax.cmi interp/coqlib.cmi parsing/coqast.cmi lib/bignat.cmi \ + parsing/ast.cmi parsing/g_zsyntax.cmi +parsing/g_zsyntax.cmx: lib/util.cmx interp/topconstr.cmx parsing/termast.cmx \ + interp/symbols.cmx pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx kernel/names.cmx library/libnames.cmx parsing/extend.cmx \ + parsing/esyntax.cmx interp/coqlib.cmx parsing/coqast.cmx lib/bignat.cmx \ + parsing/ast.cmx parsing/g_zsyntax.cmi +parsing/lexer.cmo: lib/util.cmi lib/pp.cmi lib/options.cmi parsing/lexer.cmi +parsing/lexer.cmx: lib/util.cmx lib/pp.cmx lib/options.cmx parsing/lexer.cmi +parsing/pcoq.cmo: lib/util.cmi interp/topconstr.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi interp/ppextend.cmi lib/pp.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi parsing/lexer.cmi interp/genarg.cmi \ + parsing/extend.cmi library/decl_kinds.cmo parsing/coqast.cmi \ + parsing/ast.cmi parsing/pcoq.cmi +parsing/pcoq.cmx: lib/util.cmx interp/topconstr.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx interp/ppextend.cmx lib/pp.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx parsing/lexer.cmx interp/genarg.cmx \ + parsing/extend.cmx library/decl_kinds.cmx parsing/coqast.cmx \ + parsing/ast.cmx parsing/pcoq.cmi +parsing/ppconstr.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + interp/symbols.cmi pretyping/rawterm.cmi interp/ppextend.cmi lib/pp.cmi \ + pretyping/pattern.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi interp/genarg.cmi \ + pretyping/evd.cmi parsing/coqast.cmi interp/constrextern.cmi \ + lib/bignat.cmi parsing/ast.cmi parsing/ppconstr.cmi +parsing/ppconstr.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + interp/symbols.cmx pretyping/rawterm.cmx interp/ppextend.cmx lib/pp.cmx \ + pretyping/pattern.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx interp/genarg.cmx \ + pretyping/evd.cmx parsing/coqast.cmx interp/constrextern.cmx \ + lib/bignat.cmx parsing/ast.cmx parsing/ppconstr.cmi +parsing/pptactic.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi parsing/printer.cmi \ + translate/ppconstrnew.cmi parsing/ppconstr.cmi lib/pp.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + interp/genarg.cmi parsing/extend.cmi lib/dyn.cmi interp/constrextern.cmi \ + kernel/closure.cmi parsing/pptactic.cmi +parsing/pptactic.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + proofs/tacexpr.cmx pretyping/rawterm.cmx parsing/printer.cmx \ + translate/ppconstrnew.cmx parsing/ppconstr.cmx lib/pp.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + interp/genarg.cmx parsing/extend.cmx lib/dyn.cmx interp/constrextern.cmx \ + kernel/closure.cmx parsing/pptactic.cmi +parsing/prettyp.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + interp/syntax_def.cmi interp/symbols.cmi kernel/sign.cmi \ + kernel/safe_typing.cmi pretyping/reductionops.cmi kernel/reduction.cmi \ + parsing/printmod.cmi parsing/printer.cmi lib/pp.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + pretyping/instantiate.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + library/impargs.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi library/declare.cmi kernel/declarations.cmi \ + interp/constrextern.cmi pretyping/classops.cmi parsing/prettyp.cmi +parsing/prettyp.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + interp/syntax_def.cmx interp/symbols.cmx kernel/sign.cmx \ + kernel/safe_typing.cmx pretyping/reductionops.cmx kernel/reduction.cmx \ + parsing/printmod.cmx parsing/printer.cmx lib/pp.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + pretyping/instantiate.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + library/impargs.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx library/declare.cmx kernel/declarations.cmx \ + interp/constrextern.cmx pretyping/classops.cmx parsing/prettyp.cmi +parsing/printer.cmo: lib/util.cmi pretyping/termops.cmi parsing/termast.cmi \ + kernel/term.cmi kernel/sign.cmi interp/ppextend.cmi \ + translate/ppconstrnew.cmi parsing/ppconstr.cmi lib/pp.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + library/global.cmi parsing/extend.cmi parsing/esyntax.cmi \ + kernel/environ.cmi lib/dyn.cmi library/declare.cmi parsing/coqast.cmi \ + interp/constrextern.cmi parsing/ast.cmi parsing/printer.cmi +parsing/printer.cmx: lib/util.cmx pretyping/termops.cmx parsing/termast.cmx \ + kernel/term.cmx kernel/sign.cmx interp/ppextend.cmx \ + translate/ppconstrnew.cmx parsing/ppconstr.cmx lib/pp.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + library/global.cmx parsing/extend.cmx parsing/esyntax.cmx \ + kernel/environ.cmx lib/dyn.cmx library/declare.cmx parsing/coqast.cmx \ + interp/constrextern.cmx parsing/ast.cmx parsing/printer.cmi +parsing/printmod.cmo: lib/util.cmi lib/pp.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + library/global.cmi kernel/declarations.cmi parsing/printmod.cmi +parsing/printmod.cmx: lib/util.cmx lib/pp.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + library/global.cmx kernel/declarations.cmx parsing/printmod.cmi +parsing/q_coqast.cmo: lib/util.cmi interp/topconstr.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi parsing/q_util.cmi parsing/pcoq.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi \ + parsing/coqast.cmi +parsing/q_coqast.cmx: lib/util.cmx interp/topconstr.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx parsing/q_util.cmx parsing/pcoq.cmx \ + kernel/names.cmx library/libnames.cmx interp/genarg.cmx \ + parsing/coqast.cmx parsing/q_util.cmo: lib/util.cmi parsing/q_util.cmi parsing/q_util.cmx: lib/util.cmx parsing/q_util.cmi -parsing/search.cmo: parsing/coqast.cmi interp/coqlib.cmi \ - kernel/declarations.cmi library/declare.cmi library/declaremods.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi \ - kernel/inductive.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi pretyping/matching.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi pretyping/pattern.cmi lib/pp.cmi \ - parsing/printer.cmi pretyping/rawterm.cmi kernel/term.cmi \ - pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - parsing/search.cmi -parsing/search.cmx: parsing/coqast.cmx interp/coqlib.cmx \ - kernel/declarations.cmx library/declare.cmx library/declaremods.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx \ - kernel/inductive.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx pretyping/matching.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx pretyping/pattern.cmx lib/pp.cmx \ - parsing/printer.cmx pretyping/rawterm.cmx kernel/term.cmx \ - pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - parsing/search.cmi -parsing/tacextend.cmo: parsing/argextend.cmo interp/genarg.cmi \ - parsing/pcoq.cmi lib/pp.cmi lib/pp_control.cmi parsing/q_coqast.cmo \ - parsing/q_util.cmi lib/util.cmi toplevel/vernacexpr.cmo -parsing/tacextend.cmx: parsing/argextend.cmx interp/genarg.cmx \ - parsing/pcoq.cmx lib/pp.cmx lib/pp_control.cmx parsing/q_coqast.cmx \ - parsing/q_util.cmx lib/util.cmx toplevel/vernacexpr.cmx -parsing/termast.cmo: parsing/ast.cmi pretyping/classops.cmi \ - interp/constrextern.cmi parsing/coqast.cmi library/declare.cmi \ - pretyping/detyping.cmi kernel/environ.cmi library/impargs.cmi \ - kernel/inductive.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi pretyping/pattern.cmi lib/pp.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/univ.cmi lib/util.cmi \ - parsing/termast.cmi -parsing/termast.cmx: parsing/ast.cmx pretyping/classops.cmx \ - interp/constrextern.cmx parsing/coqast.cmx library/declare.cmx \ - pretyping/detyping.cmx kernel/environ.cmx library/impargs.cmx \ - kernel/inductive.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx pretyping/pattern.cmx lib/pp.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/univ.cmx lib/util.cmx \ - parsing/termast.cmi -parsing/vernacextend.cmo: parsing/argextend.cmo parsing/ast.cmi \ - interp/genarg.cmi parsing/pcoq.cmi lib/pp.cmi lib/pp_control.cmi \ - parsing/q_coqast.cmo parsing/q_util.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/vernacextend.cmx: parsing/argextend.cmx parsing/ast.cmx \ - interp/genarg.cmx parsing/pcoq.cmx lib/pp.cmx lib/pp_control.cmx \ - parsing/q_coqast.cmx parsing/q_util.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx -pretyping/cases.cmo: pretyping/coercion.cmi kernel/declarations.cmi \ - kernel/environ.cmi pretyping/evarconv.cmi pretyping/evarutil.cmi \ - library/global.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - library/nameops.cmi kernel/names.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi pretyping/rawterm.cmi \ - pretyping/reductionops.cmi pretyping/retyping.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/type_errors.cmi \ - kernel/typeops.cmi lib/util.cmi pretyping/cases.cmi -pretyping/cases.cmx: pretyping/coercion.cmx kernel/declarations.cmx \ - kernel/environ.cmx pretyping/evarconv.cmx pretyping/evarutil.cmx \ - library/global.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - library/nameops.cmx kernel/names.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx pretyping/rawterm.cmx \ - pretyping/reductionops.cmx pretyping/retyping.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/type_errors.cmx \ - kernel/typeops.cmx lib/util.cmx pretyping/cases.cmi -pretyping/cbv.cmo: kernel/closure.cmi kernel/environ.cmi kernel/esubst.cmi \ - pretyping/evd.cmi pretyping/instantiate.cmi kernel/names.cmi lib/pp.cmi \ - kernel/term.cmi kernel/univ.cmi lib/util.cmi pretyping/cbv.cmi -pretyping/cbv.cmx: kernel/closure.cmx kernel/environ.cmx kernel/esubst.cmx \ - pretyping/evd.cmx pretyping/instantiate.cmx kernel/names.cmx lib/pp.cmx \ - kernel/term.cmx kernel/univ.cmx lib/util.cmx pretyping/cbv.cmi -pretyping/classops.cmo: library/decl_kinds.cmo kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi lib/gmap.cmi library/goptions.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi pretyping/rawterm.cmi pretyping/reductionops.cmi \ - library/summary.cmi pretyping/tacred.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi pretyping/classops.cmi -pretyping/classops.cmx: library/decl_kinds.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx lib/gmap.cmx library/goptions.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx pretyping/rawterm.cmx pretyping/reductionops.cmx \ - library/summary.cmx pretyping/tacred.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx pretyping/classops.cmi -pretyping/coercion.cmo: pretyping/classops.cmi kernel/environ.cmi \ - pretyping/evarconv.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - kernel/names.cmi pretyping/pretype_errors.cmi pretyping/rawterm.cmi \ - pretyping/recordops.cmi pretyping/reductionops.cmi pretyping/retyping.cmi \ - kernel/term.cmi kernel/typeops.cmi lib/util.cmi pretyping/coercion.cmi -pretyping/coercion.cmx: pretyping/classops.cmx kernel/environ.cmx \ - pretyping/evarconv.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - kernel/names.cmx pretyping/pretype_errors.cmx pretyping/rawterm.cmx \ - pretyping/recordops.cmx pretyping/reductionops.cmx pretyping/retyping.cmx \ - kernel/term.cmx kernel/typeops.cmx lib/util.cmx pretyping/coercion.cmi -pretyping/detyping.cmo: kernel/declarations.cmi kernel/environ.cmi \ - library/global.cmi library/goptions.cmi kernel/inductive.cmi \ - pretyping/inductiveops.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi lib/options.cmi lib/pp.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/univ.cmi lib/util.cmi pretyping/detyping.cmi -pretyping/detyping.cmx: kernel/declarations.cmx kernel/environ.cmx \ - library/global.cmx library/goptions.cmx kernel/inductive.cmx \ - pretyping/inductiveops.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx lib/options.cmx lib/pp.cmx \ - pretyping/rawterm.cmx kernel/sign.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/univ.cmx lib/util.cmx pretyping/detyping.cmi -pretyping/evarconv.cmo: pretyping/classops.cmi kernel/closure.cmi \ - kernel/environ.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - pretyping/instantiate.cmi library/libnames.cmi kernel/names.cmi \ - pretyping/rawterm.cmi pretyping/recordops.cmi pretyping/reductionops.cmi \ - kernel/term.cmi pretyping/typing.cmi lib/util.cmi pretyping/evarconv.cmi -pretyping/evarconv.cmx: pretyping/classops.cmx kernel/closure.cmx \ - kernel/environ.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - pretyping/instantiate.cmx library/libnames.cmx kernel/names.cmx \ - pretyping/rawterm.cmx pretyping/recordops.cmx pretyping/reductionops.cmx \ - kernel/term.cmx pretyping/typing.cmx lib/util.cmx pretyping/evarconv.cmi -pretyping/evarutil.cmo: kernel/environ.cmi pretyping/evd.cmi \ - library/global.cmi pretyping/indrec.cmi pretyping/instantiate.cmi \ - library/nameops.cmi kernel/names.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi pretyping/rawterm.cmi \ - pretyping/reductionops.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/typeops.cmi kernel/univ.cmi lib/util.cmi \ +parsing/search.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi pretyping/rawterm.cmi parsing/printer.cmi lib/pp.cmi \ + pretyping/pattern.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi pretyping/matching.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi kernel/inductive.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + library/declaremods.cmi library/declare.cmi kernel/declarations.cmi \ + interp/coqlib.cmi parsing/coqast.cmi parsing/search.cmi +parsing/search.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx pretyping/rawterm.cmx parsing/printer.cmx lib/pp.cmx \ + pretyping/pattern.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx pretyping/matching.cmx library/library.cmx \ + library/libobject.cmx library/libnames.cmx kernel/inductive.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + library/declaremods.cmx library/declare.cmx kernel/declarations.cmx \ + interp/coqlib.cmx parsing/coqast.cmx parsing/search.cmi +parsing/tacextend.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + parsing/q_util.cmi parsing/q_coqast.cmo lib/pp_control.cmi lib/pp.cmi \ + parsing/pcoq.cmi interp/genarg.cmi parsing/argextend.cmo +parsing/tacextend.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + parsing/q_util.cmx parsing/q_coqast.cmx lib/pp_control.cmx lib/pp.cmx \ + parsing/pcoq.cmx interp/genarg.cmx parsing/argextend.cmx +parsing/termast.cmo: lib/util.cmi kernel/univ.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi pretyping/reductionops.cmi \ + pretyping/rawterm.cmi lib/pp.cmi pretyping/pattern.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi kernel/inductive.cmi library/impargs.cmi \ + kernel/environ.cmi pretyping/detyping.cmi library/declare.cmi \ + parsing/coqast.cmi interp/constrextern.cmi pretyping/classops.cmi \ + parsing/ast.cmi parsing/termast.cmi +parsing/termast.cmx: lib/util.cmx kernel/univ.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx pretyping/reductionops.cmx \ + pretyping/rawterm.cmx lib/pp.cmx pretyping/pattern.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx kernel/inductive.cmx library/impargs.cmx \ + kernel/environ.cmx pretyping/detyping.cmx library/declare.cmx \ + parsing/coqast.cmx interp/constrextern.cmx pretyping/classops.cmx \ + parsing/ast.cmx parsing/termast.cmi +parsing/vernacextend.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + parsing/q_util.cmi parsing/q_coqast.cmo lib/pp_control.cmi lib/pp.cmi \ + parsing/pcoq.cmi interp/genarg.cmi parsing/ast.cmi parsing/argextend.cmo +parsing/vernacextend.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + parsing/q_util.cmx parsing/q_coqast.cmx lib/pp_control.cmx lib/pp.cmx \ + parsing/pcoq.cmx interp/genarg.cmx parsing/ast.cmx parsing/argextend.cmx +pretyping/cases.cmo: lib/util.cmi kernel/typeops.cmi kernel/type_errors.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/retyping.cmi pretyping/reductionops.cmi pretyping/rawterm.cmi \ + pretyping/pretype_errors.cmi lib/pp.cmi kernel/names.cmi \ + library/nameops.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + library/global.cmi pretyping/evarutil.cmi pretyping/evarconv.cmi \ + kernel/environ.cmi kernel/declarations.cmi pretyping/coercion.cmi \ + pretyping/cases.cmi +pretyping/cases.cmx: lib/util.cmx kernel/typeops.cmx kernel/type_errors.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/sign.cmx \ + pretyping/retyping.cmx pretyping/reductionops.cmx pretyping/rawterm.cmx \ + pretyping/pretype_errors.cmx lib/pp.cmx kernel/names.cmx \ + library/nameops.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + library/global.cmx pretyping/evarutil.cmx pretyping/evarconv.cmx \ + kernel/environ.cmx kernel/declarations.cmx pretyping/coercion.cmx \ + pretyping/cases.cmi +pretyping/cbv.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi lib/pp.cmi \ + kernel/names.cmi pretyping/instantiate.cmi pretyping/evd.cmi \ + kernel/esubst.cmi kernel/environ.cmi kernel/closure.cmi pretyping/cbv.cmi +pretyping/cbv.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx lib/pp.cmx \ + kernel/names.cmx pretyping/instantiate.cmx pretyping/evd.cmx \ + kernel/esubst.cmx kernel/environ.cmx kernel/closure.cmx pretyping/cbv.cmi +pretyping/classops.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/tacred.cmi library/summary.cmi pretyping/reductionops.cmi \ + pretyping/rawterm.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/library.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi library/goptions.cmi lib/gmap.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + library/decl_kinds.cmo pretyping/classops.cmi +pretyping/classops.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/tacred.cmx library/summary.cmx pretyping/reductionops.cmx \ + pretyping/rawterm.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/library.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx library/goptions.cmx lib/gmap.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + library/decl_kinds.cmx pretyping/classops.cmi +pretyping/coercion.cmo: lib/util.cmi kernel/typeops.cmi kernel/term.cmi \ + pretyping/retyping.cmi pretyping/reductionops.cmi pretyping/recordops.cmi \ + pretyping/rawterm.cmi pretyping/pretype_errors.cmi kernel/names.cmi \ + pretyping/evd.cmi pretyping/evarutil.cmi pretyping/evarconv.cmi \ + kernel/environ.cmi pretyping/classops.cmi pretyping/coercion.cmi +pretyping/coercion.cmx: lib/util.cmx kernel/typeops.cmx kernel/term.cmx \ + pretyping/retyping.cmx pretyping/reductionops.cmx pretyping/recordops.cmx \ + pretyping/rawterm.cmx pretyping/pretype_errors.cmx kernel/names.cmx \ + pretyping/evd.cmx pretyping/evarutil.cmx pretyping/evarconv.cmx \ + kernel/environ.cmx pretyping/classops.cmx pretyping/coercion.cmi +pretyping/detyping.cmo: lib/util.cmi kernel/univ.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi pretyping/rawterm.cmi lib/pp.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + library/goptions.cmi library/global.cmi kernel/environ.cmi \ + kernel/declarations.cmi pretyping/detyping.cmi +pretyping/detyping.cmx: lib/util.cmx kernel/univ.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx pretyping/rawterm.cmx lib/pp.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + library/goptions.cmx library/global.cmx kernel/environ.cmx \ + kernel/declarations.cmx pretyping/detyping.cmi +pretyping/evarconv.cmo: lib/util.cmi pretyping/typing.cmi kernel/term.cmi \ + pretyping/reductionops.cmi pretyping/recordops.cmi pretyping/rawterm.cmi \ + kernel/names.cmi library/libnames.cmi pretyping/instantiate.cmi \ + pretyping/evd.cmi pretyping/evarutil.cmi kernel/environ.cmi \ + kernel/closure.cmi pretyping/classops.cmi pretyping/evarconv.cmi +pretyping/evarconv.cmx: lib/util.cmx pretyping/typing.cmx kernel/term.cmx \ + pretyping/reductionops.cmx pretyping/recordops.cmx pretyping/rawterm.cmx \ + kernel/names.cmx library/libnames.cmx pretyping/instantiate.cmx \ + pretyping/evd.cmx pretyping/evarutil.cmx kernel/environ.cmx \ + kernel/closure.cmx pretyping/classops.cmx pretyping/evarconv.cmi +pretyping/evarutil.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi \ + pretyping/pretype_errors.cmi lib/pp.cmi kernel/names.cmi \ + library/nameops.cmi pretyping/instantiate.cmi pretyping/indrec.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ pretyping/evarutil.cmi -pretyping/evarutil.cmx: kernel/environ.cmx pretyping/evd.cmx \ - library/global.cmx pretyping/indrec.cmx pretyping/instantiate.cmx \ - library/nameops.cmx kernel/names.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx pretyping/rawterm.cmx \ - pretyping/reductionops.cmx kernel/sign.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/typeops.cmx kernel/univ.cmx lib/util.cmx \ +pretyping/evarutil.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/sign.cmx \ + pretyping/reductionops.cmx pretyping/rawterm.cmx \ + pretyping/pretype_errors.cmx lib/pp.cmx kernel/names.cmx \ + library/nameops.cmx pretyping/instantiate.cmx pretyping/indrec.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ pretyping/evarutil.cmi -pretyping/evd.cmo: kernel/names.cmi kernel/sign.cmi kernel/term.cmi \ - lib/util.cmi pretyping/evd.cmi -pretyping/evd.cmx: kernel/names.cmx kernel/sign.cmx kernel/term.cmx \ - lib/util.cmx pretyping/evd.cmi -pretyping/indrec.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi library/global.cmi kernel/indtypes.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi pretyping/instantiate.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi kernel/reduction.cmi \ - pretyping/reductionops.cmi kernel/safe_typing.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/type_errors.cmi kernel/typeops.cmi \ - lib/util.cmi pretyping/indrec.cmi -pretyping/indrec.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx library/global.cmx kernel/indtypes.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx pretyping/instantiate.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx kernel/reduction.cmx \ - pretyping/reductionops.cmx kernel/safe_typing.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/type_errors.cmx kernel/typeops.cmx \ - lib/util.cmx pretyping/indrec.cmi -pretyping/inductiveops.cmo: kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi kernel/inductive.cmi \ - kernel/names.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/univ.cmi lib/util.cmi \ - pretyping/inductiveops.cmi -pretyping/inductiveops.cmx: kernel/declarations.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx kernel/inductive.cmx \ - kernel/names.cmx pretyping/reductionops.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/univ.cmx lib/util.cmx \ - pretyping/inductiveops.cmi -pretyping/instantiate.cmo: kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi kernel/names.cmi lib/pp.cmi kernel/sign.cmi \ - kernel/term.cmi lib/util.cmi pretyping/instantiate.cmi -pretyping/instantiate.cmx: kernel/declarations.cmx kernel/environ.cmx \ - pretyping/evd.cmx kernel/names.cmx lib/pp.cmx kernel/sign.cmx \ - kernel/term.cmx lib/util.cmx pretyping/instantiate.cmi -pretyping/matching.cmo: kernel/environ.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi pretyping/pattern.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi pretyping/matching.cmi -pretyping/matching.cmx: kernel/environ.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx pretyping/pattern.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx pretyping/matching.cmi -pretyping/pattern.cmo: kernel/environ.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi pretyping/rawterm.cmi kernel/term.cmi lib/util.cmi \ +pretyping/evd.cmo: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi pretyping/evd.cmi +pretyping/evd.cmx: lib/util.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/names.cmx pretyping/evd.cmi +pretyping/indrec.cmo: lib/util.cmi kernel/typeops.cmi kernel/type_errors.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/safe_typing.cmi \ + pretyping/reductionops.cmi kernel/reduction.cmi lib/pp.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi pretyping/instantiate.cmi pretyping/inductiveops.cmi \ + kernel/inductive.cmi kernel/indtypes.cmi library/global.cmi \ + kernel/environ.cmi kernel/entries.cmi kernel/declarations.cmi \ + pretyping/indrec.cmi +pretyping/indrec.cmx: lib/util.cmx kernel/typeops.cmx kernel/type_errors.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/safe_typing.cmx \ + pretyping/reductionops.cmx kernel/reduction.cmx lib/pp.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx pretyping/instantiate.cmx pretyping/inductiveops.cmx \ + kernel/inductive.cmx kernel/indtypes.cmx library/global.cmx \ + kernel/environ.cmx kernel/entries.cmx kernel/declarations.cmx \ + pretyping/indrec.cmi +pretyping/inductiveops.cmo: lib/util.cmi kernel/univ.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi kernel/names.cmi kernel/inductive.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi pretyping/inductiveops.cmi +pretyping/inductiveops.cmx: lib/util.cmx kernel/univ.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/sign.cmx \ + pretyping/reductionops.cmx kernel/names.cmx kernel/inductive.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx pretyping/inductiveops.cmi +pretyping/instantiate.cmo: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + lib/pp.cmi kernel/names.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi pretyping/instantiate.cmi +pretyping/instantiate.cmx: lib/util.cmx kernel/term.cmx kernel/sign.cmx \ + lib/pp.cmx kernel/names.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx pretyping/instantiate.cmi +pretyping/matching.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi pretyping/pattern.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + kernel/environ.cmi pretyping/matching.cmi +pretyping/matching.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/reductionops.cmx pretyping/rawterm.cmx pretyping/pattern.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + kernel/environ.cmx pretyping/matching.cmi +pretyping/pattern.cmo: lib/util.cmi kernel/term.cmi pretyping/rawterm.cmi \ + lib/pp.cmi lib/options.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi kernel/environ.cmi \ pretyping/pattern.cmi -pretyping/pattern.cmx: kernel/environ.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx pretyping/rawterm.cmx kernel/term.cmx lib/util.cmx \ +pretyping/pattern.cmx: lib/util.cmx kernel/term.cmx pretyping/rawterm.cmx \ + lib/pp.cmx lib/options.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx kernel/environ.cmx \ pretyping/pattern.cmi -pretyping/pretype_errors.cmo: kernel/environ.cmi pretyping/evd.cmi \ - pretyping/inductiveops.cmi kernel/names.cmi pretyping/rawterm.cmi \ - kernel/reduction.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/type_errors.cmi lib/util.cmi \ - pretyping/pretype_errors.cmi -pretyping/pretype_errors.cmx: kernel/environ.cmx pretyping/evd.cmx \ - pretyping/inductiveops.cmx kernel/names.cmx pretyping/rawterm.cmx \ - kernel/reduction.cmx pretyping/reductionops.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/type_errors.cmx lib/util.cmx \ - pretyping/pretype_errors.cmi -pretyping/pretyping.cmo: pretyping/cases.cmi pretyping/classops.cmi \ - pretyping/coercion.cmi kernel/declarations.cmi pretyping/detyping.cmi \ - lib/dyn.cmi kernel/environ.cmi pretyping/evarconv.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi library/global.cmi \ - pretyping/indrec.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - pretyping/instantiate.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi pretyping/rawterm.cmi \ - pretyping/recordops.cmi pretyping/reductionops.cmi pretyping/retyping.cmi \ - kernel/sign.cmi kernel/term.cmi pretyping/termops.cmi \ - kernel/type_errors.cmi kernel/typeops.cmi lib/util.cmi \ +pretyping/pretype_errors.cmo: lib/util.cmi kernel/type_errors.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi kernel/reduction.cmi pretyping/rawterm.cmi \ + kernel/names.cmi pretyping/inductiveops.cmi pretyping/evd.cmi \ + kernel/environ.cmi pretyping/pretype_errors.cmi +pretyping/pretype_errors.cmx: lib/util.cmx kernel/type_errors.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/sign.cmx \ + pretyping/reductionops.cmx kernel/reduction.cmx pretyping/rawterm.cmx \ + kernel/names.cmx pretyping/inductiveops.cmx pretyping/evd.cmx \ + kernel/environ.cmx pretyping/pretype_errors.cmi +pretyping/pretyping.cmo: lib/util.cmi kernel/typeops.cmi \ + kernel/type_errors.cmi pretyping/termops.cmi kernel/term.cmi \ + kernel/sign.cmi pretyping/retyping.cmi pretyping/reductionops.cmi \ + pretyping/recordops.cmi pretyping/rawterm.cmi \ + pretyping/pretype_errors.cmi lib/pp.cmi pretyping/pattern.cmi \ + lib/options.cmi kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + pretyping/instantiate.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + pretyping/indrec.cmi library/global.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi pretyping/evarconv.cmi kernel/environ.cmi \ + lib/dyn.cmi pretyping/detyping.cmi kernel/declarations.cmi \ + pretyping/coercion.cmi pretyping/classops.cmi pretyping/cases.cmi \ pretyping/pretyping.cmi -pretyping/pretyping.cmx: pretyping/cases.cmx pretyping/classops.cmx \ - pretyping/coercion.cmx kernel/declarations.cmx pretyping/detyping.cmx \ - lib/dyn.cmx kernel/environ.cmx pretyping/evarconv.cmx \ - pretyping/evarutil.cmx pretyping/evd.cmx library/global.cmx \ - pretyping/indrec.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - pretyping/instantiate.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx pretyping/rawterm.cmx \ - pretyping/recordops.cmx pretyping/reductionops.cmx pretyping/retyping.cmx \ - kernel/sign.cmx kernel/term.cmx pretyping/termops.cmx \ - kernel/type_errors.cmx kernel/typeops.cmx lib/util.cmx \ +pretyping/pretyping.cmx: lib/util.cmx kernel/typeops.cmx \ + kernel/type_errors.cmx pretyping/termops.cmx kernel/term.cmx \ + kernel/sign.cmx pretyping/retyping.cmx pretyping/reductionops.cmx \ + pretyping/recordops.cmx pretyping/rawterm.cmx \ + pretyping/pretype_errors.cmx lib/pp.cmx pretyping/pattern.cmx \ + lib/options.cmx kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + pretyping/instantiate.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + pretyping/indrec.cmx library/global.cmx pretyping/evd.cmx \ + pretyping/evarutil.cmx pretyping/evarconv.cmx kernel/environ.cmx \ + lib/dyn.cmx pretyping/detyping.cmx kernel/declarations.cmx \ + pretyping/coercion.cmx pretyping/classops.cmx pretyping/cases.cmx \ pretyping/pretyping.cmi -pretyping/rawterm.cmo: lib/dyn.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi kernel/sign.cmi kernel/term.cmi kernel/univ.cmi \ - lib/util.cmi pretyping/rawterm.cmi -pretyping/rawterm.cmx: lib/dyn.cmx library/libnames.cmx kernel/names.cmx \ - library/nametab.cmx kernel/sign.cmx kernel/term.cmx kernel/univ.cmx \ - lib/util.cmx pretyping/rawterm.cmi -pretyping/recordops.cmo: pretyping/classops.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi library/library.cmi \ - kernel/names.cmi library/nametab.cmi lib/pp.cmi library/summary.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/typeops.cmi lib/util.cmi \ - pretyping/recordops.cmi -pretyping/recordops.cmx: pretyping/classops.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx library/library.cmx \ - kernel/names.cmx library/nametab.cmx lib/pp.cmx library/summary.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/typeops.cmx lib/util.cmx \ - pretyping/recordops.cmi -pretyping/reductionops.cmo: kernel/closure.cmi kernel/declarations.cmi \ - kernel/environ.cmi kernel/esubst.cmi pretyping/evd.cmi \ - pretyping/instantiate.cmi kernel/names.cmi lib/pp.cmi \ - kernel/reduction.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/univ.cmi lib/util.cmi \ +pretyping/rawterm.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + lib/dyn.cmi pretyping/rawterm.cmi +pretyping/rawterm.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx library/nametab.cmx kernel/names.cmx library/libnames.cmx \ + lib/dyn.cmx pretyping/rawterm.cmi +pretyping/recordops.cmo: lib/util.cmi kernel/typeops.cmi \ + pretyping/termops.cmi kernel/term.cmi library/summary.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + pretyping/classops.cmi pretyping/recordops.cmi +pretyping/recordops.cmx: lib/util.cmx kernel/typeops.cmx \ + pretyping/termops.cmx kernel/term.cmx library/summary.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx library/library.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + pretyping/classops.cmx pretyping/recordops.cmi +pretyping/reductionops.cmo: lib/util.cmi kernel/univ.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/reduction.cmi lib/pp.cmi kernel/names.cmi \ + pretyping/instantiate.cmi pretyping/evd.cmi kernel/esubst.cmi \ + kernel/environ.cmi kernel/declarations.cmi kernel/closure.cmi \ pretyping/reductionops.cmi -pretyping/reductionops.cmx: kernel/closure.cmx kernel/declarations.cmx \ - kernel/environ.cmx kernel/esubst.cmx pretyping/evd.cmx \ - pretyping/instantiate.cmx kernel/names.cmx lib/pp.cmx \ - kernel/reduction.cmx kernel/sign.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/univ.cmx lib/util.cmx \ +pretyping/reductionops.cmx: lib/util.cmx kernel/univ.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/reduction.cmx lib/pp.cmx kernel/names.cmx \ + pretyping/instantiate.cmx pretyping/evd.cmx kernel/esubst.cmx \ + kernel/environ.cmx kernel/declarations.cmx kernel/closure.cmx \ pretyping/reductionops.cmi -pretyping/retyping.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi pretyping/instantiate.cmi \ - kernel/names.cmi pretyping/reductionops.cmi kernel/term.cmi \ - kernel/typeops.cmi kernel/univ.cmi lib/util.cmi pretyping/retyping.cmi -pretyping/retyping.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx pretyping/instantiate.cmx \ - kernel/names.cmx pretyping/reductionops.cmx kernel/term.cmx \ - kernel/typeops.cmx kernel/univ.cmx lib/util.cmx pretyping/retyping.cmi -pretyping/tacred.cmo: pretyping/cbv.cmi kernel/closure.cmi \ - kernel/conv_oracle.cmi kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi kernel/inductive.cmi \ - pretyping/instantiate.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi lib/pp.cmi pretyping/rawterm.cmi \ - pretyping/reductionops.cmi pretyping/retyping.cmi library/summary.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi pretyping/tacred.cmi -pretyping/tacred.cmx: pretyping/cbv.cmx kernel/closure.cmx \ - kernel/conv_oracle.cmx kernel/declarations.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx kernel/inductive.cmx \ - pretyping/instantiate.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx lib/pp.cmx pretyping/rawterm.cmx \ - pretyping/reductionops.cmx pretyping/retyping.cmx library/summary.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx pretyping/tacred.cmi -pretyping/termops.cmo: kernel/environ.cmi library/global.cmi library/lib.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi lib/util.cmi pretyping/termops.cmi -pretyping/termops.cmx: kernel/environ.cmx library/global.cmx library/lib.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/univ.cmx lib/util.cmx pretyping/termops.cmi -pretyping/typing.cmo: kernel/environ.cmi kernel/inductive.cmi \ - pretyping/instantiate.cmi kernel/names.cmi pretyping/pretype_errors.cmi \ - pretyping/reductionops.cmi kernel/term.cmi kernel/type_errors.cmi \ - kernel/typeops.cmi lib/util.cmi pretyping/typing.cmi -pretyping/typing.cmx: kernel/environ.cmx kernel/inductive.cmx \ - pretyping/instantiate.cmx kernel/names.cmx pretyping/pretype_errors.cmx \ - pretyping/reductionops.cmx kernel/term.cmx kernel/type_errors.cmx \ - kernel/typeops.cmx lib/util.cmx pretyping/typing.cmi -proofs/clenv.cmo: pretyping/coercion.cmi kernel/environ.cmi \ - proofs/evar_refiner.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - library/global.cmi pretyping/instantiate.cmi proofs/logic.cmi \ - library/nameops.cmi kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - pretyping/retyping.cmi kernel/sign.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi kernel/term.cmi pretyping/termops.cmi \ - pretyping/typing.cmi lib/util.cmi proofs/clenv.cmi -proofs/clenv.cmx: pretyping/coercion.cmx kernel/environ.cmx \ - proofs/evar_refiner.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - library/global.cmx pretyping/instantiate.cmx proofs/logic.cmx \ - library/nameops.cmx kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - pretyping/retyping.cmx kernel/sign.cmx proofs/tacexpr.cmx \ - proofs/tacmach.cmx kernel/term.cmx pretyping/termops.cmx \ - pretyping/typing.cmx lib/util.cmx proofs/clenv.cmi -proofs/evar_refiner.cmo: interp/constrintern.cmi kernel/environ.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi library/global.cmi \ - pretyping/instantiate.cmi proofs/logic.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo pretyping/tacred.cmi kernel/term.cmi \ - kernel/type_errors.cmi pretyping/typing.cmi lib/util.cmi \ - proofs/evar_refiner.cmi -proofs/evar_refiner.cmx: interp/constrintern.cmx kernel/environ.cmx \ - pretyping/evarutil.cmx pretyping/evd.cmx library/global.cmx \ - pretyping/instantiate.cmx proofs/logic.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - kernel/sign.cmx proofs/tacexpr.cmx pretyping/tacred.cmx kernel/term.cmx \ - kernel/type_errors.cmx pretyping/typing.cmx lib/util.cmx \ - proofs/evar_refiner.cmi -proofs/logic.cmo: interp/constrextern.cmi parsing/coqast.cmi \ - kernel/environ.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - library/global.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi pretyping/pretype_errors.cmi parsing/printer.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi pretyping/reductionops.cmi \ - pretyping/retyping.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/type_errors.cmi kernel/typeops.cmi \ - pretyping/typing.cmi lib/util.cmi proofs/logic.cmi -proofs/logic.cmx: interp/constrextern.cmx parsing/coqast.cmx \ - kernel/environ.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - library/global.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx pretyping/pretype_errors.cmx parsing/printer.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx pretyping/reductionops.cmx \ - pretyping/retyping.cmx kernel/sign.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/type_errors.cmx kernel/typeops.cmx \ - pretyping/typing.cmx lib/util.cmx proofs/logic.cmi -proofs/pfedit.cmo: library/decl_kinds.cmo kernel/declarations.cmi \ - lib/edit.cmi kernel/entries.cmi kernel/environ.cmi \ - proofs/evar_refiner.cmi pretyping/evd.cmi library/lib.cmi \ - library/nameops.cmi kernel/names.cmi lib/pp.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi proofs/refiner.cmi kernel/safe_typing.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi kernel/term.cmi \ - pretyping/typing.cmi lib/util.cmi proofs/pfedit.cmi -proofs/pfedit.cmx: library/decl_kinds.cmx kernel/declarations.cmx \ - lib/edit.cmx kernel/entries.cmx kernel/environ.cmx \ - proofs/evar_refiner.cmx pretyping/evd.cmx library/lib.cmx \ - library/nameops.cmx kernel/names.cmx lib/pp.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx proofs/refiner.cmx kernel/safe_typing.cmx \ - kernel/sign.cmx proofs/tacexpr.cmx proofs/tacmach.cmx kernel/term.cmx \ - pretyping/typing.cmx lib/util.cmx proofs/pfedit.cmi -proofs/proof_trees.cmo: kernel/closure.cmi pretyping/detyping.cmi \ - kernel/environ.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - library/global.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_type.cmi kernel/sign.cmi pretyping/tacred.cmi \ - kernel/term.cmi pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - proofs/proof_trees.cmi -proofs/proof_trees.cmx: kernel/closure.cmx pretyping/detyping.cmx \ - kernel/environ.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - library/global.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx lib/pp.cmx parsing/printer.cmx \ - proofs/proof_type.cmx kernel/sign.cmx pretyping/tacred.cmx \ - kernel/term.cmx pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - proofs/proof_trees.cmi -proofs/proof_type.cmo: kernel/environ.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - kernel/term.cmi lib/util.cmi proofs/proof_type.cmi -proofs/proof_type.cmx: kernel/environ.cmx pretyping/evd.cmx interp/genarg.cmx \ - library/libnames.cmx kernel/names.cmx library/nametab.cmx \ - pretyping/pattern.cmx pretyping/rawterm.cmx proofs/tacexpr.cmx \ - kernel/term.cmx lib/util.cmx proofs/proof_type.cmi -proofs/refiner.cmo: kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/evd.cmi library/global.cmi pretyping/instantiate.cmi \ - proofs/logic.cmi lib/options.cmi lib/pp.cmi parsing/pptactic.cmi \ - translate/pptacticnew.cmi parsing/printer.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo kernel/term.cmi pretyping/termops.cmi \ - kernel/type_errors.cmi lib/util.cmi proofs/refiner.cmi -proofs/refiner.cmx: kernel/environ.cmx pretyping/evarutil.cmx \ - pretyping/evd.cmx library/global.cmx pretyping/instantiate.cmx \ - proofs/logic.cmx lib/options.cmx lib/pp.cmx parsing/pptactic.cmx \ - translate/pptacticnew.cmx parsing/printer.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx pretyping/reductionops.cmx kernel/sign.cmx \ - proofs/tacexpr.cmx kernel/term.cmx pretyping/termops.cmx \ - kernel/type_errors.cmx lib/util.cmx proofs/refiner.cmi -proofs/tacexpr.cmo: library/decl_kinds.cmo lib/dyn.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi pretyping/rawterm.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -proofs/tacexpr.cmx: library/decl_kinds.cmx lib/dyn.cmx interp/genarg.cmx \ - library/libnames.cmx kernel/names.cmx library/nametab.cmx \ - pretyping/pattern.cmx pretyping/rawterm.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx -proofs/tacmach.cmo: interp/constrintern.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi pretyping/instantiate.cmi \ - proofs/logic.cmi library/nameops.cmi kernel/names.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo pretyping/tacred.cmi kernel/term.cmi \ - pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - proofs/tacmach.cmi -proofs/tacmach.cmx: interp/constrintern.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx pretyping/instantiate.cmx \ - proofs/logic.cmx library/nameops.cmx kernel/names.cmx lib/pp.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - kernel/sign.cmx proofs/tacexpr.cmx pretyping/tacred.cmx kernel/term.cmx \ - pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - proofs/tacmach.cmi -proofs/tactic_debug.cmo: parsing/ast.cmi interp/constrextern.cmi \ - library/global.cmi proofs/logic.cmi kernel/names.cmi lib/options.cmi \ - lib/pp.cmi parsing/pptactic.cmi translate/pptacticnew.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi pretyping/termops.cmi proofs/tactic_debug.cmi -proofs/tactic_debug.cmx: parsing/ast.cmx interp/constrextern.cmx \ - library/global.cmx proofs/logic.cmx kernel/names.cmx lib/options.cmx \ - lib/pp.cmx parsing/pptactic.cmx translate/pptacticnew.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx proofs/tacexpr.cmx \ - proofs/tacmach.cmx pretyping/termops.cmx proofs/tactic_debug.cmi -scripts/coqc.cmo: config/coq_config.cmi toplevel/usage.cmi -scripts/coqc.cmx: config/coq_config.cmx toplevel/usage.cmx -scripts/coqmktop.cmo: config/coq_config.cmi scripts/tolink.cmo -scripts/coqmktop.cmx: config/coq_config.cmx scripts/tolink.cmx -tactics/auto.cmo: tactics/btermdn.cmi proofs/clenv.cmi \ - interp/constrintern.cmi kernel/declarations.cmi tactics/dhyp.cmi \ - proofs/evar_refiner.cmi pretyping/evd.cmi library/global.cmi \ - tactics/hiddentac.cmi tactics/hipattern.cmi kernel/inductive.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi proofs/logic.cmi pretyping/matching.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - pretyping/pattern.cmi proofs/pfedit.cmi lib/pp.cmi parsing/pptactic.cmi \ - parsing/printer.cmi proofs/proof_type.cmi pretyping/rawterm.cmi \ - kernel/reduction.cmi proofs/refiner.cmi kernel/sign.cmi \ - library/summary.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - pretyping/tacred.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo tactics/auto.cmi -tactics/auto.cmx: tactics/btermdn.cmx proofs/clenv.cmx \ - interp/constrintern.cmx kernel/declarations.cmx tactics/dhyp.cmx \ - proofs/evar_refiner.cmx pretyping/evd.cmx library/global.cmx \ - tactics/hiddentac.cmx tactics/hipattern.cmx kernel/inductive.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx proofs/logic.cmx pretyping/matching.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - pretyping/pattern.cmx proofs/pfedit.cmx lib/pp.cmx parsing/pptactic.cmx \ - parsing/printer.cmx proofs/proof_type.cmx pretyping/rawterm.cmx \ - kernel/reduction.cmx proofs/refiner.cmx kernel/sign.cmx \ - library/summary.cmx proofs/tacexpr.cmx proofs/tacmach.cmx \ - pretyping/tacred.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx tactics/auto.cmi -tactics/autorewrite.cmo: parsing/ast.cmi parsing/coqast.cmi \ - tactics/equality.cmi tactics/hipattern.cmi library/lib.cmi \ - library/libobject.cmi kernel/names.cmi lib/pp.cmi proofs/proof_type.cmi \ - library/summary.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi lib/util.cmi \ - toplevel/vernacinterp.cmi tactics/autorewrite.cmi -tactics/autorewrite.cmx: parsing/ast.cmx parsing/coqast.cmx \ - tactics/equality.cmx tactics/hipattern.cmx library/lib.cmx \ - library/libobject.cmx kernel/names.cmx lib/pp.cmx proofs/proof_type.cmx \ - library/summary.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx lib/util.cmx \ - toplevel/vernacinterp.cmx tactics/autorewrite.cmi -tactics/btermdn.cmo: tactics/dn.cmi pretyping/pattern.cmi kernel/term.cmi \ - tactics/termdn.cmi tactics/btermdn.cmi -tactics/btermdn.cmx: tactics/dn.cmx pretyping/pattern.cmx kernel/term.cmx \ - tactics/termdn.cmx tactics/btermdn.cmi -tactics/contradiction.cmo: interp/coqlib.cmi tactics/hipattern.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi pretyping/reductionops.cmi \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi lib/util.cmi tactics/contradiction.cmi -tactics/contradiction.cmx: interp/coqlib.cmx tactics/hipattern.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx pretyping/reductionops.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx lib/util.cmx tactics/contradiction.cmi -tactics/dhyp.cmo: parsing/ast.cmi proofs/clenv.cmi interp/constrintern.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi library/library.cmi \ - pretyping/matching.cmi kernel/names.cmi tactics/nbtermdn.cmi \ - pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi proofs/refiner.cmi \ - library/summary.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi lib/util.cmi \ - tactics/dhyp.cmi -tactics/dhyp.cmx: parsing/ast.cmx proofs/clenv.cmx interp/constrintern.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx library/library.cmx \ - pretyping/matching.cmx kernel/names.cmx tactics/nbtermdn.cmx \ - pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx kernel/reduction.cmx proofs/refiner.cmx \ - library/summary.cmx proofs/tacexpr.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx lib/util.cmx \ - tactics/dhyp.cmi +pretyping/retyping.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/term.cmi pretyping/reductionops.cmi kernel/names.cmi \ + pretyping/instantiate.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + kernel/environ.cmi kernel/declarations.cmi pretyping/retyping.cmi +pretyping/retyping.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/term.cmx pretyping/reductionops.cmx kernel/names.cmx \ + pretyping/instantiate.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + kernel/environ.cmx kernel/declarations.cmx pretyping/retyping.cmi +pretyping/tacred.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi library/summary.cmi pretyping/retyping.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi pretyping/instantiate.cmi kernel/inductive.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi kernel/conv_oracle.cmi kernel/closure.cmi \ + pretyping/cbv.cmi pretyping/tacred.cmi +pretyping/tacred.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx library/summary.cmx pretyping/retyping.cmx \ + pretyping/reductionops.cmx pretyping/rawterm.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx pretyping/instantiate.cmx kernel/inductive.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx kernel/conv_oracle.cmx kernel/closure.cmx \ + pretyping/cbv.cmx pretyping/tacred.cmi +pretyping/termops.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi lib/pp.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi library/lib.cmi \ + library/global.cmi kernel/environ.cmi pretyping/termops.cmi +pretyping/termops.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx lib/pp.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx library/lib.cmx \ + library/global.cmx kernel/environ.cmx pretyping/termops.cmi +pretyping/typing.cmo: lib/util.cmi kernel/typeops.cmi kernel/type_errors.cmi \ + kernel/term.cmi pretyping/reductionops.cmi pretyping/pretype_errors.cmi \ + kernel/names.cmi pretyping/instantiate.cmi kernel/inductive.cmi \ + kernel/environ.cmi pretyping/typing.cmi +pretyping/typing.cmx: lib/util.cmx kernel/typeops.cmx kernel/type_errors.cmx \ + kernel/term.cmx pretyping/reductionops.cmx pretyping/pretype_errors.cmx \ + kernel/names.cmx pretyping/instantiate.cmx kernel/inductive.cmx \ + kernel/environ.cmx pretyping/typing.cmi +proofs/clenv.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + pretyping/retyping.cmi proofs/refiner.cmi pretyping/reductionops.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + parsing/printer.cmi lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi \ + library/nameops.cmi proofs/logic.cmi pretyping/instantiate.cmi \ + library/global.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + proofs/evar_refiner.cmi kernel/environ.cmi pretyping/coercion.cmi \ + proofs/clenv.cmi +proofs/clenv.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + pretyping/retyping.cmx proofs/refiner.cmx pretyping/reductionops.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + parsing/printer.cmx lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx \ + library/nameops.cmx proofs/logic.cmx pretyping/instantiate.cmx \ + library/global.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + proofs/evar_refiner.cmx kernel/environ.cmx pretyping/coercion.cmx \ + proofs/clenv.cmi +proofs/evar_refiner.cmo: lib/util.cmi pretyping/typing.cmi \ + kernel/type_errors.cmi kernel/term.cmi pretyping/tacred.cmi \ + proofs/tacexpr.cmo kernel/sign.cmi proofs/refiner.cmi \ + pretyping/reductionops.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + lib/pp.cmi lib/options.cmi kernel/names.cmi library/nameops.cmi \ + proofs/logic.cmi pretyping/instantiate.cmi library/global.cmi \ + pretyping/evd.cmi pretyping/evarutil.cmi kernel/environ.cmi \ + interp/constrintern.cmi proofs/evar_refiner.cmi +proofs/evar_refiner.cmx: lib/util.cmx pretyping/typing.cmx \ + kernel/type_errors.cmx kernel/term.cmx pretyping/tacred.cmx \ + proofs/tacexpr.cmx kernel/sign.cmx proofs/refiner.cmx \ + pretyping/reductionops.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + lib/pp.cmx lib/options.cmx kernel/names.cmx library/nameops.cmx \ + proofs/logic.cmx pretyping/instantiate.cmx library/global.cmx \ + pretyping/evd.cmx pretyping/evarutil.cmx kernel/environ.cmx \ + interp/constrintern.cmx proofs/evar_refiner.cmi +proofs/logic.cmo: lib/util.cmi pretyping/typing.cmi kernel/typeops.cmi \ + kernel/type_errors.cmi pretyping/termops.cmi kernel/term.cmi \ + kernel/sign.cmi pretyping/retyping.cmi pretyping/reductionops.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi parsing/printer.cmi \ + pretyping/pretype_errors.cmi lib/pp.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/inductiveops.cmi kernel/inductive.cmi library/global.cmi \ + pretyping/evd.cmi pretyping/evarutil.cmi kernel/environ.cmi \ + parsing/coqast.cmi interp/constrextern.cmi proofs/logic.cmi +proofs/logic.cmx: lib/util.cmx pretyping/typing.cmx kernel/typeops.cmx \ + kernel/type_errors.cmx pretyping/termops.cmx kernel/term.cmx \ + kernel/sign.cmx pretyping/retyping.cmx pretyping/reductionops.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx parsing/printer.cmx \ + pretyping/pretype_errors.cmx lib/pp.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/inductiveops.cmx kernel/inductive.cmx library/global.cmx \ + pretyping/evd.cmx pretyping/evarutil.cmx kernel/environ.cmx \ + parsing/coqast.cmx interp/constrextern.cmx proofs/logic.cmi +proofs/pfedit.cmo: lib/util.cmi pretyping/typing.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + kernel/safe_typing.cmi proofs/refiner.cmi proofs/proof_type.cmi \ + proofs/proof_trees.cmi lib/pp.cmi kernel/names.cmi library/nameops.cmi \ + library/lib.cmi pretyping/evd.cmi proofs/evar_refiner.cmi \ + kernel/environ.cmi kernel/entries.cmi lib/edit.cmi \ + kernel/declarations.cmi library/decl_kinds.cmo proofs/pfedit.cmi +proofs/pfedit.cmx: lib/util.cmx pretyping/typing.cmx kernel/term.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + kernel/safe_typing.cmx proofs/refiner.cmx proofs/proof_type.cmx \ + proofs/proof_trees.cmx lib/pp.cmx kernel/names.cmx library/nameops.cmx \ + library/lib.cmx pretyping/evd.cmx proofs/evar_refiner.cmx \ + kernel/environ.cmx kernel/entries.cmx lib/edit.cmx \ + kernel/declarations.cmx library/decl_kinds.cmx proofs/pfedit.cmi +proofs/proof_trees.cmo: lib/util.cmi pretyping/typing.cmi \ + pretyping/termops.cmi kernel/term.cmi pretyping/tacred.cmi \ + kernel/sign.cmi proofs/proof_type.cmi parsing/printer.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi library/global.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi pretyping/detyping.cmi \ + kernel/closure.cmi proofs/proof_trees.cmi +proofs/proof_trees.cmx: lib/util.cmx pretyping/typing.cmx \ + pretyping/termops.cmx kernel/term.cmx pretyping/tacred.cmx \ + kernel/sign.cmx proofs/proof_type.cmx parsing/printer.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx library/global.cmx pretyping/evd.cmx \ + pretyping/evarutil.cmx kernel/environ.cmx pretyping/detyping.cmx \ + kernel/closure.cmx proofs/proof_trees.cmi +proofs/proof_type.cmo: lib/util.cmi kernel/term.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi pretyping/evd.cmi \ + kernel/environ.cmi proofs/proof_type.cmi +proofs/proof_type.cmx: lib/util.cmx kernel/term.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx pretyping/pattern.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx interp/genarg.cmx pretyping/evd.cmx \ + kernel/environ.cmx proofs/proof_type.cmi +proofs/refiner.cmo: lib/util.cmi kernel/type_errors.cmi pretyping/termops.cmi \ + kernel/term.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + pretyping/reductionops.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + parsing/printer.cmi translate/pptacticnew.cmi parsing/pptactic.cmi \ + lib/pp.cmi lib/options.cmi proofs/logic.cmi pretyping/instantiate.cmi \ + library/global.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + kernel/environ.cmi proofs/refiner.cmi +proofs/refiner.cmx: lib/util.cmx kernel/type_errors.cmx pretyping/termops.cmx \ + kernel/term.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + pretyping/reductionops.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + parsing/printer.cmx translate/pptacticnew.cmx parsing/pptactic.cmx \ + lib/pp.cmx lib/options.cmx proofs/logic.cmx pretyping/instantiate.cmx \ + library/global.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + kernel/environ.cmx proofs/refiner.cmi +proofs/tacexpr.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi lib/dyn.cmi \ + library/decl_kinds.cmo +proofs/tacexpr.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + pretyping/rawterm.cmx pretyping/pattern.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx interp/genarg.cmx lib/dyn.cmx \ + library/decl_kinds.cmx +proofs/tacmach.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi pretyping/tacred.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + proofs/refiner.cmi pretyping/reductionops.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi parsing/printer.cmi \ + lib/pp.cmi kernel/names.cmi library/nameops.cmi proofs/logic.cmi \ + pretyping/instantiate.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi interp/constrintern.cmi proofs/tacmach.cmi +proofs/tacmach.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx pretyping/tacred.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + proofs/refiner.cmx pretyping/reductionops.cmx pretyping/rawterm.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx parsing/printer.cmx \ + lib/pp.cmx kernel/names.cmx library/nameops.cmx proofs/logic.cmx \ + pretyping/instantiate.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx interp/constrintern.cmx proofs/tacmach.cmi +proofs/tactic_debug.cmo: pretyping/termops.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo proofs/proof_trees.cmi parsing/printer.cmi \ + translate/pptacticnew.cmi parsing/pptactic.cmi lib/pp.cmi lib/options.cmi \ + kernel/names.cmi proofs/logic.cmi library/global.cmi \ + interp/constrextern.cmi parsing/ast.cmi proofs/tactic_debug.cmi +proofs/tactic_debug.cmx: pretyping/termops.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx proofs/proof_trees.cmx parsing/printer.cmx \ + translate/pptacticnew.cmx parsing/pptactic.cmx lib/pp.cmx lib/options.cmx \ + kernel/names.cmx proofs/logic.cmx library/global.cmx \ + interp/constrextern.cmx parsing/ast.cmx proofs/tactic_debug.cmi +scripts/coqc.cmo: toplevel/usage.cmi config/coq_config.cmi +scripts/coqc.cmx: toplevel/usage.cmx config/coq_config.cmx +scripts/coqmktop.cmo: scripts/tolink.cmo config/coq_config.cmi +scripts/coqmktop.cmx: scripts/tolink.cmx config/coq_config.cmx +tactics/auto.cmo: toplevel/vernacexpr.cmo lib/util.cmi pretyping/typing.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo library/summary.cmi kernel/sign.cmi proofs/refiner.cmi \ + kernel/reduction.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + parsing/printer.cmi translate/pptacticnew.cmi parsing/pptactic.cmi \ + lib/pp.cmi proofs/pfedit.cmi pretyping/pattern.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/matching.cmi proofs/logic.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + kernel/inductive.cmi tactics/hipattern.cmi tactics/hiddentac.cmi \ + library/global.cmi pretyping/evd.cmi proofs/evar_refiner.cmi \ + tactics/dhyp.cmi kernel/declarations.cmi interp/constrintern.cmi \ + proofs/clenv.cmi tactics/btermdn.cmi tactics/auto.cmi +tactics/auto.cmx: toplevel/vernacexpr.cmx lib/util.cmx pretyping/typing.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx pretyping/tacred.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx library/summary.cmx kernel/sign.cmx proofs/refiner.cmx \ + kernel/reduction.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + parsing/printer.cmx translate/pptacticnew.cmx parsing/pptactic.cmx \ + lib/pp.cmx proofs/pfedit.cmx pretyping/pattern.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/matching.cmx proofs/logic.cmx library/library.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + kernel/inductive.cmx tactics/hipattern.cmx tactics/hiddentac.cmx \ + library/global.cmx pretyping/evd.cmx proofs/evar_refiner.cmx \ + tactics/dhyp.cmx kernel/declarations.cmx interp/constrintern.cmx \ + proofs/clenv.cmx tactics/btermdn.cmx tactics/auto.cmi +tactics/autorewrite.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo library/summary.cmi \ + proofs/proof_type.cmi lib/pp.cmi kernel/names.cmi library/libobject.cmi \ + library/lib.cmi tactics/hipattern.cmi tactics/equality.cmi \ + parsing/coqast.cmi parsing/ast.cmi tactics/autorewrite.cmi +tactics/autorewrite.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx library/summary.cmx \ + proofs/proof_type.cmx lib/pp.cmx kernel/names.cmx library/libobject.cmx \ + library/lib.cmx tactics/hipattern.cmx tactics/equality.cmx \ + parsing/coqast.cmx parsing/ast.cmx tactics/autorewrite.cmi +tactics/btermdn.cmo: tactics/termdn.cmi kernel/term.cmi pretyping/pattern.cmi \ + tactics/dn.cmi tactics/btermdn.cmi +tactics/btermdn.cmx: tactics/termdn.cmx kernel/term.cmx pretyping/pattern.cmx \ + tactics/dn.cmx tactics/btermdn.cmi +tactics/contradiction.cmo: lib/util.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi pretyping/reductionops.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi tactics/hipattern.cmi \ + interp/coqlib.cmi tactics/contradiction.cmi +tactics/contradiction.cmx: lib/util.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx pretyping/reductionops.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx tactics/hipattern.cmx \ + interp/coqlib.cmx tactics/contradiction.cmi +tactics/dhyp.cmo: lib/util.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + library/summary.cmi proofs/refiner.cmi kernel/reduction.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi lib/pp.cmi parsing/pcoq.cmi \ + pretyping/pattern.cmi tactics/nbtermdn.cmi kernel/names.cmi \ + pretyping/matching.cmi library/library.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi interp/constrintern.cmi proofs/clenv.cmi \ + parsing/ast.cmi tactics/dhyp.cmi +tactics/dhyp.cmx: lib/util.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx proofs/tacexpr.cmx \ + library/summary.cmx proofs/refiner.cmx kernel/reduction.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx lib/pp.cmx parsing/pcoq.cmx \ + pretyping/pattern.cmx tactics/nbtermdn.cmx kernel/names.cmx \ + pretyping/matching.cmx library/library.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx interp/constrintern.cmx proofs/clenv.cmx \ + parsing/ast.cmx tactics/dhyp.cmi tactics/dn.cmo: lib/tlm.cmi tactics/dn.cmi tactics/dn.cmx: lib/tlm.cmx tactics/dn.cmi -tactics/eauto.cmo: tactics/auto.cmi toplevel/cerrors.cmi proofs/clenv.cmi \ - kernel/declarations.cmi parsing/egrammar.cmi proofs/evar_refiner.cmi \ - lib/explore.cmi parsing/extend.cmi interp/genarg.cmi library/global.cmi \ - proofs/logic.cmi library/nameops.cmi kernel/names.cmi lib/options.cmi \ - pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi pretyping/rawterm.cmi \ - kernel/reduction.cmi proofs/refiner.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi tactics/eauto.cmi -tactics/eauto.cmx: tactics/auto.cmx toplevel/cerrors.cmx proofs/clenv.cmx \ - kernel/declarations.cmx parsing/egrammar.cmx proofs/evar_refiner.cmx \ - lib/explore.cmx parsing/extend.cmx interp/genarg.cmx library/global.cmx \ - proofs/logic.cmx library/nameops.cmx kernel/names.cmx lib/options.cmx \ - pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx pretyping/rawterm.cmx \ - kernel/reduction.cmx proofs/refiner.cmx kernel/sign.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx tactics/eauto.cmi -tactics/elim.cmo: proofs/clenv.cmi kernel/environ.cmi interp/genarg.cmi \ - tactics/hiddentac.cmi tactics/hipattern.cmi pretyping/inductiveops.cmi \ - library/libnames.cmi kernel/names.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_type.cmi kernel/reduction.cmi proofs/refiner.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ - tactics/elim.cmi -tactics/elim.cmx: proofs/clenv.cmx kernel/environ.cmx interp/genarg.cmx \ - tactics/hiddentac.cmx tactics/hipattern.cmx pretyping/inductiveops.cmx \ - library/libnames.cmx kernel/names.cmx lib/pp.cmx parsing/printer.cmx \ - proofs/proof_type.cmx kernel/reduction.cmx proofs/refiner.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ - tactics/elim.cmi -tactics/eqdecide.cmo: tactics/auto.cmi toplevel/cerrors.cmi interp/coqlib.cmi \ - kernel/declarations.cmi parsing/egrammar.cmi tactics/equality.cmi \ - tactics/extratactics.cmi interp/genarg.cmi library/global.cmi \ - tactics/hiddentac.cmi tactics/hipattern.cmi pretyping/matching.cmi \ - library/nameops.cmi kernel/names.cmi lib/options.cmi \ - pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi pretyping/rawterm.cmi \ - proofs/refiner.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi lib/util.cmi -tactics/eqdecide.cmx: tactics/auto.cmx toplevel/cerrors.cmx interp/coqlib.cmx \ - kernel/declarations.cmx parsing/egrammar.cmx tactics/equality.cmx \ - tactics/extratactics.cmx interp/genarg.cmx library/global.cmx \ - tactics/hiddentac.cmx tactics/hipattern.cmx pretyping/matching.cmx \ - library/nameops.cmx kernel/names.cmx lib/options.cmx \ - pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx pretyping/rawterm.cmx \ - proofs/refiner.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx lib/util.cmx -tactics/equality.cmo: proofs/clenv.cmi interp/coqlib.cmi \ - kernel/declarations.cmi kernel/environ.cmi proofs/evar_refiner.cmi \ - pretyping/evarconv.cmi pretyping/evarutil.cmi tactics/hipattern.cmi \ - pretyping/indrec.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - pretyping/instantiate.cmi proofs/logic.cmi pretyping/matching.cmi \ - library/nameops.cmi kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi pretyping/reductionops.cmi \ - pretyping/retyping.cmi tactics/setoid_replace.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi pretyping/tacred.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/typeops.cmi pretyping/typing.cmi \ - kernel/univ.cmi lib/util.cmi toplevel/vernacexpr.cmo tactics/equality.cmi -tactics/equality.cmx: proofs/clenv.cmx interp/coqlib.cmx \ - kernel/declarations.cmx kernel/environ.cmx proofs/evar_refiner.cmx \ - pretyping/evarconv.cmx pretyping/evarutil.cmx tactics/hipattern.cmx \ - pretyping/indrec.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - pretyping/instantiate.cmx proofs/logic.cmx pretyping/matching.cmx \ - library/nameops.cmx kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx pretyping/reductionops.cmx \ - pretyping/retyping.cmx tactics/setoid_replace.cmx kernel/sign.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx pretyping/tacred.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/typeops.cmx pretyping/typing.cmx \ - kernel/univ.cmx lib/util.cmx toplevel/vernacexpr.cmx tactics/equality.cmi -tactics/extraargs.cmo: parsing/extend.cmi interp/genarg.cmi \ - toplevel/metasyntax.cmi parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - tactics/tacinterp.cmi tactics/extraargs.cmi -tactics/extraargs.cmx: parsing/extend.cmx interp/genarg.cmx \ - toplevel/metasyntax.cmx parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - tactics/tacinterp.cmx tactics/extraargs.cmi -tactics/extratactics.cmo: tactics/autorewrite.cmi toplevel/cerrors.cmi \ - interp/constrintern.cmi tactics/contradiction.cmi parsing/egrammar.cmi \ - tactics/equality.cmi pretyping/evd.cmi tactics/extraargs.cmi \ - interp/genarg.cmi library/global.cmi tactics/inv.cmi tactics/leminv.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/nametab.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi pretyping/rawterm.cmi tactics/refine.cmi \ - proofs/refiner.cmi tactics/setoid_replace.cmi library/summary.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi lib/util.cmi \ - toplevel/vernacinterp.cmi tactics/extratactics.cmi -tactics/extratactics.cmx: tactics/autorewrite.cmx toplevel/cerrors.cmx \ - interp/constrintern.cmx tactics/contradiction.cmx parsing/egrammar.cmx \ - tactics/equality.cmx pretyping/evd.cmx tactics/extraargs.cmx \ - interp/genarg.cmx library/global.cmx tactics/inv.cmx tactics/leminv.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/nametab.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx pretyping/rawterm.cmx tactics/refine.cmx \ - proofs/refiner.cmx tactics/setoid_replace.cmx library/summary.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx lib/util.cmx \ - toplevel/vernacinterp.cmx tactics/extratactics.cmi -tactics/hiddentac.cmo: proofs/evar_refiner.cmi interp/genarg.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi proofs/refiner.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi tactics/tactics.cmi kernel/term.cmi \ - lib/util.cmi tactics/hiddentac.cmi -tactics/hiddentac.cmx: proofs/evar_refiner.cmx interp/genarg.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx proofs/refiner.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx tactics/tactics.cmx kernel/term.cmx \ - lib/util.cmx tactics/hiddentac.cmi -tactics/hipattern.cmo: proofs/clenv.cmi interp/coqlib.cmi \ - kernel/declarations.cmi kernel/environ.cmi pretyping/evd.cmi \ - library/global.cmi pretyping/inductiveops.cmi pretyping/matching.cmi \ - library/nameops.cmi kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi \ - proofs/proof_trees.cmi pretyping/reductionops.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +tactics/eauto.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + proofs/refiner.cmi kernel/reduction.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi parsing/pptactic.cmi \ + lib/pp.cmi parsing/pcoq.cmi pretyping/pattern.cmi lib/options.cmi \ + kernel/names.cmi library/nameops.cmi proofs/logic.cmi library/global.cmi \ + interp/genarg.cmi parsing/extend.cmi lib/explore.cmi \ + proofs/evar_refiner.cmi parsing/egrammar.cmi kernel/declarations.cmi \ + proofs/clenv.cmi toplevel/cerrors.cmi tactics/auto.cmi tactics/eauto.cmi +tactics/eauto.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + proofs/refiner.cmx kernel/reduction.cmx pretyping/rawterm.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx parsing/pptactic.cmx \ + lib/pp.cmx parsing/pcoq.cmx pretyping/pattern.cmx lib/options.cmx \ + kernel/names.cmx library/nameops.cmx proofs/logic.cmx library/global.cmx \ + interp/genarg.cmx parsing/extend.cmx lib/explore.cmx \ + proofs/evar_refiner.cmx parsing/egrammar.cmx kernel/declarations.cmx \ + proofs/clenv.cmx toplevel/cerrors.cmx tactics/auto.cmx tactics/eauto.cmi +tactics/elim.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo proofs/refiner.cmi kernel/reduction.cmi \ + proofs/proof_type.cmi parsing/printer.cmi lib/pp.cmi kernel/names.cmi \ + library/libnames.cmi pretyping/inductiveops.cmi tactics/hipattern.cmi \ + tactics/hiddentac.cmi interp/genarg.cmi kernel/environ.cmi \ + proofs/clenv.cmi tactics/elim.cmi +tactics/elim.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx proofs/refiner.cmx kernel/reduction.cmx \ + proofs/proof_type.cmx parsing/printer.cmx lib/pp.cmx kernel/names.cmx \ + library/libnames.cmx pretyping/inductiveops.cmx tactics/hipattern.cmx \ + tactics/hiddentac.cmx interp/genarg.cmx kernel/environ.cmx \ + proofs/clenv.cmx tactics/elim.cmi +tactics/eqdecide.cmo: lib/util.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo proofs/refiner.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi parsing/pptactic.cmi \ + lib/pp.cmi parsing/pcoq.cmi pretyping/pattern.cmi lib/options.cmi \ + kernel/names.cmi library/nameops.cmi pretyping/matching.cmi \ + tactics/hipattern.cmi tactics/hiddentac.cmi library/global.cmi \ + interp/genarg.cmi tactics/extratactics.cmi tactics/equality.cmi \ + parsing/egrammar.cmi kernel/declarations.cmi interp/coqlib.cmi \ + toplevel/cerrors.cmi tactics/auto.cmi +tactics/eqdecide.cmx: lib/util.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx proofs/refiner.cmx pretyping/rawterm.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx parsing/pptactic.cmx \ + lib/pp.cmx parsing/pcoq.cmx pretyping/pattern.cmx lib/options.cmx \ + kernel/names.cmx library/nameops.cmx pretyping/matching.cmx \ + tactics/hipattern.cmx tactics/hiddentac.cmx library/global.cmx \ + interp/genarg.cmx tactics/extratactics.cmx tactics/equality.cmx \ + parsing/egrammar.cmx kernel/declarations.cmx interp/coqlib.cmx \ + toplevel/cerrors.cmx tactics/auto.cmx +tactics/equality.cmo: toplevel/vernacexpr.cmo lib/util.cmi kernel/univ.cmi \ + pretyping/typing.cmi kernel/typeops.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + pretyping/tacred.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + kernel/sign.cmi tactics/setoid_replace.cmi pretyping/retyping.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/matching.cmi proofs/logic.cmi library/libnames.cmi \ + pretyping/instantiate.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + pretyping/indrec.cmi tactics/hipattern.cmi pretyping/evarutil.cmi \ + pretyping/evarconv.cmi proofs/evar_refiner.cmi kernel/environ.cmi \ + kernel/declarations.cmi interp/coqlib.cmi proofs/clenv.cmi \ + tactics/equality.cmi +tactics/equality.cmx: toplevel/vernacexpr.cmx lib/util.cmx kernel/univ.cmx \ + pretyping/typing.cmx kernel/typeops.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + pretyping/tacred.cmx proofs/tacmach.cmx proofs/tacexpr.cmx \ + kernel/sign.cmx tactics/setoid_replace.cmx pretyping/retyping.cmx \ + pretyping/reductionops.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/matching.cmx proofs/logic.cmx library/libnames.cmx \ + pretyping/instantiate.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + pretyping/indrec.cmx tactics/hipattern.cmx pretyping/evarutil.cmx \ + pretyping/evarconv.cmx proofs/evar_refiner.cmx kernel/environ.cmx \ + kernel/declarations.cmx interp/coqlib.cmx proofs/clenv.cmx \ + tactics/equality.cmi +tactics/extraargs.cmo: tactics/tacinterp.cmi parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi toplevel/metasyntax.cmi interp/genarg.cmi \ + parsing/extend.cmi tactics/extraargs.cmi +tactics/extraargs.cmx: tactics/tacinterp.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx toplevel/metasyntax.cmx interp/genarg.cmx \ + parsing/extend.cmx tactics/extraargs.cmi +tactics/extratactics.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo library/summary.cmi \ + tactics/setoid_replace.cmi proofs/refiner.cmi tactics/refine.cmi \ + pretyping/rawterm.cmi parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi library/nametab.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi tactics/leminv.cmi tactics/inv.cmi \ + library/global.cmi interp/genarg.cmi tactics/extraargs.cmi \ + pretyping/evd.cmi tactics/equality.cmi parsing/egrammar.cmi \ + tactics/contradiction.cmi interp/constrintern.cmi toplevel/cerrors.cmi \ + tactics/autorewrite.cmi tactics/extratactics.cmi +tactics/extratactics.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx library/summary.cmx \ + tactics/setoid_replace.cmx proofs/refiner.cmx tactics/refine.cmx \ + pretyping/rawterm.cmx parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx library/nametab.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx tactics/leminv.cmx tactics/inv.cmx \ + library/global.cmx interp/genarg.cmx tactics/extraargs.cmx \ + pretyping/evd.cmx tactics/equality.cmx parsing/egrammar.cmx \ + tactics/contradiction.cmx interp/constrintern.cmx toplevel/cerrors.cmx \ + tactics/autorewrite.cmx tactics/extratactics.cmi +tactics/hiddentac.cmo: lib/util.cmi kernel/term.cmi tactics/tactics.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo proofs/refiner.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi interp/genarg.cmi \ + proofs/evar_refiner.cmi tactics/hiddentac.cmi +tactics/hiddentac.cmx: lib/util.cmx kernel/term.cmx tactics/tactics.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx proofs/refiner.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx interp/genarg.cmx \ + proofs/evar_refiner.cmx tactics/hiddentac.cmi +tactics/hipattern.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi pretyping/reductionops.cmi \ + proofs/proof_trees.cmi lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi \ + library/nameops.cmi pretyping/matching.cmi pretyping/inductiveops.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi interp/coqlib.cmi proofs/clenv.cmi \ tactics/hipattern.cmi -tactics/hipattern.cmx: proofs/clenv.cmx interp/coqlib.cmx \ - kernel/declarations.cmx kernel/environ.cmx pretyping/evd.cmx \ - library/global.cmx pretyping/inductiveops.cmx pretyping/matching.cmx \ - library/nameops.cmx kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx \ - proofs/proof_trees.cmx pretyping/reductionops.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +tactics/hipattern.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx pretyping/reductionops.cmx \ + proofs/proof_trees.cmx lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx \ + library/nameops.cmx pretyping/matching.cmx pretyping/inductiveops.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx interp/coqlib.cmx proofs/clenv.cmx \ tactics/hipattern.cmi -tactics/inv.cmo: proofs/clenv.cmi interp/coqlib.cmi tactics/elim.cmi \ - kernel/environ.cmi tactics/equality.cmi proofs/evar_refiner.cmi \ - interp/genarg.cmi library/global.cmi tactics/hipattern.cmi \ - pretyping/inductiveops.cmi pretyping/matching.cmi library/nameops.cmi \ - kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/reduction.cmi \ - pretyping/reductionops.cmi pretyping/retyping.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi \ - pretyping/typing.cmi lib/util.cmi tactics/inv.cmi -tactics/inv.cmx: proofs/clenv.cmx interp/coqlib.cmx tactics/elim.cmx \ - kernel/environ.cmx tactics/equality.cmx proofs/evar_refiner.cmx \ - interp/genarg.cmx library/global.cmx tactics/hipattern.cmx \ - pretyping/inductiveops.cmx pretyping/matching.cmx library/nameops.cmx \ - kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx parsing/printer.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx kernel/reduction.cmx \ - pretyping/reductionops.cmx pretyping/retyping.cmx kernel/sign.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx \ - pretyping/typing.cmx lib/util.cmx tactics/inv.cmi -tactics/leminv.cmo: proofs/clenv.cmi interp/constrintern.cmi \ - library/decl_kinds.cmo kernel/declarations.cmi library/declare.cmi \ - kernel/entries.cmi kernel/environ.cmi proofs/evar_refiner.cmi \ - pretyping/evd.cmi library/global.cmi pretyping/inductiveops.cmi \ - tactics/inv.cmi library/nameops.cmi kernel/names.cmi proofs/pfedit.cmi \ - lib/pp.cmi pretyping/pretyping.cmi parsing/printer.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi pretyping/reductionops.cmi \ - kernel/safe_typing.cmi kernel/sign.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi toplevel/vernacexpr.cmo \ +tactics/inv.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + pretyping/retyping.cmi pretyping/reductionops.cmi kernel/reduction.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi parsing/printer.cmi \ + lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/matching.cmi pretyping/inductiveops.cmi tactics/hipattern.cmi \ + library/global.cmi interp/genarg.cmi proofs/evar_refiner.cmi \ + tactics/equality.cmi kernel/environ.cmi tactics/elim.cmi \ + interp/coqlib.cmi proofs/clenv.cmi tactics/inv.cmi +tactics/inv.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + pretyping/retyping.cmx pretyping/reductionops.cmx kernel/reduction.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx parsing/printer.cmx \ + lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/matching.cmx pretyping/inductiveops.cmx tactics/hipattern.cmx \ + library/global.cmx interp/genarg.cmx proofs/evar_refiner.cmx \ + tactics/equality.cmx kernel/environ.cmx tactics/elim.cmx \ + interp/coqlib.cmx proofs/clenv.cmx tactics/inv.cmi +tactics/leminv.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi kernel/sign.cmi \ + kernel/safe_typing.cmi pretyping/reductionops.cmi proofs/proof_type.cmi \ + proofs/proof_trees.cmi parsing/printer.cmi pretyping/pretyping.cmi \ + lib/pp.cmi proofs/pfedit.cmi kernel/names.cmi library/nameops.cmi \ + tactics/inv.cmi pretyping/inductiveops.cmi library/global.cmi \ + pretyping/evd.cmi proofs/evar_refiner.cmi kernel/environ.cmi \ + kernel/entries.cmi library/declare.cmi kernel/declarations.cmi \ + library/decl_kinds.cmo interp/constrintern.cmi proofs/clenv.cmi \ tactics/leminv.cmi -tactics/leminv.cmx: proofs/clenv.cmx interp/constrintern.cmx \ - library/decl_kinds.cmx kernel/declarations.cmx library/declare.cmx \ - kernel/entries.cmx kernel/environ.cmx proofs/evar_refiner.cmx \ - pretyping/evd.cmx library/global.cmx pretyping/inductiveops.cmx \ - tactics/inv.cmx library/nameops.cmx kernel/names.cmx proofs/pfedit.cmx \ - lib/pp.cmx pretyping/pretyping.cmx parsing/printer.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx pretyping/reductionops.cmx \ - kernel/safe_typing.cmx kernel/sign.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx toplevel/vernacexpr.cmx \ +tactics/leminv.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx kernel/sign.cmx \ + kernel/safe_typing.cmx pretyping/reductionops.cmx proofs/proof_type.cmx \ + proofs/proof_trees.cmx parsing/printer.cmx pretyping/pretyping.cmx \ + lib/pp.cmx proofs/pfedit.cmx kernel/names.cmx library/nameops.cmx \ + tactics/inv.cmx pretyping/inductiveops.cmx library/global.cmx \ + pretyping/evd.cmx proofs/evar_refiner.cmx kernel/environ.cmx \ + kernel/entries.cmx library/declare.cmx kernel/declarations.cmx \ + library/decl_kinds.cmx interp/constrintern.cmx proofs/clenv.cmx \ tactics/leminv.cmi -tactics/nbtermdn.cmo: tactics/btermdn.cmi lib/gmap.cmi library/libobject.cmi \ - library/library.cmi kernel/names.cmi pretyping/pattern.cmi \ - kernel/term.cmi tactics/termdn.cmi lib/util.cmi tactics/nbtermdn.cmi -tactics/nbtermdn.cmx: tactics/btermdn.cmx lib/gmap.cmx library/libobject.cmx \ - library/library.cmx kernel/names.cmx pretyping/pattern.cmx \ - kernel/term.cmx tactics/termdn.cmx lib/util.cmx tactics/nbtermdn.cmi -tactics/refine.cmo: proofs/clenv.cmi kernel/environ.cmi pretyping/evd.cmi \ - kernel/names.cmi lib/pp.cmi parsing/printer.cmi kernel/reduction.cmi \ - pretyping/retyping.cmi kernel/sign.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - tactics/refine.cmi -tactics/refine.cmx: proofs/clenv.cmx kernel/environ.cmx pretyping/evd.cmx \ - kernel/names.cmx lib/pp.cmx parsing/printer.cmx kernel/reduction.cmx \ - pretyping/retyping.cmx kernel/sign.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - tactics/refine.cmi -tactics/setoid_replace.cmo: tactics/auto.cmi interp/constrintern.cmi \ - interp/coqlib.cmi library/decl_kinds.cmo library/declare.cmi \ - kernel/entries.cmi kernel/environ.cmi pretyping/evd.cmi \ - library/global.cmi lib/gmap.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi proofs/pfedit.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_type.cmi pretyping/reductionops.cmi \ - kernel/safe_typing.cmi library/summary.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo tactics/setoid_replace.cmi -tactics/setoid_replace.cmx: tactics/auto.cmx interp/constrintern.cmx \ - interp/coqlib.cmx library/decl_kinds.cmx library/declare.cmx \ - kernel/entries.cmx kernel/environ.cmx pretyping/evd.cmx \ - library/global.cmx lib/gmap.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx proofs/pfedit.cmx lib/pp.cmx \ - parsing/printer.cmx proofs/proof_type.cmx pretyping/reductionops.cmx \ - kernel/safe_typing.cmx library/summary.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx tactics/setoid_replace.cmi -tactics/tacinterp.cmo: parsing/ast.cmi tactics/auto.cmi kernel/closure.cmi \ - interp/constrintern.cmi parsing/coqast.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi tactics/dhyp.cmi lib/dyn.cmi tactics/elim.cmi \ - kernel/entries.cmi kernel/environ.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/global.cmi lib/gmap.cmi tactics/hiddentac.cmi tactics/inv.cmi \ - tactics/leminv.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi proofs/logic.cmi pretyping/matching.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - pretyping/pattern.cmi proofs/pfedit.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi pretyping/pretyping.cmi parsing/printer.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi proofs/refiner.cmi \ - pretyping/retyping.cmi kernel/safe_typing.cmi kernel/sign.cmi \ - library/summary.cmi interp/syntax_def.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi pretyping/tacred.cmi proofs/tactic_debug.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi pretyping/typing.cmi lib/util.cmi \ - tactics/tacinterp.cmi -tactics/tacinterp.cmx: parsing/ast.cmx tactics/auto.cmx kernel/closure.cmx \ - interp/constrintern.cmx parsing/coqast.cmx library/decl_kinds.cmx \ - kernel/declarations.cmx tactics/dhyp.cmx lib/dyn.cmx tactics/elim.cmx \ - kernel/entries.cmx kernel/environ.cmx pretyping/evd.cmx interp/genarg.cmx \ - library/global.cmx lib/gmap.cmx tactics/hiddentac.cmx tactics/inv.cmx \ - tactics/leminv.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx proofs/logic.cmx pretyping/matching.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - pretyping/pattern.cmx proofs/pfedit.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx pretyping/pretyping.cmx parsing/printer.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx proofs/refiner.cmx \ - pretyping/retyping.cmx kernel/safe_typing.cmx kernel/sign.cmx \ - library/summary.cmx interp/syntax_def.cmx proofs/tacexpr.cmx \ - proofs/tacmach.cmx pretyping/tacred.cmx proofs/tactic_debug.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx \ - interp/topconstr.cmx pretyping/typing.cmx lib/util.cmx \ - tactics/tacinterp.cmi -tactics/tacticals.cmo: proofs/clenv.cmi kernel/declarations.cmi \ - kernel/environ.cmi proofs/evar_refiner.cmi interp/genarg.cmi \ - library/global.cmi pretyping/indrec.cmi kernel/inductive.cmi \ - library/libnames.cmi pretyping/matching.cmi kernel/names.cmi \ - pretyping/pattern.cmi lib/pp.cmi kernel/reduction.cmi proofs/refiner.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi tactics/tacticals.cmi -tactics/tacticals.cmx: proofs/clenv.cmx kernel/declarations.cmx \ - kernel/environ.cmx proofs/evar_refiner.cmx interp/genarg.cmx \ - library/global.cmx pretyping/indrec.cmx kernel/inductive.cmx \ - library/libnames.cmx pretyping/matching.cmx kernel/names.cmx \ - pretyping/pattern.cmx lib/pp.cmx kernel/reduction.cmx proofs/refiner.cmx \ - kernel/sign.cmx proofs/tacexpr.cmx proofs/tacmach.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx tactics/tacticals.cmi -tactics/tactics.cmo: proofs/clenv.cmi interp/constrintern.cmi \ - interp/coqlib.cmi library/decl_kinds.cmo kernel/declarations.cmi \ - library/declare.cmi kernel/entries.cmi kernel/environ.cmi \ - proofs/evar_refiner.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/global.cmi tactics/hipattern.cmi pretyping/indrec.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi library/libnames.cmi \ - proofs/logic.cmi library/nameops.cmi kernel/names.cmi library/nametab.cmi \ - lib/options.cmi proofs/pfedit.cmi lib/pp.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi pretyping/reductionops.cmi \ - proofs/refiner.cmi kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - pretyping/tacred.cmi tactics/tacticals.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi tactics/tactics.cmi -tactics/tactics.cmx: proofs/clenv.cmx interp/constrintern.cmx \ - interp/coqlib.cmx library/decl_kinds.cmx kernel/declarations.cmx \ - library/declare.cmx kernel/entries.cmx kernel/environ.cmx \ - proofs/evar_refiner.cmx pretyping/evd.cmx interp/genarg.cmx \ - library/global.cmx tactics/hipattern.cmx pretyping/indrec.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx library/libnames.cmx \ - proofs/logic.cmx library/nameops.cmx kernel/names.cmx library/nametab.cmx \ - lib/options.cmx proofs/pfedit.cmx lib/pp.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx pretyping/reductionops.cmx \ - proofs/refiner.cmx kernel/sign.cmx proofs/tacexpr.cmx proofs/tacmach.cmx \ - pretyping/tacred.cmx tactics/tacticals.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx tactics/tactics.cmi -tactics/tauto.cmo: parsing/ast.cmi toplevel/cerrors.cmi parsing/coqast.cmi \ - parsing/egrammar.cmi interp/genarg.cmi tactics/hipattern.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi parsing/pptactic.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi proofs/refiner.cmi proofs/tacexpr.cmo \ - tactics/tacinterp.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - interp/topconstr.cmi lib/util.cmi -tactics/tauto.cmx: parsing/ast.cmx toplevel/cerrors.cmx parsing/coqast.cmx \ - parsing/egrammar.cmx interp/genarg.cmx tactics/hipattern.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx parsing/pptactic.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx proofs/refiner.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - interp/topconstr.cmx lib/util.cmx -tactics/termdn.cmo: tactics/dn.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi pretyping/pattern.cmi \ - pretyping/rawterm.cmi kernel/term.cmi lib/util.cmi tactics/termdn.cmi -tactics/termdn.cmx: tactics/dn.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx pretyping/pattern.cmx \ - pretyping/rawterm.cmx kernel/term.cmx lib/util.cmx tactics/termdn.cmi -tools/coqdep.cmo: config/coq_config.cmi tools/coqdep_lexer.cmo -tools/coqdep.cmx: config/coq_config.cmx tools/coqdep_lexer.cmx +tactics/nbtermdn.cmo: lib/util.cmi tactics/termdn.cmi kernel/term.cmi \ + pretyping/pattern.cmi kernel/names.cmi library/library.cmi \ + library/libobject.cmi lib/gmap.cmi tactics/btermdn.cmi \ + tactics/nbtermdn.cmi +tactics/nbtermdn.cmx: lib/util.cmx tactics/termdn.cmx kernel/term.cmx \ + pretyping/pattern.cmx kernel/names.cmx library/library.cmx \ + library/libobject.cmx lib/gmap.cmx tactics/btermdn.cmx \ + tactics/nbtermdn.cmi +tactics/refine.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi kernel/sign.cmi pretyping/retyping.cmi \ + kernel/reduction.cmi parsing/printer.cmi lib/pp.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi proofs/clenv.cmi tactics/refine.cmi +tactics/refine.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx kernel/sign.cmx pretyping/retyping.cmx \ + kernel/reduction.cmx parsing/printer.cmx lib/pp.cmx kernel/names.cmx \ + pretyping/evd.cmx kernel/environ.cmx proofs/clenv.cmx tactics/refine.cmi +tactics/setoid_replace.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + pretyping/typing.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + library/summary.cmi kernel/safe_typing.cmi pretyping/reductionops.cmi \ + proofs/proof_type.cmi parsing/printer.cmi lib/pp.cmi proofs/pfedit.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi lib/gmap.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/entries.cmi library/declare.cmi library/decl_kinds.cmo \ + interp/coqlib.cmi interp/constrintern.cmi tactics/auto.cmi \ + tactics/setoid_replace.cmi +tactics/setoid_replace.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + pretyping/typing.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + library/summary.cmx kernel/safe_typing.cmx pretyping/reductionops.cmx \ + proofs/proof_type.cmx parsing/printer.cmx lib/pp.cmx proofs/pfedit.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx lib/gmap.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/entries.cmx library/declare.cmx library/decl_kinds.cmx \ + interp/coqlib.cmx interp/constrintern.cmx tactics/auto.cmx \ + tactics/setoid_replace.cmi +tactics/tacinterp.cmo: lib/util.cmi pretyping/typing.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + proofs/tactic_debug.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo interp/syntax_def.cmi library/summary.cmi \ + kernel/sign.cmi kernel/safe_typing.cmi pretyping/retyping.cmi \ + proofs/refiner.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + parsing/printer.cmi pretyping/pretyping.cmi pretyping/pretype_errors.cmi \ + lib/pp.cmi proofs/pfedit.cmi pretyping/pattern.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/matching.cmi proofs/logic.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi tactics/leminv.cmi tactics/inv.cmi \ + tactics/hiddentac.cmi lib/gmap.cmi library/global.cmi interp/genarg.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/entries.cmi tactics/elim.cmi \ + lib/dyn.cmi tactics/dhyp.cmi kernel/declarations.cmi \ + library/decl_kinds.cmo parsing/coqast.cmi interp/constrintern.cmi \ + kernel/closure.cmi tactics/auto.cmi parsing/ast.cmi tactics/tacinterp.cmi +tactics/tacinterp.cmx: lib/util.cmx pretyping/typing.cmx interp/topconstr.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + proofs/tactic_debug.cmx pretyping/tacred.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx interp/syntax_def.cmx library/summary.cmx \ + kernel/sign.cmx kernel/safe_typing.cmx pretyping/retyping.cmx \ + proofs/refiner.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + parsing/printer.cmx pretyping/pretyping.cmx pretyping/pretype_errors.cmx \ + lib/pp.cmx proofs/pfedit.cmx pretyping/pattern.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/matching.cmx proofs/logic.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx tactics/leminv.cmx tactics/inv.cmx \ + tactics/hiddentac.cmx lib/gmap.cmx library/global.cmx interp/genarg.cmx \ + pretyping/evd.cmx kernel/environ.cmx kernel/entries.cmx tactics/elim.cmx \ + lib/dyn.cmx tactics/dhyp.cmx kernel/declarations.cmx \ + library/decl_kinds.cmx parsing/coqast.cmx interp/constrintern.cmx \ + kernel/closure.cmx tactics/auto.cmx parsing/ast.cmx tactics/tacinterp.cmi +tactics/tacticals.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi proofs/refiner.cmi \ + kernel/reduction.cmi lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi \ + pretyping/matching.cmi library/libnames.cmi kernel/inductive.cmi \ + pretyping/indrec.cmi library/global.cmi interp/genarg.cmi \ + proofs/evar_refiner.cmi kernel/environ.cmi kernel/declarations.cmi \ + proofs/clenv.cmi tactics/tacticals.cmi +tactics/tacticals.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx proofs/refiner.cmx \ + kernel/reduction.cmx lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx \ + pretyping/matching.cmx library/libnames.cmx kernel/inductive.cmx \ + pretyping/indrec.cmx library/global.cmx interp/genarg.cmx \ + proofs/evar_refiner.cmx kernel/environ.cmx kernel/declarations.cmx \ + proofs/clenv.cmx tactics/tacticals.cmi +tactics/tactics.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tacticals.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo kernel/sign.cmi proofs/refiner.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + proofs/proof_trees.cmi lib/pp.cmi proofs/pfedit.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi proofs/logic.cmi \ + library/libnames.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + pretyping/indrec.cmi tactics/hipattern.cmi library/global.cmi \ + interp/genarg.cmi pretyping/evd.cmi proofs/evar_refiner.cmi \ + kernel/environ.cmi kernel/entries.cmi library/declare.cmi \ + kernel/declarations.cmi library/decl_kinds.cmo interp/coqlib.cmi \ + interp/constrintern.cmi proofs/clenv.cmi tactics/tactics.cmi +tactics/tactics.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tacticals.cmx pretyping/tacred.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx kernel/sign.cmx proofs/refiner.cmx \ + pretyping/reductionops.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + proofs/proof_trees.cmx lib/pp.cmx proofs/pfedit.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx proofs/logic.cmx \ + library/libnames.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + pretyping/indrec.cmx tactics/hipattern.cmx library/global.cmx \ + interp/genarg.cmx pretyping/evd.cmx proofs/evar_refiner.cmx \ + kernel/environ.cmx kernel/entries.cmx library/declare.cmx \ + kernel/declarations.cmx library/decl_kinds.cmx interp/coqlib.cmx \ + interp/constrintern.cmx proofs/clenv.cmx tactics/tactics.cmi +tactics/tauto.cmo: lib/util.cmi interp/topconstr.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi tactics/tacinterp.cmi proofs/tacexpr.cmo \ + proofs/refiner.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi tactics/hipattern.cmi \ + interp/genarg.cmi parsing/egrammar.cmi parsing/coqast.cmi \ + toplevel/cerrors.cmi parsing/ast.cmi +tactics/tauto.cmx: lib/util.cmx interp/topconstr.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx tactics/tacinterp.cmx proofs/tacexpr.cmx \ + proofs/refiner.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx tactics/hipattern.cmx \ + interp/genarg.cmx parsing/egrammar.cmx parsing/coqast.cmx \ + toplevel/cerrors.cmx parsing/ast.cmx +tactics/termdn.cmo: lib/util.cmi kernel/term.cmi pretyping/rawterm.cmi \ + pretyping/pattern.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi tactics/dn.cmi \ + tactics/termdn.cmi +tactics/termdn.cmx: lib/util.cmx kernel/term.cmx pretyping/rawterm.cmx \ + pretyping/pattern.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx tactics/dn.cmx \ + tactics/termdn.cmi +tools/coqdep.cmo: tools/coqdep_lexer.cmo config/coq_config.cmi +tools/coqdep.cmx: tools/coqdep_lexer.cmx config/coq_config.cmx tools/gallina.cmo: tools/gallina_lexer.cmo tools/gallina.cmx: tools/gallina_lexer.cmx -toplevel/cerrors.cmo: parsing/ast.cmi pretyping/cases.cmi toplevel/himsg.cmi \ - kernel/indtypes.cmi parsing/lexer.cmi library/libnames.cmi \ - proofs/logic.cmi library/nametab.cmi lib/options.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi proofs/refiner.cmi proofs/tactic_debug.cmi \ - kernel/type_errors.cmi kernel/univ.cmi lib/util.cmi toplevel/cerrors.cmi -toplevel/cerrors.cmx: parsing/ast.cmx pretyping/cases.cmx toplevel/himsg.cmx \ - kernel/indtypes.cmx parsing/lexer.cmx library/libnames.cmx \ - proofs/logic.cmx library/nametab.cmx lib/options.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx proofs/refiner.cmx proofs/tactic_debug.cmx \ - kernel/type_errors.cmx kernel/univ.cmx lib/util.cmx toplevel/cerrors.cmi -toplevel/class.cmo: pretyping/classops.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi library/declare.cmi kernel/entries.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi \ - kernel/inductive.cmi library/lib.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi parsing/printer.cmi pretyping/reductionops.cmi \ - pretyping/retyping.cmi kernel/safe_typing.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ +toplevel/cerrors.cmo: lib/util.cmi kernel/univ.cmi kernel/type_errors.cmi \ + proofs/tactic_debug.cmi proofs/refiner.cmi pretyping/pretype_errors.cmi \ + lib/pp.cmi lib/options.cmi library/nametab.cmi proofs/logic.cmi \ + library/libnames.cmi parsing/lexer.cmi kernel/indtypes.cmi \ + toplevel/himsg.cmi pretyping/cases.cmi parsing/ast.cmi \ + toplevel/cerrors.cmi +toplevel/cerrors.cmx: lib/util.cmx kernel/univ.cmx kernel/type_errors.cmx \ + proofs/tactic_debug.cmx proofs/refiner.cmx pretyping/pretype_errors.cmx \ + lib/pp.cmx lib/options.cmx library/nametab.cmx proofs/logic.cmx \ + library/libnames.cmx parsing/lexer.cmx kernel/indtypes.cmx \ + toplevel/himsg.cmx pretyping/cases.cmx parsing/ast.cmx \ + toplevel/cerrors.cmi +toplevel/class.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi kernel/safe_typing.cmi \ + pretyping/retyping.cmi pretyping/reductionops.cmi parsing/printer.cmi \ + lib/pp.cmi lib/options.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi library/lib.cmi \ + kernel/inductive.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi kernel/entries.cmi library/declare.cmi \ + kernel/declarations.cmi library/decl_kinds.cmo pretyping/classops.cmi \ toplevel/class.cmi -toplevel/class.cmx: pretyping/classops.cmx library/decl_kinds.cmx \ - kernel/declarations.cmx library/declare.cmx kernel/entries.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx \ - kernel/inductive.cmx library/lib.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx parsing/printer.cmx pretyping/reductionops.cmx \ - pretyping/retyping.cmx kernel/safe_typing.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ +toplevel/class.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx kernel/safe_typing.cmx \ + pretyping/retyping.cmx pretyping/reductionops.cmx parsing/printer.cmx \ + lib/pp.cmx lib/options.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx library/lib.cmx \ + kernel/inductive.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx kernel/entries.cmx library/declare.cmx \ + kernel/declarations.cmx library/decl_kinds.cmx pretyping/classops.cmx \ toplevel/class.cmi -toplevel/command.cmo: toplevel/class.cmi interp/constrextern.cmi \ - interp/constrintern.cmi library/decl_kinds.cmo kernel/declarations.cmi \ - library/declare.cmi kernel/entries.cmi kernel/environ.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi library/global.cmi \ - library/impargs.cmi pretyping/indrec.cmi kernel/indtypes.cmi \ - kernel/inductive.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi proofs/logic.cmi \ - toplevel/metasyntax.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi proofs/pfedit.cmi lib/pp.cmi \ - pretyping/pretyping.cmi parsing/printer.cmi proofs/proof_type.cmi \ - kernel/reduction.cmi pretyping/reductionops.cmi pretyping/retyping.cmi \ - kernel/safe_typing.cmi library/states.cmi interp/symbols.cmi \ - interp/syntax_def.cmi proofs/tacmach.cmi pretyping/tacred.cmi \ - kernel/term.cmi pretyping/termops.cmi interp/topconstr.cmi \ - kernel/typeops.cmi lib/util.cmi toplevel/vernacexpr.cmo \ - toplevel/command.cmi -toplevel/command.cmx: toplevel/class.cmx interp/constrextern.cmx \ - interp/constrintern.cmx library/decl_kinds.cmx kernel/declarations.cmx \ - library/declare.cmx kernel/entries.cmx kernel/environ.cmx \ - pretyping/evarutil.cmx pretyping/evd.cmx library/global.cmx \ - library/impargs.cmx pretyping/indrec.cmx kernel/indtypes.cmx \ - kernel/inductive.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/library.cmx proofs/logic.cmx \ - toplevel/metasyntax.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx proofs/pfedit.cmx lib/pp.cmx \ - pretyping/pretyping.cmx parsing/printer.cmx proofs/proof_type.cmx \ - kernel/reduction.cmx pretyping/reductionops.cmx pretyping/retyping.cmx \ - kernel/safe_typing.cmx library/states.cmx interp/symbols.cmx \ - interp/syntax_def.cmx proofs/tacmach.cmx pretyping/tacred.cmx \ - kernel/term.cmx pretyping/termops.cmx interp/topconstr.cmx \ - kernel/typeops.cmx lib/util.cmx toplevel/vernacexpr.cmx \ - toplevel/command.cmi -toplevel/coqinit.cmo: config/coq_config.cmi toplevel/mltop.cmi \ - library/nameops.cmi kernel/names.cmi lib/options.cmi lib/pp.cmi \ - lib/system.cmi toplevel/toplevel.cmi toplevel/vernac.cmi \ +toplevel/command.cmo: toplevel/vernacexpr.cmo lib/util.cmi kernel/typeops.cmi \ + interp/topconstr.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/tacred.cmi proofs/tacmach.cmi interp/syntax_def.cmi \ + interp/symbols.cmi library/states.cmi kernel/safe_typing.cmi \ + pretyping/retyping.cmi pretyping/reductionops.cmi kernel/reduction.cmi \ + proofs/proof_type.cmi parsing/printer.cmi pretyping/pretyping.cmi \ + lib/pp.cmi proofs/pfedit.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi toplevel/metasyntax.cmi \ + proofs/logic.cmi library/library.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi kernel/inductive.cmi \ + kernel/indtypes.cmi pretyping/indrec.cmi library/impargs.cmi \ + library/global.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + kernel/environ.cmi kernel/entries.cmi library/declare.cmi \ + kernel/declarations.cmi library/decl_kinds.cmo interp/constrintern.cmi \ + interp/constrextern.cmi toplevel/class.cmi toplevel/command.cmi +toplevel/command.cmx: toplevel/vernacexpr.cmx lib/util.cmx kernel/typeops.cmx \ + interp/topconstr.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/tacred.cmx proofs/tacmach.cmx interp/syntax_def.cmx \ + interp/symbols.cmx library/states.cmx kernel/safe_typing.cmx \ + pretyping/retyping.cmx pretyping/reductionops.cmx kernel/reduction.cmx \ + proofs/proof_type.cmx parsing/printer.cmx pretyping/pretyping.cmx \ + lib/pp.cmx proofs/pfedit.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx toplevel/metasyntax.cmx \ + proofs/logic.cmx library/library.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx kernel/inductive.cmx \ + kernel/indtypes.cmx pretyping/indrec.cmx library/impargs.cmx \ + library/global.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + kernel/environ.cmx kernel/entries.cmx library/declare.cmx \ + kernel/declarations.cmx library/decl_kinds.cmx interp/constrintern.cmx \ + interp/constrextern.cmx toplevel/class.cmx toplevel/command.cmi +toplevel/coqinit.cmo: toplevel/vernac.cmi toplevel/toplevel.cmi \ + lib/system.cmi lib/pp.cmi lib/options.cmi kernel/names.cmi \ + library/nameops.cmi toplevel/mltop.cmi config/coq_config.cmi \ toplevel/coqinit.cmi -toplevel/coqinit.cmx: config/coq_config.cmx toplevel/mltop.cmx \ - library/nameops.cmx kernel/names.cmx lib/options.cmx lib/pp.cmx \ - lib/system.cmx toplevel/toplevel.cmx toplevel/vernac.cmx \ +toplevel/coqinit.cmx: toplevel/vernac.cmx toplevel/toplevel.cmx \ + lib/system.cmx lib/pp.cmx lib/options.cmx kernel/names.cmx \ + library/nameops.cmx toplevel/mltop.cmx config/coq_config.cmx \ toplevel/coqinit.cmi -toplevel/coqtop.cmo: toplevel/cerrors.cmi config/coq_config.cmi \ - toplevel/coqinit.cmi library/declaremods.cmi kernel/environ.cmi \ - library/global.cmi library/lib.cmi library/libnames.cmi \ - library/library.cmi toplevel/mltop.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi lib/profile.cmi \ - library/states.cmi lib/system.cmi toplevel/toplevel.cmi \ - toplevel/usage.cmi lib/util.cmi toplevel/vernac.cmi toplevel/coqtop.cmi -toplevel/coqtop.cmx: toplevel/cerrors.cmx config/coq_config.cmx \ - toplevel/coqinit.cmx library/declaremods.cmx kernel/environ.cmx \ - library/global.cmx library/lib.cmx library/libnames.cmx \ - library/library.cmx toplevel/mltop.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx lib/profile.cmx \ - library/states.cmx lib/system.cmx toplevel/toplevel.cmx \ - toplevel/usage.cmx lib/util.cmx toplevel/vernac.cmx toplevel/coqtop.cmi -toplevel/discharge.cmo: toplevel/class.cmi pretyping/classops.cmi \ - kernel/cooking.cmi library/decl_kinds.cmo kernel/declarations.cmi \ - library/declare.cmi library/dischargedhypsmap.cmi kernel/entries.cmi \ - kernel/environ.cmi library/global.cmi library/impargs.cmi \ - kernel/indtypes.cmi kernel/inductive.cmi pretyping/instantiate.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi toplevel/recordobj.cmi \ - pretyping/recordops.cmi kernel/reduction.cmi kernel/sign.cmi \ - library/summary.cmi kernel/term.cmi kernel/typeops.cmi kernel/univ.cmi \ - lib/util.cmi toplevel/discharge.cmi -toplevel/discharge.cmx: toplevel/class.cmx pretyping/classops.cmx \ - kernel/cooking.cmx library/decl_kinds.cmx kernel/declarations.cmx \ - library/declare.cmx library/dischargedhypsmap.cmx kernel/entries.cmx \ - kernel/environ.cmx library/global.cmx library/impargs.cmx \ - kernel/indtypes.cmx kernel/inductive.cmx pretyping/instantiate.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx toplevel/recordobj.cmx \ - pretyping/recordops.cmx kernel/reduction.cmx kernel/sign.cmx \ - library/summary.cmx kernel/term.cmx kernel/typeops.cmx kernel/univ.cmx \ - lib/util.cmx toplevel/discharge.cmi -toplevel/fhimsg.cmo: kernel/environ.cmi parsing/g_minicoq.cmi \ - kernel/names.cmi lib/pp.cmi kernel/reduction.cmi kernel/sign.cmi \ - kernel/term.cmi kernel/type_errors.cmi lib/util.cmi toplevel/fhimsg.cmi -toplevel/fhimsg.cmx: kernel/environ.cmx parsing/g_minicoq.cmx \ - kernel/names.cmx lib/pp.cmx kernel/reduction.cmx kernel/sign.cmx \ - kernel/term.cmx kernel/type_errors.cmx lib/util.cmx toplevel/fhimsg.cmi -toplevel/himsg.cmo: parsing/ast.cmi pretyping/cases.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi library/impargs.cmi \ - kernel/indtypes.cmi kernel/inductive.cmi proofs/logic.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi pretyping/pretype_errors.cmi parsing/printer.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/type_errors.cmi lib/util.cmi \ - toplevel/himsg.cmi -toplevel/himsg.cmx: parsing/ast.cmx pretyping/cases.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx library/impargs.cmx \ - kernel/indtypes.cmx kernel/inductive.cmx proofs/logic.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx pretyping/pretype_errors.cmx parsing/printer.cmx \ - pretyping/rawterm.cmx kernel/reduction.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/type_errors.cmx lib/util.cmx \ - toplevel/himsg.cmi +toplevel/coqtop.cmo: toplevel/vernac.cmi lib/util.cmi toplevel/usage.cmi \ + toplevel/toplevel.cmi lib/system.cmi library/states.cmi lib/profile.cmi \ + lib/pp.cmi lib/options.cmi kernel/names.cmi library/nameops.cmi \ + toplevel/mltop.cmi library/library.cmi library/libnames.cmi \ + library/lib.cmi library/global.cmi kernel/environ.cmi \ + library/declaremods.cmi toplevel/coqinit.cmi config/coq_config.cmi \ + toplevel/cerrors.cmi toplevel/coqtop.cmi +toplevel/coqtop.cmx: toplevel/vernac.cmx lib/util.cmx toplevel/usage.cmx \ + toplevel/toplevel.cmx lib/system.cmx library/states.cmx lib/profile.cmx \ + lib/pp.cmx lib/options.cmx kernel/names.cmx library/nameops.cmx \ + toplevel/mltop.cmx library/library.cmx library/libnames.cmx \ + library/lib.cmx library/global.cmx kernel/environ.cmx \ + library/declaremods.cmx toplevel/coqinit.cmx config/coq_config.cmx \ + toplevel/cerrors.cmx toplevel/coqtop.cmi +toplevel/discharge.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/term.cmi library/summary.cmi kernel/sign.cmi kernel/reduction.cmi \ + pretyping/recordops.cmi toplevel/recordobj.cmi lib/pp.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/library.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi pretyping/instantiate.cmi kernel/inductive.cmi \ + kernel/indtypes.cmi library/impargs.cmi library/global.cmi \ + kernel/environ.cmi kernel/entries.cmi library/dischargedhypsmap.cmi \ + library/declare.cmi kernel/declarations.cmi library/decl_kinds.cmo \ + kernel/cooking.cmi pretyping/classops.cmi toplevel/class.cmi \ + toplevel/discharge.cmi +toplevel/discharge.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/term.cmx library/summary.cmx kernel/sign.cmx kernel/reduction.cmx \ + pretyping/recordops.cmx toplevel/recordobj.cmx lib/pp.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/library.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx pretyping/instantiate.cmx kernel/inductive.cmx \ + kernel/indtypes.cmx library/impargs.cmx library/global.cmx \ + kernel/environ.cmx kernel/entries.cmx library/dischargedhypsmap.cmx \ + library/declare.cmx kernel/declarations.cmx library/decl_kinds.cmx \ + kernel/cooking.cmx pretyping/classops.cmx toplevel/class.cmx \ + toplevel/discharge.cmi +toplevel/fhimsg.cmo: lib/util.cmi kernel/type_errors.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/reduction.cmi lib/pp.cmi kernel/names.cmi \ + parsing/g_minicoq.cmi kernel/environ.cmi toplevel/fhimsg.cmi +toplevel/fhimsg.cmx: lib/util.cmx kernel/type_errors.cmx kernel/term.cmx \ + kernel/sign.cmx kernel/reduction.cmx lib/pp.cmx kernel/names.cmx \ + parsing/g_minicoq.cmx kernel/environ.cmx toplevel/fhimsg.cmi +toplevel/himsg.cmo: lib/util.cmi kernel/type_errors.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi kernel/reduction.cmi \ + pretyping/rawterm.cmi parsing/printer.cmi pretyping/pretype_errors.cmi \ + lib/pp.cmi lib/options.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi proofs/logic.cmi kernel/inductive.cmi \ + kernel/indtypes.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi pretyping/cases.cmi parsing/ast.cmi toplevel/himsg.cmi +toplevel/himsg.cmx: lib/util.cmx kernel/type_errors.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx kernel/reduction.cmx \ + pretyping/rawterm.cmx parsing/printer.cmx pretyping/pretype_errors.cmx \ + lib/pp.cmx lib/options.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx proofs/logic.cmx kernel/inductive.cmx \ + kernel/indtypes.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx pretyping/cases.cmx parsing/ast.cmx toplevel/himsg.cmi toplevel/line_oriented_parser.cmo: toplevel/line_oriented_parser.cmi toplevel/line_oriented_parser.cmx: toplevel/line_oriented_parser.cmi -toplevel/metasyntax.cmo: parsing/ast.cmi pretyping/classops.cmi \ - interp/constrextern.cmi interp/constrintern.cmi parsing/coqast.cmi \ - parsing/egrammar.cmi parsing/esyntax.cmi pretyping/evd.cmi \ - parsing/extend.cmi interp/genarg.cmi library/global.cmi parsing/lexer.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - parsing/pcoq.cmi lib/pp.cmi interp/ppextend.cmi parsing/pptactic.cmi \ - pretyping/rawterm.cmi library/summary.cmi interp/symbols.cmi \ - parsing/termast.cmi interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo toplevel/metasyntax.cmi -toplevel/metasyntax.cmx: parsing/ast.cmx pretyping/classops.cmx \ - interp/constrextern.cmx interp/constrintern.cmx parsing/coqast.cmx \ - parsing/egrammar.cmx parsing/esyntax.cmx pretyping/evd.cmx \ - parsing/extend.cmx interp/genarg.cmx library/global.cmx parsing/lexer.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - parsing/pcoq.cmx lib/pp.cmx interp/ppextend.cmx parsing/pptactic.cmx \ - pretyping/rawterm.cmx library/summary.cmx interp/symbols.cmx \ - parsing/termast.cmx interp/topconstr.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx toplevel/metasyntax.cmi -toplevel/minicoq.cmo: kernel/declarations.cmi toplevel/fhimsg.cmi \ - parsing/g_minicoq.cmi kernel/inductive.cmi kernel/names.cmi lib/pp.cmi \ - kernel/safe_typing.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/type_errors.cmi lib/util.cmi -toplevel/minicoq.cmx: kernel/declarations.cmx toplevel/fhimsg.cmx \ - parsing/g_minicoq.cmx kernel/inductive.cmx kernel/names.cmx lib/pp.cmx \ - kernel/safe_typing.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/type_errors.cmx lib/util.cmx -toplevel/mltop.cmo: library/lib.cmi library/libobject.cmi library/library.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi library/summary.cmi \ - lib/system.cmi lib/util.cmi toplevel/vernacinterp.cmi toplevel/mltop.cmi -toplevel/mltop.cmx: library/lib.cmx library/libobject.cmx library/library.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx library/summary.cmx \ - lib/system.cmx lib/util.cmx toplevel/vernacinterp.cmx toplevel/mltop.cmi -toplevel/protectedtoplevel.cmo: toplevel/cerrors.cmi \ - toplevel/line_oriented_parser.cmi parsing/pcoq.cmi lib/pp.cmi \ - toplevel/vernac.cmi toplevel/vernacexpr.cmo \ - toplevel/protectedtoplevel.cmi -toplevel/protectedtoplevel.cmx: toplevel/cerrors.cmx \ - toplevel/line_oriented_parser.cmx parsing/pcoq.cmx lib/pp.cmx \ - toplevel/vernac.cmx toplevel/vernacexpr.cmx \ - toplevel/protectedtoplevel.cmi -toplevel/record.cmo: toplevel/class.cmi toplevel/command.cmi \ - interp/constrintern.cmi parsing/coqast.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi library/declare.cmi kernel/entries.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi \ - kernel/indtypes.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi parsing/printer.cmi \ - pretyping/recordops.cmi kernel/safe_typing.cmi kernel/term.cmi \ - pretyping/termops.cmi interp/topconstr.cmi kernel/type_errors.cmi \ - lib/util.cmi toplevel/vernacexpr.cmo toplevel/record.cmi -toplevel/record.cmx: toplevel/class.cmx toplevel/command.cmx \ - interp/constrintern.cmx parsing/coqast.cmx library/decl_kinds.cmx \ - kernel/declarations.cmx library/declare.cmx kernel/entries.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx \ - kernel/indtypes.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx parsing/printer.cmx \ - pretyping/recordops.cmx kernel/safe_typing.cmx kernel/term.cmx \ - pretyping/termops.cmx interp/topconstr.cmx kernel/type_errors.cmx \ - lib/util.cmx toplevel/vernacexpr.cmx toplevel/record.cmi -toplevel/recordobj.cmo: pretyping/classops.cmi library/declare.cmi \ - kernel/environ.cmi library/global.cmi pretyping/instantiate.cmi \ - library/lib.cmi library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi pretyping/recordops.cmi kernel/term.cmi \ - lib/util.cmi toplevel/recordobj.cmi -toplevel/recordobj.cmx: pretyping/classops.cmx library/declare.cmx \ - kernel/environ.cmx library/global.cmx pretyping/instantiate.cmx \ - library/lib.cmx library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx pretyping/recordops.cmx kernel/term.cmx \ - lib/util.cmx toplevel/recordobj.cmi -toplevel/toplevel.cmo: toplevel/cerrors.cmi library/lib.cmi \ - toplevel/mltop.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - proofs/pfedit.cmi lib/pp.cmi toplevel/protectedtoplevel.cmi lib/util.cmi \ - toplevel/vernac.cmi toplevel/vernacexpr.cmo toplevel/toplevel.cmi -toplevel/toplevel.cmx: toplevel/cerrors.cmx library/lib.cmx \ - toplevel/mltop.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - proofs/pfedit.cmx lib/pp.cmx toplevel/protectedtoplevel.cmx lib/util.cmx \ - toplevel/vernac.cmx toplevel/vernacexpr.cmx toplevel/toplevel.cmi +toplevel/metasyntax.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi parsing/termast.cmi interp/symbols.cmi \ + library/summary.cmi pretyping/rawterm.cmi parsing/pptactic.cmi \ + interp/ppextend.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + parsing/lexer.cmi library/global.cmi interp/genarg.cmi parsing/extend.cmi \ + pretyping/evd.cmi parsing/esyntax.cmi parsing/egrammar.cmi \ + parsing/coqast.cmi interp/constrintern.cmi interp/constrextern.cmi \ + pretyping/classops.cmi parsing/ast.cmi toplevel/metasyntax.cmi +toplevel/metasyntax.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx parsing/termast.cmx interp/symbols.cmx \ + library/summary.cmx pretyping/rawterm.cmx parsing/pptactic.cmx \ + interp/ppextend.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/library.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + parsing/lexer.cmx library/global.cmx interp/genarg.cmx parsing/extend.cmx \ + pretyping/evd.cmx parsing/esyntax.cmx parsing/egrammar.cmx \ + parsing/coqast.cmx interp/constrintern.cmx interp/constrextern.cmx \ + pretyping/classops.cmx parsing/ast.cmx toplevel/metasyntax.cmi +toplevel/minicoq.cmo: lib/util.cmi kernel/type_errors.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/safe_typing.cmi lib/pp.cmi kernel/names.cmi \ + kernel/inductive.cmi parsing/g_minicoq.cmi toplevel/fhimsg.cmi \ + kernel/declarations.cmi +toplevel/minicoq.cmx: lib/util.cmx kernel/type_errors.cmx kernel/term.cmx \ + kernel/sign.cmx kernel/safe_typing.cmx lib/pp.cmx kernel/names.cmx \ + kernel/inductive.cmx parsing/g_minicoq.cmx toplevel/fhimsg.cmx \ + kernel/declarations.cmx +toplevel/mltop.cmo: toplevel/vernacinterp.cmi lib/util.cmi lib/system.cmi \ + library/summary.cmi lib/pp.cmi lib/options.cmi kernel/names.cmi \ + library/library.cmi library/libobject.cmi library/lib.cmi \ + toplevel/mltop.cmi +toplevel/mltop.cmx: toplevel/vernacinterp.cmx lib/util.cmx lib/system.cmx \ + library/summary.cmx lib/pp.cmx lib/options.cmx kernel/names.cmx \ + library/library.cmx library/libobject.cmx library/lib.cmx \ + toplevel/mltop.cmi +toplevel/protectedtoplevel.cmo: toplevel/vernacexpr.cmo toplevel/vernac.cmi \ + lib/pp.cmi parsing/pcoq.cmi toplevel/line_oriented_parser.cmi \ + toplevel/cerrors.cmi toplevel/protectedtoplevel.cmi +toplevel/protectedtoplevel.cmx: toplevel/vernacexpr.cmx toplevel/vernac.cmx \ + lib/pp.cmx parsing/pcoq.cmx toplevel/line_oriented_parser.cmx \ + toplevel/cerrors.cmx toplevel/protectedtoplevel.cmi +toplevel/record.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + kernel/type_errors.cmi interp/topconstr.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/safe_typing.cmi pretyping/recordops.cmi \ + parsing/printer.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + pretyping/inductiveops.cmi kernel/inductive.cmi kernel/indtypes.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/entries.cmi library/declare.cmi kernel/declarations.cmi \ + library/decl_kinds.cmo parsing/coqast.cmi interp/constrintern.cmi \ + toplevel/command.cmi toplevel/class.cmi toplevel/record.cmi +toplevel/record.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + kernel/type_errors.cmx interp/topconstr.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/safe_typing.cmx pretyping/recordops.cmx \ + parsing/printer.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + pretyping/inductiveops.cmx kernel/inductive.cmx kernel/indtypes.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/entries.cmx library/declare.cmx kernel/declarations.cmx \ + library/decl_kinds.cmx parsing/coqast.cmx interp/constrintern.cmx \ + toplevel/command.cmx toplevel/class.cmx toplevel/record.cmi +toplevel/recordobj.cmo: lib/util.cmi kernel/term.cmi pretyping/recordops.cmi \ + lib/pp.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi library/lib.cmi pretyping/instantiate.cmi \ + library/global.cmi kernel/environ.cmi library/declare.cmi \ + pretyping/classops.cmi toplevel/recordobj.cmi +toplevel/recordobj.cmx: lib/util.cmx kernel/term.cmx pretyping/recordops.cmx \ + lib/pp.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx library/lib.cmx pretyping/instantiate.cmx \ + library/global.cmx kernel/environ.cmx library/declare.cmx \ + pretyping/classops.cmx toplevel/recordobj.cmi +toplevel/toplevel.cmo: toplevel/vernacexpr.cmo toplevel/vernac.cmi \ + lib/util.cmi toplevel/protectedtoplevel.cmi lib/pp.cmi proofs/pfedit.cmi \ + parsing/pcoq.cmi lib/options.cmi kernel/names.cmi toplevel/mltop.cmi \ + library/lib.cmi toplevel/cerrors.cmi toplevel/toplevel.cmi +toplevel/toplevel.cmx: toplevel/vernacexpr.cmx toplevel/vernac.cmx \ + lib/util.cmx toplevel/protectedtoplevel.cmx lib/pp.cmx proofs/pfedit.cmx \ + parsing/pcoq.cmx lib/options.cmx kernel/names.cmx toplevel/mltop.cmx \ + library/lib.cmx toplevel/cerrors.cmx toplevel/toplevel.cmi toplevel/usage.cmo: config/coq_config.cmi toplevel/usage.cmi toplevel/usage.cmx: config/coq_config.cmx toplevel/usage.cmi -toplevel/vernacentries.cmo: tactics/auto.cmi toplevel/class.cmi \ - pretyping/classops.cmi toplevel/command.cmi interp/constrextern.cmi \ - interp/constrintern.cmi library/decl_kinds.cmo library/declaremods.cmi \ - pretyping/detyping.cmi toplevel/discharge.cmi kernel/entries.cmi \ - kernel/environ.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - library/global.cmi library/goptions.cmi library/impargs.cmi \ - pretyping/inductiveops.cmi library/lib.cmi library/libnames.cmi \ - library/library.cmi toplevel/metasyntax.cmi toplevel/mltop.cmi \ - interp/modintern.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi proofs/pfedit.cmi lib/pp.cmi \ - lib/pp_control.cmi parsing/prettyp.cmi pretyping/pretyping.cmi \ - parsing/printer.cmi parsing/printmod.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi toplevel/record.cmi \ - toplevel/recordobj.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - interp/reserve.cmi kernel/safe_typing.cmi parsing/search.cmi \ - library/states.cmi interp/symbols.cmi interp/syntax_def.cmi \ - lib/system.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - proofs/tacmach.cmi pretyping/tacred.cmi proofs/tactic_debug.cmi \ - tactics/tactics.cmi kernel/term.cmi interp/topconstr.cmi \ - kernel/typeops.cmi kernel/univ.cmi lib/util.cmi toplevel/vernacexpr.cmo \ - toplevel/vernacinterp.cmi toplevel/vernacentries.cmi -toplevel/vernacentries.cmx: tactics/auto.cmx toplevel/class.cmx \ - pretyping/classops.cmx toplevel/command.cmx interp/constrextern.cmx \ - interp/constrintern.cmx library/decl_kinds.cmx library/declaremods.cmx \ - pretyping/detyping.cmx toplevel/discharge.cmx kernel/entries.cmx \ - kernel/environ.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - library/global.cmx library/goptions.cmx library/impargs.cmx \ - pretyping/inductiveops.cmx library/lib.cmx library/libnames.cmx \ - library/library.cmx toplevel/metasyntax.cmx toplevel/mltop.cmx \ - interp/modintern.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx proofs/pfedit.cmx lib/pp.cmx \ - lib/pp_control.cmx parsing/prettyp.cmx pretyping/pretyping.cmx \ - parsing/printer.cmx parsing/printmod.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx toplevel/record.cmx \ - toplevel/recordobj.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - interp/reserve.cmx kernel/safe_typing.cmx parsing/search.cmx \ - library/states.cmx interp/symbols.cmx interp/syntax_def.cmx \ - lib/system.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - proofs/tacmach.cmx pretyping/tacred.cmx proofs/tactic_debug.cmx \ - tactics/tactics.cmx kernel/term.cmx interp/topconstr.cmx \ - kernel/typeops.cmx kernel/univ.cmx lib/util.cmx toplevel/vernacexpr.cmx \ - toplevel/vernacinterp.cmx toplevel/vernacentries.cmi -toplevel/vernacexpr.cmo: library/decl_kinds.cmo parsing/extend.cmi \ - interp/genarg.cmi library/goptions.cmi library/libnames.cmi \ - kernel/names.cmi library/nametab.cmi interp/ppextend.cmi \ - pretyping/rawterm.cmi proofs/tacexpr.cmo interp/topconstr.cmi \ - lib/util.cmi -toplevel/vernacexpr.cmx: library/decl_kinds.cmx parsing/extend.cmx \ - interp/genarg.cmx library/goptions.cmx library/libnames.cmx \ - kernel/names.cmx library/nametab.cmx interp/ppextend.cmx \ - pretyping/rawterm.cmx proofs/tacexpr.cmx interp/topconstr.cmx \ - lib/util.cmx -toplevel/vernacinterp.cmo: parsing/ast.cmi parsing/coqast.cmi \ - parsing/extend.cmi toplevel/himsg.cmi library/libnames.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi proofs/proof_type.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo toplevel/vernacinterp.cmi -toplevel/vernacinterp.cmx: parsing/ast.cmx parsing/coqast.cmx \ - parsing/extend.cmx toplevel/himsg.cmx library/libnames.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx proofs/proof_type.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx toplevel/vernacinterp.cmi -toplevel/vernac.cmo: interp/constrextern.cmi interp/constrintern.cmi \ - parsing/coqast.cmi parsing/lexer.cmi library/lib.cmi library/library.cmi \ - kernel/names.cmi lib/options.cmi parsing/pcoq.cmi proofs/pfedit.cmi \ - lib/pp.cmi translate/ppvernacnew.cmi proofs/refiner.cmi \ - library/states.cmi lib/system.cmi tactics/tacinterp.cmi \ - proofs/tacmach.cmi lib/util.cmi toplevel/vernacentries.cmi \ - toplevel/vernacexpr.cmo toplevel/vernacinterp.cmi toplevel/vernac.cmi -toplevel/vernac.cmx: interp/constrextern.cmx interp/constrintern.cmx \ - parsing/coqast.cmx parsing/lexer.cmx library/lib.cmx library/library.cmx \ - kernel/names.cmx lib/options.cmx parsing/pcoq.cmx proofs/pfedit.cmx \ - lib/pp.cmx translate/ppvernacnew.cmx proofs/refiner.cmx \ - library/states.cmx lib/system.cmx tactics/tacinterp.cmx \ - proofs/tacmach.cmx lib/util.cmx toplevel/vernacentries.cmx \ - toplevel/vernacexpr.cmx toplevel/vernacinterp.cmx toplevel/vernac.cmi -translate/ppconstrnew.cmo: parsing/ast.cmi lib/bignat.cmi \ - interp/constrextern.cmi interp/constrintern.cmi parsing/coqast.cmi \ - pretyping/evd.cmi interp/genarg.cmi library/global.cmi library/lib.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - interp/ppextend.cmi pretyping/pretyping.cmi pretyping/rawterm.cmi \ - pretyping/retyping.cmi interp/symbols.cmi interp/syntax_def.cmi \ - kernel/term.cmi pretyping/termops.cmi interp/topconstr.cmi lib/util.cmi \ - translate/ppconstrnew.cmi -translate/ppconstrnew.cmx: parsing/ast.cmx lib/bignat.cmx \ - interp/constrextern.cmx interp/constrintern.cmx parsing/coqast.cmx \ - pretyping/evd.cmx interp/genarg.cmx library/global.cmx library/lib.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - interp/ppextend.cmx pretyping/pretyping.cmx pretyping/rawterm.cmx \ - pretyping/retyping.cmx interp/symbols.cmx interp/syntax_def.cmx \ - kernel/term.cmx pretyping/termops.cmx interp/topconstr.cmx lib/util.cmx \ - translate/ppconstrnew.cmi -translate/pptacticnew.cmo: kernel/closure.cmi interp/constrextern.cmi \ - lib/dyn.cmi parsing/egrammar.cmi kernel/environ.cmi parsing/extend.cmi \ - interp/genarg.cmi library/global.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi translate/ppconstrnew.cmi interp/ppextend.cmi \ - parsing/pptactic.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - kernel/term.cmi pretyping/termops.cmi interp/topconstr.cmi lib/util.cmi \ - translate/pptacticnew.cmi -translate/pptacticnew.cmx: kernel/closure.cmx interp/constrextern.cmx \ - lib/dyn.cmx parsing/egrammar.cmx kernel/environ.cmx parsing/extend.cmx \ - interp/genarg.cmx library/global.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx translate/ppconstrnew.cmx interp/ppextend.cmx \ - parsing/pptactic.cmx pretyping/rawterm.cmx proofs/tacexpr.cmx \ - kernel/term.cmx pretyping/termops.cmx interp/topconstr.cmx lib/util.cmx \ - translate/pptacticnew.cmi -translate/ppvernacnew.cmo: parsing/ast.cmi interp/constrextern.cmi \ - interp/constrintern.cmi parsing/coqast.cmi library/decl_kinds.cmo \ - library/declaremods.cmi parsing/egrammar.cmi kernel/environ.cmi \ - pretyping/evd.cmi parsing/extend.cmi interp/genarg.cmi library/global.cmi \ - library/goptions.cmi library/impargs.cmi library/lib.cmi \ - library/libnames.cmi library/library.cmi toplevel/metasyntax.cmi \ - interp/modintern.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi parsing/pcoq.cmi proofs/pfedit.cmi \ - lib/pp.cmi translate/ppconstrnew.cmi interp/ppextend.cmi \ - parsing/pptactic.cmi translate/pptacticnew.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi kernel/term.cmi \ - pretyping/termops.cmi interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo translate/ppvernacnew.cmi -translate/ppvernacnew.cmx: parsing/ast.cmx interp/constrextern.cmx \ - interp/constrintern.cmx parsing/coqast.cmx library/decl_kinds.cmx \ - library/declaremods.cmx parsing/egrammar.cmx kernel/environ.cmx \ - pretyping/evd.cmx parsing/extend.cmx interp/genarg.cmx library/global.cmx \ - library/goptions.cmx library/impargs.cmx library/lib.cmx \ - library/libnames.cmx library/library.cmx toplevel/metasyntax.cmx \ - interp/modintern.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx parsing/pcoq.cmx proofs/pfedit.cmx \ - lib/pp.cmx translate/ppconstrnew.cmx interp/ppextend.cmx \ - parsing/pptactic.cmx translate/pptacticnew.cmx pretyping/rawterm.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx kernel/term.cmx \ - pretyping/termops.cmx interp/topconstr.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx translate/ppvernacnew.cmi -contrib/cc/ccalgo.cmo: kernel/names.cmi kernel/term.cmi lib/util.cmi \ +toplevel/vernac.cmo: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + toplevel/vernacentries.cmi lib/util.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi lib/system.cmi library/states.cmi \ + proofs/refiner.cmi translate/ppvernacnew.cmi lib/pp.cmi proofs/pfedit.cmi \ + parsing/pcoq.cmi lib/options.cmi kernel/names.cmi library/library.cmi \ + library/lib.cmi parsing/lexer.cmi parsing/coqast.cmi \ + interp/constrintern.cmi interp/constrextern.cmi toplevel/vernac.cmi +toplevel/vernac.cmx: toplevel/vernacinterp.cmx toplevel/vernacexpr.cmx \ + toplevel/vernacentries.cmx lib/util.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx lib/system.cmx library/states.cmx \ + proofs/refiner.cmx translate/ppvernacnew.cmx lib/pp.cmx proofs/pfedit.cmx \ + parsing/pcoq.cmx lib/options.cmx kernel/names.cmx library/library.cmx \ + library/lib.cmx parsing/lexer.cmx parsing/coqast.cmx \ + interp/constrintern.cmx interp/constrextern.cmx toplevel/vernac.cmi +toplevel/vernacentries.cmo: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + lib/util.cmi kernel/univ.cmi kernel/typeops.cmi interp/topconstr.cmi \ + kernel/term.cmi tactics/tactics.cmi proofs/tactic_debug.cmi \ + pretyping/tacred.cmi proofs/tacmach.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo lib/system.cmi interp/syntax_def.cmi \ + interp/symbols.cmi library/states.cmi parsing/search.cmi \ + kernel/safe_typing.cmi interp/reserve.cmi proofs/refiner.cmi \ + pretyping/reductionops.cmi toplevel/recordobj.cmi toplevel/record.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + parsing/printmod.cmi parsing/printer.cmi pretyping/pretyping.cmi \ + parsing/prettyp.cmi lib/pp_control.cmi lib/pp.cmi proofs/pfedit.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + interp/modintern.cmi toplevel/mltop.cmi toplevel/metasyntax.cmi \ + library/library.cmi library/libnames.cmi library/lib.cmi \ + pretyping/inductiveops.cmi library/impargs.cmi library/goptions.cmi \ + library/global.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + kernel/environ.cmi kernel/entries.cmi toplevel/discharge.cmi \ + pretyping/detyping.cmi library/declaremods.cmi library/decl_kinds.cmo \ + interp/constrintern.cmi interp/constrextern.cmi toplevel/command.cmi \ + pretyping/classops.cmi toplevel/class.cmi tactics/auto.cmi \ + toplevel/vernacentries.cmi +toplevel/vernacentries.cmx: toplevel/vernacinterp.cmx toplevel/vernacexpr.cmx \ + lib/util.cmx kernel/univ.cmx kernel/typeops.cmx interp/topconstr.cmx \ + kernel/term.cmx tactics/tactics.cmx proofs/tactic_debug.cmx \ + pretyping/tacred.cmx proofs/tacmach.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx lib/system.cmx interp/syntax_def.cmx \ + interp/symbols.cmx library/states.cmx parsing/search.cmx \ + kernel/safe_typing.cmx interp/reserve.cmx proofs/refiner.cmx \ + pretyping/reductionops.cmx toplevel/recordobj.cmx toplevel/record.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + parsing/printmod.cmx parsing/printer.cmx pretyping/pretyping.cmx \ + parsing/prettyp.cmx lib/pp_control.cmx lib/pp.cmx proofs/pfedit.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + interp/modintern.cmx toplevel/mltop.cmx toplevel/metasyntax.cmx \ + library/library.cmx library/libnames.cmx library/lib.cmx \ + pretyping/inductiveops.cmx library/impargs.cmx library/goptions.cmx \ + library/global.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + kernel/environ.cmx kernel/entries.cmx toplevel/discharge.cmx \ + pretyping/detyping.cmx library/declaremods.cmx library/decl_kinds.cmx \ + interp/constrintern.cmx interp/constrextern.cmx toplevel/command.cmx \ + pretyping/classops.cmx toplevel/class.cmx tactics/auto.cmx \ + toplevel/vernacentries.cmi +toplevel/vernacexpr.cmo: lib/util.cmi interp/topconstr.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi interp/ppextend.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi library/goptions.cmi \ + interp/genarg.cmi parsing/extend.cmi library/decl_kinds.cmo +toplevel/vernacexpr.cmx: lib/util.cmx interp/topconstr.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx interp/ppextend.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx library/goptions.cmx \ + interp/genarg.cmx parsing/extend.cmx library/decl_kinds.cmx +toplevel/vernacinterp.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo proofs/proof_type.cmi lib/pp.cmi \ + lib/options.cmi kernel/names.cmi library/libnames.cmi toplevel/himsg.cmi \ + parsing/extend.cmi parsing/coqast.cmi parsing/ast.cmi \ + toplevel/vernacinterp.cmi +toplevel/vernacinterp.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx proofs/proof_type.cmx lib/pp.cmx \ + lib/options.cmx kernel/names.cmx library/libnames.cmx toplevel/himsg.cmx \ + parsing/extend.cmx parsing/coqast.cmx parsing/ast.cmx \ + toplevel/vernacinterp.cmi +translate/ppconstrnew.cmo: lib/util.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi interp/syntax_def.cmi \ + interp/symbols.cmi pretyping/retyping.cmi pretyping/rawterm.cmi \ + pretyping/pretyping.cmi interp/ppextend.cmi lib/pp.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi library/lib.cmi \ + library/global.cmi interp/genarg.cmi pretyping/evd.cmi parsing/coqast.cmi \ + interp/constrintern.cmi interp/constrextern.cmi lib/bignat.cmi \ + parsing/ast.cmi translate/ppconstrnew.cmi +translate/ppconstrnew.cmx: lib/util.cmx interp/topconstr.cmx \ + pretyping/termops.cmx kernel/term.cmx interp/syntax_def.cmx \ + interp/symbols.cmx pretyping/retyping.cmx pretyping/rawterm.cmx \ + pretyping/pretyping.cmx interp/ppextend.cmx lib/pp.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx library/lib.cmx \ + library/global.cmx interp/genarg.cmx pretyping/evd.cmx parsing/coqast.cmx \ + interp/constrintern.cmx interp/constrextern.cmx lib/bignat.cmx \ + parsing/ast.cmx translate/ppconstrnew.cmi +translate/pptacticnew.cmo: lib/util.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi parsing/pptactic.cmi interp/ppextend.cmi \ + translate/ppconstrnew.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + library/global.cmi interp/genarg.cmi parsing/extend.cmi \ + kernel/environ.cmi parsing/egrammar.cmi lib/dyn.cmi \ + interp/constrextern.cmi kernel/closure.cmi translate/pptacticnew.cmi +translate/pptacticnew.cmx: lib/util.cmx interp/topconstr.cmx \ + pretyping/termops.cmx kernel/term.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx parsing/pptactic.cmx interp/ppextend.cmx \ + translate/ppconstrnew.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + library/global.cmx interp/genarg.cmx parsing/extend.cmx \ + kernel/environ.cmx parsing/egrammar.cmx lib/dyn.cmx \ + interp/constrextern.cmx kernel/closure.cmx translate/pptacticnew.cmi +translate/ppvernacnew.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo pretyping/rawterm.cmi \ + translate/pptacticnew.cmi parsing/pptactic.cmi interp/ppextend.cmi \ + translate/ppconstrnew.cmi lib/pp.cmi proofs/pfedit.cmi parsing/pcoq.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + interp/modintern.cmi toplevel/metasyntax.cmi library/library.cmi \ + library/libnames.cmi library/lib.cmi library/impargs.cmi \ + library/goptions.cmi library/global.cmi interp/genarg.cmi \ + parsing/extend.cmi pretyping/evd.cmi kernel/environ.cmi \ + parsing/egrammar.cmi library/declaremods.cmi library/decl_kinds.cmo \ + parsing/coqast.cmi interp/constrintern.cmi interp/constrextern.cmi \ + parsing/ast.cmi translate/ppvernacnew.cmi +translate/ppvernacnew.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx pretyping/rawterm.cmx \ + translate/pptacticnew.cmx parsing/pptactic.cmx interp/ppextend.cmx \ + translate/ppconstrnew.cmx lib/pp.cmx proofs/pfedit.cmx parsing/pcoq.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + interp/modintern.cmx toplevel/metasyntax.cmx library/library.cmx \ + library/libnames.cmx library/lib.cmx library/impargs.cmx \ + library/goptions.cmx library/global.cmx interp/genarg.cmx \ + parsing/extend.cmx pretyping/evd.cmx kernel/environ.cmx \ + parsing/egrammar.cmx library/declaremods.cmx library/decl_kinds.cmx \ + parsing/coqast.cmx interp/constrintern.cmx interp/constrextern.cmx \ + parsing/ast.cmx translate/ppvernacnew.cmi +contrib/cc/ccalgo.cmo: lib/util.cmi kernel/term.cmi kernel/names.cmi \ contrib/cc/ccalgo.cmi -contrib/cc/ccalgo.cmx: kernel/names.cmx kernel/term.cmx lib/util.cmx \ +contrib/cc/ccalgo.cmx: lib/util.cmx kernel/term.cmx kernel/names.cmx \ contrib/cc/ccalgo.cmi -contrib/cc/ccproof.cmo: contrib/cc/ccalgo.cmi kernel/names.cmi lib/pp.cmi \ - lib/util.cmi contrib/cc/ccproof.cmi -contrib/cc/ccproof.cmx: contrib/cc/ccalgo.cmx kernel/names.cmx lib/pp.cmx \ - lib/util.cmx contrib/cc/ccproof.cmi -contrib/cc/cctac.cmo: contrib/cc/ccalgo.cmi contrib/cc/ccproof.cmi \ - toplevel/cerrors.cmi interp/coqlib.cmi kernel/declarations.cmi \ - parsing/egrammar.cmi pretyping/evd.cmi library/global.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi library/libnames.cmi \ - library/library.cmi library/nameops.cmi kernel/names.cmi lib/options.cmi \ - parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi proofs/proof_type.cmi \ - proofs/refiner.cmi kernel/sign.cmi proofs/tacexpr.cmo \ - tactics/tacinterp.cmi proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi lib/util.cmi -contrib/cc/cctac.cmx: contrib/cc/ccalgo.cmx contrib/cc/ccproof.cmx \ - toplevel/cerrors.cmx interp/coqlib.cmx kernel/declarations.cmx \ - parsing/egrammar.cmx pretyping/evd.cmx library/global.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx library/libnames.cmx \ - library/library.cmx library/nameops.cmx kernel/names.cmx lib/options.cmx \ - parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx proofs/proof_type.cmx \ - proofs/refiner.cmx kernel/sign.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx lib/util.cmx -contrib/correctness/pcicenv.cmo: library/global.cmi kernel/names.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/univ.cmi \ +contrib/cc/ccproof.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi \ + contrib/cc/ccalgo.cmi contrib/cc/ccproof.cmi +contrib/cc/ccproof.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx \ + contrib/cc/ccalgo.cmx contrib/cc/ccproof.cmi +contrib/cc/cctac.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + proofs/refiner.cmi proofs/proof_type.cmi parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi kernel/names.cmi library/nameops.cmi \ + library/library.cmi library/libnames.cmi pretyping/inductiveops.cmi \ + kernel/inductive.cmi library/global.cmi pretyping/evd.cmi \ + parsing/egrammar.cmi kernel/declarations.cmi interp/coqlib.cmi \ + toplevel/cerrors.cmi contrib/cc/ccproof.cmi contrib/cc/ccalgo.cmi +contrib/cc/cctac.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + proofs/refiner.cmx proofs/proof_type.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx kernel/names.cmx library/nameops.cmx \ + library/library.cmx library/libnames.cmx pretyping/inductiveops.cmx \ + kernel/inductive.cmx library/global.cmx pretyping/evd.cmx \ + parsing/egrammar.cmx kernel/declarations.cmx interp/coqlib.cmx \ + toplevel/cerrors.cmx contrib/cc/ccproof.cmx contrib/cc/ccalgo.cmx +contrib/correctness/pcic.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + kernel/typeops.cmi interp/topconstr.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi toplevel/record.cmi pretyping/rawterm.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi kernel/indtypes.cmi library/global.cmi \ + kernel/entries.cmi pretyping/detyping.cmi library/declare.cmi \ + kernel/declarations.cmi contrib/correctness/pcic.cmi +contrib/correctness/pcic.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + kernel/typeops.cmx interp/topconstr.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx toplevel/record.cmx pretyping/rawterm.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx kernel/indtypes.cmx library/global.cmx \ + kernel/entries.cmx pretyping/detyping.cmx library/declare.cmx \ + kernel/declarations.cmx contrib/correctness/pcic.cmi +contrib/correctness/pcicenv.cmo: kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/names.cmi library/global.cmi \ contrib/correctness/pcicenv.cmi -contrib/correctness/pcicenv.cmx: library/global.cmx kernel/names.cmx \ - kernel/sign.cmx kernel/term.cmx kernel/univ.cmx \ +contrib/correctness/pcicenv.cmx: kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx kernel/names.cmx library/global.cmx \ contrib/correctness/pcicenv.cmi -contrib/correctness/pcic.cmo: kernel/declarations.cmi library/declare.cmi \ - pretyping/detyping.cmi kernel/entries.cmi library/global.cmi \ - kernel/indtypes.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi pretyping/rawterm.cmi \ - toplevel/record.cmi kernel/sign.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi kernel/typeops.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo contrib/correctness/pcic.cmi -contrib/correctness/pcic.cmx: kernel/declarations.cmx library/declare.cmx \ - pretyping/detyping.cmx kernel/entries.cmx library/global.cmx \ - kernel/indtypes.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx pretyping/rawterm.cmx \ - toplevel/record.cmx kernel/sign.cmx kernel/term.cmx pretyping/termops.cmx \ - interp/topconstr.cmx kernel/typeops.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx contrib/correctness/pcic.cmi -contrib/correctness/pdb.cmo: interp/constrintern.cmi library/global.cmi \ - kernel/names.cmi library/nametab.cmi kernel/term.cmi \ - pretyping/termops.cmi contrib/correctness/pdb.cmi -contrib/correctness/pdb.cmx: interp/constrintern.cmx library/global.cmx \ - kernel/names.cmx library/nametab.cmx kernel/term.cmx \ - pretyping/termops.cmx contrib/correctness/pdb.cmi -contrib/correctness/peffect.cmo: toplevel/himsg.cmi library/nameops.cmi \ - kernel/names.cmi lib/pp.cmi lib/util.cmi contrib/correctness/peffect.cmi -contrib/correctness/peffect.cmx: toplevel/himsg.cmx library/nameops.cmx \ - kernel/names.cmx lib/pp.cmx lib/util.cmx contrib/correctness/peffect.cmi -contrib/correctness/penv.cmo: toplevel/himsg.cmi library/lib.cmi \ - library/libobject.cmi library/library.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi library/summary.cmi \ - kernel/term.cmi contrib/correctness/penv.cmi -contrib/correctness/penv.cmx: toplevel/himsg.cmx library/lib.cmx \ - library/libobject.cmx library/library.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx library/summary.cmx \ - kernel/term.cmx contrib/correctness/penv.cmi -contrib/correctness/perror.cmo: interp/constrintern.cmi pretyping/evd.cmi \ - library/global.cmi toplevel/himsg.cmi library/nameops.cmi \ - kernel/names.cmi lib/pp.cmi pretyping/reductionops.cmi kernel/term.cmi \ - lib/util.cmi contrib/correctness/perror.cmi -contrib/correctness/perror.cmx: interp/constrintern.cmx pretyping/evd.cmx \ - library/global.cmx toplevel/himsg.cmx library/nameops.cmx \ - kernel/names.cmx lib/pp.cmx pretyping/reductionops.cmx kernel/term.cmx \ - lib/util.cmx contrib/correctness/perror.cmi -contrib/correctness/pextract.cmo: parsing/ast.cmi pretyping/evd.cmi \ - toplevel/himsg.cmi library/library.cmi kernel/names.cmi \ - library/nametab.cmi contrib/extraction/ocaml.cmi lib/pp.cmi \ - lib/pp_control.cmi kernel/reduction.cmi pretyping/reductionops.cmi \ - lib/system.cmi kernel/term.cmi lib/util.cmi toplevel/vernacinterp.cmi \ +contrib/correctness/pdb.cmo: pretyping/termops.cmi kernel/term.cmi \ + library/nametab.cmi kernel/names.cmi library/global.cmi \ + interp/constrintern.cmi contrib/correctness/pdb.cmi +contrib/correctness/pdb.cmx: pretyping/termops.cmx kernel/term.cmx \ + library/nametab.cmx kernel/names.cmx library/global.cmx \ + interp/constrintern.cmx contrib/correctness/pdb.cmi +contrib/correctness/peffect.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi \ + library/nameops.cmi toplevel/himsg.cmi contrib/correctness/peffect.cmi +contrib/correctness/peffect.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx \ + library/nameops.cmx toplevel/himsg.cmx contrib/correctness/peffect.cmi +contrib/correctness/penv.cmo: kernel/term.cmi library/summary.cmi lib/pp.cmi \ + lib/options.cmi kernel/names.cmi library/nameops.cmi library/library.cmi \ + library/libobject.cmi library/lib.cmi toplevel/himsg.cmi \ + contrib/correctness/penv.cmi +contrib/correctness/penv.cmx: kernel/term.cmx library/summary.cmx lib/pp.cmx \ + lib/options.cmx kernel/names.cmx library/nameops.cmx library/library.cmx \ + library/libobject.cmx library/lib.cmx toplevel/himsg.cmx \ + contrib/correctness/penv.cmi +contrib/correctness/perror.cmo: lib/util.cmi kernel/term.cmi \ + pretyping/reductionops.cmi lib/pp.cmi kernel/names.cmi \ + library/nameops.cmi toplevel/himsg.cmi library/global.cmi \ + pretyping/evd.cmi interp/constrintern.cmi contrib/correctness/perror.cmi +contrib/correctness/perror.cmx: lib/util.cmx kernel/term.cmx \ + pretyping/reductionops.cmx lib/pp.cmx kernel/names.cmx \ + library/nameops.cmx toplevel/himsg.cmx library/global.cmx \ + pretyping/evd.cmx interp/constrintern.cmx contrib/correctness/perror.cmi +contrib/correctness/pextract.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + kernel/term.cmi lib/system.cmi pretyping/reductionops.cmi \ + kernel/reduction.cmi lib/pp_control.cmi lib/pp.cmi \ + contrib/extraction/ocaml.cmi library/nametab.cmi kernel/names.cmi \ + library/library.cmi toplevel/himsg.cmi pretyping/evd.cmi parsing/ast.cmi \ contrib/correctness/pextract.cmi -contrib/correctness/pextract.cmx: parsing/ast.cmx pretyping/evd.cmx \ - toplevel/himsg.cmx library/library.cmx kernel/names.cmx \ - library/nametab.cmx contrib/extraction/ocaml.cmx lib/pp.cmx \ - lib/pp_control.cmx kernel/reduction.cmx pretyping/reductionops.cmx \ - lib/system.cmx kernel/term.cmx lib/util.cmx toplevel/vernacinterp.cmx \ +contrib/correctness/pextract.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + kernel/term.cmx lib/system.cmx pretyping/reductionops.cmx \ + kernel/reduction.cmx lib/pp_control.cmx lib/pp.cmx \ + contrib/extraction/ocaml.cmx library/nametab.cmx kernel/names.cmx \ + library/library.cmx toplevel/himsg.cmx pretyping/evd.cmx parsing/ast.cmx \ contrib/correctness/pextract.cmi -contrib/correctness/pmisc.cmo: interp/constrextern.cmi \ - interp/constrintern.cmi pretyping/evarutil.cmi library/global.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi lib/options.cmi \ - lib/pp.cmi kernel/term.cmi interp/topconstr.cmi lib/util.cmi \ +contrib/correctness/pmisc.cmo: lib/util.cmi interp/topconstr.cmi \ + kernel/term.cmi lib/pp.cmi lib/options.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi library/global.cmi \ + pretyping/evarutil.cmi interp/constrintern.cmi interp/constrextern.cmi \ contrib/correctness/pmisc.cmi -contrib/correctness/pmisc.cmx: interp/constrextern.cmx \ - interp/constrintern.cmx pretyping/evarutil.cmx library/global.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx lib/options.cmx \ - lib/pp.cmx kernel/term.cmx interp/topconstr.cmx lib/util.cmx \ +contrib/correctness/pmisc.cmx: lib/util.cmx interp/topconstr.cmx \ + kernel/term.cmx lib/pp.cmx lib/options.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx library/global.cmx \ + pretyping/evarutil.cmx interp/constrintern.cmx interp/constrextern.cmx \ contrib/correctness/pmisc.cmi -contrib/correctness/pmlize.cmo: pretyping/evd.cmi library/global.cmi \ - tactics/hipattern.cmi pretyping/matching.cmi kernel/names.cmi \ - pretyping/pattern.cmi pretyping/reductionops.cmi kernel/term.cmi \ - parsing/termast.cmi pretyping/typing.cmi lib/util.cmi \ +contrib/correctness/pmlize.cmo: lib/util.cmi pretyping/typing.cmi \ + parsing/termast.cmi kernel/term.cmi pretyping/reductionops.cmi \ + pretyping/pattern.cmi kernel/names.cmi pretyping/matching.cmi \ + tactics/hipattern.cmi library/global.cmi pretyping/evd.cmi \ contrib/correctness/pmlize.cmi -contrib/correctness/pmlize.cmx: pretyping/evd.cmx library/global.cmx \ - tactics/hipattern.cmx pretyping/matching.cmx kernel/names.cmx \ - pretyping/pattern.cmx pretyping/reductionops.cmx kernel/term.cmx \ - parsing/termast.cmx pretyping/typing.cmx lib/util.cmx \ +contrib/correctness/pmlize.cmx: lib/util.cmx pretyping/typing.cmx \ + parsing/termast.cmx kernel/term.cmx pretyping/reductionops.cmx \ + pretyping/pattern.cmx kernel/names.cmx pretyping/matching.cmx \ + tactics/hipattern.cmx library/global.cmx pretyping/evd.cmx \ contrib/correctness/pmlize.cmi -contrib/correctness/pmonad.cmo: kernel/names.cmi kernel/term.cmi \ - parsing/termast.cmi lib/util.cmi contrib/correctness/pmonad.cmi -contrib/correctness/pmonad.cmx: kernel/names.cmx kernel/term.cmx \ - parsing/termast.cmx lib/util.cmx contrib/correctness/pmonad.cmi -contrib/correctness/pred.cmo: pretyping/evd.cmi library/global.cmi lib/pp.cmi \ - pretyping/reductionops.cmi kernel/term.cmi contrib/correctness/pred.cmi -contrib/correctness/pred.cmx: pretyping/evd.cmx library/global.cmx lib/pp.cmx \ - pretyping/reductionops.cmx kernel/term.cmx contrib/correctness/pred.cmi -contrib/correctness/prename.cmo: toplevel/himsg.cmi library/nameops.cmi \ - kernel/names.cmi lib/pp.cmi lib/util.cmi contrib/correctness/prename.cmi -contrib/correctness/prename.cmx: toplevel/himsg.cmx library/nameops.cmx \ - kernel/names.cmx lib/pp.cmx lib/util.cmx contrib/correctness/prename.cmi -contrib/correctness/ptactic.cmo: library/decl_kinds.cmo tactics/equality.cmi \ - pretyping/evd.cmi tactics/extratactics.cmi library/global.cmi \ - library/libnames.cmi library/library.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi lib/options.cmi \ - pretyping/pattern.cmi proofs/pfedit.cmi lib/pp.cmi \ - pretyping/pretyping.cmi parsing/printer.cmi kernel/reduction.cmi \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ - toplevel/vernacentries.cmi contrib/correctness/ptactic.cmi -contrib/correctness/ptactic.cmx: library/decl_kinds.cmx tactics/equality.cmx \ - pretyping/evd.cmx tactics/extratactics.cmx library/global.cmx \ - library/libnames.cmx library/library.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx lib/options.cmx \ - pretyping/pattern.cmx proofs/pfedit.cmx lib/pp.cmx \ - pretyping/pretyping.cmx parsing/printer.cmx kernel/reduction.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ - toplevel/vernacentries.cmx contrib/correctness/ptactic.cmi -contrib/correctness/ptyping.cmo: interp/constrintern.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi toplevel/himsg.cmi kernel/names.cmi \ - lib/pp.cmi proofs/proof_trees.cmi pretyping/reductionops.cmi \ - kernel/term.cmi pretyping/termops.cmi interp/topconstr.cmi \ - pretyping/typing.cmi lib/util.cmi contrib/correctness/ptyping.cmi -contrib/correctness/ptyping.cmx: interp/constrintern.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx toplevel/himsg.cmx kernel/names.cmx \ - lib/pp.cmx proofs/proof_trees.cmx pretyping/reductionops.cmx \ - kernel/term.cmx pretyping/termops.cmx interp/topconstr.cmx \ - pretyping/typing.cmx lib/util.cmx contrib/correctness/ptyping.cmi -contrib/correctness/putil.cmo: kernel/environ.cmi library/global.cmi \ - tactics/hipattern.cmi pretyping/matching.cmi library/nameops.cmi \ - kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi parsing/printer.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/correctness/pmonad.cmo: lib/util.cmi parsing/termast.cmi \ + kernel/term.cmi kernel/names.cmi contrib/correctness/pmonad.cmi +contrib/correctness/pmonad.cmx: lib/util.cmx parsing/termast.cmx \ + kernel/term.cmx kernel/names.cmx contrib/correctness/pmonad.cmi +contrib/correctness/pred.cmo: kernel/term.cmi pretyping/reductionops.cmi \ + lib/pp.cmi library/global.cmi pretyping/evd.cmi \ + contrib/correctness/pred.cmi +contrib/correctness/pred.cmx: kernel/term.cmx pretyping/reductionops.cmx \ + lib/pp.cmx library/global.cmx pretyping/evd.cmx \ + contrib/correctness/pred.cmi +contrib/correctness/prename.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi \ + library/nameops.cmi toplevel/himsg.cmi contrib/correctness/prename.cmi +contrib/correctness/prename.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx \ + library/nameops.cmx toplevel/himsg.cmx contrib/correctness/prename.cmi +contrib/correctness/ptactic.cmo: toplevel/vernacentries.cmi lib/util.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi kernel/reduction.cmi \ + parsing/printer.cmi pretyping/pretyping.cmi lib/pp.cmi proofs/pfedit.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/library.cmi \ + library/libnames.cmi library/global.cmi tactics/extratactics.cmi \ + pretyping/evd.cmi tactics/equality.cmi library/decl_kinds.cmo \ + contrib/correctness/ptactic.cmi +contrib/correctness/ptactic.cmx: toplevel/vernacentries.cmx lib/util.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx kernel/reduction.cmx \ + parsing/printer.cmx pretyping/pretyping.cmx lib/pp.cmx proofs/pfedit.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/library.cmx \ + library/libnames.cmx library/global.cmx tactics/extratactics.cmx \ + pretyping/evd.cmx tactics/equality.cmx library/decl_kinds.cmx \ + contrib/correctness/ptactic.cmi +contrib/correctness/ptyping.cmo: lib/util.cmi pretyping/typing.cmi \ + interp/topconstr.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/reductionops.cmi proofs/proof_trees.cmi lib/pp.cmi \ + kernel/names.cmi toplevel/himsg.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi interp/constrintern.cmi \ + contrib/correctness/ptyping.cmi +contrib/correctness/ptyping.cmx: lib/util.cmx pretyping/typing.cmx \ + interp/topconstr.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/reductionops.cmx proofs/proof_trees.cmx lib/pp.cmx \ + kernel/names.cmx toplevel/himsg.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx interp/constrintern.cmx \ + contrib/correctness/ptyping.cmi +contrib/correctness/putil.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi parsing/printer.cmi lib/pp.cmi pretyping/pattern.cmi \ + kernel/names.cmi library/nameops.cmi pretyping/matching.cmi \ + tactics/hipattern.cmi library/global.cmi kernel/environ.cmi \ contrib/correctness/putil.cmi -contrib/correctness/putil.cmx: kernel/environ.cmx library/global.cmx \ - tactics/hipattern.cmx pretyping/matching.cmx library/nameops.cmx \ - kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx parsing/printer.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/correctness/putil.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx parsing/printer.cmx lib/pp.cmx pretyping/pattern.cmx \ + kernel/names.cmx library/nameops.cmx pretyping/matching.cmx \ + tactics/hipattern.cmx library/global.cmx kernel/environ.cmx \ contrib/correctness/putil.cmi -contrib/correctness/pwp.cmo: kernel/environ.cmi library/global.cmi \ - tactics/hipattern.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi kernel/reduction.cmi pretyping/reductionops.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/correctness/pwp.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi pretyping/reductionops.cmi kernel/reduction.cmi \ + library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + tactics/hipattern.cmi library/global.cmi kernel/environ.cmi \ contrib/correctness/pwp.cmi -contrib/correctness/pwp.cmx: kernel/environ.cmx library/global.cmx \ - tactics/hipattern.cmx library/libnames.cmx kernel/names.cmx \ - library/nametab.cmx kernel/reduction.cmx pretyping/reductionops.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/correctness/pwp.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx pretyping/reductionops.cmx kernel/reduction.cmx \ + library/nametab.cmx kernel/names.cmx library/libnames.cmx \ + tactics/hipattern.cmx library/global.cmx kernel/environ.cmx \ contrib/correctness/pwp.cmi -contrib/extraction/common.cmo: kernel/declarations.cmi \ - contrib/extraction/extraction.cmi library/global.cmi lib/gset.cmi \ - contrib/extraction/haskell.cmi library/libnames.cmi \ - contrib/extraction/miniml.cmi kernel/modops.cmi \ - contrib/extraction/modutil.cmi library/nameops.cmi kernel/names.cmi \ - contrib/extraction/ocaml.cmi lib/options.cmi lib/pp.cmi \ - lib/pp_control.cmi contrib/extraction/scheme.cmi \ - contrib/extraction/table.cmi kernel/term.cmi lib/util.cmi \ +contrib/extraction/common.cmo: lib/util.cmi kernel/term.cmi \ + contrib/extraction/table.cmi contrib/extraction/scheme.cmi \ + lib/pp_control.cmi lib/pp.cmi lib/options.cmi \ + contrib/extraction/ocaml.cmi kernel/names.cmi library/nameops.cmi \ + contrib/extraction/modutil.cmi kernel/modops.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ + contrib/extraction/haskell.cmi lib/gset.cmi library/global.cmi \ + contrib/extraction/extraction.cmi kernel/declarations.cmi \ contrib/extraction/common.cmi -contrib/extraction/common.cmx: kernel/declarations.cmx \ - contrib/extraction/extraction.cmx library/global.cmx lib/gset.cmx \ - contrib/extraction/haskell.cmx library/libnames.cmx \ - contrib/extraction/miniml.cmi kernel/modops.cmx \ - contrib/extraction/modutil.cmx library/nameops.cmx kernel/names.cmx \ - contrib/extraction/ocaml.cmx lib/options.cmx lib/pp.cmx \ - lib/pp_control.cmx contrib/extraction/scheme.cmx \ - contrib/extraction/table.cmx kernel/term.cmx lib/util.cmx \ +contrib/extraction/common.cmx: lib/util.cmx kernel/term.cmx \ + contrib/extraction/table.cmx contrib/extraction/scheme.cmx \ + lib/pp_control.cmx lib/pp.cmx lib/options.cmx \ + contrib/extraction/ocaml.cmx kernel/names.cmx library/nameops.cmx \ + contrib/extraction/modutil.cmx kernel/modops.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ + contrib/extraction/haskell.cmx lib/gset.cmx library/global.cmx \ + contrib/extraction/extraction.cmx kernel/declarations.cmx \ contrib/extraction/common.cmi -contrib/extraction/extract_env.cmo: contrib/extraction/common.cmi \ - kernel/declarations.cmi contrib/extraction/extraction.cmi \ - library/global.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi contrib/extraction/miniml.cmi \ - kernel/modops.cmi contrib/extraction/modutil.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi kernel/reduction.cmi \ - contrib/extraction/table.cmi kernel/term.cmi lib/util.cmi \ +contrib/extraction/extract_env.cmo: lib/util.cmi kernel/term.cmi \ + contrib/extraction/table.cmi kernel/reduction.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi contrib/extraction/modutil.cmi \ + kernel/modops.cmi contrib/extraction/miniml.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + library/global.cmi contrib/extraction/extraction.cmi \ + kernel/declarations.cmi contrib/extraction/common.cmi \ contrib/extraction/extract_env.cmi -contrib/extraction/extract_env.cmx: contrib/extraction/common.cmx \ - kernel/declarations.cmx contrib/extraction/extraction.cmx \ - library/global.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/library.cmx contrib/extraction/miniml.cmi \ - kernel/modops.cmx contrib/extraction/modutil.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx kernel/reduction.cmx \ - contrib/extraction/table.cmx kernel/term.cmx lib/util.cmx \ +contrib/extraction/extract_env.cmx: lib/util.cmx kernel/term.cmx \ + contrib/extraction/table.cmx kernel/reduction.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx contrib/extraction/modutil.cmx \ + kernel/modops.cmx contrib/extraction/miniml.cmi library/library.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + library/global.cmx contrib/extraction/extraction.cmx \ + kernel/declarations.cmx contrib/extraction/common.cmx \ contrib/extraction/extract_env.cmi -contrib/extraction/extraction.cmo: kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - library/libnames.cmi contrib/extraction/miniml.cmi \ - contrib/extraction/mlutil.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi pretyping/recordops.cmi kernel/reduction.cmi \ - pretyping/reductionops.cmi pretyping/retyping.cmi kernel/sign.cmi \ - library/summary.cmi contrib/extraction/table.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi contrib/extraction/extraction.cmi -contrib/extraction/extraction.cmx: kernel/declarations.cmx kernel/environ.cmx \ - pretyping/evd.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - library/libnames.cmx contrib/extraction/miniml.cmi \ - contrib/extraction/mlutil.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx pretyping/recordops.cmx kernel/reduction.cmx \ - pretyping/reductionops.cmx pretyping/retyping.cmx kernel/sign.cmx \ - library/summary.cmx contrib/extraction/table.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx contrib/extraction/extraction.cmi -contrib/extraction/g_extraction.cmo: toplevel/cerrors.cmi \ - parsing/egrammar.cmi parsing/extend.cmi \ - contrib/extraction/extract_env.cmi interp/genarg.cmi lib/options.cmi \ - parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - translate/pptacticnew.cmi contrib/extraction/table.cmi \ - tactics/tacinterp.cmi lib/util.cmi toplevel/vernacexpr.cmo \ - toplevel/vernacinterp.cmi -contrib/extraction/g_extraction.cmx: toplevel/cerrors.cmx \ - parsing/egrammar.cmx parsing/extend.cmx \ - contrib/extraction/extract_env.cmx interp/genarg.cmx lib/options.cmx \ - parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - translate/pptacticnew.cmx contrib/extraction/table.cmx \ - tactics/tacinterp.cmx lib/util.cmx toplevel/vernacexpr.cmx \ - toplevel/vernacinterp.cmx -contrib/extraction/haskell.cmo: library/libnames.cmi \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmi \ - library/nameops.cmi kernel/names.cmi contrib/extraction/ocaml.cmi \ - lib/pp.cmi contrib/extraction/table.cmi lib/util.cmi \ +contrib/extraction/extraction.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi contrib/extraction/table.cmi library/summary.cmi \ + kernel/sign.cmi pretyping/retyping.cmi pretyping/reductionops.cmi \ + kernel/reduction.cmi pretyping/recordops.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ + pretyping/inductiveops.cmi kernel/inductive.cmi pretyping/evd.cmi \ + kernel/environ.cmi kernel/declarations.cmi \ + contrib/extraction/extraction.cmi +contrib/extraction/extraction.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx contrib/extraction/table.cmx library/summary.cmx \ + kernel/sign.cmx pretyping/retyping.cmx pretyping/reductionops.cmx \ + kernel/reduction.cmx pretyping/recordops.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx contrib/extraction/mlutil.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ + pretyping/inductiveops.cmx kernel/inductive.cmx pretyping/evd.cmx \ + kernel/environ.cmx kernel/declarations.cmx \ + contrib/extraction/extraction.cmi +contrib/extraction/g_extraction.cmo: toplevel/vernacinterp.cmi \ + toplevel/vernacexpr.cmo lib/util.cmi tactics/tacinterp.cmi \ + contrib/extraction/table.cmi translate/pptacticnew.cmi \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + interp/genarg.cmi contrib/extraction/extract_env.cmi parsing/extend.cmi \ + parsing/egrammar.cmi toplevel/cerrors.cmi +contrib/extraction/g_extraction.cmx: toplevel/vernacinterp.cmx \ + toplevel/vernacexpr.cmx lib/util.cmx tactics/tacinterp.cmx \ + contrib/extraction/table.cmx translate/pptacticnew.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + interp/genarg.cmx contrib/extraction/extract_env.cmx parsing/extend.cmx \ + parsing/egrammar.cmx toplevel/cerrors.cmx +contrib/extraction/haskell.cmo: lib/util.cmi contrib/extraction/table.cmi \ + lib/pp.cmi contrib/extraction/ocaml.cmi kernel/names.cmi \ + library/nameops.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ contrib/extraction/haskell.cmi -contrib/extraction/haskell.cmx: library/libnames.cmx \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmx \ - library/nameops.cmx kernel/names.cmx contrib/extraction/ocaml.cmx \ - lib/pp.cmx contrib/extraction/table.cmx lib/util.cmx \ +contrib/extraction/haskell.cmx: lib/util.cmx contrib/extraction/table.cmx \ + lib/pp.cmx contrib/extraction/ocaml.cmx kernel/names.cmx \ + library/nameops.cmx contrib/extraction/mlutil.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ contrib/extraction/haskell.cmi -contrib/extraction/mlutil.cmo: library/libnames.cmi \ - contrib/extraction/miniml.cmi kernel/names.cmi library/nametab.cmi \ - lib/pp.cmi contrib/extraction/table.cmi lib/util.cmi \ +contrib/extraction/mlutil.cmo: lib/util.cmi contrib/extraction/table.cmi \ + lib/pp.cmi library/nametab.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ contrib/extraction/mlutil.cmi -contrib/extraction/mlutil.cmx: library/libnames.cmx \ - contrib/extraction/miniml.cmi kernel/names.cmx library/nametab.cmx \ - lib/pp.cmx contrib/extraction/table.cmx lib/util.cmx \ +contrib/extraction/mlutil.cmx: lib/util.cmx contrib/extraction/table.cmx \ + lib/pp.cmx library/nametab.cmx kernel/names.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ contrib/extraction/mlutil.cmi -contrib/extraction/modutil.cmo: kernel/declarations.cmi kernel/environ.cmi \ - library/libnames.cmi contrib/extraction/miniml.cmi \ - contrib/extraction/mlutil.cmi kernel/modops.cmi kernel/names.cmi \ - contrib/extraction/table.cmi lib/util.cmi contrib/extraction/modutil.cmi -contrib/extraction/modutil.cmx: kernel/declarations.cmx kernel/environ.cmx \ - library/libnames.cmx contrib/extraction/miniml.cmi \ - contrib/extraction/mlutil.cmx kernel/modops.cmx kernel/names.cmx \ - contrib/extraction/table.cmx lib/util.cmx contrib/extraction/modutil.cmi -contrib/extraction/ocaml.cmo: library/libnames.cmi \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmi \ - contrib/extraction/modutil.cmi library/nameops.cmi kernel/names.cmi \ - lib/pp.cmi contrib/extraction/table.cmi lib/util.cmi \ +contrib/extraction/modutil.cmo: lib/util.cmi contrib/extraction/table.cmi \ + kernel/names.cmi kernel/modops.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi kernel/environ.cmi \ + kernel/declarations.cmi contrib/extraction/modutil.cmi +contrib/extraction/modutil.cmx: lib/util.cmx contrib/extraction/table.cmx \ + kernel/names.cmx kernel/modops.cmx contrib/extraction/mlutil.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx kernel/environ.cmx \ + kernel/declarations.cmx contrib/extraction/modutil.cmi +contrib/extraction/ocaml.cmo: lib/util.cmi contrib/extraction/table.cmi \ + lib/pp.cmi kernel/names.cmi library/nameops.cmi \ + contrib/extraction/modutil.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ contrib/extraction/ocaml.cmi -contrib/extraction/ocaml.cmx: library/libnames.cmx \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmx \ - contrib/extraction/modutil.cmx library/nameops.cmx kernel/names.cmx \ - lib/pp.cmx contrib/extraction/table.cmx lib/util.cmx \ +contrib/extraction/ocaml.cmx: lib/util.cmx contrib/extraction/table.cmx \ + lib/pp.cmx kernel/names.cmx library/nameops.cmx \ + contrib/extraction/modutil.cmx contrib/extraction/mlutil.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ contrib/extraction/ocaml.cmi -contrib/extraction/scheme.cmo: library/libnames.cmi \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmi \ - library/nameops.cmi kernel/names.cmi contrib/extraction/ocaml.cmi \ - lib/pp.cmi contrib/extraction/table.cmi lib/util.cmi \ +contrib/extraction/scheme.cmo: lib/util.cmi contrib/extraction/table.cmi \ + lib/pp.cmi contrib/extraction/ocaml.cmi kernel/names.cmi \ + library/nameops.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ contrib/extraction/scheme.cmi -contrib/extraction/scheme.cmx: library/libnames.cmx \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmx \ - library/nameops.cmx kernel/names.cmx contrib/extraction/ocaml.cmx \ - lib/pp.cmx contrib/extraction/table.cmx lib/util.cmx \ +contrib/extraction/scheme.cmx: lib/util.cmx contrib/extraction/table.cmx \ + lib/pp.cmx contrib/extraction/ocaml.cmx kernel/names.cmx \ + library/nameops.cmx contrib/extraction/mlutil.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ contrib/extraction/scheme.cmi -contrib/extraction/table.cmo: kernel/declarations.cmi kernel/environ.cmi \ - library/global.cmi library/goptions.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi contrib/extraction/miniml.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi parsing/printer.cmi kernel/reduction.cmi library/summary.cmi \ - kernel/term.cmi lib/util.cmi contrib/extraction/table.cmi -contrib/extraction/table.cmx: kernel/declarations.cmx kernel/environ.cmx \ - library/global.cmx library/goptions.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx contrib/extraction/miniml.cmi \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx parsing/printer.cmx kernel/reduction.cmx library/summary.cmx \ - kernel/term.cmx lib/util.cmx contrib/extraction/table.cmi -contrib/field/field.cmo: toplevel/cerrors.cmi interp/constrintern.cmi \ - interp/coqlib.cmi parsing/egrammar.cmi pretyping/evd.cmi \ - parsing/extend.cmi interp/genarg.cmi library/global.cmi lib/gmap.cmi \ - tactics/hipattern.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi kernel/names.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi translate/ppconstrnew.cmi \ - parsing/pptactic.cmi parsing/printer.cmi proofs/proof_type.cmi \ - contrib/ring/quote.cmo pretyping/reductionops.cmi proofs/refiner.cmi \ - contrib/ring/ring.cmo library/summary.cmi proofs/tacexpr.cmo \ - tactics/tacinterp.cmi proofs/tacmach.cmi tactics/tacticals.cmi \ - kernel/term.cmi interp/topconstr.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo toplevel/vernacinterp.cmi -contrib/field/field.cmx: toplevel/cerrors.cmx interp/constrintern.cmx \ - interp/coqlib.cmx parsing/egrammar.cmx pretyping/evd.cmx \ - parsing/extend.cmx interp/genarg.cmx library/global.cmx lib/gmap.cmx \ - tactics/hipattern.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/library.cmx kernel/names.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx translate/ppconstrnew.cmx \ - parsing/pptactic.cmx parsing/printer.cmx proofs/proof_type.cmx \ - contrib/ring/quote.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - contrib/ring/ring.cmx library/summary.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - kernel/term.cmx interp/topconstr.cmx pretyping/typing.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx toplevel/vernacinterp.cmx -contrib/first-order/formula.cmo: kernel/closure.cmi kernel/declarations.cmi \ - library/global.cmi tactics/hipattern.cmi kernel/inductive.cmi \ - pretyping/inductiveops.cmi library/libnames.cmi kernel/names.cmi \ - pretyping/reductionops.cmi kernel/sign.cmi proofs/tacmach.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/extraction/table.cmo: lib/util.cmi kernel/term.cmi \ + library/summary.cmi kernel/reduction.cmi parsing/printer.cmi lib/pp.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + contrib/extraction/miniml.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi library/goptions.cmi library/global.cmi \ + kernel/environ.cmi kernel/declarations.cmi contrib/extraction/table.cmi +contrib/extraction/table.cmx: lib/util.cmx kernel/term.cmx \ + library/summary.cmx kernel/reduction.cmx parsing/printer.cmx lib/pp.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + contrib/extraction/miniml.cmi library/libobject.cmx library/libnames.cmx \ + library/lib.cmx library/goptions.cmx library/global.cmx \ + kernel/environ.cmx kernel/declarations.cmx contrib/extraction/table.cmi +contrib/field/field.cmo: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + lib/util.cmi pretyping/typing.cmi interp/topconstr.cmi kernel/term.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo library/summary.cmi contrib/ring/ring.cmo \ + proofs/refiner.cmi pretyping/reductionops.cmi contrib/ring/quote.cmo \ + proofs/proof_type.cmi parsing/printer.cmi parsing/pptactic.cmi \ + translate/ppconstrnew.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/library.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi tactics/hipattern.cmi lib/gmap.cmi \ + library/global.cmi interp/genarg.cmi parsing/extend.cmi pretyping/evd.cmi \ + parsing/egrammar.cmi interp/coqlib.cmi interp/constrintern.cmi \ + toplevel/cerrors.cmi +contrib/field/field.cmx: toplevel/vernacinterp.cmx toplevel/vernacexpr.cmx \ + lib/util.cmx pretyping/typing.cmx interp/topconstr.cmx kernel/term.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx library/summary.cmx contrib/ring/ring.cmx \ + proofs/refiner.cmx pretyping/reductionops.cmx contrib/ring/quote.cmx \ + proofs/proof_type.cmx parsing/printer.cmx parsing/pptactic.cmx \ + translate/ppconstrnew.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/library.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx tactics/hipattern.cmx lib/gmap.cmx \ + library/global.cmx interp/genarg.cmx parsing/extend.cmx pretyping/evd.cmx \ + parsing/egrammar.cmx interp/coqlib.cmx interp/constrintern.cmx \ + toplevel/cerrors.cmx +contrib/first-order/formula.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi proofs/tacmach.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi kernel/names.cmi library/libnames.cmi \ + pretyping/inductiveops.cmi kernel/inductive.cmi tactics/hipattern.cmi \ + library/global.cmi kernel/declarations.cmi kernel/closure.cmi \ contrib/first-order/formula.cmi -contrib/first-order/formula.cmx: kernel/closure.cmx kernel/declarations.cmx \ - library/global.cmx tactics/hipattern.cmx kernel/inductive.cmx \ - pretyping/inductiveops.cmx library/libnames.cmx kernel/names.cmx \ - pretyping/reductionops.cmx kernel/sign.cmx proofs/tacmach.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/first-order/formula.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx proofs/tacmach.cmx kernel/sign.cmx \ + pretyping/reductionops.cmx kernel/names.cmx library/libnames.cmx \ + pretyping/inductiveops.cmx kernel/inductive.cmx tactics/hipattern.cmx \ + library/global.cmx kernel/declarations.cmx kernel/closure.cmx \ contrib/first-order/formula.cmi -contrib/first-order/g_ground.cmo: tactics/auto.cmi toplevel/cerrors.cmi \ - parsing/egrammar.cmi contrib/first-order/formula.cmi interp/genarg.cmi \ - library/goptions.cmi contrib/first-order/ground.cmi library/libnames.cmi \ - kernel/names.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi proofs/refiner.cmi contrib/first-order/sequent.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi lib/util.cmi -contrib/first-order/g_ground.cmx: tactics/auto.cmx toplevel/cerrors.cmx \ - parsing/egrammar.cmx contrib/first-order/formula.cmx interp/genarg.cmx \ - library/goptions.cmx contrib/first-order/ground.cmx library/libnames.cmx \ - kernel/names.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx proofs/refiner.cmx contrib/first-order/sequent.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx lib/util.cmx -contrib/first-order/ground.cmo: pretyping/classops.cmi kernel/closure.cmi \ - contrib/first-order/formula.cmi lib/heap.cmi \ - contrib/first-order/instances.cmi library/libnames.cmi kernel/names.cmi \ - lib/pp.cmi proofs/proof_trees.cmi contrib/first-order/rules.cmi \ - contrib/first-order/sequent.cmi tactics/tacinterp.cmi proofs/tacmach.cmi \ - proofs/tactic_debug.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi contrib/first-order/ground.cmi -contrib/first-order/ground.cmx: pretyping/classops.cmx kernel/closure.cmx \ - contrib/first-order/formula.cmx lib/heap.cmx \ - contrib/first-order/instances.cmx library/libnames.cmx kernel/names.cmx \ - lib/pp.cmx proofs/proof_trees.cmx contrib/first-order/rules.cmx \ - contrib/first-order/sequent.cmx tactics/tacinterp.cmx proofs/tacmach.cmx \ - proofs/tactic_debug.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx contrib/first-order/ground.cmi -contrib/first-order/instances.cmo: kernel/declarations.cmi \ - pretyping/detyping.cmi contrib/first-order/formula.cmi lib/heap.cmi \ - library/libnames.cmi kernel/names.cmi pretyping/pretyping.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - contrib/first-order/rules.cmi contrib/first-order/sequent.cmi \ - kernel/sign.cmi proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi \ - contrib/first-order/unify.cmi lib/util.cmi \ - contrib/first-order/instances.cmi -contrib/first-order/instances.cmx: kernel/declarations.cmx \ - pretyping/detyping.cmx contrib/first-order/formula.cmx lib/heap.cmx \ - library/libnames.cmx kernel/names.cmx pretyping/pretyping.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - contrib/first-order/rules.cmx contrib/first-order/sequent.cmx \ - kernel/sign.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx \ - contrib/first-order/unify.cmx lib/util.cmx \ - contrib/first-order/instances.cmi -contrib/first-order/rules.cmo: interp/coqlib.cmi kernel/declarations.cmi \ - contrib/first-order/formula.cmi library/libnames.cmi kernel/names.cmi \ - contrib/first-order/sequent.cmi kernel/sign.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/first-order/g_ground.cmo: lib/util.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo contrib/first-order/sequent.cmi proofs/refiner.cmi \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi contrib/first-order/ground.cmi \ + library/goptions.cmi interp/genarg.cmi contrib/first-order/formula.cmi \ + parsing/egrammar.cmi toplevel/cerrors.cmi tactics/auto.cmi +contrib/first-order/g_ground.cmx: lib/util.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx contrib/first-order/sequent.cmx proofs/refiner.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx contrib/first-order/ground.cmx \ + library/goptions.cmx interp/genarg.cmx contrib/first-order/formula.cmx \ + parsing/egrammar.cmx toplevel/cerrors.cmx tactics/auto.cmx +contrib/first-order/ground.cmo: kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tactic_debug.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi contrib/first-order/sequent.cmi \ + contrib/first-order/rules.cmi proofs/proof_trees.cmi lib/pp.cmi \ + kernel/names.cmi library/libnames.cmi contrib/first-order/instances.cmi \ + lib/heap.cmi contrib/first-order/formula.cmi kernel/closure.cmi \ + pretyping/classops.cmi contrib/first-order/ground.cmi +contrib/first-order/ground.cmx: kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tactic_debug.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx contrib/first-order/sequent.cmx \ + contrib/first-order/rules.cmx proofs/proof_trees.cmx lib/pp.cmx \ + kernel/names.cmx library/libnames.cmx contrib/first-order/instances.cmx \ + lib/heap.cmx contrib/first-order/formula.cmx kernel/closure.cmx \ + pretyping/classops.cmx contrib/first-order/ground.cmi +contrib/first-order/instances.cmo: lib/util.cmi contrib/first-order/unify.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi kernel/sign.cmi \ + contrib/first-order/sequent.cmi contrib/first-order/rules.cmi \ + proofs/refiner.cmi pretyping/reductionops.cmi pretyping/rawterm.cmi \ + pretyping/pretyping.cmi kernel/names.cmi library/libnames.cmi \ + lib/heap.cmi contrib/first-order/formula.cmi pretyping/detyping.cmi \ + kernel/declarations.cmi contrib/first-order/instances.cmi +contrib/first-order/instances.cmx: lib/util.cmx contrib/first-order/unify.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx kernel/sign.cmx \ + contrib/first-order/sequent.cmx contrib/first-order/rules.cmx \ + proofs/refiner.cmx pretyping/reductionops.cmx pretyping/rawterm.cmx \ + pretyping/pretyping.cmx kernel/names.cmx library/libnames.cmx \ + lib/heap.cmx contrib/first-order/formula.cmx pretyping/detyping.cmx \ + kernel/declarations.cmx contrib/first-order/instances.cmi +contrib/first-order/rules.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + contrib/first-order/sequent.cmi kernel/names.cmi library/libnames.cmi \ + contrib/first-order/formula.cmi kernel/declarations.cmi interp/coqlib.cmi \ contrib/first-order/rules.cmi -contrib/first-order/rules.cmx: interp/coqlib.cmx kernel/declarations.cmx \ - contrib/first-order/formula.cmx library/libnames.cmx kernel/names.cmx \ - contrib/first-order/sequent.cmx kernel/sign.cmx proofs/tacexpr.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/first-order/rules.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + contrib/first-order/sequent.cmx kernel/names.cmx library/libnames.cmx \ + contrib/first-order/formula.cmx kernel/declarations.cmx interp/coqlib.cmx \ contrib/first-order/rules.cmi -contrib/first-order/sequent.cmo: tactics/auto.cmi interp/constrextern.cmi \ - contrib/first-order/formula.cmi library/global.cmi lib/heap.cmi \ - library/libnames.cmi kernel/names.cmi lib/pp.cmi parsing/ppconstr.cmi \ - proofs/tacmach.cmi kernel/term.cmi contrib/first-order/unify.cmi \ - lib/util.cmi contrib/first-order/sequent.cmi -contrib/first-order/sequent.cmx: tactics/auto.cmx interp/constrextern.cmx \ - contrib/first-order/formula.cmx library/global.cmx lib/heap.cmx \ - library/libnames.cmx kernel/names.cmx lib/pp.cmx parsing/ppconstr.cmx \ - proofs/tacmach.cmx kernel/term.cmx contrib/first-order/unify.cmx \ - lib/util.cmx contrib/first-order/sequent.cmi -contrib/first-order/unify.cmo: contrib/first-order/formula.cmi \ - kernel/names.cmi pretyping/reductionops.cmi proofs/tacmach.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/first-order/sequent.cmo: lib/util.cmi contrib/first-order/unify.cmi \ + kernel/term.cmi proofs/tacmach.cmi parsing/ppconstr.cmi lib/pp.cmi \ + kernel/names.cmi library/libnames.cmi lib/heap.cmi library/global.cmi \ + contrib/first-order/formula.cmi interp/constrextern.cmi tactics/auto.cmi \ + contrib/first-order/sequent.cmi +contrib/first-order/sequent.cmx: lib/util.cmx contrib/first-order/unify.cmx \ + kernel/term.cmx proofs/tacmach.cmx parsing/ppconstr.cmx lib/pp.cmx \ + kernel/names.cmx library/libnames.cmx lib/heap.cmx library/global.cmx \ + contrib/first-order/formula.cmx interp/constrextern.cmx tactics/auto.cmx \ + contrib/first-order/sequent.cmi +contrib/first-order/unify.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi proofs/tacmach.cmi pretyping/reductionops.cmi \ + kernel/names.cmi contrib/first-order/formula.cmi \ contrib/first-order/unify.cmi -contrib/first-order/unify.cmx: contrib/first-order/formula.cmx \ - kernel/names.cmx pretyping/reductionops.cmx proofs/tacmach.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/first-order/unify.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx proofs/tacmach.cmx pretyping/reductionops.cmx \ + kernel/names.cmx contrib/first-order/formula.cmx \ contrib/first-order/unify.cmi -contrib/fourier/fourierR.cmo: proofs/clenv.cmi tactics/contradiction.cmi \ - interp/coqlib.cmi tactics/equality.cmi contrib/fourier/fourier.cmo \ - library/libnames.cmi library/library.cmi kernel/names.cmi \ - contrib/ring/ring.cmo proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi lib/util.cmi toplevel/vernacexpr.cmo -contrib/fourier/fourierR.cmx: proofs/clenv.cmx tactics/contradiction.cmx \ - interp/coqlib.cmx tactics/equality.cmx contrib/fourier/fourier.cmx \ - library/libnames.cmx library/library.cmx kernel/names.cmx \ - contrib/ring/ring.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx lib/util.cmx toplevel/vernacexpr.cmx -contrib/fourier/g_fourier.cmo: toplevel/cerrors.cmi parsing/egrammar.cmi \ - contrib/fourier/fourierR.cmo lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi proofs/refiner.cmi proofs/tacexpr.cmo \ - tactics/tacinterp.cmi lib/util.cmi -contrib/fourier/g_fourier.cmx: toplevel/cerrors.cmx parsing/egrammar.cmx \ - contrib/fourier/fourierR.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx proofs/refiner.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx lib/util.cmx -contrib/funind/tacinv.cmo: toplevel/cerrors.cmi interp/constrintern.cmi \ - interp/coqlib.cmi library/decl_kinds.cmo library/declare.cmi \ - parsing/egrammar.cmi kernel/entries.cmi kernel/environ.cmi \ - tactics/equality.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/global.cmi pretyping/inductiveops.cmi kernel/names.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - parsing/printer.cmi proofs/proof_type.cmi pretyping/reductionops.cmi \ - tactics/refine.cmi proofs/refiner.cmi kernel/safe_typing.cmi \ - tactics/setoid_replace.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - contrib/funind/tacinvutils.cmi proofs/tacmach.cmi pretyping/tacred.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacinterp.cmi -contrib/funind/tacinv.cmx: toplevel/cerrors.cmx interp/constrintern.cmx \ - interp/coqlib.cmx library/decl_kinds.cmx library/declare.cmx \ - parsing/egrammar.cmx kernel/entries.cmx kernel/environ.cmx \ - tactics/equality.cmx pretyping/evd.cmx interp/genarg.cmx \ - library/global.cmx pretyping/inductiveops.cmx kernel/names.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - parsing/printer.cmx proofs/proof_type.cmx pretyping/reductionops.cmx \ - tactics/refine.cmx proofs/refiner.cmx kernel/safe_typing.cmx \ - tactics/setoid_replace.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - contrib/funind/tacinvutils.cmx proofs/tacmach.cmx pretyping/tacred.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - toplevel/vernacinterp.cmx -contrib/funind/tacinvutils.cmo: interp/coqlib.cmi kernel/declarations.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi \ - pretyping/inductiveops.cmi library/nameops.cmi kernel/names.cmi \ - lib/pp.cmi parsing/printer.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/fourier/fourierR.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi contrib/ring/ring.cmo kernel/names.cmi \ + library/library.cmi library/libnames.cmi contrib/fourier/fourier.cmo \ + tactics/equality.cmi interp/coqlib.cmi tactics/contradiction.cmi \ + proofs/clenv.cmi +contrib/fourier/fourierR.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx contrib/ring/ring.cmx kernel/names.cmx \ + library/library.cmx library/libnames.cmx contrib/fourier/fourier.cmx \ + tactics/equality.cmx interp/coqlib.cmx tactics/contradiction.cmx \ + proofs/clenv.cmx +contrib/fourier/g_fourier.cmo: lib/util.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo proofs/refiner.cmi parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi contrib/fourier/fourierR.cmo \ + parsing/egrammar.cmi toplevel/cerrors.cmi +contrib/fourier/g_fourier.cmx: lib/util.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx proofs/refiner.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx contrib/fourier/fourierR.cmx \ + parsing/egrammar.cmx toplevel/cerrors.cmx +contrib/funind/tacinv.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + pretyping/typing.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi pretyping/tacred.cmi \ + proofs/tacmach.cmi contrib/funind/tacinvutils.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo tactics/setoid_replace.cmi kernel/safe_typing.cmi \ + proofs/refiner.cmi tactics/refine.cmi pretyping/reductionops.cmi \ + proofs/proof_type.cmi parsing/printer.cmi parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi kernel/names.cmi \ + pretyping/inductiveops.cmi library/global.cmi interp/genarg.cmi \ + pretyping/evd.cmi tactics/equality.cmi kernel/environ.cmi \ + kernel/entries.cmi parsing/egrammar.cmi library/declare.cmi \ + library/decl_kinds.cmo interp/coqlib.cmi interp/constrintern.cmi \ + toplevel/cerrors.cmi +contrib/funind/tacinv.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + pretyping/typing.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx pretyping/tacred.cmx \ + proofs/tacmach.cmx contrib/funind/tacinvutils.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx tactics/setoid_replace.cmx kernel/safe_typing.cmx \ + proofs/refiner.cmx tactics/refine.cmx pretyping/reductionops.cmx \ + proofs/proof_type.cmx parsing/printer.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx kernel/names.cmx \ + pretyping/inductiveops.cmx library/global.cmx interp/genarg.cmx \ + pretyping/evd.cmx tactics/equality.cmx kernel/environ.cmx \ + kernel/entries.cmx parsing/egrammar.cmx library/declare.cmx \ + library/decl_kinds.cmx interp/coqlib.cmx interp/constrintern.cmx \ + toplevel/cerrors.cmx +contrib/funind/tacinvutils.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi pretyping/reductionops.cmi \ + parsing/printer.cmi lib/pp.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/inductiveops.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi kernel/declarations.cmi interp/coqlib.cmi \ contrib/funind/tacinvutils.cmi -contrib/funind/tacinvutils.cmx: interp/coqlib.cmx kernel/declarations.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx \ - pretyping/inductiveops.cmx library/nameops.cmx kernel/names.cmx \ - lib/pp.cmx parsing/printer.cmx pretyping/reductionops.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/funind/tacinvutils.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx pretyping/reductionops.cmx \ + parsing/printer.cmx lib/pp.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/inductiveops.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx kernel/declarations.cmx interp/coqlib.cmx \ contrib/funind/tacinvutils.cmi -contrib/interface/blast.cmo: tactics/auto.cmi proofs/clenv.cmi \ - toplevel/command.cmi contrib/interface/ctast.cmo kernel/declarations.cmi \ - library/declare.cmi tactics/eauto.cmi kernel/environ.cmi \ - tactics/equality.cmi proofs/evar_refiner.cmi pretyping/evd.cmi \ - lib/explore.cmi library/global.cmi tactics/hipattern.cmi \ - kernel/inductive.cmi proofs/logic.cmi library/nameops.cmi \ - kernel/names.cmi pretyping/pattern.cmi contrib/interface/pbp.cmi \ - parsing/pcoq.cmi proofs/pfedit.cmi lib/pp.cmi parsing/pptactic.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi proofs/refiner.cmi \ - kernel/sign.cmi tactics/tacinterp.cmi proofs/tacmach.cmi \ - pretyping/tacred.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacentries.cmi toplevel/vernacinterp.cmi \ - contrib/interface/blast.cmi -contrib/interface/blast.cmx: tactics/auto.cmx proofs/clenv.cmx \ - toplevel/command.cmx contrib/interface/ctast.cmx kernel/declarations.cmx \ - library/declare.cmx tactics/eauto.cmx kernel/environ.cmx \ - tactics/equality.cmx proofs/evar_refiner.cmx pretyping/evd.cmx \ - lib/explore.cmx library/global.cmx tactics/hipattern.cmx \ - kernel/inductive.cmx proofs/logic.cmx library/nameops.cmx \ - kernel/names.cmx pretyping/pattern.cmx contrib/interface/pbp.cmx \ - parsing/pcoq.cmx proofs/pfedit.cmx lib/pp.cmx parsing/pptactic.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx kernel/reduction.cmx proofs/refiner.cmx \ - kernel/sign.cmx tactics/tacinterp.cmx proofs/tacmach.cmx \ - pretyping/tacred.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - toplevel/vernacentries.cmx toplevel/vernacinterp.cmx \ - contrib/interface/blast.cmi -contrib/interface/centaur.cmo: contrib/interface/ascent.cmi parsing/ast.cmi \ - contrib/interface/blast.cmi toplevel/cerrors.cmi pretyping/classops.cmi \ - toplevel/command.cmi interp/constrintern.cmi parsing/coqast.cmi \ - contrib/interface/debug_tac.cmi kernel/declarations.cmi \ - library/declare.cmi parsing/egrammar.cmi kernel/environ.cmi \ - pretyping/evd.cmi parsing/extend.cmi interp/genarg.cmi library/global.cmi \ - contrib/interface/history.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi \ - toplevel/line_oriented_parser.cmi pretyping/matching.cmi \ - contrib/interface/name_to_ast.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi contrib/interface/pbp.cmi \ - parsing/pcoq.cmi proofs/pfedit.cmi lib/pp.cmi parsing/pptactic.cmi \ - pretyping/pretyping.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - toplevel/protectedtoplevel.cmi pretyping/rawterm.cmi kernel/reduction.cmi \ - proofs/refiner.cmi parsing/search.cmi contrib/interface/showproof.cmi \ - contrib/interface/showproof_ct.cmo proofs/tacexpr.cmo \ - tactics/tacinterp.cmi proofs/tacmach.cmi kernel/term.cmi \ - parsing/termast.cmi contrib/interface/translate.cmi lib/util.cmi \ - toplevel/vernac.cmi toplevel/vernacentries.cmi toplevel/vernacexpr.cmo \ - toplevel/vernacinterp.cmi contrib/interface/vtp.cmi \ - contrib/interface/xlate.cmi -contrib/interface/centaur.cmx: contrib/interface/ascent.cmi parsing/ast.cmx \ - contrib/interface/blast.cmx toplevel/cerrors.cmx pretyping/classops.cmx \ - toplevel/command.cmx interp/constrintern.cmx parsing/coqast.cmx \ - contrib/interface/debug_tac.cmx kernel/declarations.cmx \ - library/declare.cmx parsing/egrammar.cmx kernel/environ.cmx \ - pretyping/evd.cmx parsing/extend.cmx interp/genarg.cmx library/global.cmx \ - contrib/interface/history.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/library.cmx \ - toplevel/line_oriented_parser.cmx pretyping/matching.cmx \ - contrib/interface/name_to_ast.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx contrib/interface/pbp.cmx \ - parsing/pcoq.cmx proofs/pfedit.cmx lib/pp.cmx parsing/pptactic.cmx \ - pretyping/pretyping.cmx proofs/proof_trees.cmx proofs/proof_type.cmx \ - toplevel/protectedtoplevel.cmx pretyping/rawterm.cmx kernel/reduction.cmx \ - proofs/refiner.cmx parsing/search.cmx contrib/interface/showproof.cmx \ - contrib/interface/showproof_ct.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx proofs/tacmach.cmx kernel/term.cmx \ - parsing/termast.cmx contrib/interface/translate.cmx lib/util.cmx \ - toplevel/vernac.cmx toplevel/vernacentries.cmx toplevel/vernacexpr.cmx \ - toplevel/vernacinterp.cmx contrib/interface/vtp.cmx \ - contrib/interface/xlate.cmx -contrib/interface/ctast.cmo: parsing/coqast.cmi lib/dyn.cmi \ - library/libnames.cmi kernel/names.cmi lib/util.cmi -contrib/interface/ctast.cmx: parsing/coqast.cmx lib/dyn.cmx \ - library/libnames.cmx kernel/names.cmx lib/util.cmx -contrib/interface/dad.cmo: interp/constrextern.cmi interp/constrintern.cmi \ - kernel/environ.cmi pretyping/evd.cmi interp/genarg.cmi library/global.cmi \ - library/libnames.cmi pretyping/matching.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi contrib/interface/paths.cmi \ - pretyping/pattern.cmi lib/pp.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/reduction.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi interp/topconstr.cmi \ - pretyping/typing.cmi lib/util.cmi toplevel/vernacexpr.cmo \ - toplevel/vernacinterp.cmi contrib/interface/dad.cmi -contrib/interface/dad.cmx: interp/constrextern.cmx interp/constrintern.cmx \ - kernel/environ.cmx pretyping/evd.cmx interp/genarg.cmx library/global.cmx \ - library/libnames.cmx pretyping/matching.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx contrib/interface/paths.cmx \ - pretyping/pattern.cmx lib/pp.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx kernel/reduction.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx interp/topconstr.cmx \ - pretyping/typing.cmx lib/util.cmx toplevel/vernacexpr.cmx \ - toplevel/vernacinterp.cmx contrib/interface/dad.cmi -contrib/interface/debug_tac.cmo: parsing/ast.cmi toplevel/cerrors.cmi \ - parsing/coqast.cmi interp/genarg.cmi lib/pp.cmi parsing/pptactic.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi proofs/refiner.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi lib/util.cmi contrib/interface/debug_tac.cmi -contrib/interface/debug_tac.cmx: parsing/ast.cmx toplevel/cerrors.cmx \ - parsing/coqast.cmx interp/genarg.cmx lib/pp.cmx parsing/pptactic.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx proofs/refiner.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx lib/util.cmx contrib/interface/debug_tac.cmi +contrib/interface/blast.cmo: toplevel/vernacinterp.cmi \ + toplevel/vernacentries.cmi lib/util.cmi pretyping/typing.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi kernel/sign.cmi proofs/refiner.cmi \ + kernel/reduction.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + proofs/proof_trees.cmi parsing/printer.cmi parsing/pptactic.cmi \ + lib/pp.cmi proofs/pfedit.cmi parsing/pcoq.cmi contrib/interface/pbp.cmi \ + pretyping/pattern.cmi kernel/names.cmi library/nameops.cmi \ + proofs/logic.cmi kernel/inductive.cmi tactics/hipattern.cmi \ + library/global.cmi lib/explore.cmi pretyping/evd.cmi \ + proofs/evar_refiner.cmi tactics/equality.cmi kernel/environ.cmi \ + tactics/eauto.cmi library/declare.cmi kernel/declarations.cmi \ + contrib/interface/ctast.cmo toplevel/command.cmi proofs/clenv.cmi \ + tactics/auto.cmi contrib/interface/blast.cmi +contrib/interface/blast.cmx: toplevel/vernacinterp.cmx \ + toplevel/vernacentries.cmx lib/util.cmx pretyping/typing.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx pretyping/tacred.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx kernel/sign.cmx proofs/refiner.cmx \ + kernel/reduction.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + proofs/proof_trees.cmx parsing/printer.cmx parsing/pptactic.cmx \ + lib/pp.cmx proofs/pfedit.cmx parsing/pcoq.cmx contrib/interface/pbp.cmx \ + pretyping/pattern.cmx kernel/names.cmx library/nameops.cmx \ + proofs/logic.cmx kernel/inductive.cmx tactics/hipattern.cmx \ + library/global.cmx lib/explore.cmx pretyping/evd.cmx \ + proofs/evar_refiner.cmx tactics/equality.cmx kernel/environ.cmx \ + tactics/eauto.cmx library/declare.cmx kernel/declarations.cmx \ + contrib/interface/ctast.cmx toplevel/command.cmx proofs/clenv.cmx \ + tactics/auto.cmx contrib/interface/blast.cmi +contrib/interface/centaur.cmo: contrib/interface/xlate.cmi \ + contrib/interface/vtp.cmi toplevel/vernacinterp.cmi \ + toplevel/vernacexpr.cmo toplevel/vernacentries.cmi toplevel/vernac.cmi \ + lib/util.cmi contrib/interface/translate.cmi parsing/termast.cmi \ + kernel/term.cmi proofs/tacmach.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo contrib/interface/showproof_ct.cmo \ + contrib/interface/showproof.cmi parsing/search.cmi proofs/refiner.cmi \ + kernel/reduction.cmi pretyping/rawterm.cmi toplevel/protectedtoplevel.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi pretyping/pretyping.cmi \ + parsing/pptactic.cmi lib/pp.cmi proofs/pfedit.cmi parsing/pcoq.cmi \ + contrib/interface/pbp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi contrib/interface/name_to_ast.cmi \ + pretyping/matching.cmi toplevel/line_oriented_parser.cmi \ + library/library.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi contrib/interface/history.cmi library/global.cmi \ + interp/genarg.cmi parsing/extend.cmi pretyping/evd.cmi kernel/environ.cmi \ + parsing/egrammar.cmi library/declare.cmi kernel/declarations.cmi \ + contrib/interface/debug_tac.cmi parsing/coqast.cmi \ + interp/constrintern.cmi toplevel/command.cmi pretyping/classops.cmi \ + toplevel/cerrors.cmi contrib/interface/blast.cmi parsing/ast.cmi \ + contrib/interface/ascent.cmi +contrib/interface/centaur.cmx: contrib/interface/xlate.cmx \ + contrib/interface/vtp.cmx toplevel/vernacinterp.cmx \ + toplevel/vernacexpr.cmx toplevel/vernacentries.cmx toplevel/vernac.cmx \ + lib/util.cmx contrib/interface/translate.cmx parsing/termast.cmx \ + kernel/term.cmx proofs/tacmach.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx contrib/interface/showproof_ct.cmx \ + contrib/interface/showproof.cmx parsing/search.cmx proofs/refiner.cmx \ + kernel/reduction.cmx pretyping/rawterm.cmx toplevel/protectedtoplevel.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx pretyping/pretyping.cmx \ + parsing/pptactic.cmx lib/pp.cmx proofs/pfedit.cmx parsing/pcoq.cmx \ + contrib/interface/pbp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx contrib/interface/name_to_ast.cmx \ + pretyping/matching.cmx toplevel/line_oriented_parser.cmx \ + library/library.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx contrib/interface/history.cmx library/global.cmx \ + interp/genarg.cmx parsing/extend.cmx pretyping/evd.cmx kernel/environ.cmx \ + parsing/egrammar.cmx library/declare.cmx kernel/declarations.cmx \ + contrib/interface/debug_tac.cmx parsing/coqast.cmx \ + interp/constrintern.cmx toplevel/command.cmx pretyping/classops.cmx \ + toplevel/cerrors.cmx contrib/interface/blast.cmx parsing/ast.cmx \ + contrib/interface/ascent.cmi +contrib/interface/ctast.cmo: lib/util.cmi kernel/names.cmi \ + library/libnames.cmi lib/dyn.cmi parsing/coqast.cmi +contrib/interface/ctast.cmx: lib/util.cmx kernel/names.cmx \ + library/libnames.cmx lib/dyn.cmx parsing/coqast.cmx +contrib/interface/dad.cmo: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + lib/util.cmi pretyping/typing.cmi interp/topconstr.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo kernel/reduction.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi lib/pp.cmi \ + pretyping/pattern.cmi contrib/interface/paths.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi pretyping/matching.cmi \ + library/libnames.cmi library/global.cmi interp/genarg.cmi \ + pretyping/evd.cmi kernel/environ.cmi interp/constrintern.cmi \ + interp/constrextern.cmi contrib/interface/dad.cmi +contrib/interface/dad.cmx: toplevel/vernacinterp.cmx toplevel/vernacexpr.cmx \ + lib/util.cmx pretyping/typing.cmx interp/topconstr.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx kernel/reduction.cmx pretyping/rawterm.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx lib/pp.cmx \ + pretyping/pattern.cmx contrib/interface/paths.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx pretyping/matching.cmx \ + library/libnames.cmx library/global.cmx interp/genarg.cmx \ + pretyping/evd.cmx kernel/environ.cmx interp/constrintern.cmx \ + interp/constrextern.cmx contrib/interface/dad.cmi +contrib/interface/debug_tac.cmo: lib/util.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi tactics/tacinterp.cmi proofs/tacexpr.cmo \ + proofs/refiner.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + parsing/pptactic.cmi lib/pp.cmi interp/genarg.cmi parsing/coqast.cmi \ + toplevel/cerrors.cmi parsing/ast.cmi contrib/interface/debug_tac.cmi +contrib/interface/debug_tac.cmx: lib/util.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx tactics/tacinterp.cmx proofs/tacexpr.cmx \ + proofs/refiner.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + parsing/pptactic.cmx lib/pp.cmx interp/genarg.cmx parsing/coqast.cmx \ + toplevel/cerrors.cmx parsing/ast.cmx contrib/interface/debug_tac.cmi contrib/interface/history.cmo: contrib/interface/paths.cmi \ contrib/interface/history.cmi contrib/interface/history.cmx: contrib/interface/paths.cmx \ contrib/interface/history.cmi contrib/interface/line_parser.cmo: contrib/interface/line_parser.cmi contrib/interface/line_parser.cmx: contrib/interface/line_parser.cmi -contrib/interface/name_to_ast.cmo: parsing/ast.cmi pretyping/classops.cmi \ - interp/constrextern.cmi parsing/coqast.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi library/declare.cmi kernel/environ.cmi \ - library/global.cmi library/impargs.cmi kernel/inductive.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/pp.cmi \ - parsing/prettyp.cmi kernel/reduction.cmi kernel/sign.cmi kernel/term.cmi \ - parsing/termast.cmi interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo contrib/interface/name_to_ast.cmi -contrib/interface/name_to_ast.cmx: parsing/ast.cmx pretyping/classops.cmx \ - interp/constrextern.cmx parsing/coqast.cmx library/decl_kinds.cmx \ - kernel/declarations.cmx library/declare.cmx kernel/environ.cmx \ - library/global.cmx library/impargs.cmx kernel/inductive.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/pp.cmx \ - parsing/prettyp.cmx kernel/reduction.cmx kernel/sign.cmx kernel/term.cmx \ - parsing/termast.cmx interp/topconstr.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx contrib/interface/name_to_ast.cmi -contrib/interface/parse.cmo: contrib/interface/ascent.cmi \ - toplevel/cerrors.cmi config/coq_config.cmi library/declaremods.cmi \ - parsing/esyntax.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi contrib/interface/line_parser.cmi toplevel/mltop.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi parsing/pcoq.cmi \ - lib/pp.cmi lib/system.cmi lib/util.cmi toplevel/vernacentries.cmi \ - toplevel/vernacexpr.cmo contrib/interface/vtp.cmi \ - contrib/interface/xlate.cmi -contrib/interface/parse.cmx: contrib/interface/ascent.cmi \ - toplevel/cerrors.cmx config/coq_config.cmx library/declaremods.cmx \ - parsing/esyntax.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx contrib/interface/line_parser.cmx toplevel/mltop.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx parsing/pcoq.cmx \ - lib/pp.cmx lib/system.cmx lib/util.cmx toplevel/vernacentries.cmx \ - toplevel/vernacexpr.cmx contrib/interface/vtp.cmx \ - contrib/interface/xlate.cmx +contrib/interface/name_to_ast.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi parsing/termast.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/reduction.cmi parsing/prettyp.cmi lib/pp.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi kernel/inductive.cmi \ + library/impargs.cmi library/global.cmi kernel/environ.cmi \ + library/declare.cmi kernel/declarations.cmi library/decl_kinds.cmo \ + parsing/coqast.cmi interp/constrextern.cmi pretyping/classops.cmi \ + parsing/ast.cmi contrib/interface/name_to_ast.cmi +contrib/interface/name_to_ast.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx parsing/termast.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/reduction.cmx parsing/prettyp.cmx lib/pp.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx kernel/inductive.cmx \ + library/impargs.cmx library/global.cmx kernel/environ.cmx \ + library/declare.cmx kernel/declarations.cmx library/decl_kinds.cmx \ + parsing/coqast.cmx interp/constrextern.cmx pretyping/classops.cmx \ + parsing/ast.cmx contrib/interface/name_to_ast.cmi +contrib/interface/parse.cmo: contrib/interface/xlate.cmi \ + contrib/interface/vtp.cmi toplevel/vernacexpr.cmo \ + toplevel/vernacentries.cmi lib/util.cmi lib/system.cmi lib/pp.cmi \ + parsing/pcoq.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + toplevel/mltop.cmi contrib/interface/line_parser.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi parsing/esyntax.cmi \ + library/declaremods.cmi config/coq_config.cmi toplevel/cerrors.cmi \ + contrib/interface/ascent.cmi +contrib/interface/parse.cmx: contrib/interface/xlate.cmx \ + contrib/interface/vtp.cmx toplevel/vernacexpr.cmx \ + toplevel/vernacentries.cmx lib/util.cmx lib/system.cmx lib/pp.cmx \ + parsing/pcoq.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + toplevel/mltop.cmx contrib/interface/line_parser.cmx library/library.cmx \ + library/libobject.cmx library/libnames.cmx parsing/esyntax.cmx \ + library/declaremods.cmx config/coq_config.cmx toplevel/cerrors.cmx \ + contrib/interface/ascent.cmi contrib/interface/paths.cmo: contrib/interface/paths.cmi contrib/interface/paths.cmx: contrib/interface/paths.cmi -contrib/interface/pbp.cmo: interp/coqlib.cmi kernel/environ.cmi \ - pretyping/evd.cmi interp/genarg.cmi library/global.cmi \ - tactics/hipattern.cmi library/libnames.cmi proofs/logic.cmi \ - pretyping/matching.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi lib/pp.cmi pretyping/pretyping.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi pretyping/rawterm.cmi \ - kernel/reduction.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi interp/topconstr.cmi \ - pretyping/typing.cmi lib/util.cmi contrib/interface/pbp.cmi -contrib/interface/pbp.cmx: interp/coqlib.cmx kernel/environ.cmx \ - pretyping/evd.cmx interp/genarg.cmx library/global.cmx \ - tactics/hipattern.cmx library/libnames.cmx proofs/logic.cmx \ - pretyping/matching.cmx kernel/names.cmx library/nametab.cmx \ - pretyping/pattern.cmx lib/pp.cmx pretyping/pretyping.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx pretyping/rawterm.cmx \ - kernel/reduction.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx interp/topconstr.cmx \ - pretyping/typing.cmx lib/util.cmx contrib/interface/pbp.cmi -contrib/interface/showproof_ct.cmo: contrib/interface/ascent.cmi \ - parsing/esyntax.cmi library/global.cmi toplevel/metasyntax.cmi lib/pp.cmi \ - parsing/printer.cmi contrib/interface/translate.cmi \ - contrib/interface/vtp.cmi contrib/interface/xlate.cmi -contrib/interface/showproof_ct.cmx: contrib/interface/ascent.cmi \ - parsing/esyntax.cmx library/global.cmx toplevel/metasyntax.cmx lib/pp.cmx \ - parsing/printer.cmx contrib/interface/translate.cmx \ - contrib/interface/vtp.cmx contrib/interface/xlate.cmx -contrib/interface/showproof.cmo: proofs/clenv.cmi interp/constrintern.cmi \ - parsing/coqast.cmi kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi interp/genarg.cmi library/global.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi proofs/pfedit.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi \ - contrib/interface/showproof_ct.cmo kernel/sign.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi kernel/term.cmi parsing/termast.cmi \ - pretyping/termops.cmi contrib/interface/translate.cmi \ - pretyping/typing.cmi lib/util.cmi toplevel/vernacinterp.cmi \ +contrib/interface/pbp.cmo: lib/util.cmi pretyping/typing.cmi \ + interp/topconstr.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo kernel/reduction.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + pretyping/pretyping.cmi lib/pp.cmi pretyping/pattern.cmi \ + library/nametab.cmi kernel/names.cmi pretyping/matching.cmi \ + proofs/logic.cmi library/libnames.cmi tactics/hipattern.cmi \ + library/global.cmi interp/genarg.cmi pretyping/evd.cmi kernel/environ.cmi \ + interp/coqlib.cmi contrib/interface/pbp.cmi +contrib/interface/pbp.cmx: lib/util.cmx pretyping/typing.cmx \ + interp/topconstr.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx kernel/reduction.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + pretyping/pretyping.cmx lib/pp.cmx pretyping/pattern.cmx \ + library/nametab.cmx kernel/names.cmx pretyping/matching.cmx \ + proofs/logic.cmx library/libnames.cmx tactics/hipattern.cmx \ + library/global.cmx interp/genarg.cmx pretyping/evd.cmx kernel/environ.cmx \ + interp/coqlib.cmx contrib/interface/pbp.cmi +contrib/interface/showproof.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + pretyping/typing.cmi contrib/interface/translate.cmi \ + pretyping/termops.cmi parsing/termast.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + contrib/interface/showproof_ct.cmo pretyping/reductionops.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + parsing/printer.cmi lib/pp.cmi proofs/pfedit.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi pretyping/inductiveops.cmi \ + kernel/inductive.cmi library/global.cmi interp/genarg.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/declarations.cmi \ + parsing/coqast.cmi interp/constrintern.cmi proofs/clenv.cmi \ contrib/interface/showproof.cmi -contrib/interface/showproof.cmx: proofs/clenv.cmx interp/constrintern.cmx \ - parsing/coqast.cmx kernel/declarations.cmx kernel/environ.cmx \ - pretyping/evd.cmx interp/genarg.cmx library/global.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx proofs/pfedit.cmx lib/pp.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx \ - contrib/interface/showproof_ct.cmx kernel/sign.cmx proofs/tacexpr.cmx \ - proofs/tacmach.cmx kernel/term.cmx parsing/termast.cmx \ - pretyping/termops.cmx contrib/interface/translate.cmx \ - pretyping/typing.cmx lib/util.cmx toplevel/vernacinterp.cmx \ +contrib/interface/showproof.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + pretyping/typing.cmx contrib/interface/translate.cmx \ + pretyping/termops.cmx parsing/termast.cmx kernel/term.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + contrib/interface/showproof_ct.cmx pretyping/reductionops.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + parsing/printer.cmx lib/pp.cmx proofs/pfedit.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx pretyping/inductiveops.cmx \ + kernel/inductive.cmx library/global.cmx interp/genarg.cmx \ + pretyping/evd.cmx kernel/environ.cmx kernel/declarations.cmx \ + parsing/coqast.cmx interp/constrintern.cmx proofs/clenv.cmx \ contrib/interface/showproof.cmi -contrib/interface/translate.cmo: contrib/interface/ascent.cmi parsing/ast.cmi \ - interp/constrextern.cmi contrib/interface/ctast.cmo kernel/environ.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi library/libobject.cmi \ - library/library.cmi kernel/names.cmi proofs/pfedit.cmi lib/pp.cmi \ - proofs/proof_type.cmi kernel/sign.cmi proofs/tacmach.cmi kernel/term.cmi \ - parsing/termast.cmi lib/util.cmi toplevel/vernacinterp.cmi \ - contrib/interface/vtp.cmi contrib/interface/xlate.cmi \ +contrib/interface/showproof_ct.cmo: contrib/interface/xlate.cmi \ + contrib/interface/vtp.cmi contrib/interface/translate.cmi \ + parsing/printer.cmi lib/pp.cmi toplevel/metasyntax.cmi library/global.cmi \ + parsing/esyntax.cmi contrib/interface/ascent.cmi +contrib/interface/showproof_ct.cmx: contrib/interface/xlate.cmx \ + contrib/interface/vtp.cmx contrib/interface/translate.cmx \ + parsing/printer.cmx lib/pp.cmx toplevel/metasyntax.cmx library/global.cmx \ + parsing/esyntax.cmx contrib/interface/ascent.cmi +contrib/interface/translate.cmo: contrib/interface/xlate.cmi \ + contrib/interface/vtp.cmi toplevel/vernacinterp.cmi lib/util.cmi \ + parsing/termast.cmi kernel/term.cmi proofs/tacmach.cmi kernel/sign.cmi \ + proofs/proof_type.cmi lib/pp.cmi proofs/pfedit.cmi kernel/names.cmi \ + library/library.cmi library/libobject.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi contrib/interface/ctast.cmo \ + interp/constrextern.cmi parsing/ast.cmi contrib/interface/ascent.cmi \ contrib/interface/translate.cmi -contrib/interface/translate.cmx: contrib/interface/ascent.cmi parsing/ast.cmx \ - interp/constrextern.cmx contrib/interface/ctast.cmx kernel/environ.cmx \ - pretyping/evarutil.cmx pretyping/evd.cmx library/libobject.cmx \ - library/library.cmx kernel/names.cmx proofs/pfedit.cmx lib/pp.cmx \ - proofs/proof_type.cmx kernel/sign.cmx proofs/tacmach.cmx kernel/term.cmx \ - parsing/termast.cmx lib/util.cmx toplevel/vernacinterp.cmx \ - contrib/interface/vtp.cmx contrib/interface/xlate.cmx \ +contrib/interface/translate.cmx: contrib/interface/xlate.cmx \ + contrib/interface/vtp.cmx toplevel/vernacinterp.cmx lib/util.cmx \ + parsing/termast.cmx kernel/term.cmx proofs/tacmach.cmx kernel/sign.cmx \ + proofs/proof_type.cmx lib/pp.cmx proofs/pfedit.cmx kernel/names.cmx \ + library/library.cmx library/libobject.cmx pretyping/evd.cmx \ + pretyping/evarutil.cmx kernel/environ.cmx contrib/interface/ctast.cmx \ + interp/constrextern.cmx parsing/ast.cmx contrib/interface/ascent.cmi \ contrib/interface/translate.cmi contrib/interface/vtp.cmo: contrib/interface/ascent.cmi \ contrib/interface/vtp.cmi contrib/interface/vtp.cmx: contrib/interface/ascent.cmi \ contrib/interface/vtp.cmi -contrib/interface/xlate.cmo: contrib/interface/ascent.cmi parsing/ast.cmi \ - lib/bignat.cmi library/decl_kinds.cmo tactics/eauto.cmi \ - parsing/extend.cmi tactics/extraargs.cmi contrib/field/field.cmo \ - interp/genarg.cmi library/goptions.cmi library/libnames.cmi \ - kernel/names.cmi lib/options.cmi parsing/ppconstr.cmi \ - pretyping/rawterm.cmi proofs/tacexpr.cmo kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi toplevel/vernacexpr.cmo \ +contrib/interface/xlate.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi kernel/term.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi parsing/ppconstr.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi library/goptions.cmi \ + interp/genarg.cmi contrib/field/field.cmo tactics/extraargs.cmi \ + parsing/extend.cmi tactics/eauto.cmi library/decl_kinds.cmo \ + lib/bignat.cmi parsing/ast.cmi contrib/interface/ascent.cmi \ contrib/interface/xlate.cmi -contrib/interface/xlate.cmx: contrib/interface/ascent.cmi parsing/ast.cmx \ - lib/bignat.cmx library/decl_kinds.cmx tactics/eauto.cmx \ - parsing/extend.cmx tactics/extraargs.cmx contrib/field/field.cmx \ - interp/genarg.cmx library/goptions.cmx library/libnames.cmx \ - kernel/names.cmx lib/options.cmx parsing/ppconstr.cmx \ - pretyping/rawterm.cmx proofs/tacexpr.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx toplevel/vernacexpr.cmx \ +contrib/interface/xlate.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx kernel/term.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx parsing/ppconstr.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx library/goptions.cmx \ + interp/genarg.cmx contrib/field/field.cmx tactics/extraargs.cmx \ + parsing/extend.cmx tactics/eauto.cmx library/decl_kinds.cmx \ + lib/bignat.cmx parsing/ast.cmx contrib/interface/ascent.cmi \ contrib/interface/xlate.cmi -contrib/jprover/jall.cmo: contrib/jprover/jlogic.cmi \ - contrib/jprover/jterm.cmi contrib/jprover/jtunify.cmi \ - contrib/jprover/opname.cmi lib/pp.cmi contrib/jprover/jall.cmi -contrib/jprover/jall.cmx: contrib/jprover/jlogic.cmx \ - contrib/jprover/jterm.cmx contrib/jprover/jtunify.cmx \ - contrib/jprover/opname.cmx lib/pp.cmx contrib/jprover/jall.cmi -contrib/jprover/jlogic.cmo: contrib/jprover/jterm.cmi \ - contrib/jprover/opname.cmi contrib/jprover/jlogic.cmi -contrib/jprover/jlogic.cmx: contrib/jprover/jterm.cmx \ - contrib/jprover/opname.cmx contrib/jprover/jlogic.cmi -contrib/jprover/jprover.cmo: toplevel/cerrors.cmi proofs/clenv.cmi \ - parsing/egrammar.cmi interp/genarg.cmi library/global.cmi \ - tactics/hiddentac.cmi tactics/hipattern.cmi contrib/jprover/jall.cmi \ - contrib/jprover/jlogic.cmi contrib/jprover/jterm.cmi kernel/names.cmi \ - lib/options.cmi pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi parsing/printer.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi pretyping/reductionops.cmi \ - proofs/refiner.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi -contrib/jprover/jprover.cmx: toplevel/cerrors.cmx proofs/clenv.cmx \ - parsing/egrammar.cmx interp/genarg.cmx library/global.cmx \ - tactics/hiddentac.cmx tactics/hipattern.cmx contrib/jprover/jall.cmx \ - contrib/jprover/jlogic.cmx contrib/jprover/jterm.cmx kernel/names.cmx \ - lib/options.cmx pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx parsing/printer.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx kernel/reduction.cmx pretyping/reductionops.cmx \ - proofs/refiner.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx +contrib/jprover/jall.cmo: lib/pp.cmi contrib/jprover/opname.cmi \ + contrib/jprover/jtunify.cmi contrib/jprover/jterm.cmi \ + contrib/jprover/jlogic.cmi contrib/jprover/jall.cmi +contrib/jprover/jall.cmx: lib/pp.cmx contrib/jprover/opname.cmx \ + contrib/jprover/jtunify.cmx contrib/jprover/jterm.cmx \ + contrib/jprover/jlogic.cmx contrib/jprover/jall.cmi +contrib/jprover/jlogic.cmo: contrib/jprover/opname.cmi \ + contrib/jprover/jterm.cmi contrib/jprover/jlogic.cmi +contrib/jprover/jlogic.cmx: contrib/jprover/opname.cmx \ + contrib/jprover/jterm.cmx contrib/jprover/jlogic.cmi +contrib/jprover/jprover.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi tactics/tacinterp.cmi proofs/tacexpr.cmo \ + proofs/refiner.cmi pretyping/reductionops.cmi kernel/reduction.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi parsing/printer.cmi \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi pretyping/pattern.cmi \ + lib/options.cmi kernel/names.cmi contrib/jprover/jterm.cmi \ + contrib/jprover/jlogic.cmi contrib/jprover/jall.cmi tactics/hipattern.cmi \ + tactics/hiddentac.cmi library/global.cmi interp/genarg.cmi \ + parsing/egrammar.cmi proofs/clenv.cmi toplevel/cerrors.cmi +contrib/jprover/jprover.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx tactics/tacinterp.cmx proofs/tacexpr.cmx \ + proofs/refiner.cmx pretyping/reductionops.cmx kernel/reduction.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx parsing/printer.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx pretyping/pattern.cmx \ + lib/options.cmx kernel/names.cmx contrib/jprover/jterm.cmx \ + contrib/jprover/jlogic.cmx contrib/jprover/jall.cmx tactics/hipattern.cmx \ + tactics/hiddentac.cmx library/global.cmx interp/genarg.cmx \ + parsing/egrammar.cmx proofs/clenv.cmx toplevel/cerrors.cmx contrib/jprover/jterm.cmo: contrib/jprover/opname.cmi \ contrib/jprover/jterm.cmi contrib/jprover/jterm.cmx: contrib/jprover/opname.cmx \ @@ -3043,228 +3040,230 @@ contrib/jprover/jtunify.cmo: contrib/jprover/jtunify.cmi contrib/jprover/jtunify.cmx: contrib/jprover/jtunify.cmi contrib/jprover/opname.cmo: contrib/jprover/opname.cmi contrib/jprover/opname.cmx: contrib/jprover/opname.cmi -contrib/omega/coq_omega.cmo: parsing/ast.cmi proofs/clenv.cmi \ - kernel/closure.cmi tactics/contradiction.cmi interp/coqlib.cmi \ - kernel/declarations.cmi kernel/environ.cmi tactics/equality.cmi \ - proofs/evar_refiner.cmi library/global.cmi library/goptions.cmi \ - kernel/inductive.cmi library/libnames.cmi library/library.cmi \ - proofs/logic.cmi library/nameops.cmi kernel/names.cmi library/nametab.cmi \ - contrib/omega/omega.cmo lib/options.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/reduction.cmi \ - kernel/sign.cmi proofs/tacmach.cmi pretyping/tacred.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi -contrib/omega/coq_omega.cmx: parsing/ast.cmx proofs/clenv.cmx \ - kernel/closure.cmx tactics/contradiction.cmx interp/coqlib.cmx \ - kernel/declarations.cmx kernel/environ.cmx tactics/equality.cmx \ - proofs/evar_refiner.cmx library/global.cmx library/goptions.cmx \ - kernel/inductive.cmx library/libnames.cmx library/library.cmx \ - proofs/logic.cmx library/nameops.cmx kernel/names.cmx library/nametab.cmx \ - contrib/omega/omega.cmx lib/options.cmx lib/pp.cmx parsing/printer.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx kernel/reduction.cmx \ - kernel/sign.cmx proofs/tacmach.cmx pretyping/tacred.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx -contrib/omega/g_omega.cmo: toplevel/cerrors.cmi contrib/omega/coq_omega.cmo \ - parsing/egrammar.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi proofs/refiner.cmi proofs/tacexpr.cmo \ - tactics/tacinterp.cmi lib/util.cmi -contrib/omega/g_omega.cmx: toplevel/cerrors.cmx contrib/omega/coq_omega.cmx \ - parsing/egrammar.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx proofs/refiner.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx lib/util.cmx -contrib/omega/omega.cmo: library/nameops.cmi kernel/names.cmi lib/util.cmi -contrib/omega/omega.cmx: library/nameops.cmx kernel/names.cmx lib/util.cmx -contrib/ring/g_quote.cmo: toplevel/cerrors.cmi parsing/egrammar.cmi \ - interp/genarg.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi contrib/ring/quote.cmo proofs/refiner.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi lib/util.cmi -contrib/ring/g_quote.cmx: toplevel/cerrors.cmx parsing/egrammar.cmx \ - interp/genarg.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx contrib/ring/quote.cmx proofs/refiner.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx lib/util.cmx -contrib/ring/g_ring.cmo: toplevel/cerrors.cmi parsing/egrammar.cmi \ - interp/genarg.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi contrib/ring/quote.cmo proofs/refiner.cmi \ - contrib/ring/ring.cmo proofs/tacexpr.cmo tactics/tacinterp.cmi \ - lib/util.cmi toplevel/vernacinterp.cmi -contrib/ring/g_ring.cmx: toplevel/cerrors.cmx parsing/egrammar.cmx \ - interp/genarg.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx contrib/ring/quote.cmx proofs/refiner.cmx \ - contrib/ring/ring.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - lib/util.cmx toplevel/vernacinterp.cmx -contrib/ring/quote.cmo: interp/coqlib.cmi kernel/environ.cmi \ - library/global.cmi pretyping/instantiate.cmi library/library.cmi \ - pretyping/matching.cmi kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi \ - proofs/proof_trees.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi lib/util.cmi -contrib/ring/quote.cmx: interp/coqlib.cmx kernel/environ.cmx \ - library/global.cmx pretyping/instantiate.cmx library/library.cmx \ - pretyping/matching.cmx kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx \ - proofs/proof_trees.cmx proofs/tacexpr.cmx proofs/tacmach.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx lib/util.cmx -contrib/ring/ring.cmo: kernel/closure.cmi interp/constrintern.cmi \ - interp/coqlib.cmi tactics/equality.cmi pretyping/evd.cmi \ - library/global.cmi tactics/hiddentac.cmi tactics/hipattern.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi contrib/ring/quote.cmo \ - pretyping/reductionops.cmi tactics/setoid_replace.cmi library/summary.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi pretyping/tacred.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/typing.cmi lib/util.cmi toplevel/vernacexpr.cmo \ - toplevel/vernacinterp.cmi -contrib/ring/ring.cmx: kernel/closure.cmx interp/constrintern.cmx \ - interp/coqlib.cmx tactics/equality.cmx pretyping/evd.cmx \ - library/global.cmx tactics/hiddentac.cmx tactics/hipattern.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx contrib/ring/quote.cmx \ - pretyping/reductionops.cmx tactics/setoid_replace.cmx library/summary.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx pretyping/tacred.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/typing.cmx lib/util.cmx toplevel/vernacexpr.cmx \ - toplevel/vernacinterp.cmx -contrib/romega/const_omega.cmo: interp/coqlib.cmi library/global.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - kernel/term.cmi lib/util.cmi -contrib/romega/const_omega.cmx: interp/coqlib.cmx library/global.cmx \ - library/libnames.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - kernel/term.cmx lib/util.cmx -contrib/romega/g_romega.cmo: toplevel/cerrors.cmi parsing/egrammar.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - proofs/refiner.cmi contrib/romega/refl_omega.cmo proofs/tacexpr.cmo \ - tactics/tacinterp.cmi lib/util.cmi -contrib/romega/g_romega.cmx: toplevel/cerrors.cmx parsing/egrammar.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - proofs/refiner.cmx contrib/romega/refl_omega.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx lib/util.cmx -contrib/romega/omega2.cmo: kernel/names.cmi lib/util.cmi -contrib/romega/omega2.cmx: kernel/names.cmx lib/util.cmx -contrib/romega/refl_omega.cmo: contrib/romega/const_omega.cmo \ - proofs/logic.cmi kernel/names.cmi contrib/romega/omega2.cmo \ - lib/options.cmi lib/pp.cmi parsing/printer.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi lib/util.cmi -contrib/romega/refl_omega.cmx: contrib/romega/const_omega.cmx \ - proofs/logic.cmx kernel/names.cmx contrib/romega/omega2.cmx \ - lib/options.cmx lib/pp.cmx parsing/printer.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx lib/util.cmx -contrib/xml/acic2Xml.cmo: contrib/xml/acic.cmo contrib/xml/cic2acic.cmo \ - kernel/names.cmi kernel/term.cmi lib/util.cmi contrib/xml/xml.cmi -contrib/xml/acic2Xml.cmx: contrib/xml/acic.cmx contrib/xml/cic2acic.cmx \ - kernel/names.cmx kernel/term.cmx lib/util.cmx contrib/xml/xml.cmx -contrib/xml/acic.cmo: kernel/names.cmi kernel/term.cmi -contrib/xml/acic.cmx: kernel/names.cmx kernel/term.cmx -contrib/xml/cic2acic.cmo: contrib/xml/acic.cmo kernel/declarations.cmi \ - library/declare.cmi library/dischargedhypsmap.cmi \ - contrib/xml/doubleTypeInference.cmi kernel/environ.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi library/global.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi pretyping/instantiate.cmi \ - library/lib.cmi library/libnames.cmi library/library.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/pp.cmi \ - parsing/printer.cmi pretyping/reductionops.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/univ.cmi contrib/xml/unshare.cmi \ - lib/util.cmi -contrib/xml/cic2acic.cmx: contrib/xml/acic.cmx kernel/declarations.cmx \ - library/declare.cmx library/dischargedhypsmap.cmx \ - contrib/xml/doubleTypeInference.cmx kernel/environ.cmx \ - pretyping/evarutil.cmx pretyping/evd.cmx library/global.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx pretyping/instantiate.cmx \ - library/lib.cmx library/libnames.cmx library/library.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/pp.cmx \ - parsing/printer.cmx pretyping/reductionops.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/univ.cmx contrib/xml/unshare.cmx \ - lib/util.cmx -contrib/xml/doubleTypeInference.cmo: contrib/xml/acic.cmo \ - kernel/conv_oracle.cmi kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/evd.cmi kernel/inductive.cmi pretyping/instantiate.cmi \ - library/libnames.cmi kernel/names.cmi lib/pp.cmi parsing/printer.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi pretyping/reductionops.cmi \ - pretyping/retyping.cmi pretyping/tacred.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/typeops.cmi contrib/xml/unshare.cmi \ - lib/util.cmi contrib/xml/doubleTypeInference.cmi -contrib/xml/doubleTypeInference.cmx: contrib/xml/acic.cmx \ - kernel/conv_oracle.cmx kernel/environ.cmx pretyping/evarutil.cmx \ - pretyping/evd.cmx kernel/inductive.cmx pretyping/instantiate.cmx \ - library/libnames.cmx kernel/names.cmx lib/pp.cmx parsing/printer.cmx \ - pretyping/rawterm.cmx kernel/reduction.cmx pretyping/reductionops.cmx \ - pretyping/retyping.cmx pretyping/tacred.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/typeops.cmx contrib/xml/unshare.cmx \ - lib/util.cmx contrib/xml/doubleTypeInference.cmi -contrib/xml/proof2aproof.cmo: pretyping/evarutil.cmi pretyping/evd.cmi \ - library/global.cmi pretyping/instantiate.cmi proofs/logic.cmi lib/pp.cmi \ - proofs/proof_type.cmi proofs/refiner.cmi kernel/sign.cmi \ - proofs/tacmach.cmi kernel/term.cmi pretyping/termops.cmi \ - contrib/xml/unshare.cmi lib/util.cmi -contrib/xml/proof2aproof.cmx: pretyping/evarutil.cmx pretyping/evd.cmx \ - library/global.cmx pretyping/instantiate.cmx proofs/logic.cmx lib/pp.cmx \ - proofs/proof_type.cmx proofs/refiner.cmx kernel/sign.cmx \ - proofs/tacmach.cmx kernel/term.cmx pretyping/termops.cmx \ - contrib/xml/unshare.cmx lib/util.cmx -contrib/xml/proofTree2Xml.cmo: contrib/xml/acic.cmo contrib/xml/acic2Xml.cmo \ - contrib/xml/cic2acic.cmo kernel/environ.cmi pretyping/evd.cmi \ - library/global.cmi proofs/logic.cmi kernel/names.cmi lib/options.cmi \ - lib/pp.cmi parsing/pptactic.cmi translate/pptacticnew.cmi \ - parsing/printer.cmi contrib/xml/proof2aproof.cmo proofs/proof_trees.cmi \ - proofs/proof_type.cmi kernel/sign.cmi proofs/tacexpr.cmo kernel/term.cmi \ - contrib/xml/unshare.cmi lib/util.cmi contrib/xml/xml.cmi -contrib/xml/proofTree2Xml.cmx: contrib/xml/acic.cmx contrib/xml/acic2Xml.cmx \ - contrib/xml/cic2acic.cmx kernel/environ.cmx pretyping/evd.cmx \ - library/global.cmx proofs/logic.cmx kernel/names.cmx lib/options.cmx \ - lib/pp.cmx parsing/pptactic.cmx translate/pptacticnew.cmx \ - parsing/printer.cmx contrib/xml/proof2aproof.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx kernel/sign.cmx proofs/tacexpr.cmx kernel/term.cmx \ - contrib/xml/unshare.cmx lib/util.cmx contrib/xml/xml.cmx +contrib/omega/coq_omega.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + pretyping/tacred.cmi proofs/tacmach.cmi kernel/sign.cmi \ + kernel/reduction.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + parsing/printer.cmi lib/pp.cmi lib/options.cmi contrib/omega/omega.cmo \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi proofs/logic.cmi \ + library/library.cmi library/libnames.cmi kernel/inductive.cmi \ + library/goptions.cmi library/global.cmi proofs/evar_refiner.cmi \ + tactics/equality.cmi kernel/environ.cmi kernel/declarations.cmi \ + interp/coqlib.cmi tactics/contradiction.cmi kernel/closure.cmi \ + proofs/clenv.cmi parsing/ast.cmi +contrib/omega/coq_omega.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + pretyping/tacred.cmx proofs/tacmach.cmx kernel/sign.cmx \ + kernel/reduction.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + parsing/printer.cmx lib/pp.cmx lib/options.cmx contrib/omega/omega.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx proofs/logic.cmx \ + library/library.cmx library/libnames.cmx kernel/inductive.cmx \ + library/goptions.cmx library/global.cmx proofs/evar_refiner.cmx \ + tactics/equality.cmx kernel/environ.cmx kernel/declarations.cmx \ + interp/coqlib.cmx tactics/contradiction.cmx kernel/closure.cmx \ + proofs/clenv.cmx parsing/ast.cmx +contrib/omega/g_omega.cmo: lib/util.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo proofs/refiner.cmi parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi parsing/egrammar.cmi \ + contrib/omega/coq_omega.cmo toplevel/cerrors.cmi +contrib/omega/g_omega.cmx: lib/util.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx proofs/refiner.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx parsing/egrammar.cmx \ + contrib/omega/coq_omega.cmx toplevel/cerrors.cmx +contrib/omega/omega.cmo: lib/util.cmi kernel/names.cmi library/nameops.cmi +contrib/omega/omega.cmx: lib/util.cmx kernel/names.cmx library/nameops.cmx +contrib/ring/g_quote.cmo: lib/util.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo proofs/refiner.cmi contrib/ring/quote.cmo \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + interp/genarg.cmi parsing/egrammar.cmi toplevel/cerrors.cmi +contrib/ring/g_quote.cmx: lib/util.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx proofs/refiner.cmx contrib/ring/quote.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + interp/genarg.cmx parsing/egrammar.cmx toplevel/cerrors.cmx +contrib/ring/g_ring.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo contrib/ring/ring.cmo \ + proofs/refiner.cmi contrib/ring/quote.cmo parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi interp/genarg.cmi parsing/egrammar.cmi \ + toplevel/cerrors.cmi +contrib/ring/g_ring.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx contrib/ring/ring.cmx \ + proofs/refiner.cmx contrib/ring/quote.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx interp/genarg.cmx parsing/egrammar.cmx \ + toplevel/cerrors.cmx +contrib/ring/quote.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + proofs/proof_trees.cmi lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi \ + pretyping/matching.cmi library/library.cmi pretyping/instantiate.cmi \ + library/global.cmi kernel/environ.cmi interp/coqlib.cmi +contrib/ring/quote.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx proofs/tacmach.cmx proofs/tacexpr.cmx \ + proofs/proof_trees.cmx lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx \ + pretyping/matching.cmx library/library.cmx pretyping/instantiate.cmx \ + library/global.cmx kernel/environ.cmx interp/coqlib.cmx +contrib/ring/ring.cmo: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + lib/util.cmi pretyping/typing.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo library/summary.cmi tactics/setoid_replace.cmi \ + pretyping/reductionops.cmi contrib/ring/quote.cmo proofs/proof_trees.cmi \ + parsing/printer.cmi lib/pp.cmi pretyping/pattern.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/library.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi tactics/hipattern.cmi tactics/hiddentac.cmi \ + library/global.cmi pretyping/evd.cmi tactics/equality.cmi \ + interp/coqlib.cmi interp/constrintern.cmi kernel/closure.cmi +contrib/ring/ring.cmx: toplevel/vernacinterp.cmx toplevel/vernacexpr.cmx \ + lib/util.cmx pretyping/typing.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx pretyping/tacred.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx library/summary.cmx tactics/setoid_replace.cmx \ + pretyping/reductionops.cmx contrib/ring/quote.cmx proofs/proof_trees.cmx \ + parsing/printer.cmx lib/pp.cmx pretyping/pattern.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/library.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx tactics/hipattern.cmx tactics/hiddentac.cmx \ + library/global.cmx pretyping/evd.cmx tactics/equality.cmx \ + interp/coqlib.cmx interp/constrintern.cmx kernel/closure.cmx +contrib/romega/const_omega.cmo: lib/util.cmi kernel/term.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + library/global.cmi interp/coqlib.cmi +contrib/romega/const_omega.cmx: lib/util.cmx kernel/term.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/libnames.cmx \ + library/global.cmx interp/coqlib.cmx +contrib/romega/g_romega.cmo: lib/util.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo contrib/romega/refl_omega.cmo proofs/refiner.cmi \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + parsing/egrammar.cmi toplevel/cerrors.cmi +contrib/romega/g_romega.cmx: lib/util.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx contrib/romega/refl_omega.cmx proofs/refiner.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + parsing/egrammar.cmx toplevel/cerrors.cmx +contrib/romega/omega2.cmo: lib/util.cmi kernel/names.cmi +contrib/romega/omega2.cmx: lib/util.cmx kernel/names.cmx +contrib/romega/refl_omega.cmo: lib/util.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + parsing/printer.cmi lib/pp.cmi lib/options.cmi contrib/romega/omega2.cmo \ + kernel/names.cmi proofs/logic.cmi contrib/romega/const_omega.cmo +contrib/romega/refl_omega.cmx: lib/util.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + parsing/printer.cmx lib/pp.cmx lib/options.cmx contrib/romega/omega2.cmx \ + kernel/names.cmx proofs/logic.cmx contrib/romega/const_omega.cmx +contrib/xml/acic.cmo: kernel/term.cmi kernel/names.cmi +contrib/xml/acic.cmx: kernel/term.cmx kernel/names.cmx +contrib/xml/acic2Xml.cmo: contrib/xml/xml.cmi lib/util.cmi kernel/term.cmi \ + kernel/names.cmi contrib/xml/cic2acic.cmo contrib/xml/acic.cmo +contrib/xml/acic2Xml.cmx: contrib/xml/xml.cmx lib/util.cmx kernel/term.cmx \ + kernel/names.cmx contrib/xml/cic2acic.cmx contrib/xml/acic.cmx +contrib/xml/cic2acic.cmo: lib/util.cmi contrib/xml/unshare.cmi \ + kernel/univ.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/reductionops.cmi parsing/printer.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/library.cmi library/libnames.cmi library/lib.cmi \ + pretyping/instantiate.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + library/global.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + kernel/environ.cmi contrib/xml/doubleTypeInference.cmi \ + library/dischargedhypsmap.cmi library/declare.cmi kernel/declarations.cmi \ + contrib/xml/acic.cmo +contrib/xml/cic2acic.cmx: lib/util.cmx contrib/xml/unshare.cmx \ + kernel/univ.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/reductionops.cmx parsing/printer.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/library.cmx library/libnames.cmx library/lib.cmx \ + pretyping/instantiate.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + library/global.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + kernel/environ.cmx contrib/xml/doubleTypeInference.cmx \ + library/dischargedhypsmap.cmx library/declare.cmx kernel/declarations.cmx \ + contrib/xml/acic.cmx +contrib/xml/doubleTypeInference.cmo: lib/util.cmi contrib/xml/unshare.cmi \ + kernel/typeops.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/tacred.cmi pretyping/retyping.cmi pretyping/reductionops.cmi \ + kernel/reduction.cmi pretyping/rawterm.cmi parsing/printer.cmi lib/pp.cmi \ + kernel/names.cmi library/libnames.cmi pretyping/instantiate.cmi \ + kernel/inductive.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + kernel/environ.cmi kernel/conv_oracle.cmi contrib/xml/acic.cmo \ + contrib/xml/doubleTypeInference.cmi +contrib/xml/doubleTypeInference.cmx: lib/util.cmx contrib/xml/unshare.cmx \ + kernel/typeops.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/tacred.cmx pretyping/retyping.cmx pretyping/reductionops.cmx \ + kernel/reduction.cmx pretyping/rawterm.cmx parsing/printer.cmx lib/pp.cmx \ + kernel/names.cmx library/libnames.cmx pretyping/instantiate.cmx \ + kernel/inductive.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + kernel/environ.cmx kernel/conv_oracle.cmx contrib/xml/acic.cmx \ + contrib/xml/doubleTypeInference.cmi +contrib/xml/proof2aproof.cmo: lib/util.cmi contrib/xml/unshare.cmi \ + pretyping/termops.cmi kernel/term.cmi proofs/tacmach.cmi kernel/sign.cmi \ + proofs/refiner.cmi proofs/proof_type.cmi lib/pp.cmi proofs/logic.cmi \ + pretyping/instantiate.cmi library/global.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi +contrib/xml/proof2aproof.cmx: lib/util.cmx contrib/xml/unshare.cmx \ + pretyping/termops.cmx kernel/term.cmx proofs/tacmach.cmx kernel/sign.cmx \ + proofs/refiner.cmx proofs/proof_type.cmx lib/pp.cmx proofs/logic.cmx \ + pretyping/instantiate.cmx library/global.cmx pretyping/evd.cmx \ + pretyping/evarutil.cmx +contrib/xml/proofTree2Xml.cmo: contrib/xml/xml.cmi lib/util.cmi \ + contrib/xml/unshare.cmi kernel/term.cmi proofs/tacexpr.cmo \ + kernel/sign.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + contrib/xml/proof2aproof.cmo parsing/printer.cmi \ + translate/pptacticnew.cmi parsing/pptactic.cmi lib/pp.cmi lib/options.cmi \ + kernel/names.cmi proofs/logic.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi contrib/xml/cic2acic.cmo contrib/xml/acic2Xml.cmo \ + contrib/xml/acic.cmo +contrib/xml/proofTree2Xml.cmx: contrib/xml/xml.cmx lib/util.cmx \ + contrib/xml/unshare.cmx kernel/term.cmx proofs/tacexpr.cmx \ + kernel/sign.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + contrib/xml/proof2aproof.cmx parsing/printer.cmx \ + translate/pptacticnew.cmx parsing/pptactic.cmx lib/pp.cmx lib/options.cmx \ + kernel/names.cmx proofs/logic.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx contrib/xml/cic2acic.cmx contrib/xml/acic2Xml.cmx \ + contrib/xml/acic.cmx contrib/xml/unshare.cmo: contrib/xml/unshare.cmi contrib/xml/unshare.cmx: contrib/xml/unshare.cmi -contrib/xml/xmlcommand.cmo: contrib/xml/acic.cmo contrib/xml/acic2Xml.cmo \ - contrib/xml/cic2acic.cmo config/coq_config.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi library/declare.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi kernel/inductive.cmi \ - parsing/lexer.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi kernel/names.cmi \ - library/nametab.cmi proofs/pfedit.cmi contrib/xml/proof2aproof.cmo \ - proofs/proof_trees.cmi pretyping/recordops.cmi kernel/sign.cmi \ - proofs/tacmach.cmi kernel/term.cmi contrib/xml/unshare.cmi lib/util.cmi \ - toplevel/vernac.cmi contrib/xml/xml.cmi contrib/xml/xmlcommand.cmi -contrib/xml/xmlcommand.cmx: contrib/xml/acic.cmx contrib/xml/acic2Xml.cmx \ - contrib/xml/cic2acic.cmx config/coq_config.cmx library/decl_kinds.cmx \ - kernel/declarations.cmx library/declare.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx kernel/inductive.cmx \ - parsing/lexer.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/library.cmx kernel/names.cmx \ - library/nametab.cmx proofs/pfedit.cmx contrib/xml/proof2aproof.cmx \ - proofs/proof_trees.cmx pretyping/recordops.cmx kernel/sign.cmx \ - proofs/tacmach.cmx kernel/term.cmx contrib/xml/unshare.cmx lib/util.cmx \ - toplevel/vernac.cmx contrib/xml/xml.cmx contrib/xml/xmlcommand.cmi -contrib/xml/xmlentries.cmo: toplevel/cerrors.cmi parsing/egrammar.cmi \ - parsing/extend.cmi interp/genarg.cmi parsing/pcoq.cmi lib/pp.cmi \ - lib/util.cmi toplevel/vernacinterp.cmi contrib/xml/xmlcommand.cmi -contrib/xml/xmlentries.cmx: toplevel/cerrors.cmx parsing/egrammar.cmx \ - parsing/extend.cmx interp/genarg.cmx parsing/pcoq.cmx lib/pp.cmx \ - lib/util.cmx toplevel/vernacinterp.cmx contrib/xml/xmlcommand.cmx contrib/xml/xml.cmo: contrib/xml/xml.cmi contrib/xml/xml.cmx: contrib/xml/xml.cmi -ide/utils/configwin_html_config.cmo: ide/utils/configwin_ihm.cmo \ - ide/utils/configwin_messages.cmo ide/utils/configwin_types.cmo \ - ide/utils/uoptions.cmi -ide/utils/configwin_html_config.cmx: ide/utils/configwin_ihm.cmx \ - ide/utils/configwin_messages.cmx ide/utils/configwin_types.cmx \ - ide/utils/uoptions.cmx -ide/utils/configwin_ihm.cmo: ide/utils/configwin_messages.cmo \ - ide/utils/configwin_types.cmo ide/utils/okey.cmi ide/utils/uoptions.cmi -ide/utils/configwin_ihm.cmx: ide/utils/configwin_messages.cmx \ - ide/utils/configwin_types.cmx ide/utils/okey.cmx ide/utils/uoptions.cmx -ide/utils/configwin.cmo: ide/utils/configwin_ihm.cmo \ - ide/utils/configwin_types.cmo ide/utils/configwin.cmi -ide/utils/configwin.cmx: ide/utils/configwin_ihm.cmx \ - ide/utils/configwin_types.cmx ide/utils/configwin.cmi -ide/utils/configwin_types.cmo: ide/utils/configwin_keys.cmo \ - ide/utils/uoptions.cmi -ide/utils/configwin_types.cmx: ide/utils/configwin_keys.cmx \ - ide/utils/uoptions.cmx +contrib/xml/xmlcommand.cmo: contrib/xml/xml.cmi toplevel/vernac.cmi \ + lib/util.cmi contrib/xml/unshare.cmi kernel/term.cmi proofs/tacmach.cmi \ + kernel/sign.cmi pretyping/recordops.cmi proofs/proof_trees.cmi \ + contrib/xml/proof2aproof.cmo proofs/pfedit.cmi library/nametab.cmi \ + kernel/names.cmi library/library.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi parsing/lexer.cmi \ + kernel/inductive.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi library/declare.cmi kernel/declarations.cmi \ + library/decl_kinds.cmo config/coq_config.cmi contrib/xml/cic2acic.cmo \ + contrib/xml/acic2Xml.cmo contrib/xml/acic.cmo contrib/xml/xmlcommand.cmi +contrib/xml/xmlcommand.cmx: contrib/xml/xml.cmx toplevel/vernac.cmx \ + lib/util.cmx contrib/xml/unshare.cmx kernel/term.cmx proofs/tacmach.cmx \ + kernel/sign.cmx pretyping/recordops.cmx proofs/proof_trees.cmx \ + contrib/xml/proof2aproof.cmx proofs/pfedit.cmx library/nametab.cmx \ + kernel/names.cmx library/library.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx parsing/lexer.cmx \ + kernel/inductive.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx library/declare.cmx kernel/declarations.cmx \ + library/decl_kinds.cmx config/coq_config.cmx contrib/xml/cic2acic.cmx \ + contrib/xml/acic2Xml.cmx contrib/xml/acic.cmx contrib/xml/xmlcommand.cmi +contrib/xml/xmlentries.cmo: contrib/xml/xmlcommand.cmi \ + toplevel/vernacinterp.cmi lib/util.cmi lib/pp.cmi parsing/pcoq.cmi \ + interp/genarg.cmi parsing/extend.cmi parsing/egrammar.cmi \ + toplevel/cerrors.cmi +contrib/xml/xmlentries.cmx: contrib/xml/xmlcommand.cmx \ + toplevel/vernacinterp.cmx lib/util.cmx lib/pp.cmx parsing/pcoq.cmx \ + interp/genarg.cmx parsing/extend.cmx parsing/egrammar.cmx \ + toplevel/cerrors.cmx +ide/utils/configwin.cmo: ide/utils/configwin_types.cmo \ + ide/utils/configwin_ihm.cmo ide/utils/configwin.cmi +ide/utils/configwin.cmx: ide/utils/configwin_types.cmx \ + ide/utils/configwin_ihm.cmx ide/utils/configwin.cmi +ide/utils/configwin_html_config.cmo: ide/utils/uoptions.cmi \ + ide/utils/configwin_types.cmo ide/utils/configwin_messages.cmo \ + ide/utils/configwin_ihm.cmo +ide/utils/configwin_html_config.cmx: ide/utils/uoptions.cmx \ + ide/utils/configwin_types.cmx ide/utils/configwin_messages.cmx \ + ide/utils/configwin_ihm.cmx +ide/utils/configwin_ihm.cmo: ide/utils/uoptions.cmi ide/utils/okey.cmi \ + ide/utils/configwin_types.cmo ide/utils/configwin_messages.cmo +ide/utils/configwin_ihm.cmx: ide/utils/uoptions.cmx ide/utils/okey.cmx \ + ide/utils/configwin_types.cmx ide/utils/configwin_messages.cmx +ide/utils/configwin_types.cmo: ide/utils/uoptions.cmi \ + ide/utils/configwin_keys.cmo +ide/utils/configwin_types.cmx: ide/utils/uoptions.cmx \ + ide/utils/configwin_keys.cmx ide/utils/okey.cmo: ide/utils/okey.cmi ide/utils/okey.cmx: ide/utils/okey.cmi ide/utils/uoptions.cmo: ide/utils/uoptions.cmi @@ -3273,15 +3272,15 @@ tools/coqdoc/alpha.cmo: tools/coqdoc/alpha.cmi tools/coqdoc/alpha.cmx: tools/coqdoc/alpha.cmi tools/coqdoc/index.cmo: tools/coqdoc/alpha.cmi tools/coqdoc/index.cmi tools/coqdoc/index.cmx: tools/coqdoc/alpha.cmx tools/coqdoc/index.cmi -tools/coqdoc/main.cmo: config/coq_config.cmi tools/coqdoc/index.cmi \ - tools/coqdoc/output.cmi tools/coqdoc/pretty.cmi -tools/coqdoc/main.cmx: config/coq_config.cmx tools/coqdoc/index.cmx \ - tools/coqdoc/output.cmx tools/coqdoc/pretty.cmx +tools/coqdoc/main.cmo: tools/coqdoc/pretty.cmi tools/coqdoc/output.cmi \ + tools/coqdoc/index.cmi config/coq_config.cmi +tools/coqdoc/main.cmx: tools/coqdoc/pretty.cmx tools/coqdoc/output.cmx \ + tools/coqdoc/index.cmx config/coq_config.cmx tools/coqdoc/output.cmo: tools/coqdoc/index.cmi tools/coqdoc/output.cmi tools/coqdoc/output.cmx: tools/coqdoc/index.cmx tools/coqdoc/output.cmi -tools/coqdoc/pretty.cmo: tools/coqdoc/index.cmi tools/coqdoc/output.cmi \ +tools/coqdoc/pretty.cmo: tools/coqdoc/output.cmi tools/coqdoc/index.cmi \ tools/coqdoc/pretty.cmi -tools/coqdoc/pretty.cmx: tools/coqdoc/index.cmx tools/coqdoc/output.cmx \ +tools/coqdoc/pretty.cmx: tools/coqdoc/output.cmx tools/coqdoc/index.cmx \ tools/coqdoc/pretty.cmi tactics/tauto.cmo: parsing/grammar.cma tactics/tauto.cmx: parsing/grammar.cma diff --git a/.depend.coq b/.depend.coq index 95233f2e..1b20c607 100644 --- a/.depend.coq +++ b/.depend.coq @@ -118,7 +118,7 @@ theories/NArith/BinNat.vo: theories/NArith/BinNat.v theories/NArith/BinPos.vo theories/NArith/NArith.vo: theories/NArith/NArith.v theories/NArith/BinPos.vo theories/NArith/BinNat.vo theories/ZArith/BinInt.vo: theories/ZArith/BinInt.v theories/NArith/BinPos.vo theories/NArith/Pnat.vo theories/NArith/BinNat.vo theories/Arith/Plus.vo theories/Arith/Mult.vo theories/ZArith/Wf_Z.vo: theories/ZArith/Wf_Z.v theories/ZArith/BinInt.vo theories/ZArith/Zcompare.vo theories/ZArith/Zorder.vo theories/ZArith/Znat.vo theories/ZArith/Zmisc.vo theories/Arith/Wf_nat.vo -theories/ZArith/ZArith.vo: theories/ZArith/ZArith.v theories/ZArith/ZArith_base.vo theories/ZArith/Zcomplements.vo theories/ZArith/Zsqrt.vo theories/ZArith/Zpower.vo theories/ZArith/Zdiv.vo theories/ZArith/Zlogarithm.vo theories/ZArith/Zbool.vo +theories/ZArith/ZArith.vo: theories/ZArith/ZArith.v theories/ZArith/ZArith_base.vo theories/ZArith/Zcomplements.vo theories/ZArith/Zsqrt.vo theories/ZArith/Zpower.vo theories/ZArith/Zdiv.vo theories/ZArith/Zlogarithm.vo theories/ZArith/ZArith_dec.vo: theories/ZArith/ZArith_dec.v theories/Bool/Sumbool.vo theories/ZArith/BinInt.vo theories/ZArith/Zorder.vo theories/ZArith/Zcompare.vo theories/ZArith/auxiliary.vo: theories/ZArith/auxiliary.v theories/Arith/Arith.vo theories/ZArith/BinInt.vo theories/ZArith/Zorder.vo theories/Logic/Decidable.vo theories/Arith/Peano_dec.vo theories/Arith/Compare_dec.vo theories/ZArith/Zmisc.vo: theories/ZArith/Zmisc.v theories/ZArith/BinInt.vo theories/ZArith/Zcompare.vo theories/ZArith/Zorder.vo theories/Bool/Bool.vo diff --git a/CHANGES b/CHANGES index 2daeded1..7b0a41d0 100644 --- a/CHANGES +++ b/CHANGES @@ -1,3 +1,20 @@ +Changes from V8.0pl1 to V8.0pl2 +=============================== + +Notations + +- Option "format" now aware of recursive notations + +Bug fixes + +- Tactic "fail n" for n<>0 now works (notice that each "match term with" + block decreases the failure level, in accordance with the intuition but + not in conformity with the reference manual) +- Option -dump-glob now strips module segment as expected by coqdoc (which + is still not aware of modules) +- See coq-bugs web page for a full list of fixed bugs (look for + fixes committed before Jan 2005 to cvs version V8-0-bugfix) + Changes from V8.0 to V8.0pl1 ============================ diff --git a/Makefile b/Makefile index af8a8c07..d04bc6ca 100644 --- a/Makefile +++ b/Makefile @@ -6,7 +6,7 @@ # # GNU Lesser General Public License Version 2.1 # ######################################################################## -# $Id: Makefile,v 1.459.2.10 2004/07/19 09:37:31 herbelin Exp $ +# $Id: Makefile,v 1.459.2.13 2005/01/21 17:15:12 herbelin Exp $ # Makefile for Coq @@ -135,8 +135,8 @@ PRETYPING=\ pretyping/reductionops.cmo pretyping/inductiveops.cmo \ pretyping/rawterm.cmo pretyping/pattern.cmo \ pretyping/detyping.cmo pretyping/retyping.cmo \ - pretyping/cbv.cmo pretyping/tacred.cmo \ - pretyping/pretype_errors.cmo pretyping/typing.cmo \ + pretyping/cbv.cmo pretyping/pretype_errors.cmo pretyping/typing.cmo \ + pretyping/tacred.cmo \ pretyping/classops.cmo pretyping/recordops.cmo pretyping/indrec.cmo \ pretyping/evarutil.cmo pretyping/evarconv.cmo \ pretyping/coercion.cmo pretyping/cases.cmo pretyping/pretyping.cmo \ @@ -1235,21 +1235,14 @@ install-latex: doc: doc/coq.tex $(MAKE) -C doc coq.ps minicoq.dvi -LPLIB = lib/doc.tex $(LIBREP:.cmo=.mli) -LPKERNEL = kernel/doc.tex $(KERNEL:.cmo=.mli) -LPLIBRARY = library/doc.tex $(LIBRARY:.cmo=.mli) -LPPRETYPING = pretyping/doc.tex pretyping/rawterm.mli $(PRETYPING:.cmo=.mli) -LPINTERP = $(INTERP:.cmo=.mli) -LPPARSING = $(PARSING:.cmo=.mli) $(HIGHPARSING:.cmo=.mli) -LPPROOFS = proofs/doc.tex $(PROOFS:.cmo=.mli) -LPTACTICS = tactics/doc.tex $(TACTICS:.cmo=.mli) $(HIGHTACTICS:.cmo=.mli) -LPTOPLEVEL = toplevel/doc.tex $(TOPLEVEL:.cmo=.mli) -LPFILES = doc/macros.tex doc/intro.tex $(LPLIB) $(LPKERNEL) $(LPLIBRARY) \ - $(LPPRETYPING) $(LPPROOFS) $(LPTACTICS) $(LPTOPLEVEL) - -doc/coq.tex: $(LPFILES) - ocamlweb -p "\usepackage{epsfig}" $(LPFILES) -o doc/coq.tex -# ocamlweb $(LPFILES) -o doc/coq.tex +doc/coq.tex: + ocamlweb -p "\usepackage{epsfig}" \ + doc/macros.tex doc/intro.tex \ + lib/{doc.tex,*.mli} kernel/{doc.tex,*.mli} library/{doc.tex,*.mli} \ + pretyping/{doc.tex,*.mli} interp/{doc.tex,*.mli} \ + parsing/{doc.tex,*.mli} proofs/{doc.tex,tacexpr.ml,*.mli} \ + tactics/{doc.tex,*.mli} toplevel/{doc.tex,vernacexpr.ml,*.mli} \ + -o doc/coq.tex clean:: rm -f doc/coq.tex @@ -1398,11 +1391,11 @@ proofs/tacexpr.cmx: proofs/tacexpr.ml lib/compat.cmo: lib/compat.ml4 $(SHOW)'OCAMLC4 $<' - $(HIDE)$(OCAMLC) $(BYTEFLAGS) -pp "$(CAMLP4O) $(CAMLP4EXTENDFLAGS) -D$(CAMLVERSION) -impl" -c -impl $< + $(HIDE)$(OCAMLC) $(BYTEFLAGS) -pp "$(CAMLP4O) $(CAMLP4EXTENDFLAGS) -impl" -c -impl $< lib/compat.cmx: lib/compat.ml4 $(SHOW)'OCAMLOPT $<' - $(HIDE)$(OCAMLOPT) $(OPTFLAGS) -pp "$(CAMLP4O) $(CAMLP4EXTENDFLAGS) -D$(CAMLVERSION) -impl" -c -impl $< + $(HIDE)$(OCAMLOPT) $(OPTFLAGS) -pp "$(CAMLP4O) $(CAMLP4EXTENDFLAGS) -impl" -c -impl $< # files compiled with camlp4 because of streams syntax diff --git a/configure b/configure index 923eee76..0891b262 100755 --- a/configure +++ b/configure @@ -6,8 +6,8 @@ # ################################## -VERSION=8.0pl1 -DATE="Jul 2004" +VERSION=8.0pl2 +DATE="Jan 2005" # a local which command for sh which () { @@ -539,4 +539,4 @@ echo echo "*Warning* To compile the system for a new architecture" echo " don't forget to do a 'make archclean' before './configure'." -# $Id: configure,v 1.74.2.5 2004/07/17 17:06:51 herbelin Exp $ +# $Id: configure,v 1.74.2.7 2005/01/21 17:27:32 herbelin Exp $ diff --git a/contrib/funind/tacinv.ml4 b/contrib/funind/tacinv.ml4 index d2ae12d6..b358ff39 100644 --- a/contrib/funind/tacinv.ml4 +++ b/contrib/funind/tacinv.ml4 @@ -68,6 +68,7 @@ let id_of_name = function let string_of_name nme = string_of_id (id_of_name nme) (*end debugging *) +(* Interpretation of constr's *) let constr_of c = Constrintern.interp_constr Evd.empty (Global.env()) c let rec collect_cases l = @@ -163,6 +164,8 @@ let rec npatternify ltypes c = (* let _ = prconstr res in *) res +(* fait une application (c m1 m2...mn, où mi est une evar, on rend également + la liste des evar munies de leur type) *) let rec apply_levars c lmetav = match lmetav with | [] -> [],c @@ -373,7 +376,8 @@ let rec proofPrinc mi lst_vars lst_eqs lst_recs: let anme = Array.of_list lnme' in let aappel_rec = Array.of_list lappel_rec in (* llevar are put outside the fix, so one level of rel must be removed *) - mkFix((iarr,i),(anme, pisarr,aappel_rec)),(pop1_levar llevar),llposeq,evararr,pisarr,[] + mkFix((iarr,i),(anme, pisarr,aappel_rec)) + , (pop1_levar llevar) , llposeq,evararr,pisarr,[] (* Cases b of arrPt end.*) | Case(cinfo, pcase, b, arrPt) -> @@ -495,7 +499,7 @@ let rec proofPrinc mi lst_vars lst_eqs lst_recs: let metav = mknewmeta() in let substmeta t = popn 1 (substitterm 0 (mkRel 1) metav t) in let newrec_call = substmeta rec_call in - let newlevar = List.map (fun ev,tev -> ev, substmeta tev) levar in + let newlevar = List.map (fun (ev,tev) -> ev, substmeta tev) levar in let newabsc = Array.map substmeta absc in newrec_call,newlevar,lposeq,evararr,newabsc,((metav,nme, typ)::parms) @@ -510,7 +514,8 @@ let rec proofPrinc mi lst_vars lst_eqs lst_recs: let nb_eqs = (List.length lst_eqs) in let eqrels = List.map fst lst_eqs in (* [terms_recs]: appel rec du fixpoint, On concatène les appels recs - trouvés dans les let in et les Cases. *) + trouvés dans les let in et les Cases avec ceux trouves dans u (ie + mi.mimick). *) (* TODO: il faudra gérer plusieurs pt fixes imbriqués ? *) let terms_recs = lst_recs @ (hdMatchSub_cpl mi.mimick mi.fonc) in @@ -539,9 +544,6 @@ let rec proofPrinc mi lst_vars lst_eqs lst_recs: let mkevarmap_aux ex = let x,y = ex in (mkevarmap_from_listex x),y -(* Interpretation of constr's *) -let constr_of_Constr c = Constrintern.interp_constr Evd.empty (Global.env()) c - (* TODO: deal with any term, not only a constant. *) let interp_fonc_tacarg fonctac gl = @@ -619,7 +621,7 @@ let invfun_basic open_princ_proof_applied listargs_ids gl dorew lposeq = (tclTHEN (* Refine on the right term (following the sheme of the given function) *) - (fun gl -> refine open_princ_proof_applied gl) + (fun gl -> refine open_princ_proof_applied gl) (* Clear the hypothesis given as arguments of the tactic (because they are generalized) *) (tclTHEN simpl_in_concl (tclTRY (clear listargs_ids)))) @@ -689,20 +691,17 @@ let invfun c l dorew gl = let _ = resetmeta() in let princ_proof,levar, lposeq,evararr,_,parms = invfun_proof [|fonc|] def_fonc [||] pis (pf_env gl) (project gl) in - (* Generalize the goal. [[x1:T1][x2:T2]... g[arg1 <- x1 ...]]. *) let gl_abstr' = add_lambdas (pf_concl gl) gl listargs' in (* apply parameters immediately *) - let gl_abstr = applistc gl_abstr' (List.map (fun x,y,z -> x) (List.rev parms)) in - + let gl_abstr = + applistc gl_abstr' (List.map (fun (x,y,z) -> x) (List.rev parms)) in (* we apply args of the fix now, the parameters will be applied later *) let princ_proof_applied_args = applistc princ_proof (listsuf (List.length parms) listargs') in - (* parameters are still there so patternify must not take them -> lift *) let princ_proof_applied_lift = lift (List.length levar) princ_proof_applied_args in - let princ_applied_hyps'' = patternify (List.rev levar) princ_proof_applied_lift (Name (id_of_string "Hyp")) in (* if there was a fix, we will not add "Q" as in funscheme, so we make a pop, @@ -710,14 +709,20 @@ let invfun c l dorew gl = and add lift in funscheme. *) let princ_applied_hyps' = if Array.length evararr > 0 then popn 1 princ_applied_hyps'' - else princ_applied_hyps'' in - + else princ_applied_hyps'' in + (* if there is was fix, we have to replace the meta representing the + predicate of the goal by the abstracted goal itself. *) let princ_applied_hyps = if Array.length evararr > 0 then (* mutual Fixpoint not treated in the tactic *) - (substit_red 0 (evararr.(0)) gl_abstr princ_applied_hyps') + (substit_red 0 (evararr.(0)) gl_abstr princ_applied_hyps') else princ_applied_hyps' (* No Fixpoint *) in let _ = prNamedConstr "princ_applied_hyps" princ_applied_hyps in - + (* Same thing inside levar *) + let newlevar' = + if Array.length evararr > 0 then (* mutual Fixpoint not treated in the tactic *) + List.map (fun (x,y) -> x,substit_red 0 (evararr.(0)) gl_abstr y) levar + else levar + in (* replace params metavar by real args *) let rec replace_parms lparms largs t = match lparms, largs with @@ -725,8 +730,12 @@ let invfun c l dorew gl = | ((p,_,_)::lp), (a::la) -> let t'= substitterm 0 p a t in replace_parms lp la t' | _, _ -> error "problem with number of args." in let princ_proof_applied = replace_parms parms listargs' princ_applied_hyps in - - + let _ = prNamedLConstr "levar:" (List.map fst newlevar') in + let _ = prNamedLConstr "levar types:" (List.map snd newlevar') in + let _ = prNamedConstr "princ_proof_applied" princ_proof_applied in + (* replace also in levar *) + let newlevar = + List.rev (List.map (fun (x,y) -> x, replace_parms parms listargs' y) newlevar') in (* (* replace params metavar by abstracted variables *) let princ_proof_params = npatternify (List.rev parms) princ_applied_hyps in @@ -734,12 +743,15 @@ let invfun c l dorew gl = let princ_proof_applied = applistc princ_proof_params (listpref (List.length parms) listargs') in *) - - - - let princ_applied_evars = apply_levars princ_proof_applied levar in + let princ_applied_evars = apply_levars princ_proof_applied newlevar in let open_princ_proof_applied = princ_applied_evars in + let _ = prNamedConstr "princ_applied_evars" (snd princ_applied_evars) in + let _ = prNamedLConstr "evars" (List.map snd (fst princ_applied_evars)) in let listargs_ids = List.map destVar (List.filter isVar listargs') in + (* debug: impression du but*) +(* let lgl = Evd.to_list (sig_sig gl) in *) +(* let _ = prNamedLConstr "\ngl= " (List.map (fun x -> (snd x).evar_concl) lgl) in *) +(* let _ = prstr "fin gl \n\n" in *) invfun_basic (mkevarmap_aux open_princ_proof_applied) listargs_ids gl dorew lposeq @@ -750,8 +762,7 @@ let invfun_verif c l dorew gl = let x,_ = decompose_prod (pf_type_of gl c) in if List.length x = List.length l then try invfun c l dorew gl - with - UserError (x,y) -> raise (UserError (x,y)) + with UserError (x,y) -> raise (UserError (x,y)) else error "wrong number of arguments for the function" @@ -790,7 +801,7 @@ let buildFunscheme fonc mutflist = in let rec princ_replace_params params t = List.fold_left ( - fun acc ev,nam,typ -> + fun acc (ev,nam,typ) -> mkLambda (Name (id_of_name nam) , typ, substitterm 0 ev (mkRel 1) (lift 0 acc))) t (List.rev params) in diff --git a/contrib/funind/tacinvutils.ml b/contrib/funind/tacinvutils.ml index 758071ba..6e086d95 100644 --- a/contrib/funind/tacinvutils.ml +++ b/contrib/funind/tacinvutils.ml @@ -20,7 +20,8 @@ open Reductionops (*s printing of constr -- debugging *) -let msg x = () ;; let prterm c = str "" (* comment this to see debug msgs *) +(* comment this line to see debug msgs *) +let msg x = () ;; let prterm c = str "" (* uncomment this to see debugging *) let prconstr c = msg (str" " ++ prterm c ++ str"\n") let prlistconstr lc = List.iter prconstr lc @@ -67,6 +68,10 @@ let rec mkevarmap_from_listex lex = match lex with | [] -> Evd.empty | ((ex,_),typ)::lex' -> +(* let _ = prstr "mkevarmap" in + let _ = prstr ("evar n. " ^ string_of_int ex ^ " ") in + let _ = prstr "OF TYPE: " in + let _ = prconstr typ in*) let info ={ evar_concl = typ; evar_hyps = empty_named_context; diff --git a/contrib/interface/xlate.ml b/contrib/interface/xlate.ml index ed51b9cb..50f5b947 100644 --- a/contrib/interface/xlate.ml +++ b/contrib/interface/xlate.ml @@ -884,7 +884,7 @@ and xlate_tac = | _ -> assert false) | _ -> assert false) | TacExtend (_, "refine", [c]) -> - CT_refine (xlate_formula (out_gen rawwit_casted_open_constr c)) + CT_refine (xlate_formula (snd (out_gen rawwit_casted_open_constr c))) | TacExtend (_,"absurd",[c]) -> CT_absurd (xlate_formula (out_gen rawwit_constr c)) | TacExtend (_,"contradiction",[opt_c]) -> @@ -1230,11 +1230,16 @@ and coerce_genarg_to_TARG x = | TacticArgType -> let t = xlate_tactic (out_gen rawwit_tactic x) in CT_coerce_TACTIC_COM_to_TARG t + | OpenConstrArgType -> + CT_coerce_SCOMMENT_CONTENT_to_TARG + (CT_coerce_FORMULA_to_SCOMMENT_CONTENT(xlate_formula + (snd (out_gen + rawwit_open_constr x)))) | CastedOpenConstrArgType -> CT_coerce_SCOMMENT_CONTENT_to_TARG (CT_coerce_FORMULA_to_SCOMMENT_CONTENT(xlate_formula - (out_gen - rawwit_casted_open_constr x))) + (snd (out_gen + rawwit_casted_open_constr x)))) | ConstrWithBindingsArgType -> xlate_error "TODO: generic constr with bindings" | BindingsArgType -> xlate_error "TODO: generic with bindings" | RedExprArgType -> xlate_error "TODO: generic red expr" @@ -1324,6 +1329,7 @@ let coerce_genarg_to_VARG x = | TacticArgType -> let t = xlate_tactic (out_gen rawwit_tactic x) in CT_coerce_TACTIC_OPT_to_VARG (CT_coerce_TACTIC_COM_to_TACTIC_OPT t) + | OpenConstrArgType -> xlate_error "TODO: generic open constr" | CastedOpenConstrArgType -> xlate_error "TODO: generic open constr" | ConstrWithBindingsArgType -> xlate_error "TODO: generic constr with bindings" | BindingsArgType -> xlate_error "TODO: generic with bindings" diff --git a/dev/top_printers.ml b/dev/top_printers.ml index 7f92d64c..1e314929 100644 --- a/dev/top_printers.ml +++ b/dev/top_printers.ml @@ -25,6 +25,8 @@ open Term open Termops open Clenv open Cerrors +open Constrextern +open Constrintern let _ = Constrextern.print_evar_arguments := true @@ -233,7 +235,7 @@ let print_pure_constr csr = print_cut(); open_vbox 0; let rec print_fix () = - for k = 0 to Array.length tl do + for k = 0 to Array.length tl - 1 do open_vbox 0; name_display lna.(k); print_string "/"; print_int t.(k); print_cut(); print_string ":"; @@ -247,7 +249,7 @@ let print_pure_constr csr = print_cut(); open_vbox 0; let rec print_fix () = - for k = 0 to Array.length tl do + for k = 0 to Array.length tl - 1 do open_vbox 1; name_display lna.(k); print_cut(); print_string ":"; box_display tl.(k) ; print_cut(); print_string ":="; diff --git a/ide/command_windows.mli b/ide/command_windows.mli index 014be777..6028c818 100644 --- a/ide/command_windows.mli +++ b/ide/command_windows.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: command_windows.mli,v 1.1.2.1 2004/07/16 19:30:19 herbelin Exp $ *) +(*i $Id: command_windows.mli,v 1.1.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) class command_window : unit -> diff --git a/ide/coq.mli b/ide/coq.mli index bcebd4e6..c1dfd847 100644 --- a/ide/coq.mli +++ b/ide/coq.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coq.mli,v 1.14.2.2 2004/07/18 11:20:15 herbelin Exp $ *) +(*i $Id: coq.mli,v 1.14.2.3 2005/01/21 17:21:33 herbelin Exp $ i*) open Names open Term diff --git a/ide/coq_tactics.mli b/ide/coq_tactics.mli index 8d603346..962b4d27 100644 --- a/ide/coq_tactics.mli +++ b/ide/coq_tactics.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coq_tactics.mli,v 1.1.2.1 2004/07/16 19:30:20 herbelin Exp $ *) +(*i $Id: coq_tactics.mli,v 1.1.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) val tactics : string list diff --git a/ide/coqide.ml b/ide/coqide.ml index 2169862e..08994010 100644 --- a/ide/coqide.ml +++ b/ide/coqide.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coqide.ml,v 1.99.2.2 2004/07/18 11:20:15 herbelin Exp $ *) +(* $Id: coqide.ml,v 1.99.2.3 2004/10/15 14:50:12 coq Exp $ *) open Preferences open Vernacexpr @@ -1030,6 +1030,7 @@ object(self) end_iter#nocopy#set_offset (start#offset + !Find_phrase.length); Some (start,end_iter) with +(* | Find_phrase.EOF s -> (* Phrase is at the end of the buffer*) let si = start#offset in @@ -1038,6 +1039,7 @@ object(self) input_buffer#insert ~iter:end_iter "\n"; Some (input_buffer#get_iter (`OFFSET si), input_buffer#get_iter (`OFFSET ei)) +*) | _ -> None method complete_at_offset (offset:int) = diff --git a/ide/coqide.mli b/ide/coqide.mli index 15e28fea..553426f1 100644 --- a/ide/coqide.mli +++ b/ide/coqide.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coqide.mli,v 1.1.2.1 2004/07/16 19:30:20 herbelin Exp $ *) +(*i $Id: coqide.mli,v 1.1.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) (* The CoqIde main module. The following function [start] will parse the command line, initialize the load path, load the input diff --git a/ide/find_phrase.mll b/ide/find_phrase.mll index 8081474f..7b65bd94 100644 --- a/ide/find_phrase.mll +++ b/ide/find_phrase.mll @@ -6,13 +6,12 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: find_phrase.mll,v 1.8.2.1 2004/07/16 19:30:20 herbelin Exp $ *) +(* $Id: find_phrase.mll,v 1.8.2.2 2004/10/15 14:50:13 coq Exp $ *) { exception Lex_error of string let length = ref 0 let buff = Buffer.create 513 - exception EOF of string } @@ -34,10 +33,13 @@ rule next_phrase = parse Buffer.contents buff} | phrase_sep eof{ + length := !length + 1; + Buffer.add_string buff (Lexing.lexeme lexbuf); + Buffer.contents buff} + | phrase_sep phrase_sep { length := !length + 2; Buffer.add_string buff (Lexing.lexeme lexbuf); - Buffer.add_char buff '\n'; - raise (EOF(Buffer.contents buff))} + next_phrase lexbuf} | _ { let c = Lexing.lexeme_char lexbuf 0 in diff --git a/ide/highlight.mll b/ide/highlight.mll index 21063459..e2a1d0cd 100644 --- a/ide/highlight.mll +++ b/ide/highlight.mll @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: highlight.mll,v 1.14.2.1 2004/07/16 19:30:20 herbelin Exp $ *) +(* $Id: highlight.mll,v 1.14.2.2 2004/11/27 14:41:43 herbelin Exp $ *) { @@ -29,18 +29,21 @@ let identchar = let ident = firstchar identchar* let keyword = - "Add" | "CoInductive" | "Defined" | + "Add" | "Defined" | "End" | "Export" | "Extraction" | "Hint" | "Implicits" | "Import" | "Infix" | "Load" | "match" | "Module" | "Module Type" | "Proof" | "Qed" | - "Record" | "Require" | "Save" | "Scheme" | + "Require" | "Save" | "Scheme" | "Section" | "Unset" | "Set" let declaration = "Lemma" | "Axiom" | "CoFixpoint" | "Definition" | "Fixpoint" | "Hypothesis" | + "Hypotheses" | "Axioms" | "Parameters" | "Subclass" | + "Remark" | "Fact" | "Conjecture" | "Let" | + "CoInductive" | "Record" | "Structure" | "Inductive" | "Parameter" | "Theorem" | "Variable" | "Variables" diff --git a/ide/ideutils.mli b/ide/ideutils.mli index 7c225e0e..d91faff4 100644 --- a/ide/ideutils.mli +++ b/ide/ideutils.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ideutils.mli,v 1.6.2.1 2004/07/16 19:30:20 herbelin Exp $ *) +(*i $Id: ideutils.mli,v 1.6.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) val async : ('a -> unit) -> 'a -> unit val browse : (string -> unit) -> string -> unit diff --git a/ide/preferences.mli b/ide/preferences.mli index b4be283d..048707a3 100644 --- a/ide/preferences.mli +++ b/ide/preferences.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: preferences.mli,v 1.8.2.1 2004/07/16 19:30:21 herbelin Exp $ *) +(*i $Id: preferences.mli,v 1.8.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) type pref = { diff --git a/ide/undo.mli b/ide/undo.mli index 6c7492ab..11613fdb 100644 --- a/ide/undo.mli +++ b/ide/undo.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: undo.mli,v 1.4.2.1 2004/07/16 19:30:21 herbelin Exp $ *) +(*i $Id: undo.mli,v 1.4.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) (* An undoable view class *) diff --git a/interp/constrextern.mli b/interp/constrextern.mli index ad1c4391..0dcdffeb 100644 --- a/interp/constrextern.mli +++ b/interp/constrextern.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: constrextern.mli,v 1.11.2.2 2004/07/16 20:51:12 herbelin Exp $ *) +(*i $Id: constrextern.mli,v 1.11.2.3 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Util diff --git a/interp/constrintern.ml b/interp/constrintern.ml index e1b916e1..222ea23b 100644 --- a/interp/constrintern.ml +++ b/interp/constrintern.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: constrintern.ml,v 1.58.2.2 2004/07/16 20:51:12 herbelin Exp $ *) +(* $Id: constrintern.ml,v 1.58.2.6 2004/11/22 14:21:23 herbelin Exp $ *) open Pp open Util @@ -154,8 +154,10 @@ let add_glob loc ref = i*) let sp = Nametab.sp_of_global ref in let id = let _,id = repr_path sp in string_of_id id in - let dp = string_of_dirpath (Lib.library_part ref) in - dump_string (Printf.sprintf "R%d %s.%s\n" (fst (unloc loc)) dp id) + let dir = Lib.file_part ref in + if dir <> None then + let dp = string_of_dirpath (out_some dir) in + dump_string (Printf.sprintf "R%d %s.%s\n" (fst (unloc loc)) dp id) let loc_of_notation f loc args ntn = if args=[] or ntn.[0] <> '_' then fst (unloc loc) @@ -630,6 +632,10 @@ let check_projection isproj nargs r = | _, Some _ -> user_err_loc (loc_of_rawconstr r, "", str "Not a projection") | _, None -> () +let get_implicit_name n imps = + if !Options.v7 then None + else Some (Impargs.name_of_implicit (List.nth imps (n-1))) + let set_hole_implicit i = function | RRef (loc,r) -> (loc,ImplicitArg (r,i)) | RVar (loc,id) -> (loc,ImplicitArg (VarRef id,i)) @@ -680,8 +686,14 @@ let coerce_to_id = function str"This expression should be a simple identifier") let traverse_binder subst id (ids,tmpsc,scopes as env) = - let id = try coerce_to_id (fst (List.assoc id subst)) with Not_found -> id in - id,(Idset.add id ids,tmpsc,scopes) + try + (* Binders bound in the notation are consider first-order object *) + (* and binders not bound in the notation do not capture variables *) + (* outside the notation *) + let id' = coerce_to_id (fst (List.assoc id subst)) in + id', (Idset.add id' ids,tmpsc,scopes) + with Not_found -> + id, env let decode_constrlist_value = function | CAppExpl (_,_,l) -> l @@ -895,7 +907,9 @@ let internalise sigma env allow_soapp lvar c = and intern_local_binder ((ids,ts,sc as env),bl) = function LocalRawAssum(nal,ty) -> - let ty = intern_type env ty in + let (loc,na) = List.hd nal in + (* TODO: fail if several names with different implicit types *) + let ty = locate_if_isevar loc na (intern_type env ty) in List.fold_left (fun ((ids,ts,sc),bl) (_,na) -> ((name_fold Idset.add na ids,ts,sc), (na,None,ty)::bl)) @@ -980,7 +994,7 @@ let internalise sigma env allow_soapp lvar c = (* with implicit arguments *) [] else - RHole (set_hole_implicit n c) :: + RHole (set_hole_implicit (n,get_implicit_name n l) c) :: aux (n+1) impl' subscopes' eargs rargs end | (imp::impl', a::rargs') -> diff --git a/interp/constrintern.mli b/interp/constrintern.mli index a65ab6a7..06039da7 100644 --- a/interp/constrintern.mli +++ b/interp/constrintern.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: constrintern.mli,v 1.15.2.1 2004/07/16 19:30:22 herbelin Exp $ *) +(*i $Id: constrintern.mli,v 1.15.2.2 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Names @@ -64,7 +64,7 @@ val interp_casted_openconstr : (* [interp_type_with_implicits] extends [interp_type] by allowing implicits arguments in the ``rel'' part of [env]; the extra argument associates a list of implicit positions to identifiers - declared in the rel_context of [env] *) + declared in the [rel_context] of [env] *) val interp_type_with_implicits : evar_map -> env -> full_implicits_env -> constr_expr -> types diff --git a/interp/coqlib.mli b/interp/coqlib.mli index 7ac2a5c9..3b377f29 100644 --- a/interp/coqlib.mli +++ b/interp/coqlib.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coqlib.mli,v 1.5.2.1 2004/07/16 19:30:22 herbelin Exp $ *) +(*i $Id: coqlib.mli,v 1.5.2.3 2005/01/21 17:14:10 herbelin Exp $ i*) (*i*) open Names @@ -80,7 +80,7 @@ val build_coq_eq_data : coq_leibniz_eq_data delayed val build_coq_eqT_data : coq_leibniz_eq_data delayed val build_coq_idT_data : coq_leibniz_eq_data delayed -val build_coq_eq : constr delayed (* = (build_coq_eq_data()).eq *) +val build_coq_eq : constr delayed (* = [(build_coq_eq_data()).eq] *) val build_coq_f_equal2 : constr delayed val build_coq_eqT : constr delayed val build_coq_sym_eqT : constr delayed diff --git a/interp/doc.tex b/interp/doc.tex index 4d60ec34..5bd92fbd 100644 --- a/interp/doc.tex +++ b/interp/doc.tex @@ -2,13 +2,13 @@ \newpage \section*{The interpretation of Coq front abstract syntax of terms} -\ocwsection \label{library} +\ocwsection \label{interp} This chapter describes the translation from \Coq\ context-dependent -front abstract syntax of terms (\verb=front=} to and from the +front abstract syntax of terms (\verb=front=) to and from the context-free, untyped, raw form of constructions (\verb=rawconstr=). The modules translating back and forth the front abstract syntax are organized as follows. \bigskip -\begin{center}\epsfig{file=library.dep.ps}\end{center} +\begin{center}\epsfig{file=interp.dep.ps}\end{center} diff --git a/interp/genarg.ml b/interp/genarg.ml index af3d805a..7facebcc 100644 --- a/interp/genarg.ml +++ b/interp/genarg.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: genarg.ml,v 1.9.2.1 2004/07/16 19:30:22 herbelin Exp $ *) +(* $Id: genarg.ml,v 1.9.2.2 2005/01/15 14:56:54 herbelin Exp $ *) open Pp open Util @@ -34,6 +34,7 @@ type argument_type = | ConstrMayEvalArgType | QuantHypArgType | TacticArgType + | OpenConstrArgType | CastedOpenConstrArgType | ConstrWithBindingsArgType | BindingsArgType @@ -85,8 +86,8 @@ and pr_case_intro_pattern = function ++ str "]" type open_constr = Evd.evar_map * Term.constr -type open_constr_expr = constr_expr -type open_rawconstr = rawconstr_and_expr +type open_constr_expr = unit * constr_expr +type open_rawconstr = unit * rawconstr_and_expr let rawwit_bool = BoolArgType let globwit_bool = BoolArgType @@ -144,6 +145,10 @@ let rawwit_tactic = TacticArgType let globwit_tactic = TacticArgType let wit_tactic = TacticArgType +let rawwit_open_constr = OpenConstrArgType +let globwit_open_constr = OpenConstrArgType +let wit_open_constr = OpenConstrArgType + let rawwit_casted_open_constr = CastedOpenConstrArgType let globwit_casted_open_constr = CastedOpenConstrArgType let wit_casted_open_constr = CastedOpenConstrArgType diff --git a/interp/genarg.mli b/interp/genarg.mli index 59b6e10d..967d5050 100644 --- a/interp/genarg.mli +++ b/interp/genarg.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: genarg.mli,v 1.9.2.1 2004/07/16 19:30:22 herbelin Exp $ *) +(*i $Id: genarg.mli,v 1.9.2.4 2005/01/21 17:14:10 herbelin Exp $ i*) open Util open Names @@ -19,14 +19,14 @@ open Term type 'a or_var = ArgArg of 'a | ArgVar of identifier located type 'a and_short_name = 'a * identifier located option -(* In globalize tactics, we need to keep the initial constr_expr to recompute*) +(* In globalize tactics, we need to keep the initial [constr_expr] to recompute*) (* in the environment by the effective calls to Intro, Inversion, etc *) -(* The constr_expr field is None in TacDef though *) +(* The [constr_expr] field is [None] in TacDef though *) type rawconstr_and_expr = rawconstr * constr_expr option type open_constr = Evd.evar_map * Term.constr -type open_constr_expr = constr_expr -type open_rawconstr = rawconstr_and_expr +type open_constr_expr = unit * constr_expr +type open_rawconstr = unit * rawconstr_and_expr type intro_pattern_expr = | IntroOrAndPattern of case_intro_pattern_expr @@ -39,6 +39,7 @@ val pr_case_intro_pattern : case_intro_pattern_expr -> Pp.std_ppcmds (* The route of a generic argument, from parsing to evaluation +\begin{verbatim} parsing in_raw out_raw char stream ----> rawtype ----> rawconstr generic_argument ----> | @@ -46,16 +47,18 @@ val pr_case_intro_pattern : case_intro_pattern_expr -> Pp.std_ppcmds V type <---- constr generic_argument <---- out in +\end{verbatim} To distinguish between the uninterpreted (raw) and the interpreted -worlds, we annotate the type generic_argument by a phantom argument -which is either constr_expr or constr (actually we add also a second -argument raw_tactic_expr and tactic, but this is only for technical +worlds, we annotate the type [generic_argument] by a phantom argument +which is either [constr_expr] or [constr] (actually we add also a second +argument [raw_tactic_expr] and [tactic], but this is only for technical reasons, because these types are undefined at the type of compilation -of Genarg). +of [Genarg]). Transformation for each type : -tag f raw open type cooked closed type +\begin{verbatim} +tag raw open type cooked closed type BoolArgType bool bool IntArgType int int @@ -70,12 +73,13 @@ ConstrArgType constr_expr constr ConstrMayEvalArgType constr_expr may_eval constr QuantHypArgType quantified_hypothesis quantified_hypothesis TacticArgType raw_tactic_expr tactic -CastedOpenConstrArgType constr_expr open_constr +OpenConstrArgType constr_expr open_constr ConstrBindingsArgType constr_expr with_bindings constr with_bindings List0ArgType of argument_type List1ArgType of argument_type OptArgType of argument_type ExtraArgType of string '_a '_b +\end{verbatim} *) type ('a,'co,'ta) abstract_argument_type @@ -132,6 +136,10 @@ val rawwit_constr_may_eval : ((constr_expr,reference) may_eval,constr_expr,'ta) val globwit_constr_may_eval : ((rawconstr_and_expr,evaluable_global_reference and_short_name or_var) may_eval,rawconstr_and_expr,'ta) abstract_argument_type val wit_constr_may_eval : (constr,constr,'ta) abstract_argument_type +val rawwit_open_constr : (open_constr_expr,constr_expr,'ta) abstract_argument_type +val globwit_open_constr : (open_rawconstr,rawconstr_and_expr,'ta) abstract_argument_type +val wit_open_constr : (open_constr,constr,'ta) abstract_argument_type + val rawwit_casted_open_constr : (open_constr_expr,constr_expr,'ta) abstract_argument_type val globwit_casted_open_constr : (open_rawconstr,rawconstr_and_expr,'ta) abstract_argument_type val wit_casted_open_constr : (open_constr,constr,'ta) abstract_argument_type @@ -167,7 +175,7 @@ val wit_pair : ('b,'co,'ta) abstract_argument_type -> ('a * 'b,'co,'ta) abstract_argument_type -(* 'a generic_argument = (Sigma t:type. t[constr/'a]) *) +(* ['a generic_argument] = (Sigma t:type. t[[constr/'a]]) *) type ('a,'b) generic_argument val fold_list0 : @@ -227,6 +235,7 @@ type argument_type = | ConstrMayEvalArgType | QuantHypArgType | TacticArgType + | OpenConstrArgType | CastedOpenConstrArgType | ConstrWithBindingsArgType | BindingsArgType @@ -247,7 +256,7 @@ val unquote : ('a,'co,'ta) abstract_argument_type -> argument_type with f a = b if a is Constr, f a = c if a is Tactic, otherwise f a = |a| - in_generic is not typable; we replace the second argument by an absurd + [in_generic] is not typable; we replace the second argument by an absurd type (with no introduction rule) *) type an_arg_of_this_type diff --git a/interp/ppextend.mli b/interp/ppextend.mli index 056b7a42..bc0a83ec 100644 --- a/interp/ppextend.mli +++ b/interp/ppextend.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: ppextend.mli,v 1.4.2.1 2004/07/16 19:30:22 herbelin Exp $ *) +(*i $Id: ppextend.mli,v 1.4.2.2 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Pp diff --git a/interp/symbols.ml b/interp/symbols.ml index ed151d8e..d1abb084 100644 --- a/interp/symbols.ml +++ b/interp/symbols.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: symbols.ml,v 1.31.2.1 2004/07/16 19:30:23 herbelin Exp $ *) +(* $Id: symbols.ml,v 1.31.2.2 2004/11/17 09:33:38 herbelin Exp $ *) (*i*) open Util @@ -270,7 +270,7 @@ let declare_notation_interpretation ntn scopt pat df pp8only = let scope = match scopt with Some s -> s | None -> default_scope in let sc = find_scope scope in if Stringmap.mem ntn sc.notations && Options.is_verbose () then - warning ("Notation "^ntn^" is already used"^ + warning ("Notation "^ntn^" was already used"^ (if scopt = None then "" else " in scope "^scope)); let sc = { sc with notations = Stringmap.add ntn (pat,df,pp8only) sc.notations } in scope_map := Stringmap.add scope sc !scope_map; diff --git a/interp/symbols.mli b/interp/symbols.mli index 00d8e5ff..5401ae77 100644 --- a/interp/symbols.mli +++ b/interp/symbols.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: symbols.mli,v 1.22.2.1 2004/07/16 19:30:23 herbelin Exp $ *) +(*i $Id: symbols.mli,v 1.22.2.3 2005/01/21 17:14:10 herbelin Exp $ i*) (*i*) open Util @@ -30,7 +30,7 @@ open Ppextend type level = precedence * tolerability list type delimiters = string type scope -type scopes (* = scope_name list*) +type scopes (* = [scope_name list] *) val type_scope : scope_name val declare_scope : scope_name -> unit @@ -52,7 +52,7 @@ val find_delimiters_scope : loc -> delimiters -> scope_name (*s Declare and uses back and forth a numeral interpretation *) -(* A numeral interpreter is the pair of an interpreter for _integer_ +(* A numeral interpreter is the pair of an interpreter for **integer** numbers in terms and an optional interpreter in pattern, if negative numbers are not supported, the interpreter must fail with an appropriate error message *) @@ -69,12 +69,12 @@ type required_module = global_reference * string list val declare_numeral_interpreter : scope_name -> required_module -> num_interpreter -> num_uninterpreter -> unit -(* Returns the term/cases_pattern bound to a numeral in a given scope context*) +(* Return the [term]/[cases_pattern] bound to a numeral in a given scope context*) val interp_numeral : loc -> bigint -> scope_name list -> rawconstr val interp_numeral_as_pattern : loc -> bigint -> name -> scope_name list -> cases_pattern -(* Returns the numeral bound to a term/cases_pattern; raises No_match if no *) +(* Return the numeral bound to a [term]/[cases_pattern]; raise [No_match] if no *) (* such numeral *) val uninterp_numeral : rawconstr -> scope_name * bigint val uninterp_cases_numeral : cases_pattern -> scope_name * bigint @@ -92,11 +92,11 @@ val declare_notation_interpretation : notation -> scope_name option -> val declare_uninterpretation : interp_rule -> interpretation -> unit -(* Returns the interpretation bound to a notation *) +(* Return the interpretation bound to a notation *) val interp_notation : loc -> notation -> scope_name list -> interpretation * ((dir_path * string) * scope_name option) -(* Returns the possible notations for a given term *) +(* Return the possible notations for a given term *) val uninterp_notations : rawconstr -> (interp_rule * interpretation * int option) list val uninterp_cases_pattern_notations : cases_pattern -> diff --git a/interp/topconstr.ml b/interp/topconstr.ml index 3ee3285b..a2b6e8b7 100644 --- a/interp/topconstr.ml +++ b/interp/topconstr.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: topconstr.ml,v 1.35.2.2 2004/07/16 19:30:23 herbelin Exp $ *) +(* $Id: topconstr.ml,v 1.35.2.3 2004/11/17 09:51:41 herbelin Exp $ *) (*i*) open Pp @@ -89,8 +89,11 @@ let rawconstr_of_aconstr_with_binders loc g f e = function | AOrderedCase (b,tyopt,tm,bv) -> ROrderedCase (loc,b,option_app (f e) tyopt,f e tm,Array.map (f e) bv,ref None) | ALetTuple (nal,(na,po),b,c) -> + let e,nal = list_fold_map (fun e na -> let (na,e) = name_app g e na in e,na) e nal in + let na,e = name_app g e na in RLetTuple (loc,nal,(na,option_app (f e) po),f e b,f e c) | AIf (c,(na,po),b1,b2) -> + let na,e = name_app g e na in RIf (loc,f e c,(na,option_app (f e) po),f e b1,f e b2) | ACast (c,t) -> RCast (loc,f e c,f e t) | ASort x -> RSort (loc,x) @@ -271,8 +274,11 @@ let aconstr_and_vars_of_rawconstr a = | ROrderedCase (_,b,tyopt,tm,bv,_) -> AOrderedCase (b,option_app aux tyopt,aux tm, Array.map aux bv) | RLetTuple (loc,nal,(na,po),b,c) -> + add_name bound_binders na; + List.iter (add_name bound_binders) nal; ALetTuple (nal,(na,option_app aux po),aux b,aux c) | RIf (loc,c,(na,po),b1,b2) -> + add_name bound_binders na; AIf (aux c,(na,option_app aux po),aux b1,aux b2) | RCast (_,c,t) -> ACast (aux c,aux t) | RSort (_,s) -> ASort s @@ -349,17 +355,19 @@ let rec alpha_var id1 id2 = function let alpha_eq_val (x,y) = x = y -let bind_env sigma var v = +let bind_env alp sigma var v = try let vvar = List.assoc var sigma in if alpha_eq_val (v,vvar) then sigma else raise No_match with Not_found -> + (* Check that no capture of binding variables occur *) + if List.exists (fun (id,_) ->occur_rawconstr id v) alp then raise No_match; (* TODO: handle the case of multiple occs in different scopes *) (var,v)::sigma let rec match_ alp metas sigma a1 a2 = match (a1,a2) with - | r1, AVar id2 when List.mem id2 metas -> bind_env sigma id2 r1 + | r1, AVar id2 when List.mem id2 metas -> bind_env alp sigma id2 r1 | RVar (_,id1), AVar id2 when alpha_var id1 id2 alp -> sigma | RRef (_,r1), ARef r2 when r1 = r2 -> sigma | RPatVar (_,(_,n1)), APatVar n2 when n1=n2 -> sigma @@ -417,7 +425,7 @@ and match_alist alp metas sigma l1 l2 x iter termin lassoc = and match_binders alp metas sigma b1 b2 na1 na2 = match (na1,na2) with | (Name id1,Name id2) when List.mem id2 metas -> - let sigma = bind_env sigma id2 (RVar (dummy_loc,id1)) in + let sigma = bind_env alp sigma id2 (RVar (dummy_loc,id1)) in match_ alp metas sigma b1 b2 | (Name id1,Name id2) -> match_ ((id1,id2)::alp) metas sigma b1 b2 | (Anonymous,Anonymous) -> match_ alp metas sigma b1 b2 diff --git a/interp/topconstr.mli b/interp/topconstr.mli index f4a82a3a..54547352 100644 --- a/interp/topconstr.mli +++ b/interp/topconstr.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: topconstr.mli,v 1.23.2.1 2004/07/16 19:30:23 herbelin Exp $ *) +(*i $Id: topconstr.mli,v 1.23.2.3 2005/01/21 17:14:10 herbelin Exp $ i*) (*i*) open Pp @@ -23,12 +23,12 @@ open Term (* non global expressions such as existential variables also *) type aconstr = - (* Part common to rawconstr and cases_pattern *) + (* Part common to [rawconstr] and [cases_pattern] *) | ARef of global_reference | AVar of identifier | AApp of aconstr * aconstr list | AList of identifier * identifier * aconstr * aconstr * bool - (* Part only in rawconstr *) + (* Part only in [rawconstr] *) | ALambda of name * aconstr * aconstr | AProd of name * aconstr * aconstr | ALetIn of name * aconstr * aconstr @@ -59,7 +59,7 @@ type scope_name = string type interpretation = (identifier * (scope_name option * scope_name list)) list * aconstr -val match_aconstr : (* scope_name option -> *) rawconstr -> interpretation -> +val match_aconstr : (*i scope_name option -> i*) rawconstr -> interpretation -> (rawconstr * (scope_name option * scope_name list)) list (*s Concrete syntax for terms *) diff --git a/kernel/conv_oracle.mli b/kernel/conv_oracle.mli index 77de9b8a..8d0c12bb 100644 --- a/kernel/conv_oracle.mli +++ b/kernel/conv_oracle.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: conv_oracle.mli,v 1.3.8.2 2004/07/16 19:30:24 herbelin Exp $ *) +(*i $Id: conv_oracle.mli,v 1.3.8.3 2005/01/21 17:14:10 herbelin Exp $ i*) open Names open Closure diff --git a/kernel/declarations.mli b/kernel/declarations.mli index 3252ddee..c670fe9a 100644 --- a/kernel/declarations.mli +++ b/kernel/declarations.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: declarations.mli,v 1.33.2.1 2004/07/16 19:30:24 herbelin Exp $ i*) +(*i $Id: declarations.mli,v 1.33.2.2 2005/01/21 16:41:49 herbelin Exp $ i*) (*i*) open Names @@ -109,8 +109,8 @@ and module_specification_body = { msb_modtype : module_type_body; msb_equiv : module_path option; msb_constraints : constraints } - (* type_of(equiv) <: modtype (if given) - + substyping of past With_Module mergers *) + (* [type_of](equiv) <: modtype (if given) + + substyping of past [With_Module] mergers *) type structure_elem_body = @@ -126,7 +126,7 @@ and module_expr_body = | MEBfunctor of mod_bound_id * module_type_body * module_expr_body | MEBstruct of mod_self_id * module_structure_body | MEBapply of module_expr_body * module_expr_body (* (F A) *) - * constraints (* type_of(A) <: input_type_of(F) *) + * constraints (* [type_of](A) <: [input_type_of](F) *) and module_body = { mod_expr : module_expr_body option; @@ -134,7 +134,7 @@ and module_body = mod_type : module_type_body; mod_equiv : module_path option; mod_constraints : constraints } - (* type_of(mod_expr) <: mod_user_type (if given) *) + (* [type_of(mod_expr)] <: [mod_user_type] (if given) *) (* if equiv given then constraints are empty *) diff --git a/kernel/environ.mli b/kernel/environ.mli index 4e54761b..a2a66cb7 100644 --- a/kernel/environ.mli +++ b/kernel/environ.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: environ.mli,v 1.66.2.1 2004/07/16 19:30:25 herbelin Exp $ i*) +(*i $Id: environ.mli,v 1.66.2.2 2005/01/21 16:41:49 herbelin Exp $ i*) (*i*) open Names @@ -44,7 +44,7 @@ val engagement : env -> engagement option val empty_context : env -> bool (************************************************************************) -(*s Context of de Bruijn variables (rel_context) *) +(*s Context of de Bruijn variables ([rel_context]) *) val push_rel : rel_declaration -> env -> env val push_rel_context : rel_context -> env -> env val push_rec_types : rec_declaration -> env -> env diff --git a/kernel/esubst.mli b/kernel/esubst.mli index b02d747b..2fe981f7 100644 --- a/kernel/esubst.mli +++ b/kernel/esubst.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: esubst.mli,v 1.3.2.1 2004/07/16 19:30:25 herbelin Exp $ *) +(*i $Id: esubst.mli,v 1.3.2.2 2005/01/21 17:14:10 herbelin Exp $ i*) (*s Compact representation of explicit relocations. \\ [ELSHFT(l,n)] == lift of [n], then apply [lift l]. diff --git a/kernel/inductive.mli b/kernel/inductive.mli index ad44fa64..04345621 100644 --- a/kernel/inductive.mli +++ b/kernel/inductive.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: inductive.mli,v 1.57.8.1 2004/07/16 19:30:25 herbelin Exp $ i*) +(*i $Id: inductive.mli,v 1.57.8.2 2005/01/21 16:41:49 herbelin Exp $ i*) (*i*) open Names @@ -62,7 +62,7 @@ val type_case_branches : given inductive type. *) val check_case_info : env -> inductive -> case_info -> unit -(* Find the ultimate inductive in the mind_equiv chain *) +(* Find the ultimate inductive in the [mind_equiv] chain *) val scrape_mind : env -> mutual_inductive -> mutual_inductive diff --git a/kernel/mod_typing.mli b/kernel/mod_typing.mli index 0ea98bf0..fdf39c56 100644 --- a/kernel/mod_typing.mli +++ b/kernel/mod_typing.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: mod_typing.mli,v 1.2.8.1 2004/07/16 19:30:26 herbelin Exp $ *) +(*i $Id: mod_typing.mli,v 1.2.8.2 2005/01/21 17:14:10 herbelin Exp $ i*) (*i*) open Declarations diff --git a/kernel/modops.mli b/kernel/modops.mli index 5433fa3e..cca2d315 100644 --- a/kernel/modops.mli +++ b/kernel/modops.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: modops.mli,v 1.7.6.1 2004/07/16 19:30:26 herbelin Exp $ i*) +(*i $Id: modops.mli,v 1.7.6.2 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Util @@ -41,7 +41,7 @@ val subst_signature_msid : module_signature_body -> module_signature_body (* [add_signature mp sign env] assumes that the substitution [msid] - \mapsto [mp] has already been performed (or is not necessary, like + $\mapsto$ [mp] has already been performed (or is not necessary, like when [mp = MPself msid]) *) val add_signature : module_path -> module_signature_body -> env -> env diff --git a/lib/bignat.mli b/lib/bignat.mli index f08ccc39..860bcf29 100644 --- a/lib/bignat.mli +++ b/lib/bignat.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: bignat.mli,v 1.4.6.1 2004/07/16 19:30:29 herbelin Exp $ *) +(*i $Id: bignat.mli,v 1.4.6.3 2005/01/21 17:14:11 herbelin Exp $ i*) (*i*) open Pp @@ -26,7 +26,7 @@ val is_one : bignat -> bool val div2_with_rest : bignat -> bignat * bool (* true=odd; false=even *) val add_1 : bignat -> bignat -val sub_1 : bignat -> bignat (* Remark: (sub_1 0)=0 *) +val sub_1 : bignat -> bignat (* Remark: [sub_1 0]=0 *) val mult_2 : bignat -> bignat val less_than : bignat -> bignat -> bool diff --git a/lib/compat.ml4 b/lib/compat.ml4 index 5e1c65b4..0947f5fb 100644 --- a/lib/compat.ml4 +++ b/lib/compat.ml4 @@ -11,19 +11,24 @@ (* IFDEF not available in 3.06; use ifdef instead *) (* type loc is different in 3.08 *) -ifdef OCAML308 then +ifdef OCAML_308 then module M = struct type loc = Token.flocation let dummy_loc = Token.dummy_loc -let unloc (b,e) = (b.Lexing.pos_cnum,e.Lexing.pos_cnum) let make_loc loc = Token.make_loc loc +let unloc (b,e) = + let loc = (b.Lexing.pos_cnum,e.Lexing.pos_cnum) in + (* Ensure that we unpack a char location that was encoded as a line-col + location by make_loc *) + assert (dummy_loc = (b,e) or make_loc loc = (b,e)); + loc end else module M = struct type loc = int * int let dummy_loc = (0,0) -let unloc x = x let make_loc x = x +let unloc x = x end type loc = M.loc diff --git a/lib/heap.mli b/lib/heap.mli index c865461e..46e72728 100644 --- a/lib/heap.mli +++ b/lib/heap.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: heap.mli,v 1.1.2.1 2004/07/16 19:30:30 herbelin Exp $ *) +(*i $Id: heap.mli,v 1.1.2.2 2005/01/21 17:14:11 herbelin Exp $ i*) (* Heaps *) diff --git a/lib/predicate.mli b/lib/predicate.mli index 160fa648..2dc7d85c 100644 --- a/lib/predicate.mli +++ b/lib/predicate.mli @@ -1,5 +1,5 @@ -(* $Id: predicate.mli,v 1.1 2001/09/20 18:10:43 barras Exp $ *) +(*i $Id: predicate.mli,v 1.1.14.1 2005/01/21 17:14:11 herbelin Exp $ i*) (* Module [Pred]: sets over infinite ordered types with complement. *) diff --git a/lib/profile.mli b/lib/profile.mli index e0488de3..e8ce8994 100644 --- a/lib/profile.mli +++ b/lib/profile.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: profile.mli,v 1.7.16.1 2004/07/16 19:30:31 herbelin Exp $ *) +(*i $Id: profile.mli,v 1.7.16.2 2005/01/21 17:14:11 herbelin Exp $ i*) (*s This program is a small time and allocation profiler for Objective Caml *) diff --git a/lib/rtree.mli b/lib/rtree.mli index 0f854bc0..79b57586 100644 --- a/lib/rtree.mli +++ b/lib/rtree.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: rtree.mli,v 1.2.8.1 2004/07/16 19:30:31 herbelin Exp $ i*) +(*i $Id: rtree.mli,v 1.2.8.2 2005/01/21 16:41:52 herbelin Exp $ i*) (* Type of regular tree with nodes labelled by values of type 'a *) type 'a t @@ -20,7 +20,7 @@ val mk_node : 'a -> 'a t array -> 'a t val mk_rec : 'a t array -> 'a t array (* [lift k t] increases of [k] the free parameters of [t]. Needed - to avoid captures when a tree appears under mk_rec *) + to avoid captures when a tree appears under [mk_rec] *) val lift : int -> 'a t -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t diff --git a/lib/util.ml b/lib/util.ml index 37568f9b..b5470e58 100644 --- a/lib/util.ml +++ b/lib/util.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: util.ml,v 1.84.2.2 2004/07/16 20:43:46 herbelin Exp $ *) +(* $Id: util.ml,v 1.84.2.3 2004/07/29 15:00:04 herbelin Exp $ *) open Pp @@ -32,7 +32,8 @@ type 'a located = loc * 'a let anomaly_loc (loc,s,strm) = Stdpp.raise_with_loc loc (Anomaly (s,strm)) let user_err_loc (loc,s,strm) = Stdpp.raise_with_loc loc (UserError (s,strm)) let invalid_arg_loc (loc,s) = Stdpp.raise_with_loc loc (Invalid_argument s) -let join_loc (deb1,_) (_,fin2) = (deb1,fin2) +let join_loc (deb1,_ as loc1) (_,fin2 as loc2) = + if loc1 = dummy_loc or loc2 = dummy_loc then dummy_loc else (deb1,fin2) (* Like Exc_located, but specifies the outermost file read, the filename associated to the location of the error, and the error itself. *) diff --git a/library/declaremods.mli b/library/declaremods.mli index f229da1e..f896310a 100644 --- a/library/declaremods.mli +++ b/library/declaremods.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: declaremods.mli,v 1.8.2.1 2004/07/16 19:30:35 herbelin Exp $ i*) +(*i $Id: declaremods.mli,v 1.8.2.2 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Util @@ -85,7 +85,7 @@ val end_library : (* [really_import_module mp] opens the module [mp] (in a Caml sense). - It modifies Nametab and performs the "open_object" function for + It modifies Nametab and performs the [open_object] function for every object of the module. *) val really_import_module : module_path -> unit @@ -109,7 +109,7 @@ val iter_all_segments : bool -> (object_name -> obj -> unit) -> unit val debug_print_modtab : unit -> Pp.std_ppcmds -(*val debug_print_modtypetab : unit -> Pp.std_ppcmds*) +(*i val debug_print_modtypetab : unit -> Pp.std_ppcmds i*) (* For translator *) val process_module_bindings : module_ident list -> diff --git a/library/lib.ml b/library/lib.ml index b9da6dea..a9f864ef 100644 --- a/library/lib.ml +++ b/library/lib.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: lib.ml,v 1.63.2.2 2004/07/16 19:30:35 herbelin Exp $ *) +(* $Id: lib.ml,v 1.63.2.3 2004/11/22 14:21:23 herbelin Exp $ *) open Pp open Util @@ -564,3 +564,15 @@ let library_part ref = else (* Theorem/Lemma outside its outer section of definition *) dir + + +let rec file_of_mp = function + | MPfile dir -> Some dir + | MPself _ -> Some (library_dp ()) + | MPbound _ -> None + | MPdot (mp,_) -> file_of_mp mp + +let file_part = function + | VarRef id -> anomaly "TODO"; + | ConstRef kn | ConstructRef ((kn,_),_) | IndRef (kn,_) -> + file_of_mp (modpath kn) diff --git a/library/lib.mli b/library/lib.mli index 8981754e..aa874470 100644 --- a/library/lib.mli +++ b/library/lib.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: lib.mli,v 1.41.2.1 2004/07/16 19:30:35 herbelin Exp $ i*) +(*i $Id: lib.mli,v 1.41.2.3 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Util @@ -59,7 +59,7 @@ val add_leaf : identifier -> obj -> object_name val add_absolutely_named_leaf : object_name -> obj -> unit val add_anonymous_leaf : obj -> unit -(* this operation adds all objects with the same name and calls load_object +(* this operation adds all objects with the same name and calls [load_object] for each of them *) val add_leaves : identifier -> obj list -> object_name @@ -107,7 +107,7 @@ val start_modtype : module_ident -> module_path -> Summary.frozen -> object_prefix val end_modtype : module_ident -> object_name * object_prefix * Summary.frozen * library_segment -(* Lib.add_frozen_state must be called after each of the above functions *) +(* [Lib.add_frozen_state] must be called after each of the above functions *) (*s Compilation units *) @@ -121,6 +121,9 @@ val library_dp : unit -> dir_path (* Extract the library part of a name even if in a section *) val library_part : global_reference -> dir_path +(* Extract the library part of a name if not in a functor *) +val file_part : global_reference -> dir_path option + (*s Sections *) val open_section : identifier -> object_prefix diff --git a/library/libnames.mli b/library/libnames.mli index 6f05333c..a6055428 100644 --- a/library/libnames.mli +++ b/library/libnames.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: libnames.mli,v 1.8.2.1 2004/07/16 19:30:35 herbelin Exp $ i*) +(*i $Id: libnames.mli,v 1.8.2.2 2005/01/21 16:41:51 herbelin Exp $ i*) (*i*) open Pp @@ -111,8 +111,8 @@ val qualid_of_dirpath : dir_path -> qualid val make_short_qualid : identifier -> qualid -(* Both names are passed to objects: a "semantic" kernel_name, which - can be substituted and a "syntactic" section_path which can be printed +(* Both names are passed to objects: a "semantic" [kernel_name], which + can be substituted and a "syntactic" [section_path] which can be printed *) type object_name = section_path * kernel_name @@ -121,7 +121,7 @@ type object_prefix = dir_path * (module_path * dir_path) val make_oname : object_prefix -> identifier -> object_name -(* to this type are mapped dir_path's in the nametab *) +(* to this type are mapped [dir_path]'s in the nametab *) type global_dir_reference = | DirOpenModule of object_prefix | DirOpenModtype of object_prefix diff --git a/library/libobject.mli b/library/libobject.mli index 8a3811e1..b9070f5d 100644 --- a/library/libobject.mli +++ b/library/libobject.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: libobject.mli,v 1.9.8.1 2004/07/16 19:30:35 herbelin Exp $ i*) +(*i $Id: libobject.mli,v 1.9.8.2 2005/01/21 16:41:51 herbelin Exp $ i*) (*i*) open Names @@ -39,7 +39,7 @@ open Libnames Keep - the object is not substitutive, but survives module closing Anticipate - this is for objects which have to be explicitely - managed by the end_module function (like Require + managed by the [end_module] function (like Require and Read markers) The classification function is also an occasion for a cleanup diff --git a/library/library.ml b/library/library.ml index 0477a8f3..cbc8874a 100644 --- a/library/library.ml +++ b/library/library.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: library.ml,v 1.79.2.1 2004/07/16 19:30:36 herbelin Exp $ *) +(* $Id: library.ml,v 1.79.2.2 2004/11/17 14:01:26 herbelin Exp $ *) open Pp open Util @@ -169,8 +169,10 @@ let _ = Summary.survive_section = false } let find_library s = - try - CompilingLibraryMap.find s !libraries_table + CompilingLibraryMap.find s !libraries_table + +let try_find_library s = + try find_library s with Not_found -> error ("Unknown library " ^ (string_of_dirpath s)) @@ -250,7 +252,7 @@ let open_libraries export modl = (fun l m -> let subimport = List.fold_left - (fun l m -> remember_last_of_each l (find_library m)) + (fun l m -> remember_last_of_each l (try_find_library m)) l m.library_imports in remember_last_of_each subimport m) [] modl in @@ -261,7 +263,7 @@ let open_libraries export modl = (* import and export - synchronous operations*) let cache_import (_,(dir,export)) = - open_libraries export [find_library dir] + open_libraries export [try_find_library dir] let open_import i (_,(dir,_) as obj) = if i=1 then @@ -698,7 +700,7 @@ let check_required_library d = open Printf let mem s = - let m = find_library s in + let m = try_find_library s in h 0 (str (sprintf "%dk (cenv = %dk / seg = %dk)" (size_kb m) (size_kb m.library_compiled) (size_kb m.library_objects))) diff --git a/library/nameops.ml b/library/nameops.ml index ea40aae5..35b707a7 100644 --- a/library/nameops.ml +++ b/library/nameops.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: nameops.ml,v 1.21.2.1 2004/07/16 19:30:36 herbelin Exp $ *) +(* $Id: nameops.ml,v 1.21.2.2 2004/10/12 10:12:31 herbelin Exp $ *) open Pp open Util @@ -29,8 +29,8 @@ let cut_ident skip_quote s = (* [n'] is the position of the first non nullary digit *) let rec numpart n n' = if n = 0 then - error - ("The string " ^ s ^ " is not an identifier: it contains only digits or _") + (* ident made of _ and digits only [and ' if skip_quote]: don't cut it *) + slen else let c = Char.code (String.get s (n-1)) in if c = code_of_0 && n <> slen then diff --git a/library/nameops.mli b/library/nameops.mli index 4b7cecda..71dbf040 100644 --- a/library/nameops.mli +++ b/library/nameops.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: nameops.mli,v 1.12.2.1 2004/07/16 19:30:36 herbelin Exp $ *) +(*i $Id: nameops.mli,v 1.12.2.3 2005/01/21 17:14:10 herbelin Exp $ i*) open Names @@ -18,7 +18,7 @@ val make_ident : string -> int option -> identifier val repr_ident : identifier -> string * int option val atompart_of_id : identifier -> string (* remove trailing digits *) -val root_of_id : identifier -> identifier (* remove trailing digits, ' and _ *) +val root_of_id : identifier -> identifier (* remove trailing digits, $'$ and $\_$ *) val add_suffix : identifier -> string -> identifier val add_prefix : string -> identifier -> identifier diff --git a/library/nametab.mli b/library/nametab.mli index 3a0bd670..08a9d1bb 100755 --- a/library/nametab.mli +++ b/library/nametab.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: nametab.mli,v 1.43.2.1 2004/07/16 19:30:36 herbelin Exp $ i*) +(*i $Id: nametab.mli,v 1.43.2.2 2005/01/21 16:41:51 herbelin Exp $ i*) (*i*) open Util @@ -33,13 +33,14 @@ open Libnames \item [locate : qualid -> object_reference] - Finds the object referred to by [qualid] or raises Not_found + Finds the object referred to by [qualid] or raises [Not_found] - \item [name_of] : object_reference -> user_name + \item [name_of : object_reference -> user_name] The [user_name] can be for example the shortest non ambiguous [qualid] or the [full_user_name] or [identifier]. Such a function can also have a local context argument. + \end{itemize} *) @@ -155,7 +156,7 @@ val id_of_global : global_reference -> identifier val pr_global_env : Idset.t -> global_reference -> std_ppcmds -(* The [shortest_qualid] functions given an object with user_name +(* The [shortest_qualid] functions given an object with [user_name] Coq.A.B.x, try to find the shortest among x, B.x, A.B.x and Coq.A.B.x that denotes the same object. *) diff --git a/parsing/argextend.ml4 b/parsing/argextend.ml4 index 5fa781ad..e6d9f99d 100644 --- a/parsing/argextend.ml4 +++ b/parsing/argextend.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: argextend.ml4,v 1.9.2.2 2004/07/16 19:30:37 herbelin Exp $ *) +(* $Id: argextend.ml4,v 1.9.2.4 2005/01/15 14:56:53 herbelin Exp $ *) open Genarg open Q_util @@ -33,6 +33,7 @@ let rec make_rawwit loc = function | QuantHypArgType -> <:expr< Genarg.rawwit_quant_hyp >> | TacticArgType -> <:expr< Genarg.rawwit_tactic >> | RedExprArgType -> <:expr< Genarg.rawwit_red_expr >> + | OpenConstrArgType -> <:expr< Genarg.rawwit_open_constr >> | CastedOpenConstrArgType -> <:expr< Genarg.rawwit_casted_open_constr >> | ConstrWithBindingsArgType -> <:expr< Genarg.rawwit_constr_with_bindings >> | BindingsArgType -> <:expr< Genarg.rawwit_bindings >> @@ -59,6 +60,7 @@ let rec make_globwit loc = function | ConstrMayEvalArgType -> <:expr< Genarg.globwit_constr_may_eval >> | TacticArgType -> <:expr< Genarg.globwit_tactic >> | RedExprArgType -> <:expr< Genarg.globwit_red_expr >> + | OpenConstrArgType -> <:expr< Genarg.globwit_open_constr >> | CastedOpenConstrArgType -> <:expr< Genarg.globwit_casted_open_constr >> | ConstrWithBindingsArgType -> <:expr< Genarg.globwit_constr_with_bindings >> | BindingsArgType -> <:expr< Genarg.globwit_bindings >> @@ -85,6 +87,7 @@ let rec make_wit loc = function | ConstrMayEvalArgType -> <:expr< Genarg.wit_constr_may_eval >> | TacticArgType -> <:expr< Genarg.wit_tactic >> | RedExprArgType -> <:expr< Genarg.wit_red_expr >> + | OpenConstrArgType -> <:expr< Genarg.wit_open_constr >> | CastedOpenConstrArgType -> <:expr< Genarg.wit_casted_open_constr >> | ConstrWithBindingsArgType -> <:expr< Genarg.wit_constr_with_bindings >> | BindingsArgType -> <:expr< Genarg.wit_bindings >> @@ -267,11 +270,14 @@ EXTEND declare_vernac_argument false loc s l ] ] ; argtype: - [ [ e = LIDENT -> fst (interp_entry_name loc e) - | e1 = LIDENT; "*"; e2 = LIDENT -> - let e1 = fst (interp_entry_name loc e1) in - let e2 = fst (interp_entry_name loc e2) in - PairArgType (e1, e2) ] ] + [ "2" RIGHTA + [ e1 = argtype; "*"; e2 = NEXT -> PairArgType (e1, e2) ] + | "1" + [ e = argtype; LIDENT "list" -> List0ArgType e + | e = argtype; LIDENT "option" -> OptArgType e ] + | "0" + [ e = LIDENT -> fst (interp_entry_name loc e) + | "("; e = argtype; ")" -> e ] ] ; argrule: [ [ "["; l = LIST0 genarg; "]"; "->"; "["; e = Pcaml.expr; "]" -> (l,e) ] ] @@ -286,4 +292,3 @@ EXTEND ] ] ; END - diff --git a/parsing/coqast.mli b/parsing/coqast.mli index 546725c0..0b1138f2 100644 --- a/parsing/coqast.mli +++ b/parsing/coqast.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: coqast.mli,v 1.10.6.1 2004/07/16 19:30:37 herbelin Exp $ i*) +(*i $Id: coqast.mli,v 1.10.6.2 2005/01/21 16:42:36 herbelin Exp $ i*) (*i*) open Util @@ -43,9 +43,9 @@ val hcons_ast: val subst_ast: Names.substitution -> t -> t -(* +(*i val map_tactic_expr : (t -> t) -> (tactic_expr -> tactic_expr) -> tactic_expr -> tactic_expr val fold_tactic_expr : ('a -> t -> 'a) -> ('a -> tactic_expr -> 'a) -> 'a -> tactic_expr -> 'a val iter_tactic_expr : (tactic_expr -> unit) -> tactic_expr -> unit -*) +i*) diff --git a/parsing/doc.tex b/parsing/doc.tex new file mode 100644 index 00000000..68ab601c --- /dev/null +++ b/parsing/doc.tex @@ -0,0 +1,9 @@ + +\newpage +\section*{The Coq parsers and printers} + +\ocwsection \label{parsing} +This chapter describes the implementation of the \Coq\ parsers and printers. + +\bigskip +\begin{center}\epsfig{file=parsing.dep.ps}\end{center} diff --git a/parsing/egrammar.ml b/parsing/egrammar.ml index 9886bbf1..7a151c1a 100644 --- a/parsing/egrammar.ml +++ b/parsing/egrammar.ml @@ -6,10 +6,11 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: egrammar.ml,v 1.48.2.1 2004/07/16 19:30:37 herbelin Exp $ *) +(* $Id: egrammar.ml,v 1.48.2.3 2004/11/26 19:37:59 herbelin Exp $ *) open Pp open Util +open Ppextend open Extend open Pcoq open Topconstr @@ -20,10 +21,11 @@ open Nameops (* State of the grammar extensions *) +type notation_grammar = + int * Gramext.g_assoc option * notation * prod_item list * int list option + type all_grammar_command = - | Notation of - (int * Gramext.g_assoc option * notation * prod_item list * - int list option) + | Notation of (precedence * tolerability list) * notation_grammar | Grammar of grammar_command | TacticGrammar of (string * (string * grammar_production list) * @@ -415,7 +417,7 @@ let add_tactic_entries gl = let extend_grammar gram = (match gram with - | Notation a -> extend_constr_notation a + | Notation (_,a) -> extend_constr_notation a | Grammar g -> extend_grammar_rules g | TacticGrammar l -> add_tactic_entries l); grammar_state := gram :: !grammar_state @@ -428,6 +430,12 @@ let reset_extend_grammars_v8 () = List.iter (fun (s,gl) -> extend_tactic_grammar s gl) te; List.iter (fun (s,gl) -> extend_vernac_command_grammar s gl) tv +let recover_notation_grammar ntn prec = + let l = map_succeed (function + | Notation (prec',(_,_,ntn',_,_ as x)) when prec = prec' & ntn = ntn' -> x + | _ -> failwith "") !grammar_state in + assert (List.length l = 1); + List.hd l (* Summary functions: the state of the lexer is included in that of the parser. Because the grammar affects the set of keywords when adding or removing diff --git a/parsing/egrammar.mli b/parsing/egrammar.mli index c601c5fc..0009b4b6 100644 --- a/parsing/egrammar.mli +++ b/parsing/egrammar.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: egrammar.mli,v 1.14.2.2 2004/07/16 19:30:37 herbelin Exp $ i*) +(*i $Id: egrammar.mli,v 1.14.2.5 2004/11/27 09:25:44 herbelin Exp $ i*) (*i*) open Util @@ -14,14 +14,16 @@ open Topconstr open Ast open Coqast open Vernacexpr +open Ppextend open Extend open Rawterm (*i*) +type notation_grammar = + int * Gramext.g_assoc option * notation * prod_item list * int list option + type all_grammar_command = - | Notation of - (int * Gramext.g_assoc option * notation * prod_item list * - int list option) + | Notation of (precedence * tolerability list) * notation_grammar | Grammar of grammar_command | TacticGrammar of (string * (string * grammar_production list) * @@ -52,3 +54,6 @@ val subst_all_grammar_command : val interp_entry_name : string -> string -> entry_type * Token.t Gramext.g_symbol + +val recover_notation_grammar : + notation -> (precedence * tolerability list) -> notation_grammar diff --git a/parsing/esyntax.mli b/parsing/esyntax.mli index e05e1ca4..88d1a0e2 100644 --- a/parsing/esyntax.mli +++ b/parsing/esyntax.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: esyntax.mli,v 1.10.2.1 2004/07/16 19:30:37 herbelin Exp $ i*) +(*i $Id: esyntax.mli,v 1.10.2.2 2005/01/21 16:42:36 herbelin Exp $ i*) (*i*) open Pp @@ -48,16 +48,14 @@ module Ppprim : val declare_primitive_printer : string -> scope_name -> primitive_printer -> unit -(* +(*i val declare_infix_symbol : Libnames.section_path -> string -> unit -*) +i*) (* Generic printing functions *) -(* +(*i val token_printer: std_printer -> std_printer -*) -(* val print_syntax_entry : string -> unparsing_subfunction -> Ast.env -> Ast.astpat syntax_entry -> std_ppcmds -*) +i*) val genprint : std_printer -> unparsing_subfunction diff --git a/parsing/extend.mli b/parsing/extend.mli index 761d0e04..c5417649 100644 --- a/parsing/extend.mli +++ b/parsing/extend.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: extend.mli,v 1.19.2.1 2004/07/16 19:30:37 herbelin Exp $ i*) +(*i $Id: extend.mli,v 1.19.2.2 2005/01/21 16:42:37 herbelin Exp $ i*) (*i*) open Pp @@ -112,10 +112,11 @@ type 'pat unparsing_hunk = | UNP_FNL | UNP_SYMBOLIC of string option * string * 'pat unparsing_hunk -(*val subst_unparsing_hunk : +(*i +val subst_unparsing_hunk : Names.substitution -> (Names.substitution -> 'pat -> 'pat) -> 'pat unparsing_hunk -> 'pat unparsing_hunk -*) +i*) (* Checks if the precedence of the parent printer (None means the highest precedence), and the child's one, follow the given diff --git a/parsing/g_constr.ml4 b/parsing/g_constr.ml4 index 7b0f7da2..80dc69f1 100644 --- a/parsing/g_constr.ml4 +++ b/parsing/g_constr.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_constr.ml4,v 1.52.2.1 2004/07/16 19:30:38 herbelin Exp $ *) +(* $Id: g_constr.ml4,v 1.52.2.2 2004/11/17 12:48:35 herbelin Exp $ *) open Pcoq open Constr @@ -23,7 +23,7 @@ let constr_kw = ":"; "("; ")"; "["; "]"; "{"; "}"; ","; ";"; "->"; "="; ":="; "!"; "::"; "<:"; ":<"; "=>"; "<"; ">"; "|"; "?"; "/"; "<->"; "\\/"; "/\\"; "`"; "``"; "&"; "*"; "+"; "@"; "^"; "#"; "-"; - "~"; "'"; "<<"; ">>"; "<>" + "~"; "'"; "<<"; ">>"; "<>"; ".." ] let _ = if !Options.v7 then diff --git a/parsing/g_constrnew.ml4 b/parsing/g_constrnew.ml4 index 18dc5683..adc26532 100644 --- a/parsing/g_constrnew.ml4 +++ b/parsing/g_constrnew.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_constrnew.ml4,v 1.41.2.1 2004/07/16 19:30:38 herbelin Exp $ *) +(* $Id: g_constrnew.ml4,v 1.41.2.2 2004/11/17 12:48:35 herbelin Exp $ *) open Pcoq open Constr @@ -22,7 +22,7 @@ open Util let constr_kw = [ "forall"; "fun"; "match"; "fix"; "cofix"; "with"; "in"; "for"; "end"; "as"; "let"; "if"; "then"; "else"; "return"; - "Prop"; "Set"; "Type"; ".("; "_" ] + "Prop"; "Set"; "Type"; ".("; "_"; ".." ] let _ = if not !Options.v7 then diff --git a/parsing/g_natsyntax.ml b/parsing/g_natsyntax.ml index e43142ba..46ef81f3 100644 --- a/parsing/g_natsyntax.ml +++ b/parsing/g_natsyntax.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_natsyntax.ml,v 1.19.2.1 2004/07/16 19:30:39 herbelin Exp $ *) +(* $Id: g_natsyntax.ml,v 1.19.2.2 2004/09/08 13:47:51 herbelin Exp $ *) (* This file to allow writing (3) for (S (S (S O))) and still write (S y) for (S y) *) @@ -125,7 +125,7 @@ let nat_of_int dloc n = match n with | POS n -> if less_than (of_string "5000") n & Options.is_verbose () then begin - warning ("You may experiment stack overflow and segmentation fault\ + warning ("You may experience stack overflow and segmentation fault\ \nwhile parsing numbers in nat greater than 5000"); flush_all () end; diff --git a/parsing/g_tactic.ml4 b/parsing/g_tactic.ml4 index 2e067215..a1559572 100644 --- a/parsing/g_tactic.ml4 +++ b/parsing/g_tactic.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_tactic.ml4,v 1.83.2.2 2004/07/16 19:30:39 herbelin Exp $ *) +(* $Id: g_tactic.ml4,v 1.83.2.4 2005/01/15 14:56:53 herbelin Exp $ *) open Pp open Ast @@ -42,7 +42,7 @@ let join_to_constr loc c2 = (fst loc), snd (Topconstr.constr_loc c2) if !Options.v7 then GEXTEND Gram GLOBAL: simple_tactic constrarg bindings constr_with_bindings - quantified_hypothesis red_expr int_or_var castedopenconstr + quantified_hypothesis red_expr int_or_var castedopenconstr open_constr simple_intropattern; int_or_var: @@ -96,8 +96,11 @@ GEXTEND Gram | IDENT "Check"; c = constr -> ConstrTypeOf c | c = constr -> ConstrTerm c ] ] ; + open_constr: + [ [ c = constr -> ((),c) ] ] + ; castedopenconstr: - [ [ c = constr -> c ] ] + [ [ c = constr -> ((),c) ] ] ; induction_arg: [ [ n = natural -> ElimOnAnonHyp n @@ -180,7 +183,7 @@ GEXTEND Gram | IDENT "Unfold"; ul = LIST1 unfold_occ -> Unfold ul | IDENT "Fold"; cl = LIST1 constr -> Fold cl | IDENT "Pattern"; pl = LIST1 pattern_occ -> Pattern pl - | s = IDENT; c = constr -> ExtraRedExpr (s,c) ] ] + | s = IDENT -> ExtraRedExpr s ] ] ; hypident: [ [ id = id_or_meta -> id,[],(InHyp,ref None) diff --git a/parsing/g_tacticnew.ml4 b/parsing/g_tacticnew.ml4 index 2070b40e..643be98d 100644 --- a/parsing/g_tacticnew.ml4 +++ b/parsing/g_tacticnew.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_tacticnew.ml4,v 1.35.2.2 2004/07/16 19:30:39 herbelin Exp $ *) +(* $Id: g_tacticnew.ml4,v 1.35.2.6 2005/01/15 14:56:53 herbelin Exp $ *) open Pp open Ast @@ -78,7 +78,7 @@ open Tactic let mk_fix_tac (loc,id,bl,ann,ty) = let n = match bl,ann with - [([_],_)], None -> 0 + [([_],_)], None -> 1 | _, Some x -> let ids = List.map snd (List.flatten (List.map fst bl)) in (try list_index (snd x) ids @@ -109,7 +109,8 @@ let join_to_constr loc c2 = (fst loc), snd (Topconstr.constr_loc c2) if not !Options.v7 then GEXTEND Gram GLOBAL: simple_tactic constr_with_bindings quantified_hypothesis - bindings red_expr int_or_var castedopenconstr simple_intropattern; + bindings red_expr int_or_var open_constr castedopenconstr + simple_intropattern; int_or_var: [ [ n = integer -> Genarg.ArgArg n @@ -128,8 +129,11 @@ GEXTEND Gram | id = METAIDENT -> MetaId (loc,id) ] ] ; + open_constr: + [ [ c = constr -> ((),c) ] ] + ; castedopenconstr: - [ [ c = constr -> c ] ] + [ [ c = constr -> ((),c) ] ] ; induction_arg: [ [ n = natural -> ElimOnAnonHyp n @@ -212,7 +216,7 @@ GEXTEND Gram | IDENT "unfold"; ul = LIST1 unfold_occ -> Unfold ul | IDENT "fold"; cl = LIST1 constr -> Fold cl | IDENT "pattern"; pl = LIST1 pattern_occ -> Pattern pl - | s = IDENT; c = constr -> ExtraRedExpr (s,c) ] ] + | s = IDENT; OPT [ (* compat V8.0pl1 *) constr ] -> ExtraRedExpr s ] ] ; hypident: [ [ id = id_or_meta -> id,(InHyp,ref None) diff --git a/parsing/g_vernac.ml4 b/parsing/g_vernac.ml4 index e2eecf55..87183e18 100644 --- a/parsing/g_vernac.ml4 +++ b/parsing/g_vernac.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_vernac.ml4,v 1.93.2.2 2004/07/16 20:51:12 herbelin Exp $ *) +(* $Id: g_vernac.ml4,v 1.93.2.3 2004/10/12 10:11:28 herbelin Exp $ *) open Names open Topconstr @@ -189,8 +189,8 @@ GEXTEND Gram ; gallina: (* Definition, Theorem, Variable, Axiom, ... *) - [ [ thm = thm_token; id = identref; ":"; c = constr -> - VernacStartTheoremProof (thm, id, ([], c), false, (fun _ _ -> ())) + [ [ thm = thm_token; id = identref; bl = binders_list; ":"; c = constr -> + VernacStartTheoremProof (thm, id, (bl, c), false, (fun _ _ -> ())) | (f,d) = def_token; id = identref; b = def_body -> VernacDefinition (d, id, b, f) | stre = assumption_token; bl = ne_params_list -> diff --git a/parsing/g_vernacnew.ml4 b/parsing/g_vernacnew.ml4 index 8a99a51e..976cc259 100644 --- a/parsing/g_vernacnew.ml4 +++ b/parsing/g_vernacnew.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_vernacnew.ml4,v 1.63.2.1 2004/07/16 19:30:39 herbelin Exp $ *) +(* $Id: g_vernacnew.ml4,v 1.63.2.2 2004/10/12 10:10:29 herbelin Exp $ *) open Pp open Util @@ -93,9 +93,8 @@ GEXTEND Gram gallina: (* Definition, Theorem, Variable, Axiom, ... *) - [ [ thm = thm_token; id = identref; (* bl = LIST0 binder; *) ":"; + [ [ thm = thm_token; id = identref; bl = LIST0 binder_let; ":"; c = lconstr -> - let bl = [] in VernacStartTheoremProof (thm, id, (bl, c), false, (fun _ _ -> ())) | (f,d) = def_token; id = identref; b = def_body -> VernacDefinition (d, id, b, f) diff --git a/parsing/g_zsyntax.ml b/parsing/g_zsyntax.ml index 27eead96..2d8d2ddd 100644 --- a/parsing/g_zsyntax.ml +++ b/parsing/g_zsyntax.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_zsyntax.ml,v 1.16.2.1 2004/07/16 19:30:39 herbelin Exp $ *) +(* $Id: g_zsyntax.ml,v 1.16.2.2 2004/11/10 13:00:44 herbelin Exp $ *) open Coqast open Pcoq @@ -197,11 +197,14 @@ let rec pat_pos_of_bignat dloc x name = | (q,true) -> PatCstr (dloc,path_of_xH,[],name) +let error_non_positive dloc = + user_err_loc (dloc, "interp_positive", + str "No non-positive numbers in type \"positive\"!") + let pat_interp_positive dloc = function - | POS n -> pat_pos_of_bignat dloc n - | NEG n -> - user_err_loc (dloc, "interp_positive", - str "No negative number in type \"positive\"!") + | NEG n -> error_non_positive dloc + | POS n -> + if is_nonzero n then pat_pos_of_bignat dloc n else error_non_positive dloc (**********************************************************************) (* Printing positive via scopes *) diff --git a/parsing/pcoq.ml4 b/parsing/pcoq.ml4 index cda482af..b5ab2387 100644 --- a/parsing/pcoq.ml4 +++ b/parsing/pcoq.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: pcoq.ml4,v 1.80.2.1 2004/07/16 19:30:40 herbelin Exp $ i*) +(*i $Id: pcoq.ml4,v 1.80.2.3 2005/01/15 14:56:53 herbelin Exp $ i*) open Pp open Util @@ -371,6 +371,8 @@ module Tactic = (* Entries that can be refered via the string -> Gram.Entry.e table *) (* Typically for tactic user extensions *) + let open_constr = + make_gen_entry utactic rawwit_open_constr "open_constr" let castedopenconstr = make_gen_entry utactic rawwit_casted_open_constr "castedopenconstr" let constr_with_bindings = @@ -774,7 +776,9 @@ let is_self from e = let is_binder_level from e = match from, e with - ETConstr(200,()), ETConstr(NumLevel 200,_) -> not !Options.v7 + ETConstr(200,()), + ETConstr(NumLevel 200,(BorderProd(false,_)|InternalProd)) -> + not !Options.v7 | _ -> false let rec symbol_of_production assoc from forpat typ = @@ -799,5 +803,3 @@ let rec symbol_of_production assoc from forpat typ = | (eobj,Some None,_) -> Gramext.Snext | (eobj,Some (Some (lev,cur)),_) -> Gramext.Snterml (Gram.Entry.obj eobj,constr_prod_level assoc cur lev) - - diff --git a/parsing/pcoq.mli b/parsing/pcoq.mli index 5c6c8354..361137f4 100644 --- a/parsing/pcoq.mli +++ b/parsing/pcoq.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: pcoq.mli,v 1.63.2.1 2004/07/16 19:30:40 herbelin Exp $ i*) +(*i $Id: pcoq.mli,v 1.63.2.2 2005/01/15 14:56:53 herbelin Exp $ i*) open Util open Names @@ -156,7 +156,8 @@ module Module : module Tactic : sig open Rawterm - val castedopenconstr : constr_expr Gram.Entry.e + val open_constr : open_constr_expr Gram.Entry.e + val castedopenconstr : open_constr_expr Gram.Entry.e val constr_with_bindings : constr_expr with_bindings Gram.Entry.e val bindings : constr_expr bindings Gram.Entry.e val constrarg : (constr_expr,reference) may_eval Gram.Entry.e diff --git a/parsing/ppconstr.ml b/parsing/ppconstr.ml index 6a5242e8..ddf008cb 100644 --- a/parsing/ppconstr.ml +++ b/parsing/ppconstr.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppconstr.ml,v 1.32.2.1 2004/07/16 19:30:40 herbelin Exp $ *) +(* $Id: ppconstr.ml,v 1.32.2.2 2004/12/29 10:17:11 herbelin Exp $ *) (*i*) open Ast @@ -370,8 +370,7 @@ let pr_red_expr (pr_constr,pr_ref) = function | Fold l -> hov 1 (str "Fold" ++ prlist (pr_arg pr_constr) l) | Pattern l -> hov 1 (str "Pattern " ++ prlist (pr_occurrences pr_constr) l) | Red true -> error "Shouldn't be accessible from user" - | ExtraRedExpr (s,c) -> - hov 1 (str s ++ pr_arg pr_constr c) + | ExtraRedExpr s -> str s let rec pr_may_eval pr pr2 = function | ConstrEval (r,c) -> diff --git a/parsing/ppconstr.mli b/parsing/ppconstr.mli index d238b371..039cd745 100644 --- a/parsing/ppconstr.mli +++ b/parsing/ppconstr.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppconstr.mli,v 1.7.2.1 2004/07/16 19:30:40 herbelin Exp $ *) +(*i $Id: ppconstr.mli,v 1.7.2.2 2005/01/21 17:19:37 herbelin Exp $ i*) open Pp open Environ diff --git a/parsing/pptactic.ml b/parsing/pptactic.ml index 95e134ae..1d7a9428 100644 --- a/parsing/pptactic.ml +++ b/parsing/pptactic.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: pptactic.ml,v 1.54.2.2 2004/07/16 19:30:40 herbelin Exp $ *) +(* $Id: pptactic.ml,v 1.54.2.3 2005/01/15 14:56:53 herbelin Exp $ *) open Pp open Names @@ -272,8 +272,9 @@ let rec pr_raw_generic prc prlc prtac prref x = pr_arg (pr_red_expr (prc,prref)) (out_gen rawwit_red_expr x) | TacticArgType -> pr_arg prtac (out_gen rawwit_tactic x) + | OpenConstrArgType -> pr_arg prc (snd (out_gen rawwit_open_constr x)) | CastedOpenConstrArgType -> - pr_arg prc (out_gen rawwit_casted_open_constr x) + pr_arg prc (snd (out_gen rawwit_casted_open_constr x)) | ConstrWithBindingsArgType -> pr_arg (pr_with_bindings prc prlc) (out_gen rawwit_constr_with_bindings x) | BindingsArgType -> @@ -320,8 +321,9 @@ let rec pr_glob_generic prc prlc prtac x = pr_arg (pr_red_expr (prc,pr_or_var (pr_and_short_name pr_evaluable_reference))) (out_gen globwit_red_expr x) | TacticArgType -> pr_arg prtac (out_gen globwit_tactic x) + | OpenConstrArgType -> pr_arg prc (snd (out_gen globwit_open_constr x)) | CastedOpenConstrArgType -> - pr_arg prc (out_gen globwit_casted_open_constr x) + pr_arg prc (snd (out_gen globwit_casted_open_constr x)) | ConstrWithBindingsArgType -> pr_arg (pr_with_bindings prc prlc) (out_gen globwit_constr_with_bindings x) | BindingsArgType -> @@ -367,6 +369,7 @@ let rec pr_generic prc prlc prtac x = | RedExprArgType -> pr_arg (pr_red_expr (prc,pr_evaluable_reference)) (out_gen wit_red_expr x) | TacticArgType -> pr_arg prtac (out_gen wit_tactic x) + | OpenConstrArgType -> pr_arg prc (snd (out_gen wit_open_constr x)) | CastedOpenConstrArgType -> pr_arg prc (snd (out_gen wit_casted_open_constr x)) | ConstrWithBindingsArgType -> diff --git a/parsing/pptactic.mli b/parsing/pptactic.mli index a80ec6fb..b9cf7401 100644 --- a/parsing/pptactic.mli +++ b/parsing/pptactic.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: pptactic.mli,v 1.9.2.1 2004/07/16 19:30:40 herbelin Exp $ *) +(*i $Id: pptactic.mli,v 1.9.2.2 2005/01/21 17:19:37 herbelin Exp $ i*) open Pp open Genarg diff --git a/parsing/printer.mli b/parsing/printer.mli index b4cd87b0..c44be124 100644 --- a/parsing/printer.mli +++ b/parsing/printer.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: printer.mli,v 1.26.2.1 2004/07/16 19:30:41 herbelin Exp $ i*) +(*i $Id: printer.mli,v 1.26.2.2 2005/01/21 16:42:37 herbelin Exp $ i*) (*i*) open Pp @@ -22,9 +22,9 @@ open Termops (*i*) (* These are the entry points for printing terms, context, tac, ... *) -(* +(*i val gentacpr : Tacexpr.raw_tactic_expr -> std_ppcmds -*) +i*) val prterm_env : env -> constr -> std_ppcmds val prterm_env_at_top : env -> constr -> std_ppcmds diff --git a/parsing/q_coqast.ml4 b/parsing/q_coqast.ml4 index aa0fce9d..a278e3d5 100644 --- a/parsing/q_coqast.ml4 +++ b/parsing/q_coqast.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: q_coqast.ml4,v 1.47.2.2 2004/07/16 20:51:12 herbelin Exp $ *) +(* $Id: q_coqast.ml4,v 1.47.2.5 2005/01/15 14:56:54 herbelin Exp $ *) open Util open Names @@ -21,8 +21,12 @@ let purge_str s = let anti loc x = let e = - let loc = unloc loc in - let loc = make_loc (1, snd loc - fst loc) in <:expr< $lid:purge_str x$ >> + let loc = + ifdef OCAML_308 then + loc + else + (1, snd loc - fst loc) + in <:expr< $lid:purge_str x$ >> in <:expr< $anti:e$ >> @@ -244,9 +248,8 @@ let mlexpr_of_red_expr = function | Rawterm.Pattern l -> let f = mlexpr_of_list mlexpr_of_occ_constr in <:expr< Rawterm.Pattern $f l$ >> - | Rawterm.ExtraRedExpr (s,c) -> - let l = mlexpr_of_constr c in - <:expr< Rawterm.ExtraRedExpr $mlexpr_of_string s$ $l$ >> + | Rawterm.ExtraRedExpr s -> + <:expr< Rawterm.ExtraRedExpr $mlexpr_of_string s$ >> let rec mlexpr_of_argtype loc = function | Genarg.BoolArgType -> <:expr< Genarg.BoolArgType >> @@ -259,6 +262,7 @@ let rec mlexpr_of_argtype loc = function | Genarg.HypArgType -> <:expr< Genarg.HypArgType >> | Genarg.StringArgType -> <:expr< Genarg.StringArgType >> | Genarg.QuantHypArgType -> <:expr< Genarg.QuantHypArgType >> + | Genarg.OpenConstrArgType -> <:expr< Genarg.OpenConstrArgType >> | Genarg.CastedOpenConstrArgType -> <:expr< Genarg.CastedOpenConstrArgType >> | Genarg.ConstrWithBindingsArgType -> <:expr< Genarg.ConstrWithBindingsArgType >> | Genarg.BindingsArgType -> <:expr< Genarg.BindingsArgType >> diff --git a/pretyping/cases.ml b/pretyping/cases.ml index 2126f015..378eee30 100644 --- a/pretyping/cases.ml +++ b/pretyping/cases.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: cases.ml,v 1.111.2.1 2004/07/16 19:30:43 herbelin Exp $ *) +(* $Id: cases.ml,v 1.111.2.4 2004/12/09 20:07:01 herbelin Exp $ *) open Util open Names @@ -262,9 +262,10 @@ type tomatch_stack = tomatch_status list (* The type [predicate_signature] types the terms to match and the rhs: - - [PrLetIn (n,dep,pred)] types a pushed term ([Pushed]), if dep is true, - the term is dependent, if n<>0 then the type of the pushed term is - necessarily inductive with n real arguments. Otherwise, it may be + - [PrLetIn (names,dep,pred)] types a pushed term ([Pushed]), + if dep<>Anonymous, the term is dependent, let n=|names|, if + n<>0 then the type of the pushed term is necessarily an + inductive with n real arguments. Otherwise, it may be non inductive, or inductive without real arguments, or inductive originating from a subterm in which case real args are not dependent; it accounts for n+1 binders if dep or n binders if not dep @@ -274,7 +275,7 @@ type tomatch_stack = tomatch_status list *) type predicate_signature = - | PrLetIn of (int * bool) * predicate_signature + | PrLetIn of (name list * name) * predicate_signature | PrProd of predicate_signature | PrCcl of constr @@ -408,12 +409,11 @@ let inh_coerce_to_ind isevars env tmloc ty tyi = let hole_source = match tmloc with | Some loc -> fun i -> (loc, TomatchTypeParameter (tyi,i)) | None -> fun _ -> (dummy_loc, InternalHole) in - let (_,evarl,_) = + let (evarl,_) = List.fold_right - (fun (na,ty) (env,evl,n) -> - (push_rel (na,None,ty) env, - (new_isevar isevars env (hole_source n) ty)::evl,n+1)) - ntys (env,[],1) in + (fun (na,ty) (evl,n) -> + (new_isevar isevars env (hole_source n) (substl evl ty))::evl,n+1) + ntys ([],1) in let expected_typ = applist (mkInd tyi,evarl) in (* devrait être indifférent d'exiger leq ou pas puisque pour un inductif cela doit être égal *) @@ -976,10 +976,17 @@ let rec map_predicate f k = function | PrCcl ccl -> PrCcl (f k ccl) | PrProd pred -> PrProd (map_predicate f (k+1) pred) - | PrLetIn ((nargs,dep as tm),pred) -> - let k' = nargs + (if dep then 1 else 0) in + | PrLetIn ((names,dep as tm),pred) -> + let k' = List.length names + (if dep<>Anonymous then 1 else 0) in PrLetIn (tm, map_predicate f (k+k') pred) +let rec noccurn_predicate k = function + | PrCcl ccl -> noccurn k ccl + | PrProd pred -> noccurn_predicate (k+1) pred + | PrLetIn ((names,dep as tm),pred) -> + let k' = List.length names + (if dep<>Anonymous then 1 else 0) in + noccurn_predicate (k+k') pred + let liftn_predicate n = map_predicate (liftn n) let lift_predicate n = liftn_predicate n 1 @@ -998,12 +1005,12 @@ let subst_predicate (args,copt) pred = let specialize_predicate_var (cur,typ) = function | PrProd _ | PrCcl _ -> anomaly "specialize_predicate_var: a pattern-variable must be pushed" - | PrLetIn ((0,dep),pred) -> - subst_predicate ([],if dep then Some cur else None) pred + | PrLetIn (([],dep),pred) -> + subst_predicate ([],if dep<>Anonymous then Some cur else None) pred | PrLetIn ((_,dep),pred) -> (match typ with | IsInd (_,IndType (_,realargs)) -> - subst_predicate (realargs,if dep then Some cur else None) pred + subst_predicate (realargs,if dep<>Anonymous then Some cur else None) pred | _ -> anomaly "specialize_predicate_var") let ungeneralize_predicate = function @@ -1020,9 +1027,9 @@ let ungeneralize_predicate = function (* then we have to replace x by x' in t(x) and y by y' in P *) (*****************************************************************************) let generalize_predicate c ny d = function - | PrLetIn ((nargs,dep as tm),pred) -> - if not dep then anomaly "Undetected dependency"; - let p = nargs + 1 in + | PrLetIn ((names,dep as tm),pred) -> + if dep=Anonymous then anomaly "Undetected dependency"; + let p = List.length names + 1 in let pred = lift_predicate 1 pred in let pred = regeneralize_index_predicate (ny+p+1) pred in PrLetIn (tm, PrProd pred) @@ -1038,18 +1045,18 @@ let rec extract_predicate l = function | PrProd pred, Abstract d'::tms -> let d' = map_rel_declaration (lift (List.length l)) d' in substl l (mkProd_or_LetIn d' (extract_predicate [] (pred,tms))) - | PrLetIn ((0,dep),pred), Pushed ((cur,_),_)::tms -> - extract_predicate (if dep then cur::l else l) (pred,tms) + | PrLetIn (([],dep),pred), Pushed ((cur,_),_)::tms -> + extract_predicate (if dep<>Anonymous then cur::l else l) (pred,tms) | PrLetIn ((_,dep),pred), Pushed ((cur,IsInd (_,(IndType(_,realargs)))),_)::tms -> let l = List.rev realargs@l in - extract_predicate (if dep then cur::l else l) (pred,tms) + extract_predicate (if dep<>Anonymous then cur::l else l) (pred,tms) | PrCcl ccl, [] -> substl l ccl | _ -> anomaly"extract_predicate: predicate inconsistent with terms to match" let abstract_predicate env sigma indf cur tms = function | (PrProd _ | PrCcl _) -> anomaly "abstract_predicate: must be some LetIn" - | PrLetIn ((nrealargs,dep),pred) -> + | PrLetIn ((names,dep),pred) -> let sign = make_arity_signature env true indf in (* n is the number of real args + 1 *) let n = List.length sign in @@ -1061,18 +1068,24 @@ let abstract_predicate env sigma indf cur tms = function (* Depending on whether the predicate is dependent or not, and has real args or not, we lift it to make room for [sign] *) (* Even if not intrinsically dep, we move the predicate into a dep one *) - let k = - if nrealargs = 0 & n <> 1 then - (* Real args were not considered *) if dep then n-1 else n + let sign,k = + if names = [] & n <> 1 then + (* Real args were not considered *) + (if dep<>Anonymous then + ((let (_,c,t) = List.hd sign in (dep,c,t)::List.tl sign),n-1) + else + (sign,n)) else - (* Real args are OK *) if dep then 0 else 1 in + (* Real args are OK *) + (List.map2 (fun na (_,c,t) -> (na,c,t)) (dep::names) sign, + if dep<>Anonymous then 0 else 1) in let pred = lift_predicate k pred in let pred = extract_predicate [] (pred,tms) in (true, it_mkLambda_or_LetIn_name env pred sign) let rec known_dependent = function | None -> false - | Some (PrLetIn ((_,dep),_)) -> dep + | Some (PrLetIn ((_,dep),_)) -> dep<>Anonymous | Some (PrCcl _) -> false | Some (PrProd _) -> anomaly "known_dependent: can only be used when patterns remain" @@ -1084,10 +1097,13 @@ let rec known_dependent = function let expand_arg n alreadydep (na,t) deps (k,pred) = (* current can occur in pred even if the original problem is not dependent *) - let dep = deps <> [] || alreadydep in - let pred = if dep then pred else lift_predicate (-1) pred in + let dep = + if alreadydep<>Anonymous then alreadydep + else if deps = [] && noccurn_predicate 1 pred then Anonymous + else Name (id_of_string "x") in + let pred = if dep<>Anonymous then pred else lift_predicate (-1) pred in (* There is no dependency in realargs for subpattern *) - (k-1, PrLetIn ((0,dep), pred)) + (k-1, PrLetIn (([],dep), pred)) (*****************************************************************************) @@ -1107,14 +1123,15 @@ let expand_arg n alreadydep (na,t) deps (k,pred) = let specialize_predicate tomatchs deps cs = function | (PrProd _ | PrCcl _) -> anomaly "specialize_predicate: a matched pattern must be pushed" - | PrLetIn ((nrealargs,isdep),pred) -> + | PrLetIn ((names,isdep),pred) -> (* Assume some gamma st: gamma, (X,x:=realargs,copt) |- pred *) - let k = nrealargs + (if isdep then 1 else 0) in + let nrealargs = List.length names in + let k = nrealargs + (if isdep<>Anonymous then 1 else 0) in (* We adjust pred st: gamma, x1..xn, (X,x:=realargs,copt) |- pred' *) let n = cs.cs_nargs in let pred' = liftn_predicate n (k+1) pred in let argsi = if nrealargs <> 0 then Array.to_list cs.cs_concl_realargs else [] in - let copti = if isdep then Some (build_dependent_constructor cs) else None in + let copti = if isdep<>Anonymous then Some (build_dependent_constructor cs) else None in (* The substituends argsi, copti are all defined in gamma, x1...xn *) (* We need _parallel_ bindings to get gamma, x1...xn |- pred'' *) let pred'' = subst_predicate (argsi, copti) pred' in @@ -1513,24 +1530,28 @@ let extract_predicate_conclusion isdep tomatchl pred = let cook = function | _,IsInd (_,IndType(_,args)) -> Some (List.length args) | _,NotInd _ -> None in - let decomp_lam_force p = + let rec decomp_lam_force n l p = + if n=0 then (l,p) else match kind_of_term p with - | Lambda (_,_,c) -> c - | _ -> (* eta-expansion *) applist (lift 1 p, [mkRel 1]) in - let rec buildrec p = function - | [] -> p + | Lambda (na,_,c) -> decomp_lam_force (n-1) (na::l) c + | _ -> (* eta-expansion *) + let na = Name (id_of_string "x") in + decomp_lam_force (n-1) (na::l) (applist (lift 1 p, [mkRel 1])) in + let rec buildrec allnames p = function + | [] -> (List.rev allnames,p) | tm::ltm -> match cook tm with | None -> let p = (* adjust to a sign containing the NotInd's *) if isdep then lift 1 p else p in - buildrec p ltm + let names = if isdep then [Anonymous] else [] in + buildrec (names::allnames) p ltm | Some n -> let n = if isdep then n+1 else n in - let p = iterate decomp_lam_force n p in - buildrec p ltm - in buildrec pred tomatchl + let names,p = decomp_lam_force n [] p in + buildrec (names::allnames) p ltm + in buildrec [] pred tomatchl let set_arity_signature dep n arsign tomatchl pred x = (* avoid is not exhaustive ! *) @@ -1572,18 +1593,19 @@ let set_arity_signature dep n arsign tomatchl pred x = decomp_block [] pred (tomatchl,arsign) let prepare_predicate_from_tycon loc dep env isevars tomatchs c = - let cook (n, l, env) = function + let cook (n, l, signs) = function | c,IsInd (_,IndType(indf,realargs)) -> let indf' = lift_inductive_family n indf in - let sign = make_arity_signature env dep indf' in + let arsign = make_arity_signature env dep indf' in let p = List.length realargs in if dep then - (n + p + 1, c::(List.rev realargs)@l, push_rels sign env) + (n + p + 1, c::(List.rev realargs)@l, arsign::signs) else - (n + p, (List.rev realargs)@l, push_rels sign env) + (n + p, (List.rev realargs)@l, arsign::signs) | c,NotInd _ -> - (n, l, env) in - let n, allargs, env = List.fold_left cook (0, [], env) tomatchs in + (n, l, []::signs) in + let n, allargs, signs = List.fold_left cook (0, [], []) tomatchs in + let env = List.fold_right push_rels signs env in let allargs = List.map (fun c -> lift n (nf_betadeltaiota env (evars_of isevars) c)) allargs in let rec build_skeleton env c = @@ -1594,28 +1616,32 @@ let prepare_predicate_from_tycon loc dep env isevars tomatchs c = mkExistential isevars env (loc, CasesType) else map_constr_with_full_binders push_rel build_skeleton env c in - build_skeleton env (lift n c) + List.rev (List.map (List.map pi1) signs), build_skeleton env (lift n c) (* Here, [pred] is assumed to be in the context built from all *) (* realargs and terms to match *) -let build_initial_predicate isdep pred tomatchl = - let nar = List.fold_left (fun n (_,t) -> - let p = match t with IsInd (_,IndType(_,a)) -> List.length a | _ -> 0 in - if isdep then n+p+1 else n+p) 0 tomatchl in - let cook = function - | _,IsInd (_,IndType(_,realargs)) -> List.length realargs - | _,NotInd _ -> 0 in +let build_initial_predicate isdep allnames pred = + let nar = List.fold_left (fun n names -> List.length names + n) 0 allnames in let rec buildrec n pred = function | [] -> PrCcl pred - | tm::ltm -> - let nrealargs = cook tm in + | names::lnames -> + let names' = if isdep then List.tl names else names in + let n' = n + List.length names' in let pred, p, user_p = if isdep then - if dependent (mkRel (nar-n)) pred then pred, 1, 1 - else liftn (-1) (nar-n) pred, 0, 1 + if dependent (mkRel (nar-n')) pred then pred, 1, 1 + else liftn (-1) (nar-n') pred, 0, 1 else pred, 0, 0 in - PrLetIn ((nrealargs,p=1), buildrec (n+nrealargs+user_p) pred ltm) - in buildrec 0 pred tomatchl + let na = + if p=1 then + let na = List.hd names in + if na = Anonymous then + (* peut arriver en raison des evars *) + Name (id_of_string "x") (*Hum*) + else na + else Anonymous in + PrLetIn ((names',na), buildrec (n'+user_p) pred lnames) + in buildrec 0 pred allnames let extract_arity_signature env0 tomatchl tmsign = let get_one_sign n tm {contents = (na,t)} = @@ -1652,9 +1678,9 @@ let extract_arity_signature env0 tomatchl tmsign = | [],[] -> [] | (_,tm)::ltm, x::tmsign -> let l = get_one_sign n tm x in - (buildrec (n + List.length l) (ltm,tmsign)) @ l + l :: buildrec (n + List.length l) (ltm,tmsign) | _ -> assert false - in buildrec 0 (tomatchl,tmsign) + in List.rev (buildrec 0 (tomatchl,tmsign)) (* Builds the predicate. If the predicate is dependent, its context is * made of 1+nrealargs assumptions for each matched term in an inductive @@ -1683,17 +1709,18 @@ let prepare_predicate loc typing_fun isevars env tomatchs sign tycon = function (match tycon with | None -> None | Some t -> - let pred = prepare_predicate_from_tycon loc false env isevars tomatchs t in - Some (build_initial_predicate false pred tomatchs)) + let names,pred = prepare_predicate_from_tycon loc false env isevars tomatchs t in + Some (build_initial_predicate false names pred)) (* v8 style type annotation *) | (None,{contents = Some rtntyp}) -> (* We extract the signature of the arity *) - let arsign = extract_arity_signature env tomatchs sign in - let env = push_rels arsign env in + let arsigns = extract_arity_signature env tomatchs sign in + let env = List.fold_right push_rels arsigns env in + let allnames = List.rev (List.map (List.map pi1) arsigns) in let predccl = (typing_fun (mk_tycon (new_Type ())) env rtntyp).uj_val in - Some (build_initial_predicate true predccl tomatchs) + Some (build_initial_predicate true allnames predccl) (* v7 style type annotation; set the v8 annotation by side effect *) | (Some pred,x) -> @@ -1721,12 +1748,9 @@ let prepare_predicate loc typing_fun isevars env tomatchs sign tycon = function error_wrong_predicate_arity_loc loc env predj.uj_val ndep_arity dep_arity in - let predccl = extract_predicate_conclusion dep tomatchs predj.uj_val in -(* - let etapred,cdep = case_dependent env (evars_of isevars) loc predj tomatchs in -*) + let ln,predccl= extract_predicate_conclusion dep tomatchs predj.uj_val in set_arity_signature dep n sign tomatchs pred x; - Some (build_initial_predicate dep predccl tomatchs) + Some (build_initial_predicate dep ln predccl) (**************************************************************************) diff --git a/pretyping/evarconv.ml b/pretyping/evarconv.ml index 6f396b43..0ee95a0f 100644 --- a/pretyping/evarconv.ml +++ b/pretyping/evarconv.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: evarconv.ml,v 1.44.6.1 2004/07/16 19:30:44 herbelin Exp $ *) +(* $Id: evarconv.ml,v 1.44.6.2 2004/11/26 23:51:39 herbelin Exp $ *) open Util open Names @@ -39,8 +39,11 @@ let flex_kind_of_term c l = let eval_flexible_term env c = match kind_of_term c with | Const c -> constant_opt_value env c - | Rel n -> let (_,v,_) = lookup_rel n env in option_app (lift n) v - | Var id -> let (_,v,_) = lookup_named id env in v + | Rel n -> + (try let (_,v,_) = lookup_rel n env in option_app (lift n) v + with Not_found -> None) + | Var id -> + (try let (_,v,_) = lookup_named id env in v with Not_found -> None) | LetIn (_,b,_,c) -> Some (subst1 b c) | Lambda _ -> Some c | _ -> assert false diff --git a/pretyping/evarutil.ml b/pretyping/evarutil.ml index 441070fe..4337c0fc 100644 --- a/pretyping/evarutil.ml +++ b/pretyping/evarutil.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: evarutil.ml,v 1.64.2.3 2004/07/16 19:30:44 herbelin Exp $ *) +(* $Id: evarutil.ml,v 1.64.2.5 2004/12/09 14:45:38 herbelin Exp $ *) open Util open Pp @@ -30,25 +30,6 @@ let rec filter_unique = function if List.mem x l then filter_unique (List.filter (fun y -> x<>y) l) else x::filter_unique l -(* -let distinct_id_list = - let rec drec fresh = function - [] -> List.rev fresh - | id::rest -> - let id' = next_ident_away_from id fresh in drec (id'::fresh) rest - in drec [] -*) - -(* -let filter_sign p sign x = - sign_it - (fun id ty (v,ids,sgn) -> - let (disc,v') = p v (id,ty) in - if disc then (v', id::ids, sgn) else (v', ids, add_sign (id,ty) sgn)) - sign - (x,[],nil_sign) -*) - (* Expanding existential variables (pretyping.ml) *) (* 1- whd_ise fails if an existential is undefined *) @@ -183,20 +164,9 @@ let do_restrict_hyps sigma ev args = let evd = Evd.map sigma ev in let env = evar_env evd in let hyps = evd.evar_hyps in - let (_,(rsign,ncargs)) = - List.fold_left - (fun (sign,(rs,na)) a -> - (List.tl sign, - if not(closed0 a) then - (rs,na) - else - (add_named_decl (List.hd sign) rs, a::na))) - (hyps,([],[])) args - in - let sign' = List.rev rsign in - let env' = reset_with_named_context sign' env in - let instance = make_evar_instance env' in - let (sigma',nc) = new_isevar_sign env' sigma evd.evar_concl instance in + let (sign,ncargs) = list_filter2 (fun _ a -> closed0 a) (hyps,args) in + let env' = reset_with_named_context sign env in + let (sigma',nc) = new_isevar_sign env' sigma evd.evar_concl ncargs in let nc = refresh_universes nc in (* needed only if nc is an inferred type *) let sigma'' = Evd.define sigma' ev nc in (sigma'', nc) diff --git a/pretyping/inductiveops.ml b/pretyping/inductiveops.ml index 24a8fbc7..c33a261b 100644 --- a/pretyping/inductiveops.ml +++ b/pretyping/inductiveops.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: inductiveops.ml,v 1.14.2.1 2004/07/16 19:30:45 herbelin Exp $ *) +(* $Id: inductiveops.ml,v 1.14.2.2 2004/12/29 12:15:00 herbelin Exp $ *) open Util open Names @@ -341,9 +341,9 @@ let control_only_guard env = Inductive.check_fix env fix; Array.iter control_rec tys; Array.iter control_rec bds; - | Case(_,p,c,b) ->control_rec p;control_rec c;Array.iter control_rec b + | Case(_,p,c,b) -> control_rec p;control_rec c;Array.iter control_rec b | Evar (_,cl) -> Array.iter control_rec cl - | App (_,cl) -> Array.iter control_rec cl + | App (c,cl) -> control_rec c; Array.iter control_rec cl | Cast (c1,c2) -> control_rec c1; control_rec c2 | Prod (_,c1,c2) -> control_rec c1; control_rec c2 | Lambda (_,c1,c2) -> control_rec c1; control_rec c2 diff --git a/pretyping/inductiveops.mli b/pretyping/inductiveops.mli index a8dcef29..8cfa9b3c 100644 --- a/pretyping/inductiveops.mli +++ b/pretyping/inductiveops.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: inductiveops.mli,v 1.10.2.1 2004/07/16 19:30:45 herbelin Exp $ *) +(*i $Id: inductiveops.mli,v 1.10.2.3 2005/01/21 17:19:37 herbelin Exp $ i*) open Names open Term @@ -66,7 +66,7 @@ val make_arity_signature : val make_arity : env -> bool -> inductive_family -> sorts -> types val build_branch_type : env -> bool -> constr -> constructor_summary -> types -(* Raise Not_found if not given an valid inductive type *) +(* Raise [Not_found] if not given an valid inductive type *) val extract_mrectype : constr -> inductive * constr list val find_mrectype : env -> evar_map -> constr -> inductive * constr list val find_rectype : env -> evar_map -> constr -> inductive_type diff --git a/pretyping/matching.mli b/pretyping/matching.mli index 808c46a4..2f666880 100644 --- a/pretyping/matching.mli +++ b/pretyping/matching.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: matching.mli,v 1.3.2.1 2004/07/16 19:30:45 herbelin Exp $ i*) +(*i $Id: matching.mli,v 1.3.2.2 2005/01/21 16:42:37 herbelin Exp $ i*) (*i*) open Names @@ -42,7 +42,7 @@ val matches_conv :env -> Evd.evar_map -> constr_pattern -> constr -> patvar_map (* To skip to the next occurrence *) exception NextOccurrence of int -(* Tries to match a _closed_ subterm of [c] with [pat] *) +(* Tries to match a **closed** subterm of [c] with [pat] *) val sub_match : int -> constr_pattern -> constr -> patvar_map * constr (* [is_matching_conv env sigma pat c] tells if [c] matches against [pat] diff --git a/pretyping/pattern.ml b/pretyping/pattern.ml index 80ab1b6e..f58a12c6 100644 --- a/pretyping/pattern.ml +++ b/pretyping/pattern.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: pattern.ml,v 1.24.2.1 2004/07/16 19:30:45 herbelin Exp $ *) +(* $Id: pattern.ml,v 1.24.2.2 2004/11/26 17:51:52 herbelin Exp $ *) open Util open Names @@ -182,8 +182,7 @@ let rec pattern_of_constr t = Some (pattern_of_constr p),pattern_of_constr a, Array.map pattern_of_constr br) | Fix f -> PFix f - | CoFix _ -> - error "pattern_of_constr: (co)fix currently not supported" + | CoFix f -> PCoFix f (* To process patterns, we need a translation without typing at all. *) diff --git a/pretyping/rawterm.ml b/pretyping/rawterm.ml index 520f09e9..ef4a4670 100644 --- a/pretyping/rawterm.ml +++ b/pretyping/rawterm.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: rawterm.ml,v 1.43.2.2 2004/07/16 19:30:46 herbelin Exp $ *) +(* $Id: rawterm.ml,v 1.43.2.4 2004/12/29 10:17:10 herbelin Exp $ *) (*i*) open Util @@ -49,7 +49,7 @@ type 'a bindings = type 'a with_bindings = 'a * 'a bindings type hole_kind = - | ImplicitArg of global_reference * int + | ImplicitArg of global_reference * (int * identifier option) | BinderType of name | QuestionMark | CasesType @@ -356,7 +356,7 @@ type ('a,'b) red_expr_gen = | Unfold of 'b occurrences list | Fold of 'a list | Pattern of 'a occurrences list - | ExtraRedExpr of string * 'a + | ExtraRedExpr of string type ('a,'b) may_eval = | ConstrTerm of 'a diff --git a/pretyping/rawterm.mli b/pretyping/rawterm.mli index d78d1866..97e11af6 100644 --- a/pretyping/rawterm.mli +++ b/pretyping/rawterm.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: rawterm.mli,v 1.47.2.2 2004/07/16 19:30:46 herbelin Exp $ i*) +(*i $Id: rawterm.mli,v 1.47.2.5 2005/01/21 16:42:37 herbelin Exp $ i*) (*i*) open Util @@ -47,7 +47,7 @@ type 'a bindings = type 'a with_bindings = 'a * 'a bindings type hole_kind = - | ImplicitArg of global_reference * int + | ImplicitArg of global_reference * (int * identifier option) | BinderType of name | QuestionMark | CasesType @@ -97,11 +97,11 @@ i*) val map_rawconstr : (rawconstr -> rawconstr) -> rawconstr -> rawconstr -(* +(*i val map_rawconstr_with_binders_loc : loc -> (identifier -> 'a -> identifier * 'a) -> ('a -> rawconstr -> rawconstr) -> 'a -> rawconstr -> rawconstr -*) +i*) val occur_rawconstr : identifier -> rawconstr -> bool @@ -130,7 +130,7 @@ type ('a,'b) red_expr_gen = | Unfold of 'b occurrences list | Fold of 'a list | Pattern of 'a occurrences list - | ExtraRedExpr of string * 'a + | ExtraRedExpr of string type ('a,'b) may_eval = | ConstrTerm of 'a diff --git a/pretyping/tacred.ml b/pretyping/tacred.ml index 7e79a4fe..f225e79f 100644 --- a/pretyping/tacred.ml +++ b/pretyping/tacred.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: tacred.ml,v 1.75.2.2 2004/07/16 19:30:46 herbelin Exp $ *) +(* $Id: tacred.ml,v 1.75.2.6 2004/12/29 10:17:10 herbelin Exp $ *) open Pp open Util @@ -329,7 +329,7 @@ let make_elim_fun (names,(nbfix,lv,n)) largs = mkLambda (Name(id_of_string"x"), substl (rev_firstn_liftn (n-k) (-i) la') a, c)) - 0 (applistc (mkEvalRef ref) la') lv) + 1 (applistc (mkEvalRef ref) la') (List.rev lv)) (* [f] is convertible to [Fix(recindices,bodynum),bodyvect)] make the reduction using this extra information *) @@ -808,6 +808,7 @@ let abstract_scheme env sigma (locc,a) t = let pattern_occs loccs_trm env sigma c = let abstr_trm = List.fold_right (abstract_scheme env sigma) loccs_trm c in + let _ = Typing.type_of env sigma abstr_trm in applist(abstr_trm, List.map snd loccs_trm) (* Generic reduction: reduction functions used in reduction tactics *) @@ -858,7 +859,7 @@ let reduction_of_redexp = function | Unfold ubinds -> unfoldn ubinds | Fold cl -> fold_commands cl | Pattern lp -> pattern_occs lp - | ExtraRedExpr (s,c) -> + | ExtraRedExpr s -> (try Stringmap.find s !red_expr_tab with Not_found -> error("unknown user-defined reduction \""^s^"\"")) (* Used in several tactics. *) @@ -945,7 +946,10 @@ let reduce_to_ref_gen allow_product env sigma ref t = try let t' = nf_betaiota (one_step_reduce env sigma t) in elimrec env t' l - with NotStepReducible -> raise Not_found + with NotStepReducible -> + errorlabstrm "" + (str "Not a statement of conclusion " ++ + Nametab.pr_global_env Idset.empty ref) in elimrec env t [] diff --git a/pretyping/tacred.mli b/pretyping/tacred.mli index 162275d5..7998a8fd 100644 --- a/pretyping/tacred.mli +++ b/pretyping/tacred.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: tacred.mli,v 1.21.2.1 2004/07/16 19:30:46 herbelin Exp $ i*) +(*i $Id: tacred.mli,v 1.21.2.2 2005/01/21 16:42:37 herbelin Exp $ i*) (*i*) open Names @@ -62,7 +62,7 @@ val reduce_to_atomic_ind : env -> evar_map -> types -> inductive * types val reduce_to_quantified_ind : env -> evar_map -> types -> inductive * types (* [reduce_to_quantified_ref env sigma ref t] try to put [t] in the form - [t'=(x1:A1)..(xn:An)(ref args)] and raise Not_found if not possible *) + [t'=(x1:A1)..(xn:An)(ref args)] and raise [Not_found] if not possible *) val reduce_to_quantified_ref : env -> evar_map -> Libnames.global_reference -> types -> types diff --git a/pretyping/termops.mli b/pretyping/termops.mli index dd9742ea..22bd0aba 100644 --- a/pretyping/termops.mli +++ b/pretyping/termops.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: termops.mli,v 1.21.2.1 2004/07/16 19:30:46 herbelin Exp $ *) +(*i $Id: termops.mli,v 1.21.2.3 2005/01/21 17:19:37 herbelin Exp $ i*) open Util open Pp @@ -16,7 +16,7 @@ open Sign open Environ (* Universes *) -(*val set_module : Names.dir_path -> unit*) +(*i val set_module : Names.dir_path -> unit i*) val new_univ : unit -> Univ.universe val new_sort_in_family : sorts_family -> sorts diff --git a/proofs/clenv.ml b/proofs/clenv.ml index 423350d7..999bb651 100644 --- a/proofs/clenv.ml +++ b/proofs/clenv.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: clenv.ml,v 1.97.2.3 2004/07/16 19:30:48 herbelin Exp $ *) +(* $Id: clenv.ml,v 1.97.2.4 2004/12/06 12:59:11 herbelin Exp $ *) open Pp open Util @@ -65,7 +65,7 @@ let exist_to_meta sigma (emap, c) = let ty = nf_betaiota (nf_evar emap (existential_type emap evar)) in let n = new_meta() in metamap := (n, ty) :: !metamap; - mkMeta n in + mkCast (mkMeta n, ty) in let rec replace c = match kind_of_term c with Evar (k,_ as ev) when not (Evd.in_dom sigma k) -> change_exist ev diff --git a/proofs/clenv.mli b/proofs/clenv.mli index 10e0004e..737fbea3 100644 --- a/proofs/clenv.mli +++ b/proofs/clenv.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: clenv.mli,v 1.32.2.1 2004/07/16 19:30:49 herbelin Exp $ i*) +(*i $Id: clenv.mli,v 1.32.2.2 2005/01/21 16:41:51 herbelin Exp $ i*) (*i*) open Util @@ -102,9 +102,9 @@ val clenv_independent : wc clausenv -> metavariable list val clenv_missing : 'a clausenv -> metavariable list val clenv_constrain_missing_args : (* Used in user contrib Lannion *) constr list -> wc clausenv -> wc clausenv -(* +(*i val clenv_constrain_dep_args : constr list -> wc clausenv -> wc clausenv -*) +i*) val clenv_lookup_name : 'a clausenv -> identifier -> metavariable val clenv_unique_resolver : bool -> wc clausenv -> goal sigma -> wc clausenv diff --git a/proofs/evar_refiner.ml b/proofs/evar_refiner.ml index d59ff835..ac4dd43a 100644 --- a/proofs/evar_refiner.ml +++ b/proofs/evar_refiner.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: evar_refiner.ml,v 1.36.2.1 2004/07/16 19:30:49 herbelin Exp $ *) +(* $Id: evar_refiner.ml,v 1.36.2.2 2004/08/03 21:37:27 herbelin Exp $ *) open Pp open Util @@ -178,6 +178,7 @@ let instantiate_pf_com n com pfts = List.nth (Evd.non_instantiated sigma) (n-1) with Failure _ -> error "not so many uninstantiated existential variables" + | Invalid_argument _ -> error "incorrect existential variable index" in let c = Constrintern.interp_constr sigma (Evarutil.evar_env evd) com in let wc' = w_Define sp c wc in diff --git a/proofs/evar_refiner.mli b/proofs/evar_refiner.mli index d7f393b3..d57e1b84 100644 --- a/proofs/evar_refiner.mli +++ b/proofs/evar_refiner.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: evar_refiner.mli,v 1.28.2.1 2004/07/16 19:30:49 herbelin Exp $ i*) +(*i $Id: evar_refiner.mli,v 1.28.2.2 2005/01/21 16:41:51 herbelin Exp $ i*) (*i*) open Names @@ -51,7 +51,7 @@ val w_const_value : wc -> constant -> constr val w_defined_evar : wc -> existential_key -> bool val instantiate : int -> constr -> identifier Tacexpr.gsimple_clause -> tactic -(* +(*i val instantiate_tac : tactic_arg list -> tactic -*) +i*) val instantiate_pf_com : int -> Topconstr.constr_expr -> pftreestate -> pftreestate diff --git a/proofs/refiner.mli b/proofs/refiner.mli index bed1158d..f6f2082e 100644 --- a/proofs/refiner.mli +++ b/proofs/refiner.mli @@ -1,4 +1,3 @@ - (************************************************************************) (* v * The Coq Proof Assistant / The Coq Development Team *) (* pftreestate val change_constraints_pftreestate : evar_map -> pftreestate -> pftreestate -(* +(*i val vernac_tactic : string * tactic_arg list -> tactic -*) +i*) (*s The most primitive tactics. *) val refiner : rule -> tactic diff --git a/scripts/coqc.ml b/scripts/coqc.ml index 7d1cc206..34025ec9 100644 --- a/scripts/coqc.ml +++ b/scripts/coqc.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coqc.ml,v 1.25.2.1 2004/07/16 19:30:50 herbelin Exp $ *) +(* $Id: coqc.ml,v 1.25.2.3 2004/09/04 10:34:56 herbelin Exp $ *) (* Afin de rendre Coq plus portable, ce programme Caml remplace le script coqc. @@ -130,8 +130,15 @@ let parse_args () = image := f; parse (cfiles,args) rem | "-image" :: [] -> usage () + | "-libdir" :: _ :: rem -> + print_string "Warning: option -libdir deprecated\n"; flush stdout; + parse (cfiles,args) rem + | ("-db"|"-debugger") :: rem -> + print_string "Warning: option -db/-debugger deprecated\n";flush stdout; + parse (cfiles,args) rem + | ("-?"|"-h"|"-H"|"-help"|"--help") :: _ -> usage () - | ("-libdir"|"-I"|"-include"|"-outputstate" + | ("-I"|"-include"|"-outputstate" |"-inputstate"|"-is"|"-load-vernac-source"|"-l"|"-load-vernac-object" |"-load-ml-source"|"-require"|"-load-ml-object"|"-user" |"-init-file"|"-dump-glob" as o) :: rem -> @@ -141,7 +148,7 @@ let parse_args () = | [] -> usage () end | "-R" as o :: s :: t :: rem -> parse (cfiles,t::s::o::args) rem - | ("-notactics"|"-debug"|"-db"|"-debugger"|"-nolib"|"-batch"|"-nois" + | ("-notactics"|"-debug"|"-nolib"|"-batch"|"-nois" |"-q"|"-full"|"-profile"|"-just-parsing"|"-echo" |"-unsafe"|"-quiet" |"-silent"|"-m"|"-xml"|"-v7"|"-v8"|"-translate"|"-strict-implicit" |"-dont-load-proofs"|"-impredicative-set" as o) :: rem -> diff --git a/tactics/auto.ml b/tactics/auto.ml index d087420a..b530178e 100644 --- a/tactics/auto.ml +++ b/tactics/auto.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: auto.ml,v 1.63.2.1 2004/07/16 19:30:51 herbelin Exp $ *) +(* $Id: auto.ml,v 1.63.2.2 2004/12/06 11:25:21 herbelin Exp $ *) open Pp open Util @@ -199,8 +199,12 @@ let make_apply_entry env sigma (eapply,verbose) name (c,cty) = in if eapply & (nmiss <> 0) then begin if verbose then + if !Options.v7 then warn (str "the hint: EApply " ++ prterm c ++ - str " will only be used by EAuto"); + str " will only be used by EAuto") + else + warn (str "the hint: eapply " ++ prterm c ++ + str " will only be used by eauto"); (hd, { hname = name; pri = nb_hyp cty + nmiss; @@ -281,40 +285,8 @@ let add_hint dbname hintlist = let cache_autohint (_,(local,name,hintlist)) = add_hint name hintlist -(* let recalc_hints hintlist = - let env = Global.env() and sigma = Evd.empty in - let recalc_hint ((_,data) as hint) = - match data.code with - | Res_pf (c,_) -> - let c' = Term.subst_mps subst c in - if c==c' then hint else - make_apply_entry env sigma (false,false) - data.hname (c', type_of env sigma c') - | ERes_pf (c,_) -> - let c' = Term.subst_mps subst c in - if c==c' then hint else - make_apply_entry env sigma (true,false) - data.hname (c', type_of env sigma c') - | Give_exact c -> - let c' = Term.subst_mps subst c in - if c==c' then hint else - make_exact_entry data.hname (c',type_of env sigma c') - | Res_pf_THEN_trivial_fail (c,_) -> - let c' = Term.subst_mps subst c in - if c==c' then hint else - make_trivial env sigma (data.hname,c') - | Unfold_nth ref -> - let ref' = subst_global subst ref in - if ref==ref' then hint else - make_unfold (data.hname,ref') - | Extern _ -> - anomaly "Extern hints cannot be substituted!!!" - in - list_smartmap recalc_hint hintlist -*) - let forward_subst_tactic = - ref (fun _ -> failwith "subst_tactic is not installed for Auto") + ref (fun _ -> failwith "subst_tactic is not installed for auto") let set_extern_subst_tactic f = forward_subst_tactic := f @@ -430,7 +402,7 @@ let add_trivials env sigma l local dbnames = dbnames let forward_intern_tac = - ref (fun _ -> failwith "intern_tac is not installed for Auto") + ref (fun _ -> failwith "intern_tac is not installed for auto") let set_extern_intern_tac f = forward_intern_tac := f @@ -492,7 +464,9 @@ let add_hints local dbnames0 h = (* Functions for printing the hints *) (**************************************************************************) -let fmt_autotactic = function +let fmt_autotactic = + if !Options.v7 then + function | Res_pf (c,clenv) -> (str"Apply " ++ prterm c) | ERes_pf (c,clenv) -> (str"EApply " ++ prterm c) | Give_exact c -> (str"Exact " ++ prterm c) @@ -500,6 +474,16 @@ let fmt_autotactic = function (str"Apply " ++ prterm c ++ str" ; Trivial") | Unfold_nth c -> (str"Unfold " ++ pr_global c) | Extern tac -> (str "Extern " ++ Pptactic.pr_glob_tactic tac) + else + function + | Res_pf (c,clenv) -> (str"apply " ++ prterm c) + | ERes_pf (c,clenv) -> (str"eapply " ++ prterm c) + | Give_exact c -> (str"exact " ++ prterm c) + | Res_pf_THEN_trivial_fail (c,clenv) -> + (str"apply " ++ prterm c ++ str" ; trivial") + | Unfold_nth c -> (str"unfold " ++ pr_global c) + | Extern tac -> + (str "(external) " ++ Pptacticnew.pr_glob_tactic (Global.env()) tac) let fmt_hint v = (fmt_autotactic v.code ++ str"(" ++ int v.pri ++ str")" ++ spc ()) @@ -631,7 +615,7 @@ si apr (* conclPattern doit échouer avec error car il est rattraper par tclFIRST *) let forward_interp_tactic = - ref (fun _ -> failwith "interp_tactic is not installed for Auto") + ref (fun _ -> failwith "interp_tactic is not installed for auto") let set_extern_interp f = forward_interp_tactic := f @@ -700,7 +684,10 @@ let trivial dbnames gl = try searchtable_map x with Not_found -> - error ("Trivial: "^x^": No such Hint database")) + if !Options.v7 then + error ("Trivial: "^x^": No such Hint database") + else + error ("trivial: "^x^": No such Hint database")) ("core"::dbnames) in tclTRY (trivial_fail_db db_list (make_local_hint_db gl)) gl @@ -799,7 +786,10 @@ let auto n dbnames gl = try searchtable_map x with Not_found -> - error ("Auto: "^x^": No such Hint database")) + if !Options.v7 then + error ("Auto: "^x^": No such Hint database") + else + error ("auto: "^x^": No such Hint database")) ("core"::dbnames) in let hyps = pf_hyps gl in diff --git a/tactics/auto.mli b/tactics/auto.mli index ef6b85ea..ec8c0d71 100644 --- a/tactics/auto.mli +++ b/tactics/auto.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: auto.mli,v 1.22.2.1 2004/07/16 19:30:51 herbelin Exp $ i*) +(*i $Id: auto.mli,v 1.22.2.2 2005/01/21 16:41:52 herbelin Exp $ i*) (*i*) open Util @@ -105,7 +105,7 @@ val make_resolves : (* [make_resolve_hyp hname htyp]. used to add an hypothesis to the local hint database; - Never raises an User_exception; + Never raises a user exception; If the hyp cannot be used as a Hint, the empty list is returned. *) val make_resolve_hyp : diff --git a/tactics/autorewrite.ml b/tactics/autorewrite.ml index 7c134b89..5706e134 100644 --- a/tactics/autorewrite.ml +++ b/tactics/autorewrite.ml @@ -22,7 +22,7 @@ open Vernacinterp open Tacexpr (* Rewriting rules *) -type rew_rule = constr * bool * tactic +type rew_rule = constr * bool * glob_tactic_expr (* Summary and Object declaration *) let rewtab = @@ -39,7 +39,6 @@ let _ = Summary.survive_module = false; Summary.survive_section = false } -(* Rewriting rules before tactic interpretation *) type raw_rew_rule = constr * bool * raw_tactic_expr (* Applies all the rules of one base *) @@ -51,6 +50,7 @@ let one_base tac_main bas = errorlabstrm "AutoRewrite" (str ("Rewriting base "^(bas)^" does not exist")) in + let lrul = List.map (fun (c,b,t) -> (c,b,Tacinterp.eval_tactic t)) lrul in tclREPEAT_MAIN (tclPROGRESS (List.fold_left (fun tac (csr,dir,tc) -> tclTHEN tac (tclREPEAT_MAIN @@ -65,12 +65,11 @@ let autorewrite tac_main lbas = (* Functions necessary to the library object declaration *) let cache_hintrewrite (_,(rbase,lrl)) = - let l = List.rev_map (fun (c,b,t) -> (c,b,Tacinterp.eval_tactic t)) lrl in let l = try - List.rev_append l (Stringmap.find rbase !rewtab) + lrl @ Stringmap.find rbase !rewtab with - | Not_found -> List.rev l + | Not_found -> lrl in rewtab:=Stringmap.add rbase l !rewtab diff --git a/tactics/equality.ml b/tactics/equality.ml index dd9054f5..994abb9d 100644 --- a/tactics/equality.ml +++ b/tactics/equality.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: equality.ml,v 1.120.2.1 2004/07/16 19:30:53 herbelin Exp $ *) +(* $Id: equality.ml,v 1.120.2.4 2004/11/21 22:24:09 herbelin Exp $ *) open Pp open Util @@ -18,6 +18,7 @@ open Termops open Inductive open Inductiveops open Environ +open Libnames open Reductionops open Instantiate open Typeops @@ -327,8 +328,11 @@ let descend_then sigma env head dirn = (dirn_nlams, dirn_env, (fun dirnval (dfltval,resty) -> - let arign,_ = get_arity env indf in - let p = it_mkLambda_or_LetIn (lift mip.mind_nrealargs resty) arign in + let arsign,_ = get_arity env indf in + let depind = build_dependent_inductive env indf in + let deparsign = (Anonymous,None,depind)::arsign in + let p = + it_mkLambda_or_LetIn (lift (mip.mind_nrealargs+1) resty) deparsign in let build_branch i = let result = if i = dirn then dirnval else dfltval in it_mkLambda_or_LetIn_name env result cstr.(i-1).cs_args in @@ -371,7 +375,9 @@ let construct_discriminator sigma env dirn c sort = let (mib,mip) = lookup_mind_specif env ind in let arsign,arsort = get_arity env indf in let (true_0,false_0,sort_0) = build_coq_True(),build_coq_False(),Prop Null in - let p = it_mkLambda_or_LetIn (mkSort sort_0) arsign in + let depind = build_dependent_inductive env indf in + let deparsign = (Anonymous,None,depind)::arsign in + let p = it_mkLambda_or_LetIn (mkSort sort_0) deparsign in let cstrs = get_constructors env indf in let build_branch i = let endpt = if i = dirn then true_0 else false_0 in @@ -419,14 +425,8 @@ let discrimination_pf e (t,t1,t2) discriminator lbeq gls = exception NotDiscriminable -let discr id gls = - let eqn = pf_whd_betadeltaiota gls (pf_get_hyp_typ gls id) in +let discrEq (lbeq,(t,t1,t2)) id gls = let sort = pf_type_of gls (pf_concl gls) in - let (lbeq,(t,t1,t2)) = - try find_eq_data_decompose eqn - with PatternMatchingFailure -> - errorlabstrm "discr" (pr_id id ++ str": not a primitive equality here") - in let sigma = project gls in let env = pf_env gls in (match find_positions env sigma t1 t2 with @@ -445,24 +445,40 @@ let discr id gls = ([onLastHyp gen_absurdity; refine (mkApp (pf, [| mkVar id |]))]))) gls) - let not_found_message id = (str "The variable" ++ spc () ++ str (string_of_id id) ++ spc () ++ str" was not found in the current environment") +let onEquality tac id gls = + let eqn = pf_whd_betadeltaiota gls (pf_get_hyp_typ gls id) in + let eq = + try find_eq_data_decompose eqn + with PatternMatchingFailure -> + errorlabstrm "" (pr_id id ++ str": not a primitive equality") + in tac eq id gls + +let check_equality tac id gls = + let eqn = pf_whd_betadeltaiota gls (pf_get_hyp_typ gls id) in + let eq = + try find_eq_data_decompose eqn + with PatternMatchingFailure -> + errorlabstrm "" (str "The goal should negate an equality") + in tac eq id gls + let onNegatedEquality tac gls = - if is_matching_not (pf_concl gls) then - (tclTHEN (tclTHEN hnf_in_concl intro) (onLastHyp tac)) gls - else if is_matching_imp_False (pf_concl gls)then - (tclTHEN intro (onLastHyp tac)) gls - else + if is_matching_not (pf_concl gls) then + (tclTHEN (tclTHEN hnf_in_concl intro) (onLastHyp(check_equality tac))) gls + else if is_matching_imp_False (pf_concl gls)then + (tclTHEN intro (onLastHyp (check_equality tac))) gls + else errorlabstrm "extract_negated_equality_then" (str"The goal should negate an equality") - let discrSimpleClause = function - | None -> onNegatedEquality discr - | Some (id,_,_) -> discr id + | None -> onNegatedEquality discrEq + | Some (id,_,_) -> onEquality discrEq id + +let discr = onEquality discrEq let discrClause = onClauses discrSimpleClause @@ -566,7 +582,7 @@ let sig_clausal_form env sigma sort_of_ty siglen ty (dFLT,dFLTty) = let isevars = Evarutil.create_evar_defs sigma in let rec sigrec_clausal_form siglen p_i = if siglen = 0 then - if Evarconv.the_conv_x env isevars p_i dFLTty then + if Evarconv.the_conv_x_leq env isevars dFLTty p_i then (* the_conv_x had a side-effect on isevars *) dFLT else @@ -695,13 +711,7 @@ let try_delta_expand env sigma t = expands then only when the whdnf has a constructor of an inductive type in hd position, otherwise delta expansion is not done *) -let inj id gls = - let eqn = pf_whd_betadeltaiota gls (pf_get_hyp_typ gls id) in - let (eq,(t,t1,t2))= - try find_eq_data_decompose eqn - with PatternMatchingFailure -> - errorlabstrm "Inj" (pr_id id ++ str": not a primitive equality here") - in +let injEq (eq,(t,t1,t2)) id gls = let sigma = project gls in let env = pf_env gls in match find_positions env sigma t1 t2 with @@ -749,17 +759,17 @@ let inj id gls = in ((tclTHENS (cut ty) ([tclIDTAC;refine pf])))) injectors gls - + +let inj = onEquality injEq + let injClause = function - | None -> onNegatedEquality inj + | None -> onNegatedEquality injEq | Some id -> try_intros_until inj id let injConcl gls = injClause None gls let injHyp id gls = injClause (Some id) gls -let decompEqThen ntac id gls = - let eqn = pf_whd_betadeltaiota gls (pf_get_hyp_typ gls id) in - let (lbeq,(t,t1,t2))= find_eq_data_decompose eqn in +let decompEqThen ntac (lbeq,(t,t1,t2)) id gls = let sort = pf_type_of gls (pf_concl gls) in let sigma = project gls in let env = pf_env gls in @@ -806,17 +816,12 @@ let decompEqThen ntac id gls = (ntac (List.length injectors))) gls)) -let decompEq = decompEqThen (fun x -> tclIDTAC) - let dEqThen ntac = function | None -> onNegatedEquality (decompEqThen ntac) - | Some id -> try_intros_until (decompEqThen ntac) id + | Some id -> try_intros_until (onEquality (decompEqThen ntac)) id let dEq = dEqThen (fun x -> tclIDTAC) -let dEqConcl gls = dEq None gls -let dEqHyp id gls = dEq (Some id) gls - let rewrite_msg = function | None -> str "passed term is not a primitive equality" | Some id -> pr_id id ++ str "does not satisfy preconditions " diff --git a/tactics/extraargs.mli b/tactics/extraargs.mli index 60a1ddc5..2b4746ae 100644 --- a/tactics/extraargs.mli +++ b/tactics/extraargs.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: extraargs.mli,v 1.3.2.1 2004/07/16 19:30:53 herbelin Exp $ *) +(*i $Id: extraargs.mli,v 1.3.2.2 2005/01/21 17:14:10 herbelin Exp $ i*) open Tacexpr open Term diff --git a/tactics/extratactics.ml4 b/tactics/extratactics.ml4 index 1dbf84ab..237f0a0d 100644 --- a/tactics/extratactics.ml4 +++ b/tactics/extratactics.ml4 @@ -8,7 +8,7 @@ (*i camlp4deps: "parsing/grammar.cma" i*) -(* $Id: extratactics.ml4,v 1.21.2.1 2004/07/16 19:30:53 herbelin Exp $ *) +(* $Id: extratactics.ml4,v 1.21.2.2 2004/11/15 11:06:49 herbelin Exp $ *) open Pp open Pcoq @@ -202,21 +202,21 @@ open Rawterm VERNAC COMMAND EXTEND DeriveInversion | [ "Derive" "Inversion" ident(na) "with" constr(c) "Sort" sort(s) ] - -> [ add_inversion_lemma_exn na c s false half_inv_tac ] + -> [ add_inversion_lemma_exn na c s false inv_tac ] | [ "Derive" "Inversion" ident(na) "with" constr(c) ] - -> [ add_inversion_lemma_exn na c (RProp Null) false half_inv_tac ] + -> [ add_inversion_lemma_exn na c (RProp Null) false inv_tac ] | [ "Derive" "Inversion" ident(na) hyp(id) ] - -> [ inversion_lemma_from_goal 1 na id Term.mk_Prop false half_inv_tac ] + -> [ inversion_lemma_from_goal 1 na id Term.mk_Prop false inv_tac ] | [ "Derive" "Inversion" natural(n) ident(na) hyp(id) ] - -> [ inversion_lemma_from_goal n na id Term.mk_Prop false half_inv_tac ] + -> [ inversion_lemma_from_goal n na id Term.mk_Prop false inv_tac ] END VERNAC COMMAND EXTEND DeriveDependentInversion | [ "Derive" "Dependent" "Inversion" ident(na) "with" constr(c) "Sort" sort(s) ] - -> [ add_inversion_lemma_exn na c s true half_dinv_tac ] + -> [ add_inversion_lemma_exn na c s true dinv_tac ] END VERNAC COMMAND EXTEND DeriveDependentInversionClear diff --git a/tactics/extratactics.mli b/tactics/extratactics.mli index a714c8dd..78a94190 100644 --- a/tactics/extratactics.mli +++ b/tactics/extratactics.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: extratactics.mli,v 1.3.10.1 2004/07/16 19:30:53 herbelin Exp $ *) +(*i $Id: extratactics.mli,v 1.3.10.2 2005/01/21 17:14:10 herbelin Exp $ i*) open Names open Term diff --git a/tactics/hiddentac.mli b/tactics/hiddentac.mli index 816678ae..1b37291c 100644 --- a/tactics/hiddentac.mli +++ b/tactics/hiddentac.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: hiddentac.mli,v 1.19.2.1 2004/07/16 19:30:53 herbelin Exp $ i*) +(*i $Id: hiddentac.mli,v 1.19.2.2 2005/01/21 16:41:52 herbelin Exp $ i*) (*i*) open Names @@ -78,9 +78,9 @@ val h_rename : identifier -> identifier -> tactic (* Constructors *) -(* +(*i val h_any_constructor : tactic -> tactic -*) +i*) val h_constructor : int -> constr bindings -> tactic val h_left : constr bindings -> tactic val h_right : constr bindings -> tactic diff --git a/tactics/setoid_replace.mli b/tactics/setoid_replace.mli index 565ae169..854fa478 100644 --- a/tactics/setoid_replace.mli +++ b/tactics/setoid_replace.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: setoid_replace.mli,v 1.3.6.1 2004/07/16 19:30:55 herbelin Exp $ *) +(*i $Id: setoid_replace.mli,v 1.3.6.2 2005/01/21 17:14:11 herbelin Exp $ i*) open Term open Proof_type diff --git a/tactics/tacinterp.ml b/tactics/tacinterp.ml index 2080b5dc..4f8e7d7c 100644 --- a/tactics/tacinterp.ml +++ b/tactics/tacinterp.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: tacinterp.ml,v 1.84.2.4 2004/07/16 19:30:55 herbelin Exp $ *) +(* $Id: tacinterp.ml,v 1.84.2.8 2005/01/15 14:56:54 herbelin Exp $ *) open Constrintern open Closure @@ -552,8 +552,7 @@ let intern_redexp ist = function | Lazy f -> Lazy (intern_flag ist f) | Pattern l -> Pattern (List.map (intern_constr_occurrence ist) l) | Simpl o -> Simpl (option_app (intern_constr_occurrence ist) o) - | (Red _ | Hnf as r) -> r - | ExtraRedExpr (s,c) -> ExtraRedExpr (s, intern_constr ist c) + | (Red _ | Hnf | ExtraRedExpr _ as r) -> r let intern_inversion_strength lf ist = function | NonDepInversion (k,idl,ids) -> @@ -879,9 +878,12 @@ and intern_genarg ist x = in_gen globwit_red_expr (intern_redexp ist (out_gen rawwit_red_expr x)) | TacticArgType -> in_gen globwit_tactic (intern_tactic ist (out_gen rawwit_tactic x)) + | OpenConstrArgType -> + in_gen globwit_open_constr + ((),intern_constr ist (snd (out_gen rawwit_open_constr x))) | CastedOpenConstrArgType -> in_gen globwit_casted_open_constr - (intern_constr ist (out_gen rawwit_casted_open_constr x)) + ((),intern_constr ist (snd (out_gen rawwit_casted_open_constr x))) | ConstrWithBindingsArgType -> in_gen globwit_constr_with_bindings (intern_constr_with_bindings ist (out_gen rawwit_constr_with_bindings x)) @@ -964,6 +966,10 @@ let is_match_catchable = function | No_match | Eval_fail _ -> true | e -> is_failure e or Logic.catchable_exception e +let hack_fail_level_shift = ref 0 +let hack_fail_level n = + if n >= !hack_fail_level_shift then n - !hack_fail_level_shift else 0 + (* Verifies if the matched list is coherent with respect to lcm *) let rec verify_metas_coherence gl lcm = function | (num,csr)::tl -> @@ -1202,12 +1208,12 @@ let interp_constr ist sigma env c = interp_casted_constr None ist sigma env c (* Interprets an open constr expression casted by the current goal *) -let pf_interp_casted_openconstr ist gl (c,ce) = +let pf_interp_openconstr_gen casted ist gl (c,ce) = let sigma = project gl in let env = pf_env gl in let (ltacvars,l) = constr_list ist env in let typs = retype_list sigma env ltacvars in - let ocl = Some (pf_concl gl) in + let ocl = if casted then Some (pf_concl gl) else None in match ce with | None -> Pretyping.understand_gen_tcc sigma env typs ocl c @@ -1216,6 +1222,9 @@ let pf_interp_casted_openconstr ist gl (c,ce) = intros/lettac/inversion hypothesis names *) | Some c -> interp_openconstr_gen sigma env (ltacvars,l) c ocl +let pf_interp_casted_openconstr = pf_interp_openconstr_gen true +let pf_interp_openconstr = pf_interp_openconstr_gen false + (* Interprets a constr expression *) let pf_interp_constr ist gl = interp_constr ist (project gl) (pf_env gl) @@ -1242,8 +1251,7 @@ let redexp_interp ist sigma env = function | Lazy f -> Lazy (interp_flag ist env f) | Pattern l -> Pattern (List.map (interp_pattern ist sigma env) l) | Simpl o -> Simpl (option_app (interp_pattern ist sigma env) o) - | (Red _ | Hnf as r) -> r - | ExtraRedExpr (s,c) -> ExtraRedExpr (s,interp_constr ist sigma env c) + | (Red _ | Hnf | ExtraRedExpr _ as r) -> r let pf_redexp_interp ist gl = redexp_interp ist (project gl) (pf_env gl) @@ -1349,7 +1357,7 @@ and eval_tactic ist = function | TacMatchContext _ -> assert false | TacMatch (c,lmr) -> assert false | TacId s -> tclIDTAC_MESSAGE s - | TacFail (n,s) -> tclFAIL (interp_int_or_var ist n) s + | TacFail (n,s) -> tclFAIL (hack_fail_level (interp_int_or_var ist n)) s | TacProgress tac -> tclPROGRESS (interp_tactic ist tac) | TacAbstract (tac,s) -> Tactics.tclABSTRACT s (interp_tactic ist tac) | TacThen (t1,t2) -> tclTHEN (interp_tactic ist t1) (interp_tactic ist t2) @@ -1494,7 +1502,7 @@ and interp_match_context ist g lr lmr = let lgoal = List.map (fun (id,c) -> (id,VConstr c)) lgoal in eval_with_fail { ist with lfun=lgoal@lctxt@ist.lfun } mt goal else - apply_hyps_context ist env goal mt lgoal mhyps hyps + apply_hyps_context ist env goal mt lctxt lgoal mhyps hyps with | e when is_failure e -> raise e | NextOccurrence _ -> raise No_match @@ -1508,7 +1516,9 @@ and interp_match_context ist g lr lmr = begin db_mc_pattern_success ist.debug; try eval_with_fail ist t goal - with e when is_match_catchable e -> + with + | e when is_failure e -> raise e + | e when is_match_catchable e -> apply_match_context ist env goal (nrs+1) (List.tl lex) tl end | (Pat (mhyps,mgoal,mt))::tl -> @@ -1529,9 +1539,10 @@ and interp_match_context ist g lr lmr = eval_with_fail {ist with lfun=lgoal@ist.lfun} mt goal end else - apply_hyps_context ist env goal mt lgoal mhyps hyps + apply_hyps_context ist env goal mt [] lgoal mhyps hyps end) with + | e when is_failure e -> raise e | e when is_match_catchable e -> begin (match e with @@ -1542,7 +1553,9 @@ and interp_match_context ist g lr lmr = end) | Subterm (id,mg) -> (try apply_goal_sub ist env goal 0 (id,mg) concl mt mhyps hyps - with e when is_match_catchable e -> + with + | e when is_failure e -> raise e + | e when is_match_catchable e -> apply_match_context ist env goal (nrs+1) (List.tl lex) tl)) | _ -> errorlabstrm "Tacinterp.apply_match_context" (str @@ -1557,7 +1570,7 @@ and interp_match_context ist g lr lmr = (read_match_rule (project g) env (fst (constr_list ist env)) lmr) (* Tries to match the hypotheses in a Match Context *) -and apply_hyps_context ist env goal mt lgmatch mhyps hyps = +and apply_hyps_context ist env goal mt lctxt lgmatch mhyps hyps = let rec apply_hyps_context_rec lfun lmatch lhyps_rest current = function | Hyp ((_,hypname),mhyp)::tl as mhyps -> let (lids,lm,hyp_match,next) = @@ -1578,7 +1591,7 @@ and apply_hyps_context ist env goal mt lgmatch mhyps hyps = db_mc_pattern_success ist.debug; eval_with_fail {ist with lfun=lmatch@lfun@ist.lfun} mt goal in - apply_hyps_context_rec [] lgmatch hyps (hyps,0) mhyps + apply_hyps_context_rec lctxt lgmatch hyps (hyps,0) mhyps (* Interprets extended tactic generic arguments *) and interp_genarg ist goal x = @@ -1617,9 +1630,12 @@ and interp_genarg ist goal x = | RedExprArgType -> in_gen wit_red_expr (pf_redexp_interp ist goal (out_gen globwit_red_expr x)) | TacticArgType -> in_gen wit_tactic (out_gen globwit_tactic x) + | OpenConstrArgType -> + in_gen wit_open_constr + (pf_interp_openconstr ist goal (snd (out_gen globwit_open_constr x))) | CastedOpenConstrArgType -> in_gen wit_casted_open_constr - (pf_interp_casted_openconstr ist goal (out_gen globwit_casted_open_constr x)) + (pf_interp_casted_openconstr ist goal (snd (out_gen globwit_casted_open_constr x))) | ConstrWithBindingsArgType -> in_gen wit_constr_with_bindings (interp_constr_with_bindings ist goal (out_gen globwit_constr_with_bindings x)) @@ -1641,6 +1657,8 @@ and interp_match ist g constr lmr = let lm = List.map (fun (id,c) -> (id,VConstr c)) lm in val_interp {ist with lfun=lm@lctxt@ist.lfun} g mt with | NextOccurrence _ -> raise No_match + | e when is_match_catchable e -> + apply_sub_match ist (nocc + 1) (id,c) csr mt in let rec apply_match ist csr = function | (All t)::_ -> @@ -1668,7 +1686,14 @@ and interp_match ist g constr lmr = errorlabstrm "Tacinterp.apply_match" (str "Argument of match does not evaluate to a term") in let ilr = read_match_rule (project g) env (fst (constr_list ist env)) lmr in - apply_match ist csr ilr + try + incr hack_fail_level_shift; + let x = apply_match ist csr ilr in + decr hack_fail_level_shift; + x + with e -> + decr hack_fail_level_shift; + raise e (* Interprets tactic expressions : returns a "tactic" *) and interp_tactic ist tac gl = @@ -1829,7 +1854,7 @@ and interp_atomic ist gl = function | TacticArgType -> val_interp ist gl (out_gen globwit_tactic x) | StringArgType | BoolArgType - | QuantHypArgType | RedExprArgType + | QuantHypArgType | RedExprArgType | OpenConstrArgType | CastedOpenConstrArgType | ConstrWithBindingsArgType | BindingsArgType | ExtraArgType _ | List0ArgType _ | List1ArgType _ | OptArgType _ | PairArgType _ -> error "This generic type is not supported in alias" @@ -1926,8 +1951,7 @@ let subst_redexp subst = function | Lazy f -> Lazy (subst_flag subst f) | Pattern l -> Pattern (List.map (subst_constr_occurrence subst) l) | Simpl o -> Simpl (option_app (subst_constr_occurrence subst) o) - | (Red _ | Hnf as r) -> r - | ExtraRedExpr (s,c) -> ExtraRedExpr (s, subst_rawconstr subst c) + | (Red _ | Hnf | ExtraRedExpr _ as r) -> r let subst_raw_may_eval subst = function | ConstrEval (r,c) -> ConstrEval (subst_redexp subst r,subst_rawconstr subst c) @@ -2120,9 +2144,12 @@ and subst_genarg subst (x:glob_generic_argument) = in_gen globwit_red_expr (subst_redexp subst (out_gen globwit_red_expr x)) | TacticArgType -> in_gen globwit_tactic (subst_tactic subst (out_gen globwit_tactic x)) + | OpenConstrArgType -> + in_gen globwit_open_constr + ((),subst_rawconstr subst (snd (out_gen globwit_open_constr x))) | CastedOpenConstrArgType -> in_gen globwit_casted_open_constr - (subst_rawconstr subst (out_gen globwit_casted_open_constr x)) + ((),subst_rawconstr subst (snd (out_gen globwit_casted_open_constr x))) | ConstrWithBindingsArgType -> in_gen globwit_constr_with_bindings (subst_raw_with_bindings subst (out_gen globwit_constr_with_bindings x)) diff --git a/tactics/tacticals.mli b/tactics/tacticals.mli index 2cb63b40..111a5e2d 100644 --- a/tactics/tacticals.mli +++ b/tactics/tacticals.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: tacticals.mli,v 1.38.2.1 2004/07/16 19:30:55 herbelin Exp $ i*) +(*i $Id: tacticals.mli,v 1.38.2.2 2005/01/21 16:41:52 herbelin Exp $ i*) (*i*) open Names @@ -127,7 +127,7 @@ type branch_assumptions = { ba : branch_args; (* the branch args *) assums : named_context} (* the list of assumptions introduced *) -(* Useful for "as intro_pattern" modifier *) +(* Useful for [as intro_pattern] modifier *) val compute_induction_names : int -> intro_pattern_expr option -> intro_pattern_expr list array diff --git a/tactics/tactics.ml b/tactics/tactics.ml index cab4f025..b6eaf015 100644 --- a/tactics/tactics.ml +++ b/tactics/tactics.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: tactics.ml,v 1.162.2.2 2004/07/16 19:30:55 herbelin Exp $ *) +(* $Id: tactics.ml,v 1.162.2.4 2004/12/04 10:26:46 herbelin Exp $ *) open Pp open Util @@ -654,7 +654,7 @@ let occurrences_of_hyp id cls = let occurrences_of_goal cls = if cls.onconcl then Some cls.concl_occs else None -let everywhere cls = (cls=allClauses) +let in_every_hyp cls = (cls.onhyps = None) (* (* Implementation with generalisation then re-intro: introduces noise *) @@ -721,8 +721,8 @@ let letin_abstract id c occs gl = | None -> depdecls | Some occ -> let newdecl = subst_term_occ_decl occ c d in - if d = newdecl then - if not (everywhere occs) + if occ = [] & d = newdecl then + if not (in_every_hyp occs) then raise (RefinerError (DoesNotOccurIn (c,hyp))) else depdecls else @@ -1175,7 +1175,7 @@ let induct_discharge statuslists destopt avoid' ((avoid7,avoid8),ra) (names,forc (match kind_of_term (pf_concl gl) with | Prod (name,t,_) -> (name,None,t) | LetIn (name,b,t,_) -> (name,Some b,t) - | _ -> assert false)) gl in + | _ -> raise (RefinerError IntroNeedsProduct))) gl in if Options.do_translate() & id7 <> id8 then force := true; let id = if !Options.v7 then id7 else id8 in rnames := !rnames @ [IntroIdentifier id]; @@ -1192,12 +1192,12 @@ let induct_discharge statuslists destopt avoid' ((avoid7,avoid8),ra) (names,forc (match kind_of_term (pf_concl gl) with | Prod (name,t,_) -> (name,None,t) | LetIn (name,b,t,_) -> (name,Some b,t) - | _ -> assert false)) gl in + | _ -> raise (RefinerError IntroNeedsProduct))) gl in let id8 = fresh_id avoid8 (default_id gl (match kind_of_term (pf_concl gl) with | Prod (name,t,_) -> (name,None,t) | LetIn (name,b,t,_) -> (name,Some b,t) - | _ -> assert false)) gl in + | _ -> raise (RefinerError IntroNeedsProduct))) gl in if Options.do_translate() & id7 <> id8 then force := true; let id = if !Options.v7 then id7 else id8 in let avoid = if !Options.v7 then avoid7 else avoid8 in diff --git a/tactics/tactics.mli b/tactics/tactics.mli index 6e67a9cd..1155d845 100644 --- a/tactics/tactics.mli +++ b/tactics/tactics.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: tactics.mli,v 1.59.2.1 2004/07/16 19:30:55 herbelin Exp $ i*) +(*i $Id: tactics.mli,v 1.59.2.2 2005/01/21 16:41:52 herbelin Exp $ i*) (*i*) open Names @@ -26,6 +26,7 @@ open Genarg open Tacexpr open Nametab open Rawterm +(*i*) (* Main tactics. *) diff --git a/test-suite/check b/test-suite/check index 1c7822d1..378c8e5d 100755 --- a/test-suite/check +++ b/test-suite/check @@ -99,7 +99,7 @@ test_parser() { foutput=`dirname $f`/`basename $f .v`.out echo "parse_file 1 \"$f\"" | ../bin/parser > $tmpoutput 2>&1 perl -ne 'if(/Starting.*Parser Loop/){$printit = 1};print if $printit' \ - $tmpoutput | grep -i error > /dev/null + $tmpoutput 2>&1 | grep -i error > /dev/null if [ $? = 0 ] ; then echo "Error! (unexpected output)" else diff --git a/test-suite/success/RecTutorial.v8 b/test-suite/success/RecTutorial.v8 new file mode 100644 index 00000000..1cef3f2f --- /dev/null +++ b/test-suite/success/RecTutorial.v8 @@ -0,0 +1,1229 @@ +Inductive nat : Set := + | O : nat + | S : nat->nat. +Check nat. +Check O. +Check S. + +Reset nat. +Print nat. + + +Print le. + +Theorem zero_leq_three: 0 <= 3. + +Proof. + constructor 2. + constructor 2. + constructor 2. + constructor 1. + +Qed. + +Print zero_leq_three. + + +Lemma zero_leq_three': 0 <= 3. + repeat constructor. +Qed. + + +Lemma zero_lt_three : 0 < 3. +Proof. + unfold lt. + repeat constructor. +Qed. + + +Require Import List. + +Print list. + +Check list. + +Check (nil (A:=nat)). + +Check (nil (A:= nat -> nat)). + +Check (fun A: Set => (cons (A:=A))). + +Check (cons 3 (cons 2 nil)). + + + + +Require Import Bvector. + +Print vector. + +Check (Vnil nat). + +Check (fun (A:Set)(a:A)=> Vcons _ a _ (Vnil _)). + +Check (Vcons _ 5 _ (Vcons _ 3 _ (Vnil _))). + + + + + + + + + + + + + +Lemma eq_3_3 : 2 + 1 = 3. +Proof. + reflexivity. +Qed. +Print eq_3_3. + +Lemma eq_proof_proof : refl_equal (2*6) = refl_equal (3*4). +Proof. + reflexivity. +Qed. +Print eq_proof_proof. + +Lemma eq_lt_le : ( 2 < 4) = (3 <= 4). +Proof. + reflexivity. +Qed. + +Lemma eq_nat_nat : nat = nat. +Proof. + reflexivity. +Qed. + +Lemma eq_Set_Set : Set = Set. +Proof. + reflexivity. +Qed. + +Lemma eq_Type_Type : Type = Type. +Proof. + reflexivity. +Qed. + + +Check (2 + 1 = 3). + + +Check (Type = Type). + +Goal Type = Type. +reflexivity. +Qed. + + +Print or. + +Print and. + + +Print sumbool. + +Print ex. + +Require Import ZArith. +Require Import Compare_dec. + +Check le_lt_dec. + +Definition max (n p :nat) := match le_lt_dec n p with + | left _ => p + | right _ => n + end. + +Theorem le_max : forall n p, n <= p -> max n p = p. +Proof. + intros n p ; unfold max ; case (le_lt_dec n p); simpl. + trivial. + intros; absurd (p < p); eauto with arith. +Qed. + +Extraction max. + + + + + + +Inductive tree(A:Set) : Set := + node : A -> forest A -> tree A +with + forest (A: Set) : Set := + nochild : forest A | + addchild : tree A -> forest A -> forest A. + + + + + +Inductive + even : nat->Prop := + evenO : even O | + evenS : forall n, odd n -> even (S n) +with + odd : nat->Prop := + oddS : forall n, even n -> odd (S n). + +Lemma odd_49 : odd (7 * 7). + simpl; repeat constructor. +Qed. + + + +Definition nat_case := + fun (Q : Type)(g0 : Q)(g1 : nat -> Q)(n:nat) => + match n return Q with + | 0 => g0 + | S p => g1 p + end. + +Eval simpl in (nat_case nat 0 (fun p => p) 34). + +Eval simpl in (fun g0 g1 => nat_case nat g0 g1 34). + +Eval simpl in (fun g0 g1 => nat_case nat g0 g1 0). + + +Definition pred (n:nat) := match n with O => O | S m => m end. + +Eval simpl in pred 56. + +Eval simpl in pred 0. + +Eval simpl in fun p => pred (S p). + + +Definition xorb (b1 b2:bool) := +match b1, b2 with + | false, true => true + | true, false => true + | _ , _ => false +end. + + + Definition pred_spec (n:nat) := {m:nat | n=0 /\ m=0 \/ n = S m}. + + + Definition predecessor : forall n:nat, pred_spec n. + intro n;case n. + unfold pred_spec;exists 0;auto. + unfold pred_spec; intro n0;exists n0; auto. + Defined. + +Print predecessor. + +Extraction predecessor. + +Theorem nat_expand : + forall n:nat, n = match n with 0 => 0 | S p => S p end. + intro n;case n;simpl;auto. +Qed. + +Check (fun p:False => match p return 2=3 with end). + +Theorem fromFalse : False -> 0=1. + intro absurd. + contradiction. +Qed. + +Section equality_elimination. + Variables (A: Type) + (a b : A) + (p : a = b) + (Q : A -> Type). + Check (fun H : Q a => + match p in (eq _ y) return Q y with + refl_equal => H + end). + +End equality_elimination. + + +Theorem trans : forall n m p:nat, n=m -> m=p -> n=p. +Proof. + intros n m p eqnm. + case eqnm. + trivial. +Qed. + +Lemma Rw : forall x y: nat, y = y * x -> y * x * x = y. + intros x y e; do 2 rewrite <- e. + reflexivity. +Qed. + + +Require Import Arith. + +Check mult_1_l. +(* +mult_1_l + : forall n : nat, 1 * n = n +*) + +Check mult_plus_distr_r. +(* +mult_plus_distr_r + : forall n m p : nat, (n + m) * p = n * p + m * p + +*) + +Lemma mult_distr_S : forall n p : nat, n * p + p = (S n)* p. + simpl;auto with arith. +Qed. + +Lemma four_n : forall n:nat, n+n+n+n = 4*n. + intro n;rewrite <- (mult_1_l n). + + Undo. + intro n; pattern n at 1. + + + rewrite <- mult_1_l. + repeat rewrite mult_distr_S. + trivial. +Qed. + + +Section Le_case_analysis. + Variables (n p : nat) + (H : n <= p) + (Q : nat -> Prop) + (H0 : Q n) + (HS : forall m, n <= m -> Q (S m)). + Check ( + match H in (_ <= q) return (Q q) with + | le_n => H0 + | le_S m Hm => HS m Hm + end + ). + + +End Le_case_analysis. + + +Lemma predecessor_of_positive : forall n, 1 <= n -> exists p:nat, n = S p. +Proof. + intros n H; case H. + exists 0; trivial. + intros m Hm; exists m;trivial. +Qed. + +Definition Vtail_total + (A : Set) (n : nat) (v : vector A n) : vector A (pred n):= +match v in (vector _ n0) return (vector A (pred n0)) with +| Vnil => Vnil A +| Vcons _ n0 v0 => v0 +end. + +Definition Vtail' (A:Set)(n:nat)(v:vector A n) : vector A (pred n). + intros A n v; case v. + simpl. + exact (Vnil A). + simpl. + auto. +Defined. + +(* +Inductive Lambda : Set := + lambda : (Lambda -> False) -> Lambda. + + +Error: Non strictly positive occurrence of "Lambda" in + "(Lambda -> False) -> Lambda" + +*) + +Section Paradox. + Variable Lambda : Set. + Variable lambda : (Lambda -> False) ->Lambda. + + Variable matchL : Lambda -> forall Q:Prop, ((Lambda ->False) -> Q) -> Q. + (* + understand matchL Q l (fun h : Lambda -> False => t) + + as match l return Q with lambda h => t end + *) + + Definition application (f x: Lambda) :False := + matchL f False (fun h => h x). + + Definition Delta : Lambda := lambda (fun x : Lambda => application x x). + + Definition loop : False := application Delta Delta. + + Theorem two_is_three : 2 = 3. + Proof. + elim loop. + Qed. + +End Paradox. + + +Require Import ZArith. + + + +Inductive itree : Set := +| ileaf : itree +| inode : Z-> (nat -> itree) -> itree. + +Definition isingle l := inode l (fun i => ileaf). + +Definition t1 := inode 0 (fun n => isingle (Z_of_nat (2*n))). + +Definition t2 := inode 0 + (fun n : nat => + inode (Z_of_nat n) + (fun p => isingle (Z_of_nat (n*p)))). + + +Inductive itree_le : itree-> itree -> Prop := + | le_leaf : forall t, itree_le ileaf t + | le_node : forall l l' s s', + Zle l l' -> + (forall i, exists j:nat, itree_le (s i) (s' j)) -> + itree_le (inode l s) (inode l' s'). + + +Theorem itree_le_trans : + forall t t', itree_le t t' -> + forall t'', itree_le t' t'' -> itree_le t t''. + induction t. + constructor 1. + + intros t'; case t'. + inversion 1. + intros z0 i0 H0. + intro t'';case t''. + inversion 1. + intros. + inversion_clear H1. + constructor 2. + inversion_clear H0;eauto with zarith. + inversion_clear H0. + intro i2; case (H4 i2). + intros. + generalize (H i2 _ H0). + intros. + case (H3 x);intros. + generalize (H5 _ H6). + exists x0;auto. +Qed. + + + +Inductive itree_le' : itree-> itree -> Prop := + | le_leaf' : forall t, itree_le' ileaf t + | le_node' : forall l l' s s' g, + Zle l l' -> + (forall i, itree_le' (s i) (s' (g i))) -> + itree_le' (inode l s) (inode l' s'). + + + + + +Lemma t1_le_t2 : itree_le t1 t2. + unfold t1, t2. + constructor. + auto with zarith. + intro i; exists (2 * i). + unfold isingle. + constructor. + auto with zarith. + exists i;constructor. +Qed. + + + +Lemma t1_le'_t2 : itree_le' t1 t2. + unfold t1, t2. + constructor 2 with (fun i : nat => 2 * i). + auto with zarith. + unfold isingle; + intro i ; constructor 2 with (fun i :nat => i). + auto with zarith. + constructor . +Qed. + + +Require Import List. + +Inductive ltree (A:Set) : Set := + lnode : A -> list (ltree A) -> ltree A. + +Inductive prop : Prop := + prop_intro : Prop -> prop. + +Lemma prop_inject: prop. +Proof prop_intro prop. + + +Inductive ex_Prop (P : Prop -> Prop) : Prop := + exP_intro : forall X : Prop, P X -> ex_Prop P. + +Lemma ex_Prop_inhabitant : ex_Prop (fun P => P -> P). +Proof. + exists (ex_Prop (fun P => P -> P)). + trivial. +Qed. + + + + +(* + +Check (fun (P:Prop->Prop)(p: ex_Prop P) => + match p with exP_intro X HX => X end). +Error: +Incorrect elimination of "p" in the inductive type +"ex_Prop", the return type has sort "Type" while it should be +"Prop" + +Elimination of an inductive object of sort "Prop" +is not allowed on a predicate in sort "Type" +because proofs can be eliminated only to build proofs + +*) + +(* +Check (match prop_inject with (prop_intro P p) => P end). + +Error: +Incorrect elimination of "prop_inject" in the inductive type +"prop", the return type has sort "Type" while it should be +"Prop" + +Elimination of an inductive object of sort "Prop" +is not allowed on a predicate in sort "Type" +because proofs can be eliminated only to build proofs + +*) +Print prop_inject. + +(* +prop_inject = +prop_inject = prop_intro prop (fun H : prop => H) + : prop +*) + + +Inductive typ : Type := + typ_intro : Type -> typ. + +Definition typ_inject: typ. +split. +exact typ. +(* +Defined. + +Error: Universe Inconsistency. +*) +Abort. +(* + +Inductive aSet : Set := + aSet_intro: Set -> aSet. + + +User error: Large non-propositional inductive types must be in Type + +*) + +Inductive ex_Set (P : Set -> Prop) : Type := + exS_intro : forall X : Set, P X -> ex_Set P. + + +Inductive comes_from_the_left (P Q:Prop): P \/ Q -> Prop := + c1 : forall p, comes_from_the_left P Q (or_introl (A:=P) Q p). + +Goal (comes_from_the_left _ _ (or_introl True I)). +split. +Qed. + +Goal ~(comes_from_the_left _ _ (or_intror True I)). + red;inversion 1. + (* discriminate H0. + *) +Abort. + +Reset comes_from_the_left. + +(* + + + + + + + Definition comes_from_the_left (P Q:Prop)(H:P \/ Q): Prop := + match H with + | or_introl p => True + | or_intror q => False + end. + +Error: +Incorrect elimination of "H" in the inductive type +"or", the return type has sort "Type" while it should be +"Prop" + +Elimination of an inductive object of sort "Prop" +is not allowed on a predicate in sort "Type" +because proofs can be eliminated only to build proofs + +*) + +Definition comes_from_the_left_sumbool + (P Q:Prop)(x:{P}+{Q}): Prop := + match x with + | left p => True + | right q => False + end. + + + + +Close Scope Z_scope. + + + + + +Theorem S_is_not_O : forall n, S n <> 0. + +Definition Is_zero (x:nat):= match x with + | 0 => True + | _ => False + end. + Lemma O_is_zero : forall m, m = 0 -> Is_zero m. + Proof. + intros m H; subst m. + (* + ============================ + Is_zero 0 + *) + simpl;trivial. + Qed. + + red; intros n Hn. + apply O_is_zero with (m := S n). + assumption. +Qed. + +Theorem disc2 : forall n, S (S n) <> 1. +Proof. + intros n Hn; discriminate. +Qed. + + +Theorem disc3 : forall n, S (S n) = 0 -> forall Q:Prop, Q. +Proof. + intros n Hn Q. + discriminate. +Qed. + + + +Theorem inj_succ : forall n m, S n = S m -> n = m. +Proof. + + +Lemma inj_pred : forall n m, n = m -> pred n = pred m. +Proof. + intros n m eq_n_m. + rewrite eq_n_m. + trivial. +Qed. + + intros n m eq_Sn_Sm. + apply inj_pred with (n:= S n) (m := S m); assumption. +Qed. + +Lemma list_inject : forall (A:Set)(a b :A)(l l':list A), + a :: b :: l = b :: a :: l' -> a = b /\ l = l'. +Proof. + intros A a b l l' e. + injection e. + auto. +Qed. + + +Theorem not_le_Sn_0 : forall n:nat, ~ (S n <= 0). +Proof. + red; intros n H. + case H. +Undo. + +Lemma not_le_Sn_0_with_constraints : + forall n p , S n <= p -> p = 0 -> False. +Proof. + intros n p H; case H ; + intros; discriminate. +Qed. + +eapply not_le_Sn_0_with_constraints; eauto. +Qed. + + +Theorem not_le_Sn_0' : forall n:nat, ~ (S n <= 0). +Proof. + red; intros n H ; inversion H. +Qed. + +Derive Inversion le_Sn_0_inv with (forall n :nat, S n <= 0). +Check le_Sn_0_inv. + +Theorem le_Sn_0'' : forall n p : nat, ~ S n <= 0 . +Proof. + intros n p H; + inversion H using le_Sn_0_inv. +Qed. + +Derive Inversion_clear le_Sn_0_inv' with (forall n :nat, S n <= 0). +Check le_Sn_0_inv'. + + +Theorem le_reverse_rules : + forall n m:nat, n <= m -> + n = m \/ + exists p, n <= p /\ m = S p. +Proof. + intros n m H; inversion H. + left;trivial. + right; exists m0; split; trivial. +Restart. + intros n m H; inversion_clear H. + left;trivial. + right; exists m0; split; trivial. +Qed. + +Inductive ArithExp : Set := + Zero : ArithExp + | Succ : ArithExp -> ArithExp + | Plus : ArithExp -> ArithExp -> ArithExp. + +Inductive RewriteRel : ArithExp -> ArithExp -> Prop := + RewSucc : forall e1 e2 :ArithExp, + RewriteRel e1 e2 -> RewriteRel (Succ e1) (Succ e2) + | RewPlus0 : forall e:ArithExp, + RewriteRel (Plus Zero e) e + | RewPlusS : forall e1 e2:ArithExp, + RewriteRel e1 e2 -> + RewriteRel (Plus (Succ e1) e2) (Succ (Plus e1 e2)). + + + +Fixpoint plus (n p:nat) {struct n} : nat := + match n with + | 0 => p + | S m => S (plus m p) + end. + +Fixpoint plus' (n p:nat) {struct p} : nat := + match p with + | 0 => n + | S q => S (plus' n q) + end. + +Fixpoint plus'' (n p:nat) {struct n} : nat := + match n with + | 0 => p + | S m => plus'' m (S p) + end. + + +Fixpoint even_test (n:nat) : bool := + match n + with 0 => true + | 1 => false + | S (S p) => even_test p + end. + + +Reset even_test. + +Fixpoint even_test (n:nat) : bool := + match n + with + | 0 => true + | S p => odd_test p + end +with odd_test (n:nat) : bool := + match n + with + | 0 => false + | S p => even_test p + end. + + + +Eval simpl in even_test. + + + +Eval simpl in (fun x : nat => even_test x). + + +Eval simpl in (fun x : nat => even_test (plus 5 x)). + +Eval simpl in (fun x : nat => even_test (plus x 5)). + + +Section Principle_of_Induction. +Variable P : nat -> Prop. +Hypothesis base_case : P 0. +Hypothesis inductive_hyp : forall n:nat, P n -> P (S n). +Fixpoint nat_ind (n:nat) : (P n) := + match n return P n with + | 0 => base_case + | S m => inductive_hyp m (nat_ind m) + end. + +End Principle_of_Induction. + +Scheme Even_induction := Minimality for even Sort Prop +with Odd_induction := Minimality for odd Sort Prop. + +Theorem even_plus_four : forall n:nat, even n -> even (4+n). +Proof. + intros n H. + elim H using Even_induction with (P0 := fun n => odd (4+n)); + simpl;repeat constructor;assumption. +Qed. + + +Section Principle_of_Double_Induction. +Variable P : nat -> nat ->Prop. +Hypothesis base_case1 : forall x:nat, P 0 x. +Hypothesis base_case2 : forall x:nat, P (S x) 0. +Hypothesis inductive_hyp : forall n m:nat, P n m -> P (S n) (S m). +Fixpoint nat_double_ind (n m:nat){struct n} : P n m := + match n, m return P n m with + | 0 , x => base_case1 x + | (S x), 0 => base_case2 x + | (S x), (S y) => inductive_hyp x y (nat_double_ind x y) + end. +End Principle_of_Double_Induction. + +Section Principle_of_Double_Recursion. +Variable P : nat -> nat -> Set. +Hypothesis base_case1 : forall x:nat, P 0 x. +Hypothesis base_case2 : forall x:nat, P (S x) 0. +Hypothesis inductive_hyp : forall n m:nat, P n m -> P (S n) (S m). +Fixpoint nat_double_rec (n m:nat){struct n} : P n m := + match n, m return P n m with + | 0 , x => base_case1 x + | (S x), 0 => base_case2 x + | (S x), (S y) => inductive_hyp x y (nat_double_rec x y) + end. +End Principle_of_Double_Recursion. + +Definition min : nat -> nat -> nat := + nat_double_rec (fun (x y:nat) => nat) + (fun (x:nat) => 0) + (fun (y:nat) => 0) + (fun (x y r:nat) => S r). + +Eval compute in (min 5 8). +Eval compute in (min 8 5). + + + +Lemma not_circular : forall n:nat, n <> S n. +Proof. + intro n. + apply nat_ind with (P:= fun n => n <> S n). + discriminate. + red; intros n0 Hn0 eqn0Sn0;injection eqn0Sn0;trivial. +Qed. + +Definition eq_nat_dec : forall n p:nat , {n=p}+{n <> p}. +Proof. + intros n p. + apply nat_double_rec with (P:= fun (n q:nat) => {q=p}+{q <> p}). +Undo. + pattern p,n. + elim n using nat_double_rec. + destruct x; auto. + destruct x; auto. + intros n0 m H; case H. + intro eq; rewrite eq ; auto. + intro neg; right; red ; injection 1; auto. +Defined. + +Definition eq_nat_dec' : forall n p:nat, {n=p}+{n <> p}. + decide equality. +Defined. + +Print Acc. + + +Require Import Minus. + +(* +Fixpoint div (x y:nat){struct x}: nat := + if eq_nat_dec x 0 + then 0 + else if eq_nat_dec y 0 + then x + else S (div (x-y) y). + +Error: +Recursive definition of div is ill-formed. +In environment +div : nat -> nat -> nat +x : nat +y : nat +_ : x <> 0 +_ : y <> 0 + +Recursive call to div has principal argument equal to +"x - y" +instead of a subterm of x + +*) + +Lemma minus_smaller_S: forall x y:nat, x - y < S x. +Proof. + intros x y; pattern y, x; + elim x using nat_double_ind. + destruct x0; auto with arith. + simpl; auto with arith. + simpl; auto with arith. +Qed. + +Lemma minus_smaller_positive : forall x y:nat, x <>0 -> y <> 0 -> + x - y < x. +Proof. + destruct x; destruct y; + ( simpl;intros; apply minus_smaller_S || + intros; absurd (0=0); auto). +Qed. + +Definition minus_decrease : forall x y:nat, Acc lt x -> + x <> 0 -> + y <> 0 -> + Acc lt (x-y). +Proof. + intros x y H; case H. + intros z Hz posz posy. + apply Hz; apply minus_smaller_positive; assumption. +Defined. + +Print minus_decrease. + + + +Definition div_aux (x y:nat)(H: Acc lt x):nat. + fix 3. + intros. + refine (if eq_nat_dec x 0 + then 0 + else if eq_nat_dec y 0 + then y + else div_aux (x-y) y _). + apply (minus_decrease x y H);assumption. +Defined. + + +Print div_aux. +(* +div_aux = +(fix div_aux (x y : nat) (H : Acc lt x) {struct H} : nat := + match eq_nat_dec x 0 with + | left _ => 0 + | right _ => + match eq_nat_dec y 0 with + | left _ => y + | right _0 => div_aux (x - y) y (minus_decrease x y H _ _0) + end + end) + : forall x : nat, nat -> Acc lt x -> nat +*) + +Require Import Wf_nat. +Definition div x y := div_aux x y (lt_wf x). + +Extraction div. +(* +let div x y = + div_aux x y +*) + +Extraction div_aux. + +(* +let rec div_aux x y = + match eq_nat_dec x O with + | Left -> O + | Right -> + (match eq_nat_dec y O with + | Left -> y + | Right -> div_aux (minus x y) y) +*) + +Lemma vector0_is_vnil : forall (A:Set)(v:vector A 0), v = Vnil A. +Proof. + intros A v;inversion v. +Abort. + +(* + Lemma vector0_is_vnil_aux : forall (A:Set)(n:nat)(v:vector A n), + n= 0 -> v = Vnil A. + +Toplevel input, characters 40281-40287 +> Lemma vector0_is_vnil_aux : forall (A:Set)(n:nat)(v:vector A n), n= 0 -> v = Vnil A. +> ^^^^^^ +Error: In environment +A : Set +n : nat +v : vector A n +e : n = 0 +The term "Vnil A" has type "vector A 0" while it is expected to have type + "vector A n" +*) + Require Import JMeq. + +Lemma vector0_is_vnil_aux : forall (A:Set)(n:nat)(v:vector A n), + n= 0 -> JMeq v (Vnil A). +Proof. + destruct v. + auto. + intro; discriminate. +Qed. + +Lemma vector0_is_vnil : forall (A:Set)(v:vector A 0), v = Vnil A. +Proof. + intros a v;apply JMeq_eq. + apply vector0_is_vnil_aux. + trivial. +Qed. + + +Implicit Arguments Vcons [A n]. +Implicit Arguments Vnil [A]. +Implicit Arguments Vhead [A n]. +Implicit Arguments Vtail [A n]. + +Definition Vid : forall (A : Set)(n:nat), vector A n -> vector A n. +Proof. + destruct n; intro v. + exact Vnil. + exact (Vcons (Vhead v) (Vtail v)). +Defined. + +Eval simpl in (fun (A:Set)(v:vector A 0) => (Vid _ _ v)). + +Eval simpl in (fun (A:Set)(v:vector A 0) => v). + + + +Lemma Vid_eq : forall (n:nat) (A:Set)(v:vector A n), v=(Vid _ n v). +Proof. + destruct v. + reflexivity. + reflexivity. +Defined. + +Theorem zero_nil : forall A (v:vector A 0), v = Vnil. +Proof. + intros. + change (Vnil (A:=A)) with (Vid _ 0 v). + apply Vid_eq. +Defined. + + +Theorem decomp : + forall (A : Set) (n : nat) (v : vector A (S n)), + v = Vcons (Vhead v) (Vtail v). +Proof. + intros. + change (Vcons (Vhead v) (Vtail v)) with (Vid _ (S n) v). + apply Vid_eq. +Defined. + + + +Definition vector_double_rect : + forall (A:Set) (P: forall (n:nat),(vector A n)->(vector A n) -> Type), + P 0 Vnil Vnil -> + (forall n (v1 v2 : vector A n) a b, P n v1 v2 -> + P (S n) (Vcons a v1) (Vcons b v2)) -> + forall n (v1 v2 : vector A n), P n v1 v2. + induction n. + intros; rewrite (zero_nil _ v1); rewrite (zero_nil _ v2). + auto. + intros v1 v2; rewrite (decomp _ _ v1);rewrite (decomp _ _ v2). + apply X0; auto. +Defined. + +Require Import Bool. + +Definition bitwise_or n v1 v2 : vector bool n := + vector_double_rect bool (fun n v1 v2 => vector bool n) + Vnil + (fun n v1 v2 a b r => Vcons (orb a b) r) n v1 v2. + + +Fixpoint vector_nth (A:Set)(n:nat)(p:nat)(v:vector A p){struct v} + : option A := + match n,v with + _ , Vnil => None + | 0 , Vcons b _ _ => Some b + | S n', Vcons _ p' v' => vector_nth A n' p' v' + end. + +Implicit Arguments vector_nth [A p]. + + +Lemma nth_bitwise : forall (n:nat) (v1 v2: vector bool n) i a b, + vector_nth i v1 = Some a -> + vector_nth i v2 = Some b -> + vector_nth i (bitwise_or _ v1 v2) = Some (orb a b). +Proof. + intros n v1 v2; pattern n,v1,v2. + apply vector_double_rect. + simpl. + destruct i; discriminate 1. + destruct i; simpl;auto. + injection 1; injection 2;intros; subst a; subst b; auto. +Qed. + + Set Implicit Arguments. + + CoInductive Stream (A:Set) : Set := + | Cons : A -> Stream A -> Stream A. + + CoInductive LList (A: Set) : Set := + | LNil : LList A + | LCons : A -> LList A -> LList A. + + + + + + Definition head (A:Set)(s : Stream A) := match s with Cons a s' => a end. + + Definition tail (A : Set)(s : Stream A) := + match s with Cons a s' => s' end. + + CoFixpoint repeat (A:Set)(a:A) : Stream A := Cons a (repeat a). + + CoFixpoint iterate (A: Set)(f: A -> A)(a : A) : Stream A:= + Cons a (iterate f (f a)). + + CoFixpoint map (A B:Set)(f: A -> B)(s : Stream A) : Stream B:= + match s with Cons a tl => Cons (f a) (map f tl) end. + +Eval simpl in (fun (A:Set)(a:A) => repeat a). + +Eval simpl in (fun (A:Set)(a:A) => head (repeat a)). + + +CoInductive EqSt (A: Set) : Stream A -> Stream A -> Prop := + eqst : forall s1 s2: Stream A, + head s1 = head s2 -> + EqSt (tail s1) (tail s2) -> + EqSt s1 s2. + + +Section Parks_Principle. +Variable A : Set. +Variable R : Stream A -> Stream A -> Prop. +Hypothesis bisim1 : forall s1 s2:Stream A, R s1 s2 -> + head s1 = head s2. +Hypothesis bisim2 : forall s1 s2:Stream A, R s1 s2 -> + R (tail s1) (tail s2). + +CoFixpoint park_ppl : forall s1 s2:Stream A, R s1 s2 -> + EqSt s1 s2 := + fun s1 s2 (p : R s1 s2) => + eqst s1 s2 (bisim1 p) + (park_ppl (bisim2 p)). +End Parks_Principle. + + +Theorem map_iterate : forall (A:Set)(f:A->A)(x:A), + EqSt (iterate f (f x)) (map f (iterate f x)). +Proof. + intros A f x. + apply park_ppl with + (R:= fun s1 s2 => exists x: A, + s1 = iterate f (f x) /\ s2 = map f (iterate f x)). + + intros s1 s2 (x0,(eqs1,eqs2));rewrite eqs1;rewrite eqs2;reflexivity. + intros s1 s2 (x0,(eqs1,eqs2)). + exists (f x0);split;[rewrite eqs1|rewrite eqs2]; reflexivity. + exists x;split; reflexivity. +Qed. + +Ltac infiniteproof f := + cofix f; constructor; [clear f| simpl; try (apply f; clear f)]. + + +Theorem map_iterate' : forall (A:Set)(f:A->A)(x:A), + EqSt (iterate f (f x)) (map f (iterate f x)). +infiniteproof map_iterate'. + reflexivity. +Qed. + + +Implicit Arguments LNil [A]. + +Lemma Lnil_not_Lcons : forall (A:Set)(a:A)(l:LList A), + LNil <> (LCons a l). + intros;discriminate. +Qed. + +Lemma injection_demo : forall (A:Set)(a b : A)(l l': LList A), + LCons a (LCons b l) = LCons b (LCons a l') -> + a = b /\ l = l'. +Proof. + intros A a b l l' e; injection e; auto. +Qed. + + +Inductive Finite (A:Set) : LList A -> Prop := +| Lnil_fin : Finite (LNil (A:=A)) +| Lcons_fin : forall a l, Finite l -> Finite (LCons a l). + +CoInductive Infinite (A:Set) : LList A -> Prop := +| LCons_inf : forall a l, Infinite l -> Infinite (LCons a l). + +Lemma LNil_not_Infinite : forall (A:Set), ~ Infinite (LNil (A:=A)). +Proof. + intros A H;inversion H. +Qed. + +Lemma Finite_not_Infinite : forall (A:Set)(l:LList A), + Finite l -> ~ Infinite l. +Proof. + intros A l H; elim H. + apply LNil_not_Infinite. + intros a l0 F0 I0' I1. + case I0'; inversion_clear I1. + trivial. +Qed. + +Lemma Not_Finite_Infinite : forall (A:Set)(l:LList A), + ~ Finite l -> Infinite l. +Proof. + cofix H. + destruct l. + intro; absurd (Finite (LNil (A:=A)));[auto|constructor]. + constructor. + apply H. + red; intro H1;case H0. + constructor. + trivial. +Qed. + + + + diff --git a/test-suite/success/univers.v b/test-suite/success/univers.v index 0a4b284f..a619b8da 100644 --- a/test-suite/success/univers.v +++ b/test-suite/success/univers.v @@ -17,3 +17,24 @@ Lemma lem3 : (P:Prop)P. Intro P ; Pattern P. Apply lem2. Abort. + +(* Check managing of universe constraints in inversion *) +(* Bug report #855 *) + +Inductive dep_eq : (X:Type) X -> X -> Prop := + | intro_eq : (X:Type) (f:X)(dep_eq X f f) + | intro_feq : (A:Type) (B:A->Type) + let T = (x:A)(B x) in + (f, g:T) (x:A) + (dep_eq (B x) (f x) (g x)) -> + (dep_eq T f g). + +Require Import Relations. + +Theorem dep_eq_trans : (X:Type) (transitive X (dep_eq X)). +Proof. + Unfold transitive. + Intros X f g h H1 H2. + Inversion H1. +Abort. + diff --git a/theories/Arith/Arith.v b/theories/Arith/Arith.v index d44efb56..114a60ee 100755 --- a/theories/Arith/Arith.v +++ b/theories/Arith/Arith.v @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: Arith.v,v 1.11.2.1 2004/07/16 19:30:59 herbelin Exp $ i*) +(*i $Id: Arith.v,v 1.11.2.2 2004/08/03 17:42:42 herbelin Exp $ i*) Require Export Le. Require Export Lt. @@ -15,7 +15,6 @@ Require Export Gt. Require Export Minus. Require Export Mult. Require Export Between. -Require Export Minus. Require Export Peano_dec. Require Export Compare_dec. -Require Export Factorial. \ No newline at end of file +Require Export Factorial. diff --git a/theories/Init/Notations.v b/theories/Init/Notations.v index 2e7cb1fc..e0a18747 100644 --- a/theories/Init/Notations.v +++ b/theories/Init/Notations.v @@ -6,11 +6,11 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: Notations.v,v 1.24.2.1 2004/07/16 19:31:03 herbelin Exp $ i*) +(*i $Id: Notations.v,v 1.24.2.2 2004/08/01 09:36:44 herbelin Exp $ i*) -(** These are the notations whose level and associativity is imposed by Coq *) +(** These are the notations whose level and associativity are imposed by Coq *) -(** Notations for logical connectives *) +(** Notations for propositional connectives *) Reserved Notation "x <-> y" (at level 95, no associativity). Reserved Notation "x /\ y" (at level 80, right associativity). diff --git a/theories/Logic/Berardi.v b/theories/Logic/Berardi.v index 7e950c17..0fe8a87d 100644 --- a/theories/Logic/Berardi.v +++ b/theories/Logic/Berardi.v @@ -6,11 +6,11 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: Berardi.v,v 1.5.2.1 2004/07/16 19:31:06 herbelin Exp $ i*) +(*i $Id: Berardi.v,v 1.5.2.2 2004/08/03 17:42:43 herbelin Exp $ i*) (** This file formalizes Berardi's paradox which says that in the calculus of constructions, excluded middle (EM) and axiom of - choice (AC) implie proof irrelevenace (PI). + choice (AC) imply proof irrelevance (PI). Here, the axiom of choice is not necessary because of the use of inductive types. << @@ -156,4 +156,4 @@ intros not_true is_true. elim not_true; trivial. Qed. -End Berardis_paradox. \ No newline at end of file +End Berardis_paradox. diff --git a/theories/Logic/ChoiceFacts.v b/theories/Logic/ChoiceFacts.v index a1f4417c..87d8a70e 100644 --- a/theories/Logic/ChoiceFacts.v +++ b/theories/Logic/ChoiceFacts.v @@ -6,14 +6,14 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: ChoiceFacts.v,v 1.7.2.1 2004/07/16 19:31:06 herbelin Exp $ i*) +(*i $Id: ChoiceFacts.v,v 1.7.2.2 2004/08/01 09:29:59 herbelin Exp $ i*) -(* We show that the functional formulation of the axiom of Choice +(** We show that the functional formulation of the axiom of Choice (usual formulation in type theory) is equivalent to its relational formulation (only formulation of set theory) + the axiom of (parametric) definite description (aka axiom of unique choice) *) -(* This shows that the axiom of choice can be assumed (under its +(** This shows that the axiom of choice can be assumed (under its relational formulation) without known inconsistency with classical logic, though definite description conflicts with classical logic *) @@ -80,7 +80,7 @@ intro H; split; intros [H H0]; exact (description_rel_choice_imp_funct_choice H0 H). Qed. -(* We show that the guarded relational formulation of the axiom of Choice +(** We show that the guarded relational formulation of the axiom of Choice comes from the non guarded formulation in presence either of the independance of premises or proof-irrelevance *) diff --git a/theories/Logic/Diaconescu.v b/theories/Logic/Diaconescu.v index 55eed096..2b982963 100644 --- a/theories/Logic/Diaconescu.v +++ b/theories/Logic/Diaconescu.v @@ -6,9 +6,9 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: Diaconescu.v,v 1.5.2.1 2004/07/16 19:31:06 herbelin Exp $ i*) +(*i $Id: Diaconescu.v,v 1.5.2.3 2004/08/01 09:36:44 herbelin Exp $ i*) -(* R. Diaconescu [Diaconescu] showed that the Axiom of Choice in Set Theory +(** R. Diaconescu [Diaconescu] showed that the Axiom of Choice in Set Theory entails Excluded-Middle; S. Lacas and B. Werner [LacasWerner] adapted the proof to show that the axiom of choice in equivalence classes entails Excluded-Middle in Type Theory. @@ -27,12 +27,12 @@ Section PredExt_GuardRelChoice_imp_EM. -(* The axiom of extensionality for predicates *) +(** The axiom of extensionality for predicates *) Definition PredicateExtensionality := forall P Q:bool -> Prop, (forall b:bool, P b <-> Q b) -> P = Q. -(* From predicate extensionality we get propositional extensionality +(** From predicate extensionality we get propositional extensionality hence proof-irrelevance *) Require Import ClassicalFacts. @@ -54,7 +54,7 @@ Proof. apply (ext_prop_dep_proof_irrel_cic prop_ext). Qed. -(* From proof-irrelevance and relational choice, we get guarded +(** From proof-irrelevance and relational choice, we get guarded relational choice *) Require Import ChoiceFacts. @@ -73,8 +73,8 @@ Proof. (rel_choice_and_proof_irrel_imp_guarded_rel_choice rel_choice proof_irrel). Qed. -(* The form of choice we need: there is a functional relation which chooses - an element in any non empty subset of bool *) +(** The form of choice we need: there is a functional relation which chooses + an element in any non empty subset of bool *) Require Import Bool. @@ -90,30 +90,30 @@ Proof. exact (fun _ H => H). Qed. -(* The proof of the excluded middle *) -(* Remark: P could have been in Set or Type *) +(** The proof of the excluded middle *) +(** Remark: P could have been in Set or Type *) Theorem pred_ext_and_rel_choice_imp_EM : forall P:Prop, P \/ ~ P. Proof. intro P. -(* first we exhibit the choice functional relation R *) +(** first we exhibit the choice functional relation R *) destruct AC as [R H]. set (class_of_true := fun b => b = true \/ P). set (class_of_false := fun b => b = false \/ P). -(* the actual "decision": is (R class_of_true) = true or false? *) +(** the actual "decision": is (R class_of_true) = true or false? *) destruct (H class_of_true) as [b0 [H0 [H0' H0'']]]. exists true; left; reflexivity. destruct H0. -(* the actual "decision": is (R class_of_false) = true or false? *) +(** the actual "decision": is (R class_of_false) = true or false? *) destruct (H class_of_false) as [b1 [H1 [H1' H1'']]]. exists false; left; reflexivity. destruct H1. -(* case where P is false: (R class_of_true)=true /\ (R class_of_false)=false *) +(** case where P is false: (R class_of_true)=true /\ (R class_of_false)=false *) right. intro HP. assert (Hequiv : forall b:bool, class_of_true b <-> class_of_false b). @@ -129,7 +129,7 @@ rewrite <- H0''. reflexivity. rewrite Heq. assumption. -(* cases where P is true *) +(** cases where P is true *) left; assumption. left; assumption. diff --git a/theories/Logic/JMeq.v b/theories/Logic/JMeq.v index 5b7528be..4666d9b4 100644 --- a/theories/Logic/JMeq.v +++ b/theories/Logic/JMeq.v @@ -6,9 +6,16 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: JMeq.v,v 1.8.2.1 2004/07/16 19:31:06 herbelin Exp $ i*) +(*i $Id: JMeq.v,v 1.8.2.2 2004/08/03 17:42:32 herbelin Exp $ i*) -(** John Major's Equality as proposed by C. Mc Bride *) +(** John Major's Equality as proposed by C. Mc Bride + + Reference: + + [McBride] Elimination with a Motive, Proceedings of TYPES 2000, + LNCS 2277, pp 197-216, 2002. + +*) Set Implicit Arguments. @@ -65,4 +72,4 @@ Lemma eq_dep_JMeq : Proof. destruct 1. apply JMeq_refl. -Qed. \ No newline at end of file +Qed. diff --git a/theories/Logic/RelationalChoice.v b/theories/Logic/RelationalChoice.v index ca7b760e..08873aa5 100644 --- a/theories/Logic/RelationalChoice.v +++ b/theories/Logic/RelationalChoice.v @@ -6,9 +6,9 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: RelationalChoice.v,v 1.3.2.1 2004/07/16 19:31:06 herbelin Exp $ i*) +(*i $Id: RelationalChoice.v,v 1.3.2.2 2004/08/01 09:29:59 herbelin Exp $ i*) -(* This file axiomatizes the relational form of the axiom of choice *) +(** This file axiomatizes the relational form of the axiom of choice *) Axiom relational_choice : diff --git a/theories/ZArith/ZArith.v b/theories/ZArith/ZArith.v index 78295591..7e361621 100644 --- a/theories/ZArith/ZArith.v +++ b/theories/ZArith/ZArith.v @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: ZArith.v,v 1.5.2.1 2004/07/16 19:31:20 herbelin Exp $ i*) +(*i $Id: ZArith.v,v 1.5.2.2 2004/08/03 17:56:30 herbelin Exp $ i*) (** Library for manipulating integers based on binary encoding *) @@ -19,4 +19,3 @@ Require Export Zsqrt. Require Export Zpower. Require Export Zdiv. Require Export Zlogarithm. -Require Export Zbool. \ No newline at end of file diff --git a/tools/coq_makefile.ml4 b/tools/coq_makefile.ml4 index 4879e97d..02607f14 100644 --- a/tools/coq_makefile.ml4 +++ b/tools/coq_makefile.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coq_makefile.ml4,v 1.16.2.1 2004/07/16 19:31:45 herbelin Exp $ *) +(* $Id: coq_makefile.ml4,v 1.16.2.4 2005/01/12 16:00:19 sacerdot Exp $ *) (* créer un Makefile pour un développement Coq automatiquement *) @@ -81,7 +81,7 @@ coq_makefile [subdirectory] .... [file.v] ... [file.ml] ... [-custom let standard sds = print "byte:\n"; - print "\t$(MAKE) all \"OPT=\"\n\n"; + print "\t$(MAKE) all \"OPT=-byte\"\n\n"; print "opt:\n"; if !opt = "" then print "\t@echo \"WARNING: opt is disabled\"\n"; print "\t$(MAKE) all \"OPT="; print !opt; print "\"\n\n"; @@ -89,8 +89,8 @@ let standard sds = print ".depend depend:\n"; if !some_file then begin print "\trm -f .depend\n"; - print "\t$(COQDEP) -i $(COQLIBS) *.v *.ml *.mli >.depend\n"; - print "\t$(COQDEP) $(COQLIBS) -suffix .html *.v >>.depend\n"; + print "\t$(COQDEP) -i $(COQLIBS) $(VFILES) *.ml *.mli >.depend\n"; + print "\t$(COQDEP) $(COQLIBS) -suffix .html $(VFILES) >>.depend\n"; end; List.iter (fun x -> print "\t(cd "; print x; print " ; $(MAKE) depend)\n") @@ -98,7 +98,7 @@ let standard sds = print "\n"; print "install:\n"; print "\tmkdir -p `$(COQC) -where`/user-contrib\n"; - if !some_vfile then print "\tcp -f *.vo `$(COQC) -where`/user-contrib\n"; + if !some_vfile then print "\tcp -f $(VOFILES) `$(COQC) -where`/user-contrib\n"; if !some_mlfile then print "\tcp -f *.cmo `$(COQC) -where`/user-contrib\n"; List.iter (fun x -> print "\t(cd "; print x; print " ; $(MAKE) install)\n") @@ -115,7 +115,7 @@ let standard sds = print "\n"; end; print "clean:\n"; - print "\trm -f *.cmo *.cmi *.cmx *.o *.vo *.vi *.g *~\n"; + print "\trm -f *.cmo *.cmi *.cmx *.o $(VOFILES) $(VIFILES) $(GFILES) *~\n"; print "\trm -f all.ps all-gal.ps $(HTMLFILES) $(GHTMLFILES)\n"; List.iter (fun x -> print "\t(cd "; print x; print " ; $(MAKE) clean)\n") diff --git a/tools/coqdoc/index.mll b/tools/coqdoc/index.mll index 799825ad..875a2337 100644 --- a/tools/coqdoc/index.mll +++ b/tools/coqdoc/index.mll @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: index.mll,v 1.2.2.1 2004/07/16 19:31:46 herbelin Exp $ i*) +(*i $Id: index.mll,v 1.2.2.2 2004/08/03 17:31:04 herbelin Exp $ i*) { @@ -197,7 +197,7 @@ rule traverse = parse | "Variable" 's'? space { current_type := Variable; index_idents lexbuf; traverse lexbuf } ***i*) - | "Require" (space+ "Export")? space+ ident + | "Require" (space+ ("Export"|"Import"))? space+ ident { ref_module (lexeme_start lexbuf) (lexeme lexbuf); traverse lexbuf } | begin_hide { skip_hide lexbuf; traverse lexbuf } diff --git a/toplevel/class.ml b/toplevel/class.ml index 429469b1..f5493929 100644 --- a/toplevel/class.ml +++ b/toplevel/class.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: class.ml,v 1.44.2.2 2004/07/16 19:31:47 herbelin Exp $ *) +(* $Id: class.ml,v 1.44.2.3 2004/11/26 18:06:54 herbelin Exp $ *) open Util open Pp @@ -92,15 +92,13 @@ let explain_coercion_error g = function (* Verifications pour l'ajout d'une classe *) -let rec arity_sort a = match kind_of_term a with - | Sort (Prop _ | Type _) -> 0 - | Prod (_,_,c) -> (arity_sort c) +1 - | LetIn (_,_,_,c) -> arity_sort c (* Utile ?? *) - | Cast (c,_) -> arity_sort c +let rec arity_sort (ctx,a) = match kind_of_term a with + | Sort (Prop _ | Type _) -> List.length ctx | _ -> raise Not_found let check_reference_arity ref = - try arity_sort (Global.type_of_global ref) + let t = Global.type_of_global ref in + try arity_sort (Reductionops.splay_prod (Global.env()) Evd.empty t) with Not_found -> raise (CoercionError (NotAClass ref)) let check_arity = function diff --git a/toplevel/command.ml b/toplevel/command.ml index b9a47781..3da1c838 100644 --- a/toplevel/command.ml +++ b/toplevel/command.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: command.ml,v 1.116.2.1 2004/07/16 19:31:47 herbelin Exp $ *) +(* $Id: command.ml,v 1.116.2.3 2004/12/31 12:01:16 herbelin Exp $ *) open Pp open Util @@ -49,12 +49,12 @@ let rec abstract_rawconstr c = function List.fold_right (fun x b -> mkLambdaC([x],t,b)) idl (abstract_rawconstr c bl) -let rec prod_rawconstr c = function +let rec generalize_rawconstr c = function | [] -> c - | LocalRawDef (x,b)::bl -> mkLetInC(x,b,prod_rawconstr c bl) + | LocalRawDef (x,b)::bl -> mkLetInC(x,b,generalize_rawconstr c bl) | LocalRawAssum (idl,t)::bl -> List.fold_right (fun x b -> mkProdC([x],t,b)) idl - (prod_rawconstr c bl) + (generalize_rawconstr c bl) let rec destSubCast c = match kind_of_term c with | Lambda (x,t,c) -> @@ -103,12 +103,28 @@ let constant_entry_of_com (bl,com,comtypopt,opacity) = const_entry_type = Some typ; const_entry_opaque = opacity } -let red_constant_entry ce = function +let rec length_of_raw_binders = function + | [] -> 0 + | LocalRawDef _::bl -> 1 + length_of_raw_binders bl + | LocalRawAssum (idl,_)::bl -> List.length idl + length_of_raw_binders bl + +let rec under_binders env f n c = + if n = 0 then f env Evd.empty c else + match kind_of_term c with + | Lambda (x,t,c) -> + mkLambda (x,t,under_binders (push_rel (x,None,t) env) f (n-1) c) + | LetIn (x,b,t,c) -> + mkLetIn (x,b,t,under_binders (push_rel (x,Some b,t) env) f (n-1) c) + | _ -> assert false + +let red_constant_entry bl ce = function | None -> ce | Some red -> let body = ce.const_entry_body in { ce with const_entry_body = - reduction_of_redexp red (Global.env()) Evd.empty body } + under_binders (Global.env()) (reduction_of_redexp red) + (length_of_raw_binders bl) + body } let declare_global_definition ident ce local = let (_,kn) = declare_constant ident (DefinitionEntry ce,IsDefinition) in @@ -119,9 +135,7 @@ let declare_global_definition ident ce local = let declare_definition ident (local,_) bl red_option c typopt hook = let ce = constant_entry_of_com (bl,c,typopt,false) in - if bl<>[] && red_option <> None then - error "Evaluation under a local context not supported"; - let ce' = red_constant_entry ce red_option in + let ce' = red_constant_entry bl ce red_option in let r = match local with | Local when Lib.sections_are_opened () -> let c = @@ -168,7 +182,7 @@ let declare_one_assumption is_coe (local,kind) c (_,ident) = if is_coe then Class.try_add_new_coercion r local let declare_assumption idl is_coe k bl c = - let c = prod_rawconstr c bl in + let c = generalize_rawconstr c bl in let c = interp_type Evd.empty (Global.env()) c in List.iter (declare_one_assumption is_coe k c) idl @@ -458,7 +472,7 @@ let build_recursive (lnameargsardef:(fixpoint_expr *decl_notation) list) = let (rec_sign,rec_impls,arityl) = List.fold_left (fun (env,impls,arl) ((recname,_,bl,arityc,_),_) -> - let arityc = prod_rawconstr arityc bl in + let arityc = generalize_rawconstr arityc bl in let arity = interp_type sigma env0 arityc in let impl = if Impargs.is_implicit_args() @@ -479,7 +493,7 @@ let build_recursive (lnameargsardef:(fixpoint_expr *decl_notation) list) = let def = try List.iter (fun (df,c,scope) -> (* No scope for tmp notation *) - Metasyntax.add_notation_interpretation df [] c None) notations; + Metasyntax.add_notation_interpretation df rec_impls c None) notations; List.map2 (fun ((_,_,bl,_,def),_) arity -> let def = abstract_rawconstr def bl in @@ -533,7 +547,7 @@ let build_corecursive lnameardef = try List.fold_left (fun (env,arl) (recname,bl,arityc,_) -> - let arityc = prod_rawconstr arityc bl in + let arityc = generalize_rawconstr arityc bl in let arj = type_judgment_of_rawconstr Evd.empty env0 arityc in let arity = arj.utj_val in let _ = declare_variable recname @@ -546,7 +560,7 @@ let build_corecursive lnameardef = let recdef = try List.map (fun (_,bl,arityc,def) -> - let arityc = prod_rawconstr arityc bl in + let arityc = generalize_rawconstr arityc bl in let def = abstract_rawconstr def bl in let arity = interp_constr sigma rec_sign arityc in interp_casted_constr sigma rec_sign def arity) @@ -610,13 +624,6 @@ let build_scheme lnamedepindsort = let lrecref = List.fold_right2 declare listdecl lrecnames [] in if_verbose ppnl (recursive_message (Array.of_list lrecref)) -let rec generalize_rawconstr c = function - | [] -> c - | LocalRawDef (id,b)::bl -> mkLetInC(id,b,generalize_rawconstr c bl) - | LocalRawAssum (idl,t)::bl -> - List.fold_right (fun x b -> mkProdC([x],t,b)) idl - (generalize_rawconstr c bl) - let start_proof id kind c hook = let sign = Global.named_context () in let sign = clear_proofs sign in diff --git a/toplevel/coqtop.ml b/toplevel/coqtop.ml index aa765b16..83d240a1 100644 --- a/toplevel/coqtop.ml +++ b/toplevel/coqtop.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coqtop.ml,v 1.72.2.3 2004/07/16 19:31:47 herbelin Exp $ *) +(* $Id: coqtop.ml,v 1.72.2.4 2004/09/03 15:05:23 herbelin Exp $ *) open Pp open Util @@ -68,7 +68,7 @@ let set_outputstate s = outputstate:=s let outputstate () = if !outputstate <> "" then extern_state !outputstate let check_coq_overwriting p = - if string_of_id (List.hd (repr_dirpath p)) = "Coq" then + if string_of_id (list_last (repr_dirpath p)) = "Coq" then error "The \"Coq\" logical root directory is reserved for the Coq library" let set_include d p = push_include (d,p) diff --git a/toplevel/himsg.ml b/toplevel/himsg.ml index de341bd9..beb80d03 100644 --- a/toplevel/himsg.ml +++ b/toplevel/himsg.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: himsg.ml,v 1.86.2.2 2004/07/16 19:31:49 herbelin Exp $ *) +(* $Id: himsg.ml,v 1.86.2.4 2004/12/03 18:45:53 herbelin Exp $ *) open Pp open Util @@ -73,12 +73,16 @@ let explain_reference_variables c = str "the constant" ++ spc () ++ pc ++ spc () ++ str "refers to variables which are not in the context" +let rec pr_disjunction pr = function + | [a] -> pr a + | [a;b] -> pr a ++ str " or" ++ spc () ++ pr b + | a::l -> pr a ++ str "," ++ spc () ++ pr_disjunction pr l + | [] -> assert false + let explain_elim_arity ctx ind aritylst c pj okinds = let ctx = make_all_name_different ctx in let pi = pr_inductive ctx ind in - let ppar = prlist_with_sep pr_coma (prterm_env ctx) aritylst in let pc = prterm_env ctx c in - let pp = prterm_env ctx pj.uj_val in let ppt = prterm_env ctx pj.uj_type in let msg = match okinds with | Some(kp,ki,explanation) -> @@ -86,26 +90,41 @@ let explain_elim_arity ctx ind aritylst c pj okinds = let pkp = prterm_env ctx kp in let explanation = match explanation with | NonInformativeToInformative -> - "non-informative objects may not construct informative ones." + "proofs can be eliminated only to build proofs" | StrongEliminationOnNonSmallType -> "strong elimination on non-small inductive types leads to paradoxes." | WrongArity -> "wrong arity" in (hov 0 - (fnl () ++ str "Elimination of an inductive object of sort : " ++ + (fnl () ++ str "Elimination of an inductive object of sort " ++ pki ++ brk(1,0) ++ - str "is not allowed on a predicate in sort : " ++ pkp ++fnl () ++ + str "is not allowed on a predicate in sort " ++ pkp ++fnl () ++ str "because" ++ spc () ++ str explanation)) | None -> mt () in - str "Incorrect elimination of" ++ brk(1,1) ++ pc ++ spc () ++ - str "in the inductive type" ++ brk(1,1) ++ pi ++ fnl () ++ - str "The elimination predicate" ++ brk(1,1) ++ pp ++ spc () ++ - str "has type" ++ brk(1,1) ++ ppt ++ fnl () ++ - str "It should be one of :" ++ brk(1,1) ++ hov 0 ppar ++ fnl () ++ - msg - + hov 0 ( + str "Incorrect elimination of" ++ spc() ++ pc ++ spc () ++ + str "in the inductive type " ++ spc() ++ quote pi ++ + (if !Options.v7 then + let pp = prterm_env ctx pj.uj_val in + let ppar = pr_disjunction (prterm_env ctx) aritylst in + let ppt = prterm_env ctx pj.uj_type in + fnl () ++ + str "The elimination predicate" ++ brk(1,1) ++ pp ++ spc () ++ + str "has arity" ++ brk(1,1) ++ ppt ++ fnl () ++ + str "It should be " ++ brk(1,1) ++ ppar + else + let sorts = List.map (fun x -> mkSort (new_sort_in_family x)) + (list_uniquize (List.map (fun ar -> + family_of_sort (destSort (snd (decompose_prod_assum ar)))) aritylst)) in + let ppar = pr_disjunction (prterm_env ctx) sorts in + let ppt = prterm_env ctx (snd (decompose_prod_assum pj.uj_type)) in + str "," ++ spc() ++ str "the return type has sort" ++ spc() ++ ppt ++ + spc () ++ str "while it should be " ++ ppar)) + ++ fnl () ++ msg + + let explain_case_not_inductive ctx cj = let ctx = make_all_name_different ctx in let pc = prterm_env ctx cj.uj_val in @@ -322,13 +341,12 @@ let explain_hole_kind env = function str "a type for " ++ Nameops.pr_id id | BinderType Anonymous -> str "a type for this anonymous binder" - | ImplicitArg (c,n) -> + | ImplicitArg (c,(n,ido)) -> if !Options.v7 then str "the " ++ pr_ord n ++ str " implicit argument of " ++ Nametab.pr_global_env Idset.empty c else - let imps = Impargs.implicits_of_global c in - let id = Impargs.name_of_implicit (List.nth imps (n-1)) in + let id = out_some ido in str "an instance for the implicit parameter " ++ pr_id id ++ spc () ++ str "of" ++ spc () ++ Nametab.pr_global_env Idset.empty c diff --git a/toplevel/metasyntax.ml b/toplevel/metasyntax.ml index 84bda0af..ca64cda0 100644 --- a/toplevel/metasyntax.ml +++ b/toplevel/metasyntax.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: metasyntax.ml,v 1.105.2.2 2004/07/16 19:31:49 herbelin Exp $ *) +(* $Id: metasyntax.ml,v 1.105.2.6 2004/11/22 12:41:38 herbelin Exp $ *) open Pp open Util @@ -606,6 +606,41 @@ let make_hunks etyps symbols from = in make NoBreak symbols +let error_format () = error "The format does not match the notation" + +let rec split_format_at_ldots hd = function + | UnpTerminal s :: fmt when id_of_string s = ldots_var -> List.rev hd, fmt + | u :: fmt -> + check_no_ldots_in_box u; + split_format_at_ldots (u::hd) fmt + | [] -> raise Exit + +and check_no_ldots_in_box = function + | UnpBox (_,fmt) -> + (try + let _ = split_format_at_ldots [] fmt in + error ("The special symbol \"..\" must occur at the same formatting depth than the variables of which it is the ellipse") + with Exit -> ()) + | _ -> () + +let skip_var_in_recursive_format = function + | UnpTerminal _ :: sl (* skip first var *) -> + (* To do, though not so important: check that the names match + the names in the notation *) + sl + | _ -> error_format () + +let read_recursive_format sl fmt = + let get_head fmt = + let sl = skip_var_in_recursive_format fmt in + try split_format_at_ldots [] sl with Exit -> error_format () in + let rec get_tail = function + | a :: sepfmt, b :: fmt when a = b -> get_tail (sepfmt, fmt) + | [], tail -> skip_var_in_recursive_format tail + | _ -> error "The format is not the same on the right and left hand side of the special token \"..\"" in + let slfmt, fmt = get_head fmt in + slfmt, get_tail (slfmt, fmt) + let hunks_of_format (from,(vars,typs) as vt) symfmt = let rec aux = function | symbs, (UnpTerminal s' as u) :: fmt @@ -624,12 +659,20 @@ let hunks_of_format (from,(vars,typs) as vt) symfmt = symbs', UnpBox (a,b') :: l | symbs, (UnpCut _ as u) :: fmt -> let symbs, l = aux (symbs,fmt) in symbs, u :: l + | SProdList (m,sl) :: symbs, fmt -> + let i = list_index m vars in + let _,prec = precedence_of_entry_type from (List.nth typs (i-1)) in + let slfmt,fmt = read_recursive_format sl fmt in + let sl, slfmt = aux (sl,slfmt) in + if sl <> [] then error_format (); + let symbs, l = aux (symbs,fmt) in + symbs, UnpListMetaVar (i,prec,slfmt) :: l | symbs, [] -> symbs, [] - | _, _ -> error "The format does not match the notation" + | _, _ -> error_format () in match aux symfmt with | [], l -> l - | _ -> error "The format does not match the notation" + | _ -> error_format () let string_of_prec (n,p) = (string_of_int n)^(match p with E -> "E" | L -> "L" | _ -> "") @@ -708,13 +751,6 @@ let recompute_assoc typs = | _, Some Gramext.RightA -> Some Gramext.RightA | _ -> None -let rec expand_squash = function - | Term ("","{") :: NonTerm (ETConstr _, n) :: Term ("","}") :: l -> - NonTerm (ETConstr (NextLevel,InternalProd),n) - :: expand_squash l - | a :: l -> a :: expand_squash l - | [] -> [] - let make_grammar_rule n typs symbols ntn perm = let assoc = recompute_assoc typs in let prod = make_production typs symbols in @@ -777,7 +813,7 @@ let pr_level ntn (from,args) = str "at level " ++ int from ++ spc () ++ str "with arguments" ++ spc() ++ prlist_with_sep pr_coma (pr_arg_level from) args -let cache_syntax_extension (_,(_,(prec,prec8),ntn,gr,se)) = +let cache_syntax_extension (_,(_,((prec,prec8),ntn,gr,se))) = try let oldprec, oldprec8 = Symbols.level_of_notation ntn in if prec8 <> oldprec8 & (Options.do_translate () or not !Options.v7) then @@ -799,13 +835,14 @@ let cache_syntax_extension (_,(_,(prec,prec8),ntn,gr,se)) = warning ("Notation "^ntn^ " was already assigned a different level or sublevels"); if oldprec = None or out_some oldprec <> out_some prec then - Egrammar.extend_grammar (Egrammar.Notation (out_some gr)) + Egrammar.extend_grammar (Egrammar.Notation (out_some prec,out_some gr)) end with Not_found -> (* Reserve the notation level *) Symbols.declare_notation_level ntn (prec,prec8); (* Declare the parsing rule *) - option_iter (fun gr -> Egrammar.extend_grammar (Egrammar.Notation gr)) gr; + option_iter (fun gr -> + Egrammar.extend_grammar (Egrammar.Notation (out_some prec,gr))) gr; (* Declare the printing rule *) Symbols.declare_notation_printing_rule ntn (se,fst prec8) @@ -813,15 +850,15 @@ let subst_notation_grammar subst x = x let subst_printing_rule subst x = x -let subst_syntax_extension (_,subst,(local,prec,ntn,gr,se)) = - (local,prec,ntn, +let subst_syntax_extension (_,subst,(local,(prec,ntn,gr,se))) = + (local,(prec,ntn, option_app (subst_notation_grammar subst) gr, - subst_printing_rule subst se) + subst_printing_rule subst se)) -let classify_syntax_definition (_,(local,_,_,_,_ as o)) = +let classify_syntax_definition (_,(local,_ as o)) = if local then Dispose else Substitute o -let export_syntax_definition (local,_,_,_,_ as o) = +let export_syntax_definition (local,_ as o) = if local then None else Some o let (inSyntaxExtension, outSyntaxExtension) = @@ -897,6 +934,10 @@ let check_rule_reversibility l = if List.for_all (function NonTerminal _ -> true | _ -> false) l then error "A notation must include at least one symbol" +let is_not_printable = function + | AVar _ -> warning "This notation won't be used for printing as it is bound to a \nsingle variable"; true + | _ -> false + let find_precedence_v7 lev etyps symbols = (match symbols with | NonTerminal x :: _ -> @@ -1010,7 +1051,7 @@ let add_syntax_extension local mv mv8 = let ntn' = match data with Some ((_,_,_,_,ntn),_,_,_) -> ntn | _ -> ntn in let pp_rule = make_pp_rule ppdata in Lib.add_anonymous_leaf - (inSyntaxExtension (local,(prec,ppprec),ntn',gram_rule,pp_rule)) + (inSyntaxExtension (local,((prec,ppprec),ntn',gram_rule,pp_rule))) (**********************************************************************) (* Distfix, Infix, Symbols *) @@ -1139,33 +1180,38 @@ let add_notation_in_scope local df c mods omodv8 scope toks = let gram_rule = make_grammar_rule n typs symbols ntn permut in Lib.add_anonymous_leaf (inSyntaxExtension - (local,(Some prec,ppprec),ntn,Some gram_rule,pp_rule)); + (local,((Some prec,ppprec),ntn,Some gram_rule,pp_rule))); (* Declare interpretation *) let (acvars,ac) = interp_aconstr [] ppvars c in let a = (remove_vars pprecvars acvars,ac) (* For recursive parts *) in let old_pp_rule = (* Used only by v7; disable if contains a recursive pattern *) - if onlyparse or pprecvars <> [] then None + if onlyparse or pprecvars <> [] or not (!Options.v7) then None else let r = interp_global_rawconstr_with_vars vars c in Some (make_old_pp_rule n symbols typs r intnot scope vars) in - let onlyparse = onlyparse or !Options.v7_only in + let onlyparse = onlyparse or !Options.v7_only or is_not_printable ac in Lib.add_anonymous_leaf (inNotation(local,old_pp_rule,intnot,scope,a,onlyparse,false,df')) let level_rule (n,p) = if p = E then n else max (n-1) 0 -let check_notation_existence notation = - try - let a,_ = Symbols.level_of_notation (contract_notation notation) in - if a = None then raise Not_found - with Not_found -> - error "Parsing rule for this notation has to be previously declared" +let recover_syntax ntn = + try + match Symbols.level_of_notation ntn with + | (Some prec,_ as pprec) -> + let rule,_ = Symbols.find_notation_printing_rule ntn in + let gr = Egrammar.recover_notation_grammar ntn prec in + Some (pprec,ntn,Some gr,rule) + | None,_ -> None + with Not_found -> None -let exists_notation_syntax ntn = - try fst (Symbols.level_of_notation (contract_notation ntn)) <> None - with Not_found -> false +let recover_notation_syntax rawntn = + let ntn = contract_notation rawntn in + match recover_syntax ntn with + | None -> None + | Some gr -> Some (gr,if ntn=rawntn then None else recover_syntax "{ _ }") let set_data_for_v7_pp recs a vars = if not !Options.v7 then None else @@ -1185,34 +1231,44 @@ let build_old_pp_rule notation scope symbs (r,vars) = make_old_pp_rule (fst prec) symbs typs r notation scope vars let add_notation_interpretation_core local symbs for_old df a scope onlyparse - onlypp = + onlypp gram_data = let notation = make_notation_key symbs in let old_pp_rule = if !Options.v7 then option_app (build_old_pp_rule notation scope symbs) for_old else None in + option_iter + (fun (x,y) -> + Lib.add_anonymous_leaf (inSyntaxExtension (local,x)); + option_iter + (fun z -> Lib.add_anonymous_leaf (inSyntaxExtension (local,z))) y) + gram_data; Lib.add_anonymous_leaf (inNotation(local,old_pp_rule,notation,scope,a,onlyparse,onlypp, (Lib.library_dp(),df))) let add_notation_interpretation df names c sc = let (recs,vars,symbs) = analyse_notation_tokens (split_notation_string df) in - check_notation_existence (make_notation_key symbs); + let gram_data = recover_notation_syntax (make_notation_key symbs) in + if gram_data = None then + error "Parsing rule for this notation has to be previously declared"; let (acvars,ac) = interp_aconstr names vars c in let a = (remove_vars recs acvars,ac) (* For recursive parts *) in let a_for_old = interp_rawconstr_with_implicits Evd.empty (Global.env()) vars names c in let for_oldpp = set_data_for_v7_pp recs a_for_old vars in - add_notation_interpretation_core false symbs for_oldpp df a sc false false + let onlyparse = is_not_printable ac in + add_notation_interpretation_core false symbs for_oldpp df a sc onlyparse + false gram_data let add_notation_in_scope_v8only local df c mv8 scope toks = let (_,recs,vars,intnot,notation),prec,ppdata,df' = compute_syntax_data false (df,mv8) in let pp_rule = make_pp_rule ppdata in Lib.add_anonymous_leaf - (inSyntaxExtension(local,(None,prec),notation,None,pp_rule)); + (inSyntaxExtension(local,((None,prec),notation,None,pp_rule))); (* Declare the interpretation *) - let onlyparse = false in let (acvars,ac) = interp_aconstr [] vars c in let a = (remove_vars recs acvars,ac) (* For recursive parts *) in + let onlyparse = is_not_printable ac in Lib.add_anonymous_leaf (inNotation(local,None,intnot,scope,a,onlyparse,true,df')) @@ -1231,11 +1287,12 @@ let add_notation_v8only local c (df,modifiers) sc = else (* Declare only interpretation *) let (recs,vars,symbs) = analyse_notation_tokens toks in - let onlyparse = modifiers = [SetOnlyParsing] in let (acvars,ac) = interp_aconstr [] vars c in + let onlyparse = modifiers = [SetOnlyParsing] + or is_not_printable ac in let a = (remove_vars recs acvars,ac) in add_notation_interpretation_core local symbs None df a sc - onlyparse true + onlyparse true None | Some n -> (* Declare both syntax and interpretation *) let mods = @@ -1266,14 +1323,17 @@ let add_notation local c dfmod mv8 sc = else (* Declare only interpretation *) let (recs,vars,symbs) = analyse_notation_tokens toks in - if exists_notation_syntax (make_notation_key symbs) then - let onlyparse = modifiers = [SetOnlyParsing] in + let gram_data = + recover_notation_syntax (make_notation_key symbs) in + if gram_data <> None then let (acvars,ac) = interp_aconstr [] vars c in let a = (remove_vars recs acvars,ac) in + let onlyparse = modifiers = [SetOnlyParsing] + or is_not_printable ac in let a_for_old = interp_global_rawconstr_with_vars vars c in let for_old = set_data_for_v7_pp recs a_for_old vars in add_notation_interpretation_core local symbs for_old df a - sc onlyparse false + sc onlyparse false gram_data else add_notation_in_scope local df c modifiers mv8 sc toks | Some n -> @@ -1340,7 +1400,7 @@ let add_infix local (inf,modl) pr mv8 sc = let a' = (remove_vars recs acvars,ac) in let a_for_old = interp_global_rawconstr_with_vars vars a in add_notation_interpretation_core local symbs None df a' sc - onlyparse true + onlyparse true None else if n8 = None then error "Needs a level" else let mv8 = match a8 with None -> SetAssoc Gramext.NonA :: mv8 |_ -> mv8 in @@ -1365,13 +1425,14 @@ let add_infix local (inf,modl) pr mv8 sc = (* de ne déclarer que l'interprétation *) (* Declare only interpretation *) let (recs,vars,symbs) = analyse_notation_tokens toks in - if exists_notation_syntax (make_notation_key symbs) then + let gram_data = recover_notation_syntax (make_notation_key symbs) in + if gram_data <> None then let (acvars,ac) = interp_aconstr [] vars a in let a' = (remove_vars recs acvars,ac) in let a_for_old = interp_global_rawconstr_with_vars vars a in let for_old = set_data_for_v7_pp recs a_for_old vars in add_notation_interpretation_core local symbs for_old df a' sc - onlyparse false + onlyparse false gram_data else let mv,mv8 = make_infix_data n assoc modl mv8 in add_notation_in_scope local df a mv mv8 sc toks diff --git a/toplevel/recordobj.mli b/toplevel/recordobj.mli index 8ea39767..91550c34 100755 --- a/toplevel/recordobj.mli +++ b/toplevel/recordobj.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: recordobj.mli,v 1.7.6.1 2004/07/16 19:31:49 herbelin Exp $ *) +(*i $Id: recordobj.mli,v 1.7.6.2 2005/01/21 17:18:33 herbelin Exp $ i*) val objdef_declare : Libnames.global_reference -> unit val add_object_hook : Tacexpr.declaration_hook diff --git a/toplevel/usage.ml b/toplevel/usage.ml index 9fe8b280..b00cfffc 100644 --- a/toplevel/usage.ml +++ b/toplevel/usage.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: usage.ml,v 1.15.2.1 2004/07/16 19:31:50 herbelin Exp $ *) +(* $Id: usage.ml,v 1.15.2.2 2004/09/03 14:35:26 herbelin Exp $ *) let version () = Printf.printf "The Coq Proof Assistant, version %s (%s)\n" @@ -23,7 +23,7 @@ let print_usage_channel co command = " -I dir add directory dir in the include path -include dir (idem) -R dir coqdir recursively map physical dir to logical coqdir - -src add source directories in the include path + -top coqdir set the toplevel name to be coqdir instead of Top -inputstate f read state from file f.coq -is f (idem) @@ -35,14 +35,14 @@ let print_usage_channel co command = -load-vernac-source f load Coq file f.v (Load f.) -l f (idem) -load-vernac-source-verbose f load Coq file f.v (Load Verbose f.) - -lv f (idem) + -lv f (idem) -load-vernac-object f load Coq object file f.vo -require f load Coq object file f.vo and import it (Require f.) -compile f compile Coq file f.v (implies -batch) -compile-verbose f verbosely compile Coq file f.v (implies -batch) - -opt run the native-code version of Coq or Coq_SearchIsos - -byte run the bytecode version of Coq or Coq_SearchIsos + -opt run the native-code version of Coq + -byte run the bytecode version of Coq -where print Coq's standard library location and exit -v print Coq version and exit @@ -59,6 +59,9 @@ let print_usage_channel co command = -xml export XML files either to the hierarchy rooted in the directory $COQ_XML_LIBRARY_ROOT (if set) or to stdout (if unset) + -quality improve the legibility of the proof terms produced by + some tactics + -h, --help print this list of options " (* print the usage on standard error *) @@ -72,5 +75,6 @@ let print_usage_coqc () = print_usage "Usage: coqc file...\n options are: -verbose compile verbosely + -bindir override the default directory where coqc looks for coqtop -image f specify an alternative executable for Coq -t keep temporary files\n\n" diff --git a/toplevel/vernacentries.mli b/toplevel/vernacentries.mli index a359b4a1..89e0d708 100644 --- a/toplevel/vernacentries.mli +++ b/toplevel/vernacentries.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: vernacentries.mli,v 1.16.2.1 2004/07/16 19:31:50 herbelin Exp $ i*) +(*i $Id: vernacentries.mli,v 1.16.2.2 2005/01/21 16:41:52 herbelin Exp $ i*) (*i*) open Names @@ -27,11 +27,11 @@ val show_node : unit -> unit in the context of the current goal, as for instance in pcoq *) val get_current_context_of_args : int option -> Evd.evar_map * Environ.env +(*i (* this function is used to analyse the extra arguments in search commands. It is used in pcoq. *) (*i anciennement: inside_outside i*) -(* val interp_search_restriction : search_restriction -> dir_path list * bool -*) +i*) type pcoq_hook = { start_proof : unit -> unit; diff --git a/toplevel/vernacexpr.ml b/toplevel/vernacexpr.ml index e1525c17..382434dc 100644 --- a/toplevel/vernacexpr.ml +++ b/toplevel/vernacexpr.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: vernacexpr.ml,v 1.55.2.1 2004/07/16 19:31:50 herbelin Exp $ *) +(*i $Id: vernacexpr.ml,v 1.55.2.2 2005/01/21 17:14:10 herbelin Exp $ i*) open Util open Names diff --git a/translate/ppconstrnew.ml b/translate/ppconstrnew.ml index 7d2feaf2..f75f767d 100644 --- a/translate/ppconstrnew.ml +++ b/translate/ppconstrnew.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppconstrnew.ml,v 1.62.2.2 2004/07/16 20:48:17 herbelin Exp $ *) +(* $Id: ppconstrnew.ml,v 1.62.2.4 2004/12/29 10:17:11 herbelin Exp $ *) (*i*) open Ast @@ -367,28 +367,31 @@ let rec split_fix n typ def = let (bl,typ,def) = split_fix (n-1) typ def in (LocalRawAssum ([na],t)::bl,typ,def) -let pr_recursive_decl pr id bl annot t c = +let pr_recursive_decl pr pr_dangling dangling_with_for id bl annot t c = + let pr_body = + if dangling_with_for then pr_dangling else pr in pr_id id ++ str" " ++ hov 0 (pr_undelimited_binders (pr ltop) bl ++ annot) ++ pr_opt_type_spc pr t ++ str " :=" ++ - pr_sep_com (fun () -> brk(1,2)) (pr ltop) c + pr_sep_com (fun () -> brk(1,2)) (pr_body ltop) c -let pr_fixdecl pr (id,n,bl,t,c) = +let pr_fixdecl pr prd dangling_with_for (id,n,bl,t,c) = let annot = let ids = names_of_local_assums bl in if List.length ids > 1 then spc() ++ str "{struct " ++ pr_name (snd (List.nth ids n)) ++ str"}" else mt() in - pr_recursive_decl pr id bl annot t c + pr_recursive_decl pr prd dangling_with_for id bl annot t c -let pr_cofixdecl pr (id,bl,t,c) = - pr_recursive_decl pr id bl (mt()) t c +let pr_cofixdecl pr prd dangling_with_for (id,bl,t,c) = + pr_recursive_decl pr prd dangling_with_for id bl (mt()) t c let pr_recursive pr_decl id = function | [] -> anomaly "(co)fixpoint with no definition" - | [d1] -> pr_decl d1 + | [d1] -> pr_decl false d1 | dl -> - prlist_with_sep (fun () -> fnl() ++ str "with ") pr_decl dl ++ + prlist_with_sep (fun () -> fnl() ++ str "with ") + (pr_decl true) dl ++ fnl() ++ str "for " ++ pr_id id let pr_arg pr x = spc () ++ pr x @@ -462,16 +465,15 @@ let rec pr sep inherited a = let (strm,prec) = match a with | CRef r -> pr_reference r, latom | CFix (_,id,fix) -> - let p = hov 0 (str"fix " ++ - pr_recursive (pr_fixdecl (pr mt)) (snd id) fix) in - if List.length fix = 1 & prec_less (fst inherited) ltop - then surround p, latom else p, lfix + hov 0 (str"fix " ++ + pr_recursive + (pr_fixdecl (pr mt) (pr_dangling_with_for mt)) (snd id) fix), + lfix | CCoFix (_,id,cofix) -> - let p = - hov 0 (str "cofix " ++ - pr_recursive (pr_cofixdecl (pr mt)) (snd id) cofix) in - if List.length cofix = 1 & prec_less (fst inherited) ltop - then surround p, latom else p, lfix + hov 0 (str "cofix " ++ + pr_recursive + (pr_cofixdecl (pr mt) (pr_dangling_with_for mt)) (snd id) cofix), + lfix | CArrow (_,a,b) -> hov 0 (pr mt (larrow,L) a ++ str " ->" ++ pr (fun () ->brk(1,0)) (-larrow,E) b), @@ -530,8 +532,9 @@ let rec pr sep inherited a = v 0 (hv 0 (str "match" ++ brk (1,2) ++ hov 0 ( - prlist_with_sep sep_v (pr_case_item (pr mt)) c - ++ pr_case_type (pr mt) rtntypopt) ++ + prlist_with_sep sep_v + (pr_case_item (pr_dangling_with_for mt)) c + ++ pr_case_type (pr_dangling_with_for mt) rtntypopt) ++ spc () ++ str "with") ++ prlist (pr_eqn (pr mt)) eqns ++ spc() ++ str "end"), latom @@ -579,7 +582,7 @@ let rec pr sep inherited a = hv 0 ( str (if style=MatchStyle then "old_match " else "match ") ++ pr mt ltop c ++ - pr_return_type (pr mt) po ++ + pr_return_type (pr_dangling_with_for mt) po ++ str " with" ++ brk (1,0) ++ hov 0 (prlist (fun b -> str "| ??? =>" ++ pr spc ltop b ++ fnl ()) bl) ++ @@ -604,6 +607,11 @@ let rec pr sep inherited a = pr_with_comments loc (sep() ++ if prec_less prec inherited then strm else surround strm) +and pr_dangling_with_for sep inherited a = + match a with + | (CFix (_,_,[_])|CCoFix(_,_,[_])) -> pr sep (latom,E) a + | _ -> pr sep inherited a + let pr = pr mt let rec abstract_constr_expr c = function @@ -768,8 +776,7 @@ let pr_red_expr (pr_constr,pr_lconstr,pr_ref) = function pr_arg (prlist_with_sep pr_coma (pr_pattern_occ pr_constr)) l) | Red true -> error "Shouldn't be accessible from user" - | ExtraRedExpr (s,c) -> - hov 1 (str s ++ pr_arg pr_constr c) + | ExtraRedExpr s -> str s let rec pr_may_eval test prc prlc pr2 = function | ConstrEval (r,c) -> diff --git a/translate/ppconstrnew.mli b/translate/ppconstrnew.mli index 4477728c..4a488499 100644 --- a/translate/ppconstrnew.mli +++ b/translate/ppconstrnew.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppconstrnew.mli,v 1.16.2.1 2004/07/16 19:31:52 herbelin Exp $ *) +(*i $Id: ppconstrnew.mli,v 1.16.2.2 2005/01/21 17:17:20 herbelin Exp $ i*) open Pp open Environ diff --git a/translate/pptacticnew.mli b/translate/pptacticnew.mli index 2558413f..b49b9e56 100644 --- a/translate/pptacticnew.mli +++ b/translate/pptacticnew.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: pptacticnew.mli,v 1.6.2.1 2004/07/16 19:31:52 herbelin Exp $ *) +(*i $Id: pptacticnew.mli,v 1.6.2.3 2005/01/21 17:17:20 herbelin Exp $ i*) open Pp open Genarg @@ -17,6 +17,8 @@ open Names val qsnew : string -> std_ppcmds +val pr_intro_pattern : intro_pattern_expr -> std_ppcmds + val pr_raw_tactic : Environ.env -> raw_tactic_expr -> std_ppcmds val pr_glob_tactic : Environ.env -> glob_tactic_expr -> std_ppcmds diff --git a/translate/ppvernacnew.ml b/translate/ppvernacnew.ml index 246253eb..bfcbee43 100644 --- a/translate/ppvernacnew.ml +++ b/translate/ppvernacnew.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppvernacnew.ml,v 1.95.2.2 2004/07/16 20:48:17 herbelin Exp $ *) +(* $Id: ppvernacnew.ml,v 1.95.2.3 2004/10/12 10:10:29 herbelin Exp $ *) open Pp open Names @@ -622,7 +622,7 @@ let rec pr_vernac = function hov 1 (pr_thm_token ki ++ spc() ++ pr_lident id ++ spc() ++ (match bl with | [] -> mt() - | _ -> error "Statements with local binders no longer supported") + | _ -> pr_binders bl ++ spc()) ++ str":" ++ pr_spc_type (rename_bound_variables (snd id) c)) | VernacEndProof Admitted -> str"Admitted" | VernacEndProof (Proved (opac,o)) -> (match o with diff --git a/translate/ppvernacnew.mli b/translate/ppvernacnew.mli index 73101a1a..4506b811 100644 --- a/translate/ppvernacnew.mli +++ b/translate/ppvernacnew.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppvernacnew.mli,v 1.3.2.1 2004/07/16 19:31:52 herbelin Exp $ *) +(*i $Id: ppvernacnew.mli,v 1.3.2.2 2005/01/21 17:17:20 herbelin Exp $ i*) open Pp open Genarg -- cgit v1.2.3