package frama-c

  1. Overview
  2. Docs
On This Page
  1. Folding
package frama-c
Legend:
Library
Module
Module type
Parameter
Class
Class type

Association between bases and ranges of bits.

type map_t
type t = private
  1. | Top of Base.SetLattice.t * Origin.t
  2. | Map of map_t
include Datatype.S_with_collections with type t := t
include Datatype.S with type t := t
include Datatype.S_no_copy with type t := t
include Datatype.Ty with type t := t
module Set : Datatype.Set with type elt = t
module Map : Datatype.Map with type key = t
module Hashtbl : Datatype.Hashtbl with type key = t
val pretty_debug : t Pretty_utils.formatter
include Lattice_type.Bounded_Join_Semi_Lattice with type t := t
include Lattice_type.Join_Semi_Lattice with type t := t

datatype of element of the lattice

include Datatype.S with type t := t
include Datatype.S_no_copy with type t := t
include Datatype.Ty with type t := t
val ty : t Type.t
val name : string

Unique name of the datatype.

val descr : t Descr.t

Datatype descriptor.

val packed_descr : Structural_descr.pack

Packed version of the descriptor.

val reprs : t list

List of representants of the descriptor.

val equal : t -> t -> bool

Equality: same spec than Stdlib.(=).

val compare : t -> t -> int

Comparison: same spec than Stdlib.compare.

val hash : t -> int

Hash function: same spec than Hashtbl.hash.

val pretty : Format.formatter -> t -> unit

Pretty print each value in an user-friendly way.

val mem_project : (Project_skeleton.t -> bool) -> t -> bool

mem_project f x must return true iff there is a value p of type Project.t in x such that f p returns true.

val copy : t -> t

Deep copy: no possible sharing between x and copy x.

val join : t -> t -> t

over-approximation of union

val is_included : t -> t -> bool

is first argument included in the second?

val bottom : t

smallest element

include Lattice_type.With_Top with type t := t
val top : t

largest element

include Lattice_type.With_Narrow with type t := t
val narrow : t -> t -> t

over-approximation of intersection

include Lattice_type.With_Under_Approximation with type t := t

under-approximation of union

val meet : t -> t -> t

under-approximation of intersection

include Lattice_type.With_Diff with type t := t
val diff : t -> t -> t

diff t1 t2 is an over-approximation of t1-t2. t2 must be an under-approximation or exact.

val is_bottom : t -> bool
val inject : Base.t -> Int_Intervals.t -> t
val find_lonely_key : t -> Base.t * Int_Intervals.t
val find_or_bottom : Base.t -> map_t -> Int_Intervals.t
val find : Base.t -> t -> Int_Intervals.t
val mem_base : Base.t -> t -> bool

mem_base b m returns true if b is associated to something or topified in t, and false otherwise.

  • since Carbon-20101201
val get_bases : t -> Base.SetLattice.t

Returns the bases contained by the given zone. Never fails, but may return Base.SetLattice.Top.

val intersects : t -> t -> bool
val valid_intersects : t -> t -> bool

Assuming that z1 and z2 only contain valid bases, valid_intersects z1 z2 returns true iff z1 and z2 have a valid intersection.

Folding

val filter_base : (Base.t -> bool) -> t -> t

filter_base can't raise Error_Top since it filters bases of Top bases. Note: the filter may give an over-approximation (in the case Top Top).

val fold_bases : (Base.t -> 'a -> 'a) -> t -> 'a -> 'a

fold_bases folds also bases of Top bases.

  • raises Error_Top

    in the case Top Top.

val fold_i : (Base.t -> Int_Intervals.t -> 'a -> 'a) -> t -> 'a -> 'a

fold_i f l acc folds l by base.

  • raises Error_Top

    in the cases Top Top, Top bases.

val fold_topset_ok : (Base.t -> Int_Intervals.t -> 'a -> 'a) -> t -> 'a -> 'a

fold_i f l acc folds l by base.

  • raises Error_Top

    in the case Top Top.

val cached_fold : cache_name:string -> temporary:bool -> f:(Base.t -> Int_Intervals.t -> 'b) -> projection:(Base.t -> Int_Intervals.t) -> joiner:('b -> 'b -> 'b) -> empty:'b -> t -> 'b
val fold2_join_heterogeneous : cache:Hptmap_sig.cache_type -> empty_left:('a Hptmap.Shape(Base.Base).t -> 'b) -> empty_right:(t -> 'b) -> both:(Base.t -> Int_Intervals.t -> 'a -> 'b) -> join:('b -> 'b -> 'b) -> empty:'b -> t -> 'a Hptmap.Shape(Base.Base).t -> 'b

Misc

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct