Functor Datalib.Create


module Create: 
functor (F : Formula.S) -> sig .. end
Parameters:
F : Formula.S

module F: F
type abstract = Formula.abstract F.term 
type format = Formula.m_format 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 
type integer = Formula.integer F.term 
type real = Formula.real F.term 
type boolean = Formula.boolean F.term 

type interval = {
   inf : integer option;
   sup : integer option;
}
val pp_interval : Format.formatter -> interval -> unit

type 'a assigned =
| Aloc of Ctypes.c_object * 'a
| Arange of Ctypes.c_object * 'a * interval
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 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 modulo : Ctypes.c_int -> 'a F.term -> 'b F.term
val guard : Ctypes.c_int -> 'a F.term -> F.pred
val i_convert : Ctypes.c_int ->
Ctypes.c_int -> 'a F.term -> 'a F.term
val round : Ctypes.c_float -> 'a F.term -> 'b F.term
val f_guard : Ctypes.c_float -> 'a F.term -> F.pred
val f_convert : Ctypes.c_float ->
Ctypes.c_float -> 'a F.term -> 'a F.term
val part_of_item : 'a Formula.item -> int
module Dset: Set.Make(sig
type t = Datalib.Create.F.pred Formula.declaration 
val compare : 'a Formula.declaration -> 'b Formula.declaration -> int
end)
val gindex : (string, Dset.elt) Hashtbl.t
val gsection : Dset.t array
val gfresh : (string, int Pervasives.ref) Hashtbl.t
val fresh_name : string -> string -> string
val s_index : Formula.section -> int
val gclear : (unit -> unit) list Pervasives.ref
val clear : unit -> unit
val on_clear : (unit -> unit) -> unit
val locked : bool Pervasives.ref
val add_declaration : Dset.elt -> unit
val iter : Formula.section -> (Dset.elt -> unit) -> unit
val iter_all : (Dset.elt -> unit) -> unit
val gdummy : int Pervasives.ref
val dummy : unit -> F.pred
module type Identifiable = sig .. end
module type Registry = sig .. end
module type Declarator = sig .. end
module Register: 
functor (D : Declarator) -> sig .. end
val gindexref : int Pervasives.ref
module type Indexed = sig .. end
module Dindex: 
functor (I : Identifiable) -> sig .. end
val pp_dim : Format.formatter -> Cil_types.typ -> unit
val pp_ctype : bool -> Format.formatter -> Cil_types.typ -> unit
module Varinfo: sig .. end
module Varaddr: sig .. end
module Fieldinfo: sig .. end
module Compinfo: sig .. end
module Arrayinfo: sig .. end
module LTypeinfo: sig .. end
module Logicvar: sig .. end
module LTinfo: sig .. end
module LTinfoId: sig .. end
module ADTDecl: Register(sig
include LTinfoId
val declare : Cil_types.logic_type_info -> 'a -> 'b Formula.item
val section : Formula.section
val clear : unit -> unit
end)
val tau_of_object : Ctypes.c_object -> Formula.tau
val tau_of_ctype : Cil_types.typ -> Formula.tau
val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
module Findex: Dindex(Fieldinfo)
module Xindex: Dindex(Varinfo)
module Tindex: Dindex(Compinfo)
module Aindex: Dindex(Varaddr)
module LTindex: Dindex(LTypeinfo)
val pp_kind : Format.formatter -> Mdata.kind -> unit
val empty : Formula.m_set F.term
val singleton : 'a F.term -> 'b F.term
val union : 'a F.term ->
'b F.term -> 'c F.term
val unions : Formula.m_set F.term list ->
Formula.m_set F.term
val inter : 'a F.term ->
'b F.term -> 'c F.term
val remove : 'a F.term ->
'b F.term -> 'c F.term
val add_set : 'a F.term ->
'b F.term -> 'c F.term
val mult_set : 'a F.term ->
'b F.term -> 'c F.term
val neg_set : 'a F.term -> 'b F.term
val loc_range : Formula.integer F.term ->
Formula.integer F.term -> Formula.m_set F.term
val range_inf : Formula.integer F.term -> Formula.m_set F.term
val range_sup : Formula.integer F.term -> Formula.m_set F.term
val integers : Formula.m_set F.term
val set_of_list : 'a F.term list -> Formula.m_set F.term
val interval : interval -> Formula.m_set F.term
val get_range_index : 'a F.term ->
interval -> 'b F.term
val set_range_index : 'a F.term ->
interval -> 'b F.term
val lt_pointer : Formula.m_pointer F.term ->
Formula.m_pointer F.term -> F.pred
val le_pointer : Formula.m_pointer F.term ->
Formula.m_pointer F.term -> F.pred
val minus_pointer : Formula.m_pointer F.term ->
Formula.m_pointer F.term ->
Formula.integer F.term
val equal_pointer_bool : Formula.m_pointer F.term ->
Formula.m_pointer F.term ->
Formula.boolean F.term
val lt_pointer_bool : Formula.m_pointer F.term ->
Formula.m_pointer F.term ->
Formula.boolean F.term
val le_pointer_bool : Formula.m_pointer F.term ->
Formula.m_pointer F.term ->
Formula.boolean F.term
val null : Formula.m_pointer F.term
val is_null : Formula.m_pointer F.term ->
Formula.boolean F.term
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 access : '_a F.term ->
'_b F.term -> '_c F.term
val has_type_int : Ctypes.c_int -> 'a F.term -> F.pred
val has_type : 'a F.term -> Cil_types.logic_type -> F.pred
class type hint = object .. end
type bindings = binding list 

