19.31 | Module `Sys`: 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 file_exists: string -> bool

> Test if a file with the given name exists.

    val remove: string -> unit

> Remove the given file name from the file system.

    val rename : src:string -> dst:string -> unit

> Rename a file. The first argument is the old name and the second is the new name.

    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 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 Caml program. One of `"Unix"`, `"Win32"`, `"Cygwin"` or `"MacOS"`.

    val word_size: int

> Size of one word on the machine currently executing the Caml program, in bits: 32 or 64.

    val max_string_length: int

> Maximum length of a string.

    val max_array_length: int

> Maximum length of an array.

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.

    val set_signal: int -> signal_behavior -> unit

> Same as `signal` but return value is ignored.

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

> Signal numbers for the standard POSIX signals.

    exception Break

> Exception raised on interactive interrupt if `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.