# Module Sys

    module Sys: sig .. end

System interface.

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

    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 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 a string.

    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.

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

    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.