Module Sexp.AnnotatedSource

Module for parsing S-expressions annotated with location information

Sourcetype pos = Pre_sexp.Annotated.pos = {
  1. line : int;
  2. col : int;
  3. offset : int;
}

Position information for annotated S-expressions

Sourcetype range = Pre_sexp.Annotated.range = {
  1. start_pos : pos;
  2. end_pos : pos;
}

Range information for annotated S-expressions

Sourcetype t = Pre_sexp.Annotated.t =
  1. | Atom of range * Type.t
  2. | List of range * t list * Type.t

S-expression annotated with location information

Sourcetype 'a conv = [
  1. | `Result of 'a
  2. | `Error of exn * t
]

Type of conversion results of annotated S-expressions.

Sourceval sexp_of_conv : ('a -> Type.t) -> 'a conv -> Type.t
Sourceexception Conv_exn of string * exn

Exception associated with conversion errors. First argument describes the location, the second the reason.

Sourcetype stack = Pre_sexp.Annotated.stack = {
  1. mutable positions : pos list;
  2. mutable stack : t list list;
}

Stack used by annotation parsers

Sourceval get_sexp : t -> Type.t

get_sexp annot_sexp

  • returns

    S-expression associated with annotated S-expression annot_sexp.

Sourceval get_range : t -> range

get_range annot_sexp

  • returns

    the range associated with annotated S-expression annot_sexp.

Sourceval find_sexp : t -> Type.t -> t option

find_sexp annot_sexp sexp

  • returns

    Some res where res is the annotated S-expression that is physically equivalent to sexp in annot_sexp, or None if there is no such S-expression.

Annotated (partial) parsing
Sourceval parse : ?parse_pos:Parse_pos.t -> ?len:int -> string -> (string, t) parse_result

parse ?parse_pos ?len str same as parse, but returns an S-expression annotated with location information.

Sourceval parse_bigstring : ?parse_pos:Parse_pos.t -> ?len:int -> bigstring -> (bigstring, t) parse_result

parse_bigstring ?parse_pos ?len str same as parse_bigstring, but returns an S-expression annotated with location information.

Sourceval input_sexp : ?parse_pos:Parse_pos.t -> in_channel -> t

input_sexp ?parse_pos ic like input_sexp, but returns an annotated S-expression instead.

Sourceval input_sexps : ?parse_pos:Parse_pos.t -> ?buf:bytes -> in_channel -> t list

input_sexps ?parse_pos ?buf ic like input_sexps, but returns a list of annotated S-expressions.

Sourceval input_rev_sexps : ?parse_pos:Parse_pos.t -> ?buf:bytes -> in_channel -> t list

input_sexps ?parse_pos ?buf ic like input_rev_sexps, but returns a list of annotated S-expressions.

Loading of annotated S-expressions

NOTE: these functions should only be used if an annotated S-expression is required.

Sourceval load_sexp : ?strict:bool -> ?buf:bytes -> string -> t

load_sexp ?strict ?buf file like load_sexp, but returns an annotated S-expression.

Sourceval load_sexps : ?buf:bytes -> string -> t list

load_sexps ?buf file like load_sexps, but returns a list of annotated S-expressions.

Sourceval load_rev_sexps : ?buf:bytes -> string -> t list

load_rev_sexps ?buf file like load_rev_sexps, but returns a list of annotated S-expressions.

String and bigstring conversions
Sourceval of_string : string -> t

of_string str same as of_string, but returns an annotated S-expression.

Sourceval of_bigstring : bigstring -> t

of_bigstring bstr same as of_string, but operates on bigstrings.

Converters using annotations for determining error locations

Sourceval conv : (Type.t -> 'a) -> t -> 'a conv

conv f annot_sexp converts the S-expression associated with annotated S-expression annot_sexp using f.

  • returns

    `Result res on success, or `Error (exn, sub_annot_sexp) otherwise, where exn is the exception associated with the conversion error, and sub_annot_sexp is the annotated S-expression on which conversion failed.

Sourceval get_conv_exn : file:string -> exc:exn -> t -> exn

get_conv_exn ~file ~exc annot_sexp

  • returns

    the exception that would be raised for a given file and exception exc if conversion had failed on annotated S-expression annot_sexp. The format of the exception message is "file:line:col"