Functor Translate_prop.Create


module Create: 
functor (M : Mlogic.S) -> sig .. end
Parameters:
M : Mlogic.S

module F: M.D.F
module D: M.D

type userdef = {
   d_info : Cil_types.logic_info;
   d_callname : string;
   d_implicit : F.var list;
   d_closure : M.closure list;
   d_formals : F.var list;
}
type axiomdef = {
   a_name : string;
   a_labels : string list;
   a_hyp_name : string;
   a_def_name : string;
   a_implicit : F.var list;
   a_closure : M.closure list;
   a_property : F.pred;
}
module Hdef: Cil_datatype.Logic_var.Hashtbl
val user_axioms : (string, D.F.pred) Hashtbl.t
val user_axiomdefs : (string, axiomdef option) Hashtbl.t
val user_variables : Formula.abstract F.term Hdef.t
val user_definitions : (userdef *
(string * D.F.pred Formula.item) list)
Hdef.t
module UserVariable: D.Register(sig
include D.Logicvar
val pp_title : Format.formatter -> Cil_types.logic_var -> unit
val pp_descr : Format.formatter -> Cil_types.logic_var -> unit
val section : Formula.section
val clear : unit -> unit
val prefix : string
val declare : Cil_types.logic_var -> 'a -> 'b Formula.item
end)
val get_user_variable : Hdef.key ->
Formula.abstract F.term
val pp_closures : Format.formatter ->
F.var list -> M.closure list -> unit
val pp_formals : Format.formatter -> F.var list -> unit
module UserAxiom: D.Register(sig
type t = string 
module H: Hashtbl.Make(sig
type t = string 
val hash : 'a -> int
val equal : string -> string -> bool
end)
val section : Formula.section
val source : 'a option
val prefix : string
val clear : unit -> unit
val index : 'a -> 'a
val basename : 'a -> 'a
val location : 'a -> 'b option
val declare : string -> 'a -> Translate_prop.Create.D.F.pred Formula.item
val pp_title : Format.formatter -> string -> unit
val pp_descr : Format.formatter -> 'a -> unit
end)
module UserDefinition: sig .. end
module UserAxiomDefs: sig .. end

type xvar =
| PrmVar of M.value
| MemVar

type env = {
   formals_in_pre : bool;
   frame : M.frame;
   label : Clabels.c_label;
   lvars : Formula.abstract F.term Cil_datatype.Logic_var.Map.t;
   xvars : M.value Cil_datatype.Varinfo.Map.t;
}
val env_at : env -> Clabels.c_label -> env
val get_frame : env -> M.frame
val mem_at_env : env -> M.mem
val quant_env : env ->
(Cil_datatype.Logic_var.Map.key *
Formula.abstract F.term)
list -> env
val env_body : M.frame -> env
val call_post : Kernel_function.t ->
M.value list ->
M.mem -> M.mem -> M.D.F.var option -> env
val call_pre : Kernel_function.t -> M.value list -> M.mem -> env
val call_exit : env -> M.D.F.var -> env
val assigns_clause : M.frame -> env
val lvar : Formula.abstract F.term Cil_datatype.Logic_var.Map.t ->
Cil_datatype.Logic_var.Map.key ->
Formula.abstract F.term
val add_lvar : env ->
Cil_datatype.Logic_var.Map.key ->
Formula.abstract F.term -> env
val xvar_of_varinfo : env ->
Cil_datatype.Varinfo.Map.key -> xvar

type kind =
| Kcint of Ctypes.c_int
| Kint
| Kreal
| Kbool
| Kptr of Cil_types.typ
| Kset of kind
| Kstruct of Cil_types.compinfo
| Karray of Ctypes.arrayinfo
| Kadt of string * kind list
val pp_kind : Format.formatter -> kind -> unit

