Module Mfloat.S.D


module D: Mdata.S 

module F: Formula.S 
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 = {
   inf : integer option;
   sup : integer option;
}
type 'a assigned =
| Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
val pp_interval : Format.formatter -> interval -> unit

FOL Helpers


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

Representation of ACSL Values


val tau_of_logic_type : Cil_types.logic_type -> Formula.tau

Constrained Terms Construction


type context 
type bindings 
class type hint = object .. 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

Generalized substitutions


type substitution 
val apply : substitution -> 'a F.term -> 'a F.term

type 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

Global Declarations


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

Functors and Types for Declaration


module type Identifiable = sig .. end
module type Registry = sig .. end
module type Declarator = sig .. end
module Register: 
functor (D : Declarator) -> Registry with type t = D.t

Build-int Identifiables and Registry


module Varinfo: Identifiable  with type t = varinfo
module Varaddr: Identifiable  with type t = varinfo
module Fieldinfo: Identifiable  with type t = fieldinfo
module Compinfo: Identifiable  with type t = compinfo
module Arrayinfo: Identifiable  with type t = arrayinfo
module Logicvar: Identifiable  with type t = logic_var
module type Indexed = sig .. end
module Dindex: 
functor (I : Identifiable) -> sig .. end
module Findex: Indexed  with type t = fieldinfo
module Xindex: Indexed  with type t = varinfo
module Aindex: Indexed  with type t = varinfo
module Tindex: Indexed  with type t = compinfo

Integer Logic Cast


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

Real Logic Cast


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

Sub-arrays


val get_range_index : array -> interval -> abstract
val set_range_index : array -> interval -> array

Set and Range as first Class Value


val empty : set
empty() returns the polymorphic empty set.
val singleton : abstract -> set
singleton a returns the singleton set containning a.
val union : set -> set -> set
union s0 s1 returns the union set of s0 and s1.
val unions : set list -> set
val inter : set -> set -> set
inter s0 s1 returns the intersection set of s0 and s1.
val remove : set -> set -> set
remove s0 s1 returns a set s' such as {b in s' | b in s0 and !(b in s1) }.
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
range l h returns the integer set s such as { i in s | l <= i <= h }.

Pointer arithmetics


val equal_pointer_bool : pointer -> pointer -> boolean
equal_pointer_bool p q is the boolean that is true when pointers p and q, that points to elements of type ty, are equal. Returns a term of type bool.
val lt_pointer_bool : pointer -> pointer -> boolean
lt_pointer_bool p q is the less than comparison of pointers p and q, that points to elements of type ty, ie. p<q. Returns a term of type boolean.
val le_pointer_bool : pointer -> pointer -> boolean
le_pointer_bool p q is the less than or equal comparison of pointers p and q, that points to elements of type ty, ie. p<=q. Returns a term of type boolean.
val lt_pointer : pointer -> pointer -> F.pred
lt_pointer p q is the less than comparison of pointers p and q, that points to elements of type ty, ie. p<q.
val le_pointer : pointer -> pointer -> F.pred
le_pointer p q is the less than or equal comparison of pointers p and q, that points to elements of type ty, ie. p<=q.
val minus_pointer : pointer -> pointer -> integer
minus_pointer ty p q is the arithmetics difference of pointers p and q, that points to elements of type ty, ie. p-q. Returns a term of type integer.
val is_null : pointer -> boolean
Take a term representing an address and returns a term of type bool.

Special locations


val null : pointer
null return the special location of the memory model designing the null pointer.

Formats


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

Record as First Class Value


val acc_field : record -> Cil_types.fieldinfo -> abstract
Takes a record term of type (tau_of F.fcomp) and returns the term of type (tau_of F) for its field 'F'
val upd_field : record -> Cil_types.fieldinfo -> abstract -> record
Takes a record term of type (tau_of F.fcomp) and a new term of type (tau_of F) for its field 'F' and return the updated record.

Array as first Class Value


val acc_index : array -> integer -> abstract
Takes term of type 'a farray and returns the 'a at index i.
val upd_index : array -> integer -> abstract -> array

ACSL Comparison


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