NAME

       Sys - System interface.

Module

       Module   Sys

Documentation

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