package bap-core-theory

  1. Overview
  2. Docs

A target-specific role of program entities.

An extensible enumeration for target and application-specific roles of variables, registers, and other entities.

  • since 2.3.0
type t = role
module Register : sig ... end

Common roles for registers.

include KB.Enum.S with type t := t
val declare : ?package:string -> string -> t

declare ?package name declares a new element of the enumeration.

Fails if the name is already declared.

val read : ?package:string -> string -> t

read ?package name reads the element from its textual representation.

Fails if the name doesn't represent a previously declared element of the enumeration.

If name is unqualified then package is used as the package name. The package itself defaults to "user".

See also of_string s from the Stringable interface which is equal to read s

name x is the name that corresponds to the element x

val unknown : t

unknown is the placeholder for unknown element.

val is_unknown : t -> bool

is_unknown t is true if t is unknown.

domain the type class implementing the domain structure.

Each enumeration type forms a flat domain with the unknown element at the bottom.

persistent the persistance type class.

The enumeration types are persistent and are derived from the KB.Name.persistent type class, i.e., they are represented as 63-bit numbers.

val hash : t -> int

the hash value of the enum

val members : unit -> t list

members () the list of all members of the enumeration type.

include Base.Comparable.S with type t := t
include Base.Comparisons.S with type t := t
include Base.Comparisons.Infix with type t := t
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (<>) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool

between t ~low ~high means low <= t <= high

val clamp_exn : t -> min:t -> max:t -> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t -> min:t -> max:t -> t Base.Or_error.t
include Base.Comparator.S with type t := t
type comparator_witness
include Core_kernel.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
include Core_kernel.Stringable.S with type t := t
val of_string : string -> t
val to_string : t -> string
include Core_kernel.Pretty_printer.S with type t := t
val pp : Base.Formatter.t -> t -> unit
include Core_kernel.Sexpable.S with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t

Innovation. Community. Security.