Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
Sys(3)				   OCamldoc				Sys(3)

       Sys - System interface.

       Module	Sys

       Module Sys
	: sig end

       System interface.

       Every function in this module raises Sys_error with an informative mes-
       sage 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 sys-

       val getenv : string -> string

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

       val getenv_opt :	string -> string option

       Return the value	associated to a	variable in the	process	environment or
       None if the variable is unbound.

       Since 4.05

       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  sys-
       tem 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,

       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

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

       - Signal_ignore : ignore	the signal

       - Signal_handle f : call	function f , giving it the  signal  number  as

       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  associ-
       ated 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


       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


       val sigusr1 : int

       Application-defined signal 1

       val sigusr2 : int

       Application-defined signal 2

       val sigchld : int

       Child process terminated

       val sigcont : int


       val sigstop : int


       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	termi-
       nate the	program	on user	interrupt.

       val ocaml_version : string

       ocaml_version  is the version of	OCaml.	It is a	string of the form ma-
       jor.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 cre-
       ated 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 un-
       known (and thus possibly	side-effecting)	function.

       At runtime, opaque_identity disappears altogether.

       A typical use of	this function is to prevent pure computations from be-
       ing  optimized away in benchmarking loops.  For example:	for _round = 1
       to 100_000 do  ignore  (Sys.opaque_identity  (my_pure_computation  ()))

       Since 4.03.0

2020-08-11			    source:				Sys(3)

NAME | Module | Documentation

Want to link to this manual page? Use this URL:

home | help