Core of the BatIO module.
This module contains the core definitions of BatIO, so as to avoid circular dependencies between modules which only need simple functions of BatIO and that module itself.
Don't use this module, use BatIO.
This exception is raised when reading on an input with the read or nread functions while there is no available token to read.
val read : input -> charRead a single char from an input or raise No_more_input if no input available.
val read_all : input -> stringread all the contents of the input until No_more_input is raised.
Create a pipe between an input and an ouput. Data written from the output can be read from the input.
val nread : input -> int -> stringnread i n reads a string of size up to n from an input. The function will raise No_more_input if no input is available. It will raise Invalid_argument if n < 0.
val really_nread : input -> int -> stringreally_nread i n reads a string of exactly n characters from the input.
input i s p len reads up to len bytes from the given input, storing them in byte sequence s, starting at position p. It returns the actual number of bytes read or raise No_more_input if no character can be read. It will raise Invalid_argument if p and len do not designate a valid subsequence of s.
really_input i s p len reads exactly len characters from the given input, storing them in the byte sequence s, starting at position p. For consistency with BatIO.input it returns len.
val close_in : input -> unitClose the input. It can no longer be read from.
val write : 'a output -> char -> unitWrite a single char to an output.
val nwrite : 'a output -> string -> unitWrite a string to an output.
output o s p len writes up to len characters from byte sequence len, starting at offset p. It returns the number of characters written. It will raise Invalid_argument if p and len do not designate a valid subsequence of s.
val output_substring : 'a output -> string -> int -> int -> intlike output above, but outputs from a substring instead of a subsequence of bytes
really_output o s p len writes exactly len characters from byte sequence s onto the the output, starting with the character at offset p. For consistency with BatIO.output it returns len.
val really_output_substring : 'a output -> string -> int -> int -> intlike really_output above, but outputs from a substring instead of a subsequence of bytes
val flush : 'a output -> unitFlush an output.
val close_out : 'a output -> 'aClose the output and return its accumulator data. It can no longer be written.
val input_string : string -> inputCreate an input that will read from a string.
val output_string : unit -> string outputCreate an output that will write into a string in an efficient way. When closed, the output returns all the data written into it.
Register a function to be triggered just before an output is closed.
val create_in :
read:(unit -> char) ->
input:(Bytes.t -> int -> int -> int) ->
close:(unit -> unit) ->
inputFully create an input by giving all the needed functions.
Note Do not use this function for creating an input which reads from one or more underlying inputs. Rather, use wrap_in.
val inherit_in :
?read:(unit -> char) ->
?input:(Bytes.t -> int -> int -> int) ->
?close:(unit -> unit) ->
input ->
inputSimplified and optimized version of wrap_in whenever only one input appears as dependency.
val wrap_in :
read:(unit -> char) ->
input:(Bytes.t -> int -> int -> int) ->
close:(unit -> unit) ->
underlying:input list ->
inputFully create an input reading from other inputs by giving all the needed functions.
This function is a more general version of create_in which also handles dependency management between inputs.
val create_out :
write:(char -> unit) ->
output:(Bytes.t -> int -> int -> int) ->
flush:(unit -> unit) ->
close:(unit -> 'a) ->
'a outputFully create an output by giving all the needed functions.
val inherit_out :
?write:(char -> unit) ->
?output:(Bytes.t -> int -> int -> int) ->
?flush:(unit -> unit) ->
?close:(unit -> unit) ->
_ output ->
unit outputSimplified and optimized version of wrap_out whenever only one output appears as dependency.
val wrap_out :
write:(char -> unit) ->
output:(Bytes.t -> int -> int -> int) ->
flush:(unit -> unit) ->
close:(unit -> 'a) ->
underlying:'b output list ->
'a outputFully create an output that writes to one or more underlying outputs.
This function is a more general version of create_out, which also handles dependency management between outputs.
To illustrate the need for dependency management, let us consider the following values:
outf : _ output -> _ output, using create_out to create a new output for writing some data to an underyling output (for instance, a function comparale to tab_out or a function performing transparent compression or transparent traduction between encodings)With these values, let us consider the following scenario
f out is createdf out but not flushedout is closed, perhaps manually or as a consequence of garbage-collection, or because the program has endedf out is flushed.In this case, data reaches out only after out has been closed, which violates the protocol. Despite appearances, it is quite easy to reach such situation, especially in short programs.
The solution is to use wrap_out rather than create_out in f. Specifying that f out writes on out will then let the run-time flush and close f out when out is closed for any reason, which in turn avoids the issue.
Here is some API useful for working with binary files, in particular binary files generated by C applications. By default, encoding of multibyte integers is low-endian. The BigEndian module provide multibyte operations with other encoding.
val read_byte : input -> intRead an unsigned 8-bit integer.
val read_signed_byte : input -> intRead an signed 8-bit integer.
val read_ui16 : input -> intRead an unsigned 16-bit word.
val read_i16 : input -> intRead a signed 16-bit word.
val read_i32 : input -> intRead a signed 32-bit integer.
val read_real_i32 : input -> int32Read a signed 32-bit integer as an OCaml int32.
val read_i64 : input -> int64Read a signed 64-bit integer as an OCaml int64.
val read_float : input -> floatRead an IEEE single precision floating point value.
val read_double : input -> floatRead an IEEE double precision floating point value.
val read_string : input -> stringRead a null-terminated string.
val read_line : input -> stringRead a LF or CRLF terminated string.
val write_byte : 'a output -> int -> unitWrite an unsigned 8-bit byte.
val write_ui16 : 'a output -> int -> unitWrite an unsigned 16-bit word.
val write_i16 : 'a output -> int -> unitWrite a signed 16-bit word.
val write_i32 : 'a output -> int -> unitWrite a signed 32-bit integer.
val write_real_i32 : 'a output -> int32 -> unitWrite an OCaml int32.
val write_i64 : 'a output -> int64 -> unitWrite an OCaml int64.
val write_double : 'a output -> float -> unitWrite an IEEE double precision floating point value.
val write_float : 'a output -> float -> unitWrite an IEEE single precision floating point value.
val write_string : 'a output -> string -> unitWrite a string and append an null character.
val write_line : 'a output -> string -> unitWrite a line and append a LF (it might be converted to CRLF on some systems depending on the underlying BatIO).
You can safely transform any output to an unit output in a safe way by using this function.
val input_channel : ?autoclose:bool -> ?cleanup:bool -> in_channel -> inputCreate an input that will read from a channel.
val output_channel : ?cleanup:bool -> out_channel -> unit outputCreate an output that will write into a channel.
val stdin : inputStandard input, as per Unix/Windows conventions (by default, keyboard).
val stdout : unit outputStandard output, as per Unix/Windows conventions (by default, console).
Use this output to display regular messages.
val stderr : unit outputStandard error output, as per Unix/Windows conventions.
Use this output to display warnings and error messages.
val stdnull : unit outputAn output which discards everything written to it.
Use this output to ignore messages.
The following modules may be useful to create hashtables of inputs or outputs.
module Input : sig ... endmodule Output : sig ... end