Code for managing s-expressions
Type of bigstrings
default_indent
reference to default indentation level for
human-readable conversions. Initialisation value: 2.
size sexp
(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_sexp ?buf lexbuf
scans an S-expression from lex buffer
lexbuf
using the optional string buffer buf
for storing
intermediate strings.
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.
scan_rev_sexps ?buf lexbuf
same as scan_sexps, but returns the
reversed list and is slightly more efficient.
scan_sexp_opt ?buf lexbuf
is equivalent to scan_sexp ?buf lexbuf
except that it returns None
when the eof is reached.
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.
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.
scan_sexps_conv ?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.
(* |
Done (t, parse_pos) finished parsing
an S-expression. Current parse position
is parse_pos .
|
*) | |
(* |
Cont (cont_state, parse_fun) met the end of input before completely
parsing an S-expression. The user has to call parse_fun to
continue parsing the S-expression in another buffer. cont_state
is the current parsing state of the continuation.
NOTE: the continuation may only be called once and will raise
Failure otherwise!
|
*) |
Type of result from calling Sexplib.Sexp.parse.
Type of parsing functions with given offsets and lengths.
: Parse_pos.t | ; | (* | Current parse position | *) | |
: 't | ; | (* | Stack of found S-expression lists | *) | |
: Buffer.t | ; | (* | Current atom buffer | *) |
Type of state maintained during parsing
: string | ; | (* | Function in which the parse failed | *) | |
: string | ; | (* | Reason why parsing failed | *) | |
: [ ] | ; | (* | State of parser | *) |
Type of parse errors
parse ?parse_pos ?len str
(partially) parses an S-expression in string buffer
str
starting out with position information provided in parse_pos
and reading at
most len
characters. 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.
parse
starts parsing str
at position parse_pos.buf_pos
. Each subsequent
parse_fun
from a Cont
uses the buf
and pos
that is supplied to it. The
final parse_fun
that returns Done
mutates the buf_pos
in the originally
supplied parse_pos
, and then returns it.
Parse_pos.create ()
String.length str - parse_pos.Parse_pos.buf_pos
parse_bigstring ?parse_pos ?len str
same as parse, but operates on
bigstrings.
input_sexp ?parse_pos ic
parses an S-expression from input channel
ic
using initial position information in parse_pos
. NOTE: this
function is not as fast on files as Sexplib.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.
Parse_pos.create ()
input_sexps ?parse_pos ?buf ic
parses whitespace separated
S-expressions from input channel ic
until EOF is reached. Faster than
the scan-functions.
Parse_pos.create ()
input_rev_sexps ?parse_pos ?buf ic
same as Sexplib.Sexp.input_sexps,
but returns a reversed list of S-expressions, which is slightly more
efficient.
load_sexp ?strict ?buf file
reads one S-expression from file
using
buffer buf
for storing intermediate data. Faster than the
scan-functions.
strict
is true and there is more than one
S-expression in the file.
true
load_sexps ?buf file
reads a list of whitespace separated S-expressions
from file
using buffer buf
for storing intermediate data.
Faster than the scan-functions.
load_rev_sexps ?buf file
same as Sexplib.Sexp.load_sexps, but returns a
reversed list of S-expressions, which is slightly more efficient.
load_sexp_conv ?strict ?buf file f
like Sexplib.Sexp.load_sexp, but
performs a conversion on the fly using f
. Performance is equivalent
to executing Sexplib.Sexp.load_sexp and performing conversion when there
are no errors. In contrast to the plain S-expression loader, this
function not only performs the conversion, it will give exact error
ranges for conversion errors.
load_sexp_conv_exn ?strict ?buf file f
like load_sexp_conv,
but returns the converted value or raises Of_sexp_error
with exact
location information in the case of a conversion error.
load_sexps_conv ?buf file f
like Sexplib.Sexp.load_sexps, but performs
a conversion on the fly using f
. Performance is equivalent to
executing Sexplib.Sexp.load_sexps and performing conversion when there
are no errors. In contrast to the plain S-expression loader, this
function not only performs the conversion, it will give exact error
ranges for conversion errors.
load_sexps_conv_exn ?buf file f
like load_sexps_conv, but returns
the converted value or raises Of_sexp_error
with exact location
information in the case of a conversion error.
NOTE: for performance reasons these output functions may need to allocate large strings to write out huge S-expressions. This may cause problems on 32-bit platforms. If you think that you may need to write huge S-expressions on such platforms, you might want to use the pretty-printers that write to formatters instead (see further below).
output_hum oc sexp
outputs S-expression sexp
to output channel
oc
in human readable form.
output_hum_indent indent oc sexp
outputs S-expression sexp
to output channel oc
in human readable form using indentation level
indent
.
output_mach oc sexp
outputs S-expression sexp
to output channel
oc
in machine readable (i.e. most compact) form.
output oc sexp
same as output_mach
.
All save-functions write to a temporary file before moving it into place to avoid intermittent garbling of existing files, which may cause problems for other processes that try to read.
save_hum ?perm file sexp
outputs S-expression sexp
to file
in human
readable form.
save_mach ?perm file sexp
outputs S-expression sexp
to file
in machine readable (i.e. most compact) form.
save_sexps_hum ?perm file sexps
outputs S-expression list sexps
to
file
in human readable form, each sexp being followed by a newline.
save_sexps_mach ?perm file sexps
outputs S-expression list sexps
to
file
in machine readable form, each sexp being followed by a
newline.
save_sexps ?perm file sexp
same as save_sexps_mach.
pp_hum ppf sexp
outputs S-expression sexp
to formatter ppf
in human readable form.
pp_hum_indent n ppf sexp
outputs S-expression sexp
to formatter
ppf
in human readable form and indentation level n
.
pp_mach ppf sexp
outputs S-expression sexp
to formatter ppf
in machine readable (i.e. most compact) form.
pp ppf sexp
same as pp_mach
.
of_string_conv str conv
like of_string, but performs type conversion
with conv
.
of_string_conv_exn str conv
like of_string_conv, but raises
Of_string_conv_exn.E if type conversion fails.
of_bigstring_conv bstr conv
like of_bigstring, but performs
type conversion with conv
.
of_bigstring_conv_exn bstr conv
like of_bigstring_conv, but raises
Of_string_conv_exn.E if type conversion fails.
to_string_hum ?indent sexp
converts S-expression sexp
to a
string in human readable form with indentation level indent
.
!default_indent
to_string_mach sexp
converts S-expression sexp
to a string in
machine readable (i.e. most compact) form.
to_string sexp
same as to_string_mach
.
to_buffer_hum ~buf ?indent sexp
outputs the S-expression sexp
converted to a string in human readable form to buffer buf
.
!default_indent
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
.
to_buffer ~buf sexp
same as to_buffer_mach.
to_buffer_gen ~buf ~add_char ~add_string sexp
outputs the S-expression
sexp
converted to a string to buffer buf
using the output functions
add_char
and add_string
.
unit
the unit-value as expressed by an S-expression.
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 of search results. `Not_found
means that an
S-expression was not found within another S-expression.
search_physical sexp ~contained
contained
was found within S-expression sexp
.
no_raise
is the identity, but by using 'a no_raise
in a sexpable type, the
resulting use sexp_of_no_raise
protects the conversion of 'a
to a sexp so that if
it fails, one gets a sexp with an error message about the failure, rather than an
exception being raised.
WARNING: The resulting no_raise_of_sexp
can still raise.
Please refer to the Sexplib documentation in base/sexplib/doc to learn more about sexp_option, sexp_list, and sexp_array generators.
With_text.t
is a value paired with the full textual representation of its sexp.
This is useful for dealing with the case where you want to keep track of a value along
with the format of the s-expression it was generated from, which allows you to
maintain formatting details, comments, etc.