Module Mfloat.S.F


module F: Formula.S 

type var 
type 'a term 
type 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

Global Declarations


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

Functors and Types for Declaration


module type Identifiable = sig .. end
module type Registry = sig .. end
module type Declarator = sig .. end
module DRegister: 
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 LTypeinfo: Identifiable  with type t = logic_type
module Cobject: Identifiable  with type t = Ctypes.c_object
module ArrayDim: Identifiable  with type t = Ctypes.c_object * int
val adt_decl : Cil_types.logic_type_info -> string
val pp_tau : Format.formatter -> Formula.tau -> unit
Be careful, this one is only used for debuging message! Do not use for extraction

Terms


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

Arithmetics


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

Booleans


val e_bool : boolean -> integer
val e_not : boolean -> boolean
val e_and : boolean -> boolean -> boolean
val e_or : boolean -> boolean -> boolean

Conditional


val e_cond : boolean ->
'a term -> 'a term -> 'a term
val p_cond : boolean -> pred -> pred -> pred

records field


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

Predicates


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

Utilities


val is_true : pred -> bool
val is_false : pred -> bool
val huge_term : int -> 'a term -> bool
val huge_pred : int -> pred -> bool

Variables

Pools are used to generate fresh free variables. Do not mix non-closed terms from different pools.

type 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
Requires domain to be disjoint from co-domain
val equal_terms : 'a term -> 'a term -> bool
Returns true when the two terms are syntactically equals

Alpha conversion


type alpha 
Maping from old var to new var

Empty mapping

val empty_alpha : alpha
val fold_alpha : (var -> var -> 'a -> 'a) -> alpha -> 'a -> 'a
val p_more_alpha_cv : alpha -> pred -> alpha * pred
alpha', p' = p_more_alpha_cv alpha p build p' from p by renaming all the variable v into v' according to the mapping alpha. Add new mappings for the variables that are not already mapped.
val p_alpha_cv : pred -> var list * pred
easier to use when doing a simple alpha conversion.
Returns the new predicate and the newly created variables.

Pretty printers


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

FOL Helpers


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

Integer Logic Cast


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 = {
   inf : integer option;
   sup : integer option;
}

Fol data



type 'a assigned =
| Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval

type havoc =
| Fresh of var
| Update of var * ((var * var) list -> abstract)
val pp_interval : Format.formatter -> interval -> unit

Sub-arrays


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 }.

Formats



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
module type Indexed = sig .. end
Buitin Indexd Declaration
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
module LTindex: Indexed  with type t = logic_type