type binding =
| Forall of F.var list
| Exists of F.var list
| Any of F.var * F.pred
| Let of F.var * Formula.abstract F.term
val pp_binding : Format.formatter -> binding -> unit

type context = {
   pool : F.pool;
   hints : hint list;
   mutable bindings : bindings;
}
val closed : bindings
val context : context list Pervasives.ref
val occur_check : F.var -> F.var list -> unit
val capture : < capture : F.var list -> unit;
subst : F.var ->
Formula.abstract F.term -> unit;
.. >
list -> binding list -> unit
val pp_vkind : Format.formatter -> Mdata.vkind -> unit
val guards_with : (F.pred -> 'a -> 'a) -> 'a -> F.var list -> 'a
val sub : F.var ->
F.var list -> F.var list
val some_alpha : F.pool -> F.var -> F.var option
val apply_bindings : (F.var * 'a F.term) list ->
F.pred -> F.pred
val alpha : F.var -> F.var option
val do_subst : F.var ->
'a F.term -> F.pred -> F.pred
val do_forall : F.var list -> F.pred -> F.pred
val do_exists : F.var list -> F.pred -> F.pred
val has_var : F.var list ->
binding list ->
< has_var : F.var list -> bool; .. > list -> bool
val forall : F.var list -> F.pred -> F.pred
val exists : F.var list -> F.pred -> F.pred
val fresh : string -> Mdata.vkind -> F.var
val pool : unit -> F.pool
val vkind_of_var : F.var -> Mdata.vkind
val term_such_that : Formula.tau ->
('a F.term -> F.pred) ->
'a F.term
val subst_in_bindings : context ->
F.var ->
Formula.abstract F.term ->
F.pred -> F.pred
val subst : F.var ->
'a F.term -> F.pred -> F.pred
val close : binding list -> F.pred -> F.pred
val has_vars : F.var list -> F.pred -> bool
val push : string ->
F.pool ->
bindings -> hint list -> context
val pop : string -> context -> bindings
val flush : string ->
context -> F.pred -> F.pred
val kill : string -> context -> unit
type substitution = (F.var * F.var) list 
val pp_sigma : Format.formatter ->
(F.var * F.var) list -> unit
val pp_bindings : Format.formatter ->
(F.var * 'a F.term) list -> unit

type havoc =
| Fresh of F.var
| Update of F.var
* (substitution -> Formula.abstract F.term)
val freshen : F.var -> F.var
val apply : (F.var * F.var) list ->
'a F.term -> 'a F.term
val domain : F.var list ->
F.var list ->
havoc list ->
F.var list * F.var list
val reverse : (F.var * F.var) list ->
(F.var * F.var) list
val freshen_sigma : F.var ->
(F.var * F.var) list ->
(F.var * F.var) list
val compute_bindings : (F.var * Formula.abstract F.term) list ->
(F.var * F.var) list ->
substitution ->
havoc list ->
(F.var * Formula.abstract F.term) list *
substitution
val apply_bindings : (F.var * 'a F.term) list ->
F.pred -> F.pred
val rename : (F.var * F.var) list ->
F.pred -> F.pred
val fixpoint : ('a * F.var) list ->
('b * F.var) list ->
F.pred -> F.pred
val havoc_inductive : havoc list -> F.pred -> F.pred
val havoc_static : havoc list -> F.pred -> F.pred
val tau_of_object : Ctypes.c_object -> Formula.tau
val format_of_object : Ctypes.c_object -> format
val acc_field : 'a F.term ->
Findex.t -> 'b F.term
val upd_field : 'a F.term ->
Findex.t ->
'b F.term -> 'c F.term
val acc_index : Formula.m_array F.term ->
Formula.integer F.term ->
Formula.abstract F.term
val upd_index : Formula.m_array F.term ->
Formula.integer F.term ->
Formula.abstract F.term ->
Formula.m_array F.term
val encode : 'a F.term ->
'b F.term -> 'c F.term
val decode : 'a F.term ->
'b F.term -> 'c F.term
val equal_rec : (Ctypes.c_object ->
Formula.abstract F.term ->
Formula.abstract F.term -> F.pred)
Pervasives.ref
val eq_record_definition : Cil_types.compinfo -> string -> F.pred
val eq_array_definition : Ctypes.arrayinfo -> string -> F.pred
module RecEqName: Register(sig
include Compinfo
val declare : Cil_types.compinfo -> 'a -> 'b Formula.item
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Datalib.Create.Compinfo.t -> unit
end)
module RecEqDef: Register(sig
include Compinfo
val declare : Datalib.Create.RecEqName.t -> 'a -> Datalib.Create.F.pred Formula.item
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Datalib.Create.Compinfo.t -> unit
val pp_descr : Format.formatter -> 'a -> unit
end)
module ArrEqName: Register(sig
include Arrayinfo
val declare : Ctypes.arrayinfo -> 'a -> 'b Formula.item
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Datalib.Create.Arrayinfo.t -> unit
end)
module ArrEqDef: Register(sig
include Arrayinfo
val declare : Datalib.Create.ArrEqName.t -> 'a -> Datalib.Create.F.pred Formula.item
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Datalib.Create.Arrayinfo.t -> unit
val pp_descr : Format.formatter -> 'a -> unit
end)
val eq_record : RecEqDef.t ->
record -> record -> F.pred
val eq_array : ArrEqDef.t ->
array -> array -> F.pred
val equal : Ctypes.c_object ->
Formula.abstract F.term ->
Formula.abstract F.term -> F.pred