type data =
| Data of Formula.abstract F.term
| Loc of M.loc
| Value of M.value
| Interval of D.interval
| Range of Ctypes.c_object * M.loc * D.interval
| List of data list
| Set of D.set
val pp_data : Format.formatter -> data -> unit
val data_of_integer : Formula.integer F.term -> data
val data_of_real : Formula.real F.term -> data
val data_of_boolean : Formula.boolean F.term -> data
val integer_of_value : M.value -> M.D.integer
val real_of_value : M.value -> M.D.real
val extract_from_data : data -> 'a F.term
val boolean_of_data : data -> Formula.boolean F.term
val array_of_data : data -> D.array
val record_of_data : data -> D.record
val urecord_of_data : data -> D.urecord
val loc_of_data : Ctypes.c_object -> data -> M.loc
val integer_of_data : kind ->
data -> Formula.integer F.term
val real_of_data : kind ->
data -> Formula.real F.term
val set_of : data -> D.set
val list_of : data -> data list
val union_data : data ->
data -> data
val union_map : ('a -> data) -> 'a list -> data
val term_of_data : data -> Formula.abstract F.term
val neg_interval : D.interval -> D.interval
val object_of_pointed : kind -> Ctypes.c_object
val kind_of_typ : Cil_types.typ -> kind
val kind_of_data : Cil_types.typ -> data -> kind
val kind_of : Cil_types.logic_type -> kind
val typ_of_elements : Cil_types.logic_type -> Cil_types.typ
val data_rec : (env -> Cil_types.term -> data)
Pervasives.ref
val rec_apply_function : (env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> Formula.abstract F.term)
Pervasives.ref
val assigned_of_data : Ctypes.c_object ->
M.loc D.assigned list ->
data -> M.loc D.assigned list
val data_valid : M.mem ->
kind ->
data -> F.pred
val data_separated : Ctypes.c_object * data ->
Ctypes.c_object * data -> F.pred
val data_shift_range : Ctypes.c_object ->
M.loc ->
kind ->
data -> is_pos:bool -> data
val data_index_range : Ctypes.c_object ->
M.loc ->
kind ->
data -> data
val data_shift : kind ->
data ->
kind ->
data -> is_pos:bool -> data
val data_index : Ctypes.c_object ->
kind ->
data ->
kind ->
data -> data
val data_field : kind ->
data ->
Cil_types.fieldinfo -> data
val data_startof_set : Ctypes.c_object -> data -> data
val data_startof : Ctypes.c_object ->
kind ->
data -> data
val data_load : env ->
Cil_types.typ -> data -> data
val logic_offset : env ->
Formula.abstract F.term ->
Cil_types.term_offset -> data
val loc_offset : env ->
M.loc -> Cil_types.typ -> Cil_types.term_offset -> M.loc
val memory_offset : env ->
Cil_types.typ ->
data ->
Cil_types.term_offset -> Cil_types.typ * data
val gaddress_of_cvar : env ->
Cil_types.varinfo ->
Cil_types.term_offset -> Cil_types.typ * data
val gaddress_of_mem : env ->
Cil_types.term ->
Cil_types.term_offset -> Cil_types.typ * data
val gstartof : Cil_types.typ * data -> data
val gstartof_cvar : env ->
Cil_types.varinfo -> Cil_types.term_offset -> data
val gstartof_mem : env ->
Cil_types.term -> Cil_types.term_offset -> data
val gstartof_value : env ->
Cil_types.typ ->
M.value -> Cil_types.term_offset -> data
val cast : data ->
kind ->
kind -> data
val int_op : Cil_types.binop ->
Formula.integer F.term ->
Formula.integer F.term ->
Formula.integer F.term
val real_op : Cil_types.binop ->
Formula.real F.term ->
Formula.real F.term ->
Formula.real F.term
val rel_op : Cil_types.relation -> Cil_types.binop
val real_cmp : Cil_types.binop ->
Formula.real F.term ->
Formula.real F.term ->
Formula.boolean F.term
val int_cmp : Cil_types.binop ->
Formula.integer F.term ->
Formula.integer F.term ->
Formula.boolean F.term
val preal_cmp : Cil_types.binop ->
Formula.real F.term ->
Formula.real F.term -> F.pred
val pint_cmp : Cil_types.binop ->
Formula.integer F.term ->
Formula.integer F.term -> F.pred
val ptr_rel : Cil_types.binop ->
D.pointer ->
D.pointer -> D.F.pred
val ptr_cmp : Cil_types.binop ->
D.pointer ->
D.pointer -> D.boolean
val plus : Formula.integer F.term ->
Formula.integer F.term ->
Formula.integer F.term
val plus_interval : D.interval ->
Formula.integer F.term ->
D.interval
val plus_interval_interval : D.interval ->
D.interval -> data
val add_integer : kind ->
data ->
kind ->
data -> data
val data_cmp : Cil_types.binop ->
kind ->
data ->
kind ->
data -> Formula.boolean F.term
val data_binop : kind ->
Cil_types.binop ->
kind ->
data ->
kind ->
data -> data
val data_unop : kind ->
Cil_types.unop ->
kind ->
data -> data
val data_const : Cil_types.constant -> data
val data_of_term : env -> Cil_types.term -> data
val term : env ->
Cil_types.term -> Formula.abstract F.term
term e t interprets the C terms t in memory model environment e as a logic term.*
val data_of_assignable : env -> Cil_types.term -> data
val assigned : env ->
Cil_types.term -> M.loc D.assigned list
Compiles an arbitrary term representing a set of left-values into a zone
val rec_apply_predicate : (env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> F.pred)
Pervasives.ref
val pred_cmp : Cil_types.binop ->
kind ->
data ->
kind ->
data -> F.pred
val prop : env ->
Cil_types.predicate Cil_types.named -> F.pred
prop e p interprets an ACSL predicate as a logic predicats in memory model environment e. *
val prop_body : env ->
Cil_types.predicate Cil_types.named -> F.pred
val get_axiom : string -> axiomdef option

type partial =
| Svalue of Formula.abstract F.term
| Sclosure of M.closure
val hints : int Pervasives.ref
val pp_partial : Format.formatter -> partial -> unit
val apply_sigma : env ->
(string * Clabels.c_label) list -> M.closure -> partial
class instance : axiomdef -> partial list -> object .. end
val instance_of_hint : env ->
Axiomatics.hint -> instance option
val saturate : instance list ->
env ->
Axiomatics.hint list -> instance list
val hint_context : instance list option Pervasives.ref
val push_instances : string -> instance list -> unit
val pop_instances : string -> instance list
val apply_hints : env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list -> unit
val do_instantiate : (< alive : bool; instantiate : F.pred option; .. >
as 'a)
list ->
F.pred ->
'a list -> 'a list * F.pred
val instantiate : (< alive : bool; instantiate : F.pred option; .. >
as 'a)
list ->
F.pred -> 'a list * F.pred
val as_hint : instance -> D.hint
val merge : (< alive : bool; id : Datatype.Int.t; .. > as 'a) list -> 'a list -> 'a list
val get_definition : (Cil_types.logic_info ->
userdef *
(string * D.F.pred Formula.item) list) ->
Cil_types.logic_info -> userdef
val push_context : string ->
instance list option * D.context
val flush_context : string ->
instance list option * D.context ->
D.F.pred -> D.F.pred
val kill_context : string ->
instance list option * D.context ->
unit
val user_env : Cil_types.logic_info ->
(instance list option * D.context) *
(Cil_types.logic_var * D.F.var) list *
env
val compile_predicate : Cil_types.logic_info ->
userdef *
(string * D.F.pred Formula.item) list
val compile_function : Cil_types.logic_info ->
userdef *
(string * F.pred Formula.item) list
val axiom_env : string -> 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
Compile an axiom and add it to the list of global declarations.
val apply_closure : env ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
M.closure -> Formula.abstract M.D.F.term
val apply_predicate : env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> F.pred
val apply_function : env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> Formula.abstract F.term