sig
module Wp_parameters :
sig
type category
type warn_category
val verbose_atleast : int -> bool
val debug_atleast : int -> bool
val printf :
?level:int ->
?dkey:category ->
?current:bool ->
?source:Filepath.position ->
?append:(Format.formatter -> unit) ->
?header:(Format.formatter -> unit) ->
('a, Format.formatter, unit) format -> 'a
val result : ?level:int -> ?dkey:category -> 'a Log.pretty_printer
val feedback :
?ontty:Log.ontty ->
?level:int -> ?dkey:category -> 'a Log.pretty_printer
val debug : ?level:int -> ?dkey:category -> 'a Log.pretty_printer
val warning : ?wkey:warn_category -> 'a Log.pretty_printer
val error : 'a Log.pretty_printer
val abort : ('a, 'b) Log.pretty_aborter
val failure : 'a Log.pretty_printer
val fatal : ('a, 'b) Log.pretty_aborter
val verify : bool -> ('a, bool) Log.pretty_aborter
val not_yet_implemented :
?current:bool ->
?source:Filepath.position ->
('a, Format.formatter, unit, 'b) format4 -> 'a
val deprecated : string -> now:string -> ('a -> 'b) -> 'a -> 'b
val with_result :
(Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
val with_warning :
(Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
val with_error :
(Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
val with_failure :
(Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
val log :
?kind:Log.kind -> ?verbose:int -> ?debug:int -> 'a Log.pretty_printer
val logwith :
(Log.event option -> 'b) ->
?wkey:warn_category ->
?emitwith:(Log.event -> unit) ->
?once:bool -> ('a, 'b) Log.pretty_aborter
val register : Log.kind -> (Log.event -> unit) -> unit
val register_tag_handlers :
(string -> string) * (string -> string) -> unit
val register_category : string -> category
val pp_category : Format.formatter -> category -> unit
val dkey_name : category -> string
val is_registered_category : string -> bool
val get_category : string -> category option
val get_all_categories : unit -> category list
val add_debug_keys : category -> unit
val del_debug_keys : category -> unit
val get_debug_keys : unit -> category list
val is_debug_key_enabled : category -> bool
val get_debug_keyset : unit -> category list
val register_warn_category : string -> warn_category
val is_warn_category : string -> bool
val pp_warn_category : Format.formatter -> warn_category -> unit
val pp_all_warn_categories_status : unit -> unit
val wkey_name : warn_category -> string
val get_warn_category : string -> warn_category option
val get_all_warn_categories : unit -> warn_category list
val get_all_warn_categories_status :
unit -> (warn_category * Log.warn_status) list
val set_warn_status : warn_category -> Log.warn_status -> unit
val get_warn_status : warn_category -> Log.warn_status
val add_group : ?memo:bool -> string -> Cmdline.Group.t
module Help : Parameter_sig.Bool
module Verbose : Parameter_sig.Int
module Debug : Parameter_sig.Int
module Share : Parameter_sig.Specific_dir
module Session : Parameter_sig.Specific_dir
module Config : Parameter_sig.Specific_dir
val help : Cmdline.Group.t
val messages : Cmdline.Group.t
val add_plugin_output_aliases :
?visible:bool -> ?deprecated:bool -> string list -> unit
val reset : unit -> unit
val hypothesis : 'a Log.pretty_printer
type functions =
Fct_none
| Fct_all
| Fct_skip of Cil_datatype.Kf.Set.t
| Fct_list of Cil_datatype.Kf.Set.t
val get_fct : unit -> Wp.Wp_parameters.functions
val iter_fct :
(Kernel_function.t -> unit) -> Wp.Wp_parameters.functions -> unit
val iter_kf : (Kernel_function.t -> unit) -> unit
module WP : Parameter_sig.Bool
module Dump : Parameter_sig.Bool
module Behaviors : Parameter_sig.String_list
module Properties : Parameter_sig.String_list
module StatusAll : Parameter_sig.Bool
module StatusTrue : Parameter_sig.Bool
module StatusFalse : Parameter_sig.Bool
module StatusMaybe : Parameter_sig.Bool
val has_dkey : category -> bool
module Model : Parameter_sig.String_list
module ByValue : Parameter_sig.String_set
module ByRef : Parameter_sig.String_set
module InHeap : Parameter_sig.String_set
module AliasInit : Parameter_sig.Bool
module InCtxt : Parameter_sig.String_set
module ExternArrays : Parameter_sig.Bool
module Literals : Parameter_sig.Bool
module Volatile : Parameter_sig.Bool
module WeakIntModel : Parameter_sig.Bool
module Region : Parameter_sig.Bool
module Region_rw : Parameter_sig.Bool
module Region_pack : Parameter_sig.Bool
module Region_flat : Parameter_sig.Bool
module Region_annot : Parameter_sig.Bool
module Region_inline : Parameter_sig.Bool
module Region_fixpoint : Parameter_sig.Bool
module Region_cluster : Parameter_sig.Bool
module Region_output_dot : Parameter_sig.Filepath
module Init : Parameter_sig.Bool
module InitWithForall : Parameter_sig.Bool
module BoundForallUnfolding : Parameter_sig.Int
module RTE : Parameter_sig.Bool
module Simpl : Parameter_sig.Bool
module Let : Parameter_sig.Bool
module Core : Parameter_sig.Bool
module Prune : Parameter_sig.Bool
module FilterInit : Parameter_sig.Bool
module Clean : Parameter_sig.Bool
module Filter : Parameter_sig.Bool
module Parasite : Parameter_sig.Bool
module Prenex : Parameter_sig.Bool
module Ground : Parameter_sig.Bool
module Reduce : Parameter_sig.Bool
module ExtEqual : Parameter_sig.Bool
module UnfoldAssigns : Parameter_sig.Int
module Split : Parameter_sig.Bool
module SplitMax : Parameter_sig.Int
module SplitDepth : Parameter_sig.Int
module DynCall : Parameter_sig.Bool
module SimplifyIsCint : Parameter_sig.Bool
module SimplifyLandMask : Parameter_sig.Bool
module SimplifyForall : Parameter_sig.Bool
module SimplifyType : Parameter_sig.Bool
module CalleePreCond : Parameter_sig.Bool
module PrecondWeakening : Parameter_sig.Bool
module TerminatesExtDeclarations : Parameter_sig.Bool
module TerminatesStdlibDeclarations : Parameter_sig.Bool
module TerminatesDefinitions : Parameter_sig.Bool
module TerminatesVariantHyp : Parameter_sig.Bool
module Detect : Parameter_sig.Bool
module Generate : Parameter_sig.Bool
module ScriptOnStdout : Parameter_sig.Bool
module Provers : Parameter_sig.String_list
module Interactive : Parameter_sig.String
module RunAllProvers : Parameter_sig.Bool
module Cache : Parameter_sig.String
module CacheEnv : Parameter_sig.Bool
module CacheDir : Parameter_sig.String
module CachePrint : Parameter_sig.Bool
module Drivers : Parameter_sig.String_list
module Timeout : Parameter_sig.Int
module FctTimeout :
sig
type key = Cil_types.kernel_function
type value = int
type t
val set : t -> unit
val add_set_hook : (t -> t -> unit) -> unit
val add_update_hook : (t -> t -> unit) -> unit
val get : unit -> t
val clear : unit -> unit
val is_default : unit -> bool
val get_default : unit -> t
val option_name : string
val print_help : Format.formatter -> unit
val self : State.t
val name : string
val mark_as_computed : ?project:Project.t -> unit -> unit
val is_computed : ?project:Project.t -> unit -> bool
module Datatype : Datatype.S
val add_hook_on_update : (Datatype.t -> unit) -> unit
val howto_marshal :
(Datatype.t -> 'a) -> ('a -> Datatype.t) -> unit
val equal : t -> t -> bool
val add_aliases :
?visible:bool -> ?deprecated:bool -> string list -> unit
val is_set : unit -> bool
val unsafe_set : t -> unit
val parameter : Typed_parameter.t
type elt = key * value option
val is_empty : unit -> bool
val iter : (elt -> unit) -> unit
val fold : (elt -> 'a -> 'a) -> 'a -> 'a
val add : elt -> unit
module As_string : Parameter_sig.String
module Category :
sig
type elt = elt
type t = elt Parameter_category.t
val none : t
val default : unit -> t
val all : unit -> t
val set_default : t -> unit
val add :
string ->
State.t list -> elt Parameter_category.accessor -> t
val enable_all :
State.t list -> elt Parameter_category.accessor -> t
val enable_all_as : t -> unit
end
val find : key -> value
val mem : key -> bool
end
module SmokeTimeout : Parameter_sig.Int
module InteractiveTimeout : Parameter_sig.Int
module TimeExtra : Parameter_sig.Int
module TimeMargin : Parameter_sig.Int
module Steps : Parameter_sig.Int
module Procs : Parameter_sig.Int
module ProofTrace : Parameter_sig.Bool
module Why3Flags : Parameter_sig.String_list
module Auto : Parameter_sig.String_list
module AutoDepth : Parameter_sig.Int
module AutoWidth : Parameter_sig.Int
module BackTrack : Parameter_sig.Int
module TruncPropIdFileName : Parameter_sig.Int
module Print : Parameter_sig.Bool
module Report : Parameter_sig.String_list
module ReportJson : Parameter_sig.String
module ReportName : Parameter_sig.String
module MemoryContext : Parameter_sig.Bool
module CheckMemoryContext : Parameter_sig.Bool
module SmokeTests : Parameter_sig.Bool
module SmokeDeadassumes : Parameter_sig.Bool
module SmokeDeadcode : Parameter_sig.Bool
module SmokeDeadcall : Parameter_sig.Bool
module SmokeDeadlocalinit : Parameter_sig.Bool
module SmokeDeadloop : Parameter_sig.Bool
val has_out : unit -> bool
val has_session : unit -> bool
val get_session : force:bool -> unit -> Datatype.Filepath.t
val get_session_dir : force:bool -> string -> Datatype.Filepath.t
val get_output : unit -> Datatype.Filepath.t
val get_output_dir : string -> Datatype.Filepath.t
val make_output_dir : string -> unit
val has_print_generated : unit -> bool
val print_generated : ?header:string -> string -> unit
val cat_print_generated : category
val protect : exn -> bool
end
module Ctypes :
sig
type c_int =
CBool
| UInt8
| SInt8
| UInt16
| SInt16
| UInt32
| SInt32
| UInt64
| SInt64
type c_float = Float32 | Float64
type arrayflat = {
arr_size : int;
arr_dim : int;
arr_cell : Cil_types.typ;
arr_cell_nbr : int64;
}
type arrayinfo = {
arr_element : Cil_types.typ;
arr_flat : Wp.Ctypes.arrayflat option;
}
type c_object =
C_int of Wp.Ctypes.c_int
| C_float of Wp.Ctypes.c_float
| C_pointer of Cil_types.typ
| C_comp of Cil_types.compinfo
| C_array of Wp.Ctypes.arrayinfo
val object_of_pointed : Wp.Ctypes.c_object -> Wp.Ctypes.c_object
val object_of_array_elem : Wp.Ctypes.c_object -> Wp.Ctypes.c_object
val object_of_logic_type : Cil_types.logic_type -> Wp.Ctypes.c_object
val object_of_logic_pointed :
Cil_types.logic_type -> Wp.Ctypes.c_object
val i_iter : (Wp.Ctypes.c_int -> unit) -> unit
val f_iter : (Wp.Ctypes.c_float -> unit) -> unit
val i_memo : (Wp.Ctypes.c_int -> 'a) -> Wp.Ctypes.c_int -> 'a
val f_memo : (Wp.Ctypes.c_float -> 'a) -> Wp.Ctypes.c_float -> 'a
val is_char : Wp.Ctypes.c_int -> bool
val c_char : unit -> Wp.Ctypes.c_int
val c_bool : unit -> Wp.Ctypes.c_int
val c_ptr : unit -> Wp.Ctypes.c_int
val c_int : Cil_types.ikind -> Wp.Ctypes.c_int
val c_float : Cil_types.fkind -> Wp.Ctypes.c_float
val object_of : Cil_types.typ -> Wp.Ctypes.c_object
val is_pointer : Wp.Ctypes.c_object -> bool
val char : char -> int64
val constant : Cil_types.exp -> int64
val get_int : Cil_types.exp -> int option
val get_int64 : Cil_types.exp -> int64 option
val signed : Wp.Ctypes.c_int -> bool
val bounds : Wp.Ctypes.c_int -> Integer.t * Integer.t
val i_bits : Wp.Ctypes.c_int -> int
val i_bytes : Wp.Ctypes.c_int -> int
val f_bits : Wp.Ctypes.c_float -> int
val f_bytes : Wp.Ctypes.c_float -> int
val p_bits : unit -> int
val p_bytes : unit -> int
val sub_c_int : Wp.Ctypes.c_int -> Wp.Ctypes.c_int -> bool
val equal_float : Wp.Ctypes.c_float -> Wp.Ctypes.c_float -> bool
val sizeof_defined : Wp.Ctypes.c_object -> bool
val sizeof_object : Wp.Ctypes.c_object -> int
val bits_sizeof_comp : Cil_types.compinfo -> int
val bits_sizeof_array : Wp.Ctypes.arrayinfo -> int
val bits_sizeof_object : Wp.Ctypes.c_object -> int
val field_offset : Cil_types.fieldinfo -> int
val no_infinite_array : Wp.Ctypes.c_object -> bool
val is_compound : Wp.Ctypes.c_object -> bool
val is_comp : Wp.Ctypes.c_object -> Cil_types.compinfo -> bool
val is_array : Wp.Ctypes.c_object -> elt:Wp.Ctypes.c_object -> bool
val get_array :
Wp.Ctypes.c_object -> (Wp.Ctypes.c_object * int option) option
val get_array_size : Wp.Ctypes.c_object -> int option
val get_array_dim : Wp.Ctypes.c_object -> int
val array_size : Wp.Ctypes.arrayinfo -> int option
val array_dimensions :
Wp.Ctypes.arrayinfo -> Wp.Ctypes.c_object * int option list
val dimension_of_object : Wp.Ctypes.c_object -> (int * int64) option
val i_convert : Wp.Ctypes.c_int -> Wp.Ctypes.c_int -> Wp.Ctypes.c_int
val f_convert :
Wp.Ctypes.c_float -> Wp.Ctypes.c_float -> Wp.Ctypes.c_float
val promote :
Wp.Ctypes.c_object -> Wp.Ctypes.c_object -> Wp.Ctypes.c_object
val pp_int : Stdlib.Format.formatter -> Wp.Ctypes.c_int -> unit
val pp_float : Stdlib.Format.formatter -> Wp.Ctypes.c_float -> unit
val pp_object : Stdlib.Format.formatter -> Wp.Ctypes.c_object -> unit
val i_name : Wp.Ctypes.c_int -> string
val f_name : Wp.Ctypes.c_float -> string
val basename : Wp.Ctypes.c_object -> string
val compare : Wp.Ctypes.c_object -> Wp.Ctypes.c_object -> int
val equal : Wp.Ctypes.c_object -> Wp.Ctypes.c_object -> bool
val hash : Wp.Ctypes.c_object -> int
val pretty : Stdlib.Format.formatter -> Wp.Ctypes.c_object -> unit
module C_object :
sig
type t = c_object
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 AinfoComparable :
sig
type t = Wp.Ctypes.arrayinfo
val compare :
Wp.Ctypes.AinfoComparable.t -> Wp.Ctypes.AinfoComparable.t -> int
val equal :
Wp.Ctypes.AinfoComparable.t ->
Wp.Ctypes.AinfoComparable.t -> bool
val hash : Wp.Ctypes.AinfoComparable.t -> int
end
val compare_c_int : Wp.Ctypes.c_int -> Wp.Ctypes.c_int -> int
val compare_c_float : Wp.Ctypes.c_float -> Wp.Ctypes.c_float -> int
val compare_ptr_conflated :
Wp.Ctypes.c_object -> Wp.Ctypes.c_object -> int
end
module Clabels :
sig
type c_label
val is_here : Wp.Clabels.c_label -> bool
val mem : Wp.Clabels.c_label -> Wp.Clabels.c_label list -> bool
val equal : Wp.Clabels.c_label -> Wp.Clabels.c_label -> bool
module T :
sig
type t = Wp.Clabels.c_label
val compare : Wp.Clabels.T.t -> Wp.Clabels.T.t -> int
end
module LabelMap :
sig
type key = c_label
type +!'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val min_binding_opt : 'a t -> (key * 'a) option
val max_binding : 'a t -> key * 'a
val max_binding_opt : 'a t -> (key * 'a) option
val choose : 'a t -> key * 'a
val choose_opt : 'a t -> (key * 'a) option
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_first : (key -> bool) -> 'a t -> key * 'a
val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
val find_last : (key -> bool) -> 'a t -> key * 'a
val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Seq.t
val to_rev_seq : 'a t -> (key * 'a) Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
val of_seq : (key * 'a) Seq.t -> 'a t
end
module LabelSet :
sig
type elt = c_label
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val disjoint : t -> t -> bool
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val map : (elt -> elt) -> t -> t
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val min_elt_opt : t -> elt option
val max_elt : t -> elt
val max_elt_opt : t -> elt option
val choose : t -> elt
val choose_opt : t -> elt option
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val find_opt : elt -> t -> elt option
val find_first : (elt -> bool) -> t -> elt
val find_first_opt : (elt -> bool) -> t -> elt option
val find_last : (elt -> bool) -> t -> elt
val find_last_opt : (elt -> bool) -> t -> elt option
val of_list : elt list -> t
val to_seq_from : elt -> t -> elt Seq.t
val to_seq : t -> elt Seq.t
val to_rev_seq : t -> elt Seq.t
val add_seq : elt Seq.t -> t -> t
val of_seq : elt Seq.t -> t
end
val pre : Wp.Clabels.c_label
val here : Wp.Clabels.c_label
val next : Wp.Clabels.c_label
val init : Wp.Clabels.c_label
val post : Wp.Clabels.c_label
val exit : Wp.Clabels.c_label
val break : Wp.Clabels.c_label
val continue : Wp.Clabels.c_label
val default : Wp.Clabels.c_label
val loopentry : Wp.Clabels.c_label
val loopcurrent : Wp.Clabels.c_label
val formal : string -> Wp.Clabels.c_label
val case : int64 -> Wp.Clabels.c_label
val stmt : Cil_types.stmt -> Wp.Clabels.c_label
val stmt_post : Cil_types.stmt -> Wp.Clabels.c_label
val loop_entry : Cil_types.stmt -> Wp.Clabels.c_label
val loop_current : Cil_types.stmt -> Wp.Clabels.c_label
val to_logic : Wp.Clabels.c_label -> Cil_types.logic_label
val of_logic : Cil_types.logic_label -> Wp.Clabels.c_label
val is_post : Cil_types.logic_label -> bool
val pretty : Stdlib.Format.formatter -> Wp.Clabels.c_label -> unit
val name : Cil_types.logic_label -> string
val lookup :
(Cil_types.logic_label * Cil_types.logic_label) list ->
string -> Cil_types.logic_label
end
module MemoryContext :
sig
type validity = Valid | Nullable
type param =
NotUsed
| ByAddr
| ByValue
| ByShift
| ByRef
| InContext of Wp.MemoryContext.validity
| InArray of Wp.MemoryContext.validity
val pp_param :
Stdlib.Format.formatter -> Wp.MemoryContext.param -> unit
type partition
val empty : Wp.MemoryContext.partition
val set :
Cil_types.varinfo ->
Wp.MemoryContext.param ->
Wp.MemoryContext.partition -> Wp.MemoryContext.partition
val compute :
string ->
(Cil_types.kernel_function -> Wp.MemoryContext.partition) -> unit
val add_behavior :
Cil_types.kernel_function ->
string ->
(Cil_types.kernel_function -> Wp.MemoryContext.partition) -> unit
val warn :
Cil_types.kernel_function ->
string ->
(Cil_types.kernel_function -> Wp.MemoryContext.partition) -> unit
end
module LogicUsage :
sig
val basename : Cil_types.varinfo -> string
type logic_lemma = {
lem_name : string;
lem_position : Filepath.position;
lem_types : string list;
lem_labels : Cil_types.logic_label list;
lem_predicate : Cil_types.toplevel_predicate;
lem_depends : Wp.LogicUsage.logic_lemma list;
lem_attrs : Cil_types.attributes;
}
type axiomatic = {
ax_name : string;
ax_position : Filepath.position;
ax_property : Property.t;
mutable ax_types : Cil_types.logic_type_info list;
mutable ax_logics : Cil_types.logic_info list;
mutable ax_lemmas : Wp.LogicUsage.logic_lemma list;
mutable ax_reads : Cil_datatype.Varinfo.Set.t;
}
type logic_section =
Toplevel of int
| Axiomatic of Wp.LogicUsage.axiomatic
val compute : unit -> unit
val ip_lemma : Wp.LogicUsage.logic_lemma -> Property.t
val iter_lemmas : (Wp.LogicUsage.logic_lemma -> unit) -> unit
val fold_lemmas : (Wp.LogicUsage.logic_lemma -> 'a -> 'a) -> 'a -> 'a
val logic_lemma : string -> Wp.LogicUsage.logic_lemma
val axiomatic : string -> Wp.LogicUsage.axiomatic
val section_of_lemma : string -> Wp.LogicUsage.logic_section
val section_of_type :
Cil_types.logic_type_info -> Wp.LogicUsage.logic_section
val section_of_logic :
Cil_types.logic_info -> Wp.LogicUsage.logic_section
val proof_context : unit -> Wp.LogicUsage.logic_lemma list
val is_recursive : Cil_types.logic_info -> bool
val get_induction_labels :
Cil_types.logic_info ->
string -> Wp.Clabels.LabelSet.t Wp.Clabels.LabelMap.t
val get_name : Cil_types.logic_info -> string
val pp_profile :
Stdlib.Format.formatter -> Cil_types.logic_info -> unit
val dump : unit -> unit
end
module RefUsage :
sig
type access = NoAccess | ByRef | ByArray | ByValue | ByAddr
val get :
?kf:Cil_types.kernel_function ->
?init:bool -> Cil_types.varinfo -> Wp.RefUsage.access
val iter :
?kf:Cil_types.kernel_function ->
?init:bool ->
(Cil_types.varinfo -> Wp.RefUsage.access -> unit) -> unit
val is_nullable : Cil_types.varinfo -> bool
val has_nullable : unit -> bool
val print :
Cil_types.varinfo ->
Wp.RefUsage.access -> Stdlib.Format.formatter -> unit
val dump : unit -> unit
val compute : unit -> unit
val is_computed : unit -> bool
end
module NormAtLabels :
sig
val catch_label_error : exn -> string -> string -> unit
type label_mapping
val labels_empty : Wp.NormAtLabels.label_mapping
val labels_fct_pre : Wp.NormAtLabels.label_mapping
val labels_fct_post : exit:bool -> Wp.NormAtLabels.label_mapping
val labels_fct_assigns : exit:bool -> Wp.NormAtLabels.label_mapping
val labels_assert :
kf:Cil_types.kernel_function ->
Cil_types.stmt -> Wp.NormAtLabels.label_mapping
val labels_loop : Cil_types.stmt -> Wp.NormAtLabels.label_mapping
val labels_stmt_pre :
kf:Cil_types.kernel_function ->
Cil_types.stmt -> Wp.NormAtLabels.label_mapping
val labels_stmt_post :
kf:Cil_types.kernel_function ->
Cil_types.stmt -> Wp.NormAtLabels.label_mapping
val labels_stmt_assigns :
kf:Cil_types.kernel_function ->
Cil_types.stmt -> Wp.NormAtLabels.label_mapping
val labels_stmt_post_l :
kf:Cil_types.kernel_function ->
Cil_types.stmt ->
Wp.Clabels.c_label option -> Wp.NormAtLabels.label_mapping
val labels_stmt_assigns_l :
kf:Cil_types.kernel_function ->
Cil_types.stmt ->
Wp.Clabels.c_label option -> Wp.NormAtLabels.label_mapping
val labels_predicate :
(Cil_types.logic_label * Cil_types.logic_label) list ->
Wp.NormAtLabels.label_mapping
val labels_axiom : Wp.NormAtLabels.label_mapping
val preproc_term :
Wp.NormAtLabels.label_mapping -> Cil_types.term -> Cil_types.term
val preproc_annot :
Wp.NormAtLabels.label_mapping ->
Cil_types.predicate -> Cil_types.predicate
val preproc_assigns :
Wp.NormAtLabels.label_mapping ->
Cil_types.from list -> Cil_types.from list
val has_postassigns : Cil_types.assigns -> bool
end
module WpPropId :
sig
type prop_id
val property_of_id : Wp.WpPropId.prop_id -> Property.t
val doomed_if_valid : Wp.WpPropId.prop_id -> Property.t list
val unreachable_if_valid : Wp.WpPropId.prop_id -> Property.other_loc
val source_of_id : Wp.WpPropId.prop_id -> Filepath.position
module PropId :
sig
type t = prop_id
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
val compare_prop_id : Wp.WpPropId.prop_id -> Wp.WpPropId.prop_id -> int
val tactical : gid:string -> Wp.WpPropId.prop_id
val is_check : Wp.WpPropId.prop_id -> bool
val is_tactic : Wp.WpPropId.prop_id -> bool
val is_assigns : Wp.WpPropId.prop_id -> bool
val is_requires : Property.t -> bool
val is_loop_preservation : Wp.WpPropId.prop_id -> Cil_types.stmt option
val is_smoke_test : Wp.WpPropId.prop_id -> bool
val select_default : Wp.WpPropId.prop_id -> bool
val select_by_name : string list -> Wp.WpPropId.prop_id -> bool
val select_for_behaviors : string list -> Wp.WpPropId.prop_id -> bool
val select_call_pre :
Cil_types.stmt -> Property.t option -> Wp.WpPropId.prop_id -> bool
val ident_names : string list -> string list
val prop_id_keys : Wp.WpPropId.prop_id -> string list * string list
val get_propid : Wp.WpPropId.prop_id -> string
val pp_propid : Stdlib.Format.formatter -> Wp.WpPropId.prop_id -> unit
val user_pred_names : Cil_types.toplevel_predicate -> string list
val user_bhv_names : Property.identified_property -> string list
val user_prop_names : Property.identified_property -> string list
val are_selected_names : string list -> string list -> bool
val pretty : Stdlib.Format.formatter -> Wp.WpPropId.prop_id -> unit
val pretty_context :
Description.kf ->
Stdlib.Format.formatter -> Wp.WpPropId.prop_id -> unit
val pretty_local :
Stdlib.Format.formatter -> Wp.WpPropId.prop_id -> unit
val label_of_prop_id : Wp.WpPropId.prop_id -> string
val string_of_termination_kind : Cil_types.termination_kind -> string
val num_of_bhv_from : Cil_types.funbehavior -> Cil_types.from -> int
val mk_smoke :
Cil_types.kernel_function ->
id:string ->
?doomed:Property.t list ->
?unreachable:Cil_types.stmt -> unit -> Wp.WpPropId.prop_id
val mk_code_annot_ids :
Cil_types.kernel_function ->
Cil_types.stmt ->
Cil_types.code_annotation -> Wp.WpPropId.prop_id list
val mk_assert_id :
Cil_types.kernel_function ->
Cil_types.stmt -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
val mk_loop_inv_id :
Cil_types.kernel_function ->
Cil_types.stmt ->
established:bool -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
val mk_loop_inv :
Cil_types.kernel_function ->
Cil_types.stmt ->
Cil_types.code_annotation ->
Wp.WpPropId.prop_id * Wp.WpPropId.prop_id
val mk_inv_hyp_id :
Cil_types.kernel_function ->
Cil_types.stmt -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
val mk_var_decr_id :
Cil_types.kernel_function ->
Cil_types.stmt -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
val mk_var_pos_id :
Cil_types.kernel_function ->
Cil_types.stmt -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
val mk_var_id :
Cil_types.kernel_function ->
Cil_types.stmt -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
val mk_loop_from_id :
Cil_types.kernel_function ->
Cil_types.stmt ->
Cil_types.code_annotation -> Cil_types.from -> Wp.WpPropId.prop_id
val mk_bhv_from_id :
Cil_types.kernel_function ->
Cil_types.kinstr ->
string list ->
Cil_types.funbehavior -> Cil_types.from -> Wp.WpPropId.prop_id
val mk_fct_from_id :
Cil_types.kernel_function ->
bool ->
Cil_types.funbehavior ->
Cil_types.termination_kind -> Cil_types.from -> Wp.WpPropId.prop_id
val mk_disj_bhv_id :
Cil_types.kernel_function * Cil_types.kinstr * string list *
string list -> Wp.WpPropId.prop_id
val mk_compl_bhv_id :
Cil_types.kernel_function * Cil_types.kinstr * string list *
string list -> Wp.WpPropId.prop_id
val mk_decrease_id :
Cil_types.kernel_function ->
Cil_types.kinstr -> Cil_types.variant -> Wp.WpPropId.prop_id
val mk_lemma_id : Wp.LogicUsage.logic_lemma -> Wp.WpPropId.prop_id
val mk_stmt_assigns_id :
Cil_types.kernel_function ->
Cil_types.stmt ->
string list ->
Cil_types.funbehavior ->
Cil_types.from list -> Wp.WpPropId.prop_id option
val mk_loop_assigns_id :
Cil_types.kernel_function ->
Cil_types.stmt ->
Cil_types.code_annotation ->
Cil_types.from list -> Wp.WpPropId.prop_id option
val mk_fct_assigns_id :
Cil_types.kernel_function ->
bool ->
Cil_types.funbehavior ->
Cil_types.termination_kind ->
Cil_types.from list -> Wp.WpPropId.prop_id option
val mk_pre_id :
Cil_types.kernel_function ->
Cil_types.kinstr ->
Cil_types.funbehavior ->
Cil_types.identified_predicate -> Wp.WpPropId.prop_id
val mk_post_id :
Cil_types.kernel_function ->
Cil_types.kinstr ->
Cil_types.funbehavior ->
Cil_types.termination_kind * Cil_types.identified_predicate ->
Wp.WpPropId.prop_id
val mk_terminates_id :
Cil_types.kernel_function ->
Cil_types.kinstr ->
Cil_types.identified_predicate -> Wp.WpPropId.prop_id
val mk_stmt_post_id :
Cil_types.kernel_function ->
Cil_types.stmt ->
Cil_types.funbehavior ->
Cil_types.termination_kind * Cil_types.identified_predicate ->
Wp.WpPropId.prop_id
val mk_fct_post_id :
Cil_types.kernel_function ->
Cil_types.funbehavior ->
Cil_types.termination_kind * Cil_types.identified_predicate ->
Wp.WpPropId.prop_id
val mk_call_pre_id :
Cil_types.kernel_function ->
Cil_types.stmt -> Property.t -> Property.t -> Wp.WpPropId.prop_id
val mk_property : Property.t -> Wp.WpPropId.prop_id
val mk_check : Property.t -> Wp.WpPropId.prop_id
type a_kind = LoopAssigns | StmtAssigns
type assigns_desc = private {
a_label : Wp.Clabels.c_label;
a_stmt : Cil_types.stmt option;
a_kind : Wp.WpPropId.a_kind;
a_assigns : Cil_types.assigns;
}
val pp_assigns_desc :
Stdlib.Format.formatter -> Wp.WpPropId.assigns_desc -> unit
type effect_source = FromCode | FromCall | FromReturn
type assigns_info = Wp.WpPropId.prop_id * Wp.WpPropId.assigns_desc
val assigns_info_id : Wp.WpPropId.assigns_info -> Wp.WpPropId.prop_id
type assigns_full_info = private
AssignsLocations of Wp.WpPropId.assigns_info
| AssignsAny of Wp.WpPropId.assigns_desc
| NoAssignsInfo
val empty_assigns_info : Wp.WpPropId.assigns_full_info
val mk_assigns_info :
Wp.WpPropId.prop_id ->
Wp.WpPropId.assigns_desc -> Wp.WpPropId.assigns_full_info
val mk_stmt_any_assigns_info :
Cil_types.stmt -> Wp.WpPropId.assigns_full_info
val mk_kf_any_assigns_info : unit -> Wp.WpPropId.assigns_full_info
val mk_loop_any_assigns_info :
Cil_types.stmt -> Wp.WpPropId.assigns_full_info
val pp_assign_info :
string ->
Stdlib.Format.formatter -> Wp.WpPropId.assigns_full_info -> unit
val merge_assign_info :
Wp.WpPropId.assigns_full_info ->
Wp.WpPropId.assigns_full_info -> Wp.WpPropId.assigns_full_info
val mk_loop_assigns_desc :
Cil_types.stmt -> Cil_types.from list -> Wp.WpPropId.assigns_desc
val mk_stmt_assigns_desc :
Cil_types.stmt -> Cil_types.from list -> Wp.WpPropId.assigns_desc
val mk_stmt_assigns_any_desc :
Cil_types.stmt -> Wp.WpPropId.assigns_desc
val mk_asm_assigns_desc : Cil_types.stmt -> Wp.WpPropId.assigns_desc
val mk_kf_assigns_desc :
Cil_types.from list -> Wp.WpPropId.assigns_desc
val mk_init_assigns : Wp.WpPropId.assigns_desc
val is_call_assigns : Wp.WpPropId.assigns_desc -> bool
type axiom_info = Wp.WpPropId.prop_id * Wp.LogicUsage.logic_lemma
val mk_axiom_info : Wp.LogicUsage.logic_lemma -> Wp.WpPropId.axiom_info
val pp_axiom_info :
Stdlib.Format.formatter -> Wp.WpPropId.axiom_info -> unit
type pred_info = Wp.WpPropId.prop_id * Cil_types.predicate
type variant_info = Wp.WpPropId.prop_id * Cil_types.variant
val mk_pred_info :
Wp.WpPropId.prop_id -> Cil_types.predicate -> Wp.WpPropId.pred_info
val pred_info_id : Wp.WpPropId.pred_info -> Wp.WpPropId.prop_id
val pp_pred_of_pred_info :
Stdlib.Format.formatter -> Wp.WpPropId.pred_info -> unit
val pp_pred_info :
Stdlib.Format.formatter -> Wp.WpPropId.pred_info -> unit
val split_bag :
(Wp.WpPropId.prop_id -> 'a -> unit) ->
Wp.WpPropId.prop_id -> 'a Bag.t -> unit
val split_map :
(Wp.WpPropId.prop_id -> 'a -> 'b) ->
Wp.WpPropId.prop_id -> 'a list -> 'b list
val mk_part : Wp.WpPropId.prop_id -> int * int -> Wp.WpPropId.prop_id
val parts_of_id : Wp.WpPropId.prop_id -> (int * int) option
val subproofs : Wp.WpPropId.prop_id -> int
val subproof_idx : Wp.WpPropId.prop_id -> int
val get_induction : Wp.WpPropId.prop_id -> Cil_types.stmt option
type proof
val create_proof : Wp.WpPropId.prop_id -> Wp.WpPropId.proof
val add_proof :
Wp.WpPropId.proof -> Wp.WpPropId.prop_id -> Property.t list -> unit
val add_invalid_proof : Wp.WpPropId.proof -> unit
val is_composed : Wp.WpPropId.proof -> bool
val is_proved : Wp.WpPropId.proof -> bool
val is_invalid : Wp.WpPropId.proof -> bool
val target : Wp.WpPropId.proof -> Property.t
val dependencies : Wp.WpPropId.proof -> Property.t list
val filter_status : Wp.WpPropId.prop_id -> bool
end
module Mcfg :
sig
type scope =
SC_Global
| SC_Frame_in
| SC_Frame_out
| SC_Block_in
| SC_Block_out
module type Export =
sig
type pred
type decl
val export_section : Stdlib.Format.formatter -> string -> unit
val export_goal :
Stdlib.Format.formatter -> string -> Wp.Mcfg.Export.pred -> unit
val export_decl :
Stdlib.Format.formatter -> Wp.Mcfg.Export.decl -> unit
end
module type Splitter =
sig
type pred
val simplify : Wp.Mcfg.Splitter.pred -> Wp.Mcfg.Splitter.pred
val split :
bool -> Wp.Mcfg.Splitter.pred -> Wp.Mcfg.Splitter.pred Bag.t
end
module type S =
sig
type t_env
type t_prop
val pretty : Stdlib.Format.formatter -> Wp.Mcfg.S.t_prop -> unit
val merge :
Wp.Mcfg.S.t_env ->
Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val empty : Wp.Mcfg.S.t_prop
val new_env :
?lvars:Cil_types.logic_var list ->
Cil_types.kernel_function -> Wp.Mcfg.S.t_env
val add_axiom :
Wp.WpPropId.prop_id -> Wp.LogicUsage.logic_lemma -> unit
val add_hyp :
?for_pid:Wp.WpPropId.prop_id ->
Wp.Mcfg.S.t_env ->
Wp.WpPropId.pred_info -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val add_goal :
Wp.Mcfg.S.t_env ->
Wp.WpPropId.pred_info -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val add_subgoal :
Wp.Mcfg.S.t_env ->
Wp.WpPropId.prop_id * 'a ->
?deps:Property.Set.t ->
Cil_types.predicate ->
Cil_types.stmt ->
Wp.WpPropId.effect_source -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val add_assigns :
Wp.Mcfg.S.t_env ->
Wp.WpPropId.assigns_info -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val use_assigns :
Wp.Mcfg.S.t_env ->
Wp.WpPropId.prop_id option ->
Wp.WpPropId.assigns_desc -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val label :
Wp.Mcfg.S.t_env ->
Cil_types.stmt option ->
Wp.Clabels.c_label -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val init :
Wp.Mcfg.S.t_env ->
Cil_types.varinfo ->
Cil_types.init option -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val const :
Wp.Mcfg.S.t_env ->
Cil_types.varinfo -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val assign :
Wp.Mcfg.S.t_env ->
Cil_types.stmt ->
Cil_types.lval ->
Cil_types.exp -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val return :
Wp.Mcfg.S.t_env ->
Cil_types.stmt ->
Cil_types.exp option -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val test :
Wp.Mcfg.S.t_env ->
Cil_types.stmt ->
Cil_types.exp ->
Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val switch :
Wp.Mcfg.S.t_env ->
Cil_types.stmt ->
Cil_types.exp ->
(Cil_types.exp list * Wp.Mcfg.S.t_prop) list ->
Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val has_init : Wp.Mcfg.S.t_env -> bool
val loop_entry : Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val loop_step : Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val call_dynamic :
Wp.Mcfg.S.t_env ->
Cil_types.stmt ->
Wp.WpPropId.prop_id ->
Cil_types.exp ->
(Cil_types.kernel_function * Wp.Mcfg.S.t_prop) list ->
Wp.Mcfg.S.t_prop
val call_goal_precond :
Wp.Mcfg.S.t_env ->
Cil_types.stmt ->
Cil_types.kernel_function ->
Cil_types.exp list ->
pre:Wp.WpPropId.pred_info list ->
Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val call_terminates :
Wp.Mcfg.S.t_env ->
Cil_types.stmt ->
Cil_types.kernel_function ->
Cil_types.exp list ->
Wp.WpPropId.pred_info ->
?callee_t:Cil_types.predicate ->
Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val call_decreases :
Wp.Mcfg.S.t_env ->
Cil_types.stmt ->
Cil_types.kernel_function ->
Cil_types.exp list ->
Wp.WpPropId.variant_info ->
?caller_t:Cil_types.predicate ->
?callee_d:Cil_types.variant ->
Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val call :
Wp.Mcfg.S.t_env ->
Cil_types.stmt ->
Cil_types.lval option ->
Cil_types.kernel_function ->
Cil_types.exp list ->
pre:Wp.WpPropId.pred_info list ->
post:Wp.WpPropId.pred_info list ->
pexit:Wp.WpPropId.pred_info list ->
assigns:Cil_types.assigns ->
p_post:Wp.Mcfg.S.t_prop ->
p_exit:Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val scope :
Wp.Mcfg.S.t_env ->
Cil_types.varinfo list ->
Wp.Mcfg.scope -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val close : Wp.Mcfg.S.t_env -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
val build_prop_of_from :
Wp.Mcfg.S.t_env ->
Wp.WpPropId.pred_info list ->
Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
end
end
module Context :
sig
val with_current_loc : Cil_types.location -> ('a -> 'b) -> 'a -> 'b
type 'a value
val create : ?default:'a -> string -> 'a Wp.Context.value
val defined : 'a Wp.Context.value -> bool
val get : 'a Wp.Context.value -> 'a
val get_opt : 'a Wp.Context.value -> 'a option
val set : 'a Wp.Context.value -> 'a -> unit
val update : 'a Wp.Context.value -> ('a -> 'a) -> unit
val bind : 'a Wp.Context.value -> 'a -> ('b -> 'c) -> 'b -> 'c
val free : 'a Wp.Context.value -> ('b -> 'c) -> 'b -> 'c
val clear : 'a Wp.Context.value -> unit
val push : 'a Wp.Context.value -> 'a -> 'a option
val pop : 'a Wp.Context.value -> 'a option -> unit
val name : 'a Wp.Context.value -> string
val register : (unit -> unit) -> unit
val configure : unit -> unit
end
module Warning :
sig
exception Error of string * string
val error :
?source:string ->
('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a
type t = {
loc : Filepath.position;
severe : bool;
source : string;
reason : string;
effect : string;
}
val compare : Wp.Warning.t -> Wp.Warning.t -> int
val pretty : Stdlib.Format.formatter -> Wp.Warning.t -> unit
module Set :
sig
type elt = t
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val disjoint : t -> t -> bool
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val map : (elt -> elt) -> t -> t
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val min_elt_opt : t -> elt option
val max_elt : t -> elt
val max_elt_opt : t -> elt option
val choose : t -> elt
val choose_opt : t -> elt option
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val find_opt : elt -> t -> elt option
val find_first : (elt -> bool) -> t -> elt
val find_first_opt : (elt -> bool) -> t -> elt option
val find_last : (elt -> bool) -> t -> elt
val find_last_opt : (elt -> bool) -> t -> elt option
val of_list : elt list -> t
val to_seq_from : elt -> t -> elt Seq.t
val to_seq : t -> elt Seq.t
val to_rev_seq : t -> elt Seq.t
val add_seq : elt Seq.t -> t -> t
val of_seq : elt Seq.t -> t
end
module Map :
sig
type key = t
type +!'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val min_binding_opt : 'a t -> (key * 'a) option
val max_binding : 'a t -> key * 'a
val max_binding_opt : 'a t -> (key * 'a) option
val choose : 'a t -> key * 'a
val choose_opt : 'a t -> (key * 'a) option
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_first : (key -> bool) -> 'a t -> key * 'a
val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
val find_last : (key -> bool) -> 'a t -> key * 'a
val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Seq.t
val to_rev_seq : 'a t -> (key * 'a) Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
val of_seq : (key * 'a) Seq.t -> 'a t
end
val severe : Wp.Warning.Set.t -> bool
type context
val context : ?source:string -> unit -> Wp.Warning.context
val flush : Wp.Warning.context -> Wp.Warning.Set.t
val add : Wp.Warning.t -> unit
val create :
?log:bool ->
?severe:bool ->
?source:string ->
effect:string ->
('a, Stdlib.Format.formatter, unit, Wp.Warning.t) Stdlib.format4 ->
'a
val emit :
?severe:bool ->
?source:string ->
effect:string ->
('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'a
val handle :
?severe:bool ->
effect:string -> handler:('a -> 'b) -> ('a -> 'b) -> 'a -> 'b
type 'a outcome =
Result of Wp.Warning.Set.t * 'a
| Failed of Wp.Warning.Set.t
val catch :
?source:string ->
?severe:bool ->
effect:string -> ('a -> 'b) -> 'a -> 'b Wp.Warning.outcome
end
module AssignsCompleteness :
sig
val compute : Kernel_function.t -> unit
val is_complete : Kernel_function.t -> bool
val warn : Kernel_function.t -> unit
val wkey_pedantic : Wp.Wp_parameters.warn_category
end
module WpContext :
sig
type model
type scope = Global | Kf of Kernel_function.t
type rollback = unit -> unit
type hypotheses =
Wp.MemoryContext.partition -> Wp.MemoryContext.partition
val register :
id:string ->
?descr:string ->
configure:(unit -> Wp.WpContext.rollback) ->
?hypotheses:Wp.WpContext.hypotheses -> unit -> Wp.WpContext.model
val get_descr : Wp.WpContext.model -> string
val get_emitter : Wp.WpContext.model -> Emitter.t
val compute_hypotheses :
Wp.WpContext.model -> Kernel_function.t -> Wp.MemoryContext.partition
type context = Wp.WpContext.model * Wp.WpContext.scope
type t = Wp.WpContext.context
module S :
sig
type t = Wp.WpContext.context
val id : Wp.WpContext.S.t -> string
val hash : Wp.WpContext.S.t -> int
val equal : Wp.WpContext.S.t -> Wp.WpContext.S.t -> bool
val compare : Wp.WpContext.S.t -> Wp.WpContext.S.t -> int
end
module MODEL :
sig
type t = Wp.WpContext.model
val id : Wp.WpContext.MODEL.t -> string
val descr : Wp.WpContext.MODEL.t -> string
val hash : Wp.WpContext.MODEL.t -> int
val equal : Wp.WpContext.MODEL.t -> Wp.WpContext.MODEL.t -> bool
val compare : Wp.WpContext.MODEL.t -> Wp.WpContext.MODEL.t -> int
val repr : Wp.WpContext.MODEL.t
end
module SCOPE :
sig
type t = Wp.WpContext.scope
val id : Wp.WpContext.SCOPE.t -> string
val hash : Wp.WpContext.SCOPE.t -> int
val equal : Wp.WpContext.SCOPE.t -> Wp.WpContext.SCOPE.t -> bool
val compare : Wp.WpContext.SCOPE.t -> Wp.WpContext.SCOPE.t -> int
end
module MINDEX :
sig
type key = model
type !'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : '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_opt : 'a t -> key -> 'a option
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 filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Seq.t
val to_seq_keys : 'a t -> key Seq.t
val to_seq_values : 'a t -> 'a Seq.t
val add_seq : 'a t -> (key * 'a) Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
val of_seq : (key * 'a) Seq.t -> 'a t
end
val is_defined : unit -> bool
val on_context : Wp.WpContext.context -> ('a -> 'b) -> 'a -> 'b
val get_model : unit -> Wp.WpContext.model
val get_scope : unit -> Wp.WpContext.scope
val get_context : unit -> Wp.WpContext.context
val directory : unit -> Datatype.Filepath.t
module type Entries =
sig
type key
type data
val name : string
val compare :
Wp.WpContext.Entries.key -> Wp.WpContext.Entries.key -> int
val pretty :
Stdlib.Format.formatter -> Wp.WpContext.Entries.key -> unit
end
module type Registry =
sig
module E : Entries
type key = E.key
type data = E.data
val id : basename:string -> Wp.WpContext.Registry.key -> string
val mem : Wp.WpContext.Registry.key -> bool
val find : Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data
val get :
Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data option
val clear : unit -> unit
val remove : Wp.WpContext.Registry.key -> unit
val define :
Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data -> unit
val update :
Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data -> unit
val memoize :
(Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data) ->
Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data
val compile :
(Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data) ->
Wp.WpContext.Registry.key -> unit
val callback :
(Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data -> unit) ->
unit
val iter :
(Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data -> unit) ->
unit
val iter_sorted :
(Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data -> unit) ->
unit
end
module Index :
functor (E : Entries) ->
sig
module E :
sig
type key = E.key
type data = E.data
val name : string
val compare : key -> key -> int
val pretty : Format.formatter -> key -> unit
end
type key = E.key
type data = E.data
val id : basename:string -> key -> string
val mem : key -> bool
val find : key -> data
val get : key -> data option
val clear : unit -> unit
val remove : key -> unit
val define : key -> data -> unit
val update : key -> data -> unit
val memoize : (key -> data) -> key -> data
val compile : (key -> data) -> key -> unit
val callback : (key -> data -> unit) -> unit
val iter : (key -> data -> unit) -> unit
val iter_sorted : (key -> data -> unit) -> unit
end
module Static :
functor (E : Entries) ->
sig
module E :
sig
type key = E.key
type data = E.data
val name : string
val compare : key -> key -> int
val pretty : Format.formatter -> key -> unit
end
type key = E.key
type data = E.data
val id : basename:string -> key -> string
val mem : key -> bool
val find : key -> data
val get : key -> data option
val clear : unit -> unit
val remove : key -> unit
val define : key -> data -> unit
val update : key -> data -> unit
val memoize : (key -> data) -> key -> data
val compile : (key -> data) -> key -> unit
val callback : (key -> data -> unit) -> unit
val iter : (key -> data -> unit) -> unit
val iter_sorted : (key -> data -> unit) -> unit
end
module type Key =
sig
type t
val compare : Wp.WpContext.Key.t -> Wp.WpContext.Key.t -> int
val pretty : Stdlib.Format.formatter -> Wp.WpContext.Key.t -> unit
end
module type Data =
sig
type key
type data
val name : string
val compile : Wp.WpContext.Data.key -> Wp.WpContext.Data.data
end
module type IData =
sig
type key
type data
val name : string
val basename : Wp.WpContext.IData.key -> string
val compile :
Wp.WpContext.IData.key -> string -> Wp.WpContext.IData.data
end
module type Generator =
sig
type key
type data
val get : Wp.WpContext.Generator.key -> Wp.WpContext.Generator.data
val mem : Wp.WpContext.Generator.key -> bool
val clear : unit -> unit
val remove : Wp.WpContext.Generator.key -> unit
end
module Generator :
functor (K : Key)
(D : sig
type key = K.t
type data
val name : string
val compile : key -> data
end)
->
sig
type key = D.key
type data = D.data
val get : key -> data
val mem : key -> bool
val clear : unit -> unit
val remove : key -> unit
end
module StaticGenerator :
functor (K : Key)
(D : sig
type key = K.t
type data
val name : string
val compile : key -> data
end)
->
sig
type key = D.key
type data = D.data
val get : key -> data
val mem : key -> bool
val clear : unit -> unit
val remove : key -> unit
end
module GeneratorID :
functor (K : Key)
(D : sig
type key = K.t
type data
val name : string
val basename : key -> string
val compile : key -> string -> data
end)
->
sig
type key = D.key
type data = D.data
val get : key -> data
val mem : key -> bool
val clear : unit -> unit
val remove : key -> unit
end
module StaticGeneratorID :
functor (K : Key)
(D : sig
type key = K.t
type data
val name : string
val basename : key -> string
val compile : key -> string -> data
end)
->
sig
type key = D.key
type data = D.data
val get : key -> data
val mem : key -> bool
val clear : unit -> unit
val remove : key -> unit
end
end
module Lang :
sig
type library = string
val comp_id : Cil_types.compinfo -> string
val comp_init_id : Cil_types.compinfo -> string
val field_id : Cil_types.fieldinfo -> string
val field_init_id : Cil_types.fieldinfo -> string
val type_id : Cil_types.logic_type_info -> string
val logic_id : Cil_types.logic_info -> string
val ctor_id : Cil_types.logic_ctor_info -> string
val lemma_id : string -> string
type datakind = KValue | KInit
type adt = private
Mtype of Wp.Lang.mdt
| Mrecord of Wp.Lang.mdt * Wp.Lang.fields
| Atype of Cil_types.logic_type_info
| Comp of Cil_types.compinfo * Wp.Lang.datakind
and mdt = string Wp.Lang.extern
and 'a extern = {
ext_id : int;
ext_link : 'a;
ext_library : Wp.Lang.library;
ext_debug : string;
}
and fields = { mutable fields : Wp.Lang.field list; }
and field =
Mfield of Wp.Lang.mdt * Wp.Lang.fields * string * Wp.Lang.tau
| Cfield of Cil_types.fieldinfo * Wp.Lang.datakind
and tau = (Wp.Lang.field, Wp.Lang.adt) Qed.Logic.datatype
type t_builtin =
E_mdt of Wp.Lang.mdt
| E_poly of (Wp.Lang.tau list -> Wp.Lang.tau)
type lfun =
ACSL of Cil_types.logic_info
| CTOR of Cil_types.logic_ctor_info
| Model of Wp.Lang.model
and model = {
m_category : Wp.Lang.lfun Qed.Logic.category;
m_params : Qed.Logic.sort list;
m_result : Qed.Logic.sort;
m_typeof : Wp.Lang.tau option list -> Wp.Lang.tau;
m_source : Wp.Lang.source;
m_coloring : bool;
}
and source =
Generated of Wp.WpContext.context option * string
| Extern of Qed.Engine.link Wp.Lang.extern
val mem_builtin_type : name:string -> bool
val is_builtin : Cil_types.logic_type_info -> bool
val is_builtin_type : name:string -> Wp.Lang.tau -> bool
val get_builtin_type : name:string -> Wp.Lang.adt
val datatype : library:string -> string -> Wp.Lang.adt
val record :
link:string ->
library:string -> (string * Wp.Lang.tau) list -> Wp.Lang.adt
val comp : Cil_types.compinfo -> Wp.Lang.adt
val comp_init : Cil_types.compinfo -> Wp.Lang.adt
val field : Wp.Lang.adt -> string -> Wp.Lang.field
val fields_of_adt : Wp.Lang.adt -> Wp.Lang.field list
val fields_of_tau : Wp.Lang.tau -> Wp.Lang.field list
val fields_of_field : Wp.Lang.field -> Wp.Lang.field list
val atype :
Cil_types.logic_type_info -> Wp.Lang.tau list -> Wp.Lang.tau
val adt : Cil_types.logic_type_info -> Wp.Lang.adt
type balance = Nary | Left | Right
val extern_s :
library:Wp.Lang.library ->
?link:Qed.Engine.link ->
?category:Wp.Lang.lfun Qed.Logic.category ->
?params:Qed.Logic.sort list ->
?sort:Qed.Logic.sort ->
?result:Wp.Lang.tau ->
?coloring:bool ->
?typecheck:(Wp.Lang.tau option list -> Wp.Lang.tau) ->
string -> Wp.Lang.lfun
val extern_f :
library:Wp.Lang.library ->
?link:Qed.Engine.link ->
?balance:Wp.Lang.balance ->
?category:Wp.Lang.lfun Qed.Logic.category ->
?params:Qed.Logic.sort list ->
?sort:Qed.Logic.sort ->
?result:Wp.Lang.tau ->
?coloring:bool ->
?typecheck:(Wp.Lang.tau option list -> Wp.Lang.tau) ->
('a, Stdlib.Format.formatter, unit, Wp.Lang.lfun) Stdlib.format4 ->
'a
val extern_p :
library:Wp.Lang.library ->
?bool:string ->
?prop:string ->
?link:Qed.Engine.link ->
?params:Qed.Logic.sort list -> ?coloring:bool -> unit -> Wp.Lang.lfun
val extern_fp :
library:Wp.Lang.library ->
?params:Qed.Logic.sort list ->
?link:string -> ?coloring:bool -> string -> Wp.Lang.lfun
val generated_f :
?context:bool ->
?category:Wp.Lang.lfun Qed.Logic.category ->
?params:Qed.Logic.sort list ->
?sort:Qed.Logic.sort ->
?result:Wp.Lang.tau ->
?coloring:bool ->
('a, Stdlib.Format.formatter, unit, Wp.Lang.lfun) Stdlib.format4 ->
'a
val generated_p :
?context:bool -> ?coloring:bool -> string -> Wp.Lang.lfun
val extern_t :
string -> link:string -> library:Wp.Lang.library -> Wp.Lang.mdt
val tau_of_object : Wp.Ctypes.c_object -> Wp.Lang.tau
val tau_of_ctype : Cil_types.typ -> Wp.Lang.tau
val tau_of_ltype : Cil_types.logic_type -> Wp.Lang.tau
val tau_of_return : Cil_types.logic_info -> Wp.Lang.tau
val tau_of_lfun :
Wp.Lang.lfun -> Wp.Lang.tau option list -> Wp.Lang.tau
val tau_of_field : Wp.Lang.field -> Wp.Lang.tau
val tau_of_record : Wp.Lang.field -> Wp.Lang.tau
val init_of_object : Wp.Ctypes.c_object -> Wp.Lang.tau
val init_of_ctype : Cil_types.typ -> Wp.Lang.tau
val t_int : Wp.Lang.tau
val t_real : Wp.Lang.tau
val t_bool : Wp.Lang.tau
val t_prop : Wp.Lang.tau
val t_addr : unit -> Wp.Lang.tau
val t_comp : Cil_types.compinfo -> Wp.Lang.tau
val t_init : Cil_types.compinfo -> Wp.Lang.tau
val t_float : Wp.Ctypes.c_float -> Wp.Lang.tau
val t_array : Wp.Lang.tau -> Wp.Lang.tau
val t_farray : Wp.Lang.tau -> Wp.Lang.tau -> Wp.Lang.tau
val t_datatype : Wp.Lang.adt -> Wp.Lang.tau list -> Wp.Lang.tau
val t_matrix : Wp.Lang.tau -> int -> Wp.Lang.tau
val pointer : Wp.Lang.tau Wp.Context.value
val floats : (Wp.Ctypes.c_float -> Wp.Lang.tau) Wp.Context.value
val poly : string list Wp.Context.value
val builtin_types : (string -> Wp.Lang.t_builtin) Wp.Context.value
val parameters : (Wp.Lang.lfun -> Qed.Logic.sort list) -> unit
val name_of_lfun : Wp.Lang.lfun -> string
val name_of_field : Wp.Lang.field -> string
val is_coloring_lfun : Wp.Lang.lfun -> bool
module ADT :
sig
type t = adt
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val debug : t -> string
val basename : t -> string
end
module Field :
sig
type t = field
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val debug : t -> string
val sort : t -> Qed.Logic.sort
end
module Fun :
sig
type t = lfun
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val debug : t -> string
val category : t -> t Qed.Logic.category
val params : t -> Qed.Logic.sort list
val sort : t -> Qed.Logic.sort
end
class virtual idprinting :
object
method datatype : Wp.Lang.ADT.t -> string
method field : Wp.Lang.Field.t -> string
method link : Wp.Lang.Fun.t -> Qed.Engine.link
method virtual sanitize : string -> string
method sanitize_field : string -> string
method sanitize_fun : string -> string
method sanitize_type : string -> string
end
module F :
sig
module QED :
sig
module ADT :
sig
type t = adt
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val debug : t -> string
val basename : t -> string
end
module Field :
sig
type t = field
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val debug : t -> string
val sort : t -> Qed.Logic.sort
end
module Fun :
sig
type t = lfun
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val debug : t -> string
val category : t -> t Qed.Logic.category
val params : t -> Qed.Logic.sort list
val sort : t -> Qed.Logic.sort
end
module Var : Qed.Logic.Variable
type term
type lc_term
module Term :
sig
type t = term
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val debug : t -> string
end
module Tset :
sig
type elt = term
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val find : elt -> t -> elt
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val map : (elt -> elt) -> t -> t
val mapf : (elt -> elt option) -> t -> t
val intersect : t -> t -> bool
end
module Tmap :
sig
type key = term
type 'a t
val is_empty : 'a t -> bool
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
end
module STset :
sig
type elt = term
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val disjoint : t -> t -> bool
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val map : (elt -> elt) -> t -> t
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val min_elt_opt : t -> elt option
val max_elt : t -> elt
val max_elt_opt : t -> elt option
val choose : t -> elt
val choose_opt : t -> elt option
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val find_opt : elt -> t -> elt option
val find_first : (elt -> bool) -> t -> elt
val find_first_opt : (elt -> bool) -> t -> elt option
val find_last : (elt -> bool) -> t -> elt
val find_last_opt : (elt -> bool) -> t -> elt option
val of_list : elt list -> t
val to_seq_from : elt -> t -> elt Seq.t
val to_seq : t -> elt Seq.t
val to_rev_seq : t -> elt Seq.t
val add_seq : elt Seq.t -> t -> t
val of_seq : elt Seq.t -> t
end
module STmap :
sig
type key = term
type +!'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val update :
key -> ('a option -> 'a option) -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val min_binding_opt : 'a t -> (key * 'a) option
val max_binding : 'a t -> key * 'a
val max_binding_opt : 'a t -> (key * 'a) option
val choose : 'a t -> key * 'a
val choose_opt : 'a t -> (key * 'a) option
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_first : (key -> bool) -> 'a t -> key * 'a
val find_first_opt :
(key -> bool) -> 'a t -> (key * 'a) option
val find_last : (key -> bool) -> 'a t -> key * 'a
val find_last_opt :
(key -> bool) -> 'a t -> (key * 'a) option
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Seq.t
val to_rev_seq : 'a t -> (key * 'a) Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
val of_seq : (key * 'a) Seq.t -> 'a t
end
type var = Var.t
type tau = (Field.t, ADT.t) Qed.Logic.datatype
module Tau :
sig
type t = tau
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val debug : t -> string
val basename : t -> string
end
module Vars :
sig
type elt = var
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val find : elt -> t -> elt
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val map : (elt -> elt) -> t -> t
val mapf : (elt -> elt option) -> t -> t
val intersect : t -> t -> bool
end
module Vmap :
sig
type key = var
type 'a t
val is_empty : 'a t -> bool
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
end
type pool
val pool : ?copy:pool -> unit -> pool
val add_var : pool -> var -> unit
val add_vars : pool -> Vars.t -> unit
val add_term : pool -> term -> unit
val fresh : pool -> ?basename:string -> tau -> var
val alpha : pool -> var -> var
val tau_of_var : var -> tau
val sort_of_var : var -> Qed.Logic.sort
val base_of_var : var -> string
type 'a expression =
(Field.t, ADT.t, Fun.t, var, lc_term, 'a)
Qed.Logic.term_repr
type repr = term expression
type record = (Field.t * term) list
val decide : term -> bool
val is_true : term -> Qed.Logic.maybe
val is_false : term -> Qed.Logic.maybe
val is_prop : term -> bool
val is_int : term -> bool
val is_real : term -> bool
val is_arith : term -> bool
val are_equal : term -> term -> Qed.Logic.maybe
val eval_eq : term -> term -> bool
val eval_neq : term -> term -> bool
val eval_lt : term -> term -> bool
val eval_leq : term -> term -> bool
val repr : term -> repr
val sort : term -> Qed.Logic.sort
val vars : term -> Vars.t
type path = int list
val subterm : term -> path -> term
val change_subterm : term -> path -> term -> term
val e_true : term
val e_false : term
val e_bool : bool -> term
val e_literal : bool -> term -> term
val e_int : int -> term
val e_float : float -> term
val e_zint : Z.t -> term
val e_real : Q.t -> term
val e_var : var -> term
val e_opp : term -> term
val e_times : Z.t -> term -> term
val e_sum : term list -> term
val e_prod : term list -> term
val e_add : term -> term -> term
val e_sub : term -> term -> term
val e_mul : term -> term -> term
val e_div : term -> term -> term
val e_mod : term -> term -> term
val e_eq : term -> term -> term
val e_neq : term -> term -> term
val e_leq : term -> term -> term
val e_lt : term -> term -> term
val e_imply : term list -> term -> term
val e_equiv : term -> term -> term
val e_and : term list -> term
val e_or : term list -> term
val e_not : term -> term
val e_if : term -> term -> term -> term
val e_const : tau -> term -> term
val e_get : term -> term -> term
val e_set : term -> term -> term -> term
val e_getfield : term -> Field.t -> term
val e_record : record -> term
val e_fun : ?result:tau -> Fun.t -> term list -> term
val e_repr : ?result:tau -> repr -> term
val e_forall : var list -> term -> term
val e_exists : var list -> term -> term
val e_lambda : var list -> term -> term
val e_apply : term -> term list -> term
val e_bind : Qed.Logic.binder -> var -> term -> term
val lc_open : var -> lc_term -> term
val e_unbind : var -> lc_term -> term
val e_open :
pool:pool ->
?forall:bool ->
?exists:bool ->
?lambda:bool -> term -> (Qed.Logic.binder * var) list * term
val e_close : (Qed.Logic.binder * var) list -> term -> term
type sigma
val sigma : ?pool:pool -> unit -> sigma
module Subst :
sig
type t = sigma
val create : ?pool:pool -> unit -> t
val copy : sigma -> sigma
val fresh : t -> tau -> var
val find : t -> term -> term
val filter : t -> term -> bool
val add : t -> term -> term -> unit
val add_fun : t -> (term -> term) -> unit
val add_filter : t -> (term -> bool) -> unit
val add_var : t -> var -> unit
val add_vars : t -> Vars.t -> unit
val add_term : t -> term -> unit
end
val e_subst : sigma -> term -> term
val e_subst_var : var -> term -> term -> term
val lc_vars : term -> Qed.Bvars.t
val lc_closed : term -> bool
val lc_repr : lc_term -> term
val lc_iter : (term -> unit) -> term -> unit
val f_map :
?pool:pool ->
?forall:bool ->
?exists:bool ->
?lambda:bool -> (term -> term) -> term -> term
val f_iter :
?pool:pool ->
?forall:bool ->
?exists:bool ->
?lambda:bool -> (term -> unit) -> term -> unit
val typeof :
?field:(Field.t -> tau) ->
?record:(Field.t -> tau) ->
?call:(Fun.t -> tau option list -> tau) -> term -> tau
val set_builtin :
?force:bool -> Fun.t -> (term list -> term) -> unit
val set_builtin' :
?force:bool ->
Fun.t -> (term list -> tau option -> term) -> unit
val set_builtin_map :
?force:bool -> Fun.t -> (term list -> term list) -> unit
val set_builtin_get :
?force:bool ->
Fun.t -> (term list -> tau option -> term -> term) -> unit
val set_builtin_eq :
?force:bool -> Fun.t -> (term -> term -> term) -> unit
val set_builtin_leq :
?force:bool -> Fun.t -> (term -> term -> term) -> unit
val consequence : term -> term -> term
val literal : term -> bool * term
val affine : term -> term Qed.Logic.affine
val record_with : record -> (term * record) option
type t = term
val id : t -> int
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val weigth : t -> int
val is_closed : t -> bool
val is_simple : t -> bool
val is_atomic : t -> bool
val is_primitive : t -> bool
val is_neutral : Fun.t -> t -> bool
val is_absorbant : Fun.t -> t -> bool
val size : t -> int
val basename : t -> string
val debug : Format.formatter -> t -> unit
val pp_id : Format.formatter -> t -> unit
val pp_rid : Format.formatter -> t -> unit
val pp_repr : Format.formatter -> repr -> unit
val is_subterm : term -> term -> bool
val shared :
?shared:(term -> bool) ->
?shareable:(term -> bool) ->
?subterms:((term -> unit) -> term -> unit) ->
term list -> term list
type marks
val marks :
?shared:(term -> bool) ->
?shareable:(term -> bool) ->
?subterms:((term -> unit) -> term -> unit) -> unit -> marks
val mark : marks -> term -> unit
val share : marks -> term -> unit
val defs : marks -> term list
end
type var = Wp.Lang.F.QED.var
type tau = Wp.Lang.F.QED.tau
type pool = Wp.Lang.F.QED.pool
module Tau = QED.Tau
module Var = QED.Var
module Vars :
sig
type elt = var
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val find : elt -> t -> elt
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val map : (elt -> elt) -> t -> t
val mapf : (elt -> elt option) -> t -> t
val intersect : t -> t -> bool
end
module Vmap :
sig
type key = var
type 'a t
val is_empty : 'a t -> bool
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val subset : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
end
val pool : ?copy:Wp.Lang.F.pool -> unit -> Wp.Lang.F.pool
val fresh :
Wp.Lang.F.pool ->
?basename:string -> Wp.Lang.F.tau -> Wp.Lang.F.var
val alpha : Wp.Lang.F.pool -> Wp.Lang.F.var -> Wp.Lang.F.var
val add_var : Wp.Lang.F.pool -> Wp.Lang.F.var -> unit
val add_vars : Wp.Lang.F.pool -> Wp.Lang.F.Vars.t -> unit
val tau_of_var : Wp.Lang.F.var -> Wp.Lang.F.tau
type term = Wp.Lang.F.QED.term
type record = (Wp.Lang.field * Wp.Lang.F.term) list
val hash : Wp.Lang.F.term -> int
val equal : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
val compare : Wp.Lang.F.term -> Wp.Lang.F.term -> int
module Tset :
sig
type elt = term
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val find : elt -> t -> elt
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val map : (elt -> elt) -> t -> t
val mapf : (elt -> elt option) -> t -> t
val intersect : t -> t -> bool
end
module Tmap :
sig
type key = term
type 'a t
val is_empty : 'a t -> bool
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val subset : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
end
type unop = Wp.Lang.F.term -> Wp.Lang.F.term
type binop = Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_zero : Wp.Lang.F.term
val e_one : Wp.Lang.F.term
val e_minus_one : Wp.Lang.F.term
val e_minus_one_real : Wp.Lang.F.term
val e_one_real : Wp.Lang.F.term
val e_zero_real : Wp.Lang.F.term
val constant : Wp.Lang.F.term -> Wp.Lang.F.term
val e_fact : int -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_int64 : int64 -> Wp.Lang.F.term
val e_bigint : Integer.t -> Wp.Lang.F.term
val e_float : float -> Wp.Lang.F.term
val e_setfield :
Wp.Lang.F.term ->
Wp.Lang.field -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_range : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val is_zero : Wp.Lang.F.term -> bool
val e_true : Wp.Lang.F.term
val e_false : Wp.Lang.F.term
val e_bool : bool -> Wp.Lang.F.term
val e_literal : bool -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_int : int -> Wp.Lang.F.term
val e_zint : Z.t -> Wp.Lang.F.term
val e_real : Q.t -> Wp.Lang.F.term
val e_var : Wp.Lang.F.var -> Wp.Lang.F.term
val e_opp : Wp.Lang.F.term -> Wp.Lang.F.term
val e_times : Z.t -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_sum : Wp.Lang.F.term list -> Wp.Lang.F.term
val e_prod : Wp.Lang.F.term list -> Wp.Lang.F.term
val e_add : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_sub : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_mul : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_div : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_mod : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_eq : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_neq : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_leq : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_lt : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_imply :
Wp.Lang.F.term list -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_equiv : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_and : Wp.Lang.F.term list -> Wp.Lang.F.term
val e_or : Wp.Lang.F.term list -> Wp.Lang.F.term
val e_not : Wp.Lang.F.term -> Wp.Lang.F.term
val e_if :
Wp.Lang.F.term ->
Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_const : Wp.Lang.F.tau -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_get : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_set :
Wp.Lang.F.term ->
Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_getfield :
Wp.Lang.F.term -> Wp.Lang.Field.t -> Wp.Lang.F.term
val e_record : Wp.Lang.F.record -> Wp.Lang.F.term
val e_fun :
?result:Wp.Lang.F.tau ->
Wp.Lang.Fun.t -> Wp.Lang.F.term list -> Wp.Lang.F.term
val e_bind :
Qed.Logic.binder ->
Wp.Lang.F.var -> Wp.Lang.F.term -> Wp.Lang.F.term
val e_open :
pool:Wp.Lang.F.pool ->
?forall:bool ->
?exists:bool ->
?lambda:bool ->
Wp.Lang.F.term ->
(Qed.Logic.binder * Wp.Lang.F.var) list * Wp.Lang.F.term
val e_close :
(Qed.Logic.binder * Wp.Lang.F.var) list ->
Wp.Lang.F.term -> Wp.Lang.F.term
type pred
type cmp = Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.pred
type operator = Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
module Pmap :
sig
type key = pred
type 'a t
val is_empty : 'a t -> bool
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val subset : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
end
module Pset :
sig
type elt = pred
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val find : elt -> t -> elt
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val map : (elt -> elt) -> t -> t
val mapf : (elt -> elt option) -> t -> t
val intersect : t -> t -> bool
end
val p_true : Wp.Lang.F.pred
val p_false : Wp.Lang.F.pred
val p_equal : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.pred
val p_equals :
(Wp.Lang.F.term * Wp.Lang.F.term) list -> Wp.Lang.F.pred list
val p_neq : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.pred
val p_leq : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.pred
val p_lt : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.pred
val p_positive : Wp.Lang.F.term -> Wp.Lang.F.pred
val is_ptrue : Wp.Lang.F.pred -> Qed.Logic.maybe
val is_pfalse : Wp.Lang.F.pred -> Qed.Logic.maybe
val is_equal : Wp.Lang.F.term -> Wp.Lang.F.term -> Qed.Logic.maybe
val eqp : Wp.Lang.F.pred -> Wp.Lang.F.pred -> bool
val comparep : Wp.Lang.F.pred -> Wp.Lang.F.pred -> int
val p_bool : Wp.Lang.F.term -> Wp.Lang.F.pred
val e_prop : Wp.Lang.F.pred -> Wp.Lang.F.term
val p_bools : Wp.Lang.F.term list -> Wp.Lang.F.pred list
val e_props : Wp.Lang.F.pred list -> Wp.Lang.F.term list
val e_lift :
(Wp.Lang.F.term -> Wp.Lang.F.term) ->
Wp.Lang.F.pred -> Wp.Lang.F.pred
val p_lift :
(Wp.Lang.F.pred -> Wp.Lang.F.pred) ->
Wp.Lang.F.term -> Wp.Lang.F.term
val p_not : Wp.Lang.F.pred -> Wp.Lang.F.pred
val p_and : Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
val p_or : Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
val p_imply : Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
val p_equiv : Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
val p_hyps :
Wp.Lang.F.pred list -> Wp.Lang.F.pred -> Wp.Lang.F.pred
val p_if :
Wp.Lang.F.pred ->
Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
val p_conj : Wp.Lang.F.pred list -> Wp.Lang.F.pred
val p_disj : Wp.Lang.F.pred list -> Wp.Lang.F.pred
val p_any : ('a -> Wp.Lang.F.pred) -> 'a list -> Wp.Lang.F.pred
val p_all : ('a -> Wp.Lang.F.pred) -> 'a list -> Wp.Lang.F.pred
val p_call : Wp.Lang.lfun -> Wp.Lang.F.term list -> Wp.Lang.F.pred
val p_forall :
Wp.Lang.F.var list -> Wp.Lang.F.pred -> Wp.Lang.F.pred
val p_exists :
Wp.Lang.F.var list -> Wp.Lang.F.pred -> Wp.Lang.F.pred
val p_bind :
Qed.Logic.binder ->
Wp.Lang.F.var -> Wp.Lang.F.pred -> Wp.Lang.F.pred
type sigma
module Subst :
sig
val copy : Wp.Lang.F.sigma -> Wp.Lang.F.sigma
val find : Wp.Lang.F.sigma -> Wp.Lang.F.term -> Wp.Lang.F.term
val add :
Wp.Lang.F.sigma -> Wp.Lang.F.term -> Wp.Lang.F.term -> unit
val add_fun :
Wp.Lang.F.sigma -> (Wp.Lang.F.term -> Wp.Lang.F.term) -> unit
val add_filter :
Wp.Lang.F.sigma -> (Wp.Lang.F.term -> bool) -> unit
end
val e_subst : Wp.Lang.F.sigma -> Wp.Lang.F.term -> Wp.Lang.F.term
val p_subst : Wp.Lang.F.sigma -> Wp.Lang.F.pred -> Wp.Lang.F.pred
val p_subst_var :
Wp.Lang.F.var ->
Wp.Lang.F.term -> Wp.Lang.F.pred -> Wp.Lang.F.pred
val e_vars : Wp.Lang.F.term -> Wp.Lang.F.var list
val p_vars : Wp.Lang.F.pred -> Wp.Lang.F.var list
val p_close : Wp.Lang.F.pred -> Wp.Lang.F.pred
val pp_tau : Stdlib.Format.formatter -> Wp.Lang.F.tau -> unit
val pp_var : Stdlib.Format.formatter -> Wp.Lang.F.var -> unit
val pp_vars : Stdlib.Format.formatter -> Wp.Lang.F.Vars.t -> unit
val pp_term : Stdlib.Format.formatter -> Wp.Lang.F.term -> unit
val pp_pred : Stdlib.Format.formatter -> Wp.Lang.F.pred -> unit
val debugp : Stdlib.Format.formatter -> Wp.Lang.F.pred -> unit
type env
val context_pp : Wp.Lang.F.env Wp.Context.value
type marks = Wp.Lang.F.QED.marks
val env : Wp.Lang.F.Vars.t -> Wp.Lang.F.env
val marker : Wp.Lang.F.env -> Wp.Lang.F.marks
val mark_e : Wp.Lang.F.marks -> Wp.Lang.F.term -> unit
val mark_p : Wp.Lang.F.marks -> Wp.Lang.F.pred -> unit
val defs : Wp.Lang.F.marks -> Wp.Lang.F.term list
val define :
(Wp.Lang.F.env -> string -> Wp.Lang.F.term -> unit) ->
Wp.Lang.F.env -> Wp.Lang.F.marks -> Wp.Lang.F.env
val pp_eterm :
Wp.Lang.F.env ->
Stdlib.Format.formatter -> Wp.Lang.F.term -> unit
val pp_epred :
Wp.Lang.F.env ->
Stdlib.Format.formatter -> Wp.Lang.F.pred -> unit
val p_expr :
Wp.Lang.F.pred -> Wp.Lang.F.pred Wp.Lang.F.QED.expression
val e_expr :
Wp.Lang.F.pred -> Wp.Lang.F.term Wp.Lang.F.QED.expression
val lc_closed : Wp.Lang.F.term -> bool
val lc_iter : (Wp.Lang.F.term -> unit) -> Wp.Lang.F.term -> unit
val decide : Wp.Lang.F.term -> bool
val basename : Wp.Lang.F.term -> string
val is_true : Wp.Lang.F.term -> Qed.Logic.maybe
val is_false : Wp.Lang.F.term -> Qed.Logic.maybe
val is_prop : Wp.Lang.F.term -> bool
val is_int : Wp.Lang.F.term -> bool
val is_real : Wp.Lang.F.term -> bool
val is_arith : Wp.Lang.F.term -> bool
val is_closed : Wp.Lang.F.term -> bool
val is_simple : Wp.Lang.F.term -> bool
val is_atomic : Wp.Lang.F.term -> bool
val is_primitive : Wp.Lang.F.term -> bool
val is_neutral : Wp.Lang.Fun.t -> Wp.Lang.F.term -> bool
val is_absorbant : Wp.Lang.Fun.t -> Wp.Lang.F.term -> bool
val record_with :
Wp.Lang.F.record -> (Wp.Lang.F.term * Wp.Lang.F.record) option
val are_equal : Wp.Lang.F.term -> Wp.Lang.F.term -> Qed.Logic.maybe
val eval_eq : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
val eval_neq : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
val eval_lt : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
val eval_leq : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
val repr : Wp.Lang.F.term -> Wp.Lang.F.QED.repr
val sort : Wp.Lang.F.term -> Qed.Logic.sort
val vars : Wp.Lang.F.term -> Wp.Lang.F.Vars.t
val varsp : Wp.Lang.F.pred -> Wp.Lang.F.Vars.t
val occurs : Wp.Lang.F.var -> Wp.Lang.F.term -> bool
val occursp : Wp.Lang.F.var -> Wp.Lang.F.pred -> bool
val intersect : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
val intersectp : Wp.Lang.F.pred -> Wp.Lang.F.pred -> bool
val is_subterm : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
val typeof :
?field:(Wp.Lang.Field.t -> Wp.Lang.F.tau) ->
?record:(Wp.Lang.Field.t -> Wp.Lang.F.tau) ->
?call:(Wp.Lang.Fun.t ->
Wp.Lang.F.tau option list -> Wp.Lang.F.tau) ->
Wp.Lang.F.term -> Wp.Lang.F.tau
val set_builtin :
Wp.Lang.lfun -> (Wp.Lang.F.term list -> Wp.Lang.F.term) -> unit
val set_builtin_get :
Wp.Lang.lfun ->
(Wp.Lang.F.term list ->
Wp.Lang.F.tau option -> Wp.Lang.F.term -> Wp.Lang.F.term) ->
unit
val set_builtin_1 : Wp.Lang.lfun -> Wp.Lang.F.unop -> unit
val set_builtin_2 : Wp.Lang.lfun -> Wp.Lang.F.binop -> unit
val set_builtin_2' :
Wp.Lang.lfun ->
(Wp.Lang.F.term ->
Wp.Lang.F.term -> Wp.Lang.F.tau option -> Wp.Lang.F.term) ->
unit
val set_builtin_eq : Wp.Lang.lfun -> Wp.Lang.F.binop -> unit
val set_builtin_leq : Wp.Lang.lfun -> Wp.Lang.F.binop -> unit
val set_builtin_eqp : Wp.Lang.lfun -> Wp.Lang.F.cmp -> unit
val release : unit -> unit
end
module N :
sig
val ( + ) : Wp.Lang.F.binop
val ( - ) : Wp.Lang.F.binop
val ( ~- ) : Wp.Lang.F.unop
val ( * ) : Wp.Lang.F.binop
val ( / ) : Wp.Lang.F.binop
val ( mod ) : Wp.Lang.F.binop
val ( = ) : Wp.Lang.F.cmp
val ( < ) : Wp.Lang.F.cmp
val ( > ) : Wp.Lang.F.cmp
val ( <= ) : Wp.Lang.F.cmp
val ( >= ) : Wp.Lang.F.cmp
val ( <> ) : Wp.Lang.F.cmp
val ( ==> ) : Wp.Lang.F.operator
val ( && ) : Wp.Lang.F.operator
val ( || ) : Wp.Lang.F.operator
val not : Wp.Lang.F.pred -> Wp.Lang.F.pred
val ( $ ) :
?result:Wp.Lang.tau ->
Wp.Lang.lfun -> Wp.Lang.F.term list -> Wp.Lang.F.term
val ( $$ ) : Wp.Lang.lfun -> Wp.Lang.F.term list -> Wp.Lang.F.pred
end
type gamma
val new_pool :
?copy:Wp.Lang.F.pool ->
?vars:Wp.Lang.F.Vars.t -> unit -> Wp.Lang.F.pool
val new_gamma : ?copy:Wp.Lang.gamma -> unit -> Wp.Lang.gamma
val local :
?pool:Wp.Lang.F.pool ->
?vars:Wp.Lang.F.Vars.t ->
?gamma:Wp.Lang.gamma -> ('a -> 'b) -> 'a -> 'b
val freshvar : ?basename:string -> Wp.Lang.F.tau -> Wp.Lang.F.var
val freshen : Wp.Lang.F.var -> Wp.Lang.F.var
val assume : Wp.Lang.F.pred -> unit
val without_assume : ('a -> 'b) -> 'a -> 'b
val hypotheses : Wp.Lang.gamma -> Wp.Lang.F.pred list
val get_pool : unit -> Wp.Lang.F.pool
val get_gamma : unit -> Wp.Lang.gamma
val has_gamma : unit -> bool
val get_hypotheses : unit -> Wp.Lang.F.pred list
val filter_hypotheses : Wp.Lang.F.var list -> Wp.Lang.F.pred list
val sigma : unit -> Wp.Lang.F.sigma
val alpha : unit -> Wp.Lang.F.sigma
val subst :
Wp.Lang.F.var list -> Wp.Lang.F.term list -> Wp.Lang.F.sigma
val e_subst :
(Wp.Lang.F.term -> Wp.Lang.F.term) ->
Wp.Lang.F.term -> Wp.Lang.F.term
val p_subst :
(Wp.Lang.F.term -> Wp.Lang.F.term) ->
Wp.Lang.F.pred -> Wp.Lang.F.pred
exception Contradiction
val is_literal : Wp.Lang.F.term -> bool
val iter_consequence_literals :
(Wp.Lang.F.term -> unit) -> Wp.Lang.F.term -> unit
class type simplifier =
object
method assume : Wp.Lang.F.pred -> unit
method copy : Wp.Lang.simplifier
method equivalent_branch : Wp.Lang.F.pred -> Wp.Lang.F.pred
method equivalent_exp : Wp.Lang.F.term -> Wp.Lang.F.term
method fixpoint : unit
method infer : Wp.Lang.F.pred list
method name : string
method stronger_goal : Wp.Lang.F.pred -> Wp.Lang.F.pred
method target : Wp.Lang.F.pred -> unit
method weaker_hyp : Wp.Lang.F.pred -> Wp.Lang.F.pred
end
module For_export :
sig
type specific_equality = {
for_tau : Wp.Lang.F.tau -> bool;
mk_new_eq : Wp.Lang.F.binop;
}
val rebuild :
?cache:Wp.Lang.F.term Wp.Lang.F.Tmap.t ->
Wp.Lang.F.term ->
Wp.Lang.F.term * Wp.Lang.F.term Wp.Lang.F.Tmap.t
val set_builtin :
Wp.Lang.Fun.t -> (Wp.Lang.F.term list -> Wp.Lang.F.term) -> unit
val set_builtin' :
Wp.Lang.Fun.t ->
(Wp.Lang.F.term list -> Wp.Lang.F.tau option -> Wp.Lang.F.term) ->
unit
val set_builtin_eq :
Wp.Lang.Fun.t ->
(Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term) -> unit
val set_builtin_leq :
Wp.Lang.Fun.t ->
(Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term) -> unit
val in_state : ('a -> 'b) -> 'a -> 'b
end
end
module Repr :
sig
type tau = Wp.Lang.F.tau
type var = Wp.Lang.F.var
type field = Wp.Lang.field
type lfun = Wp.Lang.lfun
type term = Wp.Lang.F.term
type pred = Wp.Lang.F.pred
type repr =
True
| False
| And of Wp.Repr.term list
| Or of Wp.Repr.term list
| Not of Wp.Repr.term
| Imply of Wp.Repr.term list * Wp.Repr.term
| If of Wp.Repr.term * Wp.Repr.term * Wp.Repr.term
| Var of Wp.Repr.var
| Int of Z.t
| Real of Q.t
| Add of Wp.Repr.term list
| Mul of Wp.Repr.term list
| Div of Wp.Repr.term * Wp.Repr.term
| Mod of Wp.Repr.term * Wp.Repr.term
| Eq of Wp.Repr.term * Wp.Repr.term
| Neq of Wp.Repr.term * Wp.Repr.term
| Lt of Wp.Repr.term * Wp.Repr.term
| Leq of Wp.Repr.term * Wp.Repr.term
| Times of Z.t * Wp.Repr.term
| Call of Wp.Repr.lfun * Wp.Repr.term list
| Field of Wp.Repr.term * Wp.Repr.field
| Record of (Wp.Repr.field * Wp.Repr.term) list
| Cst of Wp.Repr.tau * Wp.Repr.term
| Get of Wp.Repr.term * Wp.Repr.term
| Set of Wp.Repr.term * Wp.Repr.term * Wp.Repr.term
| HigherOrder
val term : Wp.Repr.term -> Wp.Repr.repr
val pred : Wp.Repr.pred -> Wp.Repr.repr
val lfun : Wp.Repr.lfun -> string
val field : Wp.Repr.field -> string
end
module Passive :
sig
type t
val empty : Wp.Passive.t
val is_empty : Wp.Passive.t -> bool
val union : Wp.Passive.t -> Wp.Passive.t -> Wp.Passive.t
val bind :
fresh:Wp.Lang.F.var ->
bound:Wp.Lang.F.var -> Wp.Passive.t -> Wp.Passive.t
val join :
Wp.Lang.F.var -> Wp.Lang.F.var -> Wp.Passive.t -> Wp.Passive.t
val conditions :
Wp.Passive.t -> (Wp.Lang.F.var -> bool) -> Wp.Lang.F.pred list
val apply : Wp.Passive.t -> Wp.Lang.F.pred -> Wp.Lang.F.pred
type binding =
Bind of Wp.Lang.F.var * Wp.Lang.F.var
| Join of Wp.Lang.F.var * Wp.Lang.F.var
val iter : (Wp.Passive.binding -> unit) -> Wp.Passive.t -> unit
val pretty : Stdlib.Format.formatter -> Wp.Passive.t -> unit
end
module Splitter :
sig
type tag =
THEN of Cil_types.stmt
| ELSE of Cil_types.stmt
| CALL of Cil_types.stmt * Cil_types.kernel_function
| CASE of Cil_types.stmt * int64 list
| DEFAULT of Cil_types.stmt
| ASSERT of Cil_types.identified_predicate * int * int
val loc : Wp.Splitter.tag -> Cil_types.location
val pretty : Stdlib.Format.formatter -> Wp.Splitter.tag -> unit
val if_then : Cil_types.stmt -> Wp.Splitter.tag
val if_else : Cil_types.stmt -> Wp.Splitter.tag
val switch_cases : Cil_types.stmt -> int64 list -> Wp.Splitter.tag
val switch_default : Cil_types.stmt -> Wp.Splitter.tag
val cases :
Cil_types.identified_predicate ->
(Wp.Splitter.tag * Cil_types.predicate) list option
val call :
Cil_types.stmt -> Cil_types.kernel_function -> Wp.Splitter.tag
type 'a t
val empty : 'a Wp.Splitter.t
val singleton : 'a -> 'a Wp.Splitter.t
val group :
Wp.Splitter.tag ->
('a list -> 'a) -> 'a Wp.Splitter.t -> 'a Wp.Splitter.t
val union :
('a -> 'a -> 'a) ->
'a Wp.Splitter.t -> 'a Wp.Splitter.t -> 'a Wp.Splitter.t
val merge :
left:('a -> 'c) ->
both:('a -> 'b -> 'c) ->
right:('b -> 'c) ->
'a Wp.Splitter.t -> 'b Wp.Splitter.t -> 'c Wp.Splitter.t
val merge_all :
('a list -> 'a) -> 'a Wp.Splitter.t list -> 'a Wp.Splitter.t
val unmark : ('a list -> 'a) -> 'a Wp.Splitter.t -> 'a Wp.Splitter.t
val length : 'a Wp.Splitter.t -> int
val map : ('a -> 'b) -> 'a Wp.Splitter.t -> 'b Wp.Splitter.t
val iter :
(Wp.Splitter.tag list -> 'a -> unit) -> 'a Wp.Splitter.t -> unit
val fold :
(Wp.Splitter.tag list -> 'a -> 'b -> 'b) ->
'a Wp.Splitter.t -> 'b -> 'b
val exists : ('a -> bool) -> 'a Wp.Splitter.t -> bool
val for_all : ('a -> bool) -> 'a Wp.Splitter.t -> bool
val filter : ('a -> bool) -> 'a Wp.Splitter.t -> 'a Wp.Splitter.t
end
module LogicBuiltins :
sig
type category = Wp.Lang.lfun Qed.Logic.category
type kind = Z | R | I of Wp.Ctypes.c_int | F of Wp.Ctypes.c_float | A
val kind_of_tau : Wp.Lang.tau -> Wp.LogicBuiltins.kind
val add_builtin :
string -> Wp.LogicBuiltins.kind list -> Wp.Lang.lfun -> unit
type driver
val driver : Wp.LogicBuiltins.driver Wp.Context.value
val new_driver :
id:string ->
?base:Wp.LogicBuiltins.driver ->
?descr:string ->
?includes:string list ->
?configure:(unit -> unit) -> unit -> Wp.LogicBuiltins.driver
val id : Wp.LogicBuiltins.driver -> string
val descr : Wp.LogicBuiltins.driver -> string
val is_default : Wp.LogicBuiltins.driver -> bool
val compare : Wp.LogicBuiltins.driver -> Wp.LogicBuiltins.driver -> int
val find_lib : string -> string
val dependencies : string -> string list
val add_library : string -> string list -> unit
val add_alias :
source:Filepath.position ->
string -> Wp.LogicBuiltins.kind list -> alias:string -> unit -> unit
val add_type :
?source:Filepath.position ->
string -> library:string -> ?link:string -> unit -> unit
val add_ctor :
source:Filepath.position ->
string ->
Wp.LogicBuiltins.kind list ->
library:string -> link:Qed.Engine.link -> unit -> unit
val add_logic :
source:Filepath.position ->
Wp.LogicBuiltins.kind ->
string ->
Wp.LogicBuiltins.kind list ->
library:string ->
?category:Wp.LogicBuiltins.category ->
link:Qed.Engine.link -> unit -> unit
val add_predicate :
source:Filepath.position ->
string ->
Wp.LogicBuiltins.kind list ->
library:string -> link:string -> unit -> unit
val add_option :
driver_dir:string ->
string -> string -> library:string -> string -> unit
val set_option :
driver_dir:string ->
string -> string -> library:string -> string -> unit
type doption
type sanitizer = driver_dir:string -> string -> string
val create_option :
sanitizer:Wp.LogicBuiltins.sanitizer ->
string -> string -> Wp.LogicBuiltins.doption
val get_option :
Wp.LogicBuiltins.doption -> library:string -> string list
type builtin =
ACSLDEF
| LFUN of Wp.Lang.lfun
| HACK of (Wp.Lang.F.term list -> Wp.Lang.F.term)
val logic : Cil_types.logic_info -> Wp.LogicBuiltins.builtin
val ctor : Cil_types.logic_ctor_info -> Wp.LogicBuiltins.builtin
val constant : string -> Wp.LogicBuiltins.builtin
val lookup :
string -> Wp.LogicBuiltins.kind list -> Wp.LogicBuiltins.builtin
val hack : string -> (Wp.Lang.F.term list -> Wp.Lang.F.term) -> unit
val hack_type : string -> (Wp.Lang.F.tau list -> Wp.Lang.F.tau) -> unit
val dump : unit -> unit
end
module Definitions :
sig
type cluster
val dummy : unit -> Wp.Definitions.cluster
val cluster :
id:string ->
?title:string ->
?position:Filepath.position -> unit -> Wp.Definitions.cluster
val axiomatic : Wp.LogicUsage.axiomatic -> Wp.Definitions.cluster
val section : Wp.LogicUsage.logic_section -> Wp.Definitions.cluster
val compinfo : Cil_types.compinfo -> Wp.Definitions.cluster
val matrix : unit -> Wp.Definitions.cluster
val cluster_id : Wp.Definitions.cluster -> string
val cluster_title : Wp.Definitions.cluster -> string
val cluster_position :
Wp.Definitions.cluster -> Filepath.position option
val cluster_age : Wp.Definitions.cluster -> int
val cluster_compare :
Wp.Definitions.cluster -> Wp.Definitions.cluster -> int
val pp_cluster :
Stdlib.Format.formatter -> Wp.Definitions.cluster -> unit
val iter : (Wp.Definitions.cluster -> unit) -> unit
type trigger = (Wp.Lang.F.var, Wp.Lang.lfun) Qed.Engine.ftrigger
type typedef =
(Wp.Lang.F.tau, Wp.Lang.field, Wp.Lang.lfun) Qed.Engine.ftypedef
type dlemma = {
l_name : string;
l_cluster : Wp.Definitions.cluster;
l_kind : Cil_types.predicate_kind;
l_types : int;
l_forall : Wp.Lang.F.var list;
l_triggers : Wp.Definitions.trigger list list;
l_lemma : Wp.Lang.F.pred;
}
type definition =
Logic of Wp.Lang.F.tau
| Function of Wp.Lang.F.tau * Wp.Definitions.recursion *
Wp.Lang.F.term
| Predicate of Wp.Definitions.recursion * Wp.Lang.F.pred
| Inductive of Wp.Definitions.dlemma list
and recursion = Def | Rec
type dfun = {
d_lfun : Wp.Lang.lfun;
d_cluster : Wp.Definitions.cluster;
d_types : int;
d_params : Wp.Lang.F.var list;
d_definition : Wp.Definitions.definition;
}
module Trigger :
sig
val of_term : Wp.Lang.F.term -> Wp.Definitions.trigger
val of_pred : Wp.Lang.F.pred -> Wp.Definitions.trigger
val vars : Wp.Definitions.trigger -> Wp.Lang.F.Vars.t
end
val find_symbol : Wp.Lang.lfun -> Wp.Definitions.dfun
val define_symbol : Wp.Definitions.dfun -> unit
val update_symbol : Wp.Definitions.dfun -> unit
val find_name : string -> Wp.Definitions.dlemma
val find_lemma : Wp.LogicUsage.logic_lemma -> Wp.Definitions.dlemma
val compile_lemma :
(Wp.LogicUsage.logic_lemma -> Wp.Definitions.dlemma) ->
Wp.LogicUsage.logic_lemma -> unit
val define_lemma : Wp.Definitions.dlemma -> unit
val define_type :
Wp.Definitions.cluster -> Cil_types.logic_type_info -> unit
val call_fun :
result:Wp.Lang.F.tau ->
Wp.Lang.lfun ->
(Wp.Lang.lfun -> Wp.Definitions.dfun) ->
Wp.Lang.F.term list -> Wp.Lang.F.term
val call_pred :
Wp.Lang.lfun ->
(Wp.Lang.lfun -> Wp.Definitions.dfun) ->
Wp.Lang.F.term list -> Wp.Lang.F.pred
type axioms = Wp.Definitions.cluster * Wp.LogicUsage.logic_lemma list
class virtual visitor :
Wp.Definitions.cluster ->
object
method do_local : Wp.Definitions.cluster -> bool
method virtual on_cluster : Wp.Definitions.cluster -> unit
method virtual on_comp :
Cil_types.compinfo ->
(Wp.Lang.field * Wp.Lang.F.tau) list option -> unit
method virtual on_dfun : Wp.Definitions.dfun -> unit
method virtual on_dlemma : Wp.Definitions.dlemma -> unit
method virtual on_icomp :
Cil_types.compinfo ->
(Wp.Lang.field * Wp.Lang.F.tau) list option -> unit
method virtual on_library : string -> unit
method virtual on_type :
Cil_types.logic_type_info -> Wp.Definitions.typedef -> unit
method virtual section : string -> unit
method set_local : Wp.Definitions.cluster -> unit
method vadt : Wp.Lang.ADT.t -> unit
method vcluster : Wp.Definitions.cluster -> unit
method vcomp : Cil_types.compinfo -> unit
method vfield : Wp.Lang.Field.t -> unit
method vgoal :
Wp.Definitions.axioms option -> Wp.Lang.F.pred -> unit
method vicomp : Cil_types.compinfo -> unit
method vlemma : Wp.LogicUsage.logic_lemma -> unit
method vlemmas : unit
method vlibrary : string -> unit
method vparam : Wp.Lang.F.var -> unit
method vpred : Wp.Lang.F.pred -> unit
method vself : unit
method vsymbol : Wp.Lang.lfun -> unit
method vsymbols : unit
method vtau : Wp.Lang.F.tau -> unit
method vterm : Wp.Lang.F.term -> unit
method vtype : Cil_types.logic_type_info -> unit
method vtypes : unit
end
end
module Cint :
sig
val of_real : Wp.Ctypes.c_int -> Wp.Lang.F.unop
val convert : Wp.Ctypes.c_int -> Wp.Lang.F.unop
val to_integer : Wp.Lang.F.unop
val of_integer : Wp.Ctypes.c_int -> Wp.Lang.F.unop
val to_cint : Wp.Lang.lfun -> Wp.Ctypes.c_int
val is_cint : Wp.Lang.lfun -> Wp.Ctypes.c_int
type model = Natural | Machine
val configure : Wp.Cint.model -> Wp.WpContext.rollback
val current : unit -> Wp.Cint.model
val range : Wp.Ctypes.c_int -> Wp.Lang.F.term -> Wp.Lang.F.pred
val downcast : Wp.Ctypes.c_int -> Wp.Lang.F.unop
val iopp : Wp.Ctypes.c_int -> Wp.Lang.F.unop
val iadd : Wp.Ctypes.c_int -> Wp.Lang.F.binop
val isub : Wp.Ctypes.c_int -> Wp.Lang.F.binop
val imul : Wp.Ctypes.c_int -> Wp.Lang.F.binop
val idiv : Wp.Ctypes.c_int -> Wp.Lang.F.binop
val imod : Wp.Ctypes.c_int -> Wp.Lang.F.binop
val bnot : Wp.Ctypes.c_int -> Wp.Lang.F.unop
val band : Wp.Ctypes.c_int -> Wp.Lang.F.binop
val bxor : Wp.Ctypes.c_int -> Wp.Lang.F.binop
val bor : Wp.Ctypes.c_int -> Wp.Lang.F.binop
val blsl : Wp.Ctypes.c_int -> Wp.Lang.F.binop
val blsr : Wp.Ctypes.c_int -> Wp.Lang.F.binop
val l_not : Wp.Lang.F.unop
val l_and : Wp.Lang.F.binop
val l_xor : Wp.Lang.F.binop
val l_or : Wp.Lang.F.binop
val l_lsl : Wp.Lang.F.binop
val l_lsr : Wp.Lang.F.binop
val f_lnot : Wp.Lang.lfun
val f_land : Wp.Lang.lfun
val f_lxor : Wp.Lang.lfun
val f_lor : Wp.Lang.lfun
val f_lsl : Wp.Lang.lfun
val f_lsr : Wp.Lang.lfun
val f_bitwised : Wp.Lang.lfun list
val f_bits : Wp.Lang.lfun list
val bit_test : Wp.Lang.F.term -> int -> Wp.Lang.F.term
val match_power2 : Wp.Lang.F.term -> Wp.Lang.F.term
val match_power2_minus1 : Wp.Lang.F.term -> Wp.Lang.F.term
val is_cint_simplifier : Wp.Lang.simplifier
val mask_simplifier : Wp.Lang.simplifier
val is_positive_or_null : Wp.Lang.F.term -> bool
end
module Cfloat :
sig
val f32 : Wp.Lang.adt
val f64 : Wp.Lang.adt
val t32 : Wp.Lang.F.tau
val t64 : Wp.Lang.F.tau
val fq32 : Wp.Lang.lfun
val fq64 : Wp.Lang.lfun
type model = Real | Float
val configure : Wp.Cfloat.model -> Wp.WpContext.rollback
val ftau : Wp.Ctypes.c_float -> Wp.Lang.F.tau
val tau_of_float : Wp.Ctypes.c_float -> Wp.Lang.F.tau
type op =
LT
| EQ
| LE
| NE
| NEG
| ADD
| SUB
| MUL
| DIV
| REAL
| ROUND
| EXACT
val find : Wp.Lang.lfun -> Wp.Cfloat.op * Wp.Ctypes.c_float
val code_lit :
Wp.Ctypes.c_float -> float -> string option -> Wp.Lang.F.term
val acsl_lit : Cil_types.logic_real -> Wp.Lang.F.term
val float_lit : Wp.Ctypes.c_float -> Q.t -> string
val float_of_int : Wp.Ctypes.c_float -> Wp.Lang.F.unop
val float_of_real : Wp.Ctypes.c_float -> Wp.Lang.F.unop
val real_of_float : Wp.Ctypes.c_float -> Wp.Lang.F.unop
val fopp : Wp.Ctypes.c_float -> Wp.Lang.F.unop
val fadd : Wp.Ctypes.c_float -> Wp.Lang.F.binop
val fsub : Wp.Ctypes.c_float -> Wp.Lang.F.binop
val fmul : Wp.Ctypes.c_float -> Wp.Lang.F.binop
val fdiv : Wp.Ctypes.c_float -> Wp.Lang.F.binop
val flt : Wp.Ctypes.c_float -> Wp.Lang.F.cmp
val fle : Wp.Ctypes.c_float -> Wp.Lang.F.cmp
val feq : Wp.Ctypes.c_float -> Wp.Lang.F.cmp
val fneq : Wp.Ctypes.c_float -> Wp.Lang.F.cmp
val f_model : Wp.Ctypes.c_float -> Wp.Lang.lfun
val f_delta : Wp.Ctypes.c_float -> Wp.Lang.lfun
val f_epsilon : Wp.Ctypes.c_float -> Wp.Lang.lfun
val flt_of_real : Wp.Ctypes.c_float -> Wp.Lang.lfun
val real_of_flt : Wp.Ctypes.c_float -> Wp.Lang.lfun
val flt_add : Wp.Ctypes.c_float -> Wp.Lang.lfun
val flt_mul : Wp.Ctypes.c_float -> Wp.Lang.lfun
val flt_div : Wp.Ctypes.c_float -> Wp.Lang.lfun
val flt_neg : Wp.Ctypes.c_float -> Wp.Lang.lfun
end
module Vset :
sig
type set = Wp.Vset.vset list
and vset =
Set of Wp.Lang.F.tau * Wp.Lang.F.term
| Singleton of Wp.Lang.F.term
| Range of Wp.Lang.F.term option * Wp.Lang.F.term option
| Descr of Wp.Lang.F.var list * Wp.Lang.F.term * Wp.Lang.F.pred
val tau_of_set : Wp.Lang.F.tau -> Wp.Lang.F.tau
val vars : Wp.Vset.set -> Wp.Lang.F.Vars.t
val occurs : Wp.Lang.F.var -> Wp.Vset.set -> bool
val empty : Wp.Vset.set
val singleton : Wp.Lang.F.term -> Wp.Vset.set
val range :
Wp.Lang.F.term option -> Wp.Lang.F.term option -> Wp.Vset.set
val union : Wp.Vset.set -> Wp.Vset.set -> Wp.Vset.set
val inter : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
val member : Wp.Lang.F.term -> Wp.Vset.set -> Wp.Lang.F.pred
val in_size : Wp.Lang.F.term -> int -> Wp.Lang.F.pred
val in_range :
Wp.Lang.F.term ->
Wp.Lang.F.term option -> Wp.Lang.F.term option -> Wp.Lang.F.pred
val sub_range :
Wp.Lang.F.term ->
Wp.Lang.F.term ->
Wp.Lang.F.term option -> Wp.Lang.F.term option -> Wp.Lang.F.pred
val ordered :
limit:bool ->
strict:bool ->
Wp.Lang.F.term option -> Wp.Lang.F.term option -> Wp.Lang.F.pred
val is_empty : Wp.Vset.set -> Wp.Lang.F.pred
val equal : Wp.Vset.set -> Wp.Vset.set -> Wp.Lang.F.pred
val subset : Wp.Vset.set -> Wp.Vset.set -> Wp.Lang.F.pred
val disjoint : Wp.Vset.set -> Wp.Vset.set -> Wp.Lang.F.pred
val concretize : Wp.Vset.set -> Wp.Lang.F.term
val bound_shift :
Wp.Lang.F.term option -> Wp.Lang.F.term -> Wp.Lang.F.term option
val bound_add :
Wp.Lang.F.term option ->
Wp.Lang.F.term option -> Wp.Lang.F.term option
val bound_sub :
Wp.Lang.F.term option ->
Wp.Lang.F.term option -> Wp.Lang.F.term option
val pp_bound : Stdlib.Format.formatter -> Wp.Lang.F.term option -> unit
val pp_vset : Stdlib.Format.formatter -> Wp.Vset.vset -> unit
val pretty : Stdlib.Format.formatter -> Wp.Vset.set -> unit
val map :
(Wp.Lang.F.term -> Wp.Lang.F.term) -> Wp.Vset.set -> Wp.Vset.set
val map_opp : Wp.Vset.set -> Wp.Vset.set
val lift :
(Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term) ->
Wp.Vset.set -> Wp.Vset.set -> Wp.Vset.set
val lift_add : Wp.Vset.set -> Wp.Vset.set -> Wp.Vset.set
val lift_sub : Wp.Vset.set -> Wp.Vset.set -> Wp.Vset.set
val descr :
Wp.Vset.vset -> Wp.Lang.F.var list * Wp.Lang.F.term * Wp.Lang.F.pred
end
module Cstring :
sig
type cst = C_str of string | W_str of int64 list
val pretty : Stdlib.Format.formatter -> Wp.Cstring.cst -> unit
val str_len : Wp.Cstring.cst -> Wp.Lang.F.term -> Wp.Lang.F.pred
val str_val : Wp.Cstring.cst -> Wp.Lang.F.term
val str_id : Wp.Cstring.cst -> int
val char_at : Wp.Cstring.cst -> Wp.Lang.F.term -> Wp.Lang.F.term
val cluster : unit -> Wp.Definitions.cluster
end
module Sigs :
sig
type 'a sequence = { pre : 'a; post : 'a; }
type 'a binder = { bind : 'b 'c. 'a -> ('b -> 'c) -> 'b -> 'c; }
type equation =
Set of Wp.Lang.F.term * Wp.Lang.F.term
| Assert of Wp.Lang.F.pred
type acs = RW | RD | OBJ
type 'a value = Val of Wp.Lang.F.term | Loc of 'a
type 'a rloc =
Rloc of Wp.Ctypes.c_object * 'a
| Rrange of 'a * Wp.Ctypes.c_object * Wp.Lang.F.term option *
Wp.Lang.F.term option
type 'a sloc =
Sloc of 'a
| Sarray of 'a * Wp.Ctypes.c_object * int
| Srange of 'a * Wp.Ctypes.c_object * Wp.Lang.F.term option *
Wp.Lang.F.term option
| Sdescr of Wp.Lang.F.var list * 'a * Wp.Lang.F.pred
type 'a region = (Wp.Ctypes.c_object * 'a Wp.Sigs.sloc) list
type 'a logic =
Vexp of Wp.Lang.F.term
| Vloc of 'a
| Vset of Wp.Vset.set
| Lset of 'a Wp.Sigs.sloc list
type scope = Enter | Leave
type 'a result = R_loc of 'a | R_var of Wp.Lang.F.var
type polarity = [ `Negative | `NoPolarity | `Positive ]
type frame =
string * Wp.Definitions.trigger list * Wp.Lang.F.pred list *
Wp.Lang.F.term * Wp.Lang.F.term
type s_lval = Wp.Sigs.s_host * Wp.Sigs.s_offset list
and s_host =
Mvar of Cil_types.varinfo
| Mmem of Wp.Lang.F.term
| Mval of Wp.Sigs.s_lval
and s_offset = Mfield of Cil_types.fieldinfo | Mindex of Wp.Lang.F.term
type mval =
Mterm
| Maddr of Wp.Sigs.s_lval
| Mlval of Wp.Sigs.s_lval * Wp.Lang.datakind
| Mchunk of string * Wp.Lang.datakind
type update = Mstore of Wp.Sigs.s_lval * Wp.Lang.F.term
module type Chunk =
sig
type t
val self : string
val hash : Wp.Sigs.Chunk.t -> int
val equal : Wp.Sigs.Chunk.t -> Wp.Sigs.Chunk.t -> bool
val compare : Wp.Sigs.Chunk.t -> Wp.Sigs.Chunk.t -> int
val pretty : Stdlib.Format.formatter -> Wp.Sigs.Chunk.t -> unit
val tau_of_chunk : Wp.Sigs.Chunk.t -> Wp.Lang.F.tau
val basename_of_chunk : Wp.Sigs.Chunk.t -> string
val is_framed : Wp.Sigs.Chunk.t -> bool
end
module type Sigma =
sig
type chunk
module Chunk :
sig
type t = chunk
type set
type 'a map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted : (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Wp.Sigs.Sigma.Chunk.Set.t
type t
val pretty : Stdlib.Format.formatter -> Wp.Sigs.Sigma.t -> unit
val create : unit -> Wp.Sigs.Sigma.t
val mem : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.chunk -> bool
val get : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.chunk -> Wp.Lang.F.var
val value :
Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.chunk -> Wp.Lang.F.term
val copy : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t
val join : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t -> Wp.Passive.t
val assigned :
pre:Wp.Sigs.Sigma.t ->
post:Wp.Sigs.Sigma.t ->
Wp.Sigs.Sigma.domain -> Wp.Lang.F.pred Bag.t
val choose : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t
val merge :
Wp.Sigs.Sigma.t ->
Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t * Wp.Passive.t * Wp.Passive.t
val merge_list :
Wp.Sigs.Sigma.t list -> Wp.Sigs.Sigma.t * Wp.Passive.t list
val iter :
(Wp.Sigs.Sigma.chunk -> Wp.Lang.F.var -> unit) ->
Wp.Sigs.Sigma.t -> unit
val iter2 :
(Wp.Sigs.Sigma.chunk ->
Wp.Lang.F.var option -> Wp.Lang.F.var option -> unit) ->
Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t -> unit
val havoc_chunk :
Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.chunk -> Wp.Sigs.Sigma.t
val havoc :
Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.domain -> Wp.Sigs.Sigma.t
val havoc_any : call:bool -> Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t
val remove_chunks :
Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.domain -> Wp.Sigs.Sigma.t
val domain : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.domain
val union :
Wp.Sigs.Sigma.domain ->
Wp.Sigs.Sigma.domain -> Wp.Sigs.Sigma.domain
val empty : Wp.Sigs.Sigma.domain
val writes :
Wp.Sigs.Sigma.t Wp.Sigs.sequence -> Wp.Sigs.Sigma.domain
end
module type Model =
sig
val configure : unit -> Wp.WpContext.rollback
val configure_ia :
Interpreted_automata.automaton ->
Interpreted_automata.vertex Wp.Sigs.binder
val datatype : string
val hypotheses :
Wp.MemoryContext.partition -> Wp.MemoryContext.partition
module Chunk : Chunk
module Heap :
sig
type t = Chunk.t
type set
type 'a map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted : (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
module Sigma :
sig
type chunk = Chunk.t
module Chunk :
sig
type t = Chunk.t
type set = Heap.set
type 'a map = 'a Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted : (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned : pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk -> Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t sequence -> domain
end
type loc
type chunk = Wp.Sigs.Chunk.t
type sigma = Wp.Sigs.Model.Sigma.t
type domain = Wp.Sigs.Model.Sigma.domain
type segment = Wp.Sigs.Model.loc Wp.Sigs.rloc
type state
val state : Wp.Sigs.Model.sigma -> Wp.Sigs.Model.state
val lookup : Wp.Sigs.Model.state -> Wp.Lang.F.term -> Wp.Sigs.mval
val updates :
Wp.Sigs.Model.state Wp.Sigs.sequence ->
Wp.Lang.F.Vars.t -> Wp.Sigs.update Bag.t
val apply :
(Wp.Lang.F.term -> Wp.Lang.F.term) ->
Wp.Sigs.Model.state -> Wp.Sigs.Model.state
val iter :
(Wp.Sigs.mval -> Wp.Lang.F.term -> unit) ->
Wp.Sigs.Model.state -> unit
val pretty : Stdlib.Format.formatter -> Wp.Sigs.Model.loc -> unit
val vars : Wp.Sigs.Model.loc -> Wp.Lang.F.Vars.t
val occurs : Wp.Lang.F.var -> Wp.Sigs.Model.loc -> bool
val null : Wp.Sigs.Model.loc
val literal : eid:int -> Wp.Cstring.cst -> Wp.Sigs.Model.loc
val cvar : Cil_types.varinfo -> Wp.Sigs.Model.loc
val pointer_loc : Wp.Lang.F.term -> Wp.Sigs.Model.loc
val pointer_val : Wp.Sigs.Model.loc -> Wp.Lang.F.term
val field :
Wp.Sigs.Model.loc -> Cil_types.fieldinfo -> Wp.Sigs.Model.loc
val shift :
Wp.Sigs.Model.loc ->
Wp.Ctypes.c_object -> Wp.Lang.F.term -> Wp.Sigs.Model.loc
val base_addr : Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc
val base_offset : Wp.Sigs.Model.loc -> Wp.Lang.F.term
val block_length :
Wp.Sigs.Model.sigma ->
Wp.Ctypes.c_object -> Wp.Sigs.Model.loc -> Wp.Lang.F.term
val cast :
Wp.Ctypes.c_object Wp.Sigs.sequence ->
Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc
val loc_of_int :
Wp.Ctypes.c_object -> Wp.Lang.F.term -> Wp.Sigs.Model.loc
val int_of_loc :
Wp.Ctypes.c_int -> Wp.Sigs.Model.loc -> Wp.Lang.F.term
val domain :
Wp.Ctypes.c_object -> Wp.Sigs.Model.loc -> Wp.Sigs.Model.domain
val is_well_formed : Wp.Sigs.Model.sigma -> Wp.Lang.F.pred
val load :
Wp.Sigs.Model.sigma ->
Wp.Ctypes.c_object ->
Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc Wp.Sigs.value
val load_init :
Wp.Sigs.Model.sigma ->
Wp.Ctypes.c_object -> Wp.Sigs.Model.loc -> Wp.Lang.F.term
val copied :
Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
Wp.Ctypes.c_object ->
Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Sigs.equation list
val copied_init :
Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
Wp.Ctypes.c_object ->
Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Sigs.equation list
val stored :
Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
Wp.Ctypes.c_object ->
Wp.Sigs.Model.loc -> Wp.Lang.F.term -> Wp.Sigs.equation list
val stored_init :
Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
Wp.Ctypes.c_object ->
Wp.Sigs.Model.loc -> Wp.Lang.F.term -> Wp.Sigs.equation list
val assigned :
Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
Wp.Ctypes.c_object ->
Wp.Sigs.Model.loc Wp.Sigs.sloc -> Wp.Sigs.equation list
val is_null : Wp.Sigs.Model.loc -> Wp.Lang.F.pred
val loc_eq :
Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Lang.F.pred
val loc_lt :
Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Lang.F.pred
val loc_neq :
Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Lang.F.pred
val loc_leq :
Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Lang.F.pred
val loc_diff :
Wp.Ctypes.c_object ->
Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Lang.F.term
val valid :
Wp.Sigs.Model.sigma ->
Wp.Sigs.acs -> Wp.Sigs.Model.segment -> Wp.Lang.F.pred
val frame : Wp.Sigs.Model.sigma -> Wp.Lang.F.pred list
val alloc :
Wp.Sigs.Model.sigma ->
Cil_types.varinfo list -> Wp.Sigs.Model.sigma
val initialized :
Wp.Sigs.Model.sigma -> Wp.Sigs.Model.segment -> Wp.Lang.F.pred
val invalid :
Wp.Sigs.Model.sigma -> Wp.Sigs.Model.segment -> Wp.Lang.F.pred
val scope :
Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
Wp.Sigs.scope -> Cil_types.varinfo list -> Wp.Lang.F.pred list
val global :
Wp.Sigs.Model.sigma -> Wp.Lang.F.term -> Wp.Lang.F.pred
val included :
Wp.Sigs.Model.segment -> Wp.Sigs.Model.segment -> Wp.Lang.F.pred
val separated :
Wp.Sigs.Model.segment -> Wp.Sigs.Model.segment -> Wp.Lang.F.pred
end
module type CodeSemantics =
sig
module M : Model
type loc = M.loc
type nonrec value = Wp.Sigs.CodeSemantics.loc Wp.Sigs.value
type nonrec result = Wp.Sigs.CodeSemantics.loc Wp.Sigs.result
type sigma = M.Sigma.t
val pp_value :
Stdlib.Format.formatter -> Wp.Sigs.CodeSemantics.value -> unit
val cval : Wp.Sigs.CodeSemantics.value -> Wp.Lang.F.term
val cloc : Wp.Sigs.CodeSemantics.value -> Wp.Sigs.CodeSemantics.loc
val cast :
Cil_types.typ ->
Cil_types.typ ->
Wp.Sigs.CodeSemantics.value -> Wp.Sigs.CodeSemantics.value
val equal_typ :
Cil_types.typ ->
Wp.Sigs.CodeSemantics.value ->
Wp.Sigs.CodeSemantics.value -> Wp.Lang.F.pred
val not_equal_typ :
Cil_types.typ ->
Wp.Sigs.CodeSemantics.value ->
Wp.Sigs.CodeSemantics.value -> Wp.Lang.F.pred
val equal_obj :
Wp.Ctypes.c_object ->
Wp.Sigs.CodeSemantics.value ->
Wp.Sigs.CodeSemantics.value -> Wp.Lang.F.pred
val not_equal_obj :
Wp.Ctypes.c_object ->
Wp.Sigs.CodeSemantics.value ->
Wp.Sigs.CodeSemantics.value -> Wp.Lang.F.pred
val exp :
Wp.Sigs.CodeSemantics.sigma ->
Cil_types.exp -> Wp.Sigs.CodeSemantics.value
val cond :
Wp.Sigs.CodeSemantics.sigma -> Cil_types.exp -> Wp.Lang.F.pred
val lval :
Wp.Sigs.CodeSemantics.sigma ->
Cil_types.lval -> Wp.Sigs.CodeSemantics.loc
val call :
Wp.Sigs.CodeSemantics.sigma ->
Cil_types.exp -> Wp.Sigs.CodeSemantics.loc
val instance_of :
Wp.Sigs.CodeSemantics.loc ->
Cil_types.kernel_function -> Wp.Lang.F.pred
val loc_of_exp :
Wp.Sigs.CodeSemantics.sigma ->
Cil_types.exp -> Wp.Sigs.CodeSemantics.loc
val val_of_exp :
Wp.Sigs.CodeSemantics.sigma -> Cil_types.exp -> Wp.Lang.F.term
val result :
Wp.Sigs.CodeSemantics.sigma ->
Cil_types.typ -> Wp.Sigs.CodeSemantics.result -> Wp.Lang.F.term
val return :
Wp.Sigs.CodeSemantics.sigma ->
Cil_types.typ -> Cil_types.exp -> Wp.Lang.F.term
val is_zero :
Wp.Sigs.CodeSemantics.sigma ->
Wp.Ctypes.c_object -> Wp.Sigs.CodeSemantics.loc -> Wp.Lang.F.pred
val is_exp_range :
Wp.Sigs.CodeSemantics.sigma ->
Wp.Sigs.CodeSemantics.loc ->
Wp.Ctypes.c_object ->
Wp.Lang.F.term ->
Wp.Lang.F.term ->
Wp.Sigs.CodeSemantics.value option -> Wp.Lang.F.pred
val unchanged :
M.sigma -> M.sigma -> Cil_types.varinfo -> Wp.Lang.F.pred
type warned_hyp =
Wp.Warning.Set.t * (Wp.Lang.F.pred * Wp.Lang.F.pred)
val init :
sigma:M.sigma ->
Cil_types.varinfo ->
Cil_types.init option -> Wp.Sigs.CodeSemantics.warned_hyp list
end
module type LogicSemantics =
sig
module M : Model
type loc = M.loc
type nonrec value = M.loc Wp.Sigs.value
type nonrec logic = M.loc Wp.Sigs.logic
type nonrec region = M.loc Wp.Sigs.region
type nonrec result = M.loc Wp.Sigs.result
type sigma = M.Sigma.t
type frame
val pp_frame :
Stdlib.Format.formatter -> Wp.Sigs.LogicSemantics.frame -> unit
val get_frame : unit -> Wp.Sigs.LogicSemantics.frame
val in_frame :
Wp.Sigs.LogicSemantics.frame -> ('a -> 'b) -> 'a -> 'b
val mem_at_frame :
Wp.Sigs.LogicSemantics.frame ->
Wp.Clabels.c_label -> Wp.Sigs.LogicSemantics.sigma
val set_at_frame :
Wp.Sigs.LogicSemantics.frame ->
Wp.Clabels.c_label -> Wp.Sigs.LogicSemantics.sigma -> unit
val has_at_frame :
Wp.Sigs.LogicSemantics.frame -> Wp.Clabels.c_label -> bool
val mem_frame : Wp.Clabels.c_label -> Wp.Sigs.LogicSemantics.sigma
val mk_frame :
?kf:Cil_types.kernel_function ->
?result:Wp.Sigs.LogicSemantics.result ->
?status:Wp.Lang.F.var ->
?formals:Wp.Sigs.LogicSemantics.value Cil_datatype.Varinfo.Map.t ->
?labels:Wp.Sigs.LogicSemantics.sigma Wp.Clabels.LabelMap.t ->
?descr:string -> unit -> Wp.Sigs.LogicSemantics.frame
val local : descr:string -> Wp.Sigs.LogicSemantics.frame
val frame :
Cil_types.kernel_function -> Wp.Sigs.LogicSemantics.frame
type call
val call :
?result:M.loc ->
Cil_types.kernel_function ->
Wp.Sigs.LogicSemantics.value list -> Wp.Sigs.LogicSemantics.call
val call_pre :
Wp.Sigs.LogicSemantics.sigma ->
Wp.Sigs.LogicSemantics.call ->
Wp.Sigs.LogicSemantics.sigma -> Wp.Sigs.LogicSemantics.frame
val call_post :
Wp.Sigs.LogicSemantics.sigma ->
Wp.Sigs.LogicSemantics.call ->
Wp.Sigs.LogicSemantics.sigma Wp.Sigs.sequence ->
Wp.Sigs.LogicSemantics.frame
val return : unit -> Cil_types.typ
val result : unit -> Wp.Sigs.LogicSemantics.result
val status : unit -> Wp.Lang.F.var
val guards : Wp.Sigs.LogicSemantics.frame -> Wp.Lang.F.pred list
type env
val mk_env :
?here:Wp.Sigs.LogicSemantics.sigma ->
?lvars:Cil_types.logic_var list ->
unit -> Wp.Sigs.LogicSemantics.env
val current :
Wp.Sigs.LogicSemantics.env -> Wp.Sigs.LogicSemantics.sigma
val move_at :
Wp.Sigs.LogicSemantics.env ->
Wp.Sigs.LogicSemantics.sigma -> Wp.Sigs.LogicSemantics.env
val mem_at :
Wp.Sigs.LogicSemantics.env ->
Wp.Clabels.c_label -> Wp.Sigs.LogicSemantics.sigma
val env_at :
Wp.Sigs.LogicSemantics.env ->
Wp.Clabels.c_label -> Wp.Sigs.LogicSemantics.env
val lval :
Wp.Sigs.LogicSemantics.env ->
Cil_types.term_lval -> Cil_types.typ * M.loc
val term :
Wp.Sigs.LogicSemantics.env -> Cil_types.term -> Wp.Lang.F.term
val pred :
Wp.Sigs.polarity ->
Wp.Sigs.LogicSemantics.env ->
Cil_types.predicate -> Wp.Lang.F.pred
val call_pred :
Wp.Sigs.LogicSemantics.env ->
Cil_types.logic_info ->
Cil_types.logic_label list ->
Wp.Lang.F.term list -> Wp.Lang.F.pred
val region :
Wp.Sigs.LogicSemantics.env ->
Cil_types.term -> Wp.Sigs.LogicSemantics.region
val assigned_of_lval :
Wp.Sigs.LogicSemantics.env ->
Cil_types.lval -> Wp.Sigs.LogicSemantics.region
val assigned_of_froms :
Wp.Sigs.LogicSemantics.env ->
Cil_types.from list -> Wp.Sigs.LogicSemantics.region
val assigned_of_assigns :
Wp.Sigs.LogicSemantics.env ->
Cil_types.assigns -> Wp.Sigs.LogicSemantics.region option
val val_of_term :
Wp.Sigs.LogicSemantics.env -> Cil_types.term -> Wp.Lang.F.term
val loc_of_term :
Wp.Sigs.LogicSemantics.env ->
Cil_types.term -> Wp.Sigs.LogicSemantics.loc
val lemma : Wp.LogicUsage.logic_lemma -> Wp.Definitions.dlemma
val vars : Wp.Sigs.LogicSemantics.region -> Wp.Lang.F.Vars.t
val occurs : Wp.Lang.F.var -> Wp.Sigs.LogicSemantics.region -> bool
val check_assigns :
unfold:int ->
Wp.Sigs.LogicSemantics.sigma ->
written:Wp.Sigs.LogicSemantics.region ->
assignable:Wp.Sigs.LogicSemantics.region -> Wp.Lang.F.pred
end
module type LogicAssigns =
sig
module M : Model
module L :
sig
module M :
sig
val configure : unit -> WpContext.rollback
val configure_ia :
Interpreted_automata.automaton ->
Interpreted_automata.vertex binder
val datatype : string
val hypotheses :
MemoryContext.partition -> MemoryContext.partition
module Chunk :
sig
type t = M.Chunk.t
val self : string
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val tau_of_chunk : t -> Lang.F.tau
val basename_of_chunk : t -> string
val is_framed : t -> bool
end
module Heap :
sig
type t = Chunk.t
type set = M.Heap.set
type 'a map = 'a M.Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
module Sigma :
sig
type chunk = Chunk.t
module Chunk :
sig
type t = Chunk.t
type set = Heap.set
type 'a map = 'a Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf :
(key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq :
(key -> 'a -> 'a option) -> 'a t -> 'a t
val filter :
(key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) ->
'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) ->
'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) ->
'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) ->
'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t = M.Sigma.t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned :
pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk ->
Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t sequence -> domain
end
type loc = M.loc
type chunk = Chunk.t
type sigma = Sigma.t
type domain = Sigma.domain
type segment = loc rloc
type state = M.state
val state : sigma -> state
val lookup : state -> Lang.F.term -> mval
val updates :
state sequence -> Lang.F.Vars.t -> update Bag.t
val apply : (Lang.F.term -> Lang.F.term) -> state -> state
val iter : (mval -> Lang.F.term -> unit) -> state -> unit
val pretty : Format.formatter -> loc -> unit
val vars : loc -> Lang.F.Vars.t
val occurs : Lang.F.var -> loc -> bool
val null : loc
val literal : eid:int -> Cstring.cst -> loc
val cvar : Cil_types.varinfo -> loc
val pointer_loc : Lang.F.term -> loc
val pointer_val : loc -> Lang.F.term
val field : loc -> Cil_types.fieldinfo -> loc
val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
val base_addr : loc -> loc
val base_offset : loc -> Lang.F.term
val block_length :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val cast : Ctypes.c_object sequence -> loc -> loc
val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
val domain : Ctypes.c_object -> loc -> domain
val is_well_formed : sigma -> Lang.F.pred
val load : sigma -> Ctypes.c_object -> loc -> loc value
val load_init :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val copied :
sigma sequence ->
Ctypes.c_object -> loc -> loc -> equation list
val copied_init :
sigma sequence ->
Ctypes.c_object -> loc -> loc -> equation list
val stored :
sigma sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> equation list
val stored_init :
sigma sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> equation list
val assigned :
sigma sequence ->
Ctypes.c_object -> loc sloc -> equation list
val is_null : loc -> Lang.F.pred
val loc_eq : loc -> loc -> Lang.F.pred
val loc_lt : loc -> loc -> Lang.F.pred
val loc_neq : loc -> loc -> Lang.F.pred
val loc_leq : loc -> loc -> Lang.F.pred
val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
val valid : sigma -> acs -> segment -> Lang.F.pred
val frame : sigma -> Lang.F.pred list
val alloc : sigma -> Cil_types.varinfo list -> sigma
val initialized : sigma -> segment -> Lang.F.pred
val invalid : sigma -> segment -> Lang.F.pred
val scope :
sigma sequence ->
scope -> Cil_types.varinfo list -> Lang.F.pred list
val global : sigma -> Lang.F.term -> Lang.F.pred
val included : segment -> segment -> Lang.F.pred
val separated : segment -> segment -> Lang.F.pred
end
type loc = M.loc
type nonrec value = M.loc value
type nonrec logic = M.loc logic
type nonrec region = M.loc region
type nonrec result = M.loc result
type sigma = M.Sigma.t
type frame
val pp_frame : Format.formatter -> frame -> unit
val get_frame : unit -> frame
val in_frame : frame -> ('a -> 'b) -> 'a -> 'b
val mem_at_frame : frame -> Clabels.c_label -> sigma
val set_at_frame : frame -> Clabels.c_label -> sigma -> unit
val has_at_frame : frame -> Clabels.c_label -> bool
val mem_frame : Clabels.c_label -> sigma
val mk_frame :
?kf:Cil_types.kernel_function ->
?result:result ->
?status:Lang.F.var ->
?formals:value Cil_datatype.Varinfo.Map.t ->
?labels:sigma Clabels.LabelMap.t ->
?descr:string -> unit -> frame
val local : descr:string -> frame
val frame : Cil_types.kernel_function -> frame
type call
val call :
?result:M.loc ->
Cil_types.kernel_function -> value list -> call
val call_pre : sigma -> call -> sigma -> frame
val call_post : sigma -> call -> sigma sequence -> frame
val return : unit -> Cil_types.typ
val result : unit -> result
val status : unit -> Lang.F.var
val guards : frame -> Lang.F.pred list
type env
val mk_env :
?here:sigma -> ?lvars:Cil_types.logic_var list -> unit -> env
val current : env -> sigma
val move_at : env -> sigma -> env
val mem_at : env -> Clabels.c_label -> sigma
val env_at : env -> Clabels.c_label -> env
val lval : env -> Cil_types.term_lval -> Cil_types.typ * M.loc
val term : env -> Cil_types.term -> Lang.F.term
val pred :
polarity -> env -> Cil_types.predicate -> Lang.F.pred
val call_pred :
env ->
Cil_types.logic_info ->
Cil_types.logic_label list -> Lang.F.term list -> Lang.F.pred
val region : env -> Cil_types.term -> region
val assigned_of_lval : env -> Cil_types.lval -> region
val assigned_of_froms : env -> Cil_types.from list -> region
val assigned_of_assigns :
env -> Cil_types.assigns -> region option
val val_of_term : env -> Cil_types.term -> Lang.F.term
val loc_of_term : env -> Cil_types.term -> loc
val lemma : LogicUsage.logic_lemma -> Definitions.dlemma
val vars : region -> Lang.F.Vars.t
val occurs : Lang.F.var -> region -> bool
val check_assigns :
unfold:int ->
sigma -> written:region -> assignable:region -> Lang.F.pred
end
val domain : M.loc Wp.Sigs.region -> M.Heap.set
val apply_assigns :
M.sigma Wp.Sigs.sequence ->
M.loc Wp.Sigs.region -> Wp.Lang.F.pred list
end
module type Compiler =
sig
module M : Model
module C :
sig
module M :
sig
val configure : unit -> WpContext.rollback
val configure_ia :
Interpreted_automata.automaton ->
Interpreted_automata.vertex binder
val datatype : string
val hypotheses :
MemoryContext.partition -> MemoryContext.partition
module Chunk :
sig
type t = M.Chunk.t
val self : string
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val tau_of_chunk : t -> Lang.F.tau
val basename_of_chunk : t -> string
val is_framed : t -> bool
end
module Heap :
sig
type t = Chunk.t
type set = M.Heap.set
type 'a map = 'a M.Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
module Sigma :
sig
type chunk = Chunk.t
module Chunk :
sig
type t = Chunk.t
type set = Heap.set
type 'a map = 'a Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf :
(key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq :
(key -> 'a -> 'a option) -> 'a t -> 'a t
val filter :
(key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) ->
'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) ->
'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) ->
'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) ->
'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t = M.Sigma.t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned :
pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk ->
Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t sequence -> domain
end
type loc = M.loc
type chunk = Chunk.t
type sigma = Sigma.t
type domain = Sigma.domain
type segment = loc rloc
type state = M.state
val state : sigma -> state
val lookup : state -> Lang.F.term -> mval
val updates :
state sequence -> Lang.F.Vars.t -> update Bag.t
val apply : (Lang.F.term -> Lang.F.term) -> state -> state
val iter : (mval -> Lang.F.term -> unit) -> state -> unit
val pretty : Format.formatter -> loc -> unit
val vars : loc -> Lang.F.Vars.t
val occurs : Lang.F.var -> loc -> bool
val null : loc
val literal : eid:int -> Cstring.cst -> loc
val cvar : Cil_types.varinfo -> loc
val pointer_loc : Lang.F.term -> loc
val pointer_val : loc -> Lang.F.term
val field : loc -> Cil_types.fieldinfo -> loc
val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
val base_addr : loc -> loc
val base_offset : loc -> Lang.F.term
val block_length :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val cast : Ctypes.c_object sequence -> loc -> loc
val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
val domain : Ctypes.c_object -> loc -> domain
val is_well_formed : sigma -> Lang.F.pred
val load : sigma -> Ctypes.c_object -> loc -> loc value
val load_init :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val copied :
sigma sequence ->
Ctypes.c_object -> loc -> loc -> equation list
val copied_init :
sigma sequence ->
Ctypes.c_object -> loc -> loc -> equation list
val stored :
sigma sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> equation list
val stored_init :
sigma sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> equation list
val assigned :
sigma sequence ->
Ctypes.c_object -> loc sloc -> equation list
val is_null : loc -> Lang.F.pred
val loc_eq : loc -> loc -> Lang.F.pred
val loc_lt : loc -> loc -> Lang.F.pred
val loc_neq : loc -> loc -> Lang.F.pred
val loc_leq : loc -> loc -> Lang.F.pred
val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
val valid : sigma -> acs -> segment -> Lang.F.pred
val frame : sigma -> Lang.F.pred list
val alloc : sigma -> Cil_types.varinfo list -> sigma
val initialized : sigma -> segment -> Lang.F.pred
val invalid : sigma -> segment -> Lang.F.pred
val scope :
sigma sequence ->
scope -> Cil_types.varinfo list -> Lang.F.pred list
val global : sigma -> Lang.F.term -> Lang.F.pred
val included : segment -> segment -> Lang.F.pred
val separated : segment -> segment -> Lang.F.pred
end
type loc = M.loc
type nonrec value = loc value
type nonrec result = loc result
type sigma = M.Sigma.t
val pp_value : Format.formatter -> value -> unit
val cval : value -> Lang.F.term
val cloc : value -> loc
val cast : Cil_types.typ -> Cil_types.typ -> value -> value
val equal_typ : Cil_types.typ -> value -> value -> Lang.F.pred
val not_equal_typ :
Cil_types.typ -> value -> value -> Lang.F.pred
val equal_obj :
Ctypes.c_object -> value -> value -> Lang.F.pred
val not_equal_obj :
Ctypes.c_object -> value -> value -> Lang.F.pred
val exp : sigma -> Cil_types.exp -> value
val cond : sigma -> Cil_types.exp -> Lang.F.pred
val lval : sigma -> Cil_types.lval -> loc
val call : sigma -> Cil_types.exp -> loc
val instance_of :
loc -> Cil_types.kernel_function -> Lang.F.pred
val loc_of_exp : sigma -> Cil_types.exp -> loc
val val_of_exp : sigma -> Cil_types.exp -> Lang.F.term
val result : sigma -> Cil_types.typ -> result -> Lang.F.term
val return :
sigma -> Cil_types.typ -> Cil_types.exp -> Lang.F.term
val is_zero : sigma -> Ctypes.c_object -> loc -> Lang.F.pred
val is_exp_range :
sigma ->
loc ->
Ctypes.c_object ->
Lang.F.term -> Lang.F.term -> value option -> Lang.F.pred
val unchanged :
M.sigma -> M.sigma -> Cil_types.varinfo -> Lang.F.pred
type warned_hyp = Warning.Set.t * (Lang.F.pred * Lang.F.pred)
val init :
sigma:M.sigma ->
Cil_types.varinfo -> Cil_types.init option -> warned_hyp list
end
module L :
sig
module M :
sig
val configure : unit -> WpContext.rollback
val configure_ia :
Interpreted_automata.automaton ->
Interpreted_automata.vertex binder
val datatype : string
val hypotheses :
MemoryContext.partition -> MemoryContext.partition
module Chunk :
sig
type t = M.Chunk.t
val self : string
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val tau_of_chunk : t -> Lang.F.tau
val basename_of_chunk : t -> string
val is_framed : t -> bool
end
module Heap :
sig
type t = Chunk.t
type set = M.Heap.set
type 'a map = 'a M.Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
module Sigma :
sig
type chunk = Chunk.t
module Chunk :
sig
type t = Chunk.t
type set = Heap.set
type 'a map = 'a Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf :
(key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq :
(key -> 'a -> 'a option) -> 'a t -> 'a t
val filter :
(key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) ->
'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) ->
'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) ->
'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) ->
'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t = M.Sigma.t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned :
pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk ->
Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t sequence -> domain
end
type loc = M.loc
type chunk = Chunk.t
type sigma = Sigma.t
type domain = Sigma.domain
type segment = loc rloc
type state = M.state
val state : sigma -> state
val lookup : state -> Lang.F.term -> mval
val updates :
state sequence -> Lang.F.Vars.t -> update Bag.t
val apply : (Lang.F.term -> Lang.F.term) -> state -> state
val iter : (mval -> Lang.F.term -> unit) -> state -> unit
val pretty : Format.formatter -> loc -> unit
val vars : loc -> Lang.F.Vars.t
val occurs : Lang.F.var -> loc -> bool
val null : loc
val literal : eid:int -> Cstring.cst -> loc
val cvar : Cil_types.varinfo -> loc
val pointer_loc : Lang.F.term -> loc
val pointer_val : loc -> Lang.F.term
val field : loc -> Cil_types.fieldinfo -> loc
val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
val base_addr : loc -> loc
val base_offset : loc -> Lang.F.term
val block_length :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val cast : Ctypes.c_object sequence -> loc -> loc
val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
val domain : Ctypes.c_object -> loc -> domain
val is_well_formed : sigma -> Lang.F.pred
val load : sigma -> Ctypes.c_object -> loc -> loc value
val load_init :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val copied :
sigma sequence ->
Ctypes.c_object -> loc -> loc -> equation list
val copied_init :
sigma sequence ->
Ctypes.c_object -> loc -> loc -> equation list
val stored :
sigma sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> equation list
val stored_init :
sigma sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> equation list
val assigned :
sigma sequence ->
Ctypes.c_object -> loc sloc -> equation list
val is_null : loc -> Lang.F.pred
val loc_eq : loc -> loc -> Lang.F.pred
val loc_lt : loc -> loc -> Lang.F.pred
val loc_neq : loc -> loc -> Lang.F.pred
val loc_leq : loc -> loc -> Lang.F.pred
val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
val valid : sigma -> acs -> segment -> Lang.F.pred
val frame : sigma -> Lang.F.pred list
val alloc : sigma -> Cil_types.varinfo list -> sigma
val initialized : sigma -> segment -> Lang.F.pred
val invalid : sigma -> segment -> Lang.F.pred
val scope :
sigma sequence ->
scope -> Cil_types.varinfo list -> Lang.F.pred list
val global : sigma -> Lang.F.term -> Lang.F.pred
val included : segment -> segment -> Lang.F.pred
val separated : segment -> segment -> Lang.F.pred
end
type loc = M.loc
type nonrec value = M.loc value
type nonrec logic = M.loc logic
type nonrec region = M.loc region
type nonrec result = M.loc result
type sigma = M.Sigma.t
type frame
val pp_frame : Format.formatter -> frame -> unit
val get_frame : unit -> frame
val in_frame : frame -> ('a -> 'b) -> 'a -> 'b
val mem_at_frame : frame -> Clabels.c_label -> sigma
val set_at_frame : frame -> Clabels.c_label -> sigma -> unit
val has_at_frame : frame -> Clabels.c_label -> bool
val mem_frame : Clabels.c_label -> sigma
val mk_frame :
?kf:Cil_types.kernel_function ->
?result:result ->
?status:Lang.F.var ->
?formals:value Cil_datatype.Varinfo.Map.t ->
?labels:sigma Clabels.LabelMap.t ->
?descr:string -> unit -> frame
val local : descr:string -> frame
val frame : Cil_types.kernel_function -> frame
type call
val call :
?result:M.loc ->
Cil_types.kernel_function -> value list -> call
val call_pre : sigma -> call -> sigma -> frame
val call_post : sigma -> call -> sigma sequence -> frame
val return : unit -> Cil_types.typ
val result : unit -> result
val status : unit -> Lang.F.var
val guards : frame -> Lang.F.pred list
type env
val mk_env :
?here:sigma -> ?lvars:Cil_types.logic_var list -> unit -> env
val current : env -> sigma
val move_at : env -> sigma -> env
val mem_at : env -> Clabels.c_label -> sigma
val env_at : env -> Clabels.c_label -> env
val lval : env -> Cil_types.term_lval -> Cil_types.typ * M.loc
val term : env -> Cil_types.term -> Lang.F.term
val pred :
polarity -> env -> Cil_types.predicate -> Lang.F.pred
val call_pred :
env ->
Cil_types.logic_info ->
Cil_types.logic_label list -> Lang.F.term list -> Lang.F.pred
val region : env -> Cil_types.term -> region
val assigned_of_lval : env -> Cil_types.lval -> region
val assigned_of_froms : env -> Cil_types.from list -> region
val assigned_of_assigns :
env -> Cil_types.assigns -> region option
val val_of_term : env -> Cil_types.term -> Lang.F.term
val loc_of_term : env -> Cil_types.term -> loc
val lemma : LogicUsage.logic_lemma -> Definitions.dlemma
val vars : region -> Lang.F.Vars.t
val occurs : Lang.F.var -> region -> bool
val check_assigns :
unfold:int ->
sigma -> written:region -> assignable:region -> Lang.F.pred
end
module A :
sig
module M :
sig
val configure : unit -> WpContext.rollback
val configure_ia :
Interpreted_automata.automaton ->
Interpreted_automata.vertex binder
val datatype : string
val hypotheses :
MemoryContext.partition -> MemoryContext.partition
module Chunk :
sig
type t = M.Chunk.t
val self : string
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val tau_of_chunk : t -> Lang.F.tau
val basename_of_chunk : t -> string
val is_framed : t -> bool
end
module Heap :
sig
type t = Chunk.t
type set = M.Heap.set
type 'a map = 'a M.Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
module Sigma :
sig
type chunk = Chunk.t
module Chunk :
sig
type t = Chunk.t
type set = Heap.set
type 'a map = 'a Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf :
(key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq :
(key -> 'a -> 'a option) -> 'a t -> 'a t
val filter :
(key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) ->
'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) ->
'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) ->
'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) ->
'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t = M.Sigma.t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned :
pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk ->
Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t sequence -> domain
end
type loc = M.loc
type chunk = Chunk.t
type sigma = Sigma.t
type domain = Sigma.domain
type segment = loc rloc
type state = M.state
val state : sigma -> state
val lookup : state -> Lang.F.term -> mval
val updates :
state sequence -> Lang.F.Vars.t -> update Bag.t
val apply : (Lang.F.term -> Lang.F.term) -> state -> state
val iter : (mval -> Lang.F.term -> unit) -> state -> unit
val pretty : Format.formatter -> loc -> unit
val vars : loc -> Lang.F.Vars.t
val occurs : Lang.F.var -> loc -> bool
val null : loc
val literal : eid:int -> Cstring.cst -> loc
val cvar : Cil_types.varinfo -> loc
val pointer_loc : Lang.F.term -> loc
val pointer_val : loc -> Lang.F.term
val field : loc -> Cil_types.fieldinfo -> loc
val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
val base_addr : loc -> loc
val base_offset : loc -> Lang.F.term
val block_length :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val cast : Ctypes.c_object sequence -> loc -> loc
val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
val domain : Ctypes.c_object -> loc -> domain
val is_well_formed : sigma -> Lang.F.pred
val load : sigma -> Ctypes.c_object -> loc -> loc value
val load_init :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val copied :
sigma sequence ->
Ctypes.c_object -> loc -> loc -> equation list
val copied_init :
sigma sequence ->
Ctypes.c_object -> loc -> loc -> equation list
val stored :
sigma sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> equation list
val stored_init :
sigma sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> equation list
val assigned :
sigma sequence ->
Ctypes.c_object -> loc sloc -> equation list
val is_null : loc -> Lang.F.pred
val loc_eq : loc -> loc -> Lang.F.pred
val loc_lt : loc -> loc -> Lang.F.pred
val loc_neq : loc -> loc -> Lang.F.pred
val loc_leq : loc -> loc -> Lang.F.pred
val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
val valid : sigma -> acs -> segment -> Lang.F.pred
val frame : sigma -> Lang.F.pred list
val alloc : sigma -> Cil_types.varinfo list -> sigma
val initialized : sigma -> segment -> Lang.F.pred
val invalid : sigma -> segment -> Lang.F.pred
val scope :
sigma sequence ->
scope -> Cil_types.varinfo list -> Lang.F.pred list
val global : sigma -> Lang.F.term -> Lang.F.pred
val included : segment -> segment -> Lang.F.pred
val separated : segment -> segment -> Lang.F.pred
end
module L :
sig
module M :
sig
val configure : unit -> WpContext.rollback
val configure_ia :
Interpreted_automata.automaton ->
Interpreted_automata.vertex binder
val datatype : string
val hypotheses :
MemoryContext.partition -> MemoryContext.partition
module Chunk :
sig
type t = M.Chunk.t
val self : string
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val tau_of_chunk : t -> Lang.F.tau
val basename_of_chunk : t -> string
val is_framed : t -> bool
end
module Heap :
sig
type t = Chunk.t
type set = M.Heap.set
type 'a map = 'a M.Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf :
(key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq :
(key -> 'a -> 'a option) -> 'a t -> 'a t
val filter :
(key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) ->
'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) ->
'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) ->
'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) ->
'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
module Sigma :
sig
type chunk = Chunk.t
module Chunk :
sig
type t = Chunk.t
type set = Heap.set
type 'a map = 'a Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi :
(key -> 'a -> 'b) -> 'a t -> 'b t
val mapf :
(key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq :
(key -> 'a -> 'a option) -> 'a t -> 'a t
val filter :
(key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) ->
'a t -> 'a t * 'a t
val iter :
(key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) ->
'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) ->
'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) ->
'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) ->
'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) ->
'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) ->
'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) ->
'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key ->
'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted :
(elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping :
(elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t = M.Sigma.t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned :
pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter :
(chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk ->
Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t sequence -> domain
end
type loc = M.loc
type chunk = Chunk.t
type sigma = Sigma.t
type domain = Sigma.domain
type segment = loc rloc
type state = M.state
val state : sigma -> state
val lookup : state -> Lang.F.term -> mval
val updates :
state sequence -> Lang.F.Vars.t -> update Bag.t
val apply :
(Lang.F.term -> Lang.F.term) -> state -> state
val iter :
(mval -> Lang.F.term -> unit) -> state -> unit
val pretty : Format.formatter -> loc -> unit
val vars : loc -> Lang.F.Vars.t
val occurs : Lang.F.var -> loc -> bool
val null : loc
val literal : eid:int -> Cstring.cst -> loc
val cvar : Cil_types.varinfo -> loc
val pointer_loc : Lang.F.term -> loc
val pointer_val : loc -> Lang.F.term
val field : loc -> Cil_types.fieldinfo -> loc
val shift :
loc -> Ctypes.c_object -> Lang.F.term -> loc
val base_addr : loc -> loc
val base_offset : loc -> Lang.F.term
val block_length :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val cast : Ctypes.c_object sequence -> loc -> loc
val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
val domain : Ctypes.c_object -> loc -> domain
val is_well_formed : sigma -> Lang.F.pred
val load : sigma -> Ctypes.c_object -> loc -> loc value
val load_init :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val copied :
sigma sequence ->
Ctypes.c_object -> loc -> loc -> equation list
val copied_init :
sigma sequence ->
Ctypes.c_object -> loc -> loc -> equation list
val stored :
sigma sequence ->
Ctypes.c_object ->
loc -> Lang.F.term -> equation list
val stored_init :
sigma sequence ->
Ctypes.c_object ->
loc -> Lang.F.term -> equation list
val assigned :
sigma sequence ->
Ctypes.c_object -> loc sloc -> equation list
val is_null : loc -> Lang.F.pred
val loc_eq : loc -> loc -> Lang.F.pred
val loc_lt : loc -> loc -> Lang.F.pred
val loc_neq : loc -> loc -> Lang.F.pred
val loc_leq : loc -> loc -> Lang.F.pred
val loc_diff :
Ctypes.c_object -> loc -> loc -> Lang.F.term
val valid : sigma -> acs -> segment -> Lang.F.pred
val frame : sigma -> Lang.F.pred list
val alloc : sigma -> Cil_types.varinfo list -> sigma
val initialized : sigma -> segment -> Lang.F.pred
val invalid : sigma -> segment -> Lang.F.pred
val scope :
sigma sequence ->
scope -> Cil_types.varinfo list -> Lang.F.pred list
val global : sigma -> Lang.F.term -> Lang.F.pred
val included : segment -> segment -> Lang.F.pred
val separated : segment -> segment -> Lang.F.pred
end
type loc = M.loc
type nonrec value = M.loc value
type nonrec logic = M.loc logic
type nonrec region = M.loc region
type nonrec result = M.loc result
type sigma = M.Sigma.t
type frame = L.frame
val pp_frame : Format.formatter -> frame -> unit
val get_frame : unit -> frame
val in_frame : frame -> ('a -> 'b) -> 'a -> 'b
val mem_at_frame : frame -> Clabels.c_label -> sigma
val set_at_frame :
frame -> Clabels.c_label -> sigma -> unit
val has_at_frame : frame -> Clabels.c_label -> bool
val mem_frame : Clabels.c_label -> sigma
val mk_frame :
?kf:Cil_types.kernel_function ->
?result:result ->
?status:Lang.F.var ->
?formals:value Cil_datatype.Varinfo.Map.t ->
?labels:sigma Clabels.LabelMap.t ->
?descr:string -> unit -> frame
val local : descr:string -> frame
val frame : Cil_types.kernel_function -> frame
type call = L.call
val call :
?result:M.loc ->
Cil_types.kernel_function -> value list -> call
val call_pre : sigma -> call -> sigma -> frame
val call_post : sigma -> call -> sigma sequence -> frame
val return : unit -> Cil_types.typ
val result : unit -> result
val status : unit -> Lang.F.var
val guards : frame -> Lang.F.pred list
type env = L.env
val mk_env :
?here:sigma ->
?lvars:Cil_types.logic_var list -> unit -> env
val current : env -> sigma
val move_at : env -> sigma -> env
val mem_at : env -> Clabels.c_label -> sigma
val env_at : env -> Clabels.c_label -> env
val lval :
env -> Cil_types.term_lval -> Cil_types.typ * M.loc
val term : env -> Cil_types.term -> Lang.F.term
val pred :
polarity -> env -> Cil_types.predicate -> Lang.F.pred
val call_pred :
env ->
Cil_types.logic_info ->
Cil_types.logic_label list ->
Lang.F.term list -> Lang.F.pred
val region : env -> Cil_types.term -> region
val assigned_of_lval : env -> Cil_types.lval -> region
val assigned_of_froms :
env -> Cil_types.from list -> region
val assigned_of_assigns :
env -> Cil_types.assigns -> region option
val val_of_term : env -> Cil_types.term -> Lang.F.term
val loc_of_term : env -> Cil_types.term -> loc
val lemma : LogicUsage.logic_lemma -> Definitions.dlemma
val vars : region -> Lang.F.Vars.t
val occurs : Lang.F.var -> region -> bool
val check_assigns :
unfold:int ->
sigma ->
written:region -> assignable:region -> Lang.F.pred
end
val domain : M.loc region -> M.Heap.set
val apply_assigns :
M.sigma sequence -> M.loc region -> Lang.F.pred list
end
end
end
module Mstate :
sig
val index : Wp.Sigs.s_lval -> Wp.Lang.F.term -> Wp.Sigs.s_lval
val field : Wp.Sigs.s_lval -> Cil_types.fieldinfo -> Wp.Sigs.s_lval
val equal : Wp.Sigs.s_lval -> Wp.Sigs.s_lval -> bool
type 'a model
type state
val create :
(module Wp.Sigs.Model with type Sigma.t = 'a) -> 'a Wp.Mstate.model
val state : 'a Wp.Mstate.model -> 'a -> Wp.Mstate.state
val lookup : Wp.Mstate.state -> Wp.Lang.F.term -> Wp.Sigs.mval
val apply :
(Wp.Lang.F.term -> Wp.Lang.F.term) ->
Wp.Mstate.state -> Wp.Mstate.state
val iter :
(Wp.Sigs.mval -> Wp.Lang.F.term -> unit) -> Wp.Mstate.state -> unit
val updates :
Wp.Mstate.state Wp.Sigs.sequence ->
Wp.Lang.F.Vars.t -> Wp.Sigs.update Bag.t
end
module Conditions :
sig
val forall_intro :
Wp.Lang.F.pred -> Wp.Lang.F.pred list * Wp.Lang.F.pred
val exist_intro : Wp.Lang.F.pred -> Wp.Lang.F.pred
type step = private {
mutable id : int;
size : int;
vars : Wp.Lang.F.Vars.t;
stmt : Cil_types.stmt option;
descr : string option;
deps : Property.t list;
warn : Wp.Warning.Set.t;
condition : Wp.Conditions.condition;
}
and condition =
Type of Wp.Lang.F.pred
| Have of Wp.Lang.F.pred
| When of Wp.Lang.F.pred
| Core of Wp.Lang.F.pred
| Init of Wp.Lang.F.pred
| Branch of Wp.Lang.F.pred * Wp.Conditions.sequence *
Wp.Conditions.sequence
| Either of Wp.Conditions.sequence list
| State of Wp.Mstate.state
and sequence
type sequent = Wp.Conditions.sequence * Wp.Lang.F.pred
val pretty :
(Stdlib.Format.formatter -> Wp.Conditions.sequent -> unit) Stdlib.ref
val step :
?descr:string ->
?stmt:Cil_types.stmt ->
?deps:Property.t list ->
?warn:Wp.Warning.Set.t ->
Wp.Conditions.condition -> Wp.Conditions.step
val update_cond :
?descr:string ->
?deps:Property.t list ->
?warn:Wp.Warning.Set.t ->
Wp.Conditions.step -> Wp.Conditions.condition -> Wp.Conditions.step
val is_true : Wp.Conditions.sequence -> bool
val is_empty : Wp.Conditions.sequence -> bool
val vars_hyp : Wp.Conditions.sequence -> Wp.Lang.F.Vars.t
val vars_seq : Wp.Conditions.sequent -> Wp.Lang.F.Vars.t
val empty : Wp.Conditions.sequence
val trivial : Wp.Conditions.sequent
val sequence : Wp.Conditions.step list -> Wp.Conditions.sequence
val seq_branch :
?stmt:Cil_types.stmt ->
Wp.Lang.F.pred ->
Wp.Conditions.sequence ->
Wp.Conditions.sequence -> Wp.Conditions.sequence
val append :
Wp.Conditions.sequence ->
Wp.Conditions.sequence -> Wp.Conditions.sequence
val concat : Wp.Conditions.sequence list -> Wp.Conditions.sequence
val iter :
(Wp.Conditions.step -> unit) -> Wp.Conditions.sequence -> unit
val list : Wp.Conditions.sequence -> Wp.Conditions.step list
val size : Wp.Conditions.sequence -> int
val steps : Wp.Conditions.sequence -> int
val index : Wp.Conditions.sequent -> unit
val step_at : Wp.Conditions.sequence -> int -> Wp.Conditions.step
val is_trivial : Wp.Conditions.sequent -> bool
val map_condition :
(Wp.Lang.F.pred -> Wp.Lang.F.pred) ->
Wp.Conditions.condition -> Wp.Conditions.condition
val map_step :
(Wp.Lang.F.pred -> Wp.Lang.F.pred) ->
Wp.Conditions.step -> Wp.Conditions.step
val map_sequence :
(Wp.Lang.F.pred -> Wp.Lang.F.pred) ->
Wp.Conditions.sequence -> Wp.Conditions.sequence
val map_sequent :
(Wp.Lang.F.pred -> Wp.Lang.F.pred) ->
Wp.Conditions.sequent -> Wp.Conditions.sequent
val insert :
?at:int ->
Wp.Conditions.step -> Wp.Conditions.sequent -> Wp.Conditions.sequent
val replace :
at:int ->
Wp.Conditions.step -> Wp.Conditions.sequent -> Wp.Conditions.sequent
val replace_by_step_list :
at:int ->
Wp.Conditions.step list ->
Wp.Conditions.sequent -> Wp.Conditions.sequent
val subst :
(Wp.Lang.F.term -> Wp.Lang.F.term) ->
Wp.Conditions.sequent -> Wp.Conditions.sequent
val introduction :
Wp.Conditions.sequent -> Wp.Conditions.sequent option
val introduction_eq : Wp.Conditions.sequent -> Wp.Conditions.sequent
val lemma : Wp.Lang.F.pred -> Wp.Conditions.sequent
val head : Wp.Conditions.step -> Wp.Lang.F.pred
val have : Wp.Conditions.step -> Wp.Lang.F.pred
val pred_cond : Wp.Conditions.condition -> Wp.Lang.F.pred
val condition : Wp.Conditions.sequence -> Wp.Lang.F.pred
val close : Wp.Conditions.sequent -> Wp.Lang.F.pred
val at_closure :
(Wp.Conditions.sequent -> Wp.Conditions.sequent) -> unit
type bundle
type 'a attributed =
?descr:string ->
?stmt:Cil_types.stmt ->
?deps:Property.t list -> ?warn:Wp.Warning.Set.t -> 'a
val nil : Wp.Conditions.bundle
val occurs : Wp.Lang.F.var -> Wp.Conditions.bundle -> bool
val intersect : Wp.Lang.F.pred -> Wp.Conditions.bundle -> bool
val merge : Wp.Conditions.bundle list -> Wp.Conditions.bundle
val domain :
Wp.Lang.F.pred list -> Wp.Conditions.bundle -> Wp.Conditions.bundle
val intros :
Wp.Lang.F.pred list -> Wp.Conditions.bundle -> Wp.Conditions.bundle
val state :
?descr:string ->
?stmt:Cil_types.stmt ->
Wp.Mstate.state -> Wp.Conditions.bundle -> Wp.Conditions.bundle
val assume :
(?init:bool ->
?domain:bool ->
Wp.Lang.F.pred -> Wp.Conditions.bundle -> Wp.Conditions.bundle)
Wp.Conditions.attributed
val branch :
(Wp.Lang.F.pred ->
Wp.Conditions.bundle -> Wp.Conditions.bundle -> Wp.Conditions.bundle)
Wp.Conditions.attributed
val either :
(Wp.Conditions.bundle list -> Wp.Conditions.bundle)
Wp.Conditions.attributed
val extract : Wp.Conditions.bundle -> Wp.Lang.F.pred list
val bundle : Wp.Conditions.bundle -> Wp.Conditions.sequence
val clean : Wp.Conditions.sequent -> Wp.Conditions.sequent
val filter : Wp.Conditions.sequent -> Wp.Conditions.sequent
val parasite : Wp.Conditions.sequent -> Wp.Conditions.sequent
val init_filter : Wp.Conditions.sequent -> Wp.Conditions.sequent
val simplify :
?solvers:Wp.Lang.simplifier list ->
?intros:int -> Wp.Conditions.sequent -> Wp.Conditions.sequent
val pruning :
?solvers:Wp.Lang.simplifier list ->
Wp.Conditions.sequent -> Wp.Conditions.sequent
end
module Filtering :
sig
val filter :
polarity:bool ->
(Wp.Lang.F.pred -> bool) -> Wp.Lang.F.pred -> Wp.Lang.F.pred
val compute :
?anti:bool -> Wp.Conditions.sequent -> Wp.Conditions.sequent
end
module Plang :
sig
type scope = Qed.Engine.scope
module Env :
sig
type t
val create : unit -> t
val copy : t -> t
val clear : t -> unit
val used : t -> string -> bool
val fresh :
t -> sanitizer:('a -> string) -> ?suggest:bool -> 'a -> string
val define : t -> string -> Lang.F.term -> unit
val unfold : t -> Lang.F.term -> unit
val shared : t -> Lang.F.term -> bool
val shareable : t -> Lang.F.term -> bool
val set_indexed_vars : t -> unit
val iter : (string -> Lang.F.term -> unit) -> t -> unit
end
type pool
val pool : unit -> Wp.Plang.pool
val alloc_e :
Wp.Plang.pool -> (Wp.Lang.F.var -> unit) -> Wp.Lang.F.term -> unit
val alloc_p :
Wp.Plang.pool -> (Wp.Lang.F.var -> unit) -> Wp.Lang.F.pred -> unit
val alloc_xs :
Wp.Plang.pool -> (Wp.Lang.F.var -> unit) -> Wp.Lang.F.Vars.t -> unit
val alloc_domain : Wp.Plang.pool -> Wp.Lang.F.Vars.t
val sanitizer : string -> string
type iformat = [ `Bin | `Dec | `Hex ]
type rformat = [ `Double | `Float | `Ratio ]
class engine :
object
method bind : Lang.F.var -> string
method callstyle : Qed.Engine.callstyle
method datatype : Lang.ADT.t -> string
method e_false : Qed.Engine.cmode -> string
method e_true : Qed.Engine.cmode -> string
method env : Env.t
method field : Lang.Field.t -> string
method find : Lang.F.var -> string
method get_iformat : Wp.Plang.iformat
method get_rformat : Wp.Plang.rformat
method global : (unit -> unit) -> unit
method is_atomic : Wp.Lang.F.term -> bool
method link : Lang.Fun.t -> Qed.Engine.link
method local : (unit -> unit) -> unit
method lookup : Wp.Lang.F.term -> Qed.Engine.scope
method marks : Wp.Plang.Env.t * Wp.Lang.F.marks
method mode : Qed.Engine.mode
method op_add : Qed.Engine.amode -> Qed.Engine.op
method op_and : Qed.Engine.cmode -> Qed.Engine.op
method op_div : Qed.Engine.amode -> Qed.Engine.op
method op_eq :
Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
method op_equal : Qed.Engine.cmode -> Qed.Engine.op
method op_equiv : Qed.Engine.cmode -> Qed.Engine.op
method op_imply : Qed.Engine.cmode -> Qed.Engine.op
method op_leq :
Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
method op_lt :
Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
method op_minus : Qed.Engine.amode -> Qed.Engine.op
method op_mod : Qed.Engine.amode -> Qed.Engine.op
method op_mul : Qed.Engine.amode -> Qed.Engine.op
method op_neq :
Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
method op_not : Qed.Engine.cmode -> Qed.Engine.op
method op_noteq : Qed.Engine.cmode -> Qed.Engine.op
method op_or : Qed.Engine.cmode -> Qed.Engine.op
method op_real_of_int : Qed.Engine.op
method op_scope : Qed.Engine.amode -> string option
method op_spaced : string -> bool
method op_sub : Qed.Engine.amode -> Qed.Engine.op
method pp_apply :
Qed.Engine.cmode ->
Wp.Lang.F.term -> Wp.Lang.F.term list Qed.Plib.printer
method pp_array : Lang.F.tau Qed.Plib.printer
method pp_array_cst :
Format.formatter -> Lang.F.tau -> Wp.Lang.F.term -> unit
method pp_array_get :
Format.formatter -> Wp.Lang.F.term -> Wp.Lang.F.term -> unit
method pp_array_set :
Format.formatter ->
Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term -> unit
method pp_atom : Wp.Lang.F.term Qed.Plib.printer
method pp_conditional :
Format.formatter ->
Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term -> unit
method pp_datatype : Lang.ADT.t -> Lang.F.tau list Qed.Plib.printer
method pp_def_fields :
(Lang.Field.t * Wp.Lang.F.term) list Qed.Plib.printer
method pp_equal : Wp.Lang.F.term Qed.Plib.printer2
method pp_exists : Lang.F.tau -> string list Qed.Plib.printer
method pp_expr : Lang.F.tau -> Wp.Lang.F.term Qed.Plib.printer
method pp_farray : Lang.F.tau Qed.Plib.printer2
method pp_flow : Wp.Lang.F.term Qed.Plib.printer
method pp_forall : Lang.F.tau -> string list Qed.Plib.printer
method pp_fun :
Qed.Engine.cmode ->
Lang.Fun.t -> Wp.Lang.F.term list Qed.Plib.printer
method pp_get_field :
Format.formatter -> Wp.Lang.F.term -> Lang.Field.t -> unit
method pp_imply :
Format.formatter -> Wp.Lang.F.term list -> Wp.Lang.F.term -> unit
method pp_int : Qed.Engine.amode -> Z.t Qed.Plib.printer
method pp_lambda : (string * Lang.F.tau) list Qed.Plib.printer
method pp_let :
Format.formatter ->
Qed.Engine.pmode -> string -> Wp.Lang.F.term -> unit
method pp_not : Wp.Lang.F.term Qed.Plib.printer
method pp_noteq : Wp.Lang.F.term Qed.Plib.printer2
method pp_pred : Stdlib.Format.formatter -> Wp.Lang.F.pred -> unit
method pp_prop : Wp.Lang.F.term Qed.Plib.printer
method pp_real : Q.t Qed.Plib.printer
method pp_repr : Wp.Lang.F.term Qed.Plib.printer
method pp_sort : Wp.Lang.F.term Qed.Plib.printer
method pp_subtau : Lang.F.tau Qed.Plib.printer
method pp_tau : Lang.F.tau Qed.Plib.printer
method pp_term : Wp.Lang.F.term Qed.Plib.printer
method pp_times : Format.formatter -> Z.t -> Wp.Lang.F.term -> unit
method pp_tvar : int Qed.Plib.printer
method pp_var : string Qed.Plib.printer
method sanitize : string -> string
method sanitize_field : string -> string
method sanitize_fun : string -> string
method sanitize_type : string -> string
method scope : Env.t -> (unit -> unit) -> unit
method set_env : Env.t -> unit
method set_iformat : Wp.Plang.iformat -> unit
method set_rformat : Wp.Plang.rformat -> unit
method shareable : Wp.Lang.F.term -> bool
method shared : Wp.Lang.F.term -> bool
method subterms :
(Wp.Lang.F.term -> unit) -> Wp.Lang.F.term -> unit
method t_atomic : Lang.F.tau -> bool
method t_bool : string
method t_int : string
method t_prop : string
method t_real : string
method with_mode :
Qed.Engine.mode -> (Qed.Engine.mode -> unit) -> unit
end
end
module Pcfg :
sig
type env
type label
type value =
Term
| Addr of Wp.Sigs.s_lval
| Lval of Wp.Sigs.s_lval * Wp.Pcfg.label
| Init of Wp.Sigs.s_lval * Wp.Pcfg.label
| Chunk of string * Wp.Pcfg.label
val create : unit -> Wp.Pcfg.env
val register : Wp.Conditions.sequence -> Wp.Pcfg.env
val at : Wp.Pcfg.env -> id:int -> Wp.Pcfg.label
val find : Wp.Pcfg.env -> Wp.Lang.F.term -> Wp.Pcfg.value
val updates :
Wp.Pcfg.env ->
Wp.Pcfg.label Wp.Sigs.sequence ->
Wp.Lang.F.Vars.t -> Wp.Sigs.update Bag.t
val visible : Wp.Pcfg.label -> bool
val subterms :
Wp.Pcfg.env -> (Wp.Lang.F.term -> unit) -> Wp.Lang.F.term -> bool
val prev : Wp.Pcfg.label -> Wp.Pcfg.label list
val next : Wp.Pcfg.label -> Wp.Pcfg.label list
val iter :
(Wp.Sigs.mval -> Wp.Lang.F.term -> unit) -> Wp.Pcfg.label -> unit
val branching : Wp.Pcfg.label -> bool
class virtual engine :
object
method is_atomic_lv : Wp.Sigs.s_lval -> bool
method pp_addr : Stdlib.Format.formatter -> Wp.Sigs.s_lval -> unit
method virtual pp_atom :
Stdlib.Format.formatter -> Wp.Lang.F.term -> unit
method pp_chunk : Stdlib.Format.formatter -> string -> unit
method virtual pp_flow :
Stdlib.Format.formatter -> Wp.Lang.F.term -> unit
method pp_host : Stdlib.Format.formatter -> Wp.Sigs.s_host -> unit
method pp_init : Stdlib.Format.formatter -> Wp.Sigs.s_lval -> unit
method pp_label : Stdlib.Format.formatter -> Wp.Pcfg.label -> unit
method pp_lval : Stdlib.Format.formatter -> Wp.Sigs.s_lval -> unit
method pp_offset :
Stdlib.Format.formatter -> Wp.Sigs.s_offset list -> unit
method pp_ofs : Stdlib.Format.formatter -> Wp.Sigs.s_offset -> unit
end
end
module Pcond :
sig
val pretty : Wp.Conditions.sequent Qed.Plib.printer
val dump : Wp.Conditions.bundle Qed.Plib.printer
val dump_bundle :
?clause:string ->
?goal:Wp.Lang.F.pred -> Wp.Conditions.bundle Qed.Plib.printer
val dump_sequence :
?clause:string ->
?goal:Wp.Lang.F.pred -> Wp.Conditions.sequence Qed.Plib.printer
type env = Wp.Plang.Env.t
val alloc_hyp :
Wp.Plang.pool ->
(Wp.Lang.F.var -> unit) -> Wp.Conditions.sequence -> unit
val alloc_seq :
Wp.Plang.pool ->
(Wp.Lang.F.var -> unit) -> Wp.Conditions.sequent -> unit
class engine :
#Wp.Plang.engine ->
object
method mark : Wp.Lang.F.marks -> Wp.Conditions.step -> unit
method name : Wp.Pcond.env -> Wp.Lang.F.term -> string
method pp_block :
clause:string -> Wp.Conditions.sequence Qed.Plib.printer
method pp_clause : string Qed.Plib.printer
method pp_comment : string Qed.Plib.printer
method pp_condition :
step:Wp.Conditions.step ->
Wp.Conditions.condition Qed.Plib.printer
method pp_core : Wp.Lang.F.term Qed.Plib.printer
method pp_definition :
Stdlib.Format.formatter -> string -> Wp.Lang.F.term -> unit
method pp_esequent :
Wp.Pcond.env -> Wp.Conditions.sequent Qed.Plib.printer
method pp_goal : Wp.Lang.F.pred Qed.Plib.printer
method pp_intro :
step:Wp.Conditions.step ->
clause:string -> ?dot:string -> Wp.Lang.F.pred Qed.Plib.printer
method pp_name : string Qed.Plib.printer
method pp_property : Property.t Qed.Plib.printer
method pp_sequence :
clause:string -> Wp.Conditions.sequence Qed.Plib.printer
method pp_sequent : Wp.Conditions.sequent Qed.Plib.printer
method pp_step : Wp.Conditions.step Qed.Plib.printer
method pp_stmt : string Qed.Plib.printer
method pp_warning : Wp.Warning.t Qed.Plib.printer
end
class state :
object
method bind : Lang.F.var -> string
method callstyle : Qed.Engine.callstyle
method clear : unit
method datatype : Lang.ADT.t -> string
method domain : Wp.Lang.F.Vars.t
method e_false : Qed.Engine.cmode -> string
method e_true : Qed.Engine.cmode -> string
method env : Plang.Env.t
method field : Lang.Field.t -> string
method find : Lang.F.var -> string
method get_iformat : Plang.iformat
method get_rformat : Plang.rformat
method global : (unit -> unit) -> unit
method is_atomic : Lang.F.term -> bool
method is_atomic_lv : Sigs.s_lval -> bool
method label_at : id:int -> Wp.Pcfg.label
method link : Lang.Fun.t -> Qed.Engine.link
method local : (unit -> unit) -> unit
method lookup : Lang.F.term -> Qed.Engine.scope
method marks : Plang.Env.t * Lang.F.marks
method mode : Qed.Engine.mode
method op_add : Qed.Engine.amode -> Qed.Engine.op
method op_and : Qed.Engine.cmode -> Qed.Engine.op
method op_div : Qed.Engine.amode -> Qed.Engine.op
method op_eq :
Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
method op_equal : Qed.Engine.cmode -> Qed.Engine.op
method op_equiv : Qed.Engine.cmode -> Qed.Engine.op
method op_imply : Qed.Engine.cmode -> Qed.Engine.op
method op_leq :
Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
method op_lt :
Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
method op_minus : Qed.Engine.amode -> Qed.Engine.op
method op_mod : Qed.Engine.amode -> Qed.Engine.op
method op_mul : Qed.Engine.amode -> Qed.Engine.op
method op_neq :
Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
method op_not : Qed.Engine.cmode -> Qed.Engine.op
method op_noteq : Qed.Engine.cmode -> Qed.Engine.op
method op_or : Qed.Engine.cmode -> Qed.Engine.op
method op_real_of_int : Qed.Engine.op
method op_scope : Qed.Engine.amode -> string option
method op_spaced : string -> bool
method op_sub : Qed.Engine.amode -> Qed.Engine.op
method pp_addr : Format.formatter -> Sigs.s_lval -> unit
method pp_apply :
Qed.Engine.cmode ->
Lang.F.term -> Lang.F.term list Qed.Plib.printer
method pp_array : Lang.F.tau Qed.Plib.printer
method pp_array_cst :
Format.formatter -> Lang.F.tau -> Lang.F.term -> unit
method pp_array_get :
Format.formatter -> Lang.F.term -> Lang.F.term -> unit
method pp_array_set :
Format.formatter ->
Lang.F.term -> Lang.F.term -> Lang.F.term -> unit
method pp_at : Stdlib.Format.formatter -> Wp.Pcfg.label -> unit
method pp_atom : Lang.F.term Qed.Plib.printer
method pp_chunk : Format.formatter -> string -> unit
method pp_conditional :
Format.formatter ->
Lang.F.term -> Lang.F.term -> Lang.F.term -> unit
method pp_datatype : Lang.ADT.t -> Lang.F.tau list Qed.Plib.printer
method pp_def_fields :
(Lang.Field.t * Lang.F.term) list Qed.Plib.printer
method pp_equal : Lang.F.term Qed.Plib.printer2
method pp_exists : Lang.F.tau -> string list Qed.Plib.printer
method pp_expr : Lang.F.tau -> Lang.F.term Qed.Plib.printer
method pp_farray : Lang.F.tau Qed.Plib.printer2
method pp_flow : Lang.F.term Qed.Plib.printer
method pp_forall : Lang.F.tau -> string list Qed.Plib.printer
method pp_fun :
Qed.Engine.cmode ->
Lang.Fun.t -> Lang.F.term list Qed.Plib.printer
method pp_get_field :
Format.formatter -> Lang.F.term -> Lang.Field.t -> unit
method pp_host : Format.formatter -> Sigs.s_host -> unit
method pp_imply :
Format.formatter -> Lang.F.term list -> Lang.F.term -> unit
method pp_init : Format.formatter -> Sigs.s_lval -> unit
method pp_int : Qed.Engine.amode -> Z.t Qed.Plib.printer
method pp_label : Format.formatter -> Pcfg.label -> unit
method pp_lambda : (string * Lang.F.tau) list Qed.Plib.printer
method pp_let :
Format.formatter ->
Qed.Engine.pmode -> string -> Lang.F.term -> unit
method pp_lval : Format.formatter -> Sigs.s_lval -> unit
method pp_not : Lang.F.term Qed.Plib.printer
method pp_noteq : Lang.F.term Qed.Plib.printer2
method pp_offset : Format.formatter -> Sigs.s_offset list -> unit
method pp_ofs : Format.formatter -> Sigs.s_offset -> unit
method pp_pred : Format.formatter -> Lang.F.pred -> unit
method pp_prop : Lang.F.term Qed.Plib.printer
method pp_real : Q.t Qed.Plib.printer
method pp_repr : Lang.F.term Qed.Plib.printer
method pp_sort : Lang.F.term Qed.Plib.printer
method pp_subtau : Lang.F.tau Qed.Plib.printer
method pp_tau : Lang.F.tau Qed.Plib.printer
method pp_term : Lang.F.term Qed.Plib.printer
method pp_times : Format.formatter -> Z.t -> Lang.F.term -> unit
method pp_tvar : int Qed.Plib.printer
method pp_update :
Wp.Pcfg.label ->
Stdlib.Format.formatter -> Wp.Sigs.update -> unit
method pp_value : Stdlib.Format.formatter -> Wp.Lang.F.term -> unit
method pp_var : string Qed.Plib.printer
method sanitize : string -> string
method sanitize_field : string -> string
method sanitize_fun : string -> string
method sanitize_type : string -> string
method scope : Plang.Env.t -> (unit -> unit) -> unit
method set_domain : Wp.Lang.F.Vars.t -> unit
method set_env : Plang.Env.t -> unit
method set_iformat : Plang.iformat -> unit
method set_rformat : Plang.rformat -> unit
method set_sequence : Wp.Conditions.sequence -> unit
method shareable : Lang.F.term -> bool
method shared : Lang.F.term -> bool
method subterms : (Lang.F.term -> unit) -> Lang.F.term -> unit
method t_atomic : Lang.F.tau -> bool
method t_bool : string
method t_int : string
method t_prop : string
method t_real : string
method updates :
Wp.Pcfg.label Wp.Sigs.sequence -> Wp.Sigs.update Bag.t
method with_mode :
Qed.Engine.mode -> (Qed.Engine.mode -> unit) -> unit
end
class seqengine :
#Wp.Pcond.state ->
object
method get_state : bool
method mark : Lang.F.marks -> Conditions.step -> unit
method name : env -> Lang.F.term -> string
method pp_block :
clause:string -> Conditions.sequence Qed.Plib.printer
method pp_clause : string Qed.Plib.printer
method pp_comment : string Qed.Plib.printer
method pp_condition :
step:Conditions.step -> Conditions.condition Qed.Plib.printer
method pp_core : Lang.F.term Qed.Plib.printer
method pp_definition :
Format.formatter -> string -> Lang.F.term -> unit
method pp_esequent : env -> Conditions.sequent Qed.Plib.printer
method pp_goal : Lang.F.pred Qed.Plib.printer
method pp_intro :
step:Conditions.step ->
clause:string -> ?dot:string -> Lang.F.pred Qed.Plib.printer
method pp_name : string Qed.Plib.printer
method pp_property : Property.t Qed.Plib.printer
method pp_sequence :
clause:string -> Conditions.sequence Qed.Plib.printer
method pp_sequent : Conditions.sequent Qed.Plib.printer
method pp_step : Conditions.step Qed.Plib.printer
method pp_stmt : string Qed.Plib.printer
method pp_warning : Warning.t Qed.Plib.printer
method set_goal : Wp.Lang.F.pred -> unit
method set_sequence : Wp.Conditions.sequence -> unit
method set_sequent : Wp.Conditions.sequent -> unit
method set_state : bool -> unit
end
end
module CodeSemantics :
sig
module Make :
functor (M : Sigs.Model) ->
sig
module M :
sig
val configure : unit -> WpContext.rollback
val configure_ia :
Interpreted_automata.automaton ->
Interpreted_automata.vertex Sigs.binder
val datatype : string
val hypotheses :
MemoryContext.partition -> MemoryContext.partition
module Chunk :
sig
type t = M.Chunk.t
val self : string
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val tau_of_chunk : t -> Lang.F.tau
val basename_of_chunk : t -> string
val is_framed : t -> bool
end
module Heap :
sig
type t = Chunk.t
type set = M.Heap.set
type 'a map = 'a M.Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted : (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
module Sigma :
sig
type chunk = Chunk.t
module Chunk :
sig
type t = Chunk.t
type set = Heap.set
type 'a map = 'a Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf :
(key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq :
(key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) ->
'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) ->
'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t = M.Sigma.t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned :
pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk ->
Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t Sigs.sequence -> domain
end
type loc = M.loc
type chunk = Chunk.t
type sigma = Sigma.t
type domain = Sigma.domain
type segment = loc Sigs.rloc
type state = M.state
val state : sigma -> state
val lookup : state -> Lang.F.term -> Sigs.mval
val updates :
state Sigs.sequence -> Lang.F.Vars.t -> Sigs.update Bag.t
val apply : (Lang.F.term -> Lang.F.term) -> state -> state
val iter :
(Sigs.mval -> Lang.F.term -> unit) -> state -> unit
val pretty : Format.formatter -> loc -> unit
val vars : loc -> Lang.F.Vars.t
val occurs : Lang.F.var -> loc -> bool
val null : loc
val literal : eid:int -> Cstring.cst -> loc
val cvar : Cil_types.varinfo -> loc
val pointer_loc : Lang.F.term -> loc
val pointer_val : loc -> Lang.F.term
val field : loc -> Cil_types.fieldinfo -> loc
val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
val base_addr : loc -> loc
val base_offset : loc -> Lang.F.term
val block_length :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val cast : Ctypes.c_object Sigs.sequence -> loc -> loc
val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
val domain : Ctypes.c_object -> loc -> domain
val is_well_formed : sigma -> Lang.F.pred
val load : sigma -> Ctypes.c_object -> loc -> loc Sigs.value
val load_init :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val copied :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> loc -> Sigs.equation list
val copied_init :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> loc -> Sigs.equation list
val stored :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
val stored_init :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
val assigned :
sigma Sigs.sequence ->
Ctypes.c_object -> loc Sigs.sloc -> Sigs.equation list
val is_null : loc -> Lang.F.pred
val loc_eq : loc -> loc -> Lang.F.pred
val loc_lt : loc -> loc -> Lang.F.pred
val loc_neq : loc -> loc -> Lang.F.pred
val loc_leq : loc -> loc -> Lang.F.pred
val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
val valid : sigma -> Sigs.acs -> segment -> Lang.F.pred
val frame : sigma -> Lang.F.pred list
val alloc : sigma -> Cil_types.varinfo list -> sigma
val initialized : sigma -> segment -> Lang.F.pred
val invalid : sigma -> segment -> Lang.F.pred
val scope :
sigma Sigs.sequence ->
Sigs.scope -> Cil_types.varinfo list -> Lang.F.pred list
val global : sigma -> Lang.F.term -> Lang.F.pred
val included : segment -> segment -> Lang.F.pred
val separated : segment -> segment -> Lang.F.pred
end
type loc = M.loc
type nonrec value = loc Sigs.value
type nonrec result = loc Sigs.result
type sigma = M.Sigma.t
val pp_value : Format.formatter -> value -> unit
val cval : value -> Lang.F.term
val cloc : value -> loc
val cast : Cil_types.typ -> Cil_types.typ -> value -> value
val equal_typ : Cil_types.typ -> value -> value -> Lang.F.pred
val not_equal_typ :
Cil_types.typ -> value -> value -> Lang.F.pred
val equal_obj : Ctypes.c_object -> value -> value -> Lang.F.pred
val not_equal_obj :
Ctypes.c_object -> value -> value -> Lang.F.pred
val exp : sigma -> Cil_types.exp -> value
val cond : sigma -> Cil_types.exp -> Lang.F.pred
val lval : sigma -> Cil_types.lval -> loc
val call : sigma -> Cil_types.exp -> loc
val instance_of : loc -> Cil_types.kernel_function -> Lang.F.pred
val loc_of_exp : sigma -> Cil_types.exp -> loc
val val_of_exp : sigma -> Cil_types.exp -> Lang.F.term
val result : sigma -> Cil_types.typ -> result -> Lang.F.term
val return :
sigma -> Cil_types.typ -> Cil_types.exp -> Lang.F.term
val is_zero : sigma -> Ctypes.c_object -> loc -> Lang.F.pred
val is_exp_range :
sigma ->
loc ->
Ctypes.c_object ->
Lang.F.term -> Lang.F.term -> value option -> Lang.F.pred
val unchanged :
M.sigma -> M.sigma -> Cil_types.varinfo -> Lang.F.pred
type warned_hyp = Warning.Set.t * (Lang.F.pred * Lang.F.pred)
val init :
sigma:M.sigma ->
Cil_types.varinfo -> Cil_types.init option -> warned_hyp list
end
end
module LogicCompiler :
sig
type polarity = [ `Negative | `NoPolarity | `Positive ]
module Make :
functor (M : Sigs.Model) ->
sig
type value = M.loc Wp.Sigs.value
type logic = M.loc Wp.Sigs.logic
type result = M.loc Wp.Sigs.result
type sigma = M.Sigma.t
type chunk = M.Chunk.t
type call
type frame
val pp_frame :
Stdlib.Format.formatter -> Wp.LogicCompiler.Make.frame -> unit
val local : descr:string -> Wp.LogicCompiler.Make.frame
val frame :
Cil_types.kernel_function -> Wp.LogicCompiler.Make.frame
val call :
?result:M.loc ->
Cil_types.kernel_function ->
Wp.LogicCompiler.Make.value list -> Wp.LogicCompiler.Make.call
val call_pre :
Wp.LogicCompiler.Make.sigma ->
Wp.LogicCompiler.Make.call ->
Wp.LogicCompiler.Make.sigma -> Wp.LogicCompiler.Make.frame
val call_post :
Wp.LogicCompiler.Make.sigma ->
Wp.LogicCompiler.Make.call ->
Wp.LogicCompiler.Make.sigma Wp.Sigs.sequence ->
Wp.LogicCompiler.Make.frame
val mk_frame :
?kf:Cil_types.kernel_function ->
?result:Wp.LogicCompiler.Make.result ->
?status:Wp.Lang.F.var ->
?formals:Wp.LogicCompiler.Make.value Cil_datatype.Varinfo.Map.t ->
?labels:Wp.LogicCompiler.Make.sigma Wp.Clabels.LabelMap.t ->
?descr:string -> unit -> Wp.LogicCompiler.Make.frame
val formal :
Cil_types.varinfo -> Wp.LogicCompiler.Make.value option
val return : unit -> Cil_types.typ
val result : unit -> Wp.LogicCompiler.Make.result
val status : unit -> Wp.Lang.F.var
val trigger : Wp.Definitions.trigger -> unit
val guards : Wp.LogicCompiler.Make.frame -> Wp.Lang.F.pred list
val mem_frame : Wp.Clabels.c_label -> Wp.LogicCompiler.Make.sigma
val has_at_frame :
Wp.LogicCompiler.Make.frame -> Wp.Clabels.c_label -> bool
val mem_at_frame :
Wp.LogicCompiler.Make.frame ->
Wp.Clabels.c_label -> Wp.LogicCompiler.Make.sigma
val set_at_frame :
Wp.LogicCompiler.Make.frame ->
Wp.Clabels.c_label -> Wp.LogicCompiler.Make.sigma -> unit
val in_frame :
Wp.LogicCompiler.Make.frame -> ('a -> 'b) -> 'a -> 'b
val get_frame : unit -> Wp.LogicCompiler.Make.frame
type env
val mk_env :
?here:Wp.LogicCompiler.Make.sigma ->
?lvars:Cil_datatype.Logic_var.t list ->
unit -> Wp.LogicCompiler.Make.env
val current :
Wp.LogicCompiler.Make.env -> Wp.LogicCompiler.Make.sigma
val move_at :
Wp.LogicCompiler.Make.env ->
Wp.LogicCompiler.Make.sigma -> Wp.LogicCompiler.Make.env
val env_at :
Wp.LogicCompiler.Make.env ->
Wp.Clabels.c_label -> Wp.LogicCompiler.Make.env
val mem_at :
Wp.LogicCompiler.Make.env ->
Wp.Clabels.c_label -> Wp.LogicCompiler.Make.sigma
val env_let :
Wp.LogicCompiler.Make.env ->
Cil_types.logic_var ->
Wp.LogicCompiler.Make.logic -> Wp.LogicCompiler.Make.env
val env_letp :
Wp.LogicCompiler.Make.env ->
Cil_types.logic_var ->
Wp.Lang.F.pred -> Wp.LogicCompiler.Make.env
val env_letval :
Wp.LogicCompiler.Make.env ->
Cil_types.logic_var ->
Wp.LogicCompiler.Make.value -> Wp.LogicCompiler.Make.env
val term :
Wp.LogicCompiler.Make.env -> Cil_types.term -> Wp.Lang.F.term
val pred :
Wp.LogicCompiler.polarity ->
Wp.LogicCompiler.Make.env ->
Cil_types.predicate -> Wp.Lang.F.pred
val logic :
Wp.LogicCompiler.Make.env ->
Cil_types.term -> Wp.LogicCompiler.Make.logic
val region :
Wp.LogicCompiler.Make.env ->
Cil_types.term -> M.loc Wp.Sigs.region
val bootstrap_term :
(Wp.LogicCompiler.Make.env -> Cil_types.term -> Wp.Lang.F.term) ->
unit
val bootstrap_pred :
(Wp.LogicCompiler.polarity ->
Wp.LogicCompiler.Make.env ->
Cil_types.predicate -> Wp.Lang.F.pred) ->
unit
val bootstrap_logic :
(Wp.LogicCompiler.Make.env ->
Cil_types.term -> Wp.LogicCompiler.Make.logic) ->
unit
val bootstrap_region :
(Wp.LogicCompiler.Make.env ->
Cil_types.term -> M.loc Wp.Sigs.region) ->
unit
val call_fun :
Wp.LogicCompiler.Make.env ->
Wp.Lang.F.tau ->
Cil_types.logic_info ->
Cil_types.logic_label list ->
Wp.Lang.F.term list -> Wp.Lang.F.term
val call_pred :
Wp.LogicCompiler.Make.env ->
Cil_types.logic_info ->
Cil_types.logic_label list ->
Wp.Lang.F.term list -> Wp.Lang.F.pred
val logic_var :
Wp.LogicCompiler.Make.env ->
Cil_types.logic_var -> Wp.LogicCompiler.Make.logic
val logic_info :
Wp.LogicCompiler.Make.env ->
Cil_types.logic_info -> Wp.Lang.F.pred option
val has_ltype :
Cil_types.logic_type -> Wp.Lang.F.term -> Wp.Lang.F.pred
val lemma : Wp.LogicUsage.logic_lemma -> Wp.Definitions.dlemma
end
end
module LogicSemantics :
sig
module Make :
functor (M : Sigs.Model) ->
sig
module M :
sig
val configure : unit -> WpContext.rollback
val configure_ia :
Interpreted_automata.automaton ->
Interpreted_automata.vertex Sigs.binder
val datatype : string
val hypotheses :
MemoryContext.partition -> MemoryContext.partition
module Chunk :
sig
type t = M.Chunk.t
val self : string
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val pretty : Format.formatter -> t -> unit
val tau_of_chunk : t -> Lang.F.tau
val basename_of_chunk : t -> string
val is_framed : t -> bool
end
module Heap :
sig
type t = Chunk.t
type set = M.Heap.set
type 'a map = 'a M.Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted : (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
module Sigma :
sig
type chunk = Chunk.t
module Chunk :
sig
type t = Chunk.t
type set = Heap.set
type 'a map = 'a Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf :
(key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq :
(key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) ->
'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) ->
'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t = M.Sigma.t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned :
pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk ->
Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t Sigs.sequence -> domain
end
type loc = M.loc
type chunk = Chunk.t
type sigma = Sigma.t
type domain = Sigma.domain
type segment = loc Sigs.rloc
type state = M.state
val state : sigma -> state
val lookup : state -> Lang.F.term -> Sigs.mval
val updates :
state Sigs.sequence -> Lang.F.Vars.t -> Sigs.update Bag.t
val apply : (Lang.F.term -> Lang.F.term) -> state -> state
val iter :
(Sigs.mval -> Lang.F.term -> unit) -> state -> unit
val pretty : Format.formatter -> loc -> unit
val vars : loc -> Lang.F.Vars.t
val occurs : Lang.F.var -> loc -> bool
val null : loc
val literal : eid:int -> Cstring.cst -> loc
val cvar : Cil_types.varinfo -> loc
val pointer_loc : Lang.F.term -> loc
val pointer_val : loc -> Lang.F.term
val field : loc -> Cil_types.fieldinfo -> loc
val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
val base_addr : loc -> loc
val base_offset : loc -> Lang.F.term
val block_length :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val cast : Ctypes.c_object Sigs.sequence -> loc -> loc
val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
val domain : Ctypes.c_object -> loc -> domain
val is_well_formed : sigma -> Lang.F.pred
val load : sigma -> Ctypes.c_object -> loc -> loc Sigs.value
val load_init :
sigma -> Ctypes.c_object -> loc -> Lang.F.term
val copied :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> loc -> Sigs.equation list
val copied_init :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> loc -> Sigs.equation list
val stored :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
val stored_init :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
val assigned :
sigma Sigs.sequence ->
Ctypes.c_object -> loc Sigs.sloc -> Sigs.equation list
val is_null : loc -> Lang.F.pred
val loc_eq : loc -> loc -> Lang.F.pred
val loc_lt : loc -> loc -> Lang.F.pred
val loc_neq : loc -> loc -> Lang.F.pred
val loc_leq : loc -> loc -> Lang.F.pred
val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
val valid : sigma -> Sigs.acs -> segment -> Lang.F.pred
val frame : sigma -> Lang.F.pred list
val alloc : sigma -> Cil_types.varinfo list -> sigma
val initialized : sigma -> segment -> Lang.F.pred
val invalid : sigma -> segment -> Lang.F.pred
val scope :
sigma Sigs.sequence ->
Sigs.scope -> Cil_types.varinfo list -> Lang.F.pred list
val global : sigma -> Lang.F.term -> Lang.F.pred
val included : segment -> segment -> Lang.F.pred
val separated : segment -> segment -> Lang.F.pred
end
type loc = M.loc
type nonrec value = M.loc Sigs.value
type nonrec logic = M.loc Sigs.logic
type nonrec region = M.loc Sigs.region
type nonrec result = M.loc Sigs.result
type sigma = M.Sigma.t
type frame
val pp_frame : Format.formatter -> frame -> unit
val get_frame : unit -> frame
val in_frame : frame -> ('a -> 'b) -> 'a -> 'b
val mem_at_frame : frame -> Clabels.c_label -> sigma
val set_at_frame : frame -> Clabels.c_label -> sigma -> unit
val has_at_frame : frame -> Clabels.c_label -> bool
val mem_frame : Clabels.c_label -> sigma
val mk_frame :
?kf:Cil_types.kernel_function ->
?result:result ->
?status:Lang.F.var ->
?formals:value Cil_datatype.Varinfo.Map.t ->
?labels:sigma Clabels.LabelMap.t ->
?descr:string -> unit -> frame
val local : descr:string -> frame
val frame : Cil_types.kernel_function -> frame
type call
val call :
?result:M.loc ->
Cil_types.kernel_function -> value list -> call
val call_pre : sigma -> call -> sigma -> frame
val call_post : sigma -> call -> sigma Sigs.sequence -> frame
val return : unit -> Cil_types.typ
val result : unit -> result
val status : unit -> Lang.F.var
val guards : frame -> Lang.F.pred list
type env
val mk_env :
?here:sigma -> ?lvars:Cil_types.logic_var list -> unit -> env
val current : env -> sigma
val move_at : env -> sigma -> env
val mem_at : env -> Clabels.c_label -> sigma
val env_at : env -> Clabels.c_label -> env
val lval : env -> Cil_types.term_lval -> Cil_types.typ * M.loc
val term : env -> Cil_types.term -> Lang.F.term
val pred :
Sigs.polarity -> env -> Cil_types.predicate -> Lang.F.pred
val call_pred :
env ->
Cil_types.logic_info ->
Cil_types.logic_label list -> Lang.F.term list -> Lang.F.pred
val region : env -> Cil_types.term -> region
val assigned_of_lval : env -> Cil_types.lval -> region
val assigned_of_froms : env -> Cil_types.from list -> region
val assigned_of_assigns :
env -> Cil_types.assigns -> region option
val val_of_term : env -> Cil_types.term -> Lang.F.term
val loc_of_term : env -> Cil_types.term -> loc
val lemma : LogicUsage.logic_lemma -> Definitions.dlemma
val vars : region -> Lang.F.Vars.t
val occurs : Lang.F.var -> region -> bool
val check_assigns :
unfold:int ->
sigma -> written:region -> assignable:region -> Lang.F.pred
end
end
module Sigma :
sig
module Make :
functor (C : Sigs.Chunk)
(H : sig
type t = C.t
type set
type 'a map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted : (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end)
->
sig
type chunk = C.t
module Chunk :
sig
type t = C.t
type set = H.set
type 'a map = 'a H.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted : (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned : pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk -> Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t Sigs.sequence -> domain
end
end
module MemVar :
sig
module type VarUsage =
sig
val datatype : string
val param : Cil_types.varinfo -> Wp.MemoryContext.param
val iter :
?kf:Cil_types.kernel_function ->
init:bool -> (Cil_types.varinfo -> unit) -> unit
end
module Make : functor (V : VarUsage) (M : Sigs.Model) -> Sigs.Model
end
module MemTyped :
sig
val configure : unit -> WpContext.rollback
val configure_ia :
Interpreted_automata.automaton ->
Interpreted_automata.vertex Sigs.binder
val datatype : string
val hypotheses : MemoryContext.partition -> MemoryContext.partition
module Chunk : Sigs.Chunk
module Heap :
sig
type t = Chunk.t
type set
type 'a map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted : (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val subset : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk : (key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
module Sigma :
sig
type chunk = Chunk.t
module Chunk :
sig
type t = Chunk.t
type set = Heap.set
type 'a map = 'a Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted : (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned : pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk -> Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t Sigs.sequence -> domain
end
type loc
type chunk = Chunk.t
type sigma = Sigma.t
type domain = Sigma.domain
type segment = loc Sigs.rloc
type state
val state : sigma -> state
val lookup : state -> Lang.F.term -> Sigs.mval
val updates : state Sigs.sequence -> Lang.F.Vars.t -> Sigs.update Bag.t
val apply : (Lang.F.term -> Lang.F.term) -> state -> state
val iter : (Sigs.mval -> Lang.F.term -> unit) -> state -> unit
val pretty : Format.formatter -> loc -> unit
val vars : loc -> Lang.F.Vars.t
val occurs : Lang.F.var -> loc -> bool
val null : loc
val literal : eid:int -> Cstring.cst -> loc
val cvar : Cil_types.varinfo -> loc
val pointer_loc : Lang.F.term -> loc
val pointer_val : loc -> Lang.F.term
val field : loc -> Cil_types.fieldinfo -> loc
val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
val base_addr : loc -> loc
val base_offset : loc -> Lang.F.term
val block_length : sigma -> Ctypes.c_object -> loc -> Lang.F.term
val cast : Ctypes.c_object Sigs.sequence -> loc -> loc
val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
val domain : Ctypes.c_object -> loc -> domain
val is_well_formed : sigma -> Lang.F.pred
val load : sigma -> Ctypes.c_object -> loc -> loc Sigs.value
val load_init : sigma -> Ctypes.c_object -> loc -> Lang.F.term
val copied :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> loc -> Sigs.equation list
val copied_init :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> loc -> Sigs.equation list
val stored :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
val stored_init :
sigma Sigs.sequence ->
Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
val assigned :
sigma Sigs.sequence ->
Ctypes.c_object -> loc Sigs.sloc -> Sigs.equation list
val is_null : loc -> Lang.F.pred
val loc_eq : loc -> loc -> Lang.F.pred
val loc_lt : loc -> loc -> Lang.F.pred
val loc_neq : loc -> loc -> Lang.F.pred
val loc_leq : loc -> loc -> Lang.F.pred
val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
val valid : sigma -> Sigs.acs -> segment -> Lang.F.pred
val frame : sigma -> Lang.F.pred list
val alloc : sigma -> Cil_types.varinfo list -> sigma
val initialized : sigma -> segment -> Lang.F.pred
val invalid : sigma -> segment -> Lang.F.pred
val scope :
sigma Sigs.sequence ->
Sigs.scope -> Cil_types.varinfo list -> Lang.F.pred list
val global : sigma -> Lang.F.term -> Lang.F.pred
val included : segment -> segment -> Lang.F.pred
val separated : segment -> segment -> Lang.F.pred
type pointer = NoCast | Fits | Unsafe
val pointer : Wp.MemTyped.pointer Wp.Context.value
end
module MemVal :
sig
module type State =
sig
type t
val bottom : Wp.MemVal.State.t
val join :
Wp.MemVal.State.t -> Wp.MemVal.State.t -> Wp.MemVal.State.t
val of_kinstr : Cil_types.kinstr -> Wp.MemVal.State.t
val of_stmt : Cil_types.stmt -> Wp.MemVal.State.t
val of_kf : Cil_types.kernel_function -> Wp.MemVal.State.t
val pretty : Stdlib.Format.formatter -> Wp.MemVal.State.t -> unit
end
module type Value =
sig
val configure : unit -> Wp.WpContext.rollback
val datatype : string
module State : State
type t
type state = Wp.MemVal.State.t
val null : Wp.MemVal.Value.t
val literal : eid:int -> Wp.Cstring.cst -> int * Wp.MemVal.Value.t
val cvar : Cil_types.varinfo -> Wp.MemVal.Value.t
val field :
Wp.MemVal.Value.t -> Cil_types.fieldinfo -> Wp.MemVal.Value.t
val shift :
Wp.MemVal.Value.t ->
Wp.Ctypes.c_object -> Wp.Lang.F.term -> Wp.MemVal.Value.t
val base_addr : Wp.MemVal.Value.t -> Wp.MemVal.Value.t
val load :
Wp.MemVal.Value.state ->
Wp.MemVal.Value.t -> Wp.Ctypes.c_object -> Wp.MemVal.Value.t
val domain : Wp.MemVal.Value.t -> Base.t list
val offset : Wp.MemVal.Value.t -> Wp.Lang.F.term -> Wp.Lang.F.pred
val pretty : Stdlib.Format.formatter -> Wp.MemVal.Value.t -> unit
end
module Make : functor (V : Value) -> Sigs.Model
module Eva : Value
end
module CfgCompiler :
sig
type mode = [ `Bool_Backward | `Bool_Forward | `Tree ]
module type Cfg =
sig
module S : Sigs.Sigma
module Node :
sig
type t
module Map :
sig
type key = t
type 'a t
val is_empty : 'a t -> bool
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
end
module Set :
sig
type elt = t
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val find : elt -> t -> elt
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val map : (elt -> elt) -> t -> t
val mapf : (elt -> elt option) -> t -> t
val intersect : t -> t -> bool
end
module Hashtbl :
sig
type key = t
type !'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : '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_opt : 'a t -> key -> 'a option
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 filter_map_inplace :
(key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Seq.t
val to_seq_keys : 'a t -> key Seq.t
val to_seq_values : 'a t -> 'a Seq.t
val add_seq : 'a t -> (key * 'a) Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
val of_seq : (key * 'a) Seq.t -> 'a t
end
val pp :
Stdlib.Format.formatter -> Wp.CfgCompiler.Cfg.Node.t -> unit
val create : unit -> Wp.CfgCompiler.Cfg.Node.t
val equal :
Wp.CfgCompiler.Cfg.Node.t ->
Wp.CfgCompiler.Cfg.Node.t -> bool
end
type node = Wp.CfgCompiler.Cfg.Node.t
val node : unit -> Wp.CfgCompiler.Cfg.node
module C :
sig
type t
val equal :
Wp.CfgCompiler.Cfg.C.t -> Wp.CfgCompiler.Cfg.C.t -> bool
val create : S.t -> Wp.Lang.F.pred -> Wp.CfgCompiler.Cfg.C.t
val get : Wp.CfgCompiler.Cfg.C.t -> Wp.Lang.F.pred
val reads : Wp.CfgCompiler.Cfg.C.t -> S.domain
val relocate :
S.t -> Wp.CfgCompiler.Cfg.C.t -> Wp.CfgCompiler.Cfg.C.t
end
module P :
sig
type t
val pretty :
Stdlib.Format.formatter -> Wp.CfgCompiler.Cfg.P.t -> unit
val create :
S.t Wp.CfgCompiler.Cfg.Node.Map.t ->
Wp.Lang.F.pred -> Wp.CfgCompiler.Cfg.P.t
val get : Wp.CfgCompiler.Cfg.P.t -> Wp.Lang.F.pred
val reads :
Wp.CfgCompiler.Cfg.P.t ->
S.domain Wp.CfgCompiler.Cfg.Node.Map.t
val nodes :
Wp.CfgCompiler.Cfg.P.t -> Wp.CfgCompiler.Cfg.Node.Set.t
val relocate :
S.t Wp.CfgCompiler.Cfg.Node.Map.t ->
Wp.CfgCompiler.Cfg.P.t -> Wp.CfgCompiler.Cfg.P.t
val to_condition :
Wp.CfgCompiler.Cfg.P.t ->
(Wp.CfgCompiler.Cfg.C.t * Wp.CfgCompiler.Cfg.Node.t option)
option
end
module T :
sig
type t
val pretty :
Stdlib.Format.formatter -> Wp.CfgCompiler.Cfg.T.t -> unit
val create :
S.t Wp.CfgCompiler.Cfg.Node.Map.t ->
Wp.Lang.F.term -> Wp.CfgCompiler.Cfg.T.t
val get : Wp.CfgCompiler.Cfg.T.t -> Wp.Lang.F.term
val reads :
Wp.CfgCompiler.Cfg.T.t ->
S.domain Wp.CfgCompiler.Cfg.Node.Map.t
val relocate :
S.t Wp.CfgCompiler.Cfg.Node.Map.t ->
Wp.CfgCompiler.Cfg.T.t -> Wp.CfgCompiler.Cfg.T.t
val init :
Wp.CfgCompiler.Cfg.Node.Set.t ->
(S.t Wp.CfgCompiler.Cfg.Node.Map.t -> Wp.Lang.F.term) ->
Wp.CfgCompiler.Cfg.T.t
val init' :
Wp.CfgCompiler.Cfg.Node.t ->
(S.t -> Wp.Lang.F.term) -> Wp.CfgCompiler.Cfg.T.t
end
module E :
sig
type t
val pretty :
Stdlib.Format.formatter -> Wp.CfgCompiler.Cfg.E.t -> unit
val create :
S.t Wp.Sigs.sequence ->
Wp.Lang.F.pred -> Wp.CfgCompiler.Cfg.E.t
val get : Wp.CfgCompiler.Cfg.E.t -> Wp.Lang.F.pred
val reads : Wp.CfgCompiler.Cfg.E.t -> S.domain
val writes : Wp.CfgCompiler.Cfg.E.t -> S.domain
val relocate :
S.t Wp.Sigs.sequence ->
Wp.CfgCompiler.Cfg.E.t -> Wp.CfgCompiler.Cfg.E.t
end
type cfg
val dump_env : name:string -> Wp.CfgCompiler.Cfg.cfg -> unit
val output_dot :
Stdlib.out_channel ->
?checks:Wp.CfgCompiler.Cfg.P.t Bag.t ->
Wp.CfgCompiler.Cfg.cfg -> unit
val nop : Wp.CfgCompiler.Cfg.cfg
val add_tmpnode : Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
val concat :
Wp.CfgCompiler.Cfg.cfg ->
Wp.CfgCompiler.Cfg.cfg -> Wp.CfgCompiler.Cfg.cfg
val meta :
?stmt:Cil_types.stmt ->
?descr:string ->
Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
val goto :
Wp.CfgCompiler.Cfg.node ->
Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
val branch :
Wp.CfgCompiler.Cfg.node ->
Wp.CfgCompiler.Cfg.C.t ->
Wp.CfgCompiler.Cfg.node ->
Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
val guard :
Wp.CfgCompiler.Cfg.node ->
Wp.CfgCompiler.Cfg.C.t ->
Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
val guard' :
Wp.CfgCompiler.Cfg.node ->
Wp.CfgCompiler.Cfg.C.t ->
Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
val either :
Wp.CfgCompiler.Cfg.node ->
Wp.CfgCompiler.Cfg.node list -> Wp.CfgCompiler.Cfg.cfg
val implies :
Wp.CfgCompiler.Cfg.node ->
(Wp.CfgCompiler.Cfg.C.t * Wp.CfgCompiler.Cfg.node) list ->
Wp.CfgCompiler.Cfg.cfg
val effect :
Wp.CfgCompiler.Cfg.node ->
Wp.CfgCompiler.Cfg.E.t ->
Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
val assume : Wp.CfgCompiler.Cfg.P.t -> Wp.CfgCompiler.Cfg.cfg
val havoc :
Wp.CfgCompiler.Cfg.node ->
effects:Wp.CfgCompiler.Cfg.node Wp.Sigs.sequence ->
Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
val compile :
?name:string ->
?mode:Wp.CfgCompiler.mode ->
Wp.CfgCompiler.Cfg.node ->
Wp.CfgCompiler.Cfg.Node.Set.t ->
S.domain Wp.CfgCompiler.Cfg.Node.Map.t ->
Wp.CfgCompiler.Cfg.cfg ->
Wp.Lang.F.pred Wp.CfgCompiler.Cfg.Node.Map.t *
S.t Wp.CfgCompiler.Cfg.Node.Map.t * Wp.Conditions.sequence
end
module Cfg :
functor (S : Sigs.Sigma) ->
sig
module S :
sig
type chunk = S.chunk
module Chunk :
sig
type t = chunk
type set = S.Chunk.set
type 'a map = 'a S.Chunk.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted : (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t = S.t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned : pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk -> Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t Sigs.sequence -> domain
end
module Node :
sig
type t
module Map :
sig
type key = t
type 'a t
val is_empty : 'a t -> bool
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val insert :
(key -> 'a -> 'a -> 'a) -> key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
end
module Set :
sig
type elt = t
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val find : elt -> t -> elt
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val map : (elt -> elt) -> t -> t
val mapf : (elt -> elt option) -> t -> t
val intersect : t -> t -> bool
end
module Hashtbl :
sig
type key = t
type !'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : '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_opt : 'a t -> key -> 'a option
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 filter_map_inplace :
(key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Seq.t
val to_seq_keys : 'a t -> key Seq.t
val to_seq_values : 'a t -> 'a Seq.t
val add_seq : 'a t -> (key * 'a) Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
val of_seq : (key * 'a) Seq.t -> 'a t
end
val pp : Format.formatter -> t -> unit
val create : unit -> t
val equal : t -> t -> bool
end
type node = Node.t
val node : unit -> node
module C :
sig
type t
val equal : t -> t -> bool
val create : S.t -> Lang.F.pred -> t
val get : t -> Lang.F.pred
val reads : t -> S.domain
val relocate : S.t -> t -> t
end
module P :
sig
type t
val pretty : Format.formatter -> t -> unit
val create : S.t Node.Map.t -> Lang.F.pred -> t
val get : t -> Lang.F.pred
val reads : t -> S.domain Node.Map.t
val nodes : t -> Node.Set.t
val relocate : S.t Node.Map.t -> t -> t
val to_condition : t -> (C.t * Node.t option) option
end
module T :
sig
type t
val pretty : Format.formatter -> t -> unit
val create : S.t Node.Map.t -> Lang.F.term -> t
val get : t -> Lang.F.term
val reads : t -> S.domain Node.Map.t
val relocate : S.t Node.Map.t -> t -> t
val init : Node.Set.t -> (S.t Node.Map.t -> Lang.F.term) -> t
val init' : Node.t -> (S.t -> Lang.F.term) -> t
end
module E :
sig
type t
val pretty : Format.formatter -> t -> unit
val create : S.t Sigs.sequence -> Lang.F.pred -> t
val get : t -> Lang.F.pred
val reads : t -> S.domain
val writes : t -> S.domain
val relocate : S.t Sigs.sequence -> t -> t
end
type cfg
val dump_env : name:string -> cfg -> unit
val output_dot : out_channel -> ?checks:P.t Bag.t -> cfg -> unit
val nop : cfg
val add_tmpnode : node -> cfg
val concat : cfg -> cfg -> cfg
val meta : ?stmt:Cil_types.stmt -> ?descr:string -> node -> cfg
val goto : node -> node -> cfg
val branch : node -> C.t -> node -> node -> cfg
val guard : node -> C.t -> node -> cfg
val guard' : node -> C.t -> node -> cfg
val either : node -> node list -> cfg
val implies : node -> (C.t * node) list -> cfg
val effect : node -> E.t -> node -> cfg
val assume : P.t -> cfg
val havoc : node -> effects:node Sigs.sequence -> node -> cfg
val compile :
?name:string ->
?mode:mode ->
node ->
Node.Set.t ->
S.domain Node.Map.t ->
cfg ->
Lang.F.pred Node.Map.t * S.t Node.Map.t * Conditions.sequence
end
end
module StmtSemantics :
sig
module Make :
functor (Compiler : Sigs.Compiler) ->
sig
module Cfg :
sig
module S :
sig
type chunk = Compiler.M.Chunk.t
module Chunk :
sig
type t = Compiler.M.Chunk.t
type set = Compiler.M.Heap.set
type 'a map = 'a Compiler.M.Heap.map
val hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
module Map :
sig
type key = t
type 'a t = 'a map
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val findk : key -> 'a t -> key * 'a
val size : 'a t -> int
val is_empty : 'a t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf :
(key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq :
(key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted :
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val subset :
(key -> 'a -> 'b -> bool) ->
'a t -> 'b t -> bool
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iterk :
(key -> 'a -> 'b -> unit) ->
'a t -> 'b t -> unit
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
type domain = set
val domain : 'a t -> domain
end
module Set :
sig
type elt = t
type t = set
val empty : t
val add : elt -> t -> t
val singleton : elt -> t
val elements : t -> elt list
val is_empty : t -> bool
val mem : elt -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter_sorted : (elt -> unit) -> t -> unit
val fold_sorted :
(elt -> 'a -> 'a) -> t -> 'a -> 'a
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val intersect : t -> t -> bool
val of_list : elt list -> t
type 'a mapping = 'a map
val mapping : (elt -> 'a) -> t -> 'a mapping
end
end
type domain = Chunk.Set.t
type t = Compiler.M.Sigma.t
val pretty : Format.formatter -> t -> unit
val create : unit -> t
val mem : t -> chunk -> bool
val get : t -> chunk -> Lang.F.var
val value : t -> chunk -> Lang.F.term
val copy : t -> t
val join : t -> t -> Passive.t
val assigned :
pre:t -> post:t -> domain -> Lang.F.pred Bag.t
val choose : t -> t -> t
val merge : t -> t -> t * Passive.t * Passive.t
val merge_list : t list -> t * Passive.t list
val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
val iter2 :
(chunk ->
Lang.F.var option -> Lang.F.var option -> unit) ->
t -> t -> unit
val havoc_chunk : t -> chunk -> t
val havoc : t -> domain -> t
val havoc_any : call:bool -> t -> t
val remove_chunks : t -> domain -> t
val domain : t -> domain
val union : domain -> domain -> domain
val empty : domain
val writes : t Sigs.sequence -> domain
end
module Node :
sig
type t
module Map :
sig
type key = t
type 'a t
val is_empty : 'a t -> bool
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val compare :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
val mapf : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapq : (key -> 'a -> 'a option) -> 'a t -> 'a t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val union :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val inter :
(key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interf :
(key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
val interq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val diffq :
(key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val iter2 :
(key -> 'a option -> 'b option -> unit) ->
'a t -> 'b t -> unit
val subset :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val insert :
(key -> 'a -> 'a -> 'a) ->
key -> 'a -> 'a t -> 'a t
val change :
(key -> 'b -> 'a option -> 'a option) ->
key -> 'b -> 'a t -> 'a t
end
module Set :
sig
type elt = t
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val find : elt -> t -> elt
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val map : (elt -> elt) -> t -> t
val mapf : (elt -> elt option) -> t -> t
val intersect : t -> t -> bool
end
module Hashtbl :
sig
type key = t
type !'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : '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_opt : 'a t -> key -> 'a option
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 filter_map_inplace :
(key -> 'a -> 'a option) -> 'a t -> unit
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Seq.t
val to_seq_keys : 'a t -> key Seq.t
val to_seq_values : 'a t -> 'a Seq.t
val add_seq : 'a t -> (key * 'a) Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
val of_seq : (key * 'a) Seq.t -> 'a t
end
val pp : Format.formatter -> t -> unit
val create : unit -> t
val equal : t -> t -> bool
end
type node = Node.t
val node : unit -> node
module C :
sig
type t
val equal : t -> t -> bool
val create : S.t -> Lang.F.pred -> t
val get : t -> Lang.F.pred
val reads : t -> S.domain
val relocate : S.t -> t -> t
end
module P :
sig
type t
val pretty : Format.formatter -> t -> unit
val create : S.t Node.Map.t -> Lang.F.pred -> t
val get : t -> Lang.F.pred
val reads : t -> S.domain Node.Map.t
val nodes : t -> Node.Set.t
val relocate : S.t Node.Map.t -> t -> t
val to_condition : t -> (C.t * Node.t option) option
end
module T :
sig
type t
val pretty : Format.formatter -> t -> unit
val create : S.t Node.Map.t -> Lang.F.term -> t
val get : t -> Lang.F.term
val reads : t -> S.domain Node.Map.t
val relocate : S.t Node.Map.t -> t -> t
val init :
Node.Set.t -> (S.t Node.Map.t -> Lang.F.term) -> t
val init' : Node.t -> (S.t -> Lang.F.term) -> t
end
module E :
sig
type t
val pretty : Format.formatter -> t -> unit
val create : S.t Sigs.sequence -> Lang.F.pred -> t
val get : t -> Lang.F.pred
val reads : t -> S.domain
val writes : t -> S.domain
val relocate : S.t Sigs.sequence -> t -> t
end
type cfg
val dump_env : name:string -> cfg -> unit
val output_dot :
out_channel -> ?checks:P.t Bag.t -> cfg -> unit
val nop : cfg
val add_tmpnode : node -> cfg
val concat : cfg -> cfg -> cfg
val meta :
?stmt:Cil_types.stmt -> ?descr:string -> node -> cfg
val goto : node -> node -> cfg
val branch : node -> C.t -> node -> node -> cfg
val guard : node -> C.t -> node -> cfg
val guard' : node -> C.t -> node -> cfg
val either : node -> node list -> cfg
val implies : node -> (C.t * node) list -> cfg
val effect : node -> E.t -> node -> cfg
val assume : P.t -> cfg
val havoc : node -> effects:node Sigs.sequence -> node -> cfg
val compile :
?name:string ->
?mode:CfgCompiler.mode ->
node ->
Node.Set.t ->
S.domain Node.Map.t ->
cfg ->
Lang.F.pred Node.Map.t * S.t Node.Map.t *
Conditions.sequence
end
type node = Wp.StmtSemantics.Make.Cfg.node
type goal = {
goal_pred : Wp.StmtSemantics.Make.Cfg.P.t;
goal_prop : Wp.WpPropId.prop_id;
}
type cfg = Wp.StmtSemantics.Make.Cfg.cfg
type paths = {
paths_cfg : Wp.StmtSemantics.Make.cfg;
paths_goals : Wp.StmtSemantics.Make.goal Bag.t;
}
val goals_nodes :
Wp.StmtSemantics.Make.goal Bag.t ->
Wp.StmtSemantics.Make.Cfg.Node.Set.t
exception LabelNotFound of Wp.Clabels.c_label
type env
val empty_env : Kernel_function.t -> Wp.StmtSemantics.Make.env
val bind :
Wp.Clabels.c_label ->
Wp.StmtSemantics.Make.node ->
Wp.StmtSemantics.Make.env -> Wp.StmtSemantics.Make.env
val result : Wp.StmtSemantics.Make.env -> Wp.Lang.F.var
val ( @^ ) :
Wp.StmtSemantics.Make.paths ->
Wp.StmtSemantics.Make.paths -> Wp.StmtSemantics.Make.paths
val ( @* ) :
Wp.StmtSemantics.Make.env ->
(Wp.Clabels.c_label * Wp.StmtSemantics.Make.node) list ->
Wp.StmtSemantics.Make.env
val ( @: ) :
Wp.StmtSemantics.Make.env ->
Wp.Clabels.c_label -> Wp.StmtSemantics.Make.node
val ( @- ) :
Wp.StmtSemantics.Make.env ->
(Wp.Clabels.c_label -> bool) -> Wp.StmtSemantics.Make.env
val sequence :
(Wp.StmtSemantics.Make.env -> 'a -> Wp.StmtSemantics.Make.paths) ->
Wp.StmtSemantics.Make.env ->
'a list -> Wp.StmtSemantics.Make.paths
val choice :
?pre:Wp.Clabels.c_label ->
?post:Wp.Clabels.c_label ->
(Wp.StmtSemantics.Make.env -> 'a -> Wp.StmtSemantics.Make.paths) ->
Wp.StmtSemantics.Make.env ->
'a list -> Wp.StmtSemantics.Make.paths
val parallel :
?pre:Wp.Clabels.c_label ->
?post:Wp.Clabels.c_label ->
(Wp.StmtSemantics.Make.env ->
'a ->
Wp.StmtSemantics.Make.Cfg.C.t * Wp.StmtSemantics.Make.paths) ->
Wp.StmtSemantics.Make.env ->
'a list -> Wp.StmtSemantics.Make.paths
val set :
Wp.StmtSemantics.Make.env ->
Cil_types.lval -> Cil_types.exp -> Wp.StmtSemantics.Make.paths
val scope :
Wp.StmtSemantics.Make.env ->
Wp.Sigs.scope ->
Cil_types.varinfo list -> Wp.StmtSemantics.Make.paths
val instr :
Wp.StmtSemantics.Make.env ->
Cil_types.instr -> Wp.StmtSemantics.Make.paths
val return :
Wp.StmtSemantics.Make.env ->
Cil_types.exp option -> Wp.StmtSemantics.Make.paths
val assume :
Wp.StmtSemantics.Make.Cfg.P.t -> Wp.StmtSemantics.Make.paths
val call_kf :
Wp.StmtSemantics.Make.env ->
Cil_types.lval option ->
Cil_types.kernel_function ->
Cil_types.exp list -> Wp.StmtSemantics.Make.paths
val call :
Wp.StmtSemantics.Make.env ->
Cil_types.lval option ->
Cil_types.exp ->
Cil_types.exp list -> Wp.StmtSemantics.Make.paths
val spec :
Wp.StmtSemantics.Make.env ->
Cil_types.spec -> Wp.StmtSemantics.Make.paths
val assume_ :
Wp.StmtSemantics.Make.env ->
Wp.Sigs.polarity ->
Cil_types.predicate -> Wp.StmtSemantics.Make.paths
val assigns :
Wp.StmtSemantics.Make.env ->
Cil_types.assigns -> Wp.StmtSemantics.Make.paths
val froms :
Wp.StmtSemantics.Make.env ->
Cil_types.from list -> Wp.StmtSemantics.Make.paths
val automaton :
Wp.StmtSemantics.Make.env ->
Interpreted_automata.automaton -> Wp.StmtSemantics.Make.paths
val init :
is_pre_main:bool ->
Wp.StmtSemantics.Make.env -> Wp.StmtSemantics.Make.paths
val compute_kf :
Kernel_function.t ->
Wp.StmtSemantics.Make.paths * Wp.StmtSemantics.Make.node
end
end
module Factory :
sig
type mheap =
Hoare
| ZeroAlias
| Region
| Typed of Wp.MemTyped.pointer
| Eva
type mvar = Raw | Var | Ref | Caveat
type setup = {
mvar : Wp.Factory.mvar;
mheap : Wp.Factory.mheap;
cint : Wp.Cint.model;
cfloat : Wp.Cfloat.model;
}
type driver = Wp.LogicBuiltins.driver
val ident : Wp.Factory.setup -> string
val descr : Wp.Factory.setup -> string
val compiler :
Wp.Factory.mheap -> Wp.Factory.mvar -> (module Wp.Sigs.Compiler)
val configure_driver :
Wp.Factory.setup ->
Wp.Factory.driver -> unit -> Wp.WpContext.rollback
val instance :
Wp.Factory.setup -> Wp.Factory.driver -> Wp.WpContext.model
val default : Wp.Factory.setup
val parse :
?default:Wp.Factory.setup ->
?warning:(string -> unit) -> string list -> Wp.Factory.setup
end
module Driver : sig val load_driver : unit -> Wp.LogicBuiltins.driver end
module VCS :
sig
type prover = Why3 of Why3Provers.t | Qed | Tactical
type mode = Batch | Update | Edit | Fix | FixUpdate
module Pset :
sig
type elt = prover
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val disjoint : t -> t -> bool
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val map : (elt -> elt) -> t -> t
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val min_elt_opt : t -> elt option
val max_elt : t -> elt
val max_elt_opt : t -> elt option
val choose : t -> elt
val choose_opt : t -> elt option
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val find_opt : elt -> t -> elt option
val find_first : (elt -> bool) -> t -> elt
val find_first_opt : (elt -> bool) -> t -> elt option
val find_last : (elt -> bool) -> t -> elt
val find_last_opt : (elt -> bool) -> t -> elt option
val of_list : elt list -> t
val to_seq_from : elt -> t -> elt Seq.t
val to_seq : t -> elt Seq.t
val to_rev_seq : t -> elt Seq.t
val add_seq : elt Seq.t -> t -> t
val of_seq : elt Seq.t -> t
end
module Pmap :
sig
type key = prover
type +!'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val min_binding_opt : 'a t -> (key * 'a) option
val max_binding : 'a t -> key * 'a
val max_binding_opt : 'a t -> (key * 'a) option
val choose : 'a t -> key * 'a
val choose_opt : 'a t -> (key * 'a) option
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_first : (key -> bool) -> 'a t -> key * 'a
val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
val find_last : (key -> bool) -> 'a t -> key * 'a
val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Seq.t
val to_rev_seq : 'a t -> (key * 'a) Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
val of_seq : (key * 'a) Seq.t -> 'a t
end
val name_of_prover : Wp.VCS.prover -> string
val title_of_prover : Wp.VCS.prover -> string
val filename_for_prover : Wp.VCS.prover -> string
val title_of_mode : Wp.VCS.mode -> string
val parse_mode : string -> Wp.VCS.mode
val parse_prover : string -> Wp.VCS.prover option
val pp_prover : Stdlib.Format.formatter -> Wp.VCS.prover -> unit
val pp_mode : Stdlib.Format.formatter -> Wp.VCS.mode -> unit
val cmp_prover : Wp.VCS.prover -> Wp.VCS.prover -> int
type config = {
valid : bool;
timeout : int option;
stepout : int option;
}
val current : unit -> Wp.VCS.config
val default : Wp.VCS.config
val get_timeout :
?kf:Kernel_function.t -> smoke:bool -> Wp.VCS.config -> int
val get_stepout : Wp.VCS.config -> int
type verdict =
NoResult
| Invalid
| Unknown
| Timeout
| Stepout
| Computing of (unit -> unit)
| Valid
| Failed
type result = {
verdict : Wp.VCS.verdict;
cached : bool;
solver_time : float;
prover_time : float;
prover_steps : int;
prover_errpos : Stdlib.Lexing.position option;
prover_errmsg : string;
}
val no_result : Wp.VCS.result
val valid : Wp.VCS.result
val invalid : Wp.VCS.result
val unknown : Wp.VCS.result
val stepout : int -> Wp.VCS.result
val timeout : int -> Wp.VCS.result
val computing : (unit -> unit) -> Wp.VCS.result
val failed : ?pos:Stdlib.Lexing.position -> string -> Wp.VCS.result
val kfailed :
?pos:Stdlib.Lexing.position ->
('a, Stdlib.Format.formatter, unit, Wp.VCS.result) Stdlib.format4 ->
'a
val cached : Wp.VCS.result -> Wp.VCS.result
val result :
?cached:bool ->
?solver:float ->
?time:float -> ?steps:int -> Wp.VCS.verdict -> Wp.VCS.result
val is_auto : Wp.VCS.prover -> bool
val is_verdict : Wp.VCS.result -> bool
val is_valid : Wp.VCS.result -> bool
val is_computing : Wp.VCS.result -> bool
val is_proved : smoke:bool -> Wp.VCS.result -> bool
val smoked : Wp.VCS.verdict -> Wp.VCS.verdict
val verdict : smoke:bool -> Wp.VCS.result -> Wp.VCS.verdict
val configure : Wp.VCS.result -> Wp.VCS.config
val autofit : Wp.VCS.result -> bool
val pp_result : Stdlib.Format.formatter -> Wp.VCS.result -> unit
val pp_result_qualif :
?updating:bool ->
Wp.VCS.prover -> Wp.VCS.result -> Stdlib.Format.formatter -> unit
val compare : Wp.VCS.result -> Wp.VCS.result -> int
val merge : Wp.VCS.result -> Wp.VCS.result -> Wp.VCS.result
val choose : Wp.VCS.result -> Wp.VCS.result -> Wp.VCS.result
val best : Wp.VCS.result list -> Wp.VCS.result
val dkey_shell : Wp.Wp_parameters.category
end
module Tactical :
sig
type clause = Goal of Wp.Lang.F.pred | Step of Wp.Conditions.step
type process =
Wp.Conditions.sequent -> (string * Wp.Conditions.sequent) list
type status =
Not_applicable
| Not_configured
| Applicable of Wp.Tactical.process
type selection =
Empty
| Clause of Wp.Tactical.clause
| Inside of Wp.Tactical.clause * Wp.Lang.F.term
| Compose of Wp.Tactical.compose
| Multi of Wp.Tactical.selection list
and compose = private
Cint of Integer.t
| Range of int * int
| Code of Wp.Lang.F.term * string * Wp.Tactical.selection list
val int : int -> Wp.Tactical.selection
val cint : Integer.t -> Wp.Tactical.selection
val range : int -> int -> Wp.Tactical.selection
val compose :
string -> Wp.Tactical.selection list -> Wp.Tactical.selection
val multi : Wp.Tactical.selection list -> Wp.Tactical.selection
val get_int : Wp.Tactical.selection -> int option
val destruct : Wp.Tactical.selection -> Wp.Tactical.selection list
val head : Wp.Tactical.clause -> Wp.Lang.F.pred
val is_empty : Wp.Tactical.selection -> bool
val selected : Wp.Tactical.selection -> Wp.Lang.F.term
val subclause : Wp.Tactical.clause -> Wp.Lang.F.pred -> bool
val pp_clause : Stdlib.Format.formatter -> Wp.Tactical.clause -> unit
val pp_selection :
Stdlib.Format.formatter -> Wp.Tactical.selection -> unit
type 'a field
module Fmap :
sig
type t
val create : unit -> Wp.Tactical.Fmap.t
val get : Wp.Tactical.Fmap.t -> 'a Wp.Tactical.field -> 'a
val set : Wp.Tactical.Fmap.t -> 'a Wp.Tactical.field -> 'a -> unit
end
type 'a named = {
title : string;
descr : string;
vid : string;
value : 'a;
}
type 'a range = { vmin : 'a option; vmax : 'a option; vstep : 'a; }
type 'a browser =
('a Wp.Tactical.named -> unit) -> Wp.Tactical.selection -> unit
type parameter =
Checkbox of bool Wp.Tactical.field
| Spinner of int Wp.Tactical.field * int Wp.Tactical.range
| Composer of Wp.Tactical.selection Wp.Tactical.field *
(Wp.Lang.F.term -> bool)
| Selector : 'a Wp.Tactical.field * 'a Wp.Tactical.named list *
('a -> 'a -> bool) -> Wp.Tactical.parameter
| Search : 'a Wp.Tactical.named option Wp.Tactical.field *
'a Wp.Tactical.browser * (string -> 'a) -> Wp.Tactical.parameter
val ident : 'a Wp.Tactical.field -> string
val default : 'a Wp.Tactical.field -> 'a
val signature : 'a Wp.Tactical.field -> 'a Wp.Tactical.named
val checkbox :
id:string ->
title:string ->
descr:string ->
?default:bool ->
unit -> bool Wp.Tactical.field * Wp.Tactical.parameter
val spinner :
id:string ->
title:string ->
descr:string ->
?default:int ->
?vmin:int ->
?vmax:int ->
?vstep:int -> unit -> int Wp.Tactical.field * Wp.Tactical.parameter
val selector :
id:string ->
title:string ->
descr:string ->
?default:'a ->
options:'a Wp.Tactical.named list ->
?equal:('a -> 'a -> bool) ->
unit -> 'a Wp.Tactical.field * Wp.Tactical.parameter
val composer :
id:string ->
title:string ->
descr:string ->
?default:Wp.Tactical.selection ->
?filter:(Wp.Lang.F.term -> bool) ->
unit ->
Wp.Tactical.selection Wp.Tactical.field * Wp.Tactical.parameter
val search :
id:string ->
title:string ->
descr:string ->
browse:'a Wp.Tactical.browser ->
find:(string -> 'a) ->
unit ->
'a Wp.Tactical.named option Wp.Tactical.field * Wp.Tactical.parameter
type 'a formatter =
('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'a
class type feedback =
object
method get_title : string
method has_error : bool
method interactive : bool
method pool : Wp.Lang.F.pool
method set_descr : 'a Wp.Tactical.formatter
method set_error : 'a Wp.Tactical.formatter
method set_title : 'a Wp.Tactical.formatter
method update_field :
?enabled:bool ->
?title:string ->
?tooltip:string ->
?range:bool ->
?vmin:int ->
?vmax:int ->
?filter:(Wp.Lang.F.term -> bool) -> 'a Wp.Tactical.field -> unit
end
val at : Wp.Tactical.selection -> int option
val mapi : (int -> int -> 'a -> 'b) -> 'a list -> 'b list
val insert :
?at:int -> (string * Wp.Lang.F.pred) list -> Wp.Tactical.process
val replace :
at:int ->
(string * Wp.Conditions.condition) list -> Wp.Tactical.process
val replace_single :
at:int ->
string * Wp.Conditions.condition ->
Wp.Conditions.sequent -> string * Wp.Conditions.sequent
val replace_step :
at:int -> Wp.Conditions.condition list -> Wp.Tactical.process
val split : (string * Wp.Lang.F.pred) list -> Wp.Tactical.process
val rewrite :
?at:int ->
(string * Wp.Lang.F.pred * Wp.Lang.F.term * Wp.Lang.F.term) list ->
Wp.Tactical.process
val condition :
string ->
Wp.Lang.F.pred -> Wp.Tactical.process -> Wp.Tactical.process
class type tactical =
object
method descr : string
method get_field : 'a Wp.Tactical.field -> 'a
method id : string
method params : Wp.Tactical.parameter list
method reset : unit
method select :
Wp.Tactical.feedback ->
Wp.Tactical.selection -> Wp.Tactical.status
method set_field : 'a Wp.Tactical.field -> 'a -> unit
method title : string
end
class virtual make :
id:string ->
title:string ->
descr:string ->
params:Wp.Tactical.parameter list ->
object
method descr : string
method get_field : 'a Wp.Tactical.field -> 'a
method id : string
method params : Wp.Tactical.parameter list
method reset : unit
method virtual select :
Wp.Tactical.feedback ->
Wp.Tactical.selection -> Wp.Tactical.status
method set_field : 'a Wp.Tactical.field -> 'a -> unit
method title : string
end
class type composer =
object
method arity : int
method compute : Wp.Lang.F.term list -> Wp.Lang.F.term
method descr : string
method filter : Wp.Lang.F.term list -> bool
method group : string
method id : string
method title : string
end
type t = Wp.Tactical.tactical
val register : #Wp.Tactical.tactical -> unit
val export : #Wp.Tactical.tactical -> Wp.Tactical.tactical
val lookup : id:string -> Wp.Tactical.tactical
val iter : (Wp.Tactical.tactical -> unit) -> unit
val add_composer : #Wp.Tactical.composer -> unit
val iter_composer : (Wp.Tactical.composer -> unit) -> unit
end
module Strategy :
sig
val occurs_x : Wp.Lang.F.var -> Wp.Lang.F.term -> bool
val occurs_y : Wp.Lang.F.var -> Wp.Lang.F.pred -> bool
val occurs_e : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
val occurs_p : Wp.Lang.F.term -> Wp.Lang.F.pred -> bool
val occurs_q : Wp.Lang.F.pred -> Wp.Lang.F.pred -> bool
val select_e :
Wp.Conditions.sequent -> Wp.Lang.F.term -> Wp.Tactical.selection
val select_p :
Wp.Conditions.sequent -> Wp.Lang.F.pred -> Wp.Tactical.selection
type argument = ARG : 'a Wp.Tactical.field * 'a -> Wp.Strategy.argument
type strategy = {
priority : float;
tactical : Wp.Tactical.tactical;
selection : Wp.Tactical.selection;
arguments : Wp.Strategy.argument list;
}
class pool :
object
method add : Wp.Strategy.strategy -> unit
method sort : Wp.Strategy.strategy array
end
class type heuristic =
object
method descr : string
method id : string
method search :
(Wp.Strategy.strategy -> unit) -> Wp.Conditions.sequent -> unit
method title : string
end
val register : #Wp.Strategy.heuristic -> unit
val export : #Wp.Strategy.heuristic -> Wp.Strategy.heuristic
val lookup : id:string -> Wp.Strategy.heuristic
val iter : (Wp.Strategy.heuristic -> unit) -> unit
type t = Wp.Strategy.strategy
val arg : 'a Wp.Tactical.field -> 'a -> Wp.Strategy.argument
val make :
Wp.Tactical.tactical ->
?priority:float ->
?arguments:Wp.Strategy.argument list ->
Wp.Tactical.selection -> Wp.Strategy.strategy
val set_arg : Wp.Tactical.tactical -> Wp.Strategy.argument -> unit
val set_args :
Wp.Tactical.tactical -> Wp.Strategy.argument list -> unit
end
module Auto :
sig
val array :
?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
val choice :
?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
val absurd :
?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
val contrapose :
?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
val compound :
?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
val cut :
?priority:float ->
?modus:bool -> Wp.Tactical.selection -> Wp.Strategy.strategy
val filter :
?priority:float -> ?anti:bool -> unit -> Wp.Strategy.strategy
val havoc :
?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
val separated :
?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
val instance :
?priority:float ->
Wp.Tactical.selection ->
Wp.Tactical.selection list -> Wp.Strategy.strategy
val lemma :
?priority:float ->
?at:Wp.Tactical.selection ->
string -> Wp.Tactical.selection list -> Wp.Strategy.strategy
val intuition :
?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
val range :
?priority:float ->
Wp.Tactical.selection -> vmin:int -> vmax:int -> Wp.Strategy.strategy
val split :
?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
val definition :
?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
val auto_split : Wp.Strategy.heuristic
val auto_range : Wp.Strategy.heuristic
module Range :
sig
type rg
val compute : Wp.Conditions.sequence -> Wp.Auto.Range.rg
val ranges : Wp.Auto.Range.rg -> (int * int) Wp.Lang.F.Tmap.t
val bounds :
Wp.Auto.Range.rg -> (int option * int option) Wp.Lang.F.Tmap.t
end
val t_absurd : Wp.Tactical.process
val t_id : Wp.Tactical.process
val t_finally : string -> Wp.Tactical.process
val t_descr : string -> Wp.Tactical.process -> Wp.Tactical.process
val t_split :
?pos:string -> ?neg:string -> Wp.Lang.F.pred -> Wp.Tactical.process
val t_cut :
?by:string ->
Wp.Lang.F.pred -> Wp.Tactical.process -> Wp.Tactical.process
val t_case :
Wp.Lang.F.pred ->
Wp.Tactical.process -> Wp.Tactical.process -> Wp.Tactical.process
val t_cases :
?complete:string ->
(Wp.Lang.F.pred * Wp.Tactical.process) list -> Wp.Tactical.process
val t_chain :
Wp.Tactical.process -> Wp.Tactical.process -> Wp.Tactical.process
val t_range :
Wp.Lang.F.term ->
int ->
int ->
upper:Wp.Tactical.process ->
lower:Wp.Tactical.process ->
range:Wp.Tactical.process -> Wp.Tactical.process
val t_replace :
?equal:string ->
src:Wp.Lang.F.term ->
tgt:Wp.Lang.F.term -> Wp.Tactical.process -> Wp.Tactical.process
end
module VC :
sig
type t
val get_id : Wp.VC.t -> string
val get_model : Wp.VC.t -> Wp.WpContext.model
val get_scope : Wp.VC.t -> Wp.WpContext.scope
val get_context : Wp.VC.t -> Wp.WpContext.context
val get_description : Wp.VC.t -> string
val get_property : Wp.VC.t -> Property.t
val get_result : Wp.VC.t -> Wp.VCS.prover -> Wp.VCS.result
val get_results : Wp.VC.t -> (Wp.VCS.prover * Wp.VCS.result) list
val get_logout : Wp.VC.t -> Wp.VCS.prover -> string
val get_logerr : Wp.VC.t -> Wp.VCS.prover -> string
val get_sequent : Wp.VC.t -> Wp.Conditions.sequent
val get_formula : Wp.VC.t -> Wp.Lang.F.pred
val is_trivial : Wp.VC.t -> bool
val is_proved : Wp.VC.t -> bool
val clear : unit -> unit
val proof : Property.t -> Wp.VC.t list
val remove : Property.t -> unit
val iter_ip : (Wp.VC.t -> unit) -> Property.t -> unit
val iter_kf :
(Wp.VC.t -> unit) -> ?bhv:string list -> Kernel_function.t -> unit
val generate_ip : ?model:string -> Property.t -> Wp.VC.t Bag.t
val generate_kf :
?model:string ->
?bhv:string list ->
?prop:string list -> Kernel_function.t -> Wp.VC.t Bag.t
val generate_call : ?model:string -> Cil_types.stmt -> Wp.VC.t Bag.t
val prove :
Wp.VC.t ->
?config:Wp.VCS.config ->
?mode:Wp.VCS.mode ->
?start:(Wp.VC.t -> unit) ->
?progress:(Wp.VC.t -> string -> unit) ->
?result:(Wp.VC.t -> Wp.VCS.prover -> Wp.VCS.result -> unit) ->
Wp.VCS.prover -> bool Task.task
val spawn :
Wp.VC.t ->
?config:Wp.VCS.config ->
?start:(Wp.VC.t -> unit) ->
?progress:(Wp.VC.t -> string -> unit) ->
?result:(Wp.VC.t -> Wp.VCS.prover -> Wp.VCS.result -> unit) ->
?success:(Wp.VC.t -> Wp.VCS.prover option -> unit) ->
?pool:Task.pool -> (Wp.VCS.mode * Wp.VCS.prover) list -> unit
val server : ?procs:int -> unit -> Task.server
val command :
?provers:Why3.Whyconf.prover list ->
?tip:bool -> Wp.VC.t Bag.t -> unit
end
module Wpo :
sig
type index =
Axiomatic of string option
| Function of Cil_types.kernel_function * string option
module DISK :
sig
val cache_log :
pid:Wp.WpPropId.prop_id ->
model:Wp.WpContext.model ->
prover:Wp.VCS.prover -> result:Wp.VCS.result -> string
val pretty :
pid:Wp.WpPropId.prop_id ->
model:Wp.WpContext.model ->
prover:Wp.VCS.prover ->
result:Wp.VCS.result -> Stdlib.Format.formatter -> unit
val file_kf :
kf:Cil_types.kernel_function ->
model:Wp.WpContext.model -> prover:Wp.VCS.prover -> string
val file_goal :
pid:Wp.WpPropId.prop_id ->
model:Wp.WpContext.model -> prover:Wp.VCS.prover -> string
val file_logout :
pid:Wp.WpPropId.prop_id ->
model:Wp.WpContext.model -> prover:Wp.VCS.prover -> string
val file_logerr :
pid:Wp.WpPropId.prop_id ->
model:Wp.WpContext.model -> prover:Wp.VCS.prover -> string
end
module GOAL :
sig
type t
val dummy : Wp.Wpo.GOAL.t
val trivial : Wp.Wpo.GOAL.t
val is_trivial : Wp.Wpo.GOAL.t -> bool
val make : Wp.Conditions.sequent -> Wp.Wpo.GOAL.t
val compute : pid:Wp.WpPropId.prop_id -> Wp.Wpo.GOAL.t -> unit
val compute_proof :
pid:Wp.WpPropId.prop_id -> Wp.Wpo.GOAL.t -> Wp.Lang.F.pred
val compute_descr :
pid:Wp.WpPropId.prop_id -> Wp.Wpo.GOAL.t -> Wp.Conditions.sequent
val get_descr : Wp.Wpo.GOAL.t -> Wp.Conditions.sequent
val qed_time : Wp.Wpo.GOAL.t -> float
end
module VC_Lemma :
sig
type t = {
lemma : Wp.Definitions.dlemma;
depends : Wp.LogicUsage.logic_lemma list;
mutable sequent : Wp.Conditions.sequent option;
}
val is_trivial : Wp.Wpo.VC_Lemma.t -> bool
val cache_descr :
Wp.Wpo.VC_Lemma.t ->
(Wp.VCS.prover * Wp.VCS.result) list -> string
end
module VC_Annot :
sig
type t = {
axioms : Wp.Definitions.axioms option;
goal : Wp.Wpo.GOAL.t;
tags : Wp.Splitter.tag list;
warn : Wp.Warning.t list;
deps : Property.Set.t;
path : Cil_datatype.Stmt.Set.t;
effect : (Cil_types.stmt * Wp.WpPropId.effect_source) option;
}
val is_trivial : Wp.Wpo.VC_Annot.t -> bool
val resolve : pid:Wp.WpPropId.prop_id -> Wp.Wpo.VC_Annot.t -> bool
val cache_descr :
pid:Wp.WpPropId.prop_id ->
Wp.Wpo.VC_Annot.t ->
(Wp.VCS.prover * Wp.VCS.result) list -> string
end
type formula =
GoalLemma of Wp.Wpo.VC_Lemma.t
| GoalAnnot of Wp.Wpo.VC_Annot.t
type po = Wp.Wpo.t
and t = {
po_gid : string;
po_sid : string;
po_name : string;
po_idx : Wp.Wpo.index;
po_model : Wp.WpContext.model;
po_pid : Wp.WpPropId.prop_id;
po_formula : Wp.Wpo.formula;
}
module S :
sig
type t = po
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
module Set :
sig
type elt = t
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val disjoint : t -> t -> bool
val diff : t -> t -> t
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val map : (elt -> elt) -> t -> t
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val min_elt_opt : t -> elt option
val max_elt : t -> elt
val max_elt_opt : t -> elt option
val choose : t -> elt
val choose_opt : t -> elt option
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val find_opt : elt -> t -> elt option
val find_first : (elt -> bool) -> t -> elt
val find_first_opt : (elt -> bool) -> t -> elt option
val find_last : (elt -> bool) -> t -> elt
val find_last_opt : (elt -> bool) -> t -> elt option
val of_list : elt list -> t
val to_seq_from : elt -> t -> elt Seq.t
val to_seq : t -> elt Seq.t
val to_rev_seq : t -> elt Seq.t
val add_seq : elt Seq.t -> t -> t
val of_seq : elt Seq.t -> t
val nearest_elt_le : elt -> t -> elt
val nearest_elt_ge : elt -> t -> elt
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 Map :
sig
type key = t
type +!'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val min_binding_opt : 'a t -> (key * 'a) option
val max_binding : 'a t -> key * 'a
val max_binding_opt : 'a t -> (key * 'a) option
val choose : 'a t -> key * 'a
val choose_opt : 'a t -> (key * 'a) option
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_first : (key -> bool) -> 'a t -> key * 'a
val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
val find_last : (key -> bool) -> 'a t -> key * 'a
val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Seq.t
val to_rev_seq : 'a t -> (key * 'a) Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
val of_seq : (key * 'a) Seq.t -> 'a t
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
module Hashtbl :
sig
type key = t
type !'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : '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 filter_map_inplace :
(key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Seq.t
val to_seq_keys : 'a t -> key Seq.t
val to_seq_values : 'a t -> 'a Seq.t
val add_seq : 'a t -> (key * 'a) Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
val of_seq : (key * 'a) Seq.t -> 'a t
val iter_sorted :
?cmp:(key -> key -> int) ->
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
?cmp:(key -> key -> int) ->
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted_by_entry :
cmp:(key * 'a -> key * 'a -> int) ->
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted_by_entry :
cmp:(key * 'a -> key * 'a -> int) ->
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted_by_value :
cmp:('a -> 'a -> int) -> (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted_by_value :
cmp:('a -> 'a -> int) ->
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val find_opt : 'a t -> key -> 'a option
val find_def : 'a t -> key -> 'a -> 'a
val memo : 'a t -> key -> (key -> 'a) -> 'a
val structural_descr : Structural_descr.t -> Structural_descr.t
val make_type : 'a Type.t -> 'a t Type.t
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
end
module Index : sig type t = index val compare : t -> t -> int end
module Gmap :
sig
type key = index
type +!'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val min_binding_opt : 'a t -> (key * 'a) option
val max_binding : 'a t -> key * 'a
val max_binding_opt : 'a t -> (key * 'a) option
val choose : 'a t -> key * 'a
val choose_opt : 'a t -> (key * 'a) option
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_first : (key -> bool) -> 'a t -> key * 'a
val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
val find_last : (key -> bool) -> 'a t -> key * 'a
val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Seq.t
val to_rev_seq : 'a t -> (key * 'a) Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
val of_seq : (key * 'a) Seq.t -> 'a t
end
val get_gid : Wp.Wpo.t -> string
val get_property : Wp.Wpo.t -> Property.t
val get_index : Wp.Wpo.t -> Wp.Wpo.index
val get_label : Wp.Wpo.t -> string
val get_model : Wp.Wpo.t -> Wp.WpContext.model
val get_scope : Wp.Wpo.t -> Wp.WpContext.scope
val get_context : Wp.Wpo.t -> Wp.WpContext.context
val get_file_logout : Wp.Wpo.t -> Wp.VCS.prover -> string
val get_file_logerr : Wp.Wpo.t -> Wp.VCS.prover -> string
val get_files : Wp.Wpo.t -> (string * string) list
val qed_time : Wp.Wpo.t -> float
val clear : unit -> unit
val remove : Wp.Wpo.t -> unit
val on_remove : (Wp.Wpo.t -> unit) -> unit
val add : Wp.Wpo.t -> unit
val age : Wp.Wpo.t -> int
val reduce : Wp.Wpo.t -> bool
val resolve : Wp.Wpo.t -> bool
val set_result : Wp.Wpo.t -> Wp.VCS.prover -> Wp.VCS.result -> unit
val clear_results : Wp.Wpo.t -> unit
val compute :
Wp.Wpo.t -> Wp.Definitions.axioms option * Wp.Conditions.sequent
val has_verdict : Wp.Wpo.t -> Wp.VCS.prover -> bool
val get_result : Wp.Wpo.t -> Wp.VCS.prover -> Wp.VCS.result
val get_results : Wp.Wpo.t -> (Wp.VCS.prover * Wp.VCS.result) list
val get_proof :
Wp.Wpo.t -> [ `Failed | `Passed | `Unknown ] * Property.t
val get_target : Wp.Wpo.t -> Property.t
val is_trivial : Wp.Wpo.t -> bool
val is_proved : Wp.Wpo.t -> bool
val is_unknown : Wp.Wpo.t -> bool
val is_passed : Wp.Wpo.t -> bool
val warnings : Wp.Wpo.t -> Wp.Warning.t list
val is_valid : Wp.VCS.result -> bool
val get_time : Wp.VCS.result -> float
val get_steps : Wp.VCS.result -> int
val is_tactic : Wp.Wpo.t -> bool
val is_smoke_test : Wp.Wpo.t -> bool
val iter :
?ip:Property.t ->
?index:Wp.Wpo.index ->
?on_axiomatics:(string option -> unit) ->
?on_behavior:(Cil_types.kernel_function -> string option -> unit) ->
?on_goal:(Wp.Wpo.t -> unit) -> unit -> unit
val iter_on_goals : (Wp.Wpo.t -> unit) -> unit
val goals_of_property : Property.t -> Wp.Wpo.t list
val bar : string
val kf_context : Wp.Wpo.index -> Description.kf
val pp_index : Stdlib.Format.formatter -> Wp.Wpo.index -> unit
val pp_warnings : Stdlib.Format.formatter -> Wp.Warning.t list -> unit
val pp_depend : Stdlib.Format.formatter -> Property.t -> unit
val pp_dependency :
Description.kf -> Stdlib.Format.formatter -> Property.t -> unit
val pp_dependencies :
Description.kf -> Stdlib.Format.formatter -> Property.t list -> unit
val pp_goal : Stdlib.Format.formatter -> Wp.Wpo.t -> unit
val pp_title : Stdlib.Format.formatter -> Wp.Wpo.t -> unit
val pp_logfile :
Stdlib.Format.formatter -> Wp.Wpo.t -> Wp.VCS.prover -> unit
val pp_axiomatics : Stdlib.Format.formatter -> string option -> unit
val pp_function :
Stdlib.Format.formatter -> Kernel_function.t -> string option -> unit
val pp_goal_flow : Stdlib.Format.formatter -> Wp.Wpo.t -> unit
val prover_of_name : string -> Wp.VCS.prover option
class type generator =
object
method compute_call : Cil_types.stmt -> Wp.Wpo.t Bag.t
method compute_ip : Property.t -> Wp.Wpo.t Bag.t
method compute_main :
?fct:Wp.Wp_parameters.functions ->
?bhv:string list -> ?prop:string list -> unit -> Wp.Wpo.t Bag.t
method model : Wp.WpContext.model
end
end
module ProverTask :
sig
class printer :
Stdlib.Format.formatter ->
string ->
object
method hline : unit
method lines : unit
method paragraph : unit
method printf :
('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'a
method section : string -> unit
end
val pp_file : message:string -> file:string -> unit
class type pattern =
object
method get_after : ?offset:int -> int -> string
method get_float : int -> float
method get_int : int -> int
method get_string : int -> string
end
val p_group : string -> string
val p_int : string
val p_float : string
val p_string : string
val p_until_space : string
val location : string -> int -> Stdlib.Lexing.position
type logs = [ `BOTH | `ERR | `OUT ]
class virtual command :
string ->
object
method add : string list -> unit
method add_float : name:string -> value:float -> unit
method add_int : name:string -> value:int -> unit
method add_list : name:string -> string list -> unit
method add_parameter : name:string -> (unit -> bool) -> unit
method add_positive : name:string -> value:int -> unit
method command : string list
method pretty : Stdlib.Format.formatter -> unit
method run :
?echo:bool ->
?logout:string -> ?logerr:string -> unit -> int Task.task
method set_command : string -> unit
method timeout : int -> unit
method validate_pattern :
?logs:Wp.ProverTask.logs ->
?repeat:bool ->
Str.regexp -> (Wp.ProverTask.pattern -> unit) -> unit
method validate_time : (float -> unit) -> unit
end
val server : ?procs:int -> unit -> Task.server
val schedule : 'a Task.task -> unit
val spawn :
?monitor:('a option -> unit) ->
?pool:Task.pool ->
all:bool -> smoke:bool -> ('a * bool Task.task) list -> unit
end
module Prover :
sig
val simplify :
?start:(Wp.Wpo.t -> unit) ->
?result:(Wp.Wpo.t -> Wp.VCS.prover -> Wp.VCS.result -> unit) ->
Wp.Wpo.t -> bool Task.task
val prove :
Wp.Wpo.t ->
?config:Wp.VCS.config ->
?mode:Wp.VCS.mode ->
?start:(Wp.Wpo.t -> unit) ->
?progress:(Wp.Wpo.t -> string -> unit) ->
?result:(Wp.Wpo.t -> Wp.VCS.prover -> Wp.VCS.result -> unit) ->
Wp.VCS.prover -> bool Task.task
val spawn :
Wp.Wpo.t ->
delayed:bool ->
?config:Wp.VCS.config ->
?start:(Wp.Wpo.t -> unit) ->
?progress:(Wp.Wpo.t -> string -> unit) ->
?result:(Wp.Wpo.t -> Wp.VCS.prover -> Wp.VCS.result -> unit) ->
?success:(Wp.Wpo.t -> Wp.VCS.prover option -> unit) ->
?pool:Task.pool -> (Wp.VCS.mode * Wp.VCS.prover) list -> unit
end
end