96 lines
4.4 KiB
OCaml
96 lines
4.4 KiB
OCaml
(***********************************************************************)
|
|
(* *)
|
|
(* Objective Caml *)
|
|
(* *)
|
|
(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
|
|
(* *)
|
|
(* Copyright 1996 Institut National de Recherche en Informatique et *)
|
|
(* Automatique. Distributed only by permission. *)
|
|
(* *)
|
|
(***********************************************************************)
|
|
|
|
(* $Id$ *)
|
|
|
|
(* 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 arguments given to the program. *)
|
|
external file_exists: string -> bool = "sys_file_exists"
|
|
(* Test if a file with the given name exists. *)
|
|
external remove: string -> unit = "sys_remove"
|
|
(* Remove the given file name from the file system. *)
|
|
external rename : string -> string -> unit = "sys_rename"
|
|
(* Rename a file. The first argument is the old name and the
|
|
second is the new name. *)
|
|
external getenv: string -> string = "sys_getenv"
|
|
(* Return the value associated to a variable in the process
|
|
environment. Raise [Not_found] if the variable is unbound. *)
|
|
external command: string -> int = "sys_system_command"
|
|
(* Execute the given shell command and return its exit code. *)
|
|
external chdir: string -> unit = "sys_chdir"
|
|
(* Change the current working directory of the process. *)
|
|
external getcwd: unit -> string = "sys_getcwd"
|
|
(* 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 [csltop]. *)
|
|
val os_type: string
|
|
(* Operating system currently executing the Caml program.
|
|
One of ["Unix"], ["Win32"], or ["MacOS"]. *)
|
|
val word_size: int
|
|
(* Size of one word on the machine currently executing the Caml
|
|
program, in bits: 32 or 64. *)
|
|
|
|
(*** 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
|
|
- [Signal_ignore]: ignore the signal
|
|
- [Signal_handle f]: call function [f], giving it the signal
|
|
number as argument. *)
|
|
|
|
external signal: int -> signal_behavior -> unit = "install_signal_handler"
|
|
(* Set the behavior of the system on receipt of a given signal.
|
|
The first argument is the signal number. *)
|
|
|
|
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. *)
|