Module Omod_support.Cobj

Compilation objects

Package identifiers

type pkg_id = string * Omod.fpath

The type for package identifiers. A package name and its root directory.

val pp_pkg_id : Stdlib.Format.formatter -> pkg_id -> unit

pp_pkg_id formats package identifiers.

Dependencies

type dep = string * Digest.t option

The type for compilation object dependencies. A module name and an optional interface digest.

val pp_dep : Stdlib.Format.formatter -> dep -> unit

pp_dep formats a dependency.

Specifications

val spec_of_string : string -> ( string option * string * string list, string ) Stdlib.result

spec_of_string s parses a compilation object specification from s. This parses the [PKG.]M(@VARIANT)+ syntax.

Compilation objects

type kind =
| Cmi
| Cmo
| Cmx

The type for kind of compilation objects.

val kind_of_string : string -> kind option

kind_of_string s parses s into a kind.

val kind_to_string : kind -> string

kind_to_string k is k as a string.

val exts : Omod.Private.String.Set.t

exts are the file extensions of compilation objects.

type t

The type for compilation objects.

val v : kind:kind -> pkg_id:pkg_id -> name:string -> iface_digest:Digest.t option -> iface_deps:dep list -> in_archive:bool -> path:Omod.fpath -> path_loads:t list Stdlib.Lazy.t -> t

v is a compilation object with the given parameters, see the documentation of accessors for semantics.

val add_file : pkg_id:pkg_id -> t list -> Omod.fpath -> ( t list, string ) Stdlib.result

add_file ~pkg_id acc f adds the compilation objects of file f in package pkg_id to acc. If f's extension doesn't match a supported compilation object file this is acc.

val kind : t -> kind

kind c is c's kind.

val pkg_id : t -> pkg_id

pkg_id c is c's package identifier.

val name : t -> string

name c is c's capitalized module name (more precisely compilation unit name).

val variant : t -> string

variant c is c's variant.

val iface_digest : t -> Digest.t option

iface_digest c is c's interface digest (if any).

val iface_deps : t -> dep list

iface_deps c is c's interface dependencies.

val in_archive : t -> bool

in_archive c is true if path is an object archive.

val path : t -> Omod.fpath

path c is c's file path.

val path_loads : t -> t list

path_loads c are all the objects that are loaded whenever path is loaded (includes c itself). For paths that point to archives this has all the objects of the archive.

val to_dep : t -> dep

to_dep c is c as an interface dependency.

Predicates

val is_kind : kind -> t -> bool

is_kind k c is true iff kind c = k.

val equal : t -> t -> bool

equal c c' tests c and c' for equality (all components must match).

val compare : t -> t -> int

compare is a total order compatible with equal.

val ui_compare : t -> t -> int

ui_compare orders by name, package, variant and path.

Formatters

val pp : Stdlib.Format.formatter -> t -> unit

pp formats a compilation object.

Indexes and dependency resolvers

module Index : sig ... end

Compilation object indexes.

type res = t Omod.Private.String.Map.t

The type for dependency resolutions. Maps module names to their resolved object.

val resolve_deps : variants:Omod.Private.String.Set.t -> sat:( t -> bool ) -> kind:kind -> Index.t -> root_alts:t list list -> ( res list, string ) Stdlib.result

resolve_deps ~variants ~sat ~kind i roots is a list of resolutions that recursively resolve the dependencies of the alternative root object roots root_alts to compilation objects of kind kind and satisfying sat using the twists of Index.cobjs_for_dep_res.

val fold_res : res -> ( t -> 'a -> 'a ) -> 'a -> 'a

fold_res res f acc folds f with acc over the partial dependency order of res raises Invalid_argument if the dependencies of objects in res are not defined in res, this can't happen if the map is a result of resolve_deps.

val loads : variants:Omod.Private.String.Set.t -> sat:( t -> bool ) -> kind:kind -> Index.t -> root_alts:t list list -> ( Omod.fpath list list, string ) Stdlib.result

loads ~sat ~kind i root_alts resolves the alternative root objects roots root_alts to alternative load sequences of object paths of that have objects of kind kind or Cmis (mli-only modules). All the objects involved in the load sequence satisfy sat.