functor (M : Mlogic.S) ->
sig
module F :
sig
type var = M.F.var
type 'a term = 'a M.F.term
type pred = M.F.pred
type abstract = Formula.m_abstract term
type integer = Formula.m_integer term
type real = Formula.m_real term
type boolean = Formula.m_boolean term
type record = Formula.m_record term
type urecord = Formula.m_array term
type array = Formula.m_array term
type set = Formula.m_set term
type name = Formula.m_integer term
type decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare : t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = M.F.Varinfo.H.key
type 'a t = 'a M.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = M.F.Varaddr.H.key
type 'a t = 'a M.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = M.F.Fieldinfo.H.key
type 'a t = 'a M.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = M.F.Compinfo.H.key
type 'a t = 'a M.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = M.F.Arrayinfo.H.key
type 'a t = 'a M.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = M.F.Logicvar.H.key
type 'a t = 'a M.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = M.F.LTypeinfo.H.key
type 'a t = 'a M.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = M.F.Cobject.H.key
type 'a t = 'a M.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = M.F.ArrayDim.H.key
type 'a t = 'a M.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop : Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield : Cil_types.fieldinfo -> record -> abstract
val e_setfield : Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = M.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst : (var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) -> var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = M.F.alpha
val empty_alpha : alpha
val fold_alpha : (var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 : string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert : Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
M.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a M.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
M.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field : record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
module L :
sig
module F :
sig
type var = M.F.var
type 'a term = 'a M.F.term
type pred = M.F.pred
type abstract = Formula.m_abstract term
type integer = Formula.m_integer term
type real = Formula.m_real term
type boolean = Formula.m_boolean term
type record = Formula.m_record term
type urecord = Formula.m_array term
type array = Formula.m_array term
type set = Formula.m_set term
type name = Formula.m_integer term
type decl = (var, abstract, pred) Formula.declaration
val e_int : int -> integer
val e_call : string -> abstract list -> abstract
val p_call : string -> abstract list -> pred
val wrap : 'a term -> abstract
val unwrap : abstract -> 'a term
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val fresh_name : string -> string -> string
val add_declaration : decl -> unit
val has_declaration : string -> bool
val iter_all : (string -> unit) -> (decl -> unit) -> unit
module type Identifiable =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module type Registry =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module type Declarator =
sig
type t
module H : Hashtbl.S
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
val clear : unit -> unit
val section : Formula.section
val declare :
t -> string -> (var, abstract, pred) Formula.item
end
module DRegister :
functor (D : Declarator) ->
sig
type t = D.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
end
module Varinfo :
sig
type t = Cil_types.varinfo
module H :
sig
type key = M.F.Varinfo.H.key
type 'a t = 'a M.F.Varinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Varaddr :
sig
type t = Cil_types.varinfo
module H :
sig
type key = M.F.Varaddr.H.key
type 'a t = 'a M.F.Varaddr.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Fieldinfo :
sig
type t = Cil_types.fieldinfo
module H :
sig
type key = M.F.Fieldinfo.H.key
type 'a t = 'a M.F.Fieldinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Compinfo :
sig
type t = Cil_types.compinfo
module H :
sig
type key = M.F.Compinfo.H.key
type 'a t = 'a M.F.Compinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Arrayinfo :
sig
type t = Ctypes.arrayinfo
module H :
sig
type key = M.F.Arrayinfo.H.key
type 'a t = 'a M.F.Arrayinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Logicvar :
sig
type t = Cil_types.logic_var
module H :
sig
type key = M.F.Logicvar.H.key
type 'a t = 'a M.F.Logicvar.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module LTypeinfo :
sig
type t = Cil_types.logic_type
module H :
sig
type key = M.F.LTypeinfo.H.key
type 'a t = 'a M.F.LTypeinfo.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module Cobject :
sig
type t = Ctypes.c_object
module H :
sig
type key = M.F.Cobject.H.key
type 'a t = 'a M.F.Cobject.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
module ArrayDim :
sig
type t = Ctypes.c_object * int
module H :
sig
type key = M.F.ArrayDim.H.key
type 'a t = 'a M.F.ArrayDim.H.t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
val index : t -> H.key
val prefix : string
val basename : t -> string
val location : t -> Lexing.position option
val pp_title : Format.formatter -> t -> unit
val pp_descr : Format.formatter -> t -> unit
end
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
val e_true : boolean
val e_false : boolean
val e_float : float -> real
val e_icst : string -> integer
val e_rcst : string -> real
val e_int64 : int64 -> integer
val e_ineg : integer -> integer
val e_rneg : real -> real
val e_iop : Formula.int_op -> integer -> integer -> integer
val e_rop : Formula.real_op -> real -> real -> real
val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
val e_rcmp : Formula.cmp_op -> real -> real -> boolean
val p_icmp : Formula.cmp_op -> integer -> integer -> pred
val p_rcmp : Formula.cmp_op -> real -> real -> pred
val e_bnot : integer -> integer
val e_band : integer -> integer -> integer
val e_bor : integer -> integer -> integer
val e_bxor : integer -> integer -> integer
val e_lshift : integer -> integer -> integer
val e_rshift : integer -> integer -> integer
val integer_of_real : real -> integer
val real_of_integer : integer -> real
val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean
val e_cond : boolean -> 'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred
val e_getfield : Cil_types.fieldinfo -> record -> abstract
val e_setfield :
Cil_types.fieldinfo -> record -> abstract -> record
val e_access : array -> integer -> abstract
val e_update : array -> integer -> abstract -> array
val p_true : pred
val p_false : pred
val p_bool : boolean -> pred
val p_and : pred -> pred -> pred
val p_or : pred -> pred -> pred
val p_xor : pred -> pred -> pred
val p_not : pred -> pred
val p_implies : pred -> pred -> pred
val p_iff : pred -> pred -> pred
val p_eq : 'a term -> 'a term -> pred
val p_neq : 'a term -> 'a term -> pred
val p_conj : pred list -> pred
val p_disj : pred list -> pred
val p_named : string -> pred -> pred
val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool
type pool = M.F.pool
val pool : unit -> pool
val p_fresh : pool -> string -> Formula.kind -> var
val p_freshen : pool -> var -> var
val var : var -> 'a term
val eq_var : var -> var -> bool
val name_of_var : var -> string
val basename_of_var : var -> string
val tau_of_var : var -> Formula.tau
val kind_of_var : var -> Formula.kind
val term_has_var : var list -> 'a term -> bool
val pred_has_var : var list -> pred -> bool
val term_calls : string -> 'a term -> bool
val pred_calls : string -> pred -> bool
val term_closed : 'a term -> bool
val pred_closed : pred -> bool
val freevars : pred -> var list
val p_forall : var list -> pred -> pred
val p_exists : var list -> pred -> pred
val p_subst :
(var -> var option) -> var -> 'a term -> pred -> pred
val e_subst :
(var -> var option) -> var -> 'a term -> 'b term -> 'b term
val e_rename : (var * var) list -> 'a term -> 'a term
val equal_terms : 'a term -> 'a term -> bool
type alpha = M.F.alpha
val empty_alpha : alpha
val fold_alpha : (var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
val p_alpha_cv : pred -> var list * pred
val pp_var : Format.formatter -> var -> unit
val pp_section : Format.formatter -> string -> unit
val pp_term : Format.formatter -> 'a term -> unit
val pp_pred : Format.formatter -> pred -> unit
val pp_decl : Format.formatter -> decl -> unit
val pp_goal : Format.formatter -> string -> pred -> unit
val pp_vkind : Format.formatter -> Formula.kind -> unit
val e_app0 : string -> 'a term
val e_app1 : string -> 'a term -> 'b term
val e_app2 : string -> 'a term -> 'b term -> 'c term
val e_app3 : string -> 'a term -> 'b term -> 'c term -> 'd term
val e_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term
val e_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> 'f term
val p_app0 : string -> pred
val p_app1 : string -> 'a term -> pred
val p_app2 : string -> 'a term -> 'b term -> pred
val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
val p_app4 :
string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
val p_app5 :
string ->
'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
val dummy : unit -> pred
val i_zero : integer
val r_zero : real
val i_one : integer
val i_add : integer -> integer -> integer
val i_mult : integer -> integer -> integer
val i_sub : integer -> integer -> integer
val guard : Ctypes.c_int -> integer -> pred
val modulo : Ctypes.c_int -> integer -> integer
val i_convert :
Ctypes.c_int -> Ctypes.c_int -> integer -> integer
type interval =
M.F.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a M.F.assigned =
Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
type havoc =
M.F.havoc =
Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit
val set_range_index : array -> interval -> array
val empty : set
val singleton : abstract -> set
val union : set -> set -> set
val unions : set list -> set
val inter : set -> set -> set
val remove : set -> set -> set
val set_of_list : abstract list -> set
val add_set : set -> set -> set
val mult_set : set -> set -> set
val neg_set : set -> set
val interval : interval -> set
val acc_field : record -> Cil_types.fieldinfo -> abstract
val upd_field :
record -> Cil_types.fieldinfo -> abstract -> record
val acc_index : array -> integer -> abstract
val upd_index : array -> integer -> abstract -> array
module type Indexed =
sig
type t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Dindex :
functor (I : Identifiable) ->
sig
type t = I.t
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Findex :
sig
type t = Cil_types.fieldinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Xindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Aindex :
sig
type t = Cil_types.varinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module Tindex :
sig
type t = Cil_types.compinfo
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
module LTindex :
sig
type t = Cil_types.logic_type
val define : t -> unit
val get_definition : t -> decl
val on_definition : (t -> decl -> unit) -> unit
val get_ind : t -> integer
val has_ind : t -> pred -> bool
end
end
type context = M.L.context
type bindings = M.L.bindings
val closed : bindings
val close : bindings -> F.pred -> F.pred
val push : string -> F.pool -> bindings -> context
val pop : string -> context -> bindings
val kill : string -> context -> unit
val flush : string -> context -> F.pred -> F.pred
val term_such_that :
Formula.tau -> ('a F.term -> F.pred) -> 'a F.term
val forall : F.var list -> F.pred -> F.pred
val exists : F.var list -> F.pred -> F.pred
val subst : F.var -> 'a F.term -> F.pred -> F.pred
val fresh : string -> Formula.kind -> F.var
val alpha : F.var -> F.var option
val pool : unit -> F.pool
val vkind_of_var : F.var -> Formula.kind
val has_context_vars : F.var list -> F.pred -> bool
val has_type : F.abstract -> Cil_types.logic_type -> F.pred
val is_comp : Cil_types.compinfo -> F.abstract -> F.pred
val is_array : Ctypes.arrayinfo -> F.abstract -> F.pred
val apply : (F.var * F.var) list -> 'a F.term -> 'a F.term
val havoc_static : F.havoc list -> F.pred -> F.pred
val havoc_inductive : F.havoc list -> F.pred -> F.pred
end
type user_formal =
UF_logic of Cil_types.logic_var * Translate_prop.Create.F.var
| UF_references of Cil_types.logic_var *
Translate_prop.Create.F.var option *
(Translate_prop.Create.F.var * M.formal * string) list
| UF_closure of Translate_prop.Create.F.var * M.closure * string
type userdef = {
d_info : Cil_types.logic_info;
d_callname : string;
d_formals : Translate_prop.Create.user_formal list;
}
type axiomlabel = {
a_name : string;
a_defname : string;
a_property : Translate_prop.Create.F.pred;
a_memory : Translate_prop.Create.user_formal list;
}
module Hdef :
sig
type key = Cil_datatype.Logic_var.t
type 'a t = 'a Cil_datatype.Logic_var.Hashtbl.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
val memo : 'a t -> key -> (key -> 'a) -> 'a
module Key :
sig
type t = key
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr : Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code : Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence -> Format.formatter -> t -> unit
val pretty : Format.formatter -> t -> unit
val varname : t -> string
val mem_project : (Project_skeleton.t -> bool) -> t -> bool
val copy : t -> t
end
module Make :
functor (Data : Datatype.S) ->
sig
type t = Data.t t
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr : Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code : Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence -> Format.formatter -> t -> unit
val pretty : Format.formatter -> t -> unit
val varname : t -> string
val mem_project : (Project_skeleton.t -> bool) -> t -> bool
val copy : t -> t
end
end
val user_axioms : (string, Translate_prop.Create.F.pred option) Hashtbl.t
val user_axiomlabels :
(string, Translate_prop.Create.axiomlabel option) Hashtbl.t
val user_definitions :
Translate_prop.Create.userdef Translate_prop.Create.Hdef.t
val pp_closures :
Format.formatter ->
Translate_prop.Create.F.var list * (M.closure * string) list -> unit
val pp_formals :
Format.formatter -> Translate_prop.Create.F.var list -> unit
module UserDefinition :
sig
val lock : unit Hdef.t
val pp_userdef_title :
Format.formatter -> Translate_prop.Create.userdef -> unit
val pp_userformals :
Format.formatter -> Translate_prop.Create.user_formal list -> unit
val pp_userdef_descr :
Format.formatter -> Translate_prop.Create.userdef -> unit
val define :
Translate_prop.Create.userdef ->
(string *
(Translate_prop.Create.F.var, Translate_prop.Create.F.abstract,
Translate_prop.Create.F.pred)
Formula.item)
list -> unit
val unlock : Translate_prop.Create.Hdef.key -> unit
val lock : Translate_prop.Create.Hdef.key -> unit
end
module UserAxiom :
sig
type t = string
val define : t -> unit
val get_definition : t -> F.decl
val on_definition : (t -> F.decl -> unit) -> unit
end
module UserAxiomDefs :
sig
val pp_labels : Format.formatter -> string list -> unit
val pp_axiomdef_title :
Format.formatter -> Translate_prop.Create.axiomlabel -> unit
val pp_axiomdef_descr :
Format.formatter -> Translate_prop.Create.axiomlabel -> unit
val define : Translate_prop.Create.axiomlabel -> unit
val is_defined : string -> bool
end
module Lmap :
sig
type key = Clabels.c_label
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
end
type frame = {
mutable states : M.mem Translate_prop.Create.Lmap.t;
mutable result : Translate_prop.Create.F.var option;
mutable status : Translate_prop.Create.F.var option;
mutable return : Cil_types.typ option;
}
val new_frame :
Kernel_function.t ->
?m_here:M.mem ->
?m_pre:M.mem ->
?m_post:M.mem ->
?x_result:Translate_prop.Create.F.var ->
?x_status:Translate_prop.Create.F.var ->
unit -> Translate_prop.Create.frame
val user_frame : unit -> Translate_prop.Create.frame
val result : Translate_prop.Create.frame -> Translate_prop.Create.F.var
val status : Translate_prop.Create.frame -> Translate_prop.Create.F.var
type lvar_kind =
Logic_cvar of Cil_types.varinfo
| Logic_value of M.value
| Logic_term of Translate_prop.Create.F.abstract
| Logic_var of Translate_prop.Create.F.var
| Logic_byref
type env = {
formals_in_pre : bool;
frame : Translate_prop.Create.frame;
label : Clabels.c_label;
xvars : M.value Cil_datatype.Varinfo.Map.t;
lvars : Translate_prop.Create.lvar_kind Cil_datatype.Logic_var.Map.t;
mutable laddr :
Translate_prop.Create.F.var Cil_datatype.Logic_var.Map.t;
}
val fresh_addr : Cil_types.logic_var -> Translate_prop.Create.F.var
val addr_of_ref :
Translate_prop.Create.env ->
Cil_datatype.Logic_var.Map.key -> Translate_prop.Create.F.var
val rec_apply_function :
(Translate_prop.Create.env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> Translate_prop.Create.F.abstract)
Pervasives.ref
val lvar :
Translate_prop.Create.env ->
Cil_datatype.Logic_var.Map.key -> Translate_prop.Create.lvar_kind
val xvar :
Translate_prop.Create.env ->
Cil_datatype.Varinfo.Map.key -> M.value option
val fresh_local : Cil_types.logic_var -> Translate_prop.Create.F.var
val fresh_logic_var :
Translate_prop.Create.F.pool ->
Cil_types.logic_var -> Translate_prop.Create.F.var
val add_logic_vars :
Translate_prop.Create.env ->
Translate_prop.Create.F.pool ->
Cil_datatype.Logic_var.Map.key list -> Translate_prop.Create.env
val collect_logic_vars :
Translate_prop.Create.env -> Translate_prop.Create.F.var list
val bind_lvars :
Translate_prop.Create.env ->
(Cil_datatype.Logic_var.Map.key * Translate_prop.Create.F.abstract)
list -> Translate_prop.Create.env
val bind_lvar :
Translate_prop.Create.env ->
Cil_datatype.Logic_var.Map.key ->
Translate_prop.Create.F.abstract -> Translate_prop.Create.env
val bind_fresh :
Translate_prop.Create.env ->
Cil_datatype.Logic_var.Map.key ->
Translate_prop.Create.F.var * Translate_prop.Create.env
val env_at :
Translate_prop.Create.env ->
Clabels.c_label -> Translate_prop.Create.env
val find_mem :
Translate_prop.Create.env ->
Translate_prop.Create.Lmap.key -> M.mem option
val mem_at :
Translate_prop.Create.env -> Translate_prop.Create.Lmap.key -> M.mem
val mem_at_env : Translate_prop.Create.env -> M.mem
val subst_result :
Translate_prop.Create.env ->
M.value option ->
Translate_prop.Create.L.F.pred -> Translate_prop.Create.L.F.pred
val result_type : Translate_prop.Create.env -> Cil_types.typ
val exit_status :
Translate_prop.Create.env -> Translate_prop.Create.F.var
val env :
Kernel_function.t ->
?m_here:M.mem ->
?m_pre:M.mem ->
?m_post:M.mem ->
?x_result:Translate_prop.Create.F.var ->
unit -> Translate_prop.Create.env
val bind_formals :
Kernel_function.t -> 'a list -> 'a Cil_datatype.Varinfo.Map.t
val call_pre :
Translate_prop.Create.env ->
Kernel_function.t -> M.value list -> M.mem -> Translate_prop.Create.env
val call_post :
Translate_prop.Create.env ->
Kernel_function.t ->
M.value list ->
M.mem ->
M.mem ->
Translate_prop.Create.F.var option -> Translate_prop.Create.env
val call_exit :
Translate_prop.Create.env ->
Kernel_function.t ->
M.value list ->
M.mem ->
M.mem -> Translate_prop.Create.F.var -> Translate_prop.Create.env
type kind =
Kcint of Ctypes.c_int
| Kint
| Kreal
| Kbool
| Kptr of Cil_types.typ
| Kset of Translate_prop.Create.kind
| Kstruct of Cil_types.compinfo
| Karray of Ctypes.arrayinfo
| Kadt of string * Translate_prop.Create.kind list
val kind_equal :
Translate_prop.Create.kind -> Translate_prop.Create.kind -> bool
val pp_kind : Format.formatter -> Translate_prop.Create.kind -> unit
type data =
Data of Translate_prop.Create.F.abstract
| Loc of M.loc
| Value of M.value
| Interval of Translate_prop.Create.F.interval
| Range of Ctypes.c_object * M.loc * Translate_prop.Create.F.interval
| List of Translate_prop.Create.data list
| Set of Translate_prop.Create.F.set
val pp_data : Format.formatter -> Translate_prop.Create.data -> unit
val data_of_integer :
Translate_prop.Create.F.integer -> Translate_prop.Create.data
val data_of_real :
Translate_prop.Create.F.real -> Translate_prop.Create.data
val data_of_boolean :
Translate_prop.Create.F.boolean -> Translate_prop.Create.data
val integer_of_value : M.value -> M.F.integer
val real_of_value : M.value -> M.F.real
val extract_from_data :
Translate_prop.Create.data -> 'a Translate_prop.Create.F.term
val boolean_of_data :
Translate_prop.Create.data -> Translate_prop.Create.F.boolean
val array_of_data :
Translate_prop.Create.data -> Translate_prop.Create.F.array
val record_of_data :
Translate_prop.Create.data -> Translate_prop.Create.F.record
val urecord_of_data :
Translate_prop.Create.data -> Translate_prop.Create.F.urecord
val loc_of_data : Ctypes.c_object -> Translate_prop.Create.data -> M.loc
val integer_of_data :
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.F.integer
val real_of_data :
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.F.real
val set_of : Translate_prop.Create.data -> Translate_prop.Create.F.set
val list_of :
Translate_prop.Create.data -> Translate_prop.Create.data list
val union_data :
Translate_prop.Create.data ->
Translate_prop.Create.data -> Translate_prop.Create.data
val union_map :
('a -> Translate_prop.Create.data) ->
'a list -> Translate_prop.Create.data
val term_of_data :
Translate_prop.Create.data -> Translate_prop.Create.F.abstract
val neg_interval :
Translate_prop.Create.F.interval -> Translate_prop.Create.F.interval
val object_of_pointed : Translate_prop.Create.kind -> Ctypes.c_object
val kind_of_typ : Cil_types.typ -> Translate_prop.Create.kind
val kind_of_data :
Cil_types.typ ->
Translate_prop.Create.data -> Translate_prop.Create.kind
val kind_of : Cil_types.logic_type -> Translate_prop.Create.kind
val typ_of_elements : Cil_types.logic_type -> Cil_types.typ
val data_rec :
(Translate_prop.Create.env ->
Cil_types.term -> Translate_prop.Create.data)
Pervasives.ref
val assigned_of_data :
Ctypes.c_object ->
M.loc Translate_prop.Create.F.assigned list ->
Translate_prop.Create.data ->
M.loc Translate_prop.Create.F.assigned list
val data_valid :
M.mem ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.F.pred
val data_separated :
M.mem ->
Ctypes.c_object * Translate_prop.Create.data ->
Ctypes.c_object * Translate_prop.Create.data ->
Translate_prop.Create.F.pred
val data_shift_range :
Ctypes.c_object ->
M.loc ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> is_pos:bool -> Translate_prop.Create.data
val data_index_range :
Ctypes.c_object ->
M.loc ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.data
val data_shift :
Translate_prop.Create.kind ->
Translate_prop.Create.data ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> is_pos:bool -> Translate_prop.Create.data
val data_index :
Ctypes.c_object ->
Translate_prop.Create.kind ->
Translate_prop.Create.data ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.data
val data_field :
Translate_prop.Create.kind ->
Translate_prop.Create.data ->
Cil_types.fieldinfo -> Translate_prop.Create.data
val data_startof_set :
Ctypes.c_object ->
Translate_prop.Create.data -> Translate_prop.Create.data
val data_startof :
Ctypes.c_object ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.data
val data_load :
Translate_prop.Create.env ->
Cil_types.typ ->
Translate_prop.Create.data -> Translate_prop.Create.data
val logic_offset :
Translate_prop.Create.env ->
Translate_prop.Create.F.abstract ->
Cil_types.term_offset -> Translate_prop.Create.data
val loc_offset :
Translate_prop.Create.env ->
M.loc -> Ctypes.c_object -> Cil_types.term_offset -> M.loc
val memory_offset :
Translate_prop.Create.env ->
Cil_types.typ ->
Translate_prop.Create.data ->
Cil_types.term_offset -> Cil_types.typ * Translate_prop.Create.data
val gaddress_of_cvar :
Translate_prop.Create.env ->
Cil_types.varinfo ->
Cil_types.term_offset -> Cil_types.typ * Translate_prop.Create.data
val gaddress_of_ref :
Translate_prop.Create.env ->
Cil_datatype.Logic_var.Map.key ->
Cil_types.term_offset -> Translate_prop.Create.data
val gaddress_of_mem :
Translate_prop.Create.env ->
Cil_types.term ->
Cil_types.term_offset -> Cil_types.typ * Translate_prop.Create.data
val gstartof :
Cil_types.typ * Translate_prop.Create.data ->
Translate_prop.Create.data
val gstartof_cvar :
Translate_prop.Create.env ->
Cil_types.varinfo ->
Cil_types.term_offset -> Translate_prop.Create.data
val gstartof_mem :
Translate_prop.Create.env ->
Cil_types.term -> Cil_types.term_offset -> Translate_prop.Create.data
val gstartof_value :
Translate_prop.Create.env ->
Cil_types.typ ->
M.value -> Cil_types.term_offset -> Translate_prop.Create.data
val cast :
Translate_prop.Create.data ->
Translate_prop.Create.kind ->
Translate_prop.Create.kind -> Translate_prop.Create.data
val int_op :
Cil_types.binop ->
Translate_prop.Create.F.integer ->
Translate_prop.Create.F.integer -> Translate_prop.Create.F.integer
val real_op :
Cil_types.binop ->
Translate_prop.Create.F.real ->
Translate_prop.Create.F.real -> Translate_prop.Create.F.real
val rel_op : Cil_types.relation -> Cil_types.binop
val real_cmp :
Cil_types.binop ->
Translate_prop.Create.F.real ->
Translate_prop.Create.F.real -> Translate_prop.Create.F.boolean
val int_cmp :
Cil_types.binop ->
Translate_prop.Create.F.integer ->
Translate_prop.Create.F.integer -> Translate_prop.Create.F.boolean
val preal_cmp :
Cil_types.binop ->
Translate_prop.Create.F.real ->
Translate_prop.Create.F.real -> Translate_prop.Create.F.pred
val pint_cmp :
Cil_types.binop ->
Translate_prop.Create.F.integer ->
Translate_prop.Create.F.integer -> Translate_prop.Create.F.pred
val ptr_rel :
Cil_types.binop -> M.loc -> M.loc -> Translate_prop.Create.F.pred
val ptr_cmp : Cil_types.binop -> M.loc -> M.loc -> M.F.boolean
val plus :
Translate_prop.Create.F.integer ->
Translate_prop.Create.F.integer -> Translate_prop.Create.F.integer
val plus_interval :
Translate_prop.Create.F.interval ->
Translate_prop.Create.F.integer -> Translate_prop.Create.F.interval
val plus_interval_interval :
Translate_prop.Create.F.interval ->
Translate_prop.Create.F.interval -> Translate_prop.Create.data
val add_integer :
Translate_prop.Create.kind ->
Translate_prop.Create.data ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.data
val data_cmp :
Cil_types.binop ->
Translate_prop.Create.kind ->
Translate_prop.Create.data ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.F.boolean
val data_binop :
Translate_prop.Create.kind ->
Cil_types.binop ->
Translate_prop.Create.kind ->
Translate_prop.Create.data ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.data
val data_unop :
Translate_prop.Create.kind ->
Cil_types.unop ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.data
val data_const : Cil_types.constant -> Translate_prop.Create.data
val data_of_term :
Translate_prop.Create.env ->
Cil_types.term -> Translate_prop.Create.data
val term :
Translate_prop.Create.env ->
Cil_types.term -> Translate_prop.Create.F.abstract
val data_of_assignable :
Translate_prop.Create.env ->
Cil_types.term -> Translate_prop.Create.data
val assigned :
Translate_prop.Create.env ->
Cil_types.term -> M.loc Translate_prop.Create.F.assigned list
val rec_apply_predicate :
(Translate_prop.Create.env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> Translate_prop.Create.F.pred)
Pervasives.ref
val pred_cmp :
Cil_types.binop ->
Translate_prop.Create.kind ->
Translate_prop.Create.data ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.F.pred
val prop :
Translate_prop.Create.env ->
Cil_types.predicate Cil_types.named -> Translate_prop.Create.F.pred
val prop_body :
Translate_prop.Create.env ->
Cil_types.predicate Cil_types.named -> Translate_prop.Create.F.pred
val get_definition :
(Cil_types.logic_info ->
Translate_prop.Create.userdef *
(string *
(Translate_prop.Create.F.var, Translate_prop.Create.F.abstract,
Translate_prop.Create.F.pred)
Formula.item)
list) ->
Cil_types.logic_info -> Translate_prop.Create.userdef
val push_context : string -> Translate_prop.Create.L.context
val flush_context :
string ->
Translate_prop.Create.L.context ->
Translate_prop.Create.L.F.pred -> Translate_prop.Create.L.F.pred
val kill_context : string -> Translate_prop.Create.L.context -> unit
val user_default_label : Cil_types.logic_label list -> Clabels.c_label
val user_env :
Cil_types.logic_info ->
Translate_prop.Create.L.context *
Translate_prop.Create.user_formal list * Translate_prop.Create.env
val collect_signature :
Translate_prop.Create.user_formal list ->
(Translate_prop.Create.F.var -> bool) ->
Translate_prop.Create.env -> Translate_prop.Create.user_formal list
val flatten_formals :
Translate_prop.Create.user_formal list ->
Translate_prop.Create.F.var list
val flatten_references :
(Translate_prop.Create.F.var * M.formal * string) list ->
Translate_prop.Create.user_formal list ->
Translate_prop.Create.F.var list
val all_filter : Translate_prop.Create.F.var -> bool
val term_filter :
'a Translate_prop.Create.F.term -> Translate_prop.Create.F.var -> bool
val pred_filter :
Translate_prop.Create.F.pred -> Translate_prop.Create.F.var -> bool
val compile_predicate :
Cil_types.logic_info ->
Translate_prop.Create.userdef *
(string * ('a, 'b, Translate_prop.Create.L.F.pred) Formula.item) list
val compile_function :
Cil_types.logic_info ->
Translate_prop.Create.userdef *
(string * ('a, 'b, Translate_prop.Create.F.pred) Formula.item) list
val axiom_env : string -> Translate_prop.Create.env
val compile_user_axiom :
'a ->
Cil_types.predicate Cil_types.named -> Translate_prop.Create.L.F.pred
val compile_user_axiom_labels :
string ->
Cil_types.logic_label list * Cil_types.predicate Cil_types.named ->
Translate_prop.Create.axiomlabel
val compile_and_define :
('a, 'b option) Hashtbl.t ->
'a -> 'c -> ('a -> 'c -> 'b) -> ('a -> 'b -> unit) -> unit
val add_axiom :
string ->
Cil_types.logic_label list ->
Cil_types.predicate Cil_types.named -> unit
val bool_of_option : 'a option -> bool
val apply_formals :
Translate_prop.Create.env ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Translate_prop.Create.user_formal list ->
Translate_prop.Create.data list ->
Translate_prop.Create.F.abstract list
val apply_references :
Translate_prop.Create.env ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
(Translate_prop.Create.F.var * M.formal * string) list ->
Translate_prop.Create.data ->
Translate_prop.Create.user_formal list ->
Translate_prop.Create.data list ->
Translate_prop.Create.F.abstract list
val apply_predicate :
Translate_prop.Create.env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> Translate_prop.Create.F.pred
val apply_function :
Translate_prop.Create.env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> Translate_prop.Create.F.abstract
end