functor (M : Mlogic.S) ->
sig
module F :
sig
type 'a term = 'a M.D.F.term
type pred = M.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 = M.D.F.var
type pool = M.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 = M.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
module D :
sig
module F :
sig
type 'a term = 'a M.D.F.term
type pred = M.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 = M.D.F.var
type pool = M.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 = M.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 =
M.D.interval = {
inf : integer option;
sup : integer option;
}
type 'a assigned =
'a M.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 = M.D.context
type bindings = M.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 = M.D.substitution
val apply : substitution -> 'a F.term -> 'a F.term
type havoc =
M.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 = M.D.Varinfo.H.key
type 'a t = 'a M.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 = M.D.Varaddr.H.key
type 'a t = 'a M.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 = M.D.Fieldinfo.H.key
type 'a t = 'a M.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 = M.D.Compinfo.H.key
type 'a t = 'a M.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 = M.D.Arrayinfo.H.key
type 'a t = 'a M.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 = M.D.Logicvar.H.key
type 'a t = 'a M.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 userdef = {
d_info : Cil_types.logic_info;
d_callname : string;
d_implicit : Translate_prop.Create.F.var list;
d_closure : M.closure list;
d_formals : Translate_prop.Create.F.var list;
}
type axiomdef = {
a_name : string;
a_labels : string list;
a_hyp_name : string;
a_def_name : string;
a_implicit : Translate_prop.Create.F.var list;
a_closure : M.closure list;
a_property : Translate_prop.Create.F.pred;
}
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
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.D.F.pred) Hashtbl.t
val user_axiomdefs :
(string, Translate_prop.Create.axiomdef option) Hashtbl.t
val user_variables :
Formula.abstract Translate_prop.Create.F.term
Translate_prop.Create.Hdef.t
val user_definitions :
(Translate_prop.Create.userdef *
(string * Translate_prop.Create.D.F.pred Formula.item) list)
Translate_prop.Create.Hdef.t
module UserVariable :
sig
type t = Cil_types.logic_var
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
val get_user_variable :
Translate_prop.Create.Hdef.key ->
Formula.abstract Translate_prop.Create.F.term
val pp_closures :
Format.formatter ->
Translate_prop.Create.F.var list -> M.closure list -> unit
val pp_formals :
Format.formatter -> Translate_prop.Create.F.var list -> unit
module UserAxiom :
sig
type t = string
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 UserDefinition :
sig
val index : unit Translate_prop.Create.Hdef.t
val pp_userdef_title :
Format.formatter -> Translate_prop.Create.userdef -> unit
val pp_userdef_descr :
Format.formatter -> Translate_prop.Create.userdef -> unit
val define :
Translate_prop.Create.userdef ->
(string * Translate_prop.Create.D.F.pred Formula.item) list -> unit
end
module UserAxiomDefs :
sig
val index : (string, unit) Hashtbl.t
val pp_axiomdef_title :
Format.formatter -> Translate_prop.Create.axiomdef -> unit
val pp_axiomdef_descr :
Format.formatter -> Translate_prop.Create.axiomdef -> unit
val define : Translate_prop.Create.axiomdef -> unit
end
type xvar = PrmVar of M.value | MemVar
type env = {
formals_in_pre : bool;
frame : M.frame;
label : Clabels.c_label;
lvars :
Formula.abstract Translate_prop.Create.F.term
Cil_datatype.Logic_var.Map.t;
xvars : M.value Cil_datatype.Varinfo.Map.t;
}
val env_at :
Translate_prop.Create.env ->
Clabels.c_label -> Translate_prop.Create.env
val get_frame : Translate_prop.Create.env -> M.frame
val mem_at_env : Translate_prop.Create.env -> M.mem
val quant_env :
Translate_prop.Create.env ->
(Cil_datatype.Logic_var.Map.key *
Formula.abstract Translate_prop.Create.F.term)
list -> Translate_prop.Create.env
val env_body : M.frame -> Translate_prop.Create.env
val call_post :
Kernel_function.t ->
M.value list ->
M.mem -> M.mem -> M.D.F.var option -> Translate_prop.Create.env
val call_pre :
Kernel_function.t -> M.value list -> M.mem -> Translate_prop.Create.env
val call_exit :
Translate_prop.Create.env -> M.D.F.var -> Translate_prop.Create.env
val assigns_clause : M.frame -> Translate_prop.Create.env
val lvar :
Formula.abstract Translate_prop.Create.F.term
Cil_datatype.Logic_var.Map.t ->
Cil_datatype.Logic_var.Map.key ->
Formula.abstract Translate_prop.Create.F.term
val add_lvar :
Translate_prop.Create.env ->
Cil_datatype.Logic_var.Map.key ->
Formula.abstract Translate_prop.Create.F.term ->
Translate_prop.Create.env
val xvar_of_varinfo :
Translate_prop.Create.env ->
Cil_datatype.Varinfo.Map.key -> Translate_prop.Create.xvar
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 pp_kind : Format.formatter -> Translate_prop.Create.kind -> unit
type data =
Data of Formula.abstract Translate_prop.Create.F.term
| Loc of M.loc
| Value of M.value
| Interval of Translate_prop.Create.D.interval
| Range of Ctypes.c_object * M.loc * Translate_prop.Create.D.interval
| List of Translate_prop.Create.data list
| Set of Translate_prop.Create.D.set
val pp_data : Format.formatter -> Translate_prop.Create.data -> unit
val data_of_integer :
Formula.integer Translate_prop.Create.F.term ->
Translate_prop.Create.data
val data_of_real :
Formula.real Translate_prop.Create.F.term -> Translate_prop.Create.data
val data_of_boolean :
Formula.boolean Translate_prop.Create.F.term ->
Translate_prop.Create.data
val integer_of_value : M.value -> M.D.integer
val real_of_value : M.value -> M.D.real
val extract_from_data :
Translate_prop.Create.data -> 'a Translate_prop.Create.F.term
val boolean_of_data :
Translate_prop.Create.data ->
Formula.boolean Translate_prop.Create.F.term
val array_of_data :
Translate_prop.Create.data -> Translate_prop.Create.D.array
val record_of_data :
Translate_prop.Create.data -> Translate_prop.Create.D.record
val urecord_of_data :
Translate_prop.Create.data -> Translate_prop.Create.D.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 ->
Formula.integer Translate_prop.Create.F.term
val real_of_data :
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Formula.real Translate_prop.Create.F.term
val set_of : Translate_prop.Create.data -> Translate_prop.Create.D.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 ->
Formula.abstract Translate_prop.Create.F.term
val neg_interval :
Translate_prop.Create.D.interval -> Translate_prop.Create.D.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 rec_apply_function :
(Translate_prop.Create.env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> Formula.abstract Translate_prop.Create.F.term)
Pervasives.ref
val assigned_of_data :
Ctypes.c_object ->
M.loc Translate_prop.Create.D.assigned list ->
Translate_prop.Create.data ->
M.loc Translate_prop.Create.D.assigned list
val data_valid :
M.mem ->
Translate_prop.Create.kind ->
Translate_prop.Create.data -> Translate_prop.Create.F.pred
val data_separated :
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 ->
Formula.abstract Translate_prop.Create.F.term ->
Cil_types.term_offset -> Translate_prop.Create.data
val loc_offset :
Translate_prop.Create.env ->
M.loc -> Cil_types.typ -> 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_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 ->
Formula.integer Translate_prop.Create.F.term ->
Formula.integer Translate_prop.Create.F.term ->
Formula.integer Translate_prop.Create.F.term
val real_op :
Cil_types.binop ->
Formula.real Translate_prop.Create.F.term ->
Formula.real Translate_prop.Create.F.term ->
Formula.real Translate_prop.Create.F.term
val rel_op : Cil_types.relation -> Cil_types.binop
val real_cmp :
Cil_types.binop ->
Formula.real Translate_prop.Create.F.term ->
Formula.real Translate_prop.Create.F.term ->
Formula.boolean Translate_prop.Create.F.term
val int_cmp :
Cil_types.binop ->
Formula.integer Translate_prop.Create.F.term ->
Formula.integer Translate_prop.Create.F.term ->
Formula.boolean Translate_prop.Create.F.term
val preal_cmp :
Cil_types.binop ->
Formula.real Translate_prop.Create.F.term ->
Formula.real Translate_prop.Create.F.term ->
Translate_prop.Create.F.pred
val pint_cmp :
Cil_types.binop ->
Formula.integer Translate_prop.Create.F.term ->
Formula.integer Translate_prop.Create.F.term ->
Translate_prop.Create.F.pred
val ptr_rel :
Cil_types.binop ->
Translate_prop.Create.D.pointer ->
Translate_prop.Create.D.pointer -> Translate_prop.Create.D.F.pred
val ptr_cmp :
Cil_types.binop ->
Translate_prop.Create.D.pointer ->
Translate_prop.Create.D.pointer -> Translate_prop.Create.D.boolean
val plus :
Formula.integer Translate_prop.Create.F.term ->
Formula.integer Translate_prop.Create.F.term ->
Formula.integer Translate_prop.Create.F.term
val plus_interval :
Translate_prop.Create.D.interval ->
Formula.integer Translate_prop.Create.F.term ->
Translate_prop.Create.D.interval
val plus_interval_interval :
Translate_prop.Create.D.interval ->
Translate_prop.Create.D.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 ->
Formula.boolean Translate_prop.Create.F.term
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 -> Formula.abstract Translate_prop.Create.F.term
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.D.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_axiom : string -> Translate_prop.Create.axiomdef option
type partial =
Svalue of Formula.abstract Translate_prop.Create.F.term
| Sclosure of M.closure
val hints : int Pervasives.ref
val pp_partial :
Format.formatter -> Translate_prop.Create.partial -> unit
val apply_sigma :
Translate_prop.Create.env ->
(string * Clabels.c_label) list ->
M.closure -> Translate_prop.Create.partial
class instance :
Translate_prop.Create.axiomdef ->
Translate_prop.Create.partial list ->
object
val axdef : Translate_prop.Create.axiomdef
val mutable captured : bool
val mutable id : int
val mutable partials : Translate_prop.Create.partial list
method alive : bool
method capture : Translate_prop.Create.F.var list -> unit
method extend_with_hint :
Translate_prop.Create.env ->
Axiomatics.hint -> Translate_prop.Create.instance option
method has_var : Translate_prop.Create.F.var list -> bool
method id : int
method instantiate : Translate_prop.Create.F.pred option
method pretty : Format.formatter -> unit
method subst :
Translate_prop.Create.F.var ->
Formula.abstract Translate_prop.Create.F.term -> unit
end
val instance_of_hint :
Translate_prop.Create.env ->
Axiomatics.hint -> Translate_prop.Create.instance option
val saturate :
Translate_prop.Create.instance list ->
Translate_prop.Create.env ->
Axiomatics.hint list -> Translate_prop.Create.instance list
val hint_context :
Translate_prop.Create.instance list option Pervasives.ref
val push_instances :
string -> Translate_prop.Create.instance list -> unit
val pop_instances : string -> Translate_prop.Create.instance list
val apply_hints :
Translate_prop.Create.env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list -> unit
val do_instantiate :
(< alive : bool; instantiate : Translate_prop.Create.F.pred option;
.. >
as 'a)
list ->
Translate_prop.Create.F.pred ->
'a list -> 'a list * Translate_prop.Create.F.pred
val instantiate :
(< alive : bool; instantiate : Translate_prop.Create.F.pred option;
.. >
as 'a)
list ->
Translate_prop.Create.F.pred -> 'a list * Translate_prop.Create.F.pred
val as_hint :
Translate_prop.Create.instance -> Translate_prop.Create.D.hint
val merge :
(< alive : bool; id : Datatype.Int.t; .. > as 'a) list ->
'a list -> 'a list
val get_definition :
(Cil_types.logic_info ->
Translate_prop.Create.userdef *
(string * Translate_prop.Create.D.F.pred Formula.item) list) ->
Cil_types.logic_info -> Translate_prop.Create.userdef
val push_context :
string ->
Translate_prop.Create.instance list option *
Translate_prop.Create.D.context
val flush_context :
string ->
Translate_prop.Create.instance list option *
Translate_prop.Create.D.context ->
Translate_prop.Create.D.F.pred -> Translate_prop.Create.D.F.pred
val kill_context :
string ->
Translate_prop.Create.instance list option *
Translate_prop.Create.D.context -> unit
val user_env :
Cil_types.logic_info ->
(Translate_prop.Create.instance list option *
Translate_prop.Create.D.context) *
(Cil_types.logic_var * Translate_prop.Create.D.F.var) list *
Translate_prop.Create.env
val compile_predicate :
Cil_types.logic_info ->
Translate_prop.Create.userdef *
(string * Translate_prop.Create.D.F.pred Formula.item) list
val compile_function :
Cil_types.logic_info ->
Translate_prop.Create.userdef *
(string * Translate_prop.Create.F.pred Formula.item) list
val axiom_env : string -> Translate_prop.Create.env
val compile_user_axiom :
string -> Cil_types.predicate Cil_types.named -> unit
val compile_user_hypothesis :
string ->
Cil_types.logic_label list ->
Cil_types.predicate Cil_types.named -> unit
val add_axiom :
string ->
Cil_types.logic_label list ->
Cil_types.predicate Cil_types.named -> unit
val apply_closure :
Translate_prop.Create.env ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
M.closure -> Formula.abstract M.D.F.term
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 -> Formula.abstract Translate_prop.Create.F.term
end