@tellahq/rescript 10.1.0-alpha.1

package/lib/ocaml/sys.mli

@@ -0,0 +1,333 @@
+(**************************************************************************)
+(*                                                                        *)
+(*                                 OCaml                                  *)
+(*                                                                        *)
+(*             Xavier Leroy, projet Cristal, INRIA Rocquencourt           *)
+(*                                                                        *)
+(*   Copyright 1996 Institut National de Recherche en Informatique et     *)
+(*     en Automatique.                                                    *)
+(*                                                                        *)
+(*   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.          *)
+(*                                                                        *)
+(**************************************************************************)
+
+(** System interface.
+
+  Every function in this module raises [Sys_error] with an
+  informative message when the underlying system call signal
+  an error.
+*)
+
+val argv : string array
+(** The command line arguments given to the process.
+   The first element is the command name used to invoke the program.
+   The following elements are the command-line arguments
+   given to the program. *)
+
+val executable_name : string
+(** The name of the file containing the executable currently running. *)
+
+external file_exists : string -> bool = "?sys_file_exists"
+(** Test if a file with the given name exists. *)
+
+external is_directory : string -> bool = "?sys_is_directory"
+(** Returns [true] if the given name refers to a directory,
+    [false] if it refers to another kind of file.
+    Raise [Sys_error] if no file exists with the given name.
+    @since 3.10.0
+*)
+
+external remove : string -> unit = "?sys_remove"
+(** Remove the given file name from the file system. *)
+
+external rename : string -> string -> unit = "?sys_rename"
+(** Rename a file.  [rename oldpath newpath] renames the file
+    called [oldpath], giving it [newpath] as its new name,
+    moving it between directories if needed.  If [newpath] already
+    exists, its contents will be replaced with those of [oldpath].
+    Depending on the operating system, the metadata (permissions,
+    owner, etc) of [newpath] can either be preserved or be replaced by
+    those of [oldpath].
+   @since 4.06 concerning the "replace existing file" behavior *)
+
+external getenv : string -> string = "?sys_getenv"
+(** Return the value associated to a variable in the process
+   environment. Raise [Not_found] if the variable is unbound. *)
+
+val getenv_opt: string -> string option
+(** Return the value associated to a variable in the process
+    environment or [None] if the variable is unbound.
+    @since 4.05
+*)
+
+val command : string -> int
+(** Execute the given shell command and return its exit code. *)
+
+external time : unit -> float =
+  "?sys_time" 
+(** Return the processor time, in seconds, used by the program
+   since the beginning of execution. *)
+
+external chdir : string -> unit = "?sys_chdir"
+(** Change the current working directory of the process. *)
+
+external getcwd : unit -> string = "?sys_getcwd"
+(** Return the current working directory of the process. *)
+
+external readdir : string -> string array = "?sys_read_directory"
+(** Return the names of all files present in the given directory.
+   Names denoting the current directory and the parent directory
+   (["."] and [".."] in Unix) are not returned.  Each string in the
+   result is a file name rather than a complete path.  There is no
+   guarantee that the name strings in the resulting array will appear
+   in any specific order; they are not, in particular, guaranteed to
+   appear in alphabetical order. *)
+
+val interactive : bool ref
+(** This reference is initially set to [false] in standalone
+   programs and to [true] if the code is being executed under
+   the interactive toplevel system [ocaml]. *)
+
+val os_type : string
+(** Operating system currently executing the OCaml program. One of
+-  ["Unix"] (for all Unix versions, including Linux and Mac OS X),
+-  ["Win32"] (for MS-Windows, OCaml compiled with MSVC++ or Mingw),
+-  ["Cygwin"] (for MS-Windows, OCaml compiled with Cygwin). *)
+
+type backend_type =
+  | Native
+  | Bytecode
+  | Other of string (**)
+(** Currently, the official distribution only supports [Native] and
+    [Bytecode], but it can be other backends with alternative
+    compilers, for example, javascript.
+
+    @since 4.04.0
+*)
+
+val backend_type : backend_type
+(** Backend type  currently executing the OCaml program.
+    @since 4.04.0
+ *)
+
+val unix : bool
+(** True if [Sys.os_type = "Unix"].
+    @since 4.01.0 *)
+
+val win32 : bool
+(** True if [Sys.os_type = "Win32"].
+    @since 4.01.0 *)
+
+val cygwin : bool
+(** True if [Sys.os_type = "Cygwin"].
+    @since 4.01.0 *)
+
+val word_size : int
+(** Size of one word on the machine currently executing the OCaml
+   program, in bits: 32 or 64. *)
+
+val int_size : int
+(** Size of an int.  It is 31 bits (resp. 63 bits) when using the
+    OCaml compiler on a 32 bits (resp. 64 bits) platform.  It may
+    differ for other compilers, e.g. it is 32 bits when compiling to
+    JavaScript.
+    @since 4.03.0 *)
+
+val big_endian : bool
+(** Whether the machine currently executing the Caml program is big-endian.
+    @since 4.00.0 *)
+
+val max_string_length : int
+(** Maximum length of strings and byte sequences. *)
+
+val max_array_length : int
+(** Maximum length of a normal array.  The maximum length of a float
+    array is [max_array_length/2] on 32-bit machines and
+    [max_array_length] on 64-bit machines. *)
+
+external runtime_variant : unit -> string = "?runtime_variant"
+(** Return the name of the runtime variant the program is running on.
+    This is normally the argument given to [-runtime-variant] at compile
+    time, but for byte-code it can be changed after compilation.
+    @since 4.03.0 *)
+
+external runtime_parameters : unit -> string = "?runtime_parameters"
+(** Return the value of the runtime parameters, in the same format
+    as the contents of the [OCAMLRUNPARAM] environment variable.
+    @since 4.03.0 *)
+
+
+(** {1 Signal handling} *)
+
+
+type signal_behavior =
+    Signal_default
+  | Signal_ignore
+  | Signal_handle of (int -> unit)   (** *)
+(** What to do when receiving a signal:
+   - [Signal_default]: take the default behavior
+     (usually: abort the program)
+   - [Signal_ignore]: ignore the signal
+   - [Signal_handle f]: call function [f], giving it the signal
+   number as argument. *)
+
+val signal :
+  int -> signal_behavior -> signal_behavior 
+(** Set the behavior of the system on receipt of a given signal.  The
+   first argument is the signal number.  Return the behavior
+   previously associated with the signal. If the signal number is
+   invalid (or not available on your system), an [Invalid_argument]
+   exception is raised. *)
+
+val set_signal : int -> signal_behavior -> unit
+(** Same as {!Sys.signal} but return value is ignored. *)
+
+
+(** {2 Signal numbers for the standard POSIX signals.} *)
+
+val sigabrt : int
+(** Abnormal termination *)
+
+val sigalrm : int
+(** Timeout *)
+
+val sigfpe : int
+(** Arithmetic exception *)
+
+val sighup : int
+(** Hangup on controlling terminal *)
+
+val sigill : int
+(** Invalid hardware instruction *)
+
+val sigint : int
+(** Interactive interrupt (ctrl-C) *)
+
+val sigkill : int
+(** Termination (cannot be ignored) *)
+
+val sigpipe : int
+(** Broken pipe *)
+
+val sigquit : int
+(** Interactive termination *)
+
+val sigsegv : int
+(** Invalid memory reference *)
+
+val sigterm : int
+(** Termination *)
+
+val sigusr1 : int
+(** Application-defined signal 1 *)
+
+val sigusr2 : int
+(** Application-defined signal 2 *)
+
+val sigchld : int
+(** Child process terminated *)
+
+val sigcont : int
+(** Continue *)
+
+val sigstop : int
+(** Stop *)
+
+val sigtstp : int
+(** Interactive stop *)
+
+val sigttin : int
+(** Terminal read from background process *)
+
+val sigttou : int
+(** Terminal write from background process *)
+
+val sigvtalrm : int
+(** Timeout in virtual time *)
+
+val sigprof : int
+(** Profiling interrupt *)
+
+val sigbus : int
+(** Bus error
+    @since 4.03 *)
+
+val sigpoll : int
+(** Pollable event
+    @since 4.03 *)
+
+val sigsys : int
+(** Bad argument to routine
+    @since 4.03 *)
+
+val sigtrap : int
+(** Trace/breakpoint trap
+    @since 4.03 *)
+
+val sigurg : int
+(** Urgent condition on socket
+    @since 4.03 *)
+
+val sigxcpu : int
+(** Timeout in cpu time
+    @since 4.03 *)
+
+val sigxfsz : int
+(** File size limit exceeded
+    @since 4.03 *)
+
+
+exception Break
+(** Exception raised on interactive interrupt if {!Sys.catch_break}
+   is on. *)
+
+
+val catch_break : bool -> unit
+(** [catch_break] governs whether interactive interrupt (ctrl-C)
+   terminates the program or raises the [Break] exception.
+   Call [catch_break true] to enable raising [Break],
+   and [catch_break false] to let the system
+   terminate the program on user interrupt. *)
+
+
+val ocaml_version : string
+(** [ocaml_version] is the version of OCaml.
+    It is a string of the form ["major.minor[.patchlevel][+additional-info]"],
+    where [major], [minor], and [patchlevel] are integers, and
+    [additional-info] is an arbitrary string. The [[.patchlevel]] and
+    [[+additional-info]] parts may be absent. *)
+
+
+val enable_runtime_warnings: bool -> unit
+(** Control whether the OCaml runtime system can emit warnings
+    on stderr.  Currently, the only supported warning is triggered
+    when a channel created by [open_*] functions is finalized without
+    being closed.  Runtime warnings are enabled by default.
+
+    @since 4.03.0 *)
+
+val runtime_warnings_enabled: unit -> bool
+(** Return whether runtime warnings are currently enabled.
+
+    @since 4.03.0 *)
+
+(** {1 Optimization} *)
+
+external opaque_identity : 'a -> 'a = "%opaque"
+(** For the purposes of optimization, [opaque_identity] behaves like an
+    unknown (and thus possibly side-effecting) function.
+
+    At runtime, [opaque_identity] disappears altogether.
+
+    A typical use of this function is to prevent pure computations from being
+    optimized away in benchmarking loops.  For example:
+    {[
+      for _round = 1 to 100_000 do
+        ignore (Sys.opaque_identity (my_pure_computation ()))
+      done
+    ]}
+
+    @since 4.03.0
+*)

