Invoke a System Command
system invokes the OS command specified by
system(command, intern = FALSE, ignore.stdout = FALSE, ignore.stderr = FALSE, wait = TRUE, input = NULL, show.output.on.console = TRUE, minimized = FALSE, invisible = TRUE)
- the system command to be invoked, as a character string.
- a logical (not
NA) which indicates whether to capture the output of the command as an Rcharacter vector.
- ignore.stdout, ignore.stderr
- a logical (not
NA) indicating whether messages written to
stdoutor stderrshould be ignored.
- a logical (not
NA) indicating whether the Rinterpreter should wait for the command to finish, or run it asynchronously. This will be ignored (and the interpreter will always wait) if
intern = TRUE.
- if a character vector is supplied, this is copied one
string per line to a temporary file, and the standard input of
commandis redirected to the file.
- show.output.on.console, minimized, invisible
- arguments that are accepted on Windows but ignored on this platform, with a warning.
- logical (not
NA), indicates whether to capture the output of the command and show it on the Rconsole (not used by
Rterm, which shows the output in the terminal unless
- logical (not
NA), indicates whether a command window should be displayed initially as a minimized window.
- logical (not
NA), indicates whether a command window should be visible on the screen.
This interface has become rather complicated over the years: see
system2 for a more portable and flexible interface
which is recommended for new code.
command is parsed as a command plus arguments separated by
spaces. So if the path to the command (or a single argument such as a
file path) contains spaces, it must be quoted e.g.
Only double quotes are allowed on Windows: see the examples. (Note: a
Windows path name cannot contain a double quote, so we do not need to
worry about escaping embedded quotes.)
command must be an executable (extensions
shell if you want to pass a shell command-line.
The search path for
command may be system-dependent: it will
include the R
command can be anything the
shell regards as executable, including shell scripts, and it can
contain multiple commands separated by
system does not use a shell and there is a separate
shell which passes command lines to a shell.
popen is used to invoke the
command and the output collected, line by line, into an R
character vector. If
the C function
system is used to invoke the command.
wait is implemented by appending
& to the command: this
is in principle shell-dependent, but required by POSIX and so widely
The ordering of arguments after the first two has changed from time to time: it is recommended to name all arguments after the first.
There are many pitfalls in using
system to ascertain if a
command can be run ---
Sys.which is more suitable.
intern = TRUE, a character vector giving the output of the command, one line per character string. (Output lines of more than 8095 bytes will be split.) If the command could not be run an Rerror is generated. #ifdef windows Under the
intern = TRUEalso captures
ignore.stderr = TRUE. #endif If
commandruns but gives a non-zero exit status this will be reported with a warning and in the attribute
"status"of the result: an attribute
"errmsg"may also be available
intern = FALSE, the return value is an error code (
0for success), given the invisible attribute (so needs to be printed explicitly). If the command could not be run for any reason, the value is
127. Otherwise if
wait = TRUEthe value is the exit status returned by the command, and if
wait = FALSEit is
0(the conventional success value). #ifdef windows Some Windows commands return out-of-range status values (e.g.,
-1) and so only the bottom 16 bits of the value are used.
intern = FALSE, wait = TRUE, show.output.on.console = TRUEthe
ignore.stdout = TRUEor
ignore.stderr = TRUE) output from a command that is a
console applicationshould appear in the Rconsole (
Rgui) or the window running R(
Not all Windows executables properly respect redirection of output, or may only do so from a console application such as
Rtermand not from
Rgui: for example,
fc.exewas among these in the past, but we have had more success recently. #endif
Stdout and stderr
For command-line R, error messages written to
ignore.stderr = TRUE. They can be
captured (in the most likely shells) by
system("some command 2>&1", intern = TRUE)
For GUIs, what happens to output sent to
intern = FALSE is interface-specific, and it
is unsafe to assume that such messages will appear on a GUI console
(they do on the OS X GUI's console, but not on some others).
Interaction with the command
Precisely what is seen by the user depends on the optional parameters,
Rterm is being used, and whether a
console command or GUI application is run by the command.
By default nothing will be seen in either front-end until the command finishes and the output is displayed.
For console commands
Rgui will open a new
invisible = FALSE, a commands window will appear for the
duration of the command. For
Rterm a separate commands window
will appear for console applications only if
wait = FALSE and
invisible = FALSE.
GUI applications will not display in either front-end unless
invisible is false.
It is possible to interrupt a running command being waited for from
the keyboard (using the Esc key in
Rgui or Ctrl-C
Rterm) or from the
Rgui menu: this should at least
return control to the Rconsole. Rwill attempt to shut down the
process cleanly, but may need to force it to terminate, with the
possibility of losing unsaved work, etc.
Do not try to run console applications that require user
intern = TRUE or
show.output.on.console = TRUE. They will not work.
Differences between Unix and Windows
How processes are launched differs fundamentally between Windows and
Unix-alike operating systems, as do the higher-level OS functions on
which this Rfunction is built. So it should not be surprising that
there are many differences between OSes in how
For the benefit of programmers, the more important ones are summarized
in this section.
- The most important difference is that on a Unix-alike
systemlaunches a shell which then runs
command. On Windows the command is run directly -- use
shellfor an interface which runs
commandviaa shell (by default the Windows shell
cmd.exe, which has many differences from a POSIX shell).
This means that it cannot be assumed that redirection or piping will
system(redirection sometimes does, but we have seen
cases where it stopped working after a Windows security patch), and
shell) must be used on Windows.
stderrwhen not captured depends on howRis running: Windows batch commands behave like a Unix-alike, but from the Windows GUI they are generally lost.
system(intern = TRUE)captures
ignore.stderr = TRUE.
shQuoteis a portable interface.
invisibleonly do something on Windows (and are most relevant to
shell.exec for a less raw
.Platform for platform-specific variables.
pipe to set up a pipe connection.
# launch an editor, wait for it to quit system("notepad myfile.txt") # launch your favourite shell: system(Sys.getenv("COMSPEC")) ## note the two sets of quotes here: system(paste('"c:/Program Files/Mozilla Firefox/firefox.exe"', '-url cran.r-project.org'), wait = FALSE)