functor (D : Mdata.S) ->
functor
(A : sig
module D :
sig
module F :
sig
type 'a term = 'a D.F.term
type pred = D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string ->
Formula.abstract term list -> Formula.abstract term
val p_call : string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg : Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term ->
Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term ->
Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term -> Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot : Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real :
Formula.real term -> Formula.integer term
val real_of_integer :
Formula.integer term -> Formula.real term
val e_bool : Formula.boolean term -> Formula.integer term
val e_not : Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term -> 'a term -> 'a term -> 'a term
val p_cond : Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = D.F.var
type pool = D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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 = D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter -> pred Formula.declaration -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
end
type format = Formula.m_format F.term
type abstract = Formula.abstract F.term
type integer = Formula.integer F.term
type real = Formula.real F.term
type boolean = Formula.boolean F.term
type record = Formula.m_array F.term
type urecord = Formula.m_array F.term
type array = Formula.m_array F.term
type set = Formula.m_set F.term
type name = Formula.integer F.term
type pointer = Formula.m_pointer F.term
val pp_kind : Format.formatter -> Mdata.kind -> unit
type interval =
D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a D.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit
val e_app0 : string -> 'a F.term
val e_app1 : string -> 'a F.term -> 'b F.term
val e_app2 : string -> 'a F.term -> 'b F.term -> 'c F.term
val e_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> 'd F.term
val e_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term
val e_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> 'f F.term
val p_app0 : string -> F.pred
val p_app1 : string -> 'a F.term -> F.pred
val p_app2 : string -> 'a F.term -> 'b F.term -> F.pred
val p_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> F.pred
val p_app4 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term -> F.pred
val p_app5 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term -> F.pred
val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
type context = D.context
type bindings = D.bindings
class type hint =
object
method capture : F.var list -> unit
method has_var : F.var list -> bool
method pretty : Format.formatter -> unit
method subst : F.var -> Formula.abstract F.term -> unit
end
val closed : bindings
val close : bindings -> F.pred -> F.pred
val capture : hint list -> bindings -> unit
val push :
string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val has_vars : F.var list -> F.pred -> bool
type substitution = D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
D.havoc =
Fresh of F.var
| Update of F.var *
(substitution -> Formula.abstract F.term)
val havoc_static : havoc list -> F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : F.pred Formula.declaration -> unit
val iter :
Formula.section ->
(F.pred Formula.declaration -> unit) -> unit
val iter_all : (F.pred Formula.declaration -> unit) -> unit
val dummy : unit -> F.pred
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 -> Log.source 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 -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
end
module Register :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = D.Varinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Varaddr.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Fieldinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Compinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Arrayinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Logicvar.H.key
type 'a t = 'a D.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 -> Log.source option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
val modulo : Ctypes.c_int -> integer -> integer
val guard : Ctypes.c_int -> integer -> F.pred
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
val round : Ctypes.c_float -> real -> real
val f_guard : Ctypes.c_float -> real -> F.pred
val f_convert :
Ctypes.c_float -> Ctypes.c_float -> real -> real
val has_type : abstract -> Cil_types.logic_type -> F.pred
val get_range_index : array -> interval -> abstract
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 equal_pointer_bool : pointer -> pointer -> boolean
val lt_pointer_bool : pointer -> pointer -> boolean
val le_pointer_bool : pointer -> pointer -> boolean
val lt_pointer : pointer -> pointer -> F.pred
val le_pointer : pointer -> pointer -> F.pred
val minus_pointer : pointer -> pointer -> integer
val is_null : pointer -> boolean
val null : pointer
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val int_format : format
val real_format : format
val pointer_format : format
val record_format : format
val urecord_format : format
val array_format : format -> format
val format_of_object : Ctypes.c_object -> format
val decode : format -> abstract -> 'a F.term
val encode : format -> 'a F.term -> abstract
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
val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
val eq_record :
Cil_types.compinfo -> record -> record -> F.pred
end
val i_neg : Ctypes.c_int -> D.integer -> D.integer
val i_op :
Ctypes.c_int ->
Formula.integer_op -> D.integer -> D.integer -> D.integer
val i_cmp :
Ctypes.c_int ->
Formula.cmp_op -> D.integer -> D.integer -> D.boolean
val bits_not : Ctypes.c_int -> D.integer -> D.integer
val bits_and : Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_or : Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_xor : Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_lshift :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_rshift :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
end) ->
functor
(R : sig
module D :
sig
module F :
sig
type 'a term = 'a D.F.term
type pred = D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string ->
Formula.abstract term list -> Formula.abstract term
val p_call :
string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg :
Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term ->
Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term ->
Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term -> Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot :
Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real :
Formula.real term -> Formula.integer term
val real_of_integer :
Formula.integer term -> Formula.real term
val e_bool :
Formula.boolean term -> Formula.integer term
val e_not : Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term -> 'a term -> 'a term -> 'a term
val p_cond :
Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = D.F.var
type pool = D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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 = D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter -> pred Formula.declaration -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
end
type format = Formula.m_format F.term
type abstract = Formula.abstract F.term
type integer = Formula.integer F.term
type real = Formula.real F.term
type boolean = Formula.boolean F.term
type record = Formula.m_array F.term
type urecord = Formula.m_array F.term
type array = Formula.m_array F.term
type set = Formula.m_set F.term
type name = Formula.integer F.term
type pointer = Formula.m_pointer F.term
val pp_kind : Format.formatter -> Mdata.kind -> unit
type interval =
D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a D.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit
val e_app0 : string -> 'a F.term
val e_app1 : string -> 'a F.term -> 'b F.term
val e_app2 : string -> 'a F.term -> 'b F.term -> 'c F.term
val e_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> 'd F.term
val e_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term
val e_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> 'f F.term
val p_app0 : string -> F.pred
val p_app1 : string -> 'a F.term -> F.pred
val p_app2 : string -> 'a F.term -> 'b F.term -> F.pred
val p_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> F.pred
val p_app4 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term -> F.pred
val p_app5 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term -> F.pred
val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
type context = D.context
type bindings = D.bindings
class type hint =
object
method capture : F.var list -> unit
method has_var : F.var list -> bool
method pretty : Format.formatter -> unit
method subst : F.var -> Formula.abstract F.term -> unit
end
val closed : bindings
val close : bindings -> F.pred -> F.pred
val capture : hint list -> bindings -> unit
val push :
string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val has_vars : F.var list -> F.pred -> bool
type substitution = D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
D.havoc =
Fresh of F.var
| Update of F.var *
(substitution -> Formula.abstract F.term)
val havoc_static : havoc list -> F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : F.pred Formula.declaration -> unit
val iter :
Formula.section ->
(F.pred Formula.declaration -> unit) -> unit
val iter_all : (F.pred Formula.declaration -> unit) -> unit
val dummy : unit -> F.pred
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 -> Log.source 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 -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
end
module Register :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = D.Varinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Varaddr.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Fieldinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Compinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Arrayinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Logicvar.H.key
type 'a t = 'a D.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 -> Log.source option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
val modulo : Ctypes.c_int -> integer -> integer
val guard : Ctypes.c_int -> integer -> F.pred
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
val round : Ctypes.c_float -> real -> real
val f_guard : Ctypes.c_float -> real -> F.pred
val f_convert :
Ctypes.c_float -> Ctypes.c_float -> real -> real
val has_type : abstract -> Cil_types.logic_type -> F.pred
val get_range_index : array -> interval -> abstract
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 equal_pointer_bool : pointer -> pointer -> boolean
val lt_pointer_bool : pointer -> pointer -> boolean
val le_pointer_bool : pointer -> pointer -> boolean
val lt_pointer : pointer -> pointer -> F.pred
val le_pointer : pointer -> pointer -> F.pred
val minus_pointer : pointer -> pointer -> integer
val is_null : pointer -> boolean
val null : pointer
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val int_format : format
val real_format : format
val pointer_format : format
val record_format : format
val urecord_format : format
val array_format : format -> format
val format_of_object : Ctypes.c_object -> format
val decode : format -> abstract -> 'a F.term
val encode : format -> 'a F.term -> abstract
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
val equal :
Ctypes.c_object -> abstract -> abstract -> F.pred
val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
val eq_record :
Cil_types.compinfo -> record -> record -> F.pred
end
val f_neg : Ctypes.c_float -> D.real -> D.real
val f_op :
Ctypes.c_float ->
Formula.real_op -> D.real -> D.real -> D.real
val f_cmp :
Ctypes.c_float ->
Formula.cmp_op -> D.real -> D.real -> D.boolean
end) ->
sig
val unsupported :
?model:string ->
('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a
module F :
sig
type 'a term = 'a D.F.term
type pred = D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string -> Formula.abstract term list -> Formula.abstract term
val p_call : string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg : Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term -> Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term -> Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot : Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real : Formula.real term -> Formula.integer term
val real_of_integer : Formula.integer term -> Formula.real term
val e_bool : Formula.boolean term -> Formula.integer term
val e_not : Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term -> 'a term -> 'a term -> 'a term
val p_cond : Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = D.F.var
type pool = D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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 = D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter -> pred Formula.declaration -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
end
type m_memory
val t_memory : Formula.tau
type store = Store_mem.Create.m_memory Store_mem.Create.F.term
type m_alloc
val t_alloc : Formula.tau
type tbl_alloc = Store_mem.Create.m_alloc Store_mem.Create.F.term
type mem = {
store : Store_mem.Create.store;
talloc : Store_mem.Create.tbl_alloc;
}
type m_dzone
type dzone = Store_mem.Create.m_dzone Store_mem.Create.F.term
val addr_format : D.format
val model_addr : D.integer -> D.integer -> D.integer
val model_base : D.integer -> D.integer
val model_offset : D.integer -> D.integer
val model_addr_shift : D.integer -> D.integer -> D.integer
val model_addr_of_pointer :
Store_mem.Create.Model.D.pointer -> D.integer
val model_offset_of_pointer : D.pointer -> D.integer
val model_pointer_of_addr : D.integer -> D.pointer
val model_valid :
Store_mem.Create.tbl_alloc ->
D.integer -> D.integer -> Store_mem.Create.F.pred
val model_isfresh :
Store_mem.Create.store ->
Store_mem.Create.tbl_alloc -> D.integer -> Store_mem.Create.F.pred
val model_alloc :
Store_mem.Create.tbl_alloc ->
D.integer -> D.integer -> Store_mem.Create.tbl_alloc
val model_free :
Store_mem.Create.tbl_alloc ->
D.integer -> Store_mem.Create.tbl_alloc
val model_block :
Store_mem.Create.tbl_alloc -> D.integer -> D.integer
val model_access : Store_mem.Create.store -> D.integer -> D.abstract
val model_update :
Store_mem.Create.store ->
D.integer -> D.abstract -> Store_mem.Create.store
val model_zempty : Store_mem.Create.dzone
val model_zunion :
Store_mem.Create.dzone ->
Store_mem.Create.dzone -> Store_mem.Create.dzone
val model_included :
Store_mem.Create.dzone ->
Store_mem.Create.dzone -> Store_mem.Create.F.pred
val model_zrange :
D.integer -> D.integer -> D.integer -> Store_mem.Create.dzone
val model_zrange_of_addr_range :
D.integer -> D.integer -> D.integer -> Store_mem.Create.dzone
val model_separated :
Store_mem.Create.dzone ->
Store_mem.Create.dzone -> Store_mem.Create.F.pred
val model_update_range :
Store_mem.Create.store ->
Store_mem.Create.dzone -> D.abstract -> Store_mem.Create.store
val model_access_range :
Store_mem.Create.store -> Store_mem.Create.dzone -> D.abstract
val model_ishavoc :
Store_mem.Create.tbl_alloc ->
Store_mem.Create.store ->
Store_mem.Create.dzone ->
Store_mem.Create.store -> Store_mem.Create.F.pred
module Z :
sig
type base
val cvar : D.integer -> Cil_types.varinfo -> base
val root : D.integer -> base
val base : D.integer -> base
type path
val is_atomic : Ctypes.c_object -> bool
val p_block : atomic:bool -> Ctypes.c_object -> path
val p_field : atomic:bool -> path -> Cil_types.fieldinfo -> path
val p_index :
atomic:bool ->
path -> Ctypes.c_object -> offset:D.integer -> path
val p_range :
atomic:bool ->
path ->
Ctypes.c_object -> offset:D.integer -> length:D.integer -> path
val p_interval :
atomic:bool -> path -> Ctypes.c_object -> D.interval -> path
type region
val pp_region : Format.formatter -> region -> unit
val empty : region
val union : region -> region -> region
val block : base -> region
val index : base -> D.integer -> region
val range : base -> D.integer -> D.integer -> region
val path : base -> path -> region
val is_empty : region -> D.F.pred
val included : region -> region -> D.F.pred
val separated : region -> region -> D.F.pred
val fingerprint :
D.F.pool -> region -> D.F.var list * D.F.pred * region
val a_sizeof : Ctypes.c_object -> D.integer
end
val zero : Formula.integer Store_mem.Create.F.term
val one : Formula.integer Store_mem.Create.F.term
val sub :
Formula.integer Store_mem.Create.F.term ->
Formula.integer Store_mem.Create.F.term ->
Formula.integer Store_mem.Create.F.term
val add :
Formula.integer Store_mem.Create.F.term ->
Formula.integer Store_mem.Create.F.term ->
Formula.integer Store_mem.Create.F.term
val mul :
Formula.integer Store_mem.Create.F.term ->
Formula.integer Store_mem.Create.F.term ->
Formula.integer Store_mem.Create.F.term
val sizeof :
Ctypes.c_object -> Formula.integer Store_mem.Create.F.term
val n_size :
Formula.integer Store_mem.Create.F.term ->
Ctypes.c_object -> Formula.integer Store_mem.Create.F.term
val add_offset :
Formula.integer Store_mem.Create.F.term ->
Ctypes.c_object ->
Formula.integer Store_mem.Create.F.term ->
Formula.integer Store_mem.Create.F.term
val cardinal :
Formula.integer Store_mem.Create.F.term ->
Formula.integer Store_mem.Create.F.term ->
Formula.integer Store_mem.Create.F.term
val offset_of_field :
Cil_datatype.Fieldinfo.t -> Formula.integer Store_mem.Create.F.term
module Model :
sig
module A :
sig
module D :
sig
module F :
sig
type 'a term = 'a D.F.term
type pred = D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string ->
Formula.abstract term list -> Formula.abstract term
val p_call :
string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg :
Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term ->
Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term ->
Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot :
Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real :
Formula.real term -> Formula.integer term
val real_of_integer :
Formula.integer term -> Formula.real term
val e_bool :
Formula.boolean term -> Formula.integer term
val e_not :
Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term ->
'a term -> 'a term -> 'a term
val p_cond :
Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = D.F.var
type pool = D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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 = D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter ->
pred Formula.declaration -> unit
val pp_goal :
Format.formatter -> string -> pred -> unit
end
type format = Formula.m_format F.term
type abstract = Formula.abstract F.term
type integer = Formula.integer F.term
type real = Formula.real F.term
type boolean = Formula.boolean F.term
type record = Formula.m_array F.term
type urecord = Formula.m_array F.term
type array = Formula.m_array F.term
type set = Formula.m_set F.term
type name = Formula.integer F.term
type pointer = Formula.m_pointer F.term
val pp_kind : Format.formatter -> Mdata.kind -> unit
type interval =
D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a D.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit
val e_app0 : string -> 'a F.term
val e_app1 : string -> 'a F.term -> 'b F.term
val e_app2 :
string -> 'a F.term -> 'b F.term -> 'c F.term
val e_app3 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term
val e_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term
val e_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> 'f F.term
val p_app0 : string -> F.pred
val p_app1 : string -> 'a F.term -> F.pred
val p_app2 : string -> 'a F.term -> 'b F.term -> F.pred
val p_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> F.pred
val p_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> F.pred
val p_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> F.pred
val tau_of_logic_type :
Cil_types.logic_type -> Formula.tau
type context = D.context
type bindings = D.bindings
class type hint =
object
method capture : F.var list -> unit
method has_var : F.var list -> bool
method pretty : Format.formatter -> unit
method subst :
F.var -> Formula.abstract F.term -> unit
end
val closed : bindings
val close : bindings -> F.pred -> F.pred
val capture : hint list -> bindings -> unit
val push :
string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val has_vars : F.var list -> F.pred -> bool
type substitution = D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
D.havoc =
Fresh of F.var
| Update of F.var *
(substitution -> Formula.abstract F.term)
val havoc_static : havoc list -> F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : F.pred Formula.declaration -> unit
val iter :
Formula.section ->
(F.pred Formula.declaration -> unit) -> unit
val iter_all :
(F.pred Formula.declaration -> unit) -> unit
val dummy : unit -> F.pred
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 -> Log.source 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 -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
end
module Register :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition :
t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = D.Varinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Varaddr.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Fieldinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Compinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Arrayinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Logicvar.H.key
type 'a t = 'a D.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 -> Log.source option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition :
t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
val modulo : Ctypes.c_int -> integer -> integer
val guard : Ctypes.c_int -> integer -> F.pred
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
val round : Ctypes.c_float -> real -> real
val f_guard : Ctypes.c_float -> real -> F.pred
val f_convert :
Ctypes.c_float -> Ctypes.c_float -> real -> real
val has_type : abstract -> Cil_types.logic_type -> F.pred
val get_range_index : array -> interval -> abstract
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 equal_pointer_bool : pointer -> pointer -> boolean
val lt_pointer_bool : pointer -> pointer -> boolean
val le_pointer_bool : pointer -> pointer -> boolean
val lt_pointer : pointer -> pointer -> F.pred
val le_pointer : pointer -> pointer -> F.pred
val minus_pointer : pointer -> pointer -> integer
val is_null : pointer -> boolean
val null : pointer
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val int_format : format
val real_format : format
val pointer_format : format
val record_format : format
val urecord_format : format
val array_format : format -> format
val format_of_object : Ctypes.c_object -> format
val decode : format -> abstract -> 'a F.term
val encode : format -> 'a F.term -> abstract
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
val equal :
Ctypes.c_object -> abstract -> abstract -> F.pred
val eq_array :
Ctypes.arrayinfo -> array -> array -> F.pred
val eq_record :
Cil_types.compinfo -> record -> record -> F.pred
end
val i_neg : Ctypes.c_int -> D.integer -> D.integer
val i_op :
Ctypes.c_int ->
Formula.integer_op -> D.integer -> D.integer -> D.integer
val i_cmp :
Ctypes.c_int ->
Formula.cmp_op -> D.integer -> D.integer -> D.boolean
val bits_not : Ctypes.c_int -> D.integer -> D.integer
val bits_and :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_or :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_xor :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_lshift :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_rshift :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
end
module R :
sig
module D :
sig
module F :
sig
type 'a term = 'a D.F.term
type pred = D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string ->
Formula.abstract term list -> Formula.abstract term
val p_call :
string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg :
Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term ->
Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term ->
Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot :
Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real :
Formula.real term -> Formula.integer term
val real_of_integer :
Formula.integer term -> Formula.real term
val e_bool :
Formula.boolean term -> Formula.integer term
val e_not :
Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term ->
'a term -> 'a term -> 'a term
val p_cond :
Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = D.F.var
type pool = D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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 = D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter ->
pred Formula.declaration -> unit
val pp_goal :
Format.formatter -> string -> pred -> unit
end
type format = Formula.m_format F.term
type abstract = Formula.abstract F.term
type integer = Formula.integer F.term
type real = Formula.real F.term
type boolean = Formula.boolean F.term
type record = Formula.m_array F.term
type urecord = Formula.m_array F.term
type array = Formula.m_array F.term
type set = Formula.m_set F.term
type name = Formula.integer F.term
type pointer = Formula.m_pointer F.term
val pp_kind : Format.formatter -> Mdata.kind -> unit
type interval =
D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a D.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit
val e_app0 : string -> 'a F.term
val e_app1 : string -> 'a F.term -> 'b F.term
val e_app2 :
string -> 'a F.term -> 'b F.term -> 'c F.term
val e_app3 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term
val e_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term
val e_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> 'f F.term
val p_app0 : string -> F.pred
val p_app1 : string -> 'a F.term -> F.pred
val p_app2 : string -> 'a F.term -> 'b F.term -> F.pred
val p_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> F.pred
val p_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> F.pred
val p_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> F.pred
val tau_of_logic_type :
Cil_types.logic_type -> Formula.tau
type context = D.context
type bindings = D.bindings
class type hint =
object
method capture : F.var list -> unit
method has_var : F.var list -> bool
method pretty : Format.formatter -> unit
method subst :
F.var -> Formula.abstract F.term -> unit
end
val closed : bindings
val close : bindings -> F.pred -> F.pred
val capture : hint list -> bindings -> unit
val push :
string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val has_vars : F.var list -> F.pred -> bool
type substitution = D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
D.havoc =
Fresh of F.var
| Update of F.var *
(substitution -> Formula.abstract F.term)
val havoc_static : havoc list -> F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : F.pred Formula.declaration -> unit
val iter :
Formula.section ->
(F.pred Formula.declaration -> unit) -> unit
val iter_all :
(F.pred Formula.declaration -> unit) -> unit
val dummy : unit -> F.pred
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 -> Log.source 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 -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
end
module Register :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition :
t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = D.Varinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Varaddr.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Fieldinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Compinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Arrayinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Logicvar.H.key
type 'a t = 'a D.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 -> Log.source option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition :
t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
val modulo : Ctypes.c_int -> integer -> integer
val guard : Ctypes.c_int -> integer -> F.pred
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
val round : Ctypes.c_float -> real -> real
val f_guard : Ctypes.c_float -> real -> F.pred
val f_convert :
Ctypes.c_float -> Ctypes.c_float -> real -> real
val has_type : abstract -> Cil_types.logic_type -> F.pred
val get_range_index : array -> interval -> abstract
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 equal_pointer_bool : pointer -> pointer -> boolean
val lt_pointer_bool : pointer -> pointer -> boolean
val le_pointer_bool : pointer -> pointer -> boolean
val lt_pointer : pointer -> pointer -> F.pred
val le_pointer : pointer -> pointer -> F.pred
val minus_pointer : pointer -> pointer -> integer
val is_null : pointer -> boolean
val null : pointer
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val int_format : format
val real_format : format
val pointer_format : format
val record_format : format
val urecord_format : format
val array_format : format -> format
val format_of_object : Ctypes.c_object -> format
val decode : format -> abstract -> 'a F.term
val encode : format -> 'a F.term -> abstract
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
val equal :
Ctypes.c_object -> abstract -> abstract -> F.pred
val eq_array :
Ctypes.arrayinfo -> array -> array -> F.pred
val eq_record :
Cil_types.compinfo -> record -> record -> F.pred
end
val f_neg : Ctypes.c_float -> D.real -> D.real
val f_op :
Ctypes.c_float ->
Formula.real_op -> D.real -> D.real -> D.real
val f_cmp :
Ctypes.c_float ->
Formula.cmp_op -> D.real -> D.real -> D.boolean
end
module D :
sig
module F :
sig
type 'a term = 'a D.F.term
type pred = D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string ->
Formula.abstract term list -> Formula.abstract term
val p_call : string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg : Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term ->
Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term ->
Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term -> Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot : Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real :
Formula.real term -> Formula.integer term
val real_of_integer :
Formula.integer term -> Formula.real term
val e_bool : Formula.boolean term -> Formula.integer term
val e_not : Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term -> 'a term -> 'a term -> 'a term
val p_cond : Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = D.F.var
type pool = D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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 = D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter -> pred Formula.declaration -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
end
type format = Formula.m_format F.term
type abstract = Formula.abstract F.term
type integer = Formula.integer F.term
type real = Formula.real F.term
type boolean = Formula.boolean F.term
type record = Formula.m_array F.term
type urecord = Formula.m_array F.term
type array = Formula.m_array F.term
type set = Formula.m_set F.term
type name = Formula.integer F.term
type pointer = Formula.m_pointer F.term
val pp_kind : Format.formatter -> Mdata.kind -> unit
type interval =
D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a D.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit
val e_app0 : string -> 'a F.term
val e_app1 : string -> 'a F.term -> 'b F.term
val e_app2 : string -> 'a F.term -> 'b F.term -> 'c F.term
val e_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> 'd F.term
val e_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term
val e_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> 'f F.term
val p_app0 : string -> F.pred
val p_app1 : string -> 'a F.term -> F.pred
val p_app2 : string -> 'a F.term -> 'b F.term -> F.pred
val p_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> F.pred
val p_app4 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term -> F.pred
val p_app5 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term -> F.pred
val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
type context = D.context
type bindings = D.bindings
class type hint =
object
method capture : F.var list -> unit
method has_var : F.var list -> bool
method pretty : Format.formatter -> unit
method subst : F.var -> Formula.abstract F.term -> unit
end
val closed : bindings
val close : bindings -> F.pred -> F.pred
val capture : hint list -> bindings -> unit
val push :
string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val has_vars : F.var list -> F.pred -> bool
type substitution = D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
D.havoc =
Fresh of F.var
| Update of F.var *
(substitution -> Formula.abstract F.term)
val havoc_static : havoc list -> F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : F.pred Formula.declaration -> unit
val iter :
Formula.section ->
(F.pred Formula.declaration -> unit) -> unit
val iter_all : (F.pred Formula.declaration -> unit) -> unit
val dummy : unit -> F.pred
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 -> Log.source 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 -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
end
module Register :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = D.Varinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Varaddr.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Fieldinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Compinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Arrayinfo.H.key
type 'a t = 'a D.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 -> Log.source 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 = D.Logicvar.H.key
type 'a t = 'a D.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 -> Log.source option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
val modulo : Ctypes.c_int -> integer -> integer
val guard : Ctypes.c_int -> integer -> F.pred
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
val round : Ctypes.c_float -> real -> real
val f_guard : Ctypes.c_float -> real -> F.pred
val f_convert :
Ctypes.c_float -> Ctypes.c_float -> real -> real
val has_type : abstract -> Cil_types.logic_type -> F.pred
val get_range_index : array -> interval -> abstract
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 equal_pointer_bool : pointer -> pointer -> boolean
val lt_pointer_bool : pointer -> pointer -> boolean
val le_pointer_bool : pointer -> pointer -> boolean
val lt_pointer : pointer -> pointer -> F.pred
val le_pointer : pointer -> pointer -> F.pred
val minus_pointer : pointer -> pointer -> integer
val is_null : pointer -> boolean
val null : pointer
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val int_format : format
val real_format : format
val pointer_format : format
val record_format : format
val urecord_format : format
val array_format : format -> format
val format_of_object : Ctypes.c_object -> format
val decode : format -> abstract -> 'a F.term
val encode : format -> 'a F.term -> abstract
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
val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
val eq_record :
Cil_types.compinfo -> record -> record -> F.pred
end
type loc =
Loc of Cil_types.varinfo * Store_mem.Create.Model.D.integer
| Addr of Store_mem.Create.Model.D.integer
val addr :
Store_mem.Create.Model.loc -> Store_mem.Create.Model.D.integer
val base :
Store_mem.Create.Model.loc -> Store_mem.Create.Model.D.integer
val offset :
Store_mem.Create.Model.loc -> Store_mem.Create.Model.D.integer
val loc_of_pointer :
'a ->
Store_mem.Create.Model.D.pointer -> Store_mem.Create.Model.loc
val pointer_of_loc :
Store_mem.Create.Model.loc -> Store_mem.Create.Model.D.pointer
val cast_loc_to_int :
'a ->
Store_mem.Create.Model.loc ->
'b -> Store_mem.Create.Model.D.integer
val cast_int_to_loc :
'a ->
Store_mem.Create.Model.D.integer ->
'b -> Store_mem.Create.Model.loc
val pp_loc :
Format.formatter -> Store_mem.Create.Model.loc -> unit
end
module Globals :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> D.F.pred Formula.declaration
val on_definition :
(t -> D.F.pred Formula.declaration -> unit) -> unit
end
module Data :
sig
module D :
sig
module F :
sig
type 'a term = 'a Model.D.F.term
type pred = Model.D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string ->
Formula.abstract term list -> Formula.abstract term
val p_call : string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg : Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term ->
Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term ->
Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term -> Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot : Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real :
Formula.real term -> Formula.integer term
val real_of_integer :
Formula.integer term -> Formula.real term
val e_bool : Formula.boolean term -> Formula.integer term
val e_not : Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term -> 'a term -> 'a term -> 'a term
val p_cond : Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = Model.D.F.var
type pool = Model.D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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.D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter -> pred Formula.declaration -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
end
type format = Formula.m_format F.term
type abstract = Formula.abstract F.term
type integer = Formula.integer F.term
type real = Formula.real F.term
type boolean = Formula.boolean F.term
type record = Formula.m_array F.term
type urecord = Formula.m_array F.term
type array = Formula.m_array F.term
type set = Formula.m_set F.term
type name = Formula.integer F.term
type pointer = Formula.m_pointer F.term
val pp_kind : Format.formatter -> Mdata.kind -> unit
type interval =
Model.D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.D.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit
val e_app0 : string -> 'a F.term
val e_app1 : string -> 'a F.term -> 'b F.term
val e_app2 : string -> 'a F.term -> 'b F.term -> 'c F.term
val e_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> 'd F.term
val e_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term
val e_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> 'f F.term
val p_app0 : string -> F.pred
val p_app1 : string -> 'a F.term -> F.pred
val p_app2 : string -> 'a F.term -> 'b F.term -> F.pred
val p_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> F.pred
val p_app4 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term -> F.pred
val p_app5 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term -> F.pred
val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
type context = Model.D.context
type bindings = Model.D.bindings
class type hint =
object
method capture : F.var list -> unit
method has_var : F.var list -> bool
method pretty : Format.formatter -> unit
method subst : F.var -> Formula.abstract F.term -> unit
end
val closed : bindings
val close : bindings -> F.pred -> F.pred
val capture : hint list -> bindings -> unit
val push :
string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val has_vars : F.var list -> F.pred -> bool
type substitution = Model.D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
Model.D.havoc =
Fresh of F.var
| Update of F.var *
(substitution -> Formula.abstract F.term)
val havoc_static : havoc list -> F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : F.pred Formula.declaration -> unit
val iter :
Formula.section ->
(F.pred Formula.declaration -> unit) -> unit
val iter_all : (F.pred Formula.declaration -> unit) -> unit
val dummy : unit -> F.pred
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 -> Log.source 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 -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
end
module Register :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.D.Varinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Varaddr.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Fieldinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Compinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Arrayinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Logicvar.H.key
type 'a t = 'a Model.D.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 -> Log.source option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
val modulo : Ctypes.c_int -> integer -> integer
val guard : Ctypes.c_int -> integer -> F.pred
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
val round : Ctypes.c_float -> real -> real
val f_guard : Ctypes.c_float -> real -> F.pred
val f_convert :
Ctypes.c_float -> Ctypes.c_float -> real -> real
val has_type : abstract -> Cil_types.logic_type -> F.pred
val get_range_index : array -> interval -> abstract
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 equal_pointer_bool : pointer -> pointer -> boolean
val lt_pointer_bool : pointer -> pointer -> boolean
val le_pointer_bool : pointer -> pointer -> boolean
val lt_pointer : pointer -> pointer -> F.pred
val le_pointer : pointer -> pointer -> F.pred
val minus_pointer : pointer -> pointer -> integer
val is_null : pointer -> boolean
val null : pointer
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val int_format : format
val real_format : format
val pointer_format : format
val record_format : format
val urecord_format : format
val array_format : format -> format
val format_of_object : Ctypes.c_object -> format
val decode : format -> abstract -> 'a F.term
val encode : format -> 'a F.term -> abstract
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
val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
val eq_record :
Cil_types.compinfo -> record -> record -> F.pred
end
module A :
sig
module D :
sig
module F :
sig
type 'a term = 'a Model.D.F.term
type pred = Model.D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string ->
Formula.abstract term list -> Formula.abstract term
val p_call :
string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg :
Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term ->
Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term ->
Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot :
Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real :
Formula.real term -> Formula.integer term
val real_of_integer :
Formula.integer term -> Formula.real term
val e_bool :
Formula.boolean term -> Formula.integer term
val e_not :
Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term ->
'a term -> 'a term -> 'a term
val p_cond :
Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = Model.D.F.var
type pool = Model.D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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.D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter ->
pred Formula.declaration -> unit
val pp_goal :
Format.formatter -> string -> pred -> unit
end
type format = Formula.m_format F.term
type abstract = Formula.abstract F.term
type integer = Formula.integer F.term
type real = Formula.real F.term
type boolean = Formula.boolean F.term
type record = Formula.m_array F.term
type urecord = Formula.m_array F.term
type array = Formula.m_array F.term
type set = Formula.m_set F.term
type name = Formula.integer F.term
type pointer = Formula.m_pointer F.term
val pp_kind : Format.formatter -> Mdata.kind -> unit
type interval =
Model.D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.D.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit
val e_app0 : string -> 'a F.term
val e_app1 : string -> 'a F.term -> 'b F.term
val e_app2 :
string -> 'a F.term -> 'b F.term -> 'c F.term
val e_app3 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term
val e_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term
val e_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> 'f F.term
val p_app0 : string -> F.pred
val p_app1 : string -> 'a F.term -> F.pred
val p_app2 : string -> 'a F.term -> 'b F.term -> F.pred
val p_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> F.pred
val p_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> F.pred
val p_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> F.pred
val tau_of_logic_type :
Cil_types.logic_type -> Formula.tau
type context = Model.D.context
type bindings = Model.D.bindings
class type hint =
object
method capture : F.var list -> unit
method has_var : F.var list -> bool
method pretty : Format.formatter -> unit
method subst :
F.var -> Formula.abstract F.term -> unit
end
val closed : bindings
val close : bindings -> F.pred -> F.pred
val capture : hint list -> bindings -> unit
val push :
string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val has_vars : F.var list -> F.pred -> bool
type substitution = Model.D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
Model.D.havoc =
Fresh of F.var
| Update of F.var *
(substitution -> Formula.abstract F.term)
val havoc_static : havoc list -> F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : F.pred Formula.declaration -> unit
val iter :
Formula.section ->
(F.pred Formula.declaration -> unit) -> unit
val iter_all :
(F.pred Formula.declaration -> unit) -> unit
val dummy : unit -> F.pred
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 -> Log.source 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 -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
end
module Register :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition :
t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.D.Varinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Varaddr.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Fieldinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Compinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Arrayinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Logicvar.H.key
type 'a t = 'a Model.D.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 -> Log.source option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition :
t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
val modulo : Ctypes.c_int -> integer -> integer
val guard : Ctypes.c_int -> integer -> F.pred
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
val round : Ctypes.c_float -> real -> real
val f_guard : Ctypes.c_float -> real -> F.pred
val f_convert :
Ctypes.c_float -> Ctypes.c_float -> real -> real
val has_type : abstract -> Cil_types.logic_type -> F.pred
val get_range_index : array -> interval -> abstract
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 equal_pointer_bool : pointer -> pointer -> boolean
val lt_pointer_bool : pointer -> pointer -> boolean
val le_pointer_bool : pointer -> pointer -> boolean
val lt_pointer : pointer -> pointer -> F.pred
val le_pointer : pointer -> pointer -> F.pred
val minus_pointer : pointer -> pointer -> integer
val is_null : pointer -> boolean
val null : pointer
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val int_format : format
val real_format : format
val pointer_format : format
val record_format : format
val urecord_format : format
val array_format : format -> format
val format_of_object : Ctypes.c_object -> format
val decode : format -> abstract -> 'a F.term
val encode : format -> 'a F.term -> abstract
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
val equal :
Ctypes.c_object -> abstract -> abstract -> F.pred
val eq_array :
Ctypes.arrayinfo -> array -> array -> F.pred
val eq_record :
Cil_types.compinfo -> record -> record -> F.pred
end
val i_neg : Ctypes.c_int -> D.integer -> D.integer
val i_op :
Ctypes.c_int ->
Formula.integer_op -> D.integer -> D.integer -> D.integer
val i_cmp :
Ctypes.c_int ->
Formula.cmp_op -> D.integer -> D.integer -> D.boolean
val bits_not : Ctypes.c_int -> D.integer -> D.integer
val bits_and :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_or :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_xor :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_lshift :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_rshift :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
end
module R :
sig
module D :
sig
module F :
sig
type 'a term = 'a Model.D.F.term
type pred = Model.D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string ->
Formula.abstract term list -> Formula.abstract term
val p_call :
string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg :
Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term ->
Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term ->
Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot :
Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real :
Formula.real term -> Formula.integer term
val real_of_integer :
Formula.integer term -> Formula.real term
val e_bool :
Formula.boolean term -> Formula.integer term
val e_not :
Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term ->
'a term -> 'a term -> 'a term
val p_cond :
Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = Model.D.F.var
type pool = Model.D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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.D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter ->
pred Formula.declaration -> unit
val pp_goal :
Format.formatter -> string -> pred -> unit
end
type format = Formula.m_format F.term
type abstract = Formula.abstract F.term
type integer = Formula.integer F.term
type real = Formula.real F.term
type boolean = Formula.boolean F.term
type record = Formula.m_array F.term
type urecord = Formula.m_array F.term
type array = Formula.m_array F.term
type set = Formula.m_set F.term
type name = Formula.integer F.term
type pointer = Formula.m_pointer F.term
val pp_kind : Format.formatter -> Mdata.kind -> unit
type interval =
Model.D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.D.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit
val e_app0 : string -> 'a F.term
val e_app1 : string -> 'a F.term -> 'b F.term
val e_app2 :
string -> 'a F.term -> 'b F.term -> 'c F.term
val e_app3 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term
val e_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term
val e_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> 'f F.term
val p_app0 : string -> F.pred
val p_app1 : string -> 'a F.term -> F.pred
val p_app2 : string -> 'a F.term -> 'b F.term -> F.pred
val p_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> F.pred
val p_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> F.pred
val p_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> F.pred
val tau_of_logic_type :
Cil_types.logic_type -> Formula.tau
type context = Model.D.context
type bindings = Model.D.bindings
class type hint =
object
method capture : F.var list -> unit
method has_var : F.var list -> bool
method pretty : Format.formatter -> unit
method subst :
F.var -> Formula.abstract F.term -> unit
end
val closed : bindings
val close : bindings -> F.pred -> F.pred
val capture : hint list -> bindings -> unit
val push :
string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val has_vars : F.var list -> F.pred -> bool
type substitution = Model.D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
Model.D.havoc =
Fresh of F.var
| Update of F.var *
(substitution -> Formula.abstract F.term)
val havoc_static : havoc list -> F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : F.pred Formula.declaration -> unit
val iter :
Formula.section ->
(F.pred Formula.declaration -> unit) -> unit
val iter_all :
(F.pred Formula.declaration -> unit) -> unit
val dummy : unit -> F.pred
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 -> Log.source 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 -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
end
module Register :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition :
t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.D.Varinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Varaddr.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Fieldinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Compinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Arrayinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Logicvar.H.key
type 'a t = 'a Model.D.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 -> Log.source option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition :
t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
val modulo : Ctypes.c_int -> integer -> integer
val guard : Ctypes.c_int -> integer -> F.pred
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
val round : Ctypes.c_float -> real -> real
val f_guard : Ctypes.c_float -> real -> F.pred
val f_convert :
Ctypes.c_float -> Ctypes.c_float -> real -> real
val has_type : abstract -> Cil_types.logic_type -> F.pred
val get_range_index : array -> interval -> abstract
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 equal_pointer_bool : pointer -> pointer -> boolean
val lt_pointer_bool : pointer -> pointer -> boolean
val le_pointer_bool : pointer -> pointer -> boolean
val lt_pointer : pointer -> pointer -> F.pred
val le_pointer : pointer -> pointer -> F.pred
val minus_pointer : pointer -> pointer -> integer
val is_null : pointer -> boolean
val null : pointer
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val int_format : format
val real_format : format
val pointer_format : format
val record_format : format
val urecord_format : format
val array_format : format -> format
val format_of_object : Ctypes.c_object -> format
val decode : format -> abstract -> 'a F.term
val encode : format -> 'a F.term -> abstract
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
val equal :
Ctypes.c_object -> abstract -> abstract -> F.pred
val eq_array :
Ctypes.arrayinfo -> array -> array -> F.pred
val eq_record :
Cil_types.compinfo -> record -> record -> F.pred
end
val f_neg : Ctypes.c_float -> D.real -> D.real
val f_op :
Ctypes.c_float ->
Formula.real_op -> D.real -> D.real -> D.real
val f_cmp :
Ctypes.c_float ->
Formula.cmp_op -> D.real -> D.real -> D.boolean
end
type loc = Model.loc
val loc_of_pointer : Ctypes.c_object -> D.pointer -> loc
val pointer_of_loc : loc -> D.pointer
val cast_loc_to_int :
Cil_types.typ -> loc -> Ctypes.c_int -> D.integer
val cast_int_to_loc :
Ctypes.c_int -> D.integer -> Cil_types.typ -> loc
val pp_loc : Format.formatter -> loc -> unit
type value =
Datalib.Cvalues(Model).value =
V_int of Ctypes.c_int * D.integer
| V_float of Ctypes.c_float * D.real
| V_pointer of Cil_types.typ * loc
| V_record of Cil_types.compinfo * D.record
| V_union of Cil_types.compinfo * D.urecord
| V_array of Ctypes.arrayinfo * D.array
val pp_value : Format.formatter -> value -> unit
val logic_of_value : value -> D.abstract
val value_of_logic : Ctypes.c_object -> D.abstract -> value
type m_of_mem = Store_mem.Create.m_memory
val tau_of_mem : Formula.tau
val forall_loc :
Store_mem.Create.F.pool ->
Store_mem.Create.F.var list * Store_mem.Create.Model.loc
val load_rec :
(Store_mem.Create.Data.m_of_mem D.F.term ->
Ctypes.c_object -> loc -> value)
Pervasives.ref
val store_rec :
(Store_mem.Create.Data.m_of_mem D.F.term ->
Ctypes.c_object ->
loc -> value -> Store_mem.Create.Data.m_of_mem D.F.term)
Pervasives.ref
val define_vinfo : Store_mem.Create.Globals.t -> unit
val cvar_of_var :
Store_mem.Create.Globals.t -> Store_mem.Create.Model.loc
val cvar :
'a -> Store_mem.Create.Globals.t -> Store_mem.Create.Model.loc
val offset :
Store_mem.Create.Model.loc ->
Ctypes.c_object ->
Formula.integer Store_mem.Create.F.term ->
Store_mem.Create.Model.loc
val shift :
Store_mem.Create.Model.loc ->
Ctypes.c_object ->
Formula.integer Store_mem.Create.F.term ->
Store_mem.Create.Model.loc
val index :
Store_mem.Create.Model.loc ->
Ctypes.c_object ->
Formula.integer Store_mem.Create.F.term ->
Store_mem.Create.Model.loc
val field :
Store_mem.Create.Model.loc ->
Cil_datatype.Fieldinfo.t -> Store_mem.Create.Model.loc
val load_mem :
Store_mem.Create.Data.m_of_mem D.F.term ->
Ctypes.c_object -> loc -> value
val store_mem :
Store_mem.Create.Data.m_of_mem D.F.term ->
Ctypes.c_object ->
loc -> value -> Store_mem.Create.Data.m_of_mem D.F.term
end
module DF :
sig
val record_format : Cil_types.compinfo -> Data.D.format
val array_format : Ctypes.arrayinfo -> Data.D.format
val loaded : Ctypes.c_object -> unit
val stored : Ctypes.c_object -> unit
end
module D :
sig
module F :
sig
type 'a term = 'a Model.D.F.term
type pred = Model.D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string ->
Formula.abstract term list -> Formula.abstract term
val p_call : string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg : Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term -> Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term ->
Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term -> Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot : Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real :
Formula.real term -> Formula.integer term
val real_of_integer :
Formula.integer term -> Formula.real term
val e_bool : Formula.boolean term -> Formula.integer term
val e_not : Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term -> 'a term -> 'a term -> 'a term
val p_cond : Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = Model.D.F.var
type pool = Model.D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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.D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter -> pred Formula.declaration -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
end
type format = Formula.m_format F.term
type abstract = Formula.abstract F.term
type integer = Formula.integer F.term
type real = Formula.real F.term
type boolean = Formula.boolean F.term
type record = Formula.m_array F.term
type urecord = Formula.m_array F.term
type array = Formula.m_array F.term
type set = Formula.m_set F.term
type name = Formula.integer F.term
type pointer = Formula.m_pointer F.term
val pp_kind : Format.formatter -> Mdata.kind -> unit
type interval =
Model.D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.D.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit
val e_app0 : string -> 'a F.term
val e_app1 : string -> 'a F.term -> 'b F.term
val e_app2 : string -> 'a F.term -> 'b F.term -> 'c F.term
val e_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> 'd F.term
val e_app4 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term -> 'e F.term
val e_app5 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term -> 'f F.term
val p_app0 : string -> F.pred
val p_app1 : string -> 'a F.term -> F.pred
val p_app2 : string -> 'a F.term -> 'b F.term -> F.pred
val p_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> F.pred
val p_app4 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term -> F.pred
val p_app5 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term -> F.pred
val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
type context = Model.D.context
type bindings = Model.D.bindings
class type hint =
object
method capture : F.var list -> unit
method has_var : F.var list -> bool
method pretty : Format.formatter -> unit
method subst : F.var -> Formula.abstract F.term -> unit
end
val closed : bindings
val close : bindings -> F.pred -> F.pred
val capture : hint list -> bindings -> unit
val push : string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val has_vars : F.var list -> F.pred -> bool
type substitution = Model.D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
Model.D.havoc =
Fresh of F.var
| Update of F.var * (substitution -> Formula.abstract F.term)
val havoc_static : havoc list -> F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : F.pred Formula.declaration -> unit
val iter :
Formula.section -> (F.pred Formula.declaration -> unit) -> unit
val iter_all : (F.pred Formula.declaration -> unit) -> unit
val dummy : unit -> F.pred
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 -> Log.source 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 -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
end
module Register :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.D.Varinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Varaddr.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Fieldinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Compinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Arrayinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Logicvar.H.key
type 'a t = 'a Model.D.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 -> Log.source option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
val modulo : Ctypes.c_int -> integer -> integer
val guard : Ctypes.c_int -> integer -> F.pred
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
val round : Ctypes.c_float -> real -> real
val f_guard : Ctypes.c_float -> real -> F.pred
val f_convert : Ctypes.c_float -> Ctypes.c_float -> real -> real
val has_type : abstract -> Cil_types.logic_type -> F.pred
val get_range_index : array -> interval -> abstract
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 equal_pointer_bool : pointer -> pointer -> boolean
val lt_pointer_bool : pointer -> pointer -> boolean
val le_pointer_bool : pointer -> pointer -> boolean
val lt_pointer : pointer -> pointer -> F.pred
val le_pointer : pointer -> pointer -> F.pred
val minus_pointer : pointer -> pointer -> integer
val is_null : pointer -> boolean
val null : pointer
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val int_format : format
val real_format : format
val pointer_format : format
val record_format : format
val urecord_format : format
val array_format : format -> format
val format_of_object : Ctypes.c_object -> format
val decode : format -> abstract -> 'a F.term
val encode : format -> 'a F.term -> abstract
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
val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
val eq_record : Cil_types.compinfo -> record -> record -> F.pred
end
module A :
sig
module D :
sig
module F :
sig
type 'a term = 'a Model.D.F.term
type pred = Model.D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string ->
Formula.abstract term list -> Formula.abstract term
val p_call : string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg : Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term ->
Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term ->
Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term -> Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot : Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real :
Formula.real term -> Formula.integer term
val real_of_integer :
Formula.integer term -> Formula.real term
val e_bool : Formula.boolean term -> Formula.integer term
val e_not : Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term -> 'a term -> 'a term -> 'a term
val p_cond : Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = Model.D.F.var
type pool = Model.D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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.D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter -> pred Formula.declaration -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
end
type format = Formula.m_format F.term
type abstract = Formula.abstract F.term
type integer = Formula.integer F.term
type real = Formula.real F.term
type boolean = Formula.boolean F.term
type record = Formula.m_array F.term
type urecord = Formula.m_array F.term
type array = Formula.m_array F.term
type set = Formula.m_set F.term
type name = Formula.integer F.term
type pointer = Formula.m_pointer F.term
val pp_kind : Format.formatter -> Mdata.kind -> unit
type interval =
Model.D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.D.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit
val e_app0 : string -> 'a F.term
val e_app1 : string -> 'a F.term -> 'b F.term
val e_app2 : string -> 'a F.term -> 'b F.term -> 'c F.term
val e_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> 'd F.term
val e_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term
val e_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> 'f F.term
val p_app0 : string -> F.pred
val p_app1 : string -> 'a F.term -> F.pred
val p_app2 : string -> 'a F.term -> 'b F.term -> F.pred
val p_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> F.pred
val p_app4 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term -> F.pred
val p_app5 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term -> F.pred
val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
type context = Model.D.context
type bindings = Model.D.bindings
class type hint =
object
method capture : F.var list -> unit
method has_var : F.var list -> bool
method pretty : Format.formatter -> unit
method subst : F.var -> Formula.abstract F.term -> unit
end
val closed : bindings
val close : bindings -> F.pred -> F.pred
val capture : hint list -> bindings -> unit
val push :
string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val has_vars : F.var list -> F.pred -> bool
type substitution = Model.D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
Model.D.havoc =
Fresh of F.var
| Update of F.var *
(substitution -> Formula.abstract F.term)
val havoc_static : havoc list -> F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : F.pred Formula.declaration -> unit
val iter :
Formula.section ->
(F.pred Formula.declaration -> unit) -> unit
val iter_all : (F.pred Formula.declaration -> unit) -> unit
val dummy : unit -> F.pred
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 -> Log.source 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 -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
end
module Register :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.D.Varinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Varaddr.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Fieldinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Compinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Arrayinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Logicvar.H.key
type 'a t = 'a Model.D.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 -> Log.source option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
val modulo : Ctypes.c_int -> integer -> integer
val guard : Ctypes.c_int -> integer -> F.pred
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
val round : Ctypes.c_float -> real -> real
val f_guard : Ctypes.c_float -> real -> F.pred
val f_convert :
Ctypes.c_float -> Ctypes.c_float -> real -> real
val has_type : abstract -> Cil_types.logic_type -> F.pred
val get_range_index : array -> interval -> abstract
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 equal_pointer_bool : pointer -> pointer -> boolean
val lt_pointer_bool : pointer -> pointer -> boolean
val le_pointer_bool : pointer -> pointer -> boolean
val lt_pointer : pointer -> pointer -> F.pred
val le_pointer : pointer -> pointer -> F.pred
val minus_pointer : pointer -> pointer -> integer
val is_null : pointer -> boolean
val null : pointer
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val int_format : format
val real_format : format
val pointer_format : format
val record_format : format
val urecord_format : format
val array_format : format -> format
val format_of_object : Ctypes.c_object -> format
val decode : format -> abstract -> 'a F.term
val encode : format -> 'a F.term -> abstract
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
val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
val eq_record :
Cil_types.compinfo -> record -> record -> F.pred
end
val i_neg : Ctypes.c_int -> D.integer -> D.integer
val i_op :
Ctypes.c_int ->
Formula.integer_op -> D.integer -> D.integer -> D.integer
val i_cmp :
Ctypes.c_int ->
Formula.cmp_op -> D.integer -> D.integer -> D.boolean
val bits_not : Ctypes.c_int -> D.integer -> D.integer
val bits_and :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_or : Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_xor :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_lshift :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
val bits_rshift :
Ctypes.c_int -> D.integer -> D.integer -> D.integer
end
module R :
sig
module D :
sig
module F :
sig
type 'a term = 'a Model.D.F.term
type pred = Model.D.F.pred
val e_int : int -> Formula.integer term
val e_call :
string ->
Formula.abstract term list -> Formula.abstract term
val p_call : string -> Formula.abstract term list -> pred
val wrap : 'a term -> Formula.abstract term
val unwrap : Formula.abstract term -> 'a term
val e_true : Formula.boolean term
val e_false : Formula.boolean term
val e_int : int -> Formula.integer term
val e_float : float -> Formula.real term
val e_icst : string -> Formula.integer term
val e_rcst : string -> Formula.real term
val e_int64 : int64 -> Formula.integer term
val e_ineg : Formula.integer term -> Formula.integer term
val e_rneg : Formula.real term -> Formula.real term
val e_iop :
Formula.integer_op ->
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rop :
Formula.real_op ->
Formula.real term ->
Formula.real term -> Formula.real term
val e_icmp :
Formula.cmp_op ->
Formula.integer term ->
Formula.integer term -> Formula.boolean term
val e_rcmp :
Formula.cmp_op ->
Formula.real term ->
Formula.real term -> Formula.boolean term
val p_icmp :
Formula.cmp_op ->
Formula.integer term -> Formula.integer term -> pred
val p_rcmp :
Formula.cmp_op ->
Formula.real term -> Formula.real term -> pred
val e_bnot : Formula.integer term -> Formula.integer term
val e_band :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_bxor :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_lshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val e_rshift :
Formula.integer term ->
Formula.integer term -> Formula.integer term
val integer_of_real :
Formula.real term -> Formula.integer term
val real_of_integer :
Formula.integer term -> Formula.real term
val e_bool : Formula.boolean term -> Formula.integer term
val e_not : Formula.boolean term -> Formula.boolean term
val e_and :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_or :
Formula.boolean term ->
Formula.boolean term -> Formula.boolean term
val e_cond :
Formula.boolean term -> 'a term -> 'a term -> 'a term
val p_cond : Formula.boolean term -> pred -> pred -> pred
val p_true : pred
val p_false : pred
val p_bool : Formula.boolean term -> 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 var = Model.D.F.var
type pool = Model.D.F.pool
val pool : unit -> pool
val fresh : pool -> string -> Formula.kind -> var
val freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_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_closed : 'a term -> bool
val pred_closed : pred -> bool
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.D.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_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl :
Format.formatter -> pred Formula.declaration -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
end
type format = Formula.m_format F.term
type abstract = Formula.abstract F.term
type integer = Formula.integer F.term
type real = Formula.real F.term
type boolean = Formula.boolean F.term
type record = Formula.m_array F.term
type urecord = Formula.m_array F.term
type array = Formula.m_array F.term
type set = Formula.m_set F.term
type name = Formula.integer F.term
type pointer = Formula.m_pointer F.term
val pp_kind : Format.formatter -> Mdata.kind -> unit
type interval =
Model.D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a Model.D.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit
val e_app0 : string -> 'a F.term
val e_app1 : string -> 'a F.term -> 'b F.term
val e_app2 : string -> 'a F.term -> 'b F.term -> 'c F.term
val e_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> 'd F.term
val e_app4 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term
val e_app5 :
string ->
'a F.term ->
'b F.term ->
'c F.term -> 'd F.term -> 'e F.term -> 'f F.term
val p_app0 : string -> F.pred
val p_app1 : string -> 'a F.term -> F.pred
val p_app2 : string -> 'a F.term -> 'b F.term -> F.pred
val p_app3 :
string -> 'a F.term -> 'b F.term -> 'c F.term -> F.pred
val p_app4 :
string ->
'a F.term -> 'b F.term -> 'c F.term -> 'd F.term -> F.pred
val p_app5 :
string ->
'a F.term ->
'b F.term -> 'c F.term -> 'd F.term -> 'e F.term -> F.pred
val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
type context = Model.D.context
type bindings = Model.D.bindings
class type hint =
object
method capture : F.var list -> unit
method has_var : F.var list -> bool
method pretty : Format.formatter -> unit
method subst : F.var -> Formula.abstract F.term -> unit
end
val closed : bindings
val close : bindings -> F.pred -> F.pred
val capture : hint list -> bindings -> unit
val push :
string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val has_vars : F.var list -> F.pred -> bool
type substitution = Model.D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
Model.D.havoc =
Fresh of F.var
| Update of F.var *
(substitution -> Formula.abstract F.term)
val havoc_static : havoc list -> F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : F.pred Formula.declaration -> unit
val iter :
Formula.section ->
(F.pred Formula.declaration -> unit) -> unit
val iter_all : (F.pred Formula.declaration -> unit) -> unit
val dummy : unit -> F.pred
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 -> Log.source 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 -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
end
module Register :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = Model.D.Varinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Varaddr.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Fieldinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Compinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Arrayinfo.H.key
type 'a t = 'a Model.D.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 -> Log.source 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.D.Logicvar.H.key
type 'a t = 'a Model.D.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 -> Log.source option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> F.pred Formula.declaration
val on_definition :
(t -> F.pred Formula.declaration -> unit) -> unit
val get_ind : t -> integer
end
val modulo : Ctypes.c_int -> integer -> integer
val guard : Ctypes.c_int -> integer -> F.pred
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
val round : Ctypes.c_float -> real -> real
val f_guard : Ctypes.c_float -> real -> F.pred
val f_convert :
Ctypes.c_float -> Ctypes.c_float -> real -> real
val has_type : abstract -> Cil_types.logic_type -> F.pred
val get_range_index : array -> interval -> abstract
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 equal_pointer_bool : pointer -> pointer -> boolean
val lt_pointer_bool : pointer -> pointer -> boolean
val le_pointer_bool : pointer -> pointer -> boolean
val lt_pointer : pointer -> pointer -> F.pred
val le_pointer : pointer -> pointer -> F.pred
val minus_pointer : pointer -> pointer -> integer
val is_null : pointer -> boolean
val null : pointer
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val int_format : format
val real_format : format
val pointer_format : format
val record_format : format
val urecord_format : format
val array_format : format -> format
val format_of_object : Ctypes.c_object -> format
val decode : format -> abstract -> 'a F.term
val encode : format -> 'a F.term -> abstract
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
val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
val eq_record :
Cil_types.compinfo -> record -> record -> F.pred
end
val f_neg : Ctypes.c_float -> D.real -> D.real
val f_op :
Ctypes.c_float -> Formula.real_op -> D.real -> D.real -> D.real
val f_cmp :
Ctypes.c_float ->
Formula.cmp_op -> D.real -> D.real -> D.boolean
end
type loc = Model.loc
val loc_of_pointer : Ctypes.c_object -> D.pointer -> loc
val pointer_of_loc : loc -> D.pointer
val cast_loc_to_int :
Cil_types.typ -> loc -> Ctypes.c_int -> D.integer
val cast_int_to_loc :
Ctypes.c_int -> D.integer -> Cil_types.typ -> loc
val pp_loc : Format.formatter -> loc -> unit
type value =
Datalib.Cvalues(Model).value =
V_int of Ctypes.c_int * D.integer
| V_float of Ctypes.c_float * D.real
| V_pointer of Cil_types.typ * loc
| V_record of Cil_types.compinfo * D.record
| V_union of Cil_types.compinfo * D.urecord
| V_array of Ctypes.arrayinfo * D.array
val pp_value : Format.formatter -> value -> unit
val logic_of_value : value -> D.abstract
val value_of_logic : Ctypes.c_object -> D.abstract -> value
type m_of_mem = m_memory
val tau_of_mem : Formula.tau
val forall_loc : F.pool -> F.var list * Model.loc
val load_rec :
(m_of_mem D.F.term -> Ctypes.c_object -> loc -> value) ref
val store_rec :
(m_of_mem D.F.term ->
Ctypes.c_object -> loc -> value -> m_of_mem D.F.term)
ref
val define_vinfo : Globals.t -> unit
val cvar_of_var : Globals.t -> Model.loc
val cvar : 'a -> Globals.t -> Model.loc
val offset :
Model.loc -> Ctypes.c_object -> Formula.integer F.term -> Model.loc
val shift :
Model.loc -> Ctypes.c_object -> Formula.integer F.term -> Model.loc
val index :
Model.loc -> Ctypes.c_object -> Formula.integer F.term -> Model.loc
val field : Model.loc -> Cil_datatype.Fieldinfo.t -> Model.loc
val load_mem : m_of_mem D.F.term -> Ctypes.c_object -> loc -> value
val store_mem :
m_of_mem D.F.term ->
Ctypes.c_object -> loc -> value -> m_of_mem D.F.term
val startof :
Store_mem.Create.Model.loc -> 'a -> Store_mem.Create.Model.loc
val base_address :
'a -> Store_mem.Create.Model.loc -> Store_mem.Create.Model.loc
val block_length :
Store_mem.Create.mem -> Store_mem.Create.Model.loc -> D.integer
val cast_loc_to_loc : 'a -> 'b -> 'c -> 'd
val zrange :
Store_mem.Create.Model.loc -> D.integer -> Store_mem.Create.dzone
val load_with :
D.format ->
Store_mem.Create.store -> Store_mem.Create.Model.loc -> 'a D.F.term
val load_mem :
Store_mem.Create.store ->
Ctypes.c_object -> Store_mem.Create.Model.loc -> value
val store_with :
Store_mem.Create.store ->
Store_mem.Create.Model.loc ->
D.format -> 'a D.F.term -> Store_mem.Create.store
val store_mem :
Store_mem.Create.store ->
Ctypes.c_object ->
Store_mem.Create.Model.loc -> value -> Store_mem.Create.store
val load :
Store_mem.Create.mem ->
Ctypes.c_object -> Store_mem.Create.Model.loc -> value
val tau_of_dzone : Formula.tau
type assignable =
Avar of Cil_types.varinfo * D.integer
| Aaddr of D.integer
| Arange of D.integer * D.integer * D.integer
val addr_of_assignable : Store_mem.Create.assignable -> D.integer
val zone_of_assignable :
Store_mem.Create.assignable -> Store_mem.Create.dzone
val assignable_loc :
'a -> Store_mem.Create.Model.loc -> Store_mem.Create.assignable
val assignable_range :
Ctypes.c_object ->
Store_mem.Create.Model.loc ->
D.interval -> Store_mem.Create.assignable
val assignable :
Store_mem.Create.Model.loc D.assigned ->
Store_mem.Create.assignable
val dzone_assigned :
Store_mem.Create.Model.loc D.assigned -> Store_mem.Create.dzone
val dzone_subset :
Store_mem.Create.dzone ->
Store_mem.Create.dzone -> Store_mem.Create.F.pred
val dzone_union :
Store_mem.Create.dzone ->
Store_mem.Create.dzone -> Store_mem.Create.dzone
val dzone_empty : unit -> Store_mem.Create.dzone
val effect_supported : bool
val assignable_sizeof :
'a D.assigned -> Formula.integer Store_mem.Create.F.term
val valid :
Store_mem.Create.mem ->
Store_mem.Create.Model.loc D.assigned -> Store_mem.Create.F.pred
val separated :
Store_mem.Create.Model.loc D.assigned ->
Store_mem.Create.Model.loc D.assigned -> Store_mem.Create.F.pred
type region = Store_mem.Create.Z.region
val pp_region : Format.formatter -> Store_mem.Create.Z.region -> unit
val region_of_loc :
Ctypes.c_object ->
Store_mem.Create.Model.loc -> Store_mem.Create.Z.region
val region_range :
Ctypes.c_object ->
Store_mem.Create.Model.loc ->
D.interval -> Store_mem.Create.Z.region
val region_assigned :
Store_mem.Create.Model.loc D.assigned -> Store_mem.Create.Z.region
val region_empty : unit -> Store_mem.Create.Z.region
val region_union :
Store_mem.Create.Z.region ->
Store_mem.Create.Z.region -> Store_mem.Create.Z.region
val region_included :
Store_mem.Create.Z.region -> Store_mem.Create.Z.region -> D.F.pred
val region_separated :
Store_mem.Create.Z.region -> Store_mem.Create.Z.region -> D.F.pred
val region_fingerprint :
D.F.pool ->
Store_mem.Create.Z.region ->
D.F.var list * D.F.pred * Store_mem.Create.Z.region
val region_supported : bool
type frame = {
mutable states :
(Clabels.c_label *
(Store_mem.Create.F.var * Store_mem.Create.F.var))
list;
mutable memories : (Clabels.c_label * Store_mem.Create.mem) list;
mutable result : Store_mem.Create.F.var option;
mutable exit_status : Store_mem.Create.F.var option;
return : Cil_types.typ option;
}
val new_frame :
Kernel_function.t ->
m_here:Store_mem.Create.mem option ->
m_pre:Store_mem.Create.mem option ->
m_post:Store_mem.Create.mem option ->
Store_mem.Create.F.var option -> Store_mem.Create.frame
val get_result :
Store_mem.Create.frame -> Store_mem.Create.F.var * Cil_types.typ
val get_exit : Store_mem.Create.frame -> Store_mem.Create.F.var
val set_exit_status :
Store_mem.Create.frame ->
Store_mem.Create.F.var -> Store_mem.Create.frame
val varmem_at :
Store_mem.Create.frame ->
Clabels.c_label -> Store_mem.Create.F.var * Store_mem.Create.F.var
val mem_at :
Store_mem.Create.frame -> Clabels.c_label -> Store_mem.Create.mem
val result :
Store_mem.Create.frame -> Store_mem.Create.F.var * Cil_types.typ
val exit_status : Store_mem.Create.frame -> Store_mem.Create.F.var
val get_exit_status :
Store_mem.Create.frame -> Store_mem.Create.F.var option
val update_at_label :
Store_mem.Create.frame -> Clabels.c_label -> D.F.pred -> D.F.pred
val quantify_at_label :
Store_mem.Create.frame -> Clabels.c_label -> D.F.pred -> D.F.pred
val subst_lval :
Store_mem.Create.frame ->
Ctypes.c_object ->
Store_mem.Create.Model.loc -> value -> D.F.pred -> D.F.pred
val subst_result :
Store_mem.Create.frame -> value option -> D.F.pred -> D.F.pred
val alloc_vars :
Store_mem.Create.frame -> D.Xindex.t list -> D.F.pred -> D.F.pred
val free_vars :
Store_mem.Create.frame -> D.Xindex.t list -> D.F.pred -> D.F.pred
val fresh_vars :
Store_mem.Create.frame ->
D.Xindex.t list ->
Store_mem.Create.F.pred -> Store_mem.Create.F.pred
val notexists_vars :
Store_mem.Create.frame ->
D.Xindex.t list ->
Store_mem.Create.F.pred -> Store_mem.Create.F.pred
val local_scope :
Store_mem.Create.frame ->
D.Xindex.t list ->
Mcfg.scope -> Store_mem.Create.F.pred -> Store_mem.Create.F.pred
val subst_havoc :
Store_mem.Create.frame ->
Store_mem.Create.Model.loc D.assigned -> D.havoc list
val region :
Store_mem.Create.Model.loc D.assigned list ->
Store_mem.Create.dzone
val assigns_goal :
Store_mem.Create.frame ->
Clabels.c_label ->
Store_mem.Create.Model.loc D.assigned list ->
Clabels.c_label -> Store_mem.Create.F.pred
val assigns_supported : bool
type closure = Mem of string | Alloc of string
val pp_closure : Format.formatter -> Store_mem.Create.closure -> unit
val userdef_frame : unit -> Store_mem.Create.frame
val userdef_signature :
Store_mem.Create.frame ->
'a ->
'b -> Store_mem.Create.F.var list * Store_mem.Create.closure list
val userdef_closure :
Store_mem.Create.mem ->
Store_mem.Create.closure ->
Formula.abstract Store_mem.Create.F.term
val label_at_closure : Store_mem.Create.closure -> string
end