# Module Sys

    module Sys: sig .. end

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.

    val file_exists : string -> bool

Test if a file with the given name exists.

    val is_directory : string -> bool

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

    val remove : string -> unit

Remove the given file name from the file system.

    val rename : string -> string -> unit

Rename a file. The first argument is the old name and the second is the new name. If there is already another file under the new name, `rename` may replace it, or raise an exception, depending on your operating system.

    val getenv : string -> string

Return the value associated to a variable in the process environment. Raise `Not_found` if the variable is unbound.

    val command : string -> int

Execute the given shell command and return its exit code.

    val time : unit -> float

Return the processor time, in seconds, used by the program since the beginning of execution.

    val chdir : string -> unit

Change the current working directory of the process.

    val getcwd : unit -> string

Return the current working directory of the process.

    val readdir : string -> string array

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.

    val runtime_variant : unit -> string

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

    val runtime_parameters : unit -> string

Return the value of the runtime parameters, in the same format as the contents of the `OCAMLRUNPARAM` environment variable.
Since 4.03.0

###### 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.
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

###### Optimization

    val opaque_identity : 'a -> 'a

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