Module Register.F


module F: Fol_formula

val i_pred : Formula.cmp_op -> string
val i_bool : Formula.cmp_op -> string
val i_op : Formula.int_op -> string
val r_pred : Formula.cmp_op -> string
val r_bool : Formula.cmp_op -> string
val r_op : Formula.real_op -> string
type 'a term = Fol.term 
type pred = Fol.pred 
type decl = Fol.decl 
type abstract = Formula.m_abstract term 
type integer = Formula.m_integer term 
type real = Formula.m_real term 
type boolean = Formula.m_boolean term 
type record = Formula.m_record term 
type urecord = Formula.m_array term 
type array = Formula.m_array term 
type set = Formula.m_set term 
type name = Formula.m_integer term 
type var = Fol.Var.t 
val e_true : Fol.term
val e_false : Fol.term
val e_int : int -> Fol.term
val e_int64 : int64 -> Fol.term
val e_float : float -> Fol.term
val e_icst : string -> Fol.term
val e_rcst : string -> Fol.term
val wrap : 'a -> 'a
val unwrap : 'a -> 'a
val e_call : string -> Fol.term list -> Fol.term
val p_call : string -> Fol.term list -> Fol.pred
val e_access : Fol.term -> Fol.term -> Fol.term
val e_update : Fol.term -> Fol.term -> Fol.term -> Fol.term
val e_getfield : Cil_types.fieldinfo -> Fol.term -> Fol.term
val e_setfield : Cil_types.fieldinfo -> Fol.term -> Fol.term -> Fol.term
val unop : string -> Fol.term -> Fol.term
val binop : string -> Fol.term -> Fol.term -> Fol.term
val predop : string -> Fol.term -> Fol.term -> Fol.pred
val e_ineg : Fol.term -> Fol.term
val e_rneg : Fol.term -> Fol.term
val e_icmp : Formula.cmp_op -> Fol.term -> Fol.term -> Fol.term
val p_icmp : Formula.cmp_op -> Fol.term -> Fol.term -> Fol.pred
val e_rcmp : Formula.cmp_op -> Fol.term -> Fol.term -> Fol.term
val p_rcmp : Formula.cmp_op -> Fol.term -> Fol.term -> Fol.pred
val e_iop : Formula.int_op -> Fol.term -> Fol.term -> Fol.term
val e_rop : Formula.real_op -> Fol.term -> Fol.term -> Fol.term
val real_of_integer : Fol.term -> Fol.term
val integer_of_real : Fol.term -> Fol.term
val a_true : Fol.term
val a_false : Fol.term
val e_bool : boolean -> integer
val e_cond : boolean ->
'a term -> 'a term -> 'a term
val e_not : Fol.term -> Fol.term
val e_and : Fol.term -> Fol.term -> Fol.term
val e_or : Fol.term -> Fol.term -> Fol.term
val e_bnot : Fol.term -> Fol.term
val e_band : Fol.term -> Fol.term -> Fol.term
val e_bor : Fol.term -> Fol.term -> Fol.term
val e_bxor : Fol.term -> Fol.term -> Fol.term
val e_lshift : Fol.term -> Fol.term -> Fol.term
val e_rshift : Fol.term -> Fol.term -> Fol.term
val i_zero : Fol.term
val i_one : Fol.term
val i_sub : Fol.term -> Fol.term -> Fol.term
val i_add : Fol.term -> Fol.term -> Fol.term
val i_mult : Fol.term -> Fol.term -> Fol.term
val r_zero : Fol.term
val is_incl_comp : Cil_datatype.Compinfo.t -> Cil_types.typ -> bool
val comp_compare : Cil_datatype.Compinfo.t -> Cil_datatype.Compinfo.t -> int
val part_of_item : ('a, 'b, 'c) Formula.item -> int
val compare_item : ('a, 'b, 'c) Formula.declaration -> ('d, 'e, 'f) Formula.declaration -> int
module Dset: Set.Make(sig
type t = Fol_formula.decl 
val compare : ('a, 'b, 'c) Formula.declaration -> ('d, 'e, 'f) Formula.declaration -> int
end)
val gindex : (string, decl) Hashtbl.t
val gfresh : (string, int Pervasives.ref) Hashtbl.t
val fresh_name : string -> string -> string
val s_index : Formula.section -> int
val gsection : Dset.t array
val gtoc : (Formula.section * string) array
val gclear : (unit -> unit) list Pervasives.ref
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val locked : bool Pervasives.ref
val has_declaration : string -> bool
val compile_let_item : (Fol.Var.t, Fol.term, Fol.pred) Formula.item ->
(Fol.Var.t, Fol.term, Fol.pred) Formula.item
val compile_let_decl : (Fol.Var.t, Fol.term, Fol.pred) Formula.declaration ->
(Fol.Var.t, Fol.term, Fol.pred) Formula.declaration
val add_declaration : Dset.elt -> unit
module Mset: Datatype.String.Set
val exported_macros : Mset.t Pervasives.ref
val is_macro : ('a, 'b, 'c) Formula.declaration -> bool
val is_macro_section : Formula.section -> bool
val do_export : (decl -> 'a) -> decl -> unit
val export_depends_for_item : (decl -> 'a) ->
(Fol.Var.t, Fol.term, Fol.pred) Formula.item -> unit
val export_depends_for_name : (decl -> 'a) -> string -> unit
val export_depends_for_term : (decl -> 'a) -> Fol.term -> unit
val export_depends_for_pred : (decl -> 'a) -> Fol.pred -> unit
val iter_all : (string -> 'a) -> (Dset.elt -> unit) -> unit
module type Identifiable = sig .. end
module type Registry = sig .. end
module type Declarator = sig .. end
module DRegister: 
functor (D : Declarator) -> sig .. end
val pp_dim : Format.formatter -> Cil_types.typ -> unit
val pp_ctype : bool -> Format.formatter -> Cil_types.typ -> unit
module Varinfo: sig .. end
module Varaddr: sig .. end
module Fieldinfo: sig .. end
module Compinfo: sig .. end
module Arrayinfo: sig .. end
module LTypeinfo: sig .. end
module Logicvar: sig .. end
module HC_object: sig .. end
module Cobject: sig .. end
module HC_ArrayDim: sig .. end
module ArrayDim: sig .. end
module LTinfo: sig .. end
module LTinfoId: sig .. end
module ADTDecl: DRegister(sig
include LTinfoId
val declare : Cil_types.logic_type_info -> 'a -> ('b, 'c, 'd) Formula.item
val section : Formula.section
val clear : unit -> unit
end)
val adt_decl : ADTDecl.t -> string
type pool = (string, int option) Hashtbl.t 
val pool : unit -> ('a, 'b) Hashtbl.t
val fresh_var : ('a, int option) Hashtbl.t -> 'a -> int option
val p_fresh : (string, int option) Hashtbl.t -> string -> Formula.kind -> Fol.Var.t
val var : Fol.Var.t -> Fol.term
val tau_of_var : Fol.Var.t -> Formula.tau
val name_of_var : Fol.Var.t -> string
val basename_of_var : Fol.Var.t -> string
val kind_of_var : Fol.Var.t -> Formula.kind
val p_freshen : (string, int option) Hashtbl.t -> Fol.Var.t -> Fol.Var.t
val p_true : Fol.pred
val p_false : Fol.pred
val p_not : Fol.pred -> Fol.pred
val p_bool : Fol.term -> Fol.pred
val equal_terms : Fol.term -> Fol.term -> bool
val p_and : Fol.pred -> Fol.pred -> Fol.pred
val p_or : Fol.pred -> Fol.pred -> Fol.pred
val p_xor : Fol.pred -> Fol.pred -> Fol.pred
val p_eq : Fol.term -> Fol.term -> Fol.pred
val p_neq : Fol.term -> Fol.term -> Fol.pred
val p_iff : Fol.pred -> Fol.pred -> Fol.pred
val p_conj : Fol.pred list -> Fol.pred
val p_disj : Fol.pred list -> Fol.pred
val p_cond : Fol.term -> Fol.pred -> Fol.pred -> Fol.pred
val p_named : string -> Fol.pred -> Fol.pred
val is_true : Fol.pred -> bool
val is_false : Fol.pred -> bool
val eq_var : Fol.Var.t -> Fol.Var.t -> bool
val e_subst : (Fol.Var.t -> Fol.Var.t option) ->
Fol.Var.t -> Fol.term -> Fol.term -> Fol.term
val p_forall : Fol.Var.t list -> Fol.pred -> Fol.pred
val p_exists : Fol.Var.t list -> Fol.pred -> Fol.pred
val p_subst : (Fol.Var.t -> Fol.Var.t option) ->
Fol.Var.t -> Fol.term -> Fol.pred -> Fol.pred
val p_implies : Fol.pred -> Fol.pred -> Fol.pred
val apply : (Fol.Var.t * 'a) list -> Fol.Var.t -> 'a option
val e_rename : (Fol.Var.t * Fol.Var.t) list -> Fol.term -> Fol.term
val term_has_var : Fol.Var.t list -> Fol.term -> bool
val pred_has_var : Fol.Var.t list -> Fol.pred -> bool
val term_calls : string -> Fol.term -> bool
val pred_calls : string -> Fol.pred -> bool
val term_closed : Fol.term -> bool
val pred_closed : Fol.pred -> bool
type alpha = Fol.Var.t Fol.Vmap.t 
val empty_alpha : 'a Fol.Vmap.t
val fold_alpha : (Fol.Vmap.key -> 'a -> 'b -> 'b) -> 'a Fol.Vmap.t -> 'b -> 'b
val p_more_alpha_cv : Fol.Var.t Fol.Vmap.t -> Fol.pred -> Fol.Var.t Fol.Vmap.t * Fol.pred
val p_alpha_cv : Fol.pred -> Fol.Var.t list * Fol.pred
val free_term : Fol.Vset.t -> Fol.term -> Fol.Vset.t
val free_pred : Fol.Vset.t -> Fol.pred -> Fol.Vset.t
val freevars : Fol.pred -> Fol.Vset.elt list
val pp_term : Format.formatter -> Fol.term -> unit
val pp_tau : Format.formatter -> Formula.tau -> unit
val pp_pred_atom : Fol.pred Fol_pretty.pp
val pp_pred_vbox : Format.formatter -> Fol.pred -> unit
val pp_pred_debug : Format.formatter -> Fol.pred -> unit
val pp_pred : Format.formatter -> Fol.pred -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> Fol.term -> unit
val pp_decl : Format.formatter ->
(Fol.Var.t, Fol.term, Fol.pred) Formula.declaration -> unit
val pp_goal : Format.formatter -> string -> Fol.pred -> unit
val pp_var : Format.formatter -> Fol.Var.t -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val huge_term : int -> Fol.term -> bool
val huge_pred : int -> Fol.pred -> bool

type interval = {
   inf : integer option;
   sup : integer option;
}
type 'a assigned =
| Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval

type havoc =
| Fresh of var
| Update of var
* ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val p_app0 : string -> Fol.pred
val p_app1 : string -> Fol.term -> Fol.pred
val p_app2 : string -> Fol.term -> Fol.term -> Fol.pred
val p_app3 : string -> Fol.term -> Fol.term -> Fol.term -> Fol.pred
val p_app4 : string -> Fol.term -> Fol.term -> Fol.term -> Fol.term -> Fol.pred
val p_app5 : string ->
Fol.term -> Fol.term -> Fol.term -> Fol.term -> Fol.term -> Fol.pred
val e_app0 : string -> Fol.term
val e_app1 : string -> Fol.term -> Fol.term
val e_app2 : string -> Fol.term -> Fol.term -> Fol.term
val e_app3 : string -> Fol.term -> Fol.term -> Fol.term -> Fol.term
val e_app4 : string -> Fol.term -> Fol.term -> Fol.term -> Fol.term -> Fol.term
val e_app5 : string ->
Fol.term -> Fol.term -> Fol.term -> Fol.term -> Fol.term -> Fol.term
val gdummy : int Pervasives.ref
val dummy : unit -> Fol.pred
val modulo : Ctypes.c_int -> Fol.term -> Fol.term
val guard : Ctypes.c_int -> Fol.term -> Fol.pred
val i_convert : Ctypes.c_int -> Ctypes.c_int -> Fol.term -> Fol.term
val empty : Fol.term
val singleton : Fol.term -> Fol.term
val union : Fol.term -> Fol.term -> Fol.term
val unions : Fol.term list -> Fol.term
val inter : Fol.term -> Fol.term -> Fol.term
val remove : Fol.term -> Fol.term -> Fol.term
val add_set : Fol.term -> Fol.term -> Fol.term
val mult_set : Fol.term -> Fol.term -> Fol.term
val neg_set : Fol.term -> Fol.term
val loc_range : integer -> integer -> Fol.term
val range_inf : integer -> Fol.term
val range_sup : integer -> Fol.term
val integers : Fol.term
val set_of_list : Fol.term list -> Fol.term
val interval : interval -> Fol.term
val seed : int Pervasives.ref
val set_range_index : Fol.term -> interval -> Fol.term
module RecName: DRegister(sig
include Compinfo
val declare : Cil_types.compinfo -> 'a -> ('b, 'c, 'd) Formula.item
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : 'a -> 'b -> unit
end)
val acc_field : record -> Cil_types.fieldinfo -> Fol.term
val upd_field : record -> Cil_types.fieldinfo -> Fol.term -> record
val acc_index : Fol.term -> Fol.term -> Fol.term
val upd_index : Fol.term -> Fol.term -> Fol.term -> Fol.term
val gindexref : int Pervasives.ref
module type Indexed = sig .. end
module Dindex: 
functor (I : Identifiable) -> sig .. end
module Findex: Dindex(Fieldinfo)
module Xindex: Dindex(Varinfo)
module Tindex: Dindex(Compinfo)
module Aindex: Dindex(Varaddr)
module LTindex: Dindex(LTypeinfo)