sig
val docHash :
?sep:Pretty_utils.sformat ->
('a, 'b) Pretty_utils.formatter2 ->
('a, 'b) Hashtbl.t Pretty_utils.formatter
val hash_to_list : ('a, 'b) Hashtbl.t -> ('a * 'b) list
val keys : ('a, 'b) Hashtbl.t -> 'a list
val ( $ ) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
val swap : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c
val hash_copy_into : ('a, 'b) Hashtbl.t -> ('a, 'b) Hashtbl.t -> unit
val anticompare : 'a -> 'a -> int
val list_drop : int -> 'a list -> 'a list
val list_droptail : int -> 'a list -> 'a list
val list_span : ('a -> bool) -> 'a list -> 'a list * 'a list
val list_insert_by : ('a -> 'a -> int) -> 'a -> 'a list -> 'a list
val list_head_default : 'a -> 'a list -> 'a
val list_iter3 :
('a -> 'b -> 'c -> unit) -> 'a list -> 'b list -> 'c list -> unit
val get_some_option_list : 'a option list -> 'a list
val list_append : 'a list -> 'a list -> 'a list
val list_iteri : (int -> 'a -> unit) -> 'a list -> unit
val list_mapi : (int -> 'a -> 'b) -> 'a list -> 'b list
val list_fold_lefti : ('a -> int -> 'b -> 'a) -> 'a -> 'b list -> 'a
val int_range_list : int -> int -> int list
val list_init : int -> (int -> 'a) -> 'a list
val list_find_first : 'a list -> ('a -> 'b option) -> 'b option
val list_last : 'a list -> 'a
val mapNoCopy : ('a -> 'a) -> 'a list -> 'a list
val mapNoCopyList : ('a -> 'a list) -> 'a list -> 'a list
val filterNoCopy : ('a -> bool) -> 'a list -> 'a list
val joinStrings : string -> string list -> string
val hasPrefix : string -> string -> bool
val restoreRef : ?deepCopy:('a -> 'a) -> 'a Pervasives.ref -> unit -> unit
val restoreHash :
?deepCopy:('a -> 'a) -> ('b, 'a) Hashtbl.t -> unit -> unit
val restoreIntHash : ?deepCopy:('a -> 'a) -> 'a Inthash.t -> unit -> unit
val restoreArray : ?deepCopy:('a -> 'a) -> 'a array -> unit -> unit
val runThunks : (unit -> unit) list -> unit -> unit
val memoize : ('a, 'b) Hashtbl.t -> 'a -> ('a -> 'b) -> 'b
val findOrAdd : ('a, 'b) Hashtbl.t -> 'a -> ('a -> 'b) -> 'b
val tryFinally : ('a -> 'b) -> ('b option -> unit) -> 'a -> 'b
val valOf : 'a option -> 'a
val out_some : 'a option -> 'a
val opt_map : ('a -> 'b) -> 'a option -> 'b option
val opt_bind : ('a -> 'b option) -> 'a option -> 'b option
val opt_app : ('a -> 'b) -> 'b -> 'a option -> 'b
val opt_iter : ('a -> unit) -> 'a option -> unit
val fold_for : init:'a -> lo:int -> hi:int -> (int -> 'a -> 'a) -> 'a
module type STACK =
sig
type 'a t
exception Empty
val create : unit -> 'a Cilutil.STACK.t
val push : 'a -> 'a Cilutil.STACK.t -> unit
val pop : 'a Cilutil.STACK.t -> 'a
val top : 'a Cilutil.STACK.t -> 'a
val clear : 'a Cilutil.STACK.t -> unit
val copy : 'a Cilutil.STACK.t -> 'a Cilutil.STACK.t
val is_empty : 'a Cilutil.STACK.t -> bool
val length : 'a Cilutil.STACK.t -> int
val iter : ('a -> unit) -> 'a Cilutil.STACK.t -> unit
end
module Stack : STACK
type configData =
ConfInt of int
| ConfBool of bool
| ConfFloat of float
| ConfString of string
| ConfList of Cilutil.configData list
val loadConfiguration : string -> unit
val saveConfiguration : string -> unit
val clearConfiguration : unit -> unit
val setConfiguration : string -> Cilutil.configData -> unit
val findConfiguration : string -> Cilutil.configData
val findConfigurationInt : string -> int
val useConfigurationInt : string -> (int -> unit) -> unit
val findConfigurationBool : string -> bool
val useConfigurationBool : string -> (bool -> unit) -> unit
val findConfigurationString : string -> string
val useConfigurationString : string -> (string -> unit) -> unit
val findConfigurationList : string -> Cilutil.configData list
val useConfigurationList :
string -> (Cilutil.configData list -> unit) -> unit
type symbol = int
val symbolName : Cilutil.symbol -> string
val registerSymbolName : string -> Cilutil.symbol
val registerSymbolRange : int -> (int -> string) -> Cilutil.symbol
val newSymbol : string -> Cilutil.symbol
val resetSymbols : unit -> unit
val snapshotSymbols : unit -> unit -> unit
val dumpSymbols : unit -> unit
module Int32Op :
sig
val ( <% ) : int32 -> int32 -> bool
val ( <=% ) : int32 -> int32 -> bool
val ( >% ) : int32 -> int32 -> bool
val ( >=% ) : int32 -> int32 -> bool
val ( <>% ) : int32 -> int32 -> bool
val ( +% ) : int32 -> int32 -> int32
val ( -% ) : int32 -> int32 -> int32
val ( *% ) : int32 -> int32 -> int32
val ( /% ) : int32 -> int32 -> int32
val ( ~-% ) : int32 -> int32
val sll : int32 -> int32 -> int32
val ( >>% ) : int32 -> int32 -> int32
val ( >>>% ) : int32 -> int32 -> int32
exception IntegerTooLarge
val to_int : int32 -> int
end
val equals : 'a -> 'a -> bool
val locUnknown : Cil_types.location
val get_instrLoc : Cil_types.instr -> Cil_types.location
val get_globalLoc : Cil_types.global -> Cil_types.location
val get_stmtLoc : Cil_types.stmtkind -> Cil_types.location
module StringMap :
sig
type key = String.t
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
end
module StringSet :
sig
type elt = String.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 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 min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val pretty : Format.formatter -> t -> unit
end
module type Mapl =
sig
type key
type +'a t
type 'a map = 'a list Cilutil.Mapl.t
val empty : 'a Cilutil.Mapl.t
val is_empty : 'a Cilutil.Mapl.t -> bool
val add :
Cilutil.Mapl.key ->
'a -> 'a list Cilutil.Mapl.t -> 'a list Cilutil.Mapl.t
val find : Cilutil.Mapl.key -> 'a list Cilutil.Mapl.t -> 'a list
val remove : Cilutil.Mapl.key -> 'a Cilutil.Mapl.t -> 'a Cilutil.Mapl.t
val mem : Cilutil.Mapl.key -> 'a Cilutil.Mapl.t -> bool
val iter :
(Cilutil.Mapl.key -> 'a -> unit) -> 'a Cilutil.Mapl.t -> unit
val map : ('a -> 'b) -> 'a Cilutil.Mapl.t -> 'b Cilutil.Mapl.t
val mapi :
(Cilutil.Mapl.key -> 'a -> 'b) ->
'a Cilutil.Mapl.t -> 'b Cilutil.Mapl.t
val fold :
(Cilutil.Mapl.key -> 'a -> 'b -> 'b) -> 'a Cilutil.Mapl.t -> 'b -> 'b
val fold_range :
(Cilutil.Mapl.key -> Rangemap.fuzzy_order) ->
(Cilutil.Mapl.key -> 'a -> 'b -> 'b) -> 'a Cilutil.Mapl.t -> 'b -> 'b
val compare :
('a -> 'a -> int) -> 'a Cilutil.Mapl.t -> 'a Cilutil.Mapl.t -> int
val equal :
('a -> 'a -> bool) -> 'a Cilutil.Mapl.t -> 'a Cilutil.Mapl.t -> bool
end
module Mapl_Make :
functor (X : Map.OrderedType) ->
sig
type key = X.t
type +'a t
type 'a map = 'a list t
val empty : 'a t
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a list t -> 'a list t
val find : key -> 'a list t -> 'a list
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val fold_range :
(key -> Rangemap.fuzzy_order) ->
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
end
module IntMapl :
sig
type key = int
type 'a map
val empty : 'a Cilutil.IntMapl.map
val add :
Cilutil.IntMapl.key ->
'a -> 'a Cilutil.IntMapl.map -> 'a Cilutil.IntMapl.map
val find : Cilutil.IntMapl.key -> 'a Cilutil.IntMapl.map -> 'a list
end
module Instr :
sig
type t = Cil_types.kinstr
val compare : Cilutil.Instr.t -> Cilutil.Instr.t -> int
val equal : Cilutil.Instr.t -> Cilutil.Instr.t -> bool
val hash : Cilutil.Instr.t -> int
val pretty : Format.formatter -> Cilutil.Instr.t -> unit
val loc : Cilutil.Instr.t -> Cil_types.location
end
module InstrMapl :
sig
type key = Cil_types.kinstr
type +'a t
type 'a map = 'a list t
val empty : 'a t
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a list t -> 'a list t
val find : key -> 'a list t -> 'a list
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val fold_range :
(key -> Rangemap.fuzzy_order) ->
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
end
module InstrHashtbl :
sig
type key = Cil_types.kinstr
type 'a t
val create : int -> 'a t
val clear : '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 fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
module StmtMap :
sig
type key = Cil_types.stmt
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val pretty :
(Format.formatter -> 'a -> unit) -> Format.formatter -> 'a t -> unit
end
module StmtSet :
sig
type elt = Cil_types.stmt
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 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 min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val pretty : Format.formatter -> t -> unit
end
module StmtComparable :
sig
type t = Cil_types.stmt
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
end
module StmtHashtbl :
sig
type key = Cil_types.stmt
type 'a t
val create : int -> 'a t
val clear : '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 fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val pretty : Format.formatter -> 'a t -> unit
end
module KinstrComparable :
sig
type t = Cil_types.kinstr
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
end
module VarinfoComparable :
sig
type t = Cil_types.varinfo
val compare :
Cilutil.VarinfoComparable.t -> Cilutil.VarinfoComparable.t -> int
val hash : Cilutil.VarinfoComparable.t -> int
val equal :
Cilutil.VarinfoComparable.t -> Cilutil.VarinfoComparable.t -> bool
end
module VarinfoHashtbl :
sig
type key = Cil_types.varinfo
type 'a t
val create : int -> 'a t
val clear : '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 fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
module VarinfoMap :
sig
type key = Cil_types.varinfo
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
end
module VarinfoSet :
sig
type elt = Cil_types.varinfo
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 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 min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
end
module LogicVarComparable :
sig
type t = Cil_types.logic_var
val compare :
Cilutil.LogicVarComparable.t -> Cilutil.LogicVarComparable.t -> int
val hash : Cilutil.LogicVarComparable.t -> int
val equal :
Cilutil.LogicVarComparable.t -> Cilutil.LogicVarComparable.t -> bool
end
module LogicVarHashtbl :
sig
type key = Cil_types.logic_var
type 'a t
val create : int -> 'a t
val clear : '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 fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
module LogicVarMap :
sig
type key = Cil_types.logic_var
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
end
module LogicVarSet :
sig
type elt = Cil_types.logic_var
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 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 min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
end
module FieldinfoComparable :
sig
type t = Cil_types.fieldinfo
val compare :
Cilutil.FieldinfoComparable.t -> Cilutil.FieldinfoComparable.t -> int
val hash : Cilutil.FieldinfoComparable.t -> int
val equal :
Cilutil.FieldinfoComparable.t ->
Cilutil.FieldinfoComparable.t -> bool
end
module FieldinfoHashtbl :
sig
type key = Cil_types.fieldinfo
type 'a t
val create : int -> 'a t
val clear : '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 fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
module FieldinfoSet :
sig
type elt = Cil_types.fieldinfo
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 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 min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
end
module FieldinfoMap :
sig
type key = Cil_types.fieldinfo
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
end
val pTypeSig : (Cil_types.typ -> Cil_types.typsig) Pervasives.ref
module TypeComparable :
sig
type t = Cil_types.typ
val compare :
Cilutil.TypeComparable.t -> Cilutil.TypeComparable.t -> int
val hash : Cilutil.TypeComparable.t -> int
val equal :
Cilutil.TypeComparable.t -> Cilutil.TypeComparable.t -> bool
end
module TypeHashtbl :
sig
type key = Cil_types.typ
type 'a t
val create : int -> 'a t
val clear : '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 fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
end
module TypeSet :
sig
type elt = Cil_types.typ
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 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 min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
end
module LvalComparable :
sig
type t = Cil_types.lval
val compare :
Cilutil.LvalComparable.t -> Cilutil.LvalComparable.t -> int
end
module LvalSet :
sig
type elt = Cil_types.lval
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 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 min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
end
val printStages : bool Pervasives.ref
val print_list :
(Format.formatter -> unit -> unit) ->
(Format.formatter -> 'a -> unit) -> Format.formatter -> 'a list -> unit
val print_if :
bool -> Format.formatter -> (Format.formatter -> unit -> unit) -> unit
val comma : Format.formatter -> unit -> unit
val underscore : Format.formatter -> unit -> unit
val semi : Format.formatter -> unit -> unit
val space : Format.formatter -> unit -> unit
val alt : Format.formatter -> unit -> unit
val newline : Format.formatter -> unit -> unit
val arrow : Format.formatter -> unit -> unit
val nothing : Format.formatter -> unit -> unit
val pretty_list :
(Format.formatter -> unit) ->
(Format.formatter -> 'a -> unit) -> Format.formatter -> 'a list -> unit
val pretty_list_del :
(Format.formatter -> unit) ->
(Format.formatter -> unit) ->
(Format.formatter -> unit) ->
(Format.formatter -> 'a -> unit) -> Format.formatter -> 'a list -> unit
val pretty_opt :
(Format.formatter -> 'a -> unit) -> Format.formatter -> 'a option -> unit
val space_sep : string -> Format.formatter -> unit
val nl_sep : Format.formatter -> unit
type opaque_term_env = {
term_lhosts : Cil_types.term_lhost Cilutil.VarinfoMap.t;
terms : Cil_types.term Cilutil.VarinfoMap.t;
vars : Cil_types.logic_var Cilutil.VarinfoMap.t;
}
type opaque_exp_env = { exps : Cil_types.exp Cilutil.VarinfoMap.t; }
end