module type S = sig
.. end
type
t = Type.t
=
| |
Atom of string |
| |
List of t list |
Type of S-expressions
Defaults
val default_indent : int Pervasives.ref
default_indent
reference to default indentation level for
human-readable conversions. Initialisation value: 2.
S-expression size
val size : t -> int * int
size sexp
Returns (n_atoms, n_chars)
, where n_atoms
is
the number of atoms in S-expression sexp
, and n_chars
is the
number of characters in the atoms of the S-expression.
Scan functions
val scan_sexp : ?buf:Buffer.t -> Lexing.lexbuf -> t
scan_sexp ?buf lexbuf
scans an S-expression from lex buffer
lexbuf
using the optional string buffer buf
for storing
intermediate strings.
val scan_sexps : ?buf:Buffer.t -> Lexing.lexbuf -> t list
scan_sexps ?buf lexbuf
reads a list of whitespace separated
S-expressions from lex buffer lexbuf
using the optional string
buffer buf
for storing intermediate strings.
val scan_iter_sexps : ?buf:Buffer.t -> f:(t -> unit) -> Lexing.lexbuf -> unit
scan_iter_sexps ?buf ~f lexbuf
iterates over all whitespace
separated S-expressions scanned from lex buffer lexbuf
using
function f
, and the optional string buffer buf
for storing
intermediate strings.
val scan_fold_sexps : ?buf:Buffer.t ->
f:('a -> t -> 'a) -> init:'a -> Lexing.lexbuf -> 'a
scan_fold_sexps ?buf ~f ~init lexbuf
folds over all whitespace
separated S-expressions scanned from lex buffer lexbuf
using
function f
, initial state init
, and the optional string buffer
buf
for storing intermediate strings.
val scan_cnv_sexps : ?buf:Buffer.t -> f:(t -> 'a) -> Lexing.lexbuf -> 'a list
scan_cnv_sexps ?buf ~f lexbuf
maps all whitespace separated
S-expressions scanned from lex buffer lexbuf
to some list using
function f
, and the optional string buffer buf
for storing
intermediate strings.
(Partial) parsing
type
parse_pos = private Pre_sexp.parse_pos
= private {
|
mutable text_line : int ; |
|
mutable text_char : int ; |
|
mutable buf_pos : int ; |
}
Position information after complete parse
type 'a
parse_result = 'a Pre_sexp.parse_result
=
Type of result from calling Sexp.parse
.
type 'a
parse_fun = pos:int -> len:int -> 'a -> 'a parse_result
Type of parsing functions with given offsets and lengths.
type
parse_state = private Pre_sexp.parse_state
= private {
|
parse_pos : parse_pos ; |
|
mutable pstack : t list list ; |
|
pbuf : Buffer.t ; |
}
Type of state maintained during parsing
type
parse_error = Pre_sexp.parse_error
= {
|
location : string ; |
|
err_msg : string ; |
|
parse_state : parse_state ; |
}
Type of parse errors
exception Parse_error of parse_error
Exception raised during partial parsing
val parse : ?text_line:int ->
?text_char:int ->
?pos:int -> ?len:int -> string -> string parse_result
parse ?text_line ?text_char ?pos ?len str
(partially) parses an
S-expression in string buffer str
starting at position pos
and reading at most len
characters. The text position can be
initialized with text_line
and text_char
. To parse a single
atom that is not delimited by whitespace it is necessary to call
this function a second time with the returned continuation, and a
dummy buffer that contains whitespace.
text_line
: default = 1
text_char
: default = 1
pos
: default = 0
len
: default = String.length str - pos
type
bstr = (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
val parse_bstr : ?text_line:int ->
?text_char:int ->
?pos:int ->
?len:int -> bstr -> bstr parse_result
parse_bstr ?text_line ?text_char ?pos ?len str
same as
Sexp_intf.S.parse
,
but operates on bigstrings.
val input_sexp : ?text_line:int ->
?text_char:int -> ?buf_pos:int -> Pervasives.in_channel -> t
input_sexp ?text_line ?text_char ?buf_pos ic
parses an S-expression
from input channel ic
using initial position information
text_line
, text_char
, and buf_pos
. NOTE: this function is not
as fast on files as Sexp.load_sexp
, and is also slightly slower
than the scan-functions. But it is guaranteed that input_sexp
is only going to read data parseable as an S-expression. Thus,
subsequent input functions will see the data immediately following it.
text_line
: default = 1
text_char
: default = 1
buf_pos
: default = 0
val input_sexps : ?text_line:int ->
?text_char:int ->
?buf_pos:int -> ?buf:string -> Pervasives.in_channel -> t list
input_sexps ?text_line ?text_char ?buf_pos ??buf ic
parses
whitespace separated S-expressions from input channel ic
until
EOF is reached. Faster than the scan-functions. NOTE: buf_pos
is the initial global buffer position used for locating errors and
does not refer to buf
.
text_line
: default = 1
text_char
: default = 1
buf_pos
: default = 0
val input_rev_sexps : ?text_line:int ->
?text_char:int ->
?buf_pos:int -> ?buf:string -> Pervasives.in_channel -> t list
input_rev_sexps ?buf ic
same as Sexp.input_sexps
, but returns a
reversed list of S-expressions, which is slightly more efficient.
Loading
val load_sexp : ?buf:string -> string -> t
load_sexp ?buf file
reads one S-expression from file
file
using
buffer
buf
for storing intermediate data. Ignores any trailing
data. Faster than the scan-functions.
RaisesParse_error
if the S-expression is unparseable.
Failure
if parsing reached the end of file before one
S-expression could be read.
val load_sexps : ?buf:string -> string -> t list
load_sexps file
reads a list of whitespace separated S-expressions
from file
file
using buffer
buf
for storing intermediate data.
Faster than the scan-functions.
RaisesParse_error
if there is unparseable data in the file.
Failure
if parsing reached the end of file before the last
S-expression could be fully read.
val load_rev_sexps : ?buf:string -> string -> t list
load_rev_sexps file
same as Sexp.load_sexps
, but returns a
reversed list of S-expressions, which is slightly more efficient.
Output of S-expressions to I/O-channels
val output_hum : Pervasives.out_channel -> t -> unit
output_hum oc sexp
outputs S-expression sexp
to output channel
oc
in human readable form.
val output_hum_indent : int -> Pervasives.out_channel -> t -> unit
output_hum_indent indent oc sexp
outputs S-expression sexp
to output channel oc
in human readable form using indentation level
indent
.
val output_mach : Pervasives.out_channel -> t -> unit
output_mach oc sexp
outputs S-expression sexp
to output channel
oc
in machine readable (i.e. most compact) form.
val output : Pervasives.out_channel -> t -> unit
output oc sexp
same as output_mach
.
Output of S-expressions to file
val save_hum : string -> t -> unit
save_hum file sexp
outputs S-expression sexp
to file
file
in human readable form.
val save_mach : string -> t -> unit
save_mach file sexp
outputs S-expression sexp
to file
file
in machine readable (i.e. most compact) form.
val save : string -> t -> unit
save file sexp
same as save_mach
.
val save_sexps : string -> t list -> unit
save_sexps file sexps
outputs S-expression list sexps
to file
file
in machine readable form, each sexp is followed by a newlnie.
Output of S-expressions to formatters
val pp_hum : Format.formatter -> t -> unit
pp_hum ppf sexp
outputs S-expression sexp
to formatter ppf
in human readable form.
val pp_hum_indent : int -> Format.formatter -> t -> unit
pp_hum_indent n ppf sexp
outputs S-expression sexp
to formatter
ppf
in human readable form and indentation level n
.
val pp_mach : Format.formatter -> t -> unit
pp_mach ppf sexp
outputs S-expression sexp
to formatter ppf
in machine readable (i.e. most compact) form.
val pp : Format.formatter -> t -> unit
pp ppf sexp
same as pp_mach
.
String and bigstring conversions
val of_string : string -> t
of_string str
converts string
str
to an S-expression. NOTE:
trailing whitespace is considered an error, which may be overly
strict for some applications. Either strip the string of trailing
whitespace first, or, even cheaper, use
Sexp_intf.S.parse
instead.
val of_bstr : bstr -> t
val to_string_hum : ?indent:int -> t -> string
to_string_hum ?indent sexp
converts S-expression sexp
to a
string in human readable form with indentation level indent
.
indent
: default = !default_indent
val to_string_mach : t -> string
to_string_mach sexp
converts S-expression sexp
to a string in
machine readable (i.e. most compact) form.
val to_string : t -> string
to_string sexp
same as to_string_mach
.
Buffer conversions
val to_buffer_hum : buf:Buffer.t -> ?indent:int -> t -> unit
to_buffer_hum ~buf ?indent sexp
outputs the S-expression sexp
converted to a string in human readable form to buffer buf
.
indent
: default = !default_indent
val to_buffer_mach : buf:Buffer.t -> t -> unit
to_buffer_mach ~buf sexp
outputs the S-expression sexp
converted
to a string in machine readable (i.e. most compact) form to buffer buf
.
val to_buffer : buf:Buffer.t -> t -> unit
Utilities for automated type conversions
val unit : t
unit
the unit-value as expressed by an S-expression.
val sexp_of_t : t -> t
sexp_of_t sexp
maps S-expressions which are part of a type with
automated S-expression conversion to themselves.
val t_of_sexp : t -> t
t_of_sexp sexp
maps S-expressions which are part of a type with
automated S-expression conversion to themselves.
Utilities for conversion error handling
type
found = [ `Found | `Pos of int * found ]
Type of successful search results. `Found
means that an
S-expression was found at the immediate position, and `Pos (pos,
found)
indicates that it was found at position pos
within a
structure (= S-expression list) where found
describes recursively
where it was found in that structure.
type
search_result = [ `Found | `Not_found | `Pos of int * found ]
Type of search results. `Not_found
means that an
S-expression was not found within another S-expression.
val search_physical : t -> contained:t -> search_result
search_physical sexp ~contained
Returns the search result
indicating whether, and if, where the S-expression contained
was found within S-expression sexp
.
val subst_found : t -> subst:t -> found -> t
subst_found sexp ~subst found
Returns the S-expression that
results from substituting subst
within S-expression sexp
at the location described by found
.