package grace

  1. Overview
  2. Docs

Source code ranges, also known as 'locations'.

Grace's ranges are opaque byte index intervals of the form [start, stop) (not including the byte at the stop index) within a given source.

A range is said to be valid if:

  1. All indices are valid.
  2. start <= stop, note that start = stop is permitted, in this case, this denotes an empty range.
  3. stop <= eos, where eos is the end-of-source position, also known as the source length, of source
type t

The abstract type of ranges.

include Ppx_compare_lib.Equal.S with type t := t
include Ppx_compare_lib.Comparable.S with type t := t
include Ppx_hash_lib.Hashable.S with type t := t
val hash_fold_t : t Base__Ppx_hash_lib.hash_fold
val hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_value
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0__.Sexp.t -> t
val sexp_of_t : t -> Sexplib0__.Sexp.t
include Core.Comparable.S with type t := t
include Base.Comparable.S 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
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator : (t, comparator_witness) Base__Comparator.comparator
val validate_lbound : min:t Core.Maybe_bound.t -> t Validate.check
val validate_ubound : max:t Core.Maybe_bound.t -> t Validate.check
val validate_bound : min:t Core.Maybe_bound.t -> max:t Core.Maybe_bound.t -> t Validate.check
module Replace_polymorphic_compare : sig ... end
include Core.Invariant.S with type t := t
val invariant : t Base__Invariant_intf.inv
include Core.Pretty_printer.S with type t := t
val pp : Base__.Formatter.t -> t -> unit
val create : source:Source.t -> int -> int -> t

create ~source start stop builds the range [start, stop) (not including the byte at the ending position) from the byte indices start and stop. A range is empty if its start and stop indices are the same.

  • parameter source

    the associated source of the range.

  • raises Invalid_argument

    if the start is greater than stop or stop is greater than the end-of-source position in source.

val initial : Source.t -> t

initial source is the initial range, namely [0, 0).

val eos : Source.t -> t

eos source is the end-of-source range [eos, eos) for the given source.

val source : t -> Source.t

source t returns the source associated with t.

val start : t -> int

start t returns the byte index of the (inclusive) start position.

val stop : t -> int

stop t returns the byte index of the (exclusive) stop position.

val split : t -> int * int

split t returns the pair of byte indices of t.

val merge : t -> t -> t

merge t1 t2 returns the merged interval [start, stop) where start = min start1 start2 and stop = max stop1 stop2.

  • raises Invalid_argument

    if the two ranges have differing sources. The comparison of sources is performed by Source.equal.

val inter : t -> t -> t

inter t1 t2 returns the intersectional interval [start, stop) where start = min start1 start2 and stop = max stop1 stop2.

  • raises Invalid_argument

    if the two ranges have differing sources. The comparison of sources is performed by Source.equal.

val are_disjoint : t -> t -> bool

are_disjoint t1 t2 returns whether the two ranges t1 and t2 are disjoint.

val contains : t -> int -> bool

contains t idx returns whether the position idx is within the range t.

Support for Lexing

val of_lex : ?source:Source.t -> (Stdlib.Lexing.position * Stdlib.Lexing.position) -> t

of_lex (start, stop) takes a pair of OCaml lexer positions and creates a range. It is equivalent to make ~source:default (Byte_index.of_lex start) (Byte_index.of_lex stop).

  • parameter source

    The source of the new range. The default source is `File start.pos_fname.

  • raises Invalid_argument

    if the optional argument source is not given and start.pos_fname and stop.pos_fname differ. The comparison is done by String.equal without any path canonicalization.

val of_lexbuf : ?source:Source.t -> Stdlib.Lexing.lexbuf -> t

of_lexbuf lexbuf constructs a range from the current lexeme that lexbuf points to. It is of_lex (Lexing.lexeme_start_p lexbuf, Lexing.lexeme_end_p lexbuf).

  • parameter source

    The source of the new range. The default source is `File (Lexing.lexeme_start_p lexbuf).pos_fname.

OCaml

Innovation. Community. Security.