NAME

       Sys - System interface.

Module

       Module   Sys

Documentation

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

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