1Stdlib.Sys(3) OCaml library Stdlib.Sys(3)
2
3
4
6 Stdlib.Sys - no description
7
9 Module Stdlib.Sys
10
12 Module Sys
13 : (module Stdlib__Sys)
14
15
16
17
18
19
20
21
22 val argv : string array
23
24 The command line arguments given to the process. The first element is
25 the command name used to invoke the program. The following elements
26 are the command-line arguments given to the program.
27
28
29
30 val executable_name : string
31
32 The name of the file containing the executable currently running. This
33 name may be absolute or relative to the current directory, depending on
34 the platform and whether the program was compiled to bytecode or a na‐
35 tive executable.
36
37
38
39 val file_exists : string -> bool
40
41 Test if a file with the given name exists.
42
43
44
45 val is_directory : string -> bool
46
47 Returns true if the given name refers to a directory, false if it
48 refers to another kind of file.
49
50
51 Since 3.10.0
52
53
54 Raises Sys_error if no file exists with the given name.
55
56
57
58 val remove : string -> unit
59
60 Remove the given file name from the file system.
61
62
63
64 val rename : string -> string -> unit
65
66 Rename a file. rename oldpath newpath renames the file called oldpath
67 , giving it newpath as its new name, moving it between directories if
68 needed. If newpath already exists, its contents will be replaced with
69 those of oldpath . Depending on the operating system, the metadata
70 (permissions, owner, etc) of newpath can either be preserved or be re‐
71 placed by those of oldpath .
72
73
74 Since 4.06 concerning the "replace existing file" behavior
75
76
77
78 val getenv : string -> string
79
80 Return the value associated to a variable in the process environment.
81
82
83 Raises Not_found if the variable is unbound.
84
85
86
87 val getenv_opt : string -> string option
88
89 Return the value associated to a variable in the process environment or
90 None if the variable is unbound.
91
92
93 Since 4.05
94
95
96
97 val command : string -> int
98
99 Execute the given shell command and return its exit code.
100
101 The argument of Sys.command is generally the name of a command followed
102 by zero, one or several arguments, separated by whitespace. The given
103 argument is interpreted by a shell: either the Windows shell cmd.exe
104 for the Win32 ports of OCaml, or the POSIX shell sh for other ports.
105 It can contain shell builtin commands such as echo , and also special
106 characters such as file redirections > and < , which will be honored by
107 the shell.
108
109 Conversely, whitespace or special shell characters occurring in command
110 names or in their arguments must be quoted or escaped so that the shell
111 does not interpret them. The quoting rules vary between the POSIX
112 shell and the Windows shell. The Filename.quote_command performs the
113 appropriate quoting given a command name, a list of arguments, and op‐
114 tional file redirections.
115
116
117
118 val time : unit -> float
119
120 Return the processor time, in seconds, used by the program since the
121 beginning of execution.
122
123
124
125 val chdir : string -> unit
126
127 Change the current working directory of the process.
128
129
130
131 val mkdir : string -> int -> unit
132
133 Create a directory with the given permissions.
134
135
136 Since 4.12.0
137
138
139
140 val rmdir : string -> unit
141
142 Remove an empty directory.
143
144
145 Since 4.12.0
146
147
148
149 val getcwd : unit -> string
150
151 Return the current working directory of the process.
152
153
154
155 val readdir : string -> string array
156
157 Return the names of all files present in the given directory. Names
158 denoting the current directory and the parent directory ( "." and ".."
159 in Unix) are not returned. Each string in the result is a file name
160 rather than a complete path. There is no guarantee that the name
161 strings in the resulting array will appear in any specific order; they
162 are not, in particular, guaranteed to appear in alphabetical order.
163
164
165
166 val interactive : bool ref
167
168 This reference is initially set to false in standalone programs and to
169 true if the code is being executed under the interactive toplevel sys‐
170 tem ocaml .
171
172
173
174 val os_type : string
175
176 Operating system currently executing the OCaml program. One of
177
178 - "Unix" (for all Unix versions, including Linux and Mac OS X),
179
180 - "Win32" (for MS-Windows, OCaml compiled with MSVC++ or Mingw),
181
182 - "Cygwin" (for MS-Windows, OCaml compiled with Cygwin).
183
184
185
186 type backend_type =
187 | Native
188 | Bytecode
189 | Other of string
190
191
192 Currently, the official distribution only supports Native and Bytecode
193 , but it can be other backends with alternative compilers, for example,
194 javascript.
195
196
197 Since 4.04.0
198
199
200
201 val backend_type : backend_type
202
203 Backend type currently executing the OCaml program.
204
205
206 Since 4.04.0
207
208
209
210 val unix : bool
211
212 True if Sys.os_type = "Unix" .
213
214
215 Since 4.01.0
216
217
218
219 val win32 : bool
220
221 True if Sys.os_type = "Win32" .
222
223
224 Since 4.01.0
225
226
227
228 val cygwin : bool
229
230 True if Sys.os_type = "Cygwin" .
231
232
233 Since 4.01.0
234
235
236
237 val word_size : int
238
239 Size of one word on the machine currently executing the OCaml program,
240 in bits: 32 or 64.
241
242
243
244 val int_size : int
245
246 Size of int , in bits. It is 31 (resp. 63) when using OCaml on a 32-bit
247 (resp. 64-bit) platform. It may differ for other implementations, e.g.
248 it can be 32 bits when compiling to JavaScript.
249
250
251 Since 4.03.0
252
253
254
255 val big_endian : bool
256
257 Whether the machine currently executing the Caml program is big-endian.
258
259
260 Since 4.00.0
261
262
263
264 val max_string_length : int
265
266 Maximum length of strings and byte sequences.
267
268
269
270 val max_array_length : int
271
272 Maximum length of a normal array (i.e. any array whose elements are not
273 of type float ). The maximum length of a float array is max_floatar‐
274 ray_length if OCaml was configured with --enable-flat-float-array and
275 max_array_length if configured with --disable-flat-float-array .
276
277
278
279 val max_floatarray_length : int
280
281 Maximum length of a floatarray. This is also the maximum length of a
282 float array when OCaml is configured with --enable-flat-float-array .
283
284
285
286 val runtime_variant : unit -> string
287
288 Return the name of the runtime variant the program is running on. This
289 is normally the argument given to -runtime-variant at compile time, but
290 for byte-code it can be changed after compilation.
291
292
293 Since 4.03.0
294
295
296
297 val runtime_parameters : unit -> string
298
299 Return the value of the runtime parameters, in the same format as the
300 contents of the OCAMLRUNPARAM environment variable.
301
302
303 Since 4.03.0
304
305
306
307
308 Signal handling
309 type signal_behavior =
310 | Signal_default
311 | Signal_ignore
312 | Signal_handle of (int -> unit)
313
314
315 What to do when receiving a signal:
316
317 - Signal_default : take the default behavior (usually: abort the pro‐
318 gram)
319
320 - Signal_ignore : ignore the signal
321
322 - Signal_handle f : call function f , giving it the signal number as
323 argument.
324
325
326
327
328 val signal : int -> signal_behavior -> signal_behavior
329
330 Set the behavior of the system on receipt of a given signal. The first
331 argument is the signal number. Return the behavior previously associ‐
332 ated with the signal. If the signal number is invalid (or not available
333 on your system), an Invalid_argument exception is raised.
334
335
336
337 val set_signal : int -> signal_behavior -> unit
338
339 Same as Sys.signal but return value is ignored.
340
341
342
343
344 Signal numbers for the standard POSIX signals.
345 val sigabrt : int
346
347 Abnormal termination
348
349
350
351 val sigalrm : int
352
353 Timeout
354
355
356
357 val sigfpe : int
358
359 Arithmetic exception
360
361
362
363 val sighup : int
364
365 Hangup on controlling terminal
366
367
368
369 val sigill : int
370
371 Invalid hardware instruction
372
373
374
375 val sigint : int
376
377 Interactive interrupt (ctrl-C)
378
379
380
381 val sigkill : int
382
383 Termination (cannot be ignored)
384
385
386
387 val sigpipe : int
388
389 Broken pipe
390
391
392
393 val sigquit : int
394
395 Interactive termination
396
397
398
399 val sigsegv : int
400
401 Invalid memory reference
402
403
404
405 val sigterm : int
406
407 Termination
408
409
410
411 val sigusr1 : int
412
413 Application-defined signal 1
414
415
416
417 val sigusr2 : int
418
419 Application-defined signal 2
420
421
422
423 val sigchld : int
424
425 Child process terminated
426
427
428
429 val sigcont : int
430
431 Continue
432
433
434
435 val sigstop : int
436
437 Stop
438
439
440
441 val sigtstp : int
442
443 Interactive stop
444
445
446
447 val sigttin : int
448
449 Terminal read from background process
450
451
452
453 val sigttou : int
454
455 Terminal write from background process
456
457
458
459 val sigvtalrm : int
460
461 Timeout in virtual time
462
463
464
465 val sigprof : int
466
467 Profiling interrupt
468
469
470
471 val sigbus : int
472
473 Bus error
474
475
476 Since 4.03
477
478
479
480 val sigpoll : int
481
482 Pollable event
483
484
485 Since 4.03
486
487
488
489 val sigsys : int
490
491 Bad argument to routine
492
493
494 Since 4.03
495
496
497
498 val sigtrap : int
499
500 Trace/breakpoint trap
501
502
503 Since 4.03
504
505
506
507 val sigurg : int
508
509 Urgent condition on socket
510
511
512 Since 4.03
513
514
515
516 val sigxcpu : int
517
518 Timeout in cpu time
519
520
521 Since 4.03
522
523
524
525 val sigxfsz : int
526
527 File size limit exceeded
528
529
530 Since 4.03
531
532
533
534 exception Break
535
536
537 Exception raised on interactive interrupt if Sys.catch_break is on.
538
539
540
541 val catch_break : bool -> unit
542
543
544 catch_break governs whether interactive interrupt (ctrl-C) terminates
545 the program or raises the Break exception. Call catch_break true to
546 enable raising Break , and catch_break false to let the system termi‐
547 nate the program on user interrupt.
548
549
550
551 val ocaml_version : string
552
553
554 ocaml_version is the version of OCaml. It is a string of the form "ma‐
555 jor.minor[.patchlevel][(+|~)additional-info]" , where major , minor ,
556 and patchlevel are integers, and additional-info is an arbitrary
557 string. The [.patchlevel] part is absent for versions anterior to
558 3.08.0. The [(+|~)additional-info] part may be absent.
559
560
561
562 val enable_runtime_warnings : bool -> unit
563
564 Control whether the OCaml runtime system can emit warnings on stderr.
565 Currently, the only supported warning is triggered when a channel cre‐
566 ated by open_* functions is finalized without being closed. Runtime
567 warnings are disabled by default.
568
569
570 Since 4.03.0
571
572
573
574 val runtime_warnings_enabled : unit -> bool
575
576 Return whether runtime warnings are currently enabled.
577
578
579 Since 4.03.0
580
581
582
583
584 Optimization
585 val opaque_identity : 'a -> 'a
586
587 For the purposes of optimization, opaque_identity behaves like an un‐
588 known (and thus possibly side-effecting) function.
589
590 At runtime, opaque_identity disappears altogether.
591
592 A typical use of this function is to prevent pure computations from be‐
593 ing optimized away in benchmarking loops. For example:
594 for _round = 1 to 100_000 do
595 ignore (Sys.opaque_identity (my_pure_computation ()))
596 done
597
598
599
600 Since 4.03.0
601
602
603 module Immediate64 : sig end
604
605
606
607
608
609
610
611OCamldoc 2022-02-04 Stdlib.Sys(3)