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 system command specified by `command'.

_U_s_a_g_e:

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

_A_r_g_u_m_e_n_t_s:

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

  intern: a logical, indicates whether to make the output of the
          command an R object.

    wait: should the R interpreter wait for the command to finish? The
          default is to wait, 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: a logical, indicates whether to capture  the
          output of the command and show it on the R console (not used
          by `Rterm', which captures the output unless `wait' is
          false).

invisible: a logical, indicates whether the command window should be
          visible on the screen.

minimized: a logical, indicates whether the command window should be
          initially displayed as iconic.

_D_e_t_a_i_l_s:

     The command is run directly as a Windows command by the Windows
     API call `CreateProcess': extensions of `.exe', `.com', `.cmd' and
     `.bat' are tried in turn if none is supplied. (To use DOS internal
     commands use `command.com /c cmd'.) The search path for `command'
     may be system-dependent: it will include the R `bin' directory,
     the working directory and the Windows system directories before
     `PATH'.

     Precisely what is seen by the user depends on whether `Rgui' or
     `Rterm' is being used.  For `Rgui' a new console will always be
     used, so a commands window will appear for the duration of console
     applications unless `invisible' is true. For `Rterm' a separate
     commands window will appear for console applications only if
     `wait=FALSE'.

     `unix' is a deprecated alternative, available for backwards
     compatibility.

_V_a_l_u_e:

     If `intern=TRUE', a character vector giving the output of the
     command, one line per character string. If the command could not
     be run or gives an error a R error is generated.

     If `intern=FALSE', the return value is a error code, given the
     invisible attribute (so needs to be printed explicitly). If the
     command could not be run for any reason, the value is `-1' and an
     R warning is generated. Otherwise if `wait=FALSE' the value is the
     error code returned by the command, and if `wait=TRUE' it is the
     zero (the conventional success value),

     If `intern=FALSE' and `show.output.on.console=TRUE'  the text
     output from a command that is a console application will  appear
     in the R console (`Rgui') or the window running R  (`Rterm').

_W_A_R_N_I_N_G:

     The command cannot be interrupted by the R process.

     Do not run console applications that require user input from
     `Rgui' setting `intern=TRUE' and/or `show.output.on.console=TRUE'.
     They will not work, may hang and then will probably hang `Rgui'
     too.

_A_u_t_h_o_r(_s):

     Guido Masarotto and Brian Ripley

_S_e_e _A_l_s_o:

     `shell' for a less raw interface.

_E_x_a_m_p_l_e_s:

     # launch an editor, wait for it to quit
     system("notepad myfile.txt")
     # launch a Windows 9x process monitor (from Win9x KernelToys)
     system("wintop", wait=FALSE)
     # launch your favourite (!) shell: 
     system("command.com")

