system                 package:base                 R Documentation

_I_n_v_o_k_e _a _S_y_s_t_e_m _C_o_m_m_a_n_d

_D_e_s_c_r_i_p_t_i_o_n:

     'system' invokes the OS command specified by 'command'.

_U_s_a_g_e:

     system(command, intern = FALSE, ignore.stderr = FALSE,
            wait = TRUE, input = NULL, show.output.on.console = TRUE,
            minimized = FALSE, invisible = TRUE)

_A_r_g_u_m_e_n_t_s:

 command: the system command to be invoked, as a string.

  intern: a logical (not 'NA') which indicates whether to make the
          output of the command an R object. Not available unless
          'popen' is supported on the platform. 

ignore.stderr: a logical indicating whether error messages written to
          'stderr' should be ignored.

    wait: a logical indicating whether the R interpreter should wait
          for the command to finish, or run it asynchronously. This
          will be ignored (and the interpreter will always wait) if
          'intern = TRUE'.

   input: if a character vector is supplied, this is copied one string
          per line to a temporary file, and the standard input of
          'command' is redirected to the file.

show.output.on.console, minimized, invisible: arguments that are
          accepted on other platforms but ignored on this one, with a
          warning.

_D_e_t_a_i_l_s:

     'command' is parsed as a command plus arguments separated by
     spaces. So if the path to the command (or a filepath argument)
     contains spaces, it must be quoted e.g. by 'shQuote'.

     How the command is run differs by platform: Unix-alikes use a
     shell ('/bin/sh' by default), and Windows executes the command
     directly (extensions '.exe', '.com') or as a batch file
     (extensions '.cmd' and '.bat').

     If 'intern' is 'TRUE' then 'popen' is used to invoke the command
     and the output collected, line by line, into an R 'character'
     vector.  If 'intern' is 'FALSE' then the C function 'system' is
     used to invoke the command.

     The ordering of arguments after the first two has changed from
     time to time: it is recommended to name all arguments after the
     first.

_V_a_l_u_e:

     If 'intern = TRUE', a character vector giving the output of the
     command, one line per character string.  (Output lines of more
     than 8095 characters will be split.)  If the command could not be
     run or gives an error this will be reported on the shell's
     'stderr' (unless 'popen' is not supported, when there is an R
     error).

     If 'intern = FALSE', the return value is an error code ('0' for
     success), given the invisible attribute (so needs to be printed
     explicitly).  If the command could not be run for any reason, the
     value is '256*127 = 52512'. Otherwise if 'wait = TRUE' the value
     is 256 times the error code returned by the command, and if 'wait
     = FALSE' it is '0' (the conventional success value).

_S_t_d_o_u_t _a_n_d _s_t_d_e_r_r:

     Error messages written to 'stderr' will be sent by the shell to
     the terminal unless 'ignore.stderr = TRUE'.  They can be captured
     (in the most likely shells) by


         system("some command 2>&1", intern=TRUE)

     What happens to output sent to 'stdout' and 'stderr' if 'intern =
     FALSE' is interface-specific, and it is unsafe to assume that such
     messages will appear on a console (they do on the Mac OS X
     console, but not on some others).

_N_o_t_e:

     'wait' is implemented by appending '&' to the command: this is
     shell-dependent, but required by POSIX and so widely supported.

_S_e_e _A_l_s_o:

     '.Platform' for platform-specific variables.

_E_x_a_m_p_l_e_s:

     # list all files in the current directory using the -F flag
     ## Not run: system("ls -F")

     # t1 is a character vector, each one
     # representing a separate line of output from who
     # (if the platform has popen and who)
     t1 <- try(system("who", intern = TRUE))

     try(system("ls fizzlipuzzli", intern = TRUE, ignore.stderr = TRUE))
     # empty since file doesn't exist

