package frama-c

  1. Overview
  2. Docs
package frama-c
Legend:
Library
Module
Module type
Parameter
Class
Class type
type deps_or_unassigned =
  1. | DepsBottom
    (*

    Bottom of the lattice, never bound inside a memory state at a valid location. (May appear for bases for which the validity does not start at 0, currently only NULL.)

    *)
  2. | Unassigned
    (*

    Location has never been assigned

    *)
  3. | AssignedFrom of Deps.t
    (*

    Location guaranteed to have been overwritten, its contents depend on the Deps.t value

    *)
  4. | MaybeAssignedFrom of Deps.t
    (*

    Location may or may not have been overwritten

    *)

The lattice is DepsBottom <= Unassigned, DepsBottom <= AssignedFrom z, Unassigned <= MaybeAssignedFrom and AssignedFrom z <= MaybeAssignedFrom z.

include Lmap_bitwise.With_default with type t = deps_or_unassigned
include Lattice_type.Bounded_Join_Semi_Lattice with type t = deps_or_unassigned
include Lattice_type.Join_Semi_Lattice with type t = deps_or_unassigned

datatype of element of the lattice

include Datatype.S with type t = deps_or_unassigned
include Datatype.S_no_copy with type t = deps_or_unassigned
include Datatype.Ty with type t = deps_or_unassigned
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 : Stdlib.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

val default : t
val subst : (Deps.t -> Deps.t) -> t -> t
val extract_data : t -> Locations.Zone.t
val extract_indirect : t -> Locations.Zone.t
val may_be_unassigned : t -> bool
val compose : t -> t -> t

compose d1 d2 is the sequential composition of d1 after d2, ie. the dependencies needed to execute d1 after having executed d2. It is computed as d1 if d1 = AssignedFrom _ (as executing d1 completely overwrites what d2 wrote), and as a partial join between d1 and d2 in the other cases.

val pretty_precise : Stdlib.Format.formatter -> t -> unit
val to_zone : t -> Locations.Zone.t
val to_deps : t -> Deps.deps
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