balsoft/ligo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Switch to OCaml version 4.04.0.

Browse Source
This commit is contained in:
Benjamin Canou 2017-03-17 14:39:31 +01:00
parent ed6e91a47d
commit 31bc331063
12 changed files with 292 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
scripts/version.sh
View File

@ -1,4 +1,4 @@
#! /bin/sh #! /bin/sh
alpine_version=3.5 alpine_version=3.5
ocaml_version=4.03.0 ocaml_version=4.04.0

1
src/proto/alpha/qty_repr.ml
View File

@ -167,6 +167,7 @@ module Make (T: QTY) : S = struct
| Ok res -> Ok res | Ok res -> Ok res
| Error ([ Addition_overflow _ ] as errs) -> | Error ([ Addition_overflow _ ] as errs) ->
Error (Multiplication_overflow (t, m) :: errs) Error (Multiplication_overflow (t, m) :: errs)
| Error errs -> Error errs
let ( /? ) t d = let ( /? ) t d =
if d <= 0L then if d <= 0L then

46
src/proto/environment/array.mli
View File

@ -13,6 +13,14 @@
(* *) (* *)
(**************************************************************************) (**************************************************************************)
(* TEZOS CHANGES
* Import version 4.04.0
* Remove unsafe functions
* Remove deprecated functions
*)
(** Array operations. *) (** Array operations. *)
external length : 'a array -> int = "%array_length" external length : 'a array -> int = "%array_length"
@ -48,19 +56,11 @@ external make : int -> 'a -> 'a array = "caml_make_vect"
If the value of [x] is a floating-point number, then the maximum If the value of [x] is a floating-point number, then the maximum
size is only [Sys.max_array_length / 2].*) size is only [Sys.max_array_length / 2].*)
external create : int -> 'a -> 'a array = "caml_make_vect"
[@@ocaml.deprecated "Use Array.make instead."]
(** @deprecated [Array.create] is an alias for {!Array.make}. *)
external create_float: int -> float array = "caml_make_float_vect" external create_float: int -> float array = "caml_make_float_vect"
(** [Array.create_float n] returns a fresh float array of length [n], (** [Array.create_float n] returns a fresh float array of length [n],
with uninitialized data. with uninitialized data.
@since 4.03 *) @since 4.03 *)
val make_float: int -> float array
[@@ocaml.deprecated "Use Array.create_float instead."]
(** @deprecated [Array.make_float] is an alias for {!Array.create_float}. *)
val init : int -> (int -> 'a) -> 'a array val init : int -> (int -> 'a) -> 'a array
(** [Array.init n f] returns a fresh array of length [n], (** [Array.init n f] returns a fresh array of length [n],
with element number [i] initialized to the result of [f i]. with element number [i] initialized to the result of [f i].
@ -84,10 +84,6 @@ val make_matrix : int -> int -> 'a -> 'a array array
If the value of [e] is a floating-point number, then the maximum If the value of [e] is a floating-point number, then the maximum
size is only [Sys.max_array_length / 2]. *) size is only [Sys.max_array_length / 2]. *)
val create_matrix : int -> int -> 'a -> 'a array array
[@@ocaml.deprecated "Use Array.make_matrix instead."]
(** @deprecated [Array.create_matrix] is an alias for {!Array.make_matrix}. *)
val append : 'a array -> 'a array -> 'a array val append : 'a array -> 'a array -> 'a array
(** [Array.append v1 v2] returns a fresh array containing the (** [Array.append v1 v2] returns a fresh array containing the
concatenation of the arrays [v1] and [v2]. *) concatenation of the arrays [v1] and [v2]. *)
@ -174,13 +170,15 @@ val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit
(** [Array.iter2 f a b] applies function [f] to all the elements of [a] (** [Array.iter2 f a b] applies function [f] to all the elements of [a]
and [b]. and [b].
Raise [Invalid_argument] if the arrays are not the same size. *) Raise [Invalid_argument] if the arrays are not the same size.
@since 4.03.0 *)
val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
(** [Array.map2 f a b] applies function [f] to all the elements of [a] (** [Array.map2 f a b] applies function [f] to all the elements of [a]
and [b], and builds an array with the results returned by [f]: and [b], and builds an array with the results returned by [f]:
[[| f a.(0) b.(0); ...; f a.(Array.length a - 1) b.(Array.length b - 1)|]]. [[| f a.(0) b.(0); ...; f a.(Array.length a - 1) b.(Array.length b - 1)|]].
Raise [Invalid_argument] if the arrays are not the same size. *) Raise [Invalid_argument] if the arrays are not the same size.
@since 4.03.0 *)
(** {6 Array scanning} *) (** {6 Array scanning} *)
@ -189,20 +187,24 @@ val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
val for_all : ('a -> bool) -> 'a array -> bool val for_all : ('a -> bool) -> 'a array -> bool
(** [Array.for_all p [|a1; ...; an|]] checks if all elements of the array (** [Array.for_all p [|a1; ...; an|]] checks if all elements of the array
satisfy the predicate [p]. That is, it returns satisfy the predicate [p]. That is, it returns
[(p a1) && (p a2) && ... && (p an)]. *) [(p a1) && (p a2) && ... && (p an)].
@since 4.03.0 *)
val exists : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool
(** [Array.exists p [|a1; ...; an|]] checks if at least one element of (** [Array.exists p [|a1; ...; an|]] checks if at least one element of
the array satisfies the predicate [p]. That is, it returns the array satisfies the predicate [p]. That is, it returns
[(p a1) || (p a2) || ... || (p an)]. *) [(p a1) || (p a2) || ... || (p an)].
@since 4.03.0 *)
val mem : 'a -> 'a array -> bool val mem : 'a -> 'a array -> bool
(** [mem a l] is true if and only if [a] is equal (** [mem a l] is true if and only if [a] is equal
to an element of [l]. *) to an element of [l].
@since 4.03.0 *)
val memq : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool
(** Same as {!Array.mem}, but uses physical equality instead of structural (** Same as {!Array.mem}, but uses physical equality instead of structural
equality to compare array elements. *) equality to compare array elements.
@since 4.03.0 *)
(** {6 Sorting} *) (** {6 Sorting} *)
@ -249,11 +251,3 @@ val fast_sort : ('a -> 'a -> int) -> 'a array -> unit
on typical input. on typical input.
*) *)
(**/**)
(** {6 Undocumented functions} *)
(* The following is for system use only. Do not call directly. *)
external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get"
external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set"

62
src/proto/environment/buffer.mli
View File

@ -1,20 +1,22 @@
(***********************************************************************) (**************************************************************************)
(* *) (* *)
(* OCaml *) (* OCaml *)
(* *) (* *)
(* Pierre Weis and Xavier Leroy, projet Cristal, INRIA Rocquencourt *) (* Pierre Weis and Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
(* *) (* *)
(* Copyright 1999 Institut National de Recherche en Informatique et *) (* Copyright 1999 Institut National de Recherche en Informatique et *)
(* en Automatique. All rights reserved. This file is distributed *) (* en Automatique. *)
(* under the terms of the GNU Library General Public License, with *) (* *)
(* the special exception on linking described in file ../LICENSE. *) (* All rights reserved. This file is distributed under the terms of *)
(* *) (* the GNU Lesser General Public License version 2.1, with the *)
(***********************************************************************) (* special exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
(* TEZOS CHANGES (* TEZOS CHANGES
* import version 4.02.1 * Import version 4.04.0
* Removed channel functions * Remove channel functions
*) *)
@ -45,17 +47,19 @@ val create : int -> t
val contents : t -> string val contents : t -> string
(** Return a copy of the current contents of the buffer. (** Return a copy of the current contents of the buffer.
The buffer itself is unchanged. *) The buffer itself is unchanged. *)
val to_bytes : t -> bytes val to_bytes : t -> bytes
(** Return a copy of the current contents of the buffer. (** Return a copy of the current contents of the buffer.
The buffer itself is unchanged. *) The buffer itself is unchanged.
@since 4.02 *)
val sub : t -> int -> int -> string val sub : t -> int -> int -> string
(** [Buffer.sub b off len] returns (a copy of) the bytes from the (** [Buffer.sub b off len] returns a copy of [len] bytes from the
current contents of the buffer [b] starting at offset [off] of current contents of the buffer [b], starting at offset [off].
length [len] bytes. May raise [Invalid_argument] if out of bounds
request. The buffer itself is unaffected. *) Raise [Invalid_argument] if [srcoff] and [len] do not designate a valid
range of [b]. *)
val blit : t -> int -> bytes -> int -> int -> unit val blit : t -> int -> bytes -> int -> int -> unit
(** [Buffer.blit src srcoff dst dstoff len] copies [len] characters from (** [Buffer.blit src srcoff dst dstoff len] copies [len] characters from
@ -69,7 +73,7 @@ val blit : t -> int -> bytes -> int -> int -> unit
*) *)
val nth : t -> int -> char val nth : t -> int -> char
(** get the n-th character of the buffer. Raise [Invalid_argument] if (** Get the n-th character of the buffer. Raise [Invalid_argument] if
index out of bounds *) index out of bounds *)
val length : t -> int val length : t -> int
@ -86,25 +90,27 @@ val reset : t -> unit
faster reclamation of the space used by the buffer. *) faster reclamation of the space used by the buffer. *)
val add_char : t -> char -> unit val add_char : t -> char -> unit
(** [add_char b c] appends the character [c] at the end of the buffer [b]. *) (** [add_char b c] appends the character [c] at the end of buffer [b]. *)
val add_string : t -> string -> unit val add_string : t -> string -> unit
(** [add_string b s] appends the string [s] at the end of the buffer [b]. *) (** [add_string b s] appends the string [s] at the end of buffer [b]. *)
val add_bytes : t -> bytes -> unit val add_bytes : t -> bytes -> unit
(** [add_string b s] appends the string [s] at the end of the buffer [b]. *) (** [add_bytes b s] appends the byte sequence [s] at the end of buffer [b].
@since 4.02 *)
val add_substring : t -> string -> int -> int -> unit val add_substring : t -> string -> int -> int -> unit
(** [add_substring b s ofs len] takes [len] characters from offset (** [add_substring b s ofs len] takes [len] characters from offset
[ofs] in string [s] and appends them at the end of the buffer [b]. *) [ofs] in string [s] and appends them at the end of buffer [b]. *)
val add_subbytes : t -> bytes -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit
(** [add_substring b s ofs len] takes [len] characters from offset (** [add_subbytes b s ofs len] takes [len] characters from offset
[ofs] in byte sequence [s] and appends them at the end of the buffer [b]. *) [ofs] in byte sequence [s] and appends them at the end of buffer [b].
@since 4.02 *)
val add_substitute : t -> (string -> string) -> string -> unit val add_substitute : t -> (string -> string) -> string -> unit
(** [add_substitute b f s] appends the string pattern [s] at the end (** [add_substitute b f s] appends the string pattern [s] at the end
of the buffer [b] with substitution. of buffer [b] with substitution.
The substitution process looks for variables into The substitution process looks for variables into
the pattern and substitutes each variable name by its value, as the pattern and substitutes each variable name by its value, as
obtained by applying the mapping [f] to the variable name. Inside the obtained by applying the mapping [f] to the variable name. Inside the

43
src/proto/environment/bytes.mli
View File

@ -13,6 +13,15 @@
(* *) (* *)
(**************************************************************************) (**************************************************************************)
(* TEZOS CHANGES
* Import version 4.04.0
* Remove unsafe functions
* Remove deprecated functions
* Add binary data insertion / extraction functions
*)
(** Byte sequence operations. (** Byte sequence operations.
A byte sequence is a mutable data structure that contains a A byte sequence is a mutable data structure that contains a
@ -42,21 +51,21 @@
@since 4.02.0 @since 4.02.0
*) *)
external length : bytes -> int = "%string_length" external length : bytes -> int = "%bytes_length"
(** Return the length (number of bytes) of the argument. *) (** Return the length (number of bytes) of the argument. *)
external get : bytes -> int -> char = "%string_safe_get" external get : bytes -> int -> char = "%bytes_safe_get"
(** [get s n] returns the byte at index [n] in argument [s]. (** [get s n] returns the byte at index [n] in argument [s].
Raise [Invalid_argument] if [n] not a valid index in [s]. *) Raise [Invalid_argument] if [n] not a valid index in [s]. *)
external set : bytes -> int -> char -> unit = "%string_safe_set" external set : bytes -> int -> char -> unit = "%bytes_safe_set"
(** [set s n c] modifies [s] in place, replacing the byte at index [n] (** [set s n c] modifies [s] in place, replacing the byte at index [n]
with [c]. with [c].
Raise [Invalid_argument] if [n] is not a valid index in [s]. *) Raise [Invalid_argument] if [n] is not a valid index in [s]. *)
external create : int -> bytes = "caml_create_string" external create : int -> bytes = "caml_create_bytes"
(** [create n] returns a new byte sequence of length [n]. The (** [create n] returns a new byte sequence of length [n]. The
sequence is uninitialized and contains arbitrary bytes. sequence is uninitialized and contains arbitrary bytes.
@ -232,32 +241,6 @@ val rcontains_from : bytes -> int -> char -> bool
Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid
position in [s]. *) position in [s]. *)
val uppercase : bytes -> bytes
[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."]
(** Return a copy of the argument, with all lowercase letters
translated to uppercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
@deprecated Functions operating on Latin-1 character set are deprecated. *)
val lowercase : bytes -> bytes
[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."]
(** Return a copy of the argument, with all uppercase letters
translated to lowercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
@deprecated Functions operating on Latin-1 character set are deprecated. *)
val capitalize : bytes -> bytes
[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."]
(** Return a copy of the argument, with the first character set to uppercase,
using the ISO Latin-1 (8859-1) character set..
@deprecated Functions operating on Latin-1 character set are deprecated. *)
val uncapitalize : bytes -> bytes
[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."]
(** Return a copy of the argument, with the first character set to lowercase,
using the ISO Latin-1 (8859-1) character set..
@deprecated Functions operating on Latin-1 character set are deprecated. *)
val uppercase_ascii : bytes -> bytes val uppercase_ascii : bytes -> bytes
(** Return a copy of the argument, with all lowercase letters (** Return a copy of the argument, with all lowercase letters
translated to uppercase, using the US-ASCII character set. translated to uppercase, using the US-ASCII character set.

75
src/proto/environment/format.mli
View File

@ -15,10 +15,10 @@
(* TEZOS CHANGES (* TEZOS CHANGES
* import version 4.03.0 * Import version 4.04.0
* Removed channel functions * Remove channel functions
* Removed toplevel effect based functions * Remove toplevel effect based functions
* Removed deprecated functions * Remove deprecated functions
*) *)
@ -83,15 +83,48 @@
the evaluation order of printing commands. the evaluation order of printing commands.
*) *)
(** {6:tags Semantic Tags} *)
type tag = string
(** {6:meaning Changing the meaning of standard formatter pretty printing} *)
(** The [Format] module is versatile enough to let you completely redefine
the meaning of pretty printing: you may provide your own functions to define
how to handle indentation, line splitting, and even printing of all the
characters that have to be printed! *)
type formatter_out_functions = {
out_string : string -> int -> int -> unit;
out_flush : unit -> unit;
out_newline : unit -> unit;
out_spaces : int -> unit;
}
(** {6:tagsmeaning Changing the meaning of printing semantic tags} *)
type formatter_tag_functions = {
mark_open_tag : tag -> string;
mark_close_tag : tag -> string;
print_open_tag : tag -> unit;
print_close_tag : tag -> unit;
}
(** The tag handling functions specific to a formatter:
[mark] versions are the 'tag marking' functions that associate a string
marker to a tag in order for the pretty-printing engine to flush
those markers as 0 length tokens in the output device of the formatter.
[print] versions are the 'tag printing' functions that can perform
regular printing when a tag is closed or opened. *)
(** {6 Multiple formatted output} *) (** {6 Multiple formatted output} *)
type formatter;; type formatter
(** Abstract data corresponding to a pretty-printer (also called a (** Abstract data corresponding to a pretty-printer (also called a
formatter) and all its machinery. formatter) and all its machinery.
Defining new pretty-printers permits unrelated output of material in Defining new pretty-printers permits unrelated output of material in
parallel on several output channels. parallel on several output channels.
All the parameters of a pretty-printer are local to this pretty-printer: All the parameters of a pretty-printer are local to a formatter:
margin, maximum indentation limit, maximum number of boxes margin, maximum indentation limit, maximum number of boxes
simultaneously opened, ellipsis, and so on, are specific to simultaneously opened, ellipsis, and so on, are specific to
each pretty-printer and may be fixed independently. each pretty-printer and may be fixed independently.
@ -154,6 +187,36 @@ val pp_over_max_boxes : formatter -> unit -> bool
val pp_set_ellipsis_text : formatter -> string -> unit val pp_set_ellipsis_text : formatter -> string -> unit
val pp_get_ellipsis_text : formatter -> unit -> string val pp_get_ellipsis_text : formatter -> unit -> string
val pp_set_formatter_output_functions :
formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit
val pp_get_formatter_output_functions :
formatter -> unit -> (string -> int -> int -> unit) * (unit -> unit)
val pp_set_formatter_tag_functions :
formatter -> formatter_tag_functions -> unit
val pp_get_formatter_tag_functions :
formatter -> unit -> formatter_tag_functions
val pp_set_formatter_out_functions :
formatter -> formatter_out_functions -> unit
val pp_get_formatter_out_functions :
formatter -> unit -> formatter_out_functions
(** These functions are the basic ones: usual functions
operating on the standard formatter are defined via partial
evaluation of these primitives. For instance,
[print_string] is equal to [pp_print_string std_formatter]. *)
val pp_flush_formatter : formatter -> unit
(** [pp_flush_formatter fmt] flushes [fmt]'s internal queue, ensuring that all
the printing and flushing actions have been performed. In addition, this
operation will close all boxes and reset the state of the formatter.
This will not flush [fmt]'s output. In most cases, the user may want to use
{!pp_print_flush} instead. *)
(** {6 Convenience formatting functions.} *) (** {6 Convenience formatting functions.} *)
val pp_print_list: val pp_print_list:

14
src/proto/environment/int32.mli
View File

@ -13,6 +13,13 @@
(* *) (* *)
(**************************************************************************) (**************************************************************************)
(* TEZOS CHANGES
* Import version 4.04.0
* Remove deprecated functions
*)
(** 32-bit integers. (** 32-bit integers.
This module provides operations on the type [int32] This module provides operations on the type [int32]
@ -167,10 +174,3 @@ val equal: t -> t -> bool
(** The equal function for int32s. (** The equal function for int32s.
@since 4.03.0 *) @since 4.03.0 *)
(**/**)
(** {6 Deprecated functions} *)
external format : string -> int32 -> string = "caml_int32_format"
(** Do not use this deprecated function. Instead,
used {!Printf.sprintf} with a [%l...] format. *)

14
src/proto/environment/int64.mli
View File

@ -13,6 +13,12 @@
(* *) (* *)
(**************************************************************************) (**************************************************************************)
(* TEZOS CHANGES
* Import version 4.04.0
* Remove deprecated functions
*)
(** 64-bit integers. (** 64-bit integers.
This module provides operations on the type [int64] of This module provides operations on the type [int64] of
@ -188,11 +194,3 @@ val compare: t -> t -> int
val equal: t -> t -> bool val equal: t -> t -> bool
(** The equal function for int64s. (** The equal function for int64s.
@since 4.03.0 *) @since 4.03.0 *)
(**/**)
(** {6 Deprecated functions} *)
external format : string -> int64 -> string = "caml_int64_format"
(** Do not use this deprecated function. Instead,
used {!Printf.sprintf} with a [%L...] format. *)

3
src/proto/environment/list.mli
View File

@ -67,8 +67,7 @@ val concat : 'a list list -> 'a list
(length of the argument + length of the longest sub-list). *) (length of the argument + length of the longest sub-list). *)
val flatten : 'a list list -> 'a list val flatten : 'a list list -> 'a list
(** Same as [concat]. Not tail-recursive (** An alias for [concat]. *)
(length of the argument + length of the longest sub-list). *)
(** {6 Iterators} *) (** {6 Iterators} *)

81
src/proto/environment/pervasives.mli
View File

@ -15,9 +15,12 @@
(* TEZOS CHANGES (* TEZOS CHANGES
* import version 4.02.1 * Import version 4.04.0
* Removed [channel], [exit], ... * Remove [channel], [exit], ...
* Removed polymorphic comparisons * Remove polymorphic comparisons
* Remove non IEEE754-standardized functions on floats
* Remove deprecated functions
*) *)
@ -38,7 +41,7 @@
external raise : exn -> 'a = "%raise" external raise : exn -> 'a = "%raise"
(** Raise the given exception value *) (** Raise the given exception value *)
(* external raise_notrace : exn -> 'a = "%raise_notrace" *) external raise_notrace : exn -> 'a = "%raise_notrace"
(** A faster version [raise] which does not record the backtrace. (** A faster version [raise] which does not record the backtrace.
@since 4.02.0 @since 4.02.0
*) *)
@ -46,7 +49,7 @@ external raise : exn -> 'a = "%raise"
val invalid_arg : string -> 'a val invalid_arg : string -> 'a
(** Raise exception [Invalid_argument] with the given string. *) (** Raise exception [Invalid_argument] with the given string. *)
(* val failwith : string -> 'a *) val failwith : string -> 'a
(** Raise exception [Failure] with the given string. *) (** Raise exception [Failure] with the given string. *)
exception Exit exception Exit
@ -64,56 +67,72 @@ external ( && ) : bool -> bool -> bool = "%sequand"
in [e1 && e2], [e1] is evaluated first, and if it returns [false], in [e1 && e2], [e1] is evaluated first, and if it returns [false],
[e2] is not evaluated at all. *) [e2] is not evaluated at all. *)
external ( & ) : bool -> bool -> bool = "%sequand"
(** @deprecated {!Pervasives.( && )} should be used instead. *)
external ( || ) : bool -> bool -> bool = "%sequor" external ( || ) : bool -> bool -> bool = "%sequor"
(** The boolean 'or'. Evaluation is sequential, left-to-right: (** The boolean 'or'. Evaluation is sequential, left-to-right:
in [e1 || e2], [e1] is evaluated first, and if it returns [true], in [e1 || e2], [e1] is evaluated first, and if it returns [true],
[e2] is not evaluated at all. *) [e2] is not evaluated at all. *)
external ( or ) : bool -> bool -> bool = "%sequor"
[@@ocaml.deprecated "Use (||) instead."]
(** @deprecated {!Pervasives.( || )} should be used instead.*)
(** {6 Debugging} *) (** {6 Debugging} *)
external __LOC__ : string = "%loc_LOC" external __LOC__ : string = "%loc_LOC"
(** [__LOC__] returns the location at which this expression appears in (** [__LOC__] returns the location at which this expression appears in
the file currently being parsed by the compiler, with the standard the file currently being parsed by the compiler, with the standard
error format of OCaml: "File %S, line %d, characters %d-%d" *) error format of OCaml: "File %S, line %d, characters %d-%d".
@since 4.02.0
*)
external __FILE__ : string = "%loc_FILE" external __FILE__ : string = "%loc_FILE"
(** [__FILE__] returns the name of the file currently being (** [__FILE__] returns the name of the file currently being
parsed by the compiler. *) parsed by the compiler.
@since 4.02.0
*)
external __LINE__ : int = "%loc_LINE" external __LINE__ : int = "%loc_LINE"
(** [__LINE__] returns the line number at which this expression (** [__LINE__] returns the line number at which this expression
appears in the file currently being parsed by the compiler. *) appears in the file currently being parsed by the compiler.
@since 4.02.0
*)
external __MODULE__ : string = "%loc_MODULE" external __MODULE__ : string = "%loc_MODULE"
(** [__MODULE__] returns the module name of the file being (** [__MODULE__] returns the module name of the file being
parsed by the compiler. *) parsed by the compiler.
@since 4.02.0
*)
external __POS__ : string * int * int * int = "%loc_POS" external __POS__ : string * int * int * int = "%loc_POS"
(** [__POS__] returns a tuple [(file,lnum,cnum,enum)], corresponding (** [__POS__] returns a tuple [(file,lnum,cnum,enum)], corresponding
to the location at which this expression appears in the file to the location at which this expression appears in the file
currently being parsed by the compiler. [file] is the current currently being parsed by the compiler. [file] is the current
filename, [lnum] the line number, [cnum] the character position in filename, [lnum] the line number, [cnum] the character position in
the line and [enum] the last character position in the line. *) the line and [enum] the last character position in the line.
@since 4.02.0
*)
external __LOC_OF__ : 'a -> string * 'a = "%loc_LOC" external __LOC_OF__ : 'a -> string * 'a = "%loc_LOC"
(** [__LOC_OF__ expr] returns a pair [(loc, expr)] where [loc] is the (** [__LOC_OF__ expr] returns a pair [(loc, expr)] where [loc] is the
location of [expr] in the file currently being parsed by the location of [expr] in the file currently being parsed by the
compiler, with the standard error format of OCaml: "File %S, line compiler, with the standard error format of OCaml: "File %S, line
%d, characters %d-%d" *) %d, characters %d-%d".
@since 4.02.0
*)
external __LINE_OF__ : 'a -> int * 'a = "%loc_LINE" external __LINE_OF__ : 'a -> int * 'a = "%loc_LINE"
(** [__LINE__ expr] returns a pair [(line, expr)], where [line] is the (** [__LINE__ expr] returns a pair [(line, expr)], where [line] is the
line number at which the expression [expr] appears in the file line number at which the expression [expr] appears in the file
currently being parsed by the compiler. *) currently being parsed by the compiler.
@since 4.02.0
*)
external __POS_OF__ : 'a -> (string * int * int * int) * 'a = "%loc_POS" external __POS_OF__ : 'a -> (string * int * int * int) * 'a = "%loc_POS"
(** [__POS_OF__ expr] returns a pair [(expr,loc)], where [loc] is a (** [__POS_OF__ expr] returns a pair [(loc,expr)], where [loc] is a
tuple [(file,lnum,cnum,enum)] corresponding to the location at tuple [(file,lnum,cnum,enum)] corresponding to the location at
which the expression [expr] appears in the file currently being which the expression [expr] appears in the file currently being
parsed by the compiler. [file] is the current filename, [lnum] the parsed by the compiler. [file] is the current filename, [lnum] the
line number, [cnum] the character position in the line and [enum] line number, [cnum] the character position in the line and [enum]
the last character position in the line. *) the last character position in the line.
@since 4.02.0
*)
(** {6 Composition operators} *) (** {6 Composition operators} *)
@ -556,5 +575,27 @@ type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6
type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4
val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
(** Converts a format string into a string. *)
external format_of_string :
('a, 'b, 'c, 'd, 'e, 'f) format6 ->
('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity"
(** [format_of_string s] returns a format string read from the string
literal [s].
Note: [format_of_string] can not convert a string argument that is not a
literal. If you need this functionality, use the more general
{!Scanf.format_from_string} function.
*)
val ( ^^ ) :
('a, 'b, 'c, 'd, 'e, 'f) format6 ->
('f, 'b, 'c, 'e, 'g, 'h) format6 ->
('a, 'b, 'c, 'd, 'g, 'h) format6
(** [f1 ^^ f2] catenates format strings [f1] and [f2]. The result is a
format string that behaves as the concatenation of format strings [f1] and
[f2]: in case of formatted output, it accepts arguments from [f1], then
arguments from [f2]; in case of formatted input, it returns results from
[f1], then results from [f2].
*)

11
src/proto/environment/set.mli
View File

@ -118,6 +118,17 @@ module type S =
The elements of [s] are presented to [f] in increasing order The elements of [s] are presented to [f] in increasing order
with respect to the ordering over the type of the elements. *) with respect to the ordering over the type of the elements. *)
val map: (elt -> elt) -> t -> t
(** [map f s] is the set whose elements are [f a0],[f a1]... [f
aN], where [a0],[a1]...[aN] are the elements of [s].
The elements are passed to [f] in increasing order
with respect to the ordering over the type of the elements.
If no element of [s] is changed by [f], [s] is returned
unchanged. (If each output of [f] is physically equal to its
input, the returned set is physically equal to [s].) *)
val fold: (elt -> 'a -> 'a) -> t -> 'a -> 'a val fold: (elt -> 'a -> 'a) -> t -> 'a -> 'a
(** [fold f s a] computes [(f xN ... (f x2 (f x1 a))...)], (** [fold f s a] computes [(f xN ... (f x2 (f x1 a))...)],
where [x1 ... xN] are the elements of [s], in increasing order. *) where [x1 ... xN] are the elements of [s], in increasing order. *)

145
src/proto/environment/string.mli
View File

@ -1,15 +1,26 @@
(***********************************************************************) (**************************************************************************)
(* *) (* *)
(* OCaml *) (* OCaml *)
(* *) (* *)
(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *) (* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
(* *) (* *)
(* Copyright 1996 Institut National de Recherche en Informatique et *) (* Copyright 1996 Institut National de Recherche en Informatique et *)
(* en Automatique. All rights reserved. This file is distributed *) (* en Automatique. *)
(* under the terms of the GNU Library General Public License, with *) (* *)
(* the special exception on linking described in file ../LICENSE. *) (* All rights reserved. This file is distributed under the terms of *)
(* *) (* the GNU Lesser General Public License version 2.1, with the *)
(***********************************************************************) (* special exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
(* TEZOS CHANGES
* Import version 4.04.0
* Remove unsafe functions
* Remove deprecated functions (enforcing string immutability)
* Add binary data extraction functions
*)
(** String operations. (** String operations.
@ -30,20 +41,6 @@
substring of [s] if [len >= 0] and [start] and [start+len] are substring of [s] if [len >= 0] and [start] and [start+len] are
valid positions in [s]. valid positions in [s].
OCaml strings used to be modifiable in place, for instance via the
{!String.set} and {!String.blit} functions described below. This
usage is deprecated and only possible when the compiler is put in
"unsafe-string" mode by giving the [-unsafe-string] command-line
option (which is currently the default for reasons of backward
compatibility). This is done by making the types [string] and
[bytes] (see module {!Bytes}) interchangeable so that functions
expecting byte sequences can also accept strings as arguments and
modify them.
All new code should avoid this feature and be compiled with the
[-safe-string] command-line option to enforce the separation between
the types [string] and [bytes].
*) *)
external length : string -> int = "%string_length" external length : string -> int = "%string_length"
@ -56,25 +53,6 @@ external get : string -> int -> char = "%string_safe_get"
Raise [Invalid_argument] if [n] not a valid index in [s]. *) Raise [Invalid_argument] if [n] not a valid index in [s]. *)
external set : bytes -> int -> char -> unit = "%string_safe_set"
[@@ocaml.deprecated "Use Bytes.set instead."]
(** [String.set s n c] modifies byte sequence [s] in place,
replacing the byte at index [n] with [c].
You can also write [s.[n] <- c] instead of [String.set s n c].
Raise [Invalid_argument] if [n] is not a valid index in [s].
@deprecated This is a deprecated alias of {!Bytes.set}.[ ] *)
external create : int -> bytes = "caml_create_string"
[@@ocaml.deprecated "Use Bytes.create instead."]
(** [String.create n] returns a fresh byte sequence of length [n].
The sequence is uninitialized and contains arbitrary bytes.
Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}.
@deprecated This is a deprecated alias of {!Bytes.create}.[ ] *)
val make : int -> char -> string val make : int -> char -> string
(** [String.make n c] returns a fresh string of length [n], (** [String.make n c] returns a fresh string of length [n],
filled with the character [c]. filled with the character [c].
@ -91,12 +69,6 @@ val init : int -> (int -> char) -> string
@since 4.02.0 @since 4.02.0
*) *)
val copy : string -> string [@@ocaml.deprecated]
(** Return a copy of the given string.
@deprecated Because strings are immutable, it doesn't make much
sense to make identical copies of them. *)
val sub : string -> int -> int -> string val sub : string -> int -> int -> string
(** [String.sub s start len] returns a fresh string of length [len], (** [String.sub s start len] returns a fresh string of length [len],
containing the substring of [s] that starts at position [start] and containing the substring of [s] that starts at position [start] and
@ -105,16 +77,6 @@ val sub : string -> int -> int -> string
Raise [Invalid_argument] if [start] and [len] do not Raise [Invalid_argument] if [start] and [len] do not
designate a valid substring of [s]. *) designate a valid substring of [s]. *)
val fill : bytes -> int -> int -> char -> unit
[@@ocaml.deprecated "Use Bytes.fill instead."]
(** [String.fill s start len c] modifies byte sequence [s] in place,
replacing [len] bytes with [c], starting at [start].
Raise [Invalid_argument] if [start] and [len] do not
designate a valid range of [s].
@deprecated This is a deprecated alias of {!Bytes.fill}.[ ] *)
val blit : string -> int -> bytes -> int -> int -> unit val blit : string -> int -> bytes -> int -> int -> unit
(** Same as {!Bytes.blit_string}. *) (** Same as {!Bytes.blit_string}. *)
@ -158,13 +120,20 @@ val trim : string -> string
val escaped : string -> string val escaped : string -> string
(** Return a copy of the argument, with special characters (** Return a copy of the argument, with special characters
represented by escape sequences, following the lexical represented by escape sequences, following the lexical
conventions of OCaml. If there is no special conventions of OCaml.
character in the argument, return the original string itself, All characters outside the ASCII printable range (32..126) are
not a copy. Its inverse function is Scanf.unescaped. escaped, as well as backslash and double-quote.
Raise [Invalid_argument] if the result is longer than If there is no special character in the argument that needs
{!Sys.max_string_length} bytes. *) escaping, return the original string itself, not a copy.
Raise [Invalid_argument] if the result is longer than
{!Sys.max_string_length} bytes.
The function {!Scanf.unescaped} is a left inverse of [escaped],
i.e. [Scanf.unescaped (escaped s) = s] for any string [s] (unless
[escape s] fails). *)
val index : string -> char -> int val index : string -> char -> int
(** [String.index s c] returns the index of the first (** [String.index s c] returns the index of the first
@ -214,21 +183,25 @@ val rcontains_from : string -> int -> char -> bool
Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid
position in [s]. *) position in [s]. *)
val uppercase : string -> string val uppercase_ascii : string -> string
(** Return a copy of the argument, with all lowercase letters (** Return a copy of the argument, with all lowercase letters
translated to uppercase, including accented letters of the ISO translated to uppercase, using the US-ASCII character set.
Latin-1 (8859-1) character set. *) @since 4.03.0 *)
val lowercase : string -> string val lowercase_ascii : string -> string
(** Return a copy of the argument, with all uppercase letters (** Return a copy of the argument, with all uppercase letters
translated to lowercase, including accented letters of the ISO translated to lowercase, using the US-ASCII character set.
Latin-1 (8859-1) character set. *) @since 4.03.0 *)
val capitalize : string -> string val capitalize_ascii : string -> string
(** Return a copy of the argument, with the first character set to uppercase. *) (** Return a copy of the argument, with the first character set to uppercase,
using the US-ASCII character set.
@since 4.03.0 *)
val uncapitalize : string -> string val uncapitalize_ascii : string -> string
(** Return a copy of the argument, with the first character set to lowercase. *) (** Return a copy of the argument, with the first character set to lowercase,
using the US-ASCII character set.
@since 4.03.0 *)
type t = string type t = string
(** An alias for the type of strings. *) (** An alias for the type of strings. *)
@ -239,6 +212,24 @@ val compare: t -> t -> int
allows the module [String] to be passed as argument to the functors allows the module [String] to be passed as argument to the functors
{!Set.Make} and {!Map.Make}. *) {!Set.Make} and {!Map.Make}. *)
val equal: t -> t -> bool
(** The equal function for strings.
@since 4.03.0 *)
val split_on_char: char -> string -> string list
(** [String.split_on_char sep s] returns the list of all (possibly empty)
substrings of [s] that are delimited by the [sep] character.
The function's output is specified by the following invariants:
- The list is not empty.
- Concatenating its elements using [sep] as a separator returns a
string equal to the input ([String.concat (String.make 1 sep)
(String.split_on_char sep s) = s]).
- No string in the result contains the [sep] character.
@since 4.04.0
*)
(** Functions reading bytes *) (** Functions reading bytes *)