(************************************************************************) (* * The Rocq Prover / The Rocq Development Team *) (* v * Copyright INRIA, CNRS and contributors *) (* Pp.t val fnl2 : unit -> Pp.t val space_if : bool -> Pp.t val pp_par : bool -> Pp.t -> Pp.t (** [pp_apply] : a head part applied to arguments, possibly with parenthesis *) val pp_apply : Pp.t -> bool -> Pp.t list -> Pp.t (** Same as [pp_apply], but with also protection of the head by parenthesis *) val pp_apply2 : Pp.t -> bool -> Pp.t list -> Pp.t val pp_tuple_light : (bool -> 'a -> Pp.t) -> 'a list -> Pp.t val pp_tuple : ('a -> Pp.t) -> 'a list -> Pp.t val pp_boxed_tuple : ('a -> Pp.t) -> 'a list -> Pp.t val pr_binding : Id.t list -> Pp.t val rename_id : Id.t -> Id.Set.t -> Id.t type phase = Pre | Impl | Intf module State : sig type t val make : modular:bool -> library:bool -> keywords:Id.Set.t -> unit -> t (** Getters *) val get_table : t -> Table.t val get_modular : t -> bool val get_library : t -> bool val get_keywords : t -> Id.Set.t val get_phase : t -> phase val get_duplicate : t -> ModPath.t -> Id.t -> string option (** Setters *) val set_phase : t -> phase -> t (** Reader-like *) val with_visibility : t -> ModPath.t -> MBId.t list -> (t -> 'a) -> 'a (* the [module_path list] corresponds to module parameters, the innermost one coming first in the list *) val get_top_visible_mp : t -> ModPath.t (** Cleanup *) val reset : t -> unit end (** Target languages. Plugins register theirs as [External name]; module structures are then flattened and, in modular extraction, names are qualified as in Haskell. *) val register_language : Table.lang -> State.t language_descr -> unit val is_registered_language : Table.lang -> bool val descr : unit -> State.t language_descr type env = Id.t list * Id.Set.t val empty_env : State.t -> unit -> env val rename_vars: Id.Set.t -> Id.t list -> env val rename_tvars: Id.Set.t -> Id.t list -> Id.t list val push_vars : Id.t list -> env -> Id.t list * env val get_db_name : int -> env -> Id.t val opened_libraries : State.t -> DirPath.Set.t type kind = Term | Type | Cons | Mod val pp_global_with_key : State.t -> kind -> KerName.t -> global -> string val pp_global : State.t -> kind -> global -> string val pp_global_name : State.t -> kind -> global -> string val pp_module : State.t -> ModPath.t -> string (* val clear_mpfiles_content : unit -> unit *) (** Special hack for constants of type Ascii.ascii : if an [Extract Inductive ascii => char] has been declared, then the constants are directly turned into chars *) val is_native_char : ml_ast -> bool val get_native_char : ml_ast -> char val pp_native_char : ml_ast -> Pp.t (** Special hack for constants of type String.string : if an [Extract Inductive string => string] has been declared, then the constants are directly turned into string literals *) val is_native_string : ml_ast -> bool val get_native_string : ml_ast -> string val pp_native_string : ml_ast -> Pp.t (* Registered sig type *) val sig_type_name : string