package/lib/ocaml/uchar.ml

@@ -0,0 +1,58 @@
+(**************************************************************************)
+(*                                                                        *)
+(*                                 OCaml                                  *)
+(*                                                                        *)
+(*                           Daniel C. Buenzli                            *)
+(*                                                                        *)
+(*   Copyright 2014 Institut National de Recherche en Informatique et     *)
+(*     en Automatique.                                                    *)
+(*                                                                        *)
+(*   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.          *)
+(*                                                                        *)
+(**************************************************************************)
+
+external format_int : string -> int -> string = "?format_int"
+
+let err_no_pred = "U+0000 has no predecessor"
+let err_no_succ = "U+10FFFF has no successor"
+let err_not_sv i = format_int "%X" i ^ " is not an Unicode scalar value"
+let err_not_latin1 u = "U+" ^ format_int "%04X" u ^ " is not a latin1 character"
+
+type t = int
+
+let min = 0x0000
+let max = 0x10FFFF
+let lo_bound = 0xD7FF
+let hi_bound = 0xE000
+
+let bom = 0xFEFF
+let rep = 0xFFFD
+
+let succ u =
+  if u = lo_bound then hi_bound else
+  if u = max then invalid_arg err_no_succ else
+  u + 1
+
+let pred u =
+  if u = hi_bound then lo_bound else
+  if u = min then invalid_arg err_no_pred else
+  u - 1
+
+let is_valid i = (min <= i && i <= lo_bound) || (hi_bound <= i && i <= max)
+let of_int i = if is_valid i then i else invalid_arg (err_not_sv i)
+external unsafe_of_int : int -> t = "%identity"
+external to_int : t -> int = "%identity"
+
+let is_char u = u < 256
+let of_char c = Char.code c
+let to_char u =
+  if u > 255 then invalid_arg (err_not_latin1 u) else
+  Char.unsafe_chr u
+
+let unsafe_to_char = Char.unsafe_chr
+
+let equal : int -> int -> bool = ( = )
+let compare : int -> int -> int = Pervasives.compare
+let hash = to_int

