functor (F : Formula.S) ->
functor
(A : sig
module F :
sig
type var = F.var
type 'a term = 'a F.term
type pred = F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = F.Varinfo.H.key
type 'a t = 'a F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = F.Varaddr.H.key
type 'a t = 'a F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = F.Fieldinfo.H.key
type 'a t = 'a F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = F.Compinfo.H.key
type 'a t = 'a F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = F.Arrayinfo.H.key
type 'a t = 'a F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = F.Logicvar.H.key
type 'a t = 'a F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = F.LTypeinfo.H.key
type 'a t = 'a F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = F.Cobject.H.key
type 'a t = 'a F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = F.ArrayDim.H.key
type 'a t = 'a F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop : Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield : Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) -> var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = F.alpha
val empty_alpha : alpha
val fold_alpha : (var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
val i_neg : Ctypes.c_int -> F.integer -> F.integer
val i_op :
Ctypes.c_int ->
Formula.int_op -> F.integer -> F.integer -> F.integer
val i_cmp :
Ctypes.c_int ->
Formula.cmp_op -> F.integer -> F.integer -> F.boolean
val bits_not : Ctypes.c_int -> F.integer -> F.integer
val bits_and : Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_or : Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_xor : Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_lshift :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_rshift :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
end) ->
functor
(R : sig
module F :
sig
type var = F.var
type 'a term = 'a F.term
type pred = F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = F.Varinfo.H.key
type 'a t = 'a F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = F.Varaddr.H.key
type 'a t = 'a F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = F.Fieldinfo.H.key
type 'a t = 'a F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = F.Compinfo.H.key
type 'a t = 'a F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = F.Arrayinfo.H.key
type 'a t = 'a F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = F.Logicvar.H.key
type 'a t = 'a F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = F.LTypeinfo.H.key
type 'a t = 'a F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = F.Cobject.H.key
type 'a t = 'a F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = F.ArrayDim.H.key
type 'a t = 'a F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop : Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield : Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) ->
var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
val f_neg : Ctypes.c_float -> F.real -> F.real
val f_op :
Ctypes.c_float ->
Formula.real_op -> F.real -> F.real -> F.real
val f_cmp :
Ctypes.c_float ->
Formula.cmp_op -> F.real -> F.real -> F.boolean
end) ->
sig
type decl = F.decl
type m_mbits
val t_mbits : Formula.tau
type mem_bits = Runtime_mem.Create.m_mbits F.term
type m_alloc
val t_alloc : Formula.tau
type mem_alloc = Runtime_mem.Create.m_alloc F.term
type m_mem
val t_mem : Formula.tau
type mem = { vbits : F.var; valloc : F.var; }
type m_format
type format = Runtime_mem.Create.m_format F.term
val mk_iformat : Ctypes.c_int -> string
val mk_fformat : Ctypes.c_float -> string
val int_format : '_a F.term
val real_format : '_a F.term
val i_format : Ctypes.c_int -> 'a F.term
val f_format : Ctypes.c_float -> 'a F.term
val format_of_addr : 'a -> 'b F.term
val tcomp_of_comp : Cil_types.compinfo -> Cil_types.typ
val cil_field_info : Cil_types.fieldinfo -> int * int
val cil_field_offset : Cil_types.fieldinfo -> int
val cil_field_size : Cil_types.fieldinfo -> int
val name_of_var : F.Xindex.t -> F.name
val name_of_field : F.Findex.t -> F.integer
val compute_int_mode : Runtime_mem.compute_int_mode
type 'a tint = F.integer
module Aint :
sig
type 'a t
val of_int : int -> 'a Runtime_mem.Create.??.t
val of_int64 : Int64.t -> 'a Runtime_mem.Create.??.t
val of_term :
'a Runtime_mem.Create.tint -> 'a Runtime_mem.Create.??.t
val add :
'a Runtime_mem.Create.??.t ->
'b Runtime_mem.Create.??.t -> 'a Runtime_mem.Create.??.t
val sub :
'a Runtime_mem.Create.??.t ->
'b Runtime_mem.Create.??.t -> 'a Runtime_mem.Create.??.t
val cnst_mult :
Int64.t ->
'a Runtime_mem.Create.??.t -> 'a Runtime_mem.Create.??.t
val mult :
'a Runtime_mem.Create.??.t ->
'b Runtime_mem.Create.??.t -> 'b Runtime_mem.Create.??.t
val to_term :
'a Runtime_mem.Create.??.t -> 'a Runtime_mem.Create.tint
val eq_pred :
'a Runtime_mem.Create.??.t ->
'a Runtime_mem.Create.??.t -> F.pred
end
type m_addr
type m_offset
type m_size
type m_zone
type t_addr = Runtime_mem.Create.m_addr Runtime_mem.Create.tint
type t_offset = Runtime_mem.Create.m_offset Runtime_mem.Create.tint
type t_size = Runtime_mem.Create.m_size Runtime_mem.Create.tint
type t_zone = Runtime_mem.Create.m_zone F.term
module Tint :
sig
type x_addr
val xaddr_of_var :
Runtime_mem.Create.mem_alloc ->
Cil_types.varinfo -> Runtime_mem.Create.??.x_addr
val xaddr_of_integer : F.integer -> Runtime_mem.Create.??.x_addr
val integer_of_xaddr : Runtime_mem.Create.??.x_addr -> F.integer
val varinfo_of_xaddr :
Runtime_mem.Create.??.x_addr -> Cil_types.varinfo option
val pp_addr :
Format.formatter -> Runtime_mem.Create.??.x_addr -> unit
val base :
Runtime_mem.Create.mem_alloc ->
Runtime_mem.Create.??.x_addr -> Runtime_mem.Create.??.x_addr
val term_of_xaddr :
Runtime_mem.Create.??.x_addr -> Runtime_mem.Create.t_addr
type x_size
val size_of_int : int -> Runtime_mem.Create.??.x_size
val size_of_int64 : Int64.t -> Runtime_mem.Create.??.x_size
val cnst_mult_size :
Int64.t ->
Runtime_mem.Create.??.x_size -> Runtime_mem.Create.??.x_size
val xsize_of_range :
F.integer ->
F.integer ->
Runtime_mem.Create.??.x_size -> Runtime_mem.Create.??.x_size
val term_of_xsize :
Runtime_mem.Create.??.x_size -> Runtime_mem.Create.t_size
val shift_n_elem :
Runtime_mem.Create.??.x_addr ->
F.integer ->
Runtime_mem.Create.??.x_size -> Runtime_mem.Create.??.x_addr
val shift_field :
Runtime_mem.Create.??.x_addr ->
Cil_types.fieldinfo -> Runtime_mem.Create.??.x_addr
val toffset_of_field :
?mode:Runtime_mem.compute_int_mode ->
Cil_types.fieldinfo -> Runtime_mem.Create.t_offset
val tsize_of_field :
?mode:Runtime_mem.compute_int_mode ->
Cil_types.fieldinfo -> Runtime_mem.Create.t_size
type x_zone
val mk_xzone :
Runtime_mem.Create.??.x_addr ->
Runtime_mem.Create.??.x_size -> Runtime_mem.Create.??.x_zone
val xzone_of_var :
Runtime_mem.Create.mem_alloc ->
Cil_types.varinfo ->
Runtime_mem.Create.??.x_size -> Runtime_mem.Create.??.x_zone
val pp_xzone :
Format.formatter -> Runtime_mem.Create.??.x_zone -> unit
val term_of_xzone :
Runtime_mem.Create.??.x_zone ->
Runtime_mem.Create.m_zone F.term
val eq_zone :
Runtime_mem.Create.??.x_zone ->
Runtime_mem.Create.??.x_zone -> F.pred
val xzone_disj :
Runtime_mem.Create.??.x_zone ->
Runtime_mem.Create.??.x_zone -> F.pred
end
val sizeof_c_object :
Ctypes.c_object -> Runtime_mem.Create.Tint.x_size
type m_bits
type t_bits = Runtime_mem.Create.m_bits F.term
type m_dzone
type dzone = Runtime_mem.Create.m_dzone F.term
module RtLib :
sig
val rt_global : F.name -> F.pred
val rt_vsize : F.name -> Runtime_mem.Create.t_size
val load :
Runtime_mem.Create.mem_bits ->
Runtime_mem.Create.t_zone -> Runtime_mem.Create.t_bits
val store :
Runtime_mem.Create.mem_bits ->
Runtime_mem.Create.t_addr ->
Runtime_mem.Create.t_bits -> Runtime_mem.Create.mem_bits
val havoc :
Runtime_mem.Create.mem_bits ->
Runtime_mem.Create.t_zone -> Runtime_mem.Create.mem_bits
val to_bits :
Runtime_mem.Create.format ->
F.abstract -> Runtime_mem.Create.t_bits
val from_bits :
Runtime_mem.Create.t_bits ->
Runtime_mem.Create.format -> F.abstract
val alloc :
Runtime_mem.Create.mem_alloc ->
F.name -> Runtime_mem.Create.mem_alloc
val block_length :
Runtime_mem.Create.mem_alloc ->
Runtime_mem.Create.t_addr -> Runtime_mem.Create.t_size
val valid :
Runtime_mem.Create.mem_alloc ->
Runtime_mem.Create.t_zone -> F.pred
val is_havoc :
Runtime_mem.Create.mem_alloc ->
Runtime_mem.Create.mem_bits ->
Runtime_mem.Create.dzone ->
Runtime_mem.Create.mem_bits -> F.pred
val free :
Runtime_mem.Create.mem_alloc ->
F.name -> Runtime_mem.Create.mem_alloc
val zs_empty : Runtime_mem.Create.dzone
val zs_singleton :
Runtime_mem.Create.t_zone -> Runtime_mem.Create.dzone
val zs_union :
Runtime_mem.Create.dzone ->
Runtime_mem.Create.dzone -> Runtime_mem.Create.dzone
val zs_incl :
Runtime_mem.Create.dzone -> Runtime_mem.Create.dzone -> F.pred
end
val z_from_bits :
Runtime_mem.Create.t_bits -> Runtime_mem.Create.format -> F.integer
val real_from_bits :
Runtime_mem.Create.t_bits -> Runtime_mem.Create.format -> F.real
module Model :
sig
module F :
sig
type var = F.var
type 'a term = 'a F.term
type pred = F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = F.Varinfo.H.key
type 'a t = 'a F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = F.Varaddr.H.key
type 'a t = 'a F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = F.Fieldinfo.H.key
type 'a t = 'a F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = F.Compinfo.H.key
type 'a t = 'a F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = F.Arrayinfo.H.key
type 'a t = 'a F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = F.Logicvar.H.key
type 'a t = 'a F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = F.LTypeinfo.H.key
type 'a t = 'a F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = F.Cobject.H.key
type 'a t = 'a F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = F.ArrayDim.H.key
type 'a t = 'a F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop : Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield : Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) -> var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
module A :
sig
module F :
sig
type var = F.var
type 'a term = 'a F.term
type pred = F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = F.Varinfo.H.key
type 'a t = 'a F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = F.Varaddr.H.key
type 'a t = 'a F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = F.Fieldinfo.H.key
type 'a t = 'a F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = F.Compinfo.H.key
type 'a t = 'a F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = F.Arrayinfo.H.key
type 'a t = 'a F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = F.Logicvar.H.key
type 'a t = 'a F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = F.LTypeinfo.H.key
type 'a t = 'a F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = F.Cobject.H.key
type 'a t = 'a F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = F.ArrayDim.H.key
type 'a t = 'a F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop :
Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp :
Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield :
Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) ->
var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 :
string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
val i_neg : Ctypes.c_int -> F.integer -> F.integer
val i_op :
Ctypes.c_int ->
Formula.int_op -> F.integer -> F.integer -> F.integer
val i_cmp :
Ctypes.c_int ->
Formula.cmp_op -> F.integer -> F.integer -> F.boolean
val bits_not : Ctypes.c_int -> F.integer -> F.integer
val bits_and :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_or :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_xor :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_lshift :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_rshift :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
end
module R :
sig
module F :
sig
type var = F.var
type 'a term = 'a F.term
type pred = F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = F.Varinfo.H.key
type 'a t = 'a F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = F.Varaddr.H.key
type 'a t = 'a F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = F.Fieldinfo.H.key
type 'a t = 'a F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = F.Compinfo.H.key
type 'a t = 'a F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = F.Arrayinfo.H.key
type 'a t = 'a F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = F.Logicvar.H.key
type 'a t = 'a F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = F.LTypeinfo.H.key
type 'a t = 'a F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = F.Cobject.H.key
type 'a t = 'a F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = F.ArrayDim.H.key
type 'a t = 'a F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop :
Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp :
Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield :
Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) ->
var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 :
string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
val f_neg : Ctypes.c_float -> F.real -> F.real
val f_op :
Ctypes.c_float ->
Formula.real_op -> F.real -> F.real -> F.real
val f_cmp :
Ctypes.c_float ->
Formula.cmp_op -> F.real -> F.real -> F.boolean
end
type loc = Runtime_mem.Create.Tint.x_addr
val pp_loc :
Format.formatter -> Runtime_mem.Create.Tint.x_addr -> unit
val cast_loc_to_int :
'a ->
Runtime_mem.Create.Tint.x_addr ->
Ctypes.c_int -> Runtime_mem.Create.Model.F.integer
val cast_int_to_loc :
Ctypes.c_int ->
Runtime_mem.Create.Model.F.integer ->
'a -> Runtime_mem.Create.Model.loc
val null : Runtime_mem.Create.Tint.x_addr
val is_null :
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Model.F.boolean
val minus_loc :
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Tint.x_addr ->
'a Runtime_mem.Create.Model.F.term
val le_loc_bool :
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Tint.x_addr ->
'a Runtime_mem.Create.Model.F.term
val lt_loc_bool :
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Tint.x_addr ->
'a Runtime_mem.Create.Model.F.term
val equal_loc_bool :
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Tint.x_addr ->
'a Runtime_mem.Create.Model.F.term
val le_loc :
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Model.F.pred
val lt_loc :
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Model.F.pred
val equal_loc :
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Model.F.pred
val term_of_loc :
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Model.F.abstract
val loc_of_term :
'a ->
Runtime_mem.Create.Model.F.abstract ->
Runtime_mem.Create.Tint.x_addr
val tau_of_loc : Formula.tau
end
val startof : 'a -> 'b -> 'a
val cast_loc_to_loc : 'a -> 'b -> 'c -> 'c
val tau_of_dzone : Formula.tau
val xzone_assigned :
Runtime_mem.Create.Tint.x_addr F.assigned ->
Runtime_mem.Create.Tint.x_zone
val dzone_assigned :
'a ->
Runtime_mem.Create.Tint.x_addr F.assigned ->
Runtime_mem.Create.dzone
val dzone_empty : unit -> Runtime_mem.Create.dzone
val dzone_subset :
Runtime_mem.Create.dzone -> Runtime_mem.Create.dzone -> F.pred
val dzone_union :
Runtime_mem.Create.dzone ->
Runtime_mem.Create.dzone -> Runtime_mem.Create.dzone
val effect_supported : bool
val int_format_for_hyp : Ctypes.c_object -> 'a F.term option
val add_int_format_hyp :
'a F.term -> Ctypes.c_object -> F.pred -> F.pred
module VarDecl :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.decl
val on_definition : (t -> F.decl -> unit) -> unit
end
module Fields :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.decl
val on_definition : (t -> F.decl -> unit) -> unit
end
module V :
sig
module F :
sig
type var = Model.F.var
type 'a term = 'a Model.F.term
type pred = Model.F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varinfo.H.key
type 'a t = 'a Model.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varaddr.H.key
type 'a t = 'a Model.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = Model.F.Fieldinfo.H.key
type 'a t = 'a Model.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = Model.F.Compinfo.H.key
type 'a t = 'a Model.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = Model.F.Arrayinfo.H.key
type 'a t = 'a Model.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = Model.F.Logicvar.H.key
type 'a t = 'a Model.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = Model.F.LTypeinfo.H.key
type 'a t = 'a Model.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = Model.F.Cobject.H.key
type 'a t = 'a Model.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = Model.F.ArrayDim.H.key
type 'a t = 'a Model.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop : Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield : Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = Model.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) -> var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = Model.F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
Model.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
Model.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
module A :
sig
module F :
sig
type var = Model.F.var
type 'a term = 'a Model.F.term
type pred = Model.F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varinfo.H.key
type 'a t = 'a Model.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varaddr.H.key
type 'a t = 'a Model.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = Model.F.Fieldinfo.H.key
type 'a t = 'a Model.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = Model.F.Compinfo.H.key
type 'a t = 'a Model.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = Model.F.Arrayinfo.H.key
type 'a t = 'a Model.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = Model.F.Logicvar.H.key
type 'a t = 'a Model.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = Model.F.LTypeinfo.H.key
type 'a t = 'a Model.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = Model.F.Cobject.H.key
type 'a t = 'a Model.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = Model.F.ArrayDim.H.key
type 'a t = 'a Model.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop :
Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp :
Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield :
Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = Model.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) ->
var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = Model.F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 :
string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
Model.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
Model.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
val i_neg : Ctypes.c_int -> F.integer -> F.integer
val i_op :
Ctypes.c_int ->
Formula.int_op -> F.integer -> F.integer -> F.integer
val i_cmp :
Ctypes.c_int ->
Formula.cmp_op -> F.integer -> F.integer -> F.boolean
val bits_not : Ctypes.c_int -> F.integer -> F.integer
val bits_and :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_or :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_xor :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_lshift :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_rshift :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
end
module R :
sig
module F :
sig
type var = Model.F.var
type 'a term = 'a Model.F.term
type pred = Model.F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varinfo.H.key
type 'a t = 'a Model.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varaddr.H.key
type 'a t = 'a Model.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = Model.F.Fieldinfo.H.key
type 'a t = 'a Model.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = Model.F.Compinfo.H.key
type 'a t = 'a Model.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = Model.F.Arrayinfo.H.key
type 'a t = 'a Model.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = Model.F.Logicvar.H.key
type 'a t = 'a Model.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = Model.F.LTypeinfo.H.key
type 'a t = 'a Model.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = Model.F.Cobject.H.key
type 'a t = 'a Model.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = Model.F.ArrayDim.H.key
type 'a t = 'a Model.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop :
Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp :
Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield :
Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = Model.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) ->
var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = Model.F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 :
string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
Model.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
Model.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
val f_neg : Ctypes.c_float -> F.real -> F.real
val f_op :
Ctypes.c_float ->
Formula.real_op -> F.real -> F.real -> F.real
val f_cmp :
Ctypes.c_float ->
Formula.cmp_op -> F.real -> F.real -> F.boolean
end
type loc = Model.loc
val tau_of_loc : Formula.tau
val term_of_loc : loc -> F.abstract
val loc_of_term : Ctypes.c_object -> F.abstract -> loc
val equal_loc_bool : loc -> loc -> F.boolean
val lt_loc_bool : loc -> loc -> F.boolean
val le_loc_bool : loc -> loc -> F.boolean
val lt_loc : loc -> loc -> F.pred
val le_loc : loc -> loc -> F.pred
val equal_loc : loc -> loc -> F.pred
val minus_loc : loc -> loc -> F.integer
val is_null : loc -> F.boolean
val null : loc
val cast_loc_to_int :
Cil_types.typ -> loc -> Ctypes.c_int -> F.integer
val cast_int_to_loc :
Ctypes.c_int -> F.integer -> Cil_types.typ -> loc
val pp_loc : Format.formatter -> loc -> unit
type value =
Datalib.Cvalues(Model).value =
V_int of Ctypes.c_int * F.integer
| V_float of Ctypes.c_float * F.real
| V_pointer of Ctypes.c_object * loc
| V_record of Cil_types.compinfo * F.record
| V_union of Cil_types.compinfo * F.urecord
| V_array of Ctypes.arrayinfo * F.array
val pp_value : Format.formatter -> value -> unit
val equal : Ctypes.c_object -> F.abstract -> F.abstract -> F.pred
val eq_array : Ctypes.arrayinfo -> F.array -> F.array -> F.pred
val eq_record :
Cil_types.compinfo -> F.record -> F.record -> F.pred
val logic_of_value : value -> F.abstract
val value_of_logic : Ctypes.c_object -> F.abstract -> value
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_object_array : Ctypes.c_object -> int -> Formula.tau
val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
val pp_tau : Format.formatter -> Formula.tau -> unit
val symb_is_init : Ctypes.c_object -> string option
val symb_is_init_range : Ctypes.c_object -> string option
end
module L :
sig
module F :
sig
type var = V.F.var
type 'a term = 'a V.F.term
type pred = V.F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = V.F.Varinfo.H.key
type 'a t = 'a V.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = V.F.Varaddr.H.key
type 'a t = 'a V.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = V.F.Fieldinfo.H.key
type 'a t = 'a V.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = V.F.Compinfo.H.key
type 'a t = 'a V.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = V.F.Arrayinfo.H.key
type 'a t = 'a V.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = V.F.Logicvar.H.key
type 'a t = 'a V.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = V.F.LTypeinfo.H.key
type 'a t = 'a V.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = V.F.Cobject.H.key
type 'a t = 'a V.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = V.F.ArrayDim.H.key
type 'a t = 'a V.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop : Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield : Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = V.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) -> var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = V.F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
V.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a V.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
V.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
type context = Datalib.Create(V).context
type bindings = Datalib.Create(V).bindings
val closed : bindings
val close : bindings -> F.pred -> F.pred
val push : string -> F.pool -> bindings -> context
val pop : string -> context -> bindings
val kill : string -> context -> unit
val flush : string -> context -> F.pred -> F.pred
val term_such_that :
Formula.tau -> ('a F.term -> F.pred) -> 'a F.term
val forall : F.var list -> F.pred -> F.pred
val exists : F.var list -> F.pred -> F.pred
val subst : F.var -> 'a F.term -> F.pred -> F.pred
val fresh : string -> Formula.kind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Formula.kind
val has_context_vars : F.var list -> F.pred -> bool
val has_type : F.abstract -> Cil_types.logic_type -> F.pred
val is_comp : Cil_types.compinfo -> F.abstract -> F.pred
val is_array : Ctypes.arrayinfo -> F.abstract -> F.pred
val apply : (F.var * F.var) list -> 'a F.term -> 'a F.term
val havoc_static : F.havoc list -> F.pred -> F.pred
val havoc_inductive : F.havoc list -> F.pred -> F.pred
end
module Data :
sig
module F :
sig
type var = Model.F.var
type 'a term = 'a Model.F.term
type pred = Model.F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varinfo.H.key
type 'a t = 'a Model.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varaddr.H.key
type 'a t = 'a Model.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = Model.F.Fieldinfo.H.key
type 'a t = 'a Model.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = Model.F.Compinfo.H.key
type 'a t = 'a Model.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = Model.F.Arrayinfo.H.key
type 'a t = 'a Model.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = Model.F.Logicvar.H.key
type 'a t = 'a Model.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = Model.F.LTypeinfo.H.key
type 'a t = 'a Model.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = Model.F.Cobject.H.key
type 'a t = 'a Model.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = Model.F.ArrayDim.H.key
type 'a t = 'a Model.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop : Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield : Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = Model.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) -> var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = Model.F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
Model.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
Model.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
module A :
sig
module F :
sig
type var = Model.F.var
type 'a term = 'a Model.F.term
type pred = Model.F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varinfo.H.key
type 'a t = 'a Model.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varaddr.H.key
type 'a t = 'a Model.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = Model.F.Fieldinfo.H.key
type 'a t = 'a Model.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = Model.F.Compinfo.H.key
type 'a t = 'a Model.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = Model.F.Arrayinfo.H.key
type 'a t = 'a Model.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = Model.F.Logicvar.H.key
type 'a t = 'a Model.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = Model.F.LTypeinfo.H.key
type 'a t = 'a Model.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = Model.F.Cobject.H.key
type 'a t = 'a Model.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = Model.F.ArrayDim.H.key
type 'a t = 'a Model.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop :
Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp :
Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield :
Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = Model.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) ->
var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = Model.F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 :
string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
Model.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
Model.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
val i_neg : Ctypes.c_int -> F.integer -> F.integer
val i_op :
Ctypes.c_int ->
Formula.int_op -> F.integer -> F.integer -> F.integer
val i_cmp :
Ctypes.c_int ->
Formula.cmp_op -> F.integer -> F.integer -> F.boolean
val bits_not : Ctypes.c_int -> F.integer -> F.integer
val bits_and :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_or :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_xor :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_lshift :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_rshift :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
end
module R :
sig
module F :
sig
type var = Model.F.var
type 'a term = 'a Model.F.term
type pred = Model.F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varinfo.H.key
type 'a t = 'a Model.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varaddr.H.key
type 'a t = 'a Model.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = Model.F.Fieldinfo.H.key
type 'a t = 'a Model.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = Model.F.Compinfo.H.key
type 'a t = 'a Model.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = Model.F.Arrayinfo.H.key
type 'a t = 'a Model.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = Model.F.Logicvar.H.key
type 'a t = 'a Model.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = Model.F.LTypeinfo.H.key
type 'a t = 'a Model.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = Model.F.Cobject.H.key
type 'a t = 'a Model.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = Model.F.ArrayDim.H.key
type 'a t = 'a Model.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop :
Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp :
Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield :
Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = Model.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) ->
var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = Model.F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 :
string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
Model.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
Model.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
val f_neg : Ctypes.c_float -> F.real -> F.real
val f_op :
Ctypes.c_float ->
Formula.real_op -> F.real -> F.real -> F.real
val f_cmp :
Ctypes.c_float ->
Formula.cmp_op -> F.real -> F.real -> F.boolean
end
type loc = Model.loc
val tau_of_loc : Formula.tau
val term_of_loc : loc -> F.abstract
val loc_of_term : Ctypes.c_object -> F.abstract -> loc
val equal_loc_bool : loc -> loc -> F.boolean
val lt_loc_bool : loc -> loc -> F.boolean
val le_loc_bool : loc -> loc -> F.boolean
val lt_loc : loc -> loc -> F.pred
val le_loc : loc -> loc -> F.pred
val equal_loc : loc -> loc -> F.pred
val minus_loc : loc -> loc -> F.integer
val is_null : loc -> F.boolean
val null : loc
val cast_loc_to_int :
Cil_types.typ -> loc -> Ctypes.c_int -> F.integer
val cast_int_to_loc :
Ctypes.c_int -> F.integer -> Cil_types.typ -> loc
val pp_loc : Format.formatter -> loc -> unit
type value =
Datalib.Cvalues(Model).value =
V_int of Ctypes.c_int * F.integer
| V_float of Ctypes.c_float * F.real
| V_pointer of Ctypes.c_object * loc
| V_record of Cil_types.compinfo * F.record
| V_union of Cil_types.compinfo * F.urecord
| V_array of Ctypes.arrayinfo * F.array
val pp_value : Format.formatter -> value -> unit
val equal : Ctypes.c_object -> F.abstract -> F.abstract -> F.pred
val eq_array : Ctypes.arrayinfo -> F.array -> F.array -> F.pred
val eq_record :
Cil_types.compinfo -> F.record -> F.record -> F.pred
val logic_of_value : value -> F.abstract
val value_of_logic : Ctypes.c_object -> F.abstract -> value
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_object_array : Ctypes.c_object -> int -> Formula.tau
val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
val pp_tau : Format.formatter -> Formula.tau -> unit
val symb_is_init : Ctypes.c_object -> string option
val symb_is_init_range : Ctypes.c_object -> string option
type m_of_mem = Runtime_mem.Create.m_mbits
val tau_of_mem : Formula.tau
val forall_loc :
F.pool -> F.var list * Runtime_mem.Create.Tint.x_addr
val global : Runtime_mem.Create.VarDecl.t -> unit
val cvar :
Runtime_mem.Create.mem ->
Runtime_mem.Create.VarDecl.t -> Runtime_mem.Create.Tint.x_addr
val inner_loc : 'a -> 'b
val lvar : 'a -> Cil_types.logic_var -> F.var -> loc
val shift : loc -> Ctypes.c_object -> F.integer -> loc
val index : loc -> Ctypes.c_object -> F.integer -> loc
val field :
loc ->
Runtime_mem.Create.Fields.t -> Runtime_mem.Create.Tint.x_addr
val value_of_bits :
(Ctypes.c_object -> Runtime_mem.Create.t_bits -> value)
Pervasives.ref
val bits_of_value :
(Ctypes.c_object -> value -> Runtime_mem.Create.t_bits)
Pervasives.ref
val load_mem :
Runtime_mem.Create.mem_bits ->
Ctypes.c_object -> Runtime_mem.Create.Tint.x_addr -> value
val store_mem :
Runtime_mem.Create.mem_bits ->
Ctypes.c_object ->
Runtime_mem.Create.Tint.x_addr ->
value -> Runtime_mem.Create.mem_bits
end
module DF :
sig
val record_format : Cil_types.compinfo -> 'a Data.F.term
val array_format : Ctypes.arrayinfo -> 'a Data.F.term
val loaded : Ctypes.c_object -> unit
val stored : Ctypes.c_object -> unit
end
val load :
Runtime_mem.Create.mem ->
Ctypes.c_object ->
Runtime_mem.Create.Tint.x_addr -> Runtime_mem.Create.Data.value
val store :
Runtime_mem.Create.mem ->
Runtime_mem.Create.Tint.x_addr ->
Ctypes.c_object ->
Runtime_mem.Create.Data.value -> Runtime_mem.Create.mem_bits
module F :
sig
type var = Model.F.var
type 'a term = 'a Model.F.term
type pred = Model.F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varinfo.H.key
type 'a t = 'a Model.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varaddr.H.key
type 'a t = 'a Model.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = Model.F.Fieldinfo.H.key
type 'a t = 'a Model.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = Model.F.Compinfo.H.key
type 'a t = 'a Model.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = Model.F.Arrayinfo.H.key
type 'a t = 'a Model.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = Model.F.Logicvar.H.key
type 'a t = 'a Model.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = Model.F.LTypeinfo.H.key
type 'a t = 'a Model.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = Model.F.Cobject.H.key
type 'a t = 'a Model.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = Model.F.ArrayDim.H.key
type 'a t = 'a Model.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop : Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield : Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = Model.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) -> var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = Model.F.alpha
val empty_alpha : alpha
val fold_alpha : (var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 : string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
Model.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
Model.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
module A :
sig
module F :
sig
type var = Model.F.var
type 'a term = 'a Model.F.term
type pred = Model.F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varinfo.H.key
type 'a t = 'a Model.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varaddr.H.key
type 'a t = 'a Model.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = Model.F.Fieldinfo.H.key
type 'a t = 'a Model.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = Model.F.Compinfo.H.key
type 'a t = 'a Model.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = Model.F.Arrayinfo.H.key
type 'a t = 'a Model.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = Model.F.Logicvar.H.key
type 'a t = 'a Model.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = Model.F.LTypeinfo.H.key
type 'a t = 'a Model.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = Model.F.Cobject.H.key
type 'a t = 'a Model.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = Model.F.ArrayDim.H.key
type 'a t = 'a Model.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop : Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield : Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = Model.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) -> var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = Model.F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
Model.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
Model.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
val i_neg : Ctypes.c_int -> F.integer -> F.integer
val i_op :
Ctypes.c_int ->
Formula.int_op -> F.integer -> F.integer -> F.integer
val i_cmp :
Ctypes.c_int ->
Formula.cmp_op -> F.integer -> F.integer -> F.boolean
val bits_not : Ctypes.c_int -> F.integer -> F.integer
val bits_and :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_or : Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_xor :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_lshift :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
val bits_rshift :
Ctypes.c_int -> F.integer -> F.integer -> F.integer
end
module R :
sig
module F :
sig
type var = Model.F.var
type 'a term = 'a Model.F.term
type pred = Model.F.pred
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 decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varinfo.H.key
type 'a t = 'a Model.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.F.Varaddr.H.key
type 'a t = 'a Model.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = Model.F.Fieldinfo.H.key
type 'a t = 'a Model.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = Model.F.Compinfo.H.key
type 'a t = 'a Model.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = Model.F.Arrayinfo.H.key
type 'a t = 'a Model.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = Model.F.Logicvar.H.key
type 'a t = 'a Model.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = Model.F.LTypeinfo.H.key
type 'a t = 'a Model.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = Model.F.Cobject.H.key
type 'a t = 'a Model.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = Model.F.ArrayDim.H.key
type 'a t = 'a Model.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop : Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield : Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = Model.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) -> var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = Model.F.alpha
val empty_alpha : alpha
val fold_alpha :
(var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 :
string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term ->
'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
Model.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
Model.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
val f_neg : Ctypes.c_float -> F.real -> F.real
val f_op :
Ctypes.c_float -> Formula.real_op -> F.real -> F.real -> F.real
val f_cmp :
Ctypes.c_float ->
Formula.cmp_op -> F.real -> F.real -> F.boolean
end
type loc = Model.loc
val tau_of_loc : Formula.tau
val term_of_loc : loc -> F.abstract
val loc_of_term : Ctypes.c_object -> F.abstract -> loc
val equal_loc_bool : loc -> loc -> F.boolean
val lt_loc_bool : loc -> loc -> F.boolean
val le_loc_bool : loc -> loc -> F.boolean
val lt_loc : loc -> loc -> F.pred
val le_loc : loc -> loc -> F.pred
val equal_loc : loc -> loc -> F.pred
val minus_loc : loc -> loc -> F.integer
val is_null : loc -> F.boolean
val null : loc
val cast_loc_to_int :
Cil_types.typ -> loc -> Ctypes.c_int -> F.integer
val cast_int_to_loc :
Ctypes.c_int -> F.integer -> Cil_types.typ -> loc
val pp_loc : Format.formatter -> loc -> unit
type value =
Datalib.Cvalues(Model).value =
V_int of Ctypes.c_int * F.integer
| V_float of Ctypes.c_float * F.real
| V_pointer of Ctypes.c_object * loc
| V_record of Cil_types.compinfo * F.record
| V_union of Cil_types.compinfo * F.urecord
| V_array of Ctypes.arrayinfo * F.array
val pp_value : Format.formatter -> value -> unit
val equal : Ctypes.c_object -> F.abstract -> F.abstract -> F.pred
val eq_array : Ctypes.arrayinfo -> F.array -> F.array -> F.pred
val eq_record : Cil_types.compinfo -> F.record -> F.record -> F.pred
val logic_of_value : value -> F.abstract
val value_of_logic : Ctypes.c_object -> F.abstract -> value
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_object_array : Ctypes.c_object -> int -> Formula.tau
val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
val pp_tau : Format.formatter -> Formula.tau -> unit
val symb_is_init : Ctypes.c_object -> string option
val symb_is_init_range : Ctypes.c_object -> string option
type m_of_mem = m_mbits
val tau_of_mem : Formula.tau
val forall_loc : F.pool -> F.var list * Tint.x_addr
val global : VarDecl.t -> unit
val cvar : mem -> VarDecl.t -> Tint.x_addr
val inner_loc : 'a -> 'b
val lvar : 'a -> Cil_types.logic_var -> F.var -> loc
val shift : loc -> Ctypes.c_object -> F.integer -> loc
val index : loc -> Ctypes.c_object -> F.integer -> loc
val field : loc -> Fields.t -> Tint.x_addr
val value_of_bits : (Ctypes.c_object -> t_bits -> value) ref
val bits_of_value : (Ctypes.c_object -> value -> t_bits) ref
val load_mem : mem_bits -> Ctypes.c_object -> Tint.x_addr -> value
val store_mem :
mem_bits -> Ctypes.c_object -> Tint.x_addr -> value -> mem_bits
val format_of_compinfo :
Cil_types.compinfo -> 'a Runtime_mem.Create.Data.F.term
val format_of_array :
Ctypes.arrayinfo -> 'a Runtime_mem.Create.Data.F.term
val rt_format_of_ctype :
Ctypes.c_object -> 'a Runtime_mem.Create.Data.F.term
val value_of_bits :
Ctypes.c_object ->
Runtime_mem.Create.t_bits -> Runtime_mem.Create.Data.value
val bits_of_value : 'a -> value -> Runtime_mem.Create.t_bits
val mem : unit -> Runtime_mem.Create.mem
val valid :
Runtime_mem.Create.mem ->
Runtime_mem.Create.Tint.x_addr F.assigned -> F.pred
val separated :
'a ->
Runtime_mem.Create.Tint.x_addr F.assigned ->
Runtime_mem.Create.Tint.x_addr F.assigned -> F.pred
val tbits_of_var : F.var -> Runtime_mem.Create.t_bits
val subst_havoc :
Runtime_mem.Create.mem ->
Runtime_mem.Create.Tint.x_addr F.assigned -> F.havoc list
val assigns_goal :
Runtime_mem.Create.mem ->
Runtime_mem.Create.Tint.x_addr F.assigned list ->
Runtime_mem.Create.mem -> F.pred
val assigns_supported : bool
val base_address :
Runtime_mem.Create.mem ->
Runtime_mem.Create.Tint.x_addr -> Runtime_mem.Create.Tint.x_addr
val block_length :
Runtime_mem.Create.mem ->
Runtime_mem.Create.Tint.x_addr -> Runtime_mem.Create.t_size
type closure = Mem | Alloc
val pp_closure :
Format.formatter -> Runtime_mem.Create.closure -> unit
val userdef_mem_signature :
Runtime_mem.Create.mem -> (F.var * Runtime_mem.Create.closure) list
val userdef_mem_apply :
Runtime_mem.Create.mem -> Runtime_mem.Create.closure -> F.abstract
type formal = unit
val pp_formal : 'a -> 'b -> unit
val userdef_is_ref_param : Cil_types.logic_var -> bool
val userdef_ref_signature :
Runtime_mem.Create.mem ->
(F.var * Cil_types.logic_var * Runtime_mem.Create.formal) list
val userdef_ref_apply :
Runtime_mem.Create.mem -> Runtime_mem.Create.formal -> loc -> value
val userdef_ref_has_cvar : Cil_types.logic_var -> bool
val update :
at:Runtime_mem.Create.mem ->
here:Runtime_mem.Create.mem ->
Runtime_mem.Create.L.F.pred -> Runtime_mem.Create.L.F.pred
val quantify :
Runtime_mem.Create.mem ->
Runtime_mem.Create.L.F.pred -> Runtime_mem.Create.L.F.pred
val subst_lval :
Runtime_mem.Create.mem ->
Ctypes.c_object ->
Runtime_mem.Create.Tint.x_addr ->
Runtime_mem.Create.Data.value ->
Runtime_mem.Create.L.F.pred -> Runtime_mem.Create.L.F.pred
val local_scope :
Runtime_mem.Create.mem ->
F.Xindex.t list ->
Mcfg.scope ->
Runtime_mem.Create.L.F.pred -> Runtime_mem.Create.L.F.pred
val global_scope : 'a -> 'b -> 'b
end