package/lib/ocaml/uchar.mli

@@ -0,0 +1,98 @@
+(**************************************************************************)
+(*                                                                        *)
+(*                                 OCaml                                  *)
+(*                                                                        *)
+(*                           Daniel C. Buenzli                            *)
+(*                                                                        *)
+(*   Copyright 2014 Institut National de Recherche en Informatique et     *)
+(*     en Automatique.                                                    *)
+(*                                                                        *)
+(*   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.          *)
+(*                                                                        *)
+(**************************************************************************)
+
+(** Unicode characters.
+
+    @since 4.03 *)
+
+type t
+(** The type for Unicode characters.
+
+    A value of this type represents an Unicode
+    {{:http://unicode.org/glossary/#unicode_scalar_value}scalar
+    value} which is an integer in the ranges [0x0000]...[0xD7FF] or
+    [0xE000]...[0x10FFFF]. *)
+
+val min : t
+(** [min] is U+0000. *)
+
+val max : t
+(** [max] is U+10FFFF. *)
+
+val bom : t
+(** [bom] is U+FEFF, the
+    {{:http://unicode.org/glossary/#byte_order_mark}byte order mark} (BOM)
+    character.
+
+    @since 4.06.0 *)
+
+val rep : t
+(** [rep] is U+FFFD, the
+    {{:http://unicode.org/glossary/#replacement_character}replacement}
+    character.
+
+    @since 4.06.0 *)
+
+val succ : t -> t
+(** [succ u] is the scalar value after [u] in the set of Unicode scalar
+    values.
+
+    @raise Invalid_argument if [u] is {!max}. *)
+
+val pred : t -> t
+(** [pred u] is the scalar value before [u] in the set of Unicode scalar
+    values.
+
+    @raise Invalid_argument if [u] is {!min}. *)
+
+val is_valid : int -> bool
+(** [is_valid n] is [true] iff [n] is an Unicode scalar value
+    (i.e. in the ranges [0x0000]...[0xD7FF] or [0xE000]...[0x10FFFF]).*)
+
+val of_int : int -> t
+(** [of_int i] is [i] as an Unicode character.
+
+    @raise Invalid_argument if [i] does not satisfy {!is_valid}. *)
+
+(**/**)
+val unsafe_of_int : int -> t
+(**/**)
+
+val to_int : t -> int
+(** [to_int u] is [u] as an integer. *)
+
+val is_char : t -> bool
+(** [is_char u] is [true] iff [u] is a latin1 OCaml character. *)
+
+val of_char : char -> t
+(** [of_char c] is [c] as an Unicode character. *)
+
+val to_char : t -> char
+(** [to_char u] is [u] as an OCaml latin1 character.
+
+    @raise Invalid_argument if [u] does not satisfy {!is_char}. *)
+
+(**/**)
+val unsafe_to_char : t -> char
+(**/**)
+
+val equal : t -> t -> bool
+(** [equal u u'] is [u = u']. *)
+
+val compare : t -> t -> int
+(** [compare u u'] is [Pervasives.compare u u']. *)
+
+val hash : t -> int
+(** [hash u] associates a non-negative integer to [u